Subversion Repositories Kolibri OS

;SIZE_Y equ 350

;ROUND equ 8

;TEX_X equ 512

;TEX_Y equ 512

;TEXTURE_SIZE EQU (512*512)-1

;TEX_SHIFT EQU 9

;TEXTURE_SIZE EQU (TEX_X * TEX_Y)-1

;Ext = SSE

;SSE = 3

;MMX = 1

;NON = 0

;use32

;------- Big thanks to Majuma (www.majuma.xt.pl) for absolutely great---

;------- DOS 13h mode demos --------------------------------------------

;------- Procedure draws triangle with two overlapped textures, I use --

;--------Catmull Z-buffer algorithm- (Z coordinate interpolation)-------

;--------I calc texture pixel by this way: col1*col2/256 ---------------

two_tex_triangle_z:

;------------------in - eax - x1 shl 16 + y1 -----------

;---------------------- ebx - x2 shl 16 + y2 -----------

;---------------------- ecx - x3 shl 16 + y3 -----------

;---------------------- edx - pointer to b. texture-----

;---------------------- esi - pointer to e. texture-----

;---------------------- edi - pointer to screen buffer--

;---------------------- stack : b. tex coordinates------

;----------------------         e. tex coordinates------

;----------------------         Z position coordinates--

;----------------------         pointer io Z buffer-----

;-- Z-buffer - filled with coordinates as dword --------

;-- (Z coor. as word) shl CATMULL_SHIFT ----------------

.b_x1   equ ebp+4   ; procedure don't save registers !!!

.b_y1   equ ebp+6   ; each coordinate as word

.b_x2   equ ebp+8

.b_y2   equ ebp+10       ; b - first texture

.b_x3   equ ebp+12

.b_y3   equ ebp+14       ; e - second texture

.e_x1   equ ebp+16

.e_y1   equ ebp+18

.e_x2   equ ebp+20

.e_y2   equ ebp+22

.e_x3   equ ebp+24

.e_y3   equ ebp+26

.z1     equ word[ebp+28]

.z2     equ word[ebp+30]

.z3     equ word[ebp+32]

.z_buff equ dword[ebp+34]       ; pointer to Z-buffer

.t_emap equ dword[ebp-8]        ; pointer to e. texture

.x1     equ word[ebp-10]

.y1     equ word[ebp-12]

.x2     equ word[ebp-14]

.y2     equ word[ebp-16]

.x3     equ word[ebp-18]

.y3     equ word[ebp-20]

.dbx12 equ dword[ebp-28]

.dby12 equ dword[ebp-32]

.dby12q equ     [ebp-32]

.dex12 equ dword[ebp-36]

.dey12 equ dword[ebp-40]

.dey12q equ     [ebp-40]

.dz12  equ dword[ebp-44]

.dbx13 equ dword[ebp-52]

.dby13 equ dword[ebp-56]

.dby13q equ     [ebp-56]

.dex13 equ dword[ebp-60]

.dey13 equ dword[ebp-64]

.dey13q equ     [ebp-64]

.dz13  equ dword[ebp-68]

.dbx23 equ dword[ebp-76]

.dby23 equ dword[ebp-80]

.dby23q equ     [ebp-80]

.dex23 equ dword[ebp-84]

.dey23 equ dword[ebp-88]

.dey23q equ     [ebp-88]

.dz23  equ dword[ebp-92]

.cx2   equ dword[ebp-100]

.cbx1  equ dword[ebp-104]

.cby1  equ [ebp-108]

.cex1  equ dword[ebp-112]

.cey1  equ [ebp-116]

.cbx2  equ dword[ebp-120]

.cby2  equ [ebp-124]

.cex2  equ dword[ebp-128]

.cey2  equ [ebp-132]

.cz2   equ dword[ebp-140]

       emms

    else

       cld

    end if

       mov     ebp,esp

       push    edx esi       ; store bump map

;       push    esi        ; store e. map

     ; sub     esp,120

 .sort3:                  ; sort triangle coordinates...

       cmp     ax,bx

       jle     .sort1

       xchg    eax,ebx

       mov     edx,dword[.b_x1]

       xchg    edx,dword[.b_x2]

       mov     dword[.b_x1],edx

       mov     edx,dword[.e_x1]

       xchg    edx,dword[.e_x2]

       mov     dword[.e_x1],edx

       mov     dx,.z1

       xchg    dx,.z2

       mov     .z1,dx

 .sort1:

       cmp      bx,cx

       jle      .sort2

       xchg     ebx,ecx

       mov      edx,dword[.b_x2]

       xchg     edx,dword[.b_x3]

       mov      dword[.b_x2],edx

       mov      edx,dword[.e_x2]

       xchg     edx,dword[.e_x3]

       mov      dword[.e_x2],edx

       mov     dx,.z2

       xchg    dx,.z3

       mov     .z2,dx

       jmp      .sort3

 .sort2:

       push     eax ebx ecx    ; store triangle coords in variables

;       push     ebx

;       push     ecx

         and      edx,ebx        ; if *all* of them are negative a sign flag is raised

         and      edx,ecx

         and      edx,eax

         test     edx,80008000h  ; Check both X&Y at once

         jne      .loop23_done

    ;   mov     edx,eax         ; eax,ebx,ecx are ORd together into edx which means that

    ;   or      edx,ebx         ; if any *one* of them is negative a sign flag is raised

    ;   or      edx,ecx

    ;   test    edx,80000000h   ; Check only X

    ;   jne     .loop23_done

    ;   jg      .loop23_done

    ;   cmp     .x2,SIZE_X     ; This can be optimized with effort

    ;   jg      .loop23_done

    ;   cmp     .x3,SIZE_X

    ;   jg      .loop23_done    ; {

       sub      bx,.y1

       jnz      .bt_dx12_make

       mov      ecx,6

       xor      edx,edx

     @@:

       push     edx   ;dword 0

       loop     @b

       jmp      .bt_dx12_done

 .bt_dx12_make:

       mov      ax,.x2

       sub      ax,.x1

       cwde

       movsx    ebx,bx

       shl      eax,ROUND

       cdq

       idiv     ebx

;      mov      .dx12,eax

       push      eax

       cvtsi2ss  xmm3,ebx            ;rcps

    ;   mov       eax,255

       cvtsi2ss  xmm4,[i255d] ;eax

       divss     xmm3,xmm4

       rcpss     xmm3,xmm3

    ;   mulss     xmm3,xmm4

       shufps    xmm3,xmm3,0

       movd      mm1,[.b_x2]

       movd      mm2,[.e_x1]

       movd      mm3,[.e_x2]

     ;  psubsw    mm3,mm2

     ;  psubsw    mm1,mm0

       pxor      mm4,mm4

       punpcklwd mm0,mm4

       punpcklwd mm1,mm4

       punpcklwd mm2,mm4

       punpcklwd mm3,mm4

   ;    pslld     mm0,ROUND

   ;    pslld     mm1,ROUND

   ;    pslld     mm2,ROUND

   ;    pslld     mm3,ROUND

       cvtpi2ps  xmm0,mm0

       movlhps   xmm0,xmm0

       cvtpi2ps  xmm0,mm2

       cvtpi2ps  xmm1,mm1

       movlhps   xmm1,xmm1

       cvtpi2ps  xmm1,mm3

       subps     xmm1,xmm0

     ;  movq      mm5,mm1

     ;  movq      mm6,mm1

     ;  pcmpeqb   mm5,mm4

;       psubd     mm1,mm0

;       psubd     mm3,mm2