675 lines
14 KiB
Plaintext
675 lines
14 KiB
Plaintext
;; SONIC ROBO BLAST 2
|
|
;;-----------------------------------------------------------------------------
|
|
;; Copyright (C) 1998-2000 by DOSDOOM.
|
|
;; Copyright (C) 2010-2021 by Sonic Team Junior.
|
|
;;
|
|
;; This program is free software distributed under the
|
|
;; terms of the GNU General Public License, version 2.
|
|
;; See the 'LICENSE' file for more details.
|
|
;;-----------------------------------------------------------------------------
|
|
;; FILE:
|
|
;; tmap_mmx.nas
|
|
;; DESCRIPTION:
|
|
;; Assembler optimised rendering code for software mode, using SIMD
|
|
;; instructions.
|
|
;; Draw wall columns.
|
|
|
|
|
|
[BITS 32]
|
|
|
|
%define FRACBITS 16
|
|
%define TRANSPARENTPIXEL 255
|
|
|
|
%ifdef LINUX
|
|
%macro cextern 1
|
|
[extern %1]
|
|
%endmacro
|
|
|
|
%macro cglobal 1
|
|
[global %1]
|
|
%endmacro
|
|
|
|
%else
|
|
%macro cextern 1
|
|
%define %1 _%1
|
|
[extern %1]
|
|
%endmacro
|
|
|
|
%macro cglobal 1
|
|
%define %1 _%1
|
|
[global %1]
|
|
%endmacro
|
|
|
|
%endif
|
|
|
|
|
|
; The viddef_s structure. We only need the width field.
|
|
struc viddef_s
|
|
resb 12
|
|
.width: resb 4
|
|
resb 44
|
|
endstruc
|
|
|
|
|
|
;; externs
|
|
;; columns
|
|
cextern dc_colormap
|
|
cextern dc_x
|
|
cextern dc_yl
|
|
cextern dc_yh
|
|
cextern dc_iscale
|
|
cextern dc_texturemid
|
|
cextern dc_texheight
|
|
cextern dc_source
|
|
cextern dc_hires
|
|
cextern centery
|
|
cextern centeryfrac
|
|
cextern dc_transmap
|
|
|
|
cextern R_DrawColumn_8_ASM
|
|
cextern R_Draw2sMultiPatchColumn_8_ASM
|
|
|
|
;; spans
|
|
cextern nflatshiftup
|
|
cextern nflatxshift
|
|
cextern nflatyshift
|
|
cextern nflatmask
|
|
cextern ds_xfrac
|
|
cextern ds_yfrac
|
|
cextern ds_xstep
|
|
cextern ds_ystep
|
|
cextern ds_x1
|
|
cextern ds_x2
|
|
cextern ds_y
|
|
cextern ds_source
|
|
cextern ds_colormap
|
|
|
|
cextern ylookup
|
|
cextern columnofs
|
|
cextern vid
|
|
|
|
[SECTION .data]
|
|
|
|
nflatmask64 dq 0
|
|
|
|
|
|
[SECTION .text]
|
|
|
|
;;----------------------------------------------------------------------
|
|
;;
|
|
;; R_DrawColumn : 8bpp column drawer
|
|
;;
|
|
;; MMX column drawer.
|
|
;;
|
|
;;----------------------------------------------------------------------
|
|
;; eax = accumulator
|
|
;; ebx = colormap
|
|
;; ecx = count
|
|
;; edx = accumulator
|
|
;; esi = source
|
|
;; edi = dest
|
|
;; ebp = vid.width
|
|
;; mm0 = accumulator
|
|
;; mm1 = heightmask, twice
|
|
;; mm2 = 2 * fracstep, twice
|
|
;; mm3 = pair of consecutive fracs
|
|
;;----------------------------------------------------------------------
|
|
|
|
|
|
cglobal R_DrawColumn_8_MMX
|
|
R_DrawColumn_8_MMX:
|
|
push ebp ;; preserve caller's stack frame pointer
|
|
push esi ;; preserve register variables
|
|
push edi
|
|
push ebx
|
|
|
|
;;
|
|
;; Our algorithm requires that the texture height be a power of two.
|
|
;; If not, fall back to the non-MMX drawer.
|
|
;;
|
|
.texheightcheck:
|
|
mov edx, [dc_texheight]
|
|
sub edx, 1 ;; edx = heightmask
|
|
test edx, [dc_texheight]
|
|
jnz near .usenonMMX
|
|
|
|
mov ebp, edx ;; Keep a copy of heightmask in a
|
|
;; GPR for the time being.
|
|
|
|
;;
|
|
;; Fill mm1 with heightmask
|
|
;;
|
|
movd mm1, edx ;; low dword = heightmask
|
|
punpckldq mm1, mm1 ;; copy low dword to high dword
|
|
|
|
;;
|
|
;; dest = ylookup[dc_yl] + columnofs[dc_x];
|
|
;;
|
|
mov eax, [dc_yl]
|
|
mov edi, [ylookup+eax*4]
|
|
mov ebx, [dc_x]
|
|
add edi, [columnofs+ebx*4] ;; edi = dest
|
|
|
|
|
|
;;
|
|
;; pixelcount = yh - yl + 1
|
|
;;
|
|
mov ecx, [dc_yh]
|
|
add ecx, 1
|
|
sub ecx, eax ;; pixel count
|
|
jle near .done ;; nothing to scale
|
|
|
|
;;
|
|
;; fracstep = dc_iscale;
|
|
;;
|
|
movd mm2, [dc_iscale] ;; fracstep in low dword
|
|
punpckldq mm2, mm2 ;; copy to high dword
|
|
|
|
mov ebx, [dc_colormap]
|
|
mov esi, [dc_source]
|
|
|
|
;;
|
|
;; frac = (dc_texturemid + FixedMul((dc_yl << FRACBITS) - centeryfrac, fracstep));
|
|
;;
|
|
;; eax == dc_yl already
|
|
shl eax, FRACBITS
|
|
sub eax, [centeryfrac]
|
|
imul dword [dc_iscale]
|
|
shrd eax, edx, FRACBITS
|
|
add eax, [dc_texturemid]
|
|
|
|
;;
|
|
;; if (dc_hires) frac = 0;
|
|
;;
|
|
test byte [dc_hires], 0x01
|
|
jz .mod2
|
|
xor eax, eax
|
|
|
|
|
|
;;
|
|
;; Do mod-2 pixel.
|
|
;;
|
|
.mod2:
|
|
test ecx, 1
|
|
jz .pairprepare
|
|
mov edx, eax ;; edx = frac
|
|
add eax, [dc_iscale] ;; eax += fracstep
|
|
sar edx, FRACBITS
|
|
and edx, ebp ;; edx &= heightmask
|
|
movzx edx, byte [esi + edx]
|
|
movzx edx, byte [ebx + edx]
|
|
mov [edi], dl
|
|
|
|
add edi, [vid + viddef_s.width]
|
|
sub ecx, 1
|
|
jz .done
|
|
|
|
.pairprepare:
|
|
;;
|
|
;; Prepare for the main loop.
|
|
;;
|
|
movd mm3, eax ;; Low dword = frac
|
|
movq mm4, mm3 ;; Copy to intermediate register
|
|
paddd mm4, mm2 ;; dwords of mm4 += fracstep
|
|
punpckldq mm3, mm4 ;; Low dword = first frac, high = second
|
|
pslld mm2, 1 ;; fracstep *= 2
|
|
|
|
;;
|
|
;; ebp = vid.width
|
|
;;
|
|
mov ebp, [vid + viddef_s.width]
|
|
|
|
align 16
|
|
.pairloop:
|
|
movq mm0, mm3 ;; 3B 1u.
|
|
psrad mm0, FRACBITS ;; 4B 1u.
|
|
pand mm0, mm1 ;; 3B 1u. frac &= heightmask
|
|
paddd mm3, mm2 ;; 3B 1u. frac += fracstep
|
|
|
|
movd eax, mm0 ;; 3B 1u. Get first frac
|
|
;; IFETCH boundary
|
|
movzx eax, byte [esi + eax] ;; 4B 1u. Texture map
|
|
movzx eax, byte [ebx + eax] ;; 4B 1u. Colormap
|
|
|
|
punpckhdq mm0, mm0 ;; 3B 1(2)u. low dword = high dword
|
|
movd edx, mm0 ;; 3B 1u. Get second frac
|
|
mov [edi], al ;; 2B 1(2)u. First pixel
|
|
;; IFETCH boundary
|
|
|
|
movzx edx, byte [esi + edx] ;; 4B 1u. Texture map
|
|
movzx edx, byte [ebx + edx] ;; 4B 1u. Colormap
|
|
mov [edi + 1*ebp], dl ;; 3B 1(2)u. Second pixel
|
|
|
|
lea edi, [edi + 2*ebp] ;; 3B 1u. edi += 2 * vid.width
|
|
;; IFETCH boundary
|
|
sub ecx, 2 ;; 3B 1u. count -= 2
|
|
jnz .pairloop ;; 2B 1u. if(count != 0) goto .pairloop
|
|
|
|
|
|
.done:
|
|
;;
|
|
;; Clear MMX state, or else FPU operations will go badly awry.
|
|
;;
|
|
emms
|
|
|
|
pop ebx
|
|
pop edi
|
|
pop esi
|
|
pop ebp
|
|
ret
|
|
|
|
.usenonMMX:
|
|
call R_DrawColumn_8_ASM
|
|
jmp .done
|
|
|
|
|
|
;;----------------------------------------------------------------------
|
|
;;
|
|
;; R_Draw2sMultiPatchColumn : Like R_DrawColumn, but omits transparent
|
|
;; pixels.
|
|
;;
|
|
;; MMX column drawer.
|
|
;;
|
|
;;----------------------------------------------------------------------
|
|
;; eax = accumulator
|
|
;; ebx = colormap
|
|
;; ecx = count
|
|
;; edx = accumulator
|
|
;; esi = source
|
|
;; edi = dest
|
|
;; ebp = vid.width
|
|
;; mm0 = accumulator
|
|
;; mm1 = heightmask, twice
|
|
;; mm2 = 2 * fracstep, twice
|
|
;; mm3 = pair of consecutive fracs
|
|
;;----------------------------------------------------------------------
|
|
|
|
|
|
cglobal R_Draw2sMultiPatchColumn_8_MMX
|
|
R_Draw2sMultiPatchColumn_8_MMX:
|
|
push ebp ;; preserve caller's stack frame pointer
|
|
push esi ;; preserve register variables
|
|
push edi
|
|
push ebx
|
|
|
|
;;
|
|
;; Our algorithm requires that the texture height be a power of two.
|
|
;; If not, fall back to the non-MMX drawer.
|
|
;;
|
|
.texheightcheck:
|
|
mov edx, [dc_texheight]
|
|
sub edx, 1 ;; edx = heightmask
|
|
test edx, [dc_texheight]
|
|
jnz near .usenonMMX
|
|
|
|
mov ebp, edx ;; Keep a copy of heightmask in a
|
|
;; GPR for the time being.
|
|
|
|
;;
|
|
;; Fill mm1 with heightmask
|
|
;;
|
|
movd mm1, edx ;; low dword = heightmask
|
|
punpckldq mm1, mm1 ;; copy low dword to high dword
|
|
|
|
;;
|
|
;; dest = ylookup[dc_yl] + columnofs[dc_x];
|
|
;;
|
|
mov eax, [dc_yl]
|
|
mov edi, [ylookup+eax*4]
|
|
mov ebx, [dc_x]
|
|
add edi, [columnofs+ebx*4] ;; edi = dest
|
|
|
|
|
|
;;
|
|
;; pixelcount = yh - yl + 1
|
|
;;
|
|
mov ecx, [dc_yh]
|
|
add ecx, 1
|
|
sub ecx, eax ;; pixel count
|
|
jle near .done ;; nothing to scale
|
|
;;
|
|
;; fracstep = dc_iscale;
|
|
;;
|
|
movd mm2, [dc_iscale] ;; fracstep in low dword
|
|
punpckldq mm2, mm2 ;; copy to high dword
|
|
|
|
mov ebx, [dc_colormap]
|
|
mov esi, [dc_source]
|
|
|
|
;;
|
|
;; frac = (dc_texturemid + FixedMul((dc_yl << FRACBITS) - centeryfrac, fracstep));
|
|
;;
|
|
;; eax == dc_yl already
|
|
shl eax, FRACBITS
|
|
sub eax, [centeryfrac]
|
|
imul dword [dc_iscale]
|
|
shrd eax, edx, FRACBITS
|
|
add eax, [dc_texturemid]
|
|
|
|
;;
|
|
;; if (dc_hires) frac = 0;
|
|
;;
|
|
test byte [dc_hires], 0x01
|
|
jz .mod2
|
|
xor eax, eax
|
|
|
|
|
|
;;
|
|
;; Do mod-2 pixel.
|
|
;;
|
|
.mod2:
|
|
test ecx, 1
|
|
jz .pairprepare
|
|
mov edx, eax ;; edx = frac
|
|
add eax, [dc_iscale] ;; eax += fracstep
|
|
sar edx, FRACBITS
|
|
and edx, ebp ;; edx &= heightmask
|
|
movzx edx, byte [esi + edx]
|
|
cmp dl, TRANSPARENTPIXEL
|
|
je .nextmod2
|
|
movzx edx, byte [ebx + edx]
|
|
mov [edi], dl
|
|
|
|
.nextmod2:
|
|
add edi, [vid + viddef_s.width]
|
|
sub ecx, 1
|
|
jz .done
|
|
|
|
.pairprepare:
|
|
;;
|
|
;; Prepare for the main loop.
|
|
;;
|
|
movd mm3, eax ;; Low dword = frac
|
|
movq mm4, mm3 ;; Copy to intermediate register
|
|
paddd mm4, mm2 ;; dwords of mm4 += fracstep
|
|
punpckldq mm3, mm4 ;; Low dword = first frac, high = second
|
|
pslld mm2, 1 ;; fracstep *= 2
|
|
|
|
;;
|
|
;; ebp = vid.width
|
|
;;
|
|
mov ebp, [vid + viddef_s.width]
|
|
|
|
align 16
|
|
.pairloop:
|
|
movq mm0, mm3 ;; 3B 1u.
|
|
psrad mm0, FRACBITS ;; 4B 1u.
|
|
pand mm0, mm1 ;; 3B 1u. frac &= heightmask
|
|
paddd mm3, mm2 ;; 3B 1u. frac += fracstep
|
|
|
|
movd eax, mm0 ;; 3B 1u. Get first frac
|
|
;; IFETCH boundary
|
|
movzx eax, byte [esi + eax] ;; 4B 1u. Texture map
|
|
punpckhdq mm0, mm0 ;; 3B 1(2)u. low dword = high dword
|
|
movd edx, mm0 ;; 3B 1u. Get second frac
|
|
cmp al, TRANSPARENTPIXEL ;; 2B 1u.
|
|
je .secondinpair ;; 2B 1u.
|
|
;; IFETCH boundary
|
|
movzx eax, byte [ebx + eax] ;; 4B 1u. Colormap
|
|
mov [edi], al ;; 2B 1(2)u. First pixel
|
|
|
|
.secondinpair:
|
|
movzx edx, byte [esi + edx] ;; 4B 1u. Texture map
|
|
cmp dl, TRANSPARENTPIXEL ;; 2B 1u.
|
|
je .nextpair ;; 2B 1u.
|
|
;; IFETCH boundary
|
|
movzx edx, byte [ebx + edx] ;; 4B 1u. Colormap
|
|
mov [edi + 1*ebp], dl ;; 3B 1(2)u. Second pixel
|
|
|
|
.nextpair:
|
|
lea edi, [edi + 2*ebp] ;; 3B 1u. edi += 2 * vid.width
|
|
sub ecx, 2 ;; 3B 1u. count -= 2
|
|
jnz .pairloop ;; 2B 1u. if(count != 0) goto .pairloop
|
|
|
|
|
|
.done:
|
|
;;
|
|
;; Clear MMX state, or else FPU operations will go badly awry.
|
|
;;
|
|
emms
|
|
|
|
pop ebx
|
|
pop edi
|
|
pop esi
|
|
pop ebp
|
|
ret
|
|
|
|
.usenonMMX:
|
|
call R_Draw2sMultiPatchColumn_8_ASM
|
|
jmp .done
|
|
|
|
|
|
;;----------------------------------------------------------------------
|
|
;;
|
|
;; R_DrawSpan : 8bpp span drawer
|
|
;;
|
|
;; MMX span drawer.
|
|
;;
|
|
;;----------------------------------------------------------------------
|
|
;; eax = accumulator
|
|
;; ebx = colormap
|
|
;; ecx = count
|
|
;; edx = accumulator
|
|
;; esi = source
|
|
;; edi = dest
|
|
;; ebp = two pixels
|
|
;; mm0 = accumulator
|
|
;; mm1 = xposition
|
|
;; mm2 = yposition
|
|
;; mm3 = 2 * xstep
|
|
;; mm4 = 2 * ystep
|
|
;; mm5 = nflatxshift
|
|
;; mm6 = nflatyshift
|
|
;; mm7 = accumulator
|
|
;;----------------------------------------------------------------------
|
|
|
|
cglobal R_DrawSpan_8_MMX
|
|
R_DrawSpan_8_MMX:
|
|
push ebp ;; preserve caller's stack frame pointer
|
|
push esi ;; preserve register variables
|
|
push edi
|
|
push ebx
|
|
|
|
;;
|
|
;; esi = ds_source
|
|
;; ebx = ds_colormap
|
|
;;
|
|
mov esi, [ds_source]
|
|
mov ebx, [ds_colormap]
|
|
|
|
;;
|
|
;; edi = ylookup[ds_y] + columnofs[ds_x1]
|
|
;;
|
|
mov eax, [ds_y]
|
|
mov edi, [ylookup + eax*4]
|
|
mov edx, [ds_x1]
|
|
add edi, [columnofs + edx*4]
|
|
|
|
;;
|
|
;; ecx = ds_x2 - ds_x1 + 1
|
|
;;
|
|
mov ecx, [ds_x2]
|
|
sub ecx, edx
|
|
add ecx, 1
|
|
|
|
;;
|
|
;; Needed for fracs and steps
|
|
;;
|
|
movd mm7, [nflatshiftup]
|
|
|
|
;;
|
|
;; mm3 = xstep
|
|
;;
|
|
movd mm3, [ds_xstep]
|
|
pslld mm3, mm7
|
|
punpckldq mm3, mm3
|
|
|
|
;;
|
|
;; mm4 = ystep
|
|
;;
|
|
movd mm4, [ds_ystep]
|
|
pslld mm4, mm7
|
|
punpckldq mm4, mm4
|
|
|
|
;;
|
|
;; mm1 = pair of consecutive xpositions
|
|
;;
|
|
movd mm1, [ds_xfrac]
|
|
pslld mm1, mm7
|
|
movq mm6, mm1
|
|
paddd mm6, mm3
|
|
punpckldq mm1, mm6
|
|
|
|
;;
|
|
;; mm2 = pair of consecutive ypositions
|
|
;;
|
|
movd mm2, [ds_yfrac]
|
|
pslld mm2, mm7
|
|
movq mm6, mm2
|
|
paddd mm6, mm4
|
|
punpckldq mm2, mm6
|
|
|
|
;;
|
|
;; mm5 = nflatxshift
|
|
;; mm6 = nflatyshift
|
|
;;
|
|
movd mm5, [nflatxshift]
|
|
movd mm6, [nflatyshift]
|
|
|
|
;;
|
|
;; Mask is in memory due to lack of registers.
|
|
;;
|
|
mov eax, [nflatmask]
|
|
mov [nflatmask64], eax
|
|
mov [nflatmask64 + 4], eax
|
|
|
|
|
|
;;
|
|
;; Go until we reach a dword boundary.
|
|
;;
|
|
.unaligned:
|
|
test edi, 3
|
|
jz .alignedprep
|
|
.stragglers:
|
|
cmp ecx, 0
|
|
je .done ;; If ecx == 0, we're finished.
|
|
|
|
;;
|
|
;; eax = ((yposition >> nflatyshift) & nflatmask) | (xposition >> nflatxshift)
|
|
;;
|
|
movq mm0, mm1 ;; mm0 = xposition
|
|
movq mm7, mm2 ;; mm7 = yposition
|
|
paddd mm1, mm3 ;; xposition += xstep (once!)
|
|
paddd mm2, mm4 ;; yposition += ystep (once!)
|
|
psrld mm0, mm5 ;; shift
|
|
psrld mm7, mm6 ;; shift
|
|
pand mm7, [nflatmask64] ;; mask
|
|
por mm0, mm7 ;; or x and y together
|
|
|
|
movd eax, mm0 ;; eax = index of first pixel
|
|
movzx eax, byte [esi + eax] ;; al = source[eax]
|
|
movzx eax, byte [ebx + eax] ;; al = colormap[al]
|
|
|
|
mov [edi], al
|
|
add edi, 1
|
|
|
|
sub ecx, 1
|
|
jmp .unaligned
|
|
|
|
|
|
.alignedprep:
|
|
;;
|
|
;; We can double the steps now.
|
|
;;
|
|
pslld mm3, 1
|
|
pslld mm4, 1
|
|
|
|
|
|
;;
|
|
;; Generate chunks of four pixels.
|
|
;;
|
|
.alignedloop:
|
|
|
|
;;
|
|
;; Make sure we have at least four pixels.
|
|
;;
|
|
cmp ecx, 4
|
|
jl .prestragglers
|
|
|
|
;;
|
|
;; First two pixels.
|
|
;;
|
|
movq mm0, mm1 ;; mm0 = xposition
|
|
movq mm7, mm2 ;; mm7 = yposition
|
|
paddd mm1, mm3 ;; xposition += xstep
|
|
paddd mm2, mm4 ;; yposition += ystep
|
|
psrld mm0, mm5 ;; shift
|
|
psrld mm7, mm6 ;; shift
|
|
pand mm7, [nflatmask64] ;; mask
|
|
por mm0, mm7 ;; or x and y together
|
|
|
|
movd eax, mm0 ;; eax = index of first pixel
|
|
movzx eax, byte [esi + eax] ;; al = source[eax]
|
|
movzx ebp, byte [ebx + eax] ;; ebp = colormap[al]
|
|
|
|
punpckhdq mm0, mm0 ;; both dwords = high dword
|
|
movd eax, mm0 ;; eax = index of second pixel
|
|
movzx eax, byte [esi + eax] ;; al = source[eax]
|
|
movzx eax, byte [ebx + eax] ;; al = colormap[al]
|
|
shl eax, 8 ;; get pixel in right byte
|
|
or ebp, eax ;; put pixel in ebp
|
|
|
|
;;
|
|
;; Next two pixels.
|
|
;;
|
|
movq mm0, mm1 ;; mm0 = xposition
|
|
movq mm7, mm2 ;; mm7 = yposition
|
|
paddd mm1, mm3 ;; xposition += xstep
|
|
paddd mm2, mm4 ;; yposition += ystep
|
|
psrld mm0, mm5 ;; shift
|
|
psrld mm7, mm6 ;; shift
|
|
pand mm7, [nflatmask64] ;; mask
|
|
por mm0, mm7 ;; or x and y together
|
|
|
|
movd eax, mm0 ;; eax = index of third pixel
|
|
movzx eax, byte [esi + eax] ;; al = source[eax]
|
|
movzx eax, byte [ebx + eax] ;; al = colormap[al]
|
|
shl eax, 16 ;; get pixel in right byte
|
|
or ebp, eax ;; put pixel in ebp
|
|
|
|
punpckhdq mm0, mm0 ;; both dwords = high dword
|
|
movd eax, mm0 ;; eax = index of second pixel
|
|
movzx eax, byte [esi + eax] ;; al = source[eax]
|
|
movzx eax, byte [ebx + eax] ;; al = colormap[al]
|
|
shl eax, 24 ;; get pixel in right byte
|
|
or ebp, eax ;; put pixel in ebp
|
|
|
|
;;
|
|
;; Write pixels.
|
|
;;
|
|
mov [edi], ebp
|
|
add edi, 4
|
|
|
|
sub ecx, 4
|
|
jmp .alignedloop
|
|
|
|
.prestragglers:
|
|
;;
|
|
;; Back to one step at a time.
|
|
;;
|
|
psrad mm3, 1
|
|
psrad mm4, 1
|
|
jmp .stragglers
|
|
|
|
.done:
|
|
;;
|
|
;; Clear MMX state, or else FPU operations will go badly awry.
|
|
;;
|
|
emms
|
|
|
|
pop ebx
|
|
pop edi
|
|
pop esi
|
|
pop ebp
|
|
ret
|