eukara/ngunix
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity

Dropping ASM code, cleaning up variables and misc things.

Browse source
This commit is contained in:
Marco Vicari 2016-02-14 19:04:00 +01:00
parent eef03a859f
commit d0ac39bba4
41 changed files with 593 additions and 12110 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

86
Makefile
View file

@ -33,7 +33,6 @@ XLDFLAGS=`pkg-config --libs gtk+-2.0`
DO_CC=$(CC) $(CFLAGS) -o $@ -c $<
DO_DEBUG_CC=$(CC) $(DEBUG_CFLAGS) -o $@ -c $<
DO_AS=$(CC) $(CFLAGS) -DELF -x assembler-with-cpp -o $@ -c $<
DO_DUMB=$(CC) $(CFLAGS) -o $@ -c $<
#############################################################################
@ -182,27 +181,7 @@ NGUNIX_OBJS = \
$(BUILDDIR)/nvs_client.o \
$(BUILDDIR)/nvs_common.o \
$(BUILDDIR)/nvs_server.o \
$(BUILDDIR)/nvs_server_data.o \
\
$(BUILDDIR)/d_draw.o \
$(BUILDDIR)/d_draw16.o \
$(BUILDDIR)/d_parta.o \
$(BUILDDIR)/d_polysa.o \
$(BUILDDIR)/d_scana.o \
$(BUILDDIR)/d_spr8.o \
$(BUILDDIR)/d_varsa.o \
$(BUILDDIR)/math.o \
$(BUILDDIR)/r_aliasa.o \
$(BUILDDIR)/r_drawa.o \
$(BUILDDIR)/r_edgea.o \
$(BUILDDIR)/r_varsa.o \
$(BUILDDIR)/surf16.o \
$(BUILDDIR)/surf8.o \
$(BUILDDIR)/surf8fst.o \
$(BUILDDIR)/worlda.o \
$(BUILDDIR)/r_aclipa.o \
$(BUILDDIR)/snd_mixa.o \
$(BUILDDIR)/sys.o
$(BUILDDIR)/nvs_server_data.o
$(MASTER_DIR)/ngunix.x86 : $(NGUNIX_OBJS)
$(CC) $(CFLAGS) -o $@ $(NGUNIX_OBJS) $(XLDFLAGS) $(LDFLAGS)
@ -575,69 +554,6 @@ $(BUILDDIR)/nvs_server.o :$(MOUNT_DIR)/../network/nvs_server.c
$(BUILDDIR)/nvs_server_data.o :$(MOUNT_DIR)/../network/nvs_server_data.c
$(DO_CC)
#####
$(BUILDDIR)/d_copy.o : $(MOUNT_DIR)/../asm/d_copy.s
$(DO_AS)
$(BUILDDIR)/d_draw.o : $(MOUNT_DIR)/../asm/d_draw.s
$(DO_AS)
$(BUILDDIR)/d_draw16.o : $(MOUNT_DIR)/../asm/d_draw16.s
$(DO_AS)
$(BUILDDIR)/d_parta.o : $(MOUNT_DIR)/../asm/d_parta.s
$(DO_AS)
$(BUILDDIR)/d_polysa.o : $(MOUNT_DIR)/../asm/d_polysa.s
$(DO_AS)
$(BUILDDIR)/d_scana.o : $(MOUNT_DIR)/../asm/d_scana.s
$(DO_AS)
$(BUILDDIR)/d_spr8.o : $(MOUNT_DIR)/../asm/d_spr8.s
$(DO_AS)
$(BUILDDIR)/d_varsa.o : $(MOUNT_DIR)/../asm/d_varsa.s
$(DO_AS)
$(BUILDDIR)/math.o : $(MOUNT_DIR)/../asm/math.s
$(DO_AS)
$(BUILDDIR)/r_aliasa.o : $(MOUNT_DIR)/../asm/r_aliasa.s
$(DO_AS)
$(BUILDDIR)/r_drawa.o : $(MOUNT_DIR)/../asm/r_drawa.s
$(DO_AS)
$(BUILDDIR)/r_edgea.o : $(MOUNT_DIR)/../asm/r_edgea.s
$(DO_AS)
$(BUILDDIR)/r_varsa.o : $(MOUNT_DIR)/../asm/r_varsa.s
$(DO_AS)
$(BUILDDIR)/surf16.o : $(MOUNT_DIR)/../asm/surf16.s
$(DO_AS)
$(BUILDDIR)/surf8.o : $(MOUNT_DIR)/../asm/surf8.s
$(DO_AS)
$(BUILDDIR)/surf8fst.o : $(MOUNT_DIR)/../asm/surf8fst.s
$(DO_AS)
$(BUILDDIR)/worlda.o : $(MOUNT_DIR)/../asm/worlda.s
$(DO_AS)
$(BUILDDIR)/r_aclipa.o : $(MOUNT_DIR)/../asm/r_aclipa.s
$(DO_AS)
$(BUILDDIR)/snd_mixa.o : $(MOUNT_DIR)/../asm/snd_mixa.s
$(DO_AS)
$(BUILDDIR)/sys.o : $(MOUNT_DIR)/../asm/sys.s
$(DO_AS)
#############################################################################
# MISC
#############################################################################

169
asm/d_copy.s
View file

@ -1,169 +0,0 @@
/*
Copyright (C) 1996-1997 Id Software, Inc.
This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
See the GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*/
//
// d_copy.s
// x86 assembly-language screen copying code.
//
#ifndef NOASM
#include "asm_i386.h"
#include "asm.h"
#include "asm_draw.h"
.data
LCopyWidth: .long 0
LBlockSrcStep: .long 0
LBlockDestStep: .long 0
LSrcDelta: .long 0
LDestDelta: .long 0
#define bufptr 4+16
// copies 16 rows per plane at a pop; idea is that 16*512 = 8k, and since
// no Mode X mode is wider than 360, all the data should fit in the cache for
// the passes for the next 3 planes
.text
.globl C(VGA_UpdatePlanarScreen)
C(VGA_UpdatePlanarScreen):
pushl %ebp // preserve caller's stack frame
pushl %edi
pushl %esi // preserve register variables
pushl %ebx
movl C(VGA_bufferrowbytes),%eax
shll $1,%eax
movl %eax,LBlockSrcStep
movl C(VGA_rowbytes),%eax
shll $1,%eax
movl %eax,LBlockDestStep
movl $0x3C4,%edx
movb $2,%al
outb %al,%dx // point the SC to the Map Mask
incl %edx
movl bufptr(%esp),%esi
movl C(VGA_pagebase),%edi
movl C(VGA_height),%ebp
shrl $1,%ebp
movl C(VGA_width),%ecx
movl C(VGA_bufferrowbytes),%eax
subl %ecx,%eax
movl %eax,LSrcDelta
movl C(VGA_rowbytes),%eax
shll $2,%eax
subl %ecx,%eax
movl %eax,LDestDelta
shrl $4,%ecx
movl %ecx,LCopyWidth
LRowLoop:
movb $1,%al
LPlaneLoop:
outb %al,%dx
movb $2,%ah
pushl %esi
pushl %edi
LRowSetLoop:
movl LCopyWidth,%ecx
LColumnLoop:
movb 12(%esi),%bh
movb 8(%esi),%bl
shll $16,%ebx
movb 4(%esi),%bh
movb (%esi),%bl
movl %ebx,(%edi)
addl $16,%esi
addl $4,%edi
decl %ecx
jnz LColumnLoop
addl LDestDelta,%edi
addl LSrcDelta,%esi
decb %ah
jnz LRowSetLoop
popl %edi
popl %esi
incl %esi
shlb $1,%al
cmpb $16,%al
jnz LPlaneLoop
subl $4,%esi
addl LBlockSrcStep,%esi
addl LBlockDestStep,%edi
decl %ebp
jnz LRowLoop
popl %ebx // restore register variables
popl %esi
popl %edi
popl %ebp // restore the caller's stack frame
ret
#define srcptr 4+16
#define destptr 8+16
#define width 12+16
#define height 16+16
#define srcrowbytes 20+16
#define destrowbytes 24+16
.globl C(VGA_UpdateLinearScreen)
C(VGA_UpdateLinearScreen):
pushl %ebp // preserve caller's stack frame
pushl %edi
pushl %esi // preserve register variables
pushl %ebx
cld
movl srcptr(%esp),%esi
movl destptr(%esp),%edi
movl width(%esp),%ebx
movl srcrowbytes(%esp),%eax
subl %ebx,%eax
movl destrowbytes(%esp),%edx
subl %ebx,%edx
shrl $2,%ebx
movl height(%esp),%ebp
LLRowLoop:
movl %ebx,%ecx
rep/movsl (%esi),(%edi)
addl %eax,%esi
addl %edx,%edi
decl %ebp
jnz LLRowLoop
popl %ebx // restore register variables
popl %esi
popl %edi
popl %ebp // restore the caller's stack frame
ret
#endif

1040
asm/d_draw.s
View file

File diff suppressed because it is too large Load diff

978
asm/d_draw16.s
View file

@ -1,978 +0,0 @@
/*
Copyright (C) 1996-1997 Id Software, Inc.
This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
See the GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*/
//
// d_draw16.s
// x86 assembly-language horizontal 8-bpp span-drawing code, with 16-pixel
// subdivision.
//
#ifndef NOASM
#include "asm_i386.h"
#include "asm.h"
#include "asm_draw.h"
#include "d_ifacea.h"
#if id386
//----------------------------------------------------------------------
// 8-bpp horizontal span drawing code for polygons, with no transparency and
// 16-pixel subdivision.
//
// Assumes there is at least one span in pspans, and that every span
// contains at least one pixel
//----------------------------------------------------------------------
.data
.text
// out-of-line, rarely-needed clamping code
LClampHigh0:
movl C(bbextents),%esi
jmp LClampReentry0
LClampHighOrLow0:
jg LClampHigh0
xorl %esi,%esi
jmp LClampReentry0
LClampHigh1:
movl C(bbextentt),%edx
jmp LClampReentry1
LClampHighOrLow1:
jg LClampHigh1
xorl %edx,%edx
jmp LClampReentry1
LClampLow2:
movl $4096,%ebp
jmp LClampReentry2
LClampHigh2:
movl C(bbextents),%ebp
jmp LClampReentry2
LClampLow3:
movl $4096,%ecx
jmp LClampReentry3
LClampHigh3:
movl C(bbextentt),%ecx
jmp LClampReentry3
LClampLow4:
movl $4096,%eax
jmp LClampReentry4
LClampHigh4:
movl C(bbextents),%eax
jmp LClampReentry4
LClampLow5:
movl $4096,%ebx
jmp LClampReentry5
LClampHigh5:
movl C(bbextentt),%ebx
jmp LClampReentry5
#define pspans 4+16
.align 4
.globl C(D_DrawSpans16)
C(D_DrawSpans16):
pushl %ebp // preserve caller's stack frame
pushl %edi
pushl %esi // preserve register variables
pushl %ebx
//
// set up scaled-by-16 steps, for 16-long segments; also set up cacheblock
// and span list pointers
//
// TODO: any overlap from rearranging?
flds C(d_sdivzstepu)
fmuls fp_16
movl C(cacheblock),%edx
flds C(d_tdivzstepu)
fmuls fp_16
movl pspans(%esp),%ebx // point to the first span descriptor
flds C(d_zistepu)
fmuls fp_16
movl %edx,pbase // pbase = cacheblock
fstps zi16stepu
fstps tdivz16stepu
fstps sdivz16stepu
LSpanLoop:
//
// set up the initial s/z, t/z, and 1/z on the FP stack, and generate the
// initial s and t values
//
// FIXME: pipeline FILD?
fildl espan_t_v(%ebx)
fildl espan_t_u(%ebx)
fld %st(1) // dv | du | dv
fmuls C(d_sdivzstepv) // dv*d_sdivzstepv | du | dv
fld %st(1) // du | dv*d_sdivzstepv | du | dv
fmuls C(d_sdivzstepu) // du*d_sdivzstepu | dv*d_sdivzstepv | du | dv
fld %st(2) // du | du*d_sdivzstepu | dv*d_sdivzstepv | du | dv
fmuls C(d_tdivzstepu) // du*d_tdivzstepu | du*d_sdivzstepu |
// dv*d_sdivzstepv | du | dv
fxch %st(1) // du*d_sdivzstepu | du*d_tdivzstepu |
// dv*d_sdivzstepv | du | dv
faddp %st(0),%st(2) // du*d_tdivzstepu |
// du*d_sdivzstepu + dv*d_sdivzstepv | du | dv
fxch %st(1) // du*d_sdivzstepu + dv*d_sdivzstepv |
// du*d_tdivzstepu | du | dv
fld %st(3) // dv | du*d_sdivzstepu + dv*d_sdivzstepv |
// du*d_tdivzstepu | du | dv
fmuls C(d_tdivzstepv) // dv*d_tdivzstepv |
// du*d_sdivzstepu + dv*d_sdivzstepv |
// du*d_tdivzstepu | du | dv
fxch %st(1) // du*d_sdivzstepu + dv*d_sdivzstepv |
// dv*d_tdivzstepv | du*d_tdivzstepu | du | dv
fadds C(d_sdivzorigin) // sdivz = d_sdivzorigin + dv*d_sdivzstepv +
// du*d_sdivzstepu; stays in %st(2) at end
fxch %st(4) // dv | dv*d_tdivzstepv | du*d_tdivzstepu | du |
// s/z
fmuls C(d_zistepv) // dv*d_zistepv | dv*d_tdivzstepv |
// du*d_tdivzstepu | du | s/z
fxch %st(1) // dv*d_tdivzstepv | dv*d_zistepv |
// du*d_tdivzstepu | du | s/z
faddp %st(0),%st(2) // dv*d_zistepv |
// dv*d_tdivzstepv + du*d_tdivzstepu | du | s/z
fxch %st(2) // du | dv*d_tdivzstepv + du*d_tdivzstepu |
// dv*d_zistepv | s/z
fmuls C(d_zistepu) // du*d_zistepu |
// dv*d_tdivzstepv + du*d_tdivzstepu |
// dv*d_zistepv | s/z
fxch %st(1) // dv*d_tdivzstepv + du*d_tdivzstepu |
// du*d_zistepu | dv*d_zistepv | s/z
fadds C(d_tdivzorigin) // tdivz = d_tdivzorigin + dv*d_tdivzstepv +
// du*d_tdivzstepu; stays in %st(1) at end
fxch %st(2) // dv*d_zistepv | du*d_zistepu | t/z | s/z
faddp %st(0),%st(1) // dv*d_zistepv + du*d_zistepu | t/z | s/z
flds fp_64k // fp_64k | dv*d_zistepv + du*d_zistepu | t/z | s/z
fxch %st(1) // dv*d_zistepv + du*d_zistepu | fp_64k | t/z | s/z
fadds C(d_ziorigin) // zi = d_ziorigin + dv*d_zistepv +
// du*d_zistepu; stays in %st(0) at end
// 1/z | fp_64k | t/z | s/z
//
// calculate and clamp s & t
//
fdivr %st(0),%st(1) // 1/z | z*64k | t/z | s/z
//
// point %edi to the first pixel in the span
//
movl C(d_viewbuffer),%ecx
movl espan_t_v(%ebx),%eax
movl %ebx,pspantemp // preserve spans pointer
movl C(tadjust),%edx
movl C(sadjust),%esi
movl C(d_scantable)(,%eax,4),%edi // v * screenwidth
addl %ecx,%edi
movl espan_t_u(%ebx),%ecx
addl %ecx,%edi // pdest = &pdestspan[scans->u];
movl espan_t_count(%ebx),%ecx
//
// now start the FDIV for the end of the span
//
cmpl $16,%ecx
ja LSetupNotLast1
decl %ecx
jz LCleanup1 // if only one pixel, no need to start an FDIV
movl %ecx,spancountminus1
// finish up the s and t calcs
fxch %st(1) // z*64k | 1/z | t/z | s/z
fld %st(0) // z*64k | z*64k | 1/z | t/z | s/z
fmul %st(4),%st(0) // s | z*64k | 1/z | t/z | s/z
fxch %st(1) // z*64k | s | 1/z | t/z | s/z
fmul %st(3),%st(0) // t | s | 1/z | t/z | s/z
fxch %st(1) // s | t | 1/z | t/z | s/z
fistpl s // 1/z | t | t/z | s/z
fistpl t // 1/z | t/z | s/z
fildl spancountminus1
flds C(d_tdivzstepu) // C(d_tdivzstepu) | spancountminus1
flds C(d_zistepu) // C(d_zistepu) | C(d_tdivzstepu) | spancountminus1
fmul %st(2),%st(0) // C(d_zistepu)*scm1 | C(d_tdivzstepu) | scm1
fxch %st(1) // C(d_tdivzstepu) | C(d_zistepu)*scm1 | scm1
fmul %st(2),%st(0) // C(d_tdivzstepu)*scm1 | C(d_zistepu)*scm1 | scm1
fxch %st(2) // scm1 | C(d_zistepu)*scm1 | C(d_tdivzstepu)*scm1
fmuls C(d_sdivzstepu) // C(d_sdivzstepu)*scm1 | C(d_zistepu)*scm1 |
// C(d_tdivzstepu)*scm1
fxch %st(1) // C(d_zistepu)*scm1 | C(d_sdivzstepu)*scm1 |
// C(d_tdivzstepu)*scm1
faddp %st(0),%st(3) // C(d_sdivzstepu)*scm1 | C(d_tdivzstepu)*scm1
fxch %st(1) // C(d_tdivzstepu)*scm1 | C(d_sdivzstepu)*scm1
faddp %st(0),%st(3) // C(d_sdivzstepu)*scm1
faddp %st(0),%st(3)
flds fp_64k
fdiv %st(1),%st(0) // this is what we've gone to all this trouble to
// overlap
jmp LFDIVInFlight1
LCleanup1:
// finish up the s and t calcs
fxch %st(1) // z*64k | 1/z | t/z | s/z
fld %st(0) // z*64k | z*64k | 1/z | t/z | s/z
fmul %st(4),%st(0) // s | z*64k | 1/z | t/z | s/z
fxch %st(1) // z*64k | s | 1/z | t/z | s/z
fmul %st(3),%st(0) // t | s | 1/z | t/z | s/z
fxch %st(1) // s | t | 1/z | t/z | s/z
fistpl s // 1/z | t | t/z | s/z
fistpl t // 1/z | t/z | s/z
jmp LFDIVInFlight1
.align 4
LSetupNotLast1:
// finish up the s and t calcs
fxch %st(1) // z*64k | 1/z | t/z | s/z
fld %st(0) // z*64k | z*64k | 1/z | t/z | s/z
fmul %st(4),%st(0) // s | z*64k | 1/z | t/z | s/z
fxch %st(1) // z*64k | s | 1/z | t/z | s/z
fmul %st(3),%st(0) // t | s | 1/z | t/z | s/z
fxch %st(1) // s | t | 1/z | t/z | s/z
fistpl s // 1/z | t | t/z | s/z
fistpl t // 1/z | t/z | s/z
fadds zi16stepu
fxch %st(2)
fadds sdivz16stepu
fxch %st(2)
flds tdivz16stepu
faddp %st(0),%st(2)
flds fp_64k
fdiv %st(1),%st(0) // z = 1/1/z
// this is what we've gone to all this trouble to
// overlap
LFDIVInFlight1:
addl s,%esi
addl t,%edx
movl C(bbextents),%ebx
movl C(bbextentt),%ebp
cmpl %ebx,%esi
ja LClampHighOrLow0
LClampReentry0:
movl %esi,s
movl pbase,%ebx
shll $16,%esi
cmpl %ebp,%edx
movl %esi,sfracf
ja LClampHighOrLow1
LClampReentry1:
movl %edx,t
movl s,%esi // sfrac = scans->sfrac;
shll $16,%edx
movl t,%eax // tfrac = scans->tfrac;
sarl $16,%esi
movl %edx,tfracf
//
// calculate the texture starting address
//
sarl $16,%eax
movl C(cachewidth),%edx
imull %edx,%eax // (tfrac >> 16) * cachewidth
addl %ebx,%esi
addl %eax,%esi // psource = pbase + (sfrac >> 16) +
// ((tfrac >> 16) * cachewidth);
//
// determine whether last span or not
//
cmpl $16,%ecx
jna LLastSegment
//
// not the last segment; do full 16-wide segment
//
LNotLastSegment:
//
// advance s/z, t/z, and 1/z, and calculate s & t at end of span and steps to
// get there
//
// pick up after the FDIV that was left in flight previously
fld %st(0) // duplicate it
fmul %st(4),%st(0) // s = s/z * z
fxch %st(1)
fmul %st(3),%st(0) // t = t/z * z
fxch %st(1)
fistpl snext
fistpl tnext
movl snext,%eax
movl tnext,%edx
movb (%esi),%bl // get first source texel
subl $16,%ecx // count off this segments' pixels
movl C(sadjust),%ebp
movl %ecx,counttemp // remember count of remaining pixels
movl C(tadjust),%ecx
movb %bl,(%edi) // store first dest pixel
addl %eax,%ebp
addl %edx,%ecx
movl C(bbextents),%eax
movl C(bbextentt),%edx
cmpl $4096,%ebp
jl LClampLow2
cmpl %eax,%ebp
ja LClampHigh2
LClampReentry2:
cmpl $4096,%ecx
jl LClampLow3
cmpl %edx,%ecx
ja LClampHigh3
LClampReentry3:
movl %ebp,snext
movl %ecx,tnext
subl s,%ebp
subl t,%ecx
//
// set up advancetable
//
movl %ecx,%eax
movl %ebp,%edx
sarl $20,%eax // tstep >>= 16;
jz LZero
sarl $20,%edx // sstep >>= 16;
movl C(cachewidth),%ebx
imull %ebx,%eax
jmp LSetUp1
LZero:
sarl $20,%edx // sstep >>= 16;
movl C(cachewidth),%ebx
LSetUp1:
addl %edx,%eax // add in sstep
// (tstep >> 16) * cachewidth + (sstep >> 16);
movl tfracf,%edx
movl %eax,advancetable+4 // advance base in t
addl %ebx,%eax // ((tstep >> 16) + 1) * cachewidth +
// (sstep >> 16);
shll $12,%ebp // left-justify sstep fractional part
movl sfracf,%ebx
shll $12,%ecx // left-justify tstep fractional part
movl %eax,advancetable // advance extra in t
movl %ecx,tstep
addl %ecx,%edx // advance tfrac fractional part by tstep frac
sbbl %ecx,%ecx // turn tstep carry into -1 (0 if none)
addl %ebp,%ebx // advance sfrac fractional part by sstep frac
adcl advancetable+4(,%ecx,4),%esi // point to next source texel
addl tstep,%edx
sbbl %ecx,%ecx
movb (%esi),%al
addl %ebp,%ebx
movb %al,1(%edi)
adcl advancetable+4(,%ecx,4),%esi
addl tstep,%edx
sbbl %ecx,%ecx
addl %ebp,%ebx
movb (%esi),%al
adcl advancetable+4(,%ecx,4),%esi
addl tstep,%edx
sbbl %ecx,%ecx
movb %al,2(%edi)
addl %ebp,%ebx
movb (%esi),%al
adcl advancetable+4(,%ecx,4),%esi
addl tstep,%edx
sbbl %ecx,%ecx
movb %al,3(%edi)
addl %ebp,%ebx
movb (%esi),%al
adcl advancetable+4(,%ecx,4),%esi
addl tstep,%edx
sbbl %ecx,%ecx
movb %al,4(%edi)
addl %ebp,%ebx
movb (%esi),%al
adcl advancetable+4(,%ecx,4),%esi
addl tstep,%edx
sbbl %ecx,%ecx
movb %al,5(%edi)
addl %ebp,%ebx
movb (%esi),%al
adcl advancetable+4(,%ecx,4),%esi
addl tstep,%edx
sbbl %ecx,%ecx
movb %al,6(%edi)
addl %ebp,%ebx
movb (%esi),%al
adcl advancetable+4(,%ecx,4),%esi
addl tstep,%edx
sbbl %ecx,%ecx
movb %al,7(%edi)
addl %ebp,%ebx
movb (%esi),%al
adcl advancetable+4(,%ecx,4),%esi
//
// start FDIV for end of next segment in flight, so it can overlap
//
movl counttemp,%ecx
cmpl $16,%ecx // more than one segment after this?
ja LSetupNotLast2 // yes
decl %ecx
jz LFDIVInFlight2 // if only one pixel, no need to start an FDIV
movl %ecx,spancountminus1
fildl spancountminus1
flds C(d_zistepu) // C(d_zistepu) | spancountminus1
fmul %st(1),%st(0) // C(d_zistepu)*scm1 | scm1
flds C(d_tdivzstepu) // C(d_tdivzstepu) | C(d_zistepu)*scm1 | scm1
fmul %st(2),%st(0) // C(d_tdivzstepu)*scm1 | C(d_zistepu)*scm1 | scm1
fxch %st(1) // C(d_zistepu)*scm1 | C(d_tdivzstepu)*scm1 | scm1
faddp %st(0),%st(3) // C(d_tdivzstepu)*scm1 | scm1
fxch %st(1) // scm1 | C(d_tdivzstepu)*scm1
fmuls C(d_sdivzstepu) // C(d_sdivzstepu)*scm1 | C(d_tdivzstepu)*scm1
fxch %st(1) // C(d_tdivzstepu)*scm1 | C(d_sdivzstepu)*scm1
faddp %st(0),%st(3) // C(d_sdivzstepu)*scm1
flds fp_64k // 64k | C(d_sdivzstepu)*scm1
fxch %st(1) // C(d_sdivzstepu)*scm1 | 64k
faddp %st(0),%st(4) // 64k
fdiv %st(1),%st(0) // this is what we've gone to all this trouble to
// overlap
jmp LFDIVInFlight2
.align 4
LSetupNotLast2:
fadds zi16stepu
fxch %st(2)
fadds sdivz16stepu
fxch %st(2)
flds tdivz16stepu
faddp %st(0),%st(2)
flds fp_64k
fdiv %st(1),%st(0) // z = 1/1/z
// this is what we've gone to all this trouble to
// overlap
LFDIVInFlight2:
movl %ecx,counttemp
addl tstep,%edx
sbbl %ecx,%ecx
movb %al,8(%edi)
addl %ebp,%ebx
movb (%esi),%al
adcl advancetable+4(,%ecx,4),%esi
addl tstep,%edx
sbbl %ecx,%ecx
movb %al,9(%edi)
addl %ebp,%ebx
movb (%esi),%al
adcl advancetable+4(,%ecx,4),%esi
addl tstep,%edx
sbbl %ecx,%ecx
movb %al,10(%edi)
addl %ebp,%ebx
movb (%esi),%al
adcl advancetable+4(,%ecx,4),%esi
addl tstep,%edx
sbbl %ecx,%ecx
movb %al,11(%edi)
addl %ebp,%ebx
movb (%esi),%al
adcl advancetable+4(,%ecx,4),%esi
addl tstep,%edx
sbbl %ecx,%ecx
movb %al,12(%edi)
addl %ebp,%ebx
movb (%esi),%al
adcl advancetable+4(,%ecx,4),%esi
addl tstep,%edx
sbbl %ecx,%ecx
movb %al,13(%edi)
addl %ebp,%ebx
movb (%esi),%al
adcl advancetable+4(,%ecx,4),%esi
addl tstep,%edx
sbbl %ecx,%ecx
movb %al,14(%edi)
addl %ebp,%ebx
movb (%esi),%al
adcl advancetable+4(,%ecx,4),%esi
addl $16,%edi
movl %edx,tfracf
movl snext,%edx
movl %ebx,sfracf
movl tnext,%ebx
movl %edx,s
movl %ebx,t
movl counttemp,%ecx // retrieve count
//
// determine whether last span or not
//
cmpl $16,%ecx // are there multiple segments remaining?
movb %al,-1(%edi)
ja LNotLastSegment // yes
//
// last segment of scan
//
LLastSegment:
//
// advance s/z, t/z, and 1/z, and calculate s & t at end of span and steps to
// get there. The number of pixels left is variable, and we want to land on the
// last pixel, not step one past it, so we can't run into arithmetic problems
//
testl %ecx,%ecx
jz LNoSteps // just draw the last pixel and we're done
// pick up after the FDIV that was left in flight previously
fld %st(0) // duplicate it
fmul %st(4),%st(0) // s = s/z * z
fxch %st(1)
fmul %st(3),%st(0) // t = t/z * z
fxch %st(1)
fistpl snext
fistpl tnext
movb (%esi),%al // load first texel in segment
movl C(tadjust),%ebx
movb %al,(%edi) // store first pixel in segment
movl C(sadjust),%eax
addl snext,%eax
addl tnext,%ebx
movl C(bbextents),%ebp
movl C(bbextentt),%edx
cmpl $4096,%eax
jl LClampLow4
cmpl %ebp,%eax
ja LClampHigh4
LClampReentry4:
movl %eax,snext
cmpl $4096,%ebx
jl LClampLow5
cmpl %edx,%ebx
ja LClampHigh5
LClampReentry5:
cmpl $1,%ecx // don't bother
je LOnlyOneStep // if two pixels in segment, there's only one step,
// of the segment length
subl s,%eax
subl t,%ebx
addl %eax,%eax // convert to 15.17 format so multiply by 1.31
addl %ebx,%ebx // reciprocal yields 16.48
imull reciprocal_table_16-8(,%ecx,4) // sstep = (snext - s) /
// (spancount-1)
movl %edx,%ebp
movl %ebx,%eax
imull reciprocal_table_16-8(,%ecx,4) // tstep = (tnext - t) /
// (spancount-1)
LSetEntryvec:
//
// set up advancetable
//
movl entryvec_table_16(,%ecx,4),%ebx
movl %edx,%eax
movl %ebx,jumptemp // entry point into code for RET later
movl %ebp,%ecx
sarl $16,%edx // tstep >>= 16;
movl C(cachewidth),%ebx
sarl $16,%ecx // sstep >>= 16;
imull %ebx,%edx
addl %ecx,%edx // add in sstep
// (tstep >> 16) * cachewidth + (sstep >> 16);
movl tfracf,%ecx
movl %edx,advancetable+4 // advance base in t
addl %ebx,%edx // ((tstep >> 16) + 1) * cachewidth +
// (sstep >> 16);
shll $16,%ebp // left-justify sstep fractional part
movl sfracf,%ebx
shll $16,%eax // left-justify tstep fractional part
movl %edx,advancetable // advance extra in t
movl %eax,tstep
movl %ecx,%edx
addl %eax,%edx
sbbl %ecx,%ecx
addl %ebp,%ebx
adcl advancetable+4(,%ecx,4),%esi
jmp *jumptemp // jump to the number-of-pixels handler
//----------------------------------------
LNoSteps:
movb (%esi),%al // load first texel in segment
subl $15,%edi // adjust for hardwired offset
jmp LEndSpan
LOnlyOneStep:
subl s,%eax
subl t,%ebx
movl %eax,%ebp
movl %ebx,%edx
jmp LSetEntryvec
//----------------------------------------
.globl Entry2_16, Entry3_16, Entry4_16, Entry5_16
.globl Entry6_16, Entry7_16, Entry8_16, Entry9_16
.globl Entry10_16, Entry11_16, Entry12_16, Entry13_16
.globl Entry14_16, Entry15_16, Entry16_16
Entry2_16:
subl $14,%edi // adjust for hardwired offsets
movb (%esi),%al
jmp LEntry2_16
//----------------------------------------
Entry3_16:
subl $13,%edi // adjust for hardwired offsets
addl %eax,%edx
movb (%esi),%al
sbbl %ecx,%ecx
addl %ebp,%ebx
adcl advancetable+4(,%ecx,4),%esi
jmp LEntry3_16
//----------------------------------------
Entry4_16:
subl $12,%edi // adjust for hardwired offsets
addl %eax,%edx
movb (%esi),%al
sbbl %ecx,%ecx
addl %ebp,%ebx
adcl advancetable+4(,%ecx,4),%esi
addl tstep,%edx
jmp LEntry4_16
//----------------------------------------
Entry5_16:
subl $11,%edi // adjust for hardwired offsets
addl %eax,%edx
movb (%esi),%al
sbbl %ecx,%ecx
addl %ebp,%ebx
adcl advancetable+4(,%ecx,4),%esi
addl tstep,%edx
jmp LEntry5_16
//----------------------------------------
Entry6_16:
subl $10,%edi // adjust for hardwired offsets
addl %eax,%edx
movb (%esi),%al
sbbl %ecx,%ecx
addl %ebp,%ebx
adcl advancetable+4(,%ecx,4),%esi
addl tstep,%edx
jmp LEntry6_16
//----------------------------------------
Entry7_16:
subl $9,%edi // adjust for hardwired offsets
addl %eax,%edx
movb (%esi),%al
sbbl %ecx,%ecx
addl %ebp,%ebx
adcl advancetable+4(,%ecx,4),%esi
addl tstep,%edx
jmp LEntry7_16
//----------------------------------------
Entry8_16:
subl $8,%edi // adjust for hardwired offsets
addl %eax,%edx
movb (%esi),%al
sbbl %ecx,%ecx
addl %ebp,%ebx
adcl advancetable+4(,%ecx,4),%esi
addl tstep,%edx
jmp LEntry8_16
//----------------------------------------
Entry9_16:
subl $7,%edi // adjust for hardwired offsets
addl %eax,%edx
movb (%esi),%al
sbbl %ecx,%ecx
addl %ebp,%ebx
adcl advancetable+4(,%ecx,4),%esi
addl tstep,%edx
jmp LEntry9_16
//----------------------------------------
Entry10_16:
subl $6,%edi // adjust for hardwired offsets
addl %eax,%edx
movb (%esi),%al
sbbl %ecx,%ecx
addl %ebp,%ebx
adcl advancetable+4(,%ecx,4),%esi
addl tstep,%edx
jmp LEntry10_16
//----------------------------------------
Entry11_16:
subl $5,%edi // adjust for hardwired offsets
addl %eax,%edx
movb (%esi),%al
sbbl %ecx,%ecx
addl %ebp,%ebx
adcl advancetable+4(,%ecx,4),%esi
addl tstep,%edx
jmp LEntry11_16
//----------------------------------------
Entry12_16:
subl $4,%edi // adjust for hardwired offsets
addl %eax,%edx
movb (%esi),%al
sbbl %ecx,%ecx
addl %ebp,%ebx
adcl advancetable+4(,%ecx,4),%esi
addl tstep,%edx
jmp LEntry12_16
//----------------------------------------
Entry13_16:
subl $3,%edi // adjust for hardwired offsets
addl %eax,%edx
movb (%esi),%al
sbbl %ecx,%ecx
addl %ebp,%ebx
adcl advancetable+4(,%ecx,4),%esi
addl tstep,%edx
jmp LEntry13_16
//----------------------------------------
Entry14_16:
subl $2,%edi // adjust for hardwired offsets
addl %eax,%edx
movb (%esi),%al
sbbl %ecx,%ecx
addl %ebp,%ebx
adcl advancetable+4(,%ecx,4),%esi
addl tstep,%edx
jmp LEntry14_16
//----------------------------------------
Entry15_16:
decl %edi // adjust for hardwired offsets
addl %eax,%edx
movb (%esi),%al
sbbl %ecx,%ecx
addl %ebp,%ebx
adcl advancetable+4(,%ecx,4),%esi
addl tstep,%edx
jmp LEntry15_16
//----------------------------------------
Entry16_16:
addl %eax,%edx
movb (%esi),%al
sbbl %ecx,%ecx
addl %ebp,%ebx
adcl advancetable+4(,%ecx,4),%esi
addl tstep,%edx
sbbl %ecx,%ecx
movb %al,1(%edi)
addl %ebp,%ebx
movb (%esi),%al
adcl advancetable+4(,%ecx,4),%esi
addl tstep,%edx
LEntry15_16:
sbbl %ecx,%ecx
movb %al,2(%edi)
addl %ebp,%ebx
movb (%esi),%al
adcl advancetable+4(,%ecx,4),%esi
addl tstep,%edx
LEntry14_16:
sbbl %ecx,%ecx
movb %al,3(%edi)
addl %ebp,%ebx
movb (%esi),%al
adcl advancetable+4(,%ecx,4),%esi
addl tstep,%edx
LEntry13_16:
sbbl %ecx,%ecx
movb %al,4(%edi)
addl %ebp,%ebx
movb (%esi),%al
adcl advancetable+4(,%ecx,4),%esi
addl tstep,%edx
LEntry12_16:
sbbl %ecx,%ecx
movb %al,5(%edi)
addl %ebp,%ebx
movb (%esi),%al
adcl advancetable+4(,%ecx,4),%esi
addl tstep,%edx
LEntry11_16:
sbbl %ecx,%ecx
movb %al,6(%edi)
addl %ebp,%ebx
movb (%esi),%al
adcl advancetable+4(,%ecx,4),%esi
addl tstep,%edx
LEntry10_16:
sbbl %ecx,%ecx
movb %al,7(%edi)
addl %ebp,%ebx
movb (%esi),%al
adcl advancetable+4(,%ecx,4),%esi
addl tstep,%edx
LEntry9_16:
sbbl %ecx,%ecx
movb %al,8(%edi)
addl %ebp,%ebx
movb (%esi),%al
adcl advancetable+4(,%ecx,4),%esi
addl tstep,%edx
LEntry8_16:
sbbl %ecx,%ecx
movb %al,9(%edi)
addl %ebp,%ebx
movb (%esi),%al
adcl advancetable+4(,%ecx,4),%esi
addl tstep,%edx
LEntry7_16:
sbbl %ecx,%ecx
movb %al,10(%edi)
addl %ebp,%ebx
movb (%esi),%al
adcl advancetable+4(,%ecx,4),%esi
addl tstep,%edx
LEntry6_16:
sbbl %ecx,%ecx
movb %al,11(%edi)
addl %ebp,%ebx
movb (%esi),%al
adcl advancetable+4(,%ecx,4),%esi
addl tstep,%edx
LEntry5_16:
sbbl %ecx,%ecx
movb %al,12(%edi)
addl %ebp,%ebx
movb (%esi),%al
adcl advancetable+4(,%ecx,4),%esi
addl tstep,%edx
LEntry4_16:
sbbl %ecx,%ecx
movb %al,13(%edi)
addl %ebp,%ebx
movb (%esi),%al
adcl advancetable+4(,%ecx,4),%esi
LEntry3_16:
movb %al,14(%edi)
movb (%esi),%al
LEntry2_16:
LEndSpan:
//
// clear s/z, t/z, 1/z from FP stack
//
fstp %st(0)
fstp %st(0)
fstp %st(0)
movl pspantemp,%ebx // restore spans pointer
movl espan_t_pnext(%ebx),%ebx // point to next span
testl %ebx,%ebx // any more spans?
movb %al,15(%edi)
jnz LSpanLoop // more spans
popl %ebx // restore register variables
popl %esi
popl %edi
popl %ebp // restore the caller's stack frame
ret
#endif // id386
#endif

484
asm/d_parta.s
View file

@ -1,484 +0,0 @@
/*
Copyright (C) 1996-1997 Id Software, Inc.
This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
See the GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*/
#ifndef NOASM
//
// d_parta.s
// x86 assembly-language 8-bpp particle-drawing code.
//
#include "asm_i386.h"
#include "asm.h"
#include "d_ifacea.h"
#include "asm_draw.h"
#if id386
//----------------------------------------------------------------------
// 8-bpp particle drawing code.
//----------------------------------------------------------------------
//FIXME: comments, full optimization
//----------------------------------------------------------------------
// 8-bpp particle queueing code.
//----------------------------------------------------------------------
.text
#define P 12+4
.align 4
.globl C(D_DrawParticle)
C(D_DrawParticle):
pushl %ebp // preserve caller's stack frame
pushl %edi // preserve register variables
pushl %ebx
movl P(%esp),%edi
// FIXME: better FP overlap in general here
// transform point
// VectorSubtract (p->org, r_origin, local);
flds C(r_origin)
fsubrs pt_org(%edi)
flds pt_org+4(%edi)
fsubs C(r_origin)+4
flds pt_org+8(%edi)
fsubs C(r_origin)+8
fxch %st(2) // local[0] | local[1] | local[2]
// transformed[2] = DotProduct(local, r_ppn);
flds C(r_ppn) // r_ppn[0] | local[0] | local[1] | local[2]
fmul %st(1),%st(0) // dot0 | local[0] | local[1] | local[2]
flds C(r_ppn)+4 // r_ppn[1] | dot0 | local[0] | local[1] | local[2]
fmul %st(3),%st(0) // dot1 | dot0 | local[0] | local[1] | local[2]
flds C(r_ppn)+8 // r_ppn[2] | dot1 | dot0 | local[0] |
// local[1] | local[2]
fmul %st(5),%st(0) // dot2 | dot1 | dot0 | local[0] | local[1] | local[2]
fxch %st(2) // dot0 | dot1 | dot2 | local[0] | local[1] | local[2]
faddp %st(0),%st(1) // dot0 + dot1 | dot2 | local[0] | local[1] |
// local[2]
faddp %st(0),%st(1) // z | local[0] | local[1] | local[2]
fld %st(0) // z | z | local[0] | local[1] |
// local[2]
fdivrs float_1 // 1/z | z | local[0] | local[1] | local[2]
fxch %st(1) // z | 1/z | local[0] | local[1] | local[2]
// if (transformed[2] < PARTICLE_Z_CLIP)
// return;
fcomps float_particle_z_clip // 1/z | local[0] | local[1] | local[2]
fxch %st(3) // local[2] | local[0] | local[1] | 1/z
flds C(r_pup) // r_pup[0] | local[2] | local[0] | local[1] | 1/z
fmul %st(2),%st(0) // dot0 | local[2] | local[0] | local[1] | 1/z
flds C(r_pup)+4 // r_pup[1] | dot0 | local[2] | local[0] |
// local[1] | 1/z
fnstsw %ax
testb $1,%ah
jnz LPop6AndDone
// transformed[1] = DotProduct(local, r_pup);
fmul %st(4),%st(0) // dot1 | dot0 | local[2] | local[0] | local[1] | 1/z
flds C(r_pup)+8 // r_pup[2] | dot1 | dot0 | local[2] |
// local[0] | local[1] | 1/z
fmul %st(3),%st(0) // dot2 | dot1 | dot0 | local[2] | local[0] |
// local[1] | 1/z
fxch %st(2) // dot0 | dot1 | dot2 | local[2] | local[0] |
// local[1] | 1/z
faddp %st(0),%st(1) // dot0 + dot1 | dot2 | local[2] | local[0] |
// local[1] | 1/z
faddp %st(0),%st(1) // y | local[2] | local[0] | local[1] | 1/z
fxch %st(3) // local[1] | local[2] | local[0] | y | 1/z
// transformed[0] = DotProduct(local, r_pright);
fmuls C(r_pright)+4 // dot1 | local[2] | local[0] | y | 1/z
fxch %st(2) // local[0] | local[2] | dot1 | y | 1/z
fmuls C(r_pright) // dot0 | local[2] | dot1 | y | 1/z
fxch %st(1) // local[2] | dot0 | dot1 | y | 1/z
fmuls C(r_pright)+8 // dot2 | dot0 | dot1 | y | 1/z
fxch %st(2) // dot1 | dot0 | dot2 | y | 1/z
faddp %st(0),%st(1) // dot1 + dot0 | dot2 | y | 1/z
faddp %st(0),%st(1) // x | y | 1/z
fxch %st(1) // y | x | 1/z
// project the point
fmul %st(2),%st(0) // y/z | x | 1/z
fxch %st(1) // x | y/z | 1/z
fmul %st(2),%st(0) // x/z | y/z | 1/z
fxch %st(1) // y/z | x/z | 1/z
fsubrs C(ycenter) // v | x/z | 1/z
fxch %st(1) // x/z | v | 1/z
fadds C(xcenter) // u | v | 1/z
// FIXME: preadjust xcenter and ycenter
fxch %st(1) // v | u | 1/z
fadds float_point5 // v | u | 1/z
fxch %st(1) // u | v | 1/z
fadds float_point5 // u | v | 1/z
fxch %st(2) // 1/z | v | u
fmuls DP_32768 // 1/z * 0x8000 | v | u
fxch %st(2) // u | v | 1/z * 0x8000
// FIXME: use Terje's fp->int trick here?
// FIXME: check we're getting proper rounding here
fistpl DP_u // v | 1/z * 0x8000
fistpl DP_v // 1/z * 0x8000
movl DP_u,%eax
movl DP_v,%edx
// if ((v > d_vrectbottom_particle) ||
// (u > d_vrectright_particle) ||
// (v < d_vrecty) ||
// (u < d_vrectx))
// {
// continue;
// }
movl C(d_vrectbottom_particle),%ebx
movl C(d_vrectright_particle),%ecx
cmpl %ebx,%edx
jg LPop1AndDone
cmpl %ecx,%eax
jg LPop1AndDone
movl C(d_vrecty),%ebx
movl C(d_vrectx),%ecx
cmpl %ebx,%edx
jl LPop1AndDone
cmpl %ecx,%eax
jl LPop1AndDone
flds pt_color(%edi) // color | 1/z * 0x8000
// FIXME: use Terje's fast fp->int trick?
fistpl DP_Color // 1/z * 0x8000
movl C(d_viewbuffer),%ebx
addl %eax,%ebx
movl C(d_scantable)(,%edx,4),%edi // point to the pixel
imull C(d_zrowbytes),%edx // point to the z pixel
leal (%edx,%eax,2),%edx
movl C(d_pzbuffer),%eax
fistpl izi
addl %ebx,%edi
addl %eax,%edx
// pix = izi >> d_pix_shift;
movl izi,%eax
movl C(d_pix_shift),%ecx
shrl %cl,%eax
movl izi,%ebp
// if (pix < d_pix_min)
// pix = d_pix_min;
// else if (pix > d_pix_max)
// pix = d_pix_max;
movl C(d_pix_min),%ebx
movl C(d_pix_max),%ecx
cmpl %ebx,%eax
jnl LTestPixMax
movl %ebx,%eax
jmp LTestDone
LTestPixMax:
cmpl %ecx,%eax
jng LTestDone
movl %ecx,%eax
LTestDone:
movb DP_Color,%ch
movl C(d_y_aspect_shift),%ebx
testl %ebx,%ebx
jnz LDefault
cmpl $4,%eax
ja LDefault
// 2000-07-30 DJGPP compiler warning fix by Norberto Alfredo Bensa start
// jmp DP_EntryTable-4(,%eax,4)
jmp *DP_EntryTable-4(,%eax,4)
// 2000-07-30 DJGPP compiler warning fix by Norberto Alfredo Bensa end
// 1x1
.globl DP_1x1
DP_1x1:
cmpw %bp,(%edx) // just one pixel to do
jg LDone
movw %bp,(%edx)
movb %ch,(%edi)
jmp LDone
// 2x2
.globl DP_2x2
DP_2x2:
pushl %esi
movl C(screenwidth),%ebx
movl C(d_zrowbytes),%esi
cmpw %bp,(%edx)
jg L2x2_1
movw %bp,(%edx)
movb %ch,(%edi)
L2x2_1:
cmpw %bp,2(%edx)
jg L2x2_2
movw %bp,2(%edx)
movb %ch,1(%edi)
L2x2_2:
cmpw %bp,(%edx,%esi,1)
jg L2x2_3
movw %bp,(%edx,%esi,1)
movb %ch,(%edi,%ebx,1)
L2x2_3:
cmpw %bp,2(%edx,%esi,1)
jg L2x2_4
movw %bp,2(%edx,%esi,1)
movb %ch,1(%edi,%ebx,1)
L2x2_4:
popl %esi
jmp LDone
// 3x3
.globl DP_3x3
DP_3x3:
pushl %esi
movl C(screenwidth),%ebx
movl C(d_zrowbytes),%esi
cmpw %bp,(%edx)
jg L3x3_1
movw %bp,(%edx)
movb %ch,(%edi)
L3x3_1:
cmpw %bp,2(%edx)
jg L3x3_2
movw %bp,2(%edx)
movb %ch,1(%edi)
L3x3_2:
cmpw %bp,4(%edx)
jg L3x3_3
movw %bp,4(%edx)
movb %ch,2(%edi)
L3x3_3:
cmpw %bp,(%edx,%esi,1)
jg L3x3_4
movw %bp,(%edx,%esi,1)
movb %ch,(%edi,%ebx,1)
L3x3_4:
cmpw %bp,2(%edx,%esi,1)
jg L3x3_5
movw %bp,2(%edx,%esi,1)
movb %ch,1(%edi,%ebx,1)
L3x3_5:
cmpw %bp,4(%edx,%esi,1)
jg L3x3_6
movw %bp,4(%edx,%esi,1)
movb %ch,2(%edi,%ebx,1)
L3x3_6:
cmpw %bp,(%edx,%esi,2)
jg L3x3_7
movw %bp,(%edx,%esi,2)
movb %ch,(%edi,%ebx,2)
L3x3_7:
cmpw %bp,2(%edx,%esi,2)
jg L3x3_8
movw %bp,2(%edx,%esi,2)
movb %ch,1(%edi,%ebx,2)
L3x3_8:
cmpw %bp,4(%edx,%esi,2)
jg L3x3_9
movw %bp,4(%edx,%esi,2)
movb %ch,2(%edi,%ebx,2)
L3x3_9:
popl %esi
jmp LDone
// 4x4
.globl DP_4x4
DP_4x4:
pushl %esi
movl C(screenwidth),%ebx
movl C(d_zrowbytes),%esi
cmpw %bp,(%edx)
jg L4x4_1
movw %bp,(%edx)
movb %ch,(%edi)
L4x4_1:
cmpw %bp,2(%edx)
jg L4x4_2
movw %bp,2(%edx)
movb %ch,1(%edi)
L4x4_2:
cmpw %bp,4(%edx)
jg L4x4_3
movw %bp,4(%edx)
movb %ch,2(%edi)
L4x4_3:
cmpw %bp,6(%edx)
jg L4x4_4
movw %bp,6(%edx)
movb %ch,3(%edi)
L4x4_4:
cmpw %bp,(%edx,%esi,1)
jg L4x4_5
movw %bp,(%edx,%esi,1)
movb %ch,(%edi,%ebx,1)
L4x4_5:
cmpw %bp,2(%edx,%esi,1)
jg L4x4_6
movw %bp,2(%edx,%esi,1)
movb %ch,1(%edi,%ebx,1)
L4x4_6:
cmpw %bp,4(%edx,%esi,1)
jg L4x4_7
movw %bp,4(%edx,%esi,1)
movb %ch,2(%edi,%ebx,1)
L4x4_7:
cmpw %bp,6(%edx,%esi,1)
jg L4x4_8
movw %bp,6(%edx,%esi,1)
movb %ch,3(%edi,%ebx,1)
L4x4_8:
leal (%edx,%esi,2),%edx
leal (%edi,%ebx,2),%edi
cmpw %bp,(%edx)
jg L4x4_9
movw %bp,(%edx)
movb %ch,(%edi)
L4x4_9:
cmpw %bp,2(%edx)
jg L4x4_10
movw %bp,2(%edx)
movb %ch,1(%edi)
L4x4_10:
cmpw %bp,4(%edx)
jg L4x4_11
movw %bp,4(%edx)
movb %ch,2(%edi)
L4x4_11:
cmpw %bp,6(%edx)
jg L4x4_12
movw %bp,6(%edx)
movb %ch,3(%edi)
L4x4_12:
cmpw %bp,(%edx,%esi,1)
jg L4x4_13
movw %bp,(%edx,%esi,1)
movb %ch,(%edi,%ebx,1)
L4x4_13:
cmpw %bp,2(%edx,%esi,1)
jg L4x4_14
movw %bp,2(%edx,%esi,1)
movb %ch,1(%edi,%ebx,1)
L4x4_14:
cmpw %bp,4(%edx,%esi,1)
jg L4x4_15
movw %bp,4(%edx,%esi,1)
movb %ch,2(%edi,%ebx,1)
L4x4_15:
cmpw %bp,6(%edx,%esi,1)
jg L4x4_16
movw %bp,6(%edx,%esi,1)
movb %ch,3(%edi,%ebx,1)
L4x4_16:
popl %esi
jmp LDone
// default case, handling any size particle
LDefault:
// count = pix << d_y_aspect_shift;
movl %eax,%ebx
movl %eax,DP_Pix
movb C(d_y_aspect_shift),%cl
shll %cl,%ebx
// for ( ; count ; count--, pz += d_zwidth, pdest += screenwidth)
// {
// for (i=0 ; i<pix ; i++)
// {
// if (pz[i] <= izi)
// {
// pz[i] = izi;
// pdest[i] = color;
// }
// }
// }
LGenRowLoop:
movl DP_Pix,%eax
LGenColLoop:
cmpw %bp,-2(%edx,%eax,2)
jg LGSkip
movw %bp,-2(%edx,%eax,2)
movb %ch,-1(%edi,%eax,1)
LGSkip:
decl %eax // --pix
jnz LGenColLoop
addl C(d_zrowbytes),%edx
addl C(screenwidth),%edi
decl %ebx // --count
jnz LGenRowLoop
LDone:
popl %ebx // restore register variables
popl %edi
popl %ebp // restore the caller's stack frame
ret
LPop6AndDone:
fstp %st(0)
fstp %st(0)
fstp %st(0)
fstp %st(0)
fstp %st(0)
LPop1AndDone:
fstp %st(0)
jmp LDone
#endif // id386
#endif

1749
asm/d_polysa.s
View file

File diff suppressed because it is too large Load diff

98
asm/d_scana.s
View file

@ -1,98 +0,0 @@
/*
Copyright (C) 1996-1997 Id Software, Inc.
This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
See the GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*/
//
// d_scana.s
// x86 assembly-language turbulent texture mapping code
//
#ifndef NOASM
#include "asm_i386.h"
#include "asm.h"
#include "asm_draw.h"
#include "d_ifacea.h"
#if id386
.data
.text
//----------------------------------------------------------------------
// turbulent texture mapping code
//----------------------------------------------------------------------
.align 4
.globl C(D_DrawTurbulent8Span)
C(D_DrawTurbulent8Span):
pushl %ebp // preserve caller's stack frame pointer
pushl %esi // preserve register variables
pushl %edi
pushl %ebx
movl C(r_turb_s),%esi
movl C(r_turb_t),%ecx
movl C(r_turb_pdest),%edi
movl C(r_turb_spancount),%ebx
Llp:
movl %ecx,%eax
movl %esi,%edx
sarl $16,%eax
movl C(r_turb_turb),%ebp
sarl $16,%edx
andl $(CYCLE-1),%eax
andl $(CYCLE-1),%edx
movl (%ebp,%eax,4),%eax
movl (%ebp,%edx,4),%edx
addl %esi,%eax
sarl $16,%eax
addl %ecx,%edx
sarl $16,%edx
andl $(TURB_TEX_SIZE-1),%eax
andl $(TURB_TEX_SIZE-1),%edx
shll $6,%edx
movl C(r_turb_pbase),%ebp
addl %eax,%edx
incl %edi
addl C(r_turb_sstep),%esi
addl C(r_turb_tstep),%ecx
movb (%ebp,%edx,1),%dl
decl %ebx
movb %dl,-1(%edi)
jnz Llp
movl %edi,C(r_turb_pdest)
popl %ebx // restore register variables
popl %edi
popl %esi
popl %ebp // restore caller's stack frame pointer
ret
#endif // id386
#endif

902
asm/d_spr8.s
View file

@ -1,902 +0,0 @@
/*
Copyright (C) 1996-1997 Id Software, Inc.
This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
See the GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*/
//
// d_spr8.s
// x86 assembly-language horizontal 8-bpp transparent span-drawing code.
//
#ifndef NOASM
#include "asm_i386.h"
#include "asm.h"
#include "asm_draw.h"
#if id386
//----------------------------------------------------------------------
// 8-bpp horizontal span drawing code for polygons, with transparency.
//----------------------------------------------------------------------
.text
// out-of-line, rarely-needed clamping code
LClampHigh0:
movl C(bbextents),%esi
jmp LClampReentry0
LClampHighOrLow0:
jg LClampHigh0
xorl %esi,%esi
jmp LClampReentry0
LClampHigh1:
movl C(bbextentt),%edx
jmp LClampReentry1
LClampHighOrLow1:
jg LClampHigh1
xorl %edx,%edx
jmp LClampReentry1
LClampLow2:
movl $2048,%ebp
jmp LClampReentry2
LClampHigh2:
movl C(bbextents),%ebp
jmp LClampReentry2
LClampLow3:
movl $2048,%ecx
jmp LClampReentry3
LClampHigh3:
movl C(bbextentt),%ecx
jmp LClampReentry3
LClampLow4:
movl $2048,%eax
jmp LClampReentry4
LClampHigh4:
movl C(bbextents),%eax
jmp LClampReentry4
LClampLow5:
movl $2048,%ebx
jmp LClampReentry5
LClampHigh5:
movl C(bbextentt),%ebx
jmp LClampReentry5
#define pspans 4+16
.align 4
.globl C(D_SpriteDrawSpans)
C(D_SpriteDrawSpans):
pushl %ebp // preserve caller's stack frame
pushl %edi
pushl %esi // preserve register variables
pushl %ebx
//
// set up scaled-by-8 steps, for 8-long segments; also set up cacheblock
// and span list pointers, and 1/z step in 0.32 fixed-point
//
// FIXME: any overlap from rearranging?
flds C(d_sdivzstepu)
fmuls fp_8
movl C(cacheblock),%edx
flds C(d_tdivzstepu)
fmuls fp_8
movl pspans(%esp),%ebx // point to the first span descriptor
flds C(d_zistepu)
fmuls fp_8
movl %edx,pbase // pbase = cacheblock
flds C(d_zistepu)
fmuls fp_64kx64k
fxch %st(3)
fstps sdivz8stepu
fstps zi8stepu
fstps tdivz8stepu
fistpl izistep
movl izistep,%eax
rorl $16,%eax // put upper 16 bits in low word
movl sspan_t_count(%ebx),%ecx
movl %eax,izistep
cmpl $0,%ecx
jle LNextSpan
LSpanLoop:
//
// set up the initial s/z, t/z, and 1/z on the FP stack, and generate the
// initial s and t values
//
// FIXME: pipeline FILD?
fildl sspan_t_v(%ebx)
fildl sspan_t_u(%ebx)
fld %st(1) // dv | du | dv
fmuls C(d_sdivzstepv) // dv*d_sdivzstepv | du | dv
fld %st(1) // du | dv*d_sdivzstepv | du | dv
fmuls C(d_sdivzstepu) // du*d_sdivzstepu | dv*d_sdivzstepv | du | dv
fld %st(2) // du | du*d_sdivzstepu | dv*d_sdivzstepv | du | dv
fmuls C(d_tdivzstepu) // du*d_tdivzstepu | du*d_sdivzstepu |
// dv*d_sdivzstepv | du | dv
fxch %st(1) // du*d_sdivzstepu | du*d_tdivzstepu |
// dv*d_sdivzstepv | du | dv
faddp %st(0),%st(2) // du*d_tdivzstepu |
// du*d_sdivzstepu + dv*d_sdivzstepv | du | dv
fxch %st(1) // du*d_sdivzstepu + dv*d_sdivzstepv |
// du*d_tdivzstepu | du | dv
fld %st(3) // dv | du*d_sdivzstepu + dv*d_sdivzstepv |
// du*d_tdivzstepu | du | dv
fmuls C(d_tdivzstepv) // dv*d_tdivzstepv |
// du*d_sdivzstepu + dv*d_sdivzstepv |
// du*d_tdivzstepu | du | dv
fxch %st(1) // du*d_sdivzstepu + dv*d_sdivzstepv |
// dv*d_tdivzstepv | du*d_tdivzstepu | du | dv
fadds C(d_sdivzorigin) // sdivz = d_sdivzorigin + dv*d_sdivzstepv +
// du*d_sdivzstepu; stays in %st(2) at end
fxch %st(4) // dv | dv*d_tdivzstepv | du*d_tdivzstepu | du |
// s/z
fmuls C(d_zistepv) // dv*d_zistepv | dv*d_tdivzstepv |
// du*d_tdivzstepu | du | s/z
fxch %st(1) // dv*d_tdivzstepv | dv*d_zistepv |
// du*d_tdivzstepu | du | s/z
faddp %st(0),%st(2) // dv*d_zistepv |
// dv*d_tdivzstepv + du*d_tdivzstepu | du | s/z
fxch %st(2) // du | dv*d_tdivzstepv + du*d_tdivzstepu |
// dv*d_zistepv | s/z
fmuls C(d_zistepu) // du*d_zistepu |
// dv*d_tdivzstepv + du*d_tdivzstepu |
// dv*d_zistepv | s/z
fxch %st(1) // dv*d_tdivzstepv + du*d_tdivzstepu |
// du*d_zistepu | dv*d_zistepv | s/z
fadds C(d_tdivzorigin) // tdivz = d_tdivzorigin + dv*d_tdivzstepv +
// du*d_tdivzstepu; stays in %st(1) at end
fxch %st(2) // dv*d_zistepv | du*d_zistepu | t/z | s/z
faddp %st(0),%st(1) // dv*d_zistepv + du*d_zistepu | t/z | s/z
flds fp_64k // fp_64k | dv*d_zistepv + du*d_zistepu | t/z | s/z
fxch %st(1) // dv*d_zistepv + du*d_zistepu | fp_64k | t/z | s/z
fadds C(d_ziorigin) // zi = d_ziorigin + dv*d_zistepv +
// du*d_zistepu; stays in %st(0) at end
// 1/z | fp_64k | t/z | s/z
fld %st(0) // FIXME: get rid of stall on FMUL?
fmuls fp_64kx64k
fxch %st(1)
//
// calculate and clamp s & t
//
fdivr %st(0),%st(2) // 1/z | z*64k | t/z | s/z
fxch %st(1)
fistpl izi // 0.32 fixed-point 1/z
movl izi,%ebp
//
// set pz to point to the first z-buffer pixel in the span
//
rorl $16,%ebp // put upper 16 bits in low word
movl sspan_t_v(%ebx),%eax
movl %ebp,izi
movl sspan_t_u(%ebx),%ebp
imull C(d_zrowbytes)
shll $1,%ebp // a word per pixel
addl C(d_pzbuffer),%eax
addl %ebp,%eax
movl %eax,pz
//
// point %edi to the first pixel in the span
//
movl C(d_viewbuffer),%ebp
movl sspan_t_v(%ebx),%eax
pushl %ebx // preserve spans pointer
movl C(tadjust),%edx
movl C(sadjust),%esi
movl C(d_scantable)(,%eax,4),%edi // v * screenwidth
addl %ebp,%edi
movl sspan_t_u(%ebx),%ebp
addl %ebp,%edi // pdest = &pdestspan[scans->u];
//
// now start the FDIV for the end of the span
//
cmpl $8,%ecx
ja LSetupNotLast1
decl %ecx
jz LCleanup1 // if only one pixel, no need to start an FDIV
movl %ecx,spancountminus1
// finish up the s and t calcs
fxch %st(1) // z*64k | 1/z | t/z | s/z
fld %st(0) // z*64k | z*64k | 1/z | t/z | s/z
fmul %st(4),%st(0) // s | z*64k | 1/z | t/z | s/z
fxch %st(1) // z*64k | s | 1/z | t/z | s/z
fmul %st(3),%st(0) // t | s | 1/z | t/z | s/z
fxch %st(1) // s | t | 1/z | t/z | s/z
fistpl s // 1/z | t | t/z | s/z
fistpl t // 1/z | t/z | s/z
fildl spancountminus1
flds C(d_tdivzstepu) // _d_tdivzstepu | spancountminus1
flds C(d_zistepu) // _d_zistepu | _d_tdivzstepu | spancountminus1
fmul %st(2),%st(0) // _d_zistepu*scm1 | _d_tdivzstepu | scm1
fxch %st(1) // _d_tdivzstepu | _d_zistepu*scm1 | scm1
fmul %st(2),%st(0) // _d_tdivzstepu*scm1 | _d_zistepu*scm1 | scm1
fxch %st(2) // scm1 | _d_zistepu*scm1 | _d_tdivzstepu*scm1
fmuls C(d_sdivzstepu) // _d_sdivzstepu*scm1 | _d_zistepu*scm1 |
// _d_tdivzstepu*scm1
fxch %st(1) // _d_zistepu*scm1 | _d_sdivzstepu*scm1 |
// _d_tdivzstepu*scm1
faddp %st(0),%st(3) // _d_sdivzstepu*scm1 | _d_tdivzstepu*scm1
fxch %st(1) // _d_tdivzstepu*scm1 | _d_sdivzstepu*scm1
faddp %st(0),%st(3) // _d_sdivzstepu*scm1
faddp %st(0),%st(3)
flds fp_64k
fdiv %st(1),%st(0) // this is what we've gone to all this trouble to
// overlap
jmp LFDIVInFlight1
LCleanup1:
// finish up the s and t calcs
fxch %st(1) // z*64k | 1/z | t/z | s/z
fld %st(0) // z*64k | z*64k | 1/z | t/z | s/z
fmul %st(4),%st(0) // s | z*64k | 1/z | t/z | s/z
fxch %st(1) // z*64k | s | 1/z | t/z | s/z
fmul %st(3),%st(0) // t | s | 1/z | t/z | s/z
fxch %st(1) // s | t | 1/z | t/z | s/z
fistpl s // 1/z | t | t/z | s/z
fistpl t // 1/z | t/z | s/z
jmp LFDIVInFlight1
.align 4
LSetupNotLast1:
// finish up the s and t calcs
fxch %st(1) // z*64k | 1/z | t/z | s/z
fld %st(0) // z*64k | z*64k | 1/z | t/z | s/z
fmul %st(4),%st(0) // s | z*64k | 1/z | t/z | s/z
fxch %st(1) // z*64k | s | 1/z | t/z | s/z
fmul %st(3),%st(0) // t | s | 1/z | t/z | s/z
fxch %st(1) // s | t | 1/z | t/z | s/z
fistpl s // 1/z | t | t/z | s/z
fistpl t // 1/z | t/z | s/z
fadds zi8stepu
fxch %st(2)
fadds sdivz8stepu
fxch %st(2)
flds tdivz8stepu
faddp %st(0),%st(2)
flds fp_64k
fdiv %st(1),%st(0) // z = 1/1/z
// this is what we've gone to all this trouble to
// overlap
LFDIVInFlight1:
addl s,%esi
addl t,%edx
movl C(bbextents),%ebx
movl C(bbextentt),%ebp
cmpl %ebx,%esi
ja LClampHighOrLow0
LClampReentry0:
movl %esi,s
movl pbase,%ebx
shll $16,%esi
cmpl %ebp,%edx
movl %esi,sfracf
ja LClampHighOrLow1
LClampReentry1:
movl %edx,t
movl s,%esi // sfrac = scans->sfrac;
shll $16,%edx
movl t,%eax // tfrac = scans->tfrac;
sarl $16,%esi
movl %edx,tfracf
//
// calculate the texture starting address
//
sarl $16,%eax
addl %ebx,%esi
imull C(cachewidth),%eax // (tfrac >> 16) * cachewidth
addl %eax,%esi // psource = pbase + (sfrac >> 16) +
// ((tfrac >> 16) * cachewidth);
//
// determine whether last span or not
//
cmpl $8,%ecx
jna LLastSegment
//
// not the last segment; do full 8-wide segment
//
LNotLastSegment:
//
// advance s/z, t/z, and 1/z, and calculate s & t at end of span and steps to
// get there
//
// pick up after the FDIV that was left in flight previously
fld %st(0) // duplicate it
fmul %st(4),%st(0) // s = s/z * z
fxch %st(1)
fmul %st(3),%st(0) // t = t/z * z
fxch %st(1)
fistpl snext
fistpl tnext
movl snext,%eax
movl tnext,%edx
subl $8,%ecx // count off this segments' pixels
movl C(sadjust),%ebp
pushl %ecx // remember count of remaining pixels
movl C(tadjust),%ecx
addl %eax,%ebp
addl %edx,%ecx
movl C(bbextents),%eax
movl C(bbextentt),%edx
cmpl $2048,%ebp
jl LClampLow2
cmpl %eax,%ebp
ja LClampHigh2
LClampReentry2:
cmpl $2048,%ecx
jl LClampLow3
cmpl %edx,%ecx
ja LClampHigh3
LClampReentry3:
movl %ebp,snext
movl %ecx,tnext
subl s,%ebp
subl t,%ecx
//
// set up advancetable
//
movl %ecx,%eax
movl %ebp,%edx
sarl $19,%edx // sstep >>= 16;
movl C(cachewidth),%ebx
sarl $19,%eax // tstep >>= 16;
jz LIsZero
imull %ebx,%eax // (tstep >> 16) * cachewidth;
LIsZero:
addl %edx,%eax // add in sstep
// (tstep >> 16) * cachewidth + (sstep >> 16);
movl tfracf,%edx
movl %eax,advancetable+4 // advance base in t
addl %ebx,%eax // ((tstep >> 16) + 1) * cachewidth +
// (sstep >> 16);
shll $13,%ebp // left-justify sstep fractional part
movl %ebp,sstep
movl sfracf,%ebx
shll $13,%ecx // left-justify tstep fractional part
movl %eax,advancetable // advance extra in t
movl %ecx,tstep
movl pz,%ecx
movl izi,%ebp
cmpw (%ecx),%bp
jl Lp1
movb (%esi),%al // get first source texel
cmpb $(TRANSPARENT_COLOR),%al
jz Lp1
movw %bp,(%ecx)
movb %al,(%edi) // store first dest pixel
Lp1:
addl izistep,%ebp
adcl $0,%ebp
addl tstep,%edx // advance tfrac fractional part by tstep frac
sbbl %eax,%eax // turn tstep carry into -1 (0 if none)
addl sstep,%ebx // advance sfrac fractional part by sstep frac
adcl advancetable+4(,%eax,4),%esi // point to next source texel
cmpw 2(%ecx),%bp
jl Lp2
movb (%esi),%al
cmpb $(TRANSPARENT_COLOR),%al
jz Lp2
movw %bp,2(%ecx)
movb %al,1(%edi)
Lp2:
addl izistep,%ebp
adcl $0,%ebp
addl tstep,%edx
sbbl %eax,%eax
addl sstep,%ebx
adcl advancetable+4(,%eax,4),%esi
cmpw 4(%ecx),%bp
jl Lp3
movb (%esi),%al
cmpb $(TRANSPARENT_COLOR),%al
jz Lp3
movw %bp,4(%ecx)
movb %al,2(%edi)
Lp3:
addl izistep,%ebp
adcl $0,%ebp
addl tstep,%edx
sbbl %eax,%eax
addl sstep,%ebx
adcl advancetable+4(,%eax,4),%esi
cmpw 6(%ecx),%bp
jl Lp4
movb (%esi),%al
cmpb $(TRANSPARENT_COLOR),%al
jz Lp4
movw %bp,6(%ecx)
movb %al,3(%edi)
Lp4:
addl izistep,%ebp
adcl $0,%ebp
addl tstep,%edx
sbbl %eax,%eax
addl sstep,%ebx
adcl advancetable+4(,%eax,4),%esi
cmpw 8(%ecx),%bp
jl Lp5
movb (%esi),%al
cmpb $(TRANSPARENT_COLOR),%al
jz Lp5
movw %bp,8(%ecx)
movb %al,4(%edi)
Lp5:
addl izistep,%ebp
adcl $0,%ebp
addl tstep,%edx
sbbl %eax,%eax
addl sstep,%ebx
adcl advancetable+4(,%eax,4),%esi
//
// start FDIV for end of next segment in flight, so it can overlap
//
popl %eax
cmpl $8,%eax // more than one segment after this?
ja LSetupNotLast2 // yes
decl %eax
jz LFDIVInFlight2 // if only one pixel, no need to start an FDIV
movl %eax,spancountminus1
fildl spancountminus1
flds C(d_zistepu) // _d_zistepu | spancountminus1
fmul %st(1),%st(0) // _d_zistepu*scm1 | scm1
flds C(d_tdivzstepu) // _d_tdivzstepu | _d_zistepu*scm1 | scm1
fmul %st(2),%st(0) // _d_tdivzstepu*scm1 | _d_zistepu*scm1 | scm1
fxch %st(1) // _d_zistepu*scm1 | _d_tdivzstepu*scm1 | scm1
faddp %st(0),%st(3) // _d_tdivzstepu*scm1 | scm1
fxch %st(1) // scm1 | _d_tdivzstepu*scm1
fmuls C(d_sdivzstepu) // _d_sdivzstepu*scm1 | _d_tdivzstepu*scm1
fxch %st(1) // _d_tdivzstepu*scm1 | _d_sdivzstepu*scm1
faddp %st(0),%st(3) // _d_sdivzstepu*scm1
flds fp_64k // 64k | _d_sdivzstepu*scm1
fxch %st(1) // _d_sdivzstepu*scm1 | 64k
faddp %st(0),%st(4) // 64k
fdiv %st(1),%st(0) // this is what we've gone to all this trouble to
// overlap
jmp LFDIVInFlight2
.align 4
LSetupNotLast2:
fadds zi8stepu
fxch %st(2)
fadds sdivz8stepu
fxch %st(2)
flds tdivz8stepu
faddp %st(0),%st(2)
flds fp_64k
fdiv %st(1),%st(0) // z = 1/1/z
// this is what we've gone to all this trouble to
// overlap
LFDIVInFlight2:
pushl %eax
cmpw 10(%ecx),%bp
jl Lp6
movb (%esi),%al
cmpb $(TRANSPARENT_COLOR),%al
jz Lp6
movw %bp,10(%ecx)
movb %al,5(%edi)
Lp6:
addl izistep,%ebp
adcl $0,%ebp
addl tstep,%edx
sbbl %eax,%eax
addl sstep,%ebx
adcl advancetable+4(,%eax,4),%esi
cmpw 12(%ecx),%bp
jl Lp7
movb (%esi),%al
cmpb $(TRANSPARENT_COLOR),%al
jz Lp7
movw %bp,12(%ecx)
movb %al,6(%edi)
Lp7:
addl izistep,%ebp
adcl $0,%ebp
addl tstep,%edx
sbbl %eax,%eax
addl sstep,%ebx
adcl advancetable+4(,%eax,4),%esi
cmpw 14(%ecx),%bp
jl Lp8
movb (%esi),%al
cmpb $(TRANSPARENT_COLOR),%al
jz Lp8
movw %bp,14(%ecx)
movb %al,7(%edi)
Lp8:
addl izistep,%ebp
adcl $0,%ebp
addl tstep,%edx
sbbl %eax,%eax
addl sstep,%ebx
adcl advancetable+4(,%eax,4),%esi
addl $8,%edi
addl $16,%ecx
movl %edx,tfracf
movl snext,%edx
movl %ebx,sfracf
movl tnext,%ebx
movl %edx,s
movl %ebx,t
movl %ecx,pz
movl %ebp,izi
popl %ecx // retrieve count
//
// determine whether last span or not
//
cmpl $8,%ecx // are there multiple segments remaining?
ja LNotLastSegment // yes
//
// last segment of scan
//
LLastSegment:
//
// advance s/z, t/z, and 1/z, and calculate s & t at end of span and steps to
// get there. The number of pixels left is variable, and we want to land on the
// last pixel, not step one past it, so we can't run into arithmetic problems
//
testl %ecx,%ecx
jz LNoSteps // just draw the last pixel and we're done
// pick up after the FDIV that was left in flight previously
fld %st(0) // duplicate it
fmul %st(4),%st(0) // s = s/z * z
fxch %st(1)
fmul %st(3),%st(0) // t = t/z * z
fxch %st(1)
fistpl snext
fistpl tnext
movl C(tadjust),%ebx
movl C(sadjust),%eax
addl snext,%eax
addl tnext,%ebx
movl C(bbextents),%ebp
movl C(bbextentt),%edx
cmpl $2048,%eax
jl LClampLow4
cmpl %ebp,%eax
ja LClampHigh4
LClampReentry4:
movl %eax,snext
cmpl $2048,%ebx
jl LClampLow5
cmpl %edx,%ebx
ja LClampHigh5
LClampReentry5:
cmpl $1,%ecx // don't bother
je LOnlyOneStep // if two pixels in segment, there's only one step,
// of the segment length
subl s,%eax
subl t,%ebx
addl %eax,%eax // convert to 15.17 format so multiply by 1.31
addl %ebx,%ebx // reciprocal yields 16.48
imull reciprocal_table-8(,%ecx,4) // sstep = (snext - s) / (spancount-1)
movl %edx,%ebp
movl %ebx,%eax
imull reciprocal_table-8(,%ecx,4) // tstep = (tnext - t) / (spancount-1)
LSetEntryvec:
//
// set up advancetable
//
movl spr8entryvec_table(,%ecx,4),%ebx
movl %edx,%eax
pushl %ebx // entry point into code for RET later
movl %ebp,%ecx
sarl $16,%ecx // sstep >>= 16;
movl C(cachewidth),%ebx
sarl $16,%edx // tstep >>= 16;
jz LIsZeroLast
imull %ebx,%edx // (tstep >> 16) * cachewidth;
LIsZeroLast:
addl %ecx,%edx // add in sstep
// (tstep >> 16) * cachewidth + (sstep >> 16);
movl tfracf,%ecx
movl %edx,advancetable+4 // advance base in t
addl %ebx,%edx // ((tstep >> 16) + 1) * cachewidth +
// (sstep >> 16);
shll $16,%ebp // left-justify sstep fractional part
movl sfracf,%ebx
shll $16,%eax // left-justify tstep fractional part
movl %edx,advancetable // advance extra in t
movl %eax,tstep
movl %ebp,sstep
movl %ecx,%edx
movl pz,%ecx
movl izi,%ebp
ret // jump to the number-of-pixels handler
//----------------------------------------
LNoSteps:
movl pz,%ecx
subl $7,%edi // adjust for hardwired offset
subl $14,%ecx
jmp LEndSpan
LOnlyOneStep:
subl s,%eax
subl t,%ebx
movl %eax,%ebp
movl %ebx,%edx
jmp LSetEntryvec
//----------------------------------------
.globl Spr8Entry2_8
Spr8Entry2_8:
subl $6,%edi // adjust for hardwired offsets
subl $12,%ecx
movb (%esi),%al
jmp LLEntry2_8
//----------------------------------------
.globl Spr8Entry3_8
Spr8Entry3_8:
subl $5,%edi // adjust for hardwired offsets
subl $10,%ecx
jmp LLEntry3_8
//----------------------------------------
.globl Spr8Entry4_8
Spr8Entry4_8:
subl $4,%edi // adjust for hardwired offsets
subl $8,%ecx
jmp LLEntry4_8
//----------------------------------------
.globl Spr8Entry5_8
Spr8Entry5_8:
subl $3,%edi // adjust for hardwired offsets
subl $6,%ecx
jmp LLEntry5_8
//----------------------------------------
.globl Spr8Entry6_8
Spr8Entry6_8:
subl $2,%edi // adjust for hardwired offsets
subl $4,%ecx
jmp LLEntry6_8
//----------------------------------------
.globl Spr8Entry7_8
Spr8Entry7_8:
decl %edi // adjust for hardwired offsets
subl $2,%ecx
jmp LLEntry7_8
//----------------------------------------
.globl Spr8Entry8_8
Spr8Entry8_8:
cmpw (%ecx),%bp
jl Lp9
movb (%esi),%al
cmpb $(TRANSPARENT_COLOR),%al
jz Lp9
movw %bp,(%ecx)
movb %al,(%edi)
Lp9:
addl izistep,%ebp
adcl $0,%ebp
addl tstep,%edx
sbbl %eax,%eax
addl sstep,%ebx
adcl advancetable+4(,%eax,4),%esi
LLEntry7_8:
cmpw 2(%ecx),%bp
jl Lp10
movb (%esi),%al
cmpb $(TRANSPARENT_COLOR),%al
jz Lp10
movw %bp,2(%ecx)
movb %al,1(%edi)
Lp10:
addl izistep,%ebp
adcl $0,%ebp
addl tstep,%edx
sbbl %eax,%eax
addl sstep,%ebx
adcl advancetable+4(,%eax,4),%esi
LLEntry6_8:
cmpw 4(%ecx),%bp
jl Lp11
movb (%esi),%al
cmpb $(TRANSPARENT_COLOR),%al
jz Lp11
movw %bp,4(%ecx)
movb %al,2(%edi)
Lp11:
addl izistep,%ebp
adcl $0,%ebp
addl tstep,%edx
sbbl %eax,%eax
addl sstep,%ebx
adcl advancetable+4(,%eax,4),%esi
LLEntry5_8:
cmpw 6(%ecx),%bp
jl Lp12
movb (%esi),%al
cmpb $(TRANSPARENT_COLOR),%al
jz Lp12
movw %bp,6(%ecx)
movb %al,3(%edi)
Lp12:
addl izistep,%ebp
adcl $0,%ebp
addl tstep,%edx
sbbl %eax,%eax
addl sstep,%ebx
adcl advancetable+4(,%eax,4),%esi
LLEntry4_8:
cmpw 8(%ecx),%bp
jl Lp13
movb (%esi),%al
cmpb $(TRANSPARENT_COLOR),%al
jz Lp13
movw %bp,8(%ecx)
movb %al,4(%edi)
Lp13:
addl izistep,%ebp
adcl $0,%ebp
addl tstep,%edx
sbbl %eax,%eax
addl sstep,%ebx
adcl advancetable+4(,%eax,4),%esi
LLEntry3_8:
cmpw 10(%ecx),%bp
jl Lp14
movb (%esi),%al
cmpb $(TRANSPARENT_COLOR),%al
jz Lp14
movw %bp,10(%ecx)
movb %al,5(%edi)
Lp14:
addl izistep,%ebp
adcl $0,%ebp
addl tstep,%edx
sbbl %eax,%eax
addl sstep,%ebx
adcl advancetable+4(,%eax,4),%esi
LLEntry2_8:
cmpw 12(%ecx),%bp
jl Lp15
movb (%esi),%al
cmpb $(TRANSPARENT_COLOR),%al
jz Lp15
movw %bp,12(%ecx)
movb %al,6(%edi)
Lp15:
addl izistep,%ebp
adcl $0,%ebp
addl tstep,%edx
sbbl %eax,%eax
addl sstep,%ebx
adcl advancetable+4(,%eax,4),%esi
LEndSpan:
cmpw 14(%ecx),%bp
jl Lp16
movb (%esi),%al // load first texel in segment
cmpb $(TRANSPARENT_COLOR),%al
jz Lp16
movw %bp,14(%ecx)
movb %al,7(%edi)
Lp16:
//
// clear s/z, t/z, 1/z from FP stack
//
fstp %st(0)
fstp %st(0)
fstp %st(0)
popl %ebx // restore spans pointer
LNextSpan:
addl $(sspan_t_size),%ebx // point to next span
movl sspan_t_count(%ebx),%ecx
cmpl $0,%ecx // any more spans?
jg LSpanLoop // yes
jz LNextSpan // yes, but this one's empty
popl %ebx // restore register variables
popl %esi
popl %edi
popl %ebp // restore the caller's stack frame
ret
#endif // id386
#endif

215
asm/d_varsa.s
View file

@ -1,215 +0,0 @@
/*
Copyright (C) 1996-1997 Id Software, Inc.
This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
See the GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*/
//
// d_varsa.s
//
#ifndef NOASM
#include "asm_i386.h"
#include "asm.h"
#include "asm_draw.h"
#include "d_ifacea.h"
#if id386
.data
//-------------------------------------------------------
// global refresh variables
//-------------------------------------------------------
// FIXME: put all refresh variables into one contiguous block. Make into one
// big structure, like cl or sv?
.align 4
.globl C(d_sdivzstepu)
.globl C(d_tdivzstepu)
.globl C(d_zistepu)
.globl C(d_sdivzstepv)
.globl C(d_tdivzstepv)
.globl C(d_zistepv)
.globl C(d_sdivzorigin)
.globl C(d_tdivzorigin)
.globl C(d_ziorigin)
C(d_sdivzstepu): .single 0
C(d_tdivzstepu): .single 0
C(d_zistepu): .single 0
C(d_sdivzstepv): .single 0
C(d_tdivzstepv): .single 0
C(d_zistepv): .single 0
C(d_sdivzorigin): .single 0
C(d_tdivzorigin): .single 0
C(d_ziorigin): .single 0
.globl C(sadjust)
.globl C(tadjust)
.globl C(bbextents)
.globl C(bbextentt)
C(sadjust): .long 0
C(tadjust): .long 0
C(bbextents): .long 0
C(bbextentt): .long 0
.globl C(cacheblock)
.globl C(d_viewbuffer)
.globl C(cachewidth)
.globl C(d_pzbuffer)
.globl C(d_zrowbytes)
.globl C(d_zwidth)
C(cacheblock): .long 0
C(cachewidth): .long 0
C(d_viewbuffer): .long 0
C(d_pzbuffer): .long 0
C(d_zrowbytes): .long 0
C(d_zwidth): .long 0
//-------------------------------------------------------
// ASM-only variables
//-------------------------------------------------------
.globl izi
izi: .long 0
.globl pbase, s, t, sfracf, tfracf, snext, tnext
.globl spancountminus1, zi16stepu, sdivz16stepu, tdivz16stepu
.globl zi8stepu, sdivz8stepu, tdivz8stepu, pz
s: .long 0
t: .long 0
snext: .long 0
tnext: .long 0
sfracf: .long 0
tfracf: .long 0
pbase: .long 0
zi8stepu: .long 0
sdivz8stepu: .long 0
tdivz8stepu: .long 0
zi16stepu: .long 0
sdivz16stepu: .long 0
tdivz16stepu: .long 0
spancountminus1: .long 0
pz: .long 0
.globl izistep
izistep: .long 0
//-------------------------------------------------------
// local variables for d_draw16.s
//-------------------------------------------------------
.globl reciprocal_table_16, entryvec_table_16
// 1/2, 1/3, 1/4, 1/5, 1/6, 1/7, 1/8, 1/9, 1/10, 1/11, 1/12, 1/13,
// 1/14, and 1/15 in 0.32 form
reciprocal_table_16: .long 0x40000000, 0x2aaaaaaa, 0x20000000
.long 0x19999999, 0x15555555, 0x12492492
.long 0x10000000, 0xe38e38e, 0xccccccc, 0xba2e8ba
.long 0xaaaaaaa, 0x9d89d89, 0x9249249, 0x8888888
#ifndef NeXT
.extern Entry2_16
.extern Entry3_16
.extern Entry4_16
.extern Entry5_16
.extern Entry6_16
.extern Entry7_16
.extern Entry8_16
.extern Entry9_16
.extern Entry10_16
.extern Entry11_16
.extern Entry12_16
.extern Entry13_16
.extern Entry14_16
.extern Entry15_16
.extern Entry16_16
#endif
entryvec_table_16: .long 0, Entry2_16, Entry3_16, Entry4_16
.long Entry5_16, Entry6_16, Entry7_16, Entry8_16
.long Entry9_16, Entry10_16, Entry11_16, Entry12_16
.long Entry13_16, Entry14_16, Entry15_16, Entry16_16
//-------------------------------------------------------
// local variables for d_parta.s
//-------------------------------------------------------
.globl DP_Count, DP_u, DP_v, DP_32768, DP_Color, DP_Pix, DP_EntryTable
DP_Count: .long 0
DP_u: .long 0
DP_v: .long 0
DP_32768: .single 32768.0
DP_Color: .long 0
DP_Pix: .long 0
#ifndef NeXT
.extern DP_1x1
.extern DP_2x2
.extern DP_3x3
.extern DP_4x4
#endif
DP_EntryTable: .long DP_1x1, DP_2x2, DP_3x3, DP_4x4
//
// advancetable is 8 bytes, but points to the middle of that range so negative
// offsets will work
//
.globl advancetable, sstep, tstep, pspantemp, counttemp, jumptemp
advancetable: .long 0, 0
sstep: .long 0
tstep: .long 0
pspantemp: .long 0
counttemp: .long 0
jumptemp: .long 0
// 1/2, 1/3, 1/4, 1/5, 1/6, and 1/7 in 0.32 form
.globl reciprocal_table, entryvec_table
reciprocal_table: .long 0x40000000, 0x2aaaaaaa, 0x20000000
.long 0x19999999, 0x15555555, 0x12492492
#ifndef NeXT
.extern Entry2_8
.extern Entry3_8
.extern Entry4_8
.extern Entry5_8
.extern Entry6_8
.extern Entry7_8
.extern Entry8_8
#endif
entryvec_table: .long 0, Entry2_8, Entry3_8, Entry4_8
.long Entry5_8, Entry6_8, Entry7_8, Entry8_8
#ifndef NeXT
.extern Spr8Entry2_8
.extern Spr8Entry3_8
.extern Spr8Entry4_8
.extern Spr8Entry5_8
.extern Spr8Entry6_8
.extern Spr8Entry7_8
.extern Spr8Entry8_8
#endif
.globl spr8entryvec_table
spr8entryvec_table: .long 0, Spr8Entry2_8, Spr8Entry3_8, Spr8Entry4_8
.long Spr8Entry5_8, Spr8Entry6_8, Spr8Entry7_8, Spr8Entry8_8
#endif // id386
#endif

430
asm/math.s
View file

@ -1,430 +0,0 @@
/*
Copyright (C) 1996-1997 Id Software, Inc.
This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
See the GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*/
//
// math.s
// x86 assembly-language math routines.
#ifndef NOASM
#define GLQUAKE 1 // don't include unneeded client defs
#include "asm_i386.h"
#include "asm.h"
#if id386
.data
.align 4
Ljmptab: .long Lcase0, Lcase1, Lcase2, Lcase3
.long Lcase4, Lcase5, Lcase6, Lcase7
.text
// 2001-12-28 Merged assembler files of Quake and QuakeWorld by Maddes start
// Disable unused asm code of Quake engine
/*
// TODO: rounding needed?
// stack parameter offset
#define val 4
.globl C(Invert24To16)
C(Invert24To16):
movl val(%esp),%ecx
movl $0x100,%edx // 0x10000000000 as dividend
cmpl %edx,%ecx
jle LOutOfRange
subl %eax,%eax
divl %ecx
ret
LOutOfRange:
movl $0xFFFFFFFF,%eax
ret
*/
// 2001-12-28 Merged assembler files of Quake and QuakeWorld by Maddes end
#ifndef SERVERONLY // no asm in dedicated server // 2001-12-28 Merged assembler files of Quake and QuakeWorld by Maddes
#define in 4
#define out 8
.align 2
.globl C(TransformVector)
C(TransformVector):
movl in(%esp),%eax
movl out(%esp),%edx
flds (%eax) // in[0]
fmuls C(vright) // in[0]*vright[0]
flds (%eax) // in[0] | in[0]*vright[0]
fmuls C(vup) // in[0]*vup[0] | in[0]*vright[0]
flds (%eax) // in[0] | in[0]*vup[0] | in[0]*vright[0]
fmuls C(vpn) // in[0]*vpn[0] | in[0]*vup[0] | in[0]*vright[0]
flds 4(%eax) // in[1] | ...
fmuls C(vright)+4 // in[1]*vright[1] | ...
flds 4(%eax) // in[1] | in[1]*vright[1] | ...
fmuls C(vup)+4 // in[1]*vup[1] | in[1]*vright[1] | ...
flds 4(%eax) // in[1] | in[1]*vup[1] | in[1]*vright[1] | ...
fmuls C(vpn)+4 // in[1]*vpn[1] | in[1]*vup[1] | in[1]*vright[1] | ...
fxch %st(2) // in[1]*vright[1] | in[1]*vup[1] | in[1]*vpn[1] | ...
faddp %st(0),%st(5) // in[1]*vup[1] | in[1]*vpn[1] | ...
faddp %st(0),%st(3) // in[1]*vpn[1] | ...
faddp %st(0),%st(1) // vpn_accum | vup_accum | vright_accum
flds 8(%eax) // in[2] | ...
fmuls C(vright)+8 // in[2]*vright[2] | ...
flds 8(%eax) // in[2] | in[2]*vright[2] | ...
fmuls C(vup)+8 // in[2]*vup[2] | in[2]*vright[2] | ...
flds 8(%eax) // in[2] | in[2]*vup[2] | in[2]*vright[2] | ...
fmuls C(vpn)+8 // in[2]*vpn[2] | in[2]*vup[2] | in[2]*vright[2] | ...
fxch %st(2) // in[2]*vright[2] | in[2]*vup[2] | in[2]*vpn[2] | ...
faddp %st(0),%st(5) // in[2]*vup[2] | in[2]*vpn[2] | ...
faddp %st(0),%st(3) // in[2]*vpn[2] | ...
faddp %st(0),%st(1) // vpn_accum | vup_accum | vright_accum
fstps 8(%edx) // out[2]
fstps 4(%edx) // out[1]
fstps (%edx) // out[0]
ret
#endif // ndef SERVERONLY // 2001-12-28 Merged assembler files of Quake and QuakeWorld by Maddes
#define EMINS 4+4
#define EMAXS 4+8
#define P 4+12
.align 2
.globl C(BoxOnPlaneSide)
C(BoxOnPlaneSide):
pushl %ebx
movl P(%esp),%edx
movl EMINS(%esp),%ecx
xorl %eax,%eax
movl EMAXS(%esp),%ebx
movb pl_signbits(%edx),%al
cmpb $8,%al // QW SV was: cmpl $8,%al // 2001-12-28 Merged assembler files of Quake and QuakeWorld by Maddes
jge Lerror
flds pl_normal(%edx) // p->normal[0]
fld %st(0) // p->normal[0] | p->normal[0]
// 2000-07-30 DJGPP compiler warning fix by Norberto Alfredo Bensa start
// jmp Ljmptab(,%eax,4)
jmp *Ljmptab(,%eax,4)
// 2000-07-30 DJGPP compiler warning fix by Norberto Alfredo Bensa end
//dist1= p->normal[0]*emaxs[0] + p->normal[1]*emaxs[1] + p->normal[2]*emaxs[2];
//dist2= p->normal[0]*emins[0] + p->normal[1]*emins[1] + p->normal[2]*emins[2];
Lcase0:
fmuls (%ebx) // p->normal[0]*emaxs[0] | p->normal[0]
flds pl_normal+4(%edx) // p->normal[1] | p->normal[0]*emaxs[0] |
// p->normal[0]
fxch %st(2) // p->normal[0] | p->normal[0]*emaxs[0] |
// p->normal[1]
fmuls (%ecx) // p->normal[0]*emins[0] |
// p->normal[0]*emaxs[0] | p->normal[1]
fxch %st(2) // p->normal[1] | p->normal[0]*emaxs[0] |
// p->normal[0]*emins[0]
fld %st(0) // p->normal[1] | p->normal[1] |
// p->normal[0]*emaxs[0] |
// p->normal[0]*emins[0]
fmuls 4(%ebx) // p->normal[1]*emaxs[1] | p->normal[1] |
// p->normal[0]*emaxs[0] |
// p->normal[0]*emins[0]
flds pl_normal+8(%edx) // p->normal[2] | p->normal[1]*emaxs[1] |
// p->normal[1] | p->normal[0]*emaxs[0] |
// p->normal[0]*emins[0]
fxch %st(2) // p->normal[1] | p->normal[1]*emaxs[1] |
// p->normal[2] | p->normal[0]*emaxs[0] |
// p->normal[0]*emins[0]
fmuls 4(%ecx) // p->normal[1]*emins[1] |
// p->normal[1]*emaxs[1] |
// p->normal[2] | p->normal[0]*emaxs[0] |
// p->normal[0]*emins[0]
fxch %st(2) // p->normal[2] | p->normal[1]*emaxs[1] |
// p->normal[1]*emins[1] |
// p->normal[0]*emaxs[0] |
// p->normal[0]*emins[0]
fld %st(0) // p->normal[2] | p->normal[2] |
// p->normal[1]*emaxs[1] |
// p->normal[1]*emins[1] |
// p->normal[0]*emaxs[0] |
// p->normal[0]*emins[0]
fmuls 8(%ebx) // p->normal[2]*emaxs[2] |
// p->normal[2] |
// p->normal[1]*emaxs[1] |
// p->normal[1]*emins[1] |
// p->normal[0]*emaxs[0] |
// p->normal[0]*emins[0]
fxch %st(5) // p->normal[0]*emins[0] |
// p->normal[2] |
// p->normal[1]*emaxs[1] |
// p->normal[1]*emins[1] |
// p->normal[0]*emaxs[0] |
// p->normal[2]*emaxs[2]
faddp %st(0),%st(3) //p->normal[2] |
// p->normal[1]*emaxs[1] |
// p->normal[1]*emins[1]+p->normal[0]*emins[0]|
// p->normal[0]*emaxs[0] |
// p->normal[2]*emaxs[2]
fmuls 8(%ecx) //p->normal[2]*emins[2] |
// p->normal[1]*emaxs[1] |
// p->normal[1]*emins[1]+p->normal[0]*emins[0]|
// p->normal[0]*emaxs[0] |
// p->normal[2]*emaxs[2]
fxch %st(1) //p->normal[1]*emaxs[1] |
// p->normal[2]*emins[2] |
// p->normal[1]*emins[1]+p->normal[0]*emins[0]|
// p->normal[0]*emaxs[0] |
// p->normal[2]*emaxs[2]
faddp %st(0),%st(3) //p->normal[2]*emins[2] |
// p->normal[1]*emins[1]+p->normal[0]*emins[0]|
// p->normal[0]*emaxs[0]+p->normal[1]*emaxs[1]|
// p->normal[2]*emaxs[2]
fxch %st(3) //p->normal[2]*emaxs[2] +
// p->normal[1]*emins[1]+p->normal[0]*emins[0]|
// p->normal[0]*emaxs[0]+p->normal[1]*emaxs[1]|
// p->normal[2]*emins[2]
faddp %st(0),%st(2) //p->normal[1]*emins[1]+p->normal[0]*emins[0]|
// dist1 | p->normal[2]*emins[2]
jmp LSetSides
//dist1= p->normal[0]*emins[0] + p->normal[1]*emaxs[1] + p->normal[2]*emaxs[2];
//dist2= p->normal[0]*emaxs[0] + p->normal[1]*emins[1] + p->normal[2]*emins[2];
Lcase1:
fmuls (%ecx) // emins[0]
flds pl_normal+4(%edx)
fxch %st(2)
fmuls (%ebx) // emaxs[0]
fxch %st(2)
fld %st(0)
fmuls 4(%ebx) // emaxs[1]
flds pl_normal+8(%edx)
fxch %st(2)
fmuls 4(%ecx) // emins[1]
fxch %st(2)
fld %st(0)
fmuls 8(%ebx) // emaxs[2]
fxch %st(5)
faddp %st(0),%st(3)
fmuls 8(%ecx) // emins[2]
fxch %st(1)
faddp %st(0),%st(3)
fxch %st(3)
faddp %st(0),%st(2)
jmp LSetSides
//dist1= p->normal[0]*emaxs[0] + p->normal[1]*emins[1] + p->normal[2]*emaxs[2];
//dist2= p->normal[0]*emins[0] + p->normal[1]*emaxs[1] + p->normal[2]*emins[2];
Lcase2:
fmuls (%ebx) // emaxs[0]
flds pl_normal+4(%edx)
fxch %st(2)
fmuls (%ecx) // emins[0]
fxch %st(2)
fld %st(0)
fmuls 4(%ecx) // emins[1]
flds pl_normal+8(%edx)
fxch %st(2)
fmuls 4(%ebx) // emaxs[1]
fxch %st(2)
fld %st(0)
fmuls 8(%ebx) // emaxs[2]
fxch %st(5)
faddp %st(0),%st(3)
fmuls 8(%ecx) // emins[2]
fxch %st(1)
faddp %st(0),%st(3)
fxch %st(3)
faddp %st(0),%st(2)
jmp LSetSides
//dist1= p->normal[0]*emins[0] + p->normal[1]*emins[1] + p->normal[2]*emaxs[2];
//dist2= p->normal[0]*emaxs[0] + p->normal[1]*emaxs[1] + p->normal[2]*emins[2];
Lcase3:
fmuls (%ecx) // emins[0]
flds pl_normal+4(%edx)
fxch %st(2)
fmuls (%ebx) // emaxs[0]
fxch %st(2)
fld %st(0)
fmuls 4(%ecx) // emins[1]
flds pl_normal+8(%edx)
fxch %st(2)
fmuls 4(%ebx) // emaxs[1]
fxch %st(2)
fld %st(0)
fmuls 8(%ebx) // emaxs[2]
fxch %st(5)
faddp %st(0),%st(3)
fmuls 8(%ecx) // emins[2]
fxch %st(1)
faddp %st(0),%st(3)
fxch %st(3)
faddp %st(0),%st(2)
jmp LSetSides
//dist1= p->normal[0]*emaxs[0] + p->normal[1]*emaxs[1] + p->normal[2]*emins[2];
//dist2= p->normal[0]*emins[0] + p->normal[1]*emins[1] + p->normal[2]*emaxs[2];
Lcase4:
fmuls (%ebx) // emaxs[0]
flds pl_normal+4(%edx)
fxch %st(2)
fmuls (%ecx) // emins[0]
fxch %st(2)
fld %st(0)
fmuls 4(%ebx) // emaxs[1]
flds pl_normal+8(%edx)
fxch %st(2)
fmuls 4(%ecx) // emins[1]
fxch %st(2)
fld %st(0)
fmuls 8(%ecx) // emins[2]
fxch %st(5)
faddp %st(0),%st(3)
fmuls 8(%ebx) // emaxs[2]
fxch %st(1)
faddp %st(0),%st(3)
fxch %st(3)
faddp %st(0),%st(2)
jmp LSetSides
//dist1= p->normal[0]*emins[0] + p->normal[1]*emaxs[1] + p->normal[2]*emins[2];
//dist2= p->normal[0]*emaxs[0] + p->normal[1]*emins[1] + p->normal[2]*emaxs[2];
Lcase5:
fmuls (%ecx) // emins[0]
flds pl_normal+4(%edx)
fxch %st(2)
fmuls (%ebx) // emaxs[0]
fxch %st(2)
fld %st(0)
fmuls 4(%ebx) // emaxs[1]
flds pl_normal+8(%edx)
fxch %st(2)
fmuls 4(%ecx) // emins[1]
fxch %st(2)
fld %st(0)
fmuls 8(%ecx) // emins[2]
fxch %st(5)
faddp %st(0),%st(3)
fmuls 8(%ebx) // emaxs[2]
fxch %st(1)
faddp %st(0),%st(3)
fxch %st(3)
faddp %st(0),%st(2)
jmp LSetSides
//dist1= p->normal[0]*emaxs[0] + p->normal[1]*emins[1] + p->normal[2]*emins[2];
//dist2= p->normal[0]*emins[0] + p->normal[1]*emaxs[1] + p->normal[2]*emaxs[2];
Lcase6:
fmuls (%ebx) // emaxs[0]
flds pl_normal+4(%edx)
fxch %st(2)
fmuls (%ecx) // emins[0]
fxch %st(2)
fld %st(0)
fmuls 4(%ecx) // emins[1]
flds pl_normal+8(%edx)
fxch %st(2)
fmuls 4(%ebx) // emaxs[1]
fxch %st(2)
fld %st(0)
fmuls 8(%ecx) // emins[2]
fxch %st(5)
faddp %st(0),%st(3)
fmuls 8(%ebx) // emaxs[2]
fxch %st(1)
faddp %st(0),%st(3)
fxch %st(3)
faddp %st(0),%st(2)
jmp LSetSides
//dist1= p->normal[0]*emins[0] + p->normal[1]*emins[1] + p->normal[2]*emins[2];
//dist2= p->normal[0]*emaxs[0] + p->normal[1]*emaxs[1] + p->normal[2]*emaxs[2];
Lcase7:
fmuls (%ecx) // emins[0]
flds pl_normal+4(%edx)
fxch %st(2)
fmuls (%ebx) // emaxs[0]
fxch %st(2)
fld %st(0)
fmuls 4(%ecx) // emins[1]
flds pl_normal+8(%edx)
fxch %st(2)
fmuls 4(%ebx) // emaxs[1]
fxch %st(2)
fld %st(0)
fmuls 8(%ecx) // emins[2]
fxch %st(5)
faddp %st(0),%st(3)
fmuls 8(%ebx) // emaxs[2]
fxch %st(1)
faddp %st(0),%st(3)
fxch %st(3)
faddp %st(0),%st(2)
LSetSides:
// sides = 0;
// if (dist1 >= p->dist)
// sides = 1;
// if (dist2 < p->dist)
// sides |= 2;
faddp %st(0),%st(2) // dist1 | dist2
fcomps pl_dist(%edx)
xorl %ecx,%ecx
fnstsw %ax
fcomps pl_dist(%edx)
andb $1,%ah
xorb $1,%ah
addb %ah,%cl
fnstsw %ax
andb $1,%ah
addb %ah,%ah
addb %ah,%cl
// return sides;
popl %ebx
movl %ecx,%eax // return status
ret
Lerror:
call C(BOPS_Error)
#endif // id386
#endif

218
asm/r_aclipa.s
View file

@ -1,218 +0,0 @@
/*
Copyright (C) 1996-1997 Id Software, Inc.
This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
See the GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*/
//
// r_aliasa.s
// x86 assembly-language Alias model transform and project code.
//
#ifndef NOASM
#include "asm_i386.h"
#include "asm.h"
#include "asm_draw.h"
#include "d_ifacea.h"
#if id386
.data
Ltemp0: .long 0
Ltemp1: .long 0
.text
#define pfv0 8+4
#define pfv1 8+8
#define out 8+12
.globl C(R_Alias_clip_bottom)
C(R_Alias_clip_bottom):
pushl %esi
pushl %edi
movl pfv0(%esp),%esi
movl pfv1(%esp),%edi
movl C(r_refdef)+rd_aliasvrectbottom,%eax
LDoForwardOrBackward:
movl fv_v+4(%esi),%edx
movl fv_v+4(%edi),%ecx
cmpl %ecx,%edx
jl LDoForward
movl fv_v+4(%esi),%ecx
movl fv_v+4(%edi),%edx
movl pfv0(%esp),%edi
movl pfv1(%esp),%esi
LDoForward:
subl %edx,%ecx
subl %edx,%eax
movl %ecx,Ltemp1
movl %eax,Ltemp0
fildl Ltemp1
fildl Ltemp0
movl out(%esp),%edx
movl $2,%eax
fdivp %st(0),%st(1) // scale
LDo3Forward:
fildl fv_v+0(%esi) // fv0v0 | scale
fildl fv_v+0(%edi) // fv1v0 | fv0v0 | scale
fildl fv_v+4(%esi) // fv0v1 | fv1v0 | fv0v0 | scale
fildl fv_v+4(%edi) // fv1v1 | fv0v1 | fv1v0 | fv0v0 | scale
fildl fv_v+8(%esi) // fv0v2 | fv1v1 | fv0v1 | fv1v0 | fv0v0 | scale
fildl fv_v+8(%edi) // fv1v2 | fv0v2 | fv1v1 | fv0v1 | fv1v0 | fv0v0 |
// scale
fxch %st(5) // fv0v0 | fv0v2 | fv1v1 | fv0v1 | fv1v0 | fv1v2 |
// scale
fsubr %st(0),%st(4) // fv0v0 | fv0v2 | fv1v1 | fv0v1 | fv1v0-fv0v0 |
// fv1v2 | scale
fxch %st(3) // fv0v1 | fv0v2 | fv1v1 | fv0v0 | fv1v0-fv0v0 |
// fv1v2 | scale
fsubr %st(0),%st(2) // fv0v1 | fv0v2 | fv1v1-fv0v1 | fv0v0 |
// fv1v0-fv0v0 | fv1v2 | scale
fxch %st(1) // fv0v2 | fv0v1 | fv1v1-fv0v1 | fv0v0 |
// fv1v0-fv0v0 | fv1v2 | scale
fsubr %st(0),%st(5) // fv0v2 | fv0v1 | fv1v1-fv0v1 | fv0v0 |
// fv1v0-fv0v0 | fv1v2-fv0v2 | scale
fxch %st(6) // scale | fv0v1 | fv1v1-fv0v1 | fv0v0 |
// fv1v0-fv0v0 | fv1v2-fv0v2 | fv0v2
fmul %st(0),%st(4) // scale | fv0v1 | fv1v1-fv0v1 | fv0v0 |
// (fv1v0-fv0v0)*scale | fv1v2-fv0v2 | fv0v2
addl $12,%edi
fmul %st(0),%st(2) // scale | fv0v1 | (fv1v1-fv0v1)*scale | fv0v0 |
// (fv1v0-fv0v0)*scale | fv1v2-fv0v2 | fv0v2
addl $12,%esi
addl $12,%edx
fmul %st(0),%st(5) // scale | fv0v1 | (fv1v1-fv0v1)*scale | fv0v0 |
// (fv1v0-fv0v0)*scale | (fv1v2-fv0v2)*scale |
// fv0v2
fxch %st(3) // fv0v0 | fv0v1 | (fv1v1-fv0v1)*scale | scale |
// (fv1v0-fv0v0)*scale | (fv1v2-fv0v2)*scale |
// fv0v2
faddp %st(0),%st(4) // fv0v1 | (fv1v1-fv0v1)*scale | scale |
// fv0v0+(fv1v0-fv0v0)*scale |
// (fv1v2-fv0v2)*scale | fv0v2
faddp %st(0),%st(1) // fv0v1+(fv1v1-fv0v1)*scale | scale |
// fv0v0+(fv1v0-fv0v0)*scale |
// (fv1v2-fv0v2)*scale | fv0v2
fxch %st(4) // fv0v2 | scale | fv0v0+(fv1v0-fv0v0)*scale |
// (fv1v2-fv0v2)*scale | fv0v1+(fv1v1-fv0v1)*scale
faddp %st(0),%st(3) // scale | fv0v0+(fv1v0-fv0v0)*scale |
// fv0v2+(fv1v2-fv0v2)*scale |
// fv0v1+(fv1v1-fv0v1)*scale
fxch %st(1) // fv0v0+(fv1v0-fv0v0)*scale | scale |
// fv0v2+(fv1v2-fv0v2)*scale |
// fv0v1+(fv1v1-fv0v1)*scale
fadds float_point5
fxch %st(3) // fv0v1+(fv1v1-fv0v1)*scale | scale |
// fv0v2+(fv1v2-fv0v2)*scale |
// fv0v0+(fv1v0-fv0v0)*scale
fadds float_point5
fxch %st(2) // fv0v2+(fv1v2-fv0v2)*scale | scale |
// fv0v1+(fv1v1-fv0v1)*scale |
// fv0v0+(fv1v0-fv0v0)*scale
fadds float_point5
fxch %st(3) // fv0v0+(fv1v0-fv0v0)*scale | scale |
// fv0v1+(fv1v1-fv0v1)*scale |
// fv0v2+(fv1v2-fv0v2)*scale
fistpl fv_v+0-12(%edx) // scale | fv0v1+(fv1v1-fv0v1)*scale |
// fv0v2+(fv1v2-fv0v2)*scale
fxch %st(1) // fv0v1+(fv1v1-fv0v1)*scale | scale |
// fv0v2+(fv1v2-fv0v2)*scale | scale
fistpl fv_v+4-12(%edx) // scale | fv0v2+(fv1v2-fv0v2)*scale
fxch %st(1) // fv0v2+(fv1v2-fv0v2)*sc | scale
fistpl fv_v+8-12(%edx) // scale
decl %eax
jnz LDo3Forward
fstp %st(0)
popl %edi
popl %esi
ret
.globl C(R_Alias_clip_top)
C(R_Alias_clip_top):
pushl %esi
pushl %edi
movl pfv0(%esp),%esi
movl pfv1(%esp),%edi
movl C(r_refdef)+rd_aliasvrect+4,%eax
jmp LDoForwardOrBackward
.globl C(R_Alias_clip_right)
C(R_Alias_clip_right):
pushl %esi
pushl %edi
movl pfv0(%esp),%esi
movl pfv1(%esp),%edi
movl C(r_refdef)+rd_aliasvrectright,%eax
LRightLeftEntry:
movl fv_v+4(%esi),%edx
movl fv_v+4(%edi),%ecx
cmpl %ecx,%edx
movl fv_v+0(%esi),%edx
movl fv_v+0(%edi),%ecx
jl LDoForward2
movl fv_v+0(%esi),%ecx
movl fv_v+0(%edi),%edx
movl pfv0(%esp),%edi
movl pfv1(%esp),%esi
LDoForward2:
jmp LDoForward
.globl C(R_Alias_clip_left)
C(R_Alias_clip_left):
pushl %esi
pushl %edi
movl pfv0(%esp),%esi
movl pfv1(%esp),%edi
movl C(r_refdef)+rd_aliasvrect+0,%eax
jmp LRightLeftEntry
#endif // id386
#endif

239
asm/r_aliasa.s
View file

@ -1,239 +0,0 @@
/*
Copyright (C) 1996-1997 Id Software, Inc.
This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
See the GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*/
//
// r_aliasa.s
// x86 assembly-language Alias model transform and project code.
//
#ifndef NOASM
#include "asm_i386.h"
#include "asm.h"
#include "asm_draw.h"
#include "d_ifacea.h"
#if id386broken
.data
Lfloat_1: .single 1.0
Ltemp: .long 0
Lcoords: .long 0, 0, 0
.text
#define fv 12+4
#define pstverts 12+8
.globl C(R_AliasTransformAndProjectFinalVerts)
C(R_AliasTransformAndProjectFinalVerts):
pushl %ebp // preserve caller's stack frame
pushl %edi
pushl %esi // preserve register variables
// int i, temp;
// float lightcos, *plightnormal, zi;
// trivertx_t *pverts;
// pverts = r_apverts;
movl C(r_apverts),%esi
// for (i=0 ; i<r_anumverts ; i++, fv++, pverts++, pstverts++)
// {
movl pstverts(%esp),%ebp
movl fv(%esp),%edi
movl C(r_anumverts),%ecx
subl %edx,%edx
Lloop:
// // transform and project
// zi = 1.0 / (DotProduct(pverts->v, aliastransform[2]) +
// aliastransform[2][3]);
movb (%esi),%dl
movb %dl,Lcoords
fildl Lcoords // v[0]
movb 1(%esi),%dl
movb %dl,Lcoords+4
fildl Lcoords+4 // v[1] | v[0]
movb 2(%esi),%dl
movb %dl,Lcoords+8
fildl Lcoords+8 // v[2] | v[1] | v[0]
fld %st(2) // v[0] | v[2] | v[1] | v[0]
fmuls C(aliastransform)+32 // accum | v[2] | v[1] | v[0]
fld %st(2) // v[1] | accum | v[2] | v[1] | v[0]
fmuls C(aliastransform)+36 // accum2 | accum | v[2] | v[1] | v[0]
fxch %st(1) // accum | accum2 | v[2] | v[1] | v[0]
fadds C(aliastransform)+44 // accum | accum2 | v[2] | v[1] | v[0]
fld %st(2) // v[2] | accum | accum2 | v[2] | v[1] | v[0]
fmuls C(aliastransform)+40 // accum3 | accum | accum2 | v[2] | v[1] |
// v[0]
fxch %st(1) // accum | accum3 | accum2 | v[2] | v[1] | v[0]
faddp %st(0),%st(2) // accum3 | accum | v[2] | v[1] | v[0]
movb tv_lightnormalindex(%esi),%dl
movl stv_s(%ebp),%eax
movl %eax,fv_v+8(%edi)
faddp %st(0),%st(1) // z | v[2] | v[1] | v[0]
movl stv_t(%ebp),%eax
movl %eax,fv_v+12(%edi)
// // lighting
// plightnormal = r_avertexnormals[pverts->lightnormalindex];
fdivrs Lfloat_1 // zi | v[2] | v[1] | v[0]
// fv->v[2] = pstverts->s;
// fv->v[3] = pstverts->t;
// fv->flags = pstverts->onseam;
movl stv_onseam(%ebp),%eax
movl %eax,fv_flags(%edi)
movl fv_size(%edi),%eax
movl stv_size(%ebp),%eax
movl 4(%esi),%eax
leal (%edx,%edx,2),%eax // index*3
fxch %st(3) // v[0] | v[2] | v[1] | zi
// lightcos = DotProduct (plightnormal, r_plightvec);
flds C(r_avertexnormals)(,%eax,4)
fmuls C(r_plightvec)
flds C(r_avertexnormals)+4(,%eax,4)
fmuls C(r_plightvec)+4
flds C(r_avertexnormals)+8(,%eax,4)
fmuls C(r_plightvec)+8
fxch %st(1)
faddp %st(0),%st(2)
fld %st(2) // v[0] | laccum | laccum2 | v[0] | v[2] |
// v[1] | zi
fmuls C(aliastransform)+0 // xaccum | laccum | laccum2 | v[0] | v[2] |
// v[1] | zi
fxch %st(2) // laccum2 | laccum | xaccum | v[0] | v[2] |
// v[1] | zi
faddp %st(0),%st(1) // laccum | xaccum | v[0] | v[2] | v[1] | zi
// temp = r_ambientlight;
// if (lightcos < 0)
// {
fsts Ltemp
movl C(r_ambientlight),%eax
movb Ltemp+3,%dl
testb $0x80,%dl
jz Lsavelight // no need to clamp if only ambient lit, because
// r_ambientlight is preclamped
// temp += (int)(r_shadelight * lightcos);
fmuls C(r_shadelight)
// FIXME: fast float->int conversion?
fistpl Ltemp
addl Ltemp,%eax
// // clamp; because we limited the minimum ambient and shading light, we
// // don't have to clamp low light, just bright
// if (temp < 0)
// temp = 0;
jns Lp1
subl %eax,%eax
// }
Lp1:
// fv->v[4] = temp;
//
// // x, y, and z are scaled down by 1/2**31 in the transform, so 1/z is
// // scaled up by 1/2**31, and the scaling cancels out for x and y in the
// // projection
// fv->v[0] = ((DotProduct(pverts->v, aliastransform[0]) +
// aliastransform[0][3]) * zi) + aliasxcenter;
// fv->v[1] = ((DotProduct(pverts->v, aliastransform[1]) +
// aliastransform[1][3]) * zi) + aliasycenter;
// fv->v[5] = zi;
fxch %st(1) // v[0] | xaccum | v[2] | v[1] | zi
fmuls C(aliastransform)+16 // yaccum | xaccum | v[2] | v[1] | zi
fxch %st(3) // v[1] | xaccum | v[2] | yaccum | zi
fld %st(0) // v[1] | v[1] | xaccum | v[2] | yaccum | zi
fmuls C(aliastransform)+4 // xaccum2 | v[1] | xaccum | v[2] | yaccum |zi
fxch %st(1) // v[1] | xaccum2 | xaccum | v[2] | yaccum |zi
movl %eax,fv_v+16(%edi)
fmuls C(aliastransform)+20 // yaccum2 | xaccum2 | xaccum | v[2] | yaccum|
// zi
fxch %st(2) // xaccum | xaccum2 | yaccum2 | v[2] | yaccum|
// zi
fadds C(aliastransform)+12 // xaccum | xaccum2 | yaccum2 | v[2] | yaccum|
// zi
fxch %st(4) // yaccum | xaccum2 | yaccum2 | v[2] | xaccum|
// zi
fadds C(aliastransform)+28 // yaccum | xaccum2 | yaccum2 | v[2] | xaccum|
// zi
fxch %st(3) // v[2] | xaccum2 | yaccum2 | yaccum | xaccum|
// zi
fld %st(0) // v[2] | v[2] | xaccum2 | yaccum2 | yaccum |
// xaccum | zi
fmuls C(aliastransform)+8 // xaccum3 | v[2] | xaccum2 | yaccum2 |yaccum|
// xaccum | zi
fxch %st(1) // v[2] | xaccum3 | xaccum2 | yaccum2 |yaccum|
// xaccum | zi
fmuls C(aliastransform)+24 // yaccum3 | xaccum3 | xaccum2 | yaccum2 |
// yaccum | xaccum | zi
fxch %st(5) // xaccum | xaccum3 | xaccum2 | yaccum2 |
// yaccum | yaccum3 | zi
faddp %st(0),%st(2) // xaccum3 | xaccum | yaccum2 | yaccum |
// yaccum3 | zi
fxch %st(3) // yaccum | xaccum | yaccum2 | xaccum3 |
// yaccum3 | zi
faddp %st(0),%st(2) // xaccum | yaccum | xaccum3 | yaccum3 | zi
addl $(tv_size),%esi
faddp %st(0),%st(2) // yaccum | x | yaccum3 | zi
faddp %st(0),%st(2) // x | y | zi
addl $(stv_size),%ebp
fmul %st(2),%st(0) // x/z | y | zi
fxch %st(1) // y | x/z | zi
fmul %st(2),%st(0) // y/z | x/z | zi
fxch %st(1) // x/z | y/z | zi
fadds C(aliasxcenter) // u | y/z | zi
fxch %st(1) // y/z | u | zi
fadds C(aliasycenter) // v | u | zi
fxch %st(2) // zi | u | v
// FIXME: fast float->int conversion?
fistpl fv_v+20(%edi) // u | v
fistpl fv_v+0(%edi) // v
fistpl fv_v+4(%edi)
// }
addl $(fv_size),%edi
decl %ecx
jnz Lloop
popl %esi // restore register variables
popl %edi
popl %ebp // restore the caller's stack frame
ret
Lsavelight:
fstp %st(0)
jmp Lp1
#endif // id386
#endif

840
asm/r_drawa.s
View file

@ -1,840 +0,0 @@
/*
Copyright (C) 1996-1997 Id Software, Inc.
This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
See the GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*/
//
// r_drawa.s
// x86 assembly-language edge clipping and emission code
//
#ifndef NOASM
#include "asm_i386.h"
#include "asm.h"
#include "asm_draw.h"
#include "d_ifacea.h"
#if id386
// !!! if these are changed, they must be changed in r_draw.c too !!!
#define FULLY_CLIPPED_CACHED 0x80000000
#define FRAMECOUNT_MASK 0x7FFFFFFF
.data
Ld0: .single 0.0
Ld1: .single 0.0
Lstack: .long 0
Lfp_near_clip: .single NEAR_CLIP
Lceilv0: .long 0
Lv: .long 0
Lu0: .long 0
Lv0: .long 0
Lzi0: .long 0
.text
//----------------------------------------------------------------------
// edge clipping code
//----------------------------------------------------------------------
#define pv0 4+12
#define pv1 8+12
#define clip 12+12
.align 4
.globl C(R_ClipEdge)
C(R_ClipEdge):
pushl %esi // preserve register variables
pushl %edi
pushl %ebx
movl %esp,Lstack // for clearing the stack later
// float d0, d1, f;
// mvertex_t clipvert;
movl clip(%esp),%ebx
movl pv0(%esp),%esi
movl pv1(%esp),%edx
// if (clip)
// {
testl %ebx,%ebx
jz Lemit
// do
// {
Lcliploop:
// d0 = DotProduct (pv0->position, clip->normal) - clip->dist;
// d1 = DotProduct (pv1->position, clip->normal) - clip->dist;
flds mv_position+0(%esi)
fmuls cp_normal+0(%ebx)
flds mv_position+4(%esi)
fmuls cp_normal+4(%ebx)
flds mv_position+8(%esi)
fmuls cp_normal+8(%ebx)
fxch %st(1)
faddp %st(0),%st(2) // d0mul2 | d0add0
flds mv_position+0(%edx)
fmuls cp_normal+0(%ebx)
flds mv_position+4(%edx)
fmuls cp_normal+4(%ebx)
flds mv_position+8(%edx)
fmuls cp_normal+8(%ebx)
fxch %st(1)
faddp %st(0),%st(2) // d1mul2 | d1add0 | d0mul2 | d0add0
fxch %st(3) // d0add0 | d1add0 | d0mul2 | d1mul2
faddp %st(0),%st(2) // d1add0 | dot0 | d1mul2
faddp %st(0),%st(2) // dot0 | dot1
fsubs cp_dist(%ebx) // d0 | dot1
fxch %st(1) // dot1 | d0
fsubs cp_dist(%ebx) // d1 | d0
fxch %st(1)
fstps Ld0
fstps Ld1
// if (d0 >= 0)
// {
movl Ld0,%eax
movl Ld1,%ecx
orl %eax,%ecx
js Lp2
// both points are unclipped
Lcontinue:
//
// R_ClipEdge (&clipvert, pv1, clip->next);
// return;
// }
// } while ((clip = clip->next) != NULL);
movl cp_next(%ebx),%ebx
testl %ebx,%ebx
jnz Lcliploop
// }
//// add the edge
// R_EmitEdge (pv0, pv1);
Lemit:
//
// set integer rounding to ceil mode, set to single precision
//
// FIXME: do away with by manually extracting integers from floats?
// FIXME: set less often
fldcw ceil_cw
// edge_t *edge, *pcheck;
// int u_check;
// float u, u_step;
// vec3_t local, transformed;
// float *world;
// int v, v2, ceilv0;
// float scale, lzi0, u0, v0;
// int side;
// if (r_lastvertvalid)
// {
cmpl $0,C(r_lastvertvalid)
jz LCalcFirst
// u0 = r_u1;
// v0 = r_v1;
// lzi0 = r_lzi1;
// ceilv0 = r_ceilv1;
movl C(r_lzi1),%eax
movl C(r_u1),%ecx
movl %eax,Lzi0
movl %ecx,Lu0
movl C(r_v1),%ecx
movl C(r_ceilv1),%eax
movl %ecx,Lv0
movl %eax,Lceilv0
jmp LCalcSecond
// }
LCalcFirst:
// else
// {
// world = &pv0->position[0];
call LTransformAndProject // v0 | lzi0 | u0
fsts Lv0
fxch %st(2) // u0 | lzi0 | v0
fstps Lu0 // lzi0 | v0
fstps Lzi0 // v0
// ceilv0 = (int)(v0 - 2000) + 2000; // ceil(v0);
fistpl Lceilv0
// }
LCalcSecond:
// world = &pv1->position[0];
movl %edx,%esi
call LTransformAndProject // v1 | lzi1 | u1
flds Lu0 // u0 | v1 | lzi1 | u1
fxch %st(3) // u1 | v1 | lzi1 | u0
flds Lzi0 // lzi0 | u1 | v1 | lzi1 | u0
fxch %st(3) // lzi1 | u1 | v1 | lzi0 | u0
flds Lv0 // v0 | lzi1 | u1 | v1 | lzi0 | u0
fxch %st(3) // v1 | lzi1 | u1 | v0 | lzi0 | u0
// r_ceilv1 = (int)(r_v1 - 2000) + 2000; // ceil(r_v1);
fistl C(r_ceilv1)
fldcw single_cw // put back normal floating-point state
fsts C(r_v1)
fxch %st(4) // lzi0 | lzi1 | u1 | v0 | v1 | u0
// if (r_lzi1 > lzi0)
// lzi0 = r_lzi1;
fcom %st(1)
fnstsw %ax
testb $1,%ah
jz LP0
fstp %st(0)
fld %st(0)
LP0:
fxch %st(1) // lzi1 | lzi0 | u1 | v0 | v1 | u0
fstps C(r_lzi1) // lzi0 | u1 | v0 | v1 | u0
fxch %st(1)
fsts C(r_u1)
fxch %st(1)
// if (lzi0 > r_nearzi) // for mipmap finding
// r_nearzi = lzi0;
fcoms C(r_nearzi)
fnstsw %ax
testb $0x45,%ah
jnz LP1
fsts C(r_nearzi)
LP1:
// // for right edges, all we want is the effect on 1/z
// if (r_nearzionly)
// return;
movl C(r_nearzionly),%eax
testl %eax,%eax
jz LP2
LPop5AndDone:
movl C(cacheoffset),%eax
movl C(r_framecount),%edx
cmpl $0x7FFFFFFF,%eax
jz LDoPop
andl $(FRAMECOUNT_MASK),%edx
orl $(FULLY_CLIPPED_CACHED),%edx
movl %edx,C(cacheoffset)
LDoPop:
fstp %st(0) // u1 | v0 | v1 | u0
fstp %st(0) // v0 | v1 | u0
fstp %st(0) // v1 | u0
fstp %st(0) // u0
fstp %st(0)
jmp Ldone
LP2:
// // create the edge
// if (ceilv0 == r_ceilv1)
// return; // horizontal edge
movl Lceilv0,%ebx
movl C(edge_p),%edi
movl C(r_ceilv1),%ecx
movl %edi,%edx
movl C(r_pedge),%esi
addl $(et_size),%edx
cmpl %ecx,%ebx
jz LPop5AndDone
movl C(r_pedge),%eax
movl %eax,et_owner(%edi)
// side = ceilv0 > r_ceilv1;
//
// edge->nearzi = lzi0;
fstps et_nearzi(%edi) // u1 | v0 | v1 | u0
// if (side == 1)
// {
jc LSide0
LSide1:
// // leading edge (go from p2 to p1)
// u_step = ((u0 - r_u1) / (v0 - r_v1));
fsubrp %st(0),%st(3) // v0 | v1 | u0-u1
fsub %st(1),%st(0) // v0-v1 | v1 | u0-u1
fdivrp %st(0),%st(2) // v1 | ustep
// r_emitted = 1;
movl $1,C(r_emitted)
// edge = edge_p++;
movl %edx,C(edge_p)
// pretouch next edge
movl (%edx),%eax
// v2 = ceilv0 - 1;
// v = r_ceilv1;
movl %ecx,%eax
leal -1(%ebx),%ecx
movl %eax,%ebx
// edge->surfs[0] = 0;
// edge->surfs[1] = surface_p - surfaces;
movl C(surface_p),%eax
movl C(surfaces),%esi
subl %edx,%edx
subl %esi,%eax
shrl $(SURF_T_SHIFT),%eax
movl %edx,et_surfs(%edi)
movl %eax,et_surfs+2(%edi)
subl %esi,%esi
// u = r_u1 + ((float)v - r_v1) * u_step;
movl %ebx,Lv
fildl Lv // v | v1 | ustep
fsubp %st(0),%st(1) // v-v1 | ustep
fmul %st(1),%st(0) // (v-v1)*ustep | ustep
fadds C(r_u1) // u | ustep
jmp LSideDone
// }
LSide0:
// else
// {
// // trailing edge (go from p1 to p2)
// u_step = ((r_u1 - u0) / (r_v1 - v0));
fsub %st(3),%st(0) // u1-u0 | v0 | v1 | u0
fxch %st(2) // v1 | v0 | u1-u0 | u0
fsub %st(1),%st(0) // v1-v0 | v0 | u1-u0 | u0
fdivrp %st(0),%st(2) // v0 | ustep | u0
// r_emitted = 1;
movl $1,C(r_emitted)
// edge = edge_p++;
movl %edx,C(edge_p)
// pretouch next edge
movl (%edx),%eax
// v = ceilv0;
// v2 = r_ceilv1 - 1;
decl %ecx
// edge->surfs[0] = surface_p - surfaces;
// edge->surfs[1] = 0;
movl C(surface_p),%eax
movl C(surfaces),%esi
subl %edx,%edx
subl %esi,%eax
shrl $(SURF_T_SHIFT),%eax
movl %edx,et_surfs+2(%edi)
movl %eax,et_surfs(%edi)
movl $1,%esi
// u = u0 + ((float)v - v0) * u_step;
movl %ebx,Lv
fildl Lv // v | v0 | ustep | u0
fsubp %st(0),%st(1) // v-v0 | ustep | u0
fmul %st(1),%st(0) // (v-v0)*ustep | ustep | u0
faddp %st(0),%st(2) // ustep | u
fxch %st(1) // u | ustep
// }
LSideDone:
// edge->u_step = u_step*0x100000;
// edge->u = u*0x100000 + 0xFFFFF;
fmuls fp_1m // u*0x100000 | ustep
fxch %st(1) // ustep | u*0x100000
fmuls fp_1m // ustep*0x100000 | u*0x100000
fxch %st(1) // u*0x100000 | ustep*0x100000
fadds fp_1m_minus_1 // u*0x100000 + 0xFFFFF | ustep*0x100000
fxch %st(1) // ustep*0x100000 | u*0x100000 + 0xFFFFF
fistpl et_u_step(%edi) // u*0x100000 + 0xFFFFF
fistpl et_u(%edi)
// // we need to do this to avoid stepping off the edges if a very nearly
// // horizontal edge is less than epsilon above a scan, and numeric error
// // causes it to incorrectly extend to the scan, and the extension of the
// // line goes off the edge of the screen
// // FIXME: is this actually needed?
// if (edge->u < r_refdef.vrect_x_adj_shift20)
// edge->u = r_refdef.vrect_x_adj_shift20;
// if (edge->u > r_refdef.vrectright_adj_shift20)
// edge->u = r_refdef.vrectright_adj_shift20;
movl et_u(%edi),%eax
movl C(r_refdef)+rd_vrect_x_adj_shift20,%edx
cmpl %edx,%eax
jl LP4
movl C(r_refdef)+rd_vrectright_adj_shift20,%edx
cmpl %edx,%eax
jng LP5
LP4:
movl %edx,et_u(%edi)
movl %edx,%eax
LP5:
// // sort the edge in normally
// u_check = edge->u;
//
// if (edge->surfs[0])
// u_check++; // sort trailers after leaders
addl %esi,%eax
// if (!newedges[v] || newedges[v]->u >= u_check)
// {
movl C(newedges)(,%ebx,4),%esi
testl %esi,%esi
jz LDoFirst
cmpl %eax,et_u(%esi)
jl LNotFirst
LDoFirst:
// edge->next = newedges[v];
// newedges[v] = edge;
movl %esi,et_next(%edi)
movl %edi,C(newedges)(,%ebx,4)
jmp LSetRemove
// }
LNotFirst:
// else
// {
// pcheck = newedges[v];
//
// while (pcheck->next && pcheck->next->u < u_check)
// pcheck = pcheck->next;
LFindInsertLoop:
movl %esi,%edx
movl et_next(%esi),%esi
testl %esi,%esi
jz LInsertFound
cmpl %eax,et_u(%esi)
jl LFindInsertLoop
LInsertFound:
// edge->next = pcheck->next;
// pcheck->next = edge;
movl %esi,et_next(%edi)
movl %edi,et_next(%edx)
// }
LSetRemove:
// edge->nextremove = removeedges[v2];
// removeedges[v2] = edge;
movl C(removeedges)(,%ecx,4),%eax
movl %edi,C(removeedges)(,%ecx,4)
movl %eax,et_nextremove(%edi)
Ldone:
movl Lstack,%esp // clear temporary variables from stack
popl %ebx // restore register variables
popl %edi
popl %esi
ret
// at least one point is clipped
Lp2:
testl %eax,%eax
jns Lp1
// else
// {
// // point 0 is clipped
// if (d1 < 0)
// {
movl Ld1,%eax
testl %eax,%eax
jns Lp3
// // both points are clipped
// // we do cache fully clipped edges
// if (!leftclipped)
movl C(r_leftclipped),%eax
movl C(r_pedge),%ecx
testl %eax,%eax
jnz Ldone
// r_pedge->framecount = r_framecount;
movl C(r_framecount),%eax
andl $(FRAMECOUNT_MASK),%eax
orl $(FULLY_CLIPPED_CACHED),%eax
movl %eax,C(cacheoffset)
// return;
jmp Ldone
// }
Lp1:
// // point 0 is unclipped
// if (d1 >= 0)
// {
// // both points are unclipped
// continue;
// // only point 1 is clipped
// f = d0 / (d0 - d1);
flds Ld0
flds Ld1
fsubr %st(1),%st(0)
// // we don't cache partially clipped edges
movl $0x7FFFFFFF,C(cacheoffset)
fdivrp %st(0),%st(1)
subl $(mv_size),%esp // allocate space for clipvert
// clipvert.position[0] = pv0->position[0] +
// f * (pv1->position[0] - pv0->position[0]);
// clipvert.position[1] = pv0->position[1] +
// f * (pv1->position[1] - pv0->position[1]);
// clipvert.position[2] = pv0->position[2] +
// f * (pv1->position[2] - pv0->position[2]);
flds mv_position+8(%edx)
fsubs mv_position+8(%esi)
flds mv_position+4(%edx)
fsubs mv_position+4(%esi)
flds mv_position+0(%edx)
fsubs mv_position+0(%esi) // 0 | 1 | 2
// replace pv1 with the clip point
movl %esp,%edx
movl cp_leftedge(%ebx),%eax
testb %al,%al
fmul %st(3),%st(0)
fxch %st(1) // 1 | 0 | 2
fmul %st(3),%st(0)
fxch %st(2) // 2 | 0 | 1
fmulp %st(0),%st(3) // 0 | 1 | 2
fadds mv_position+0(%esi)
fxch %st(1) // 1 | 0 | 2
fadds mv_position+4(%esi)
fxch %st(2) // 2 | 0 | 1
fadds mv_position+8(%esi)
fxch %st(1) // 0 | 2 | 1
fstps mv_position+0(%esp) // 2 | 1
fstps mv_position+8(%esp) // 1
fstps mv_position+4(%esp)
// if (clip->leftedge)
// {
jz Ltestright
// r_leftclipped = true;
// r_leftexit = clipvert;
movl $1,C(r_leftclipped)
movl mv_position+0(%esp),%eax
movl %eax,C(r_leftexit)+mv_position+0
movl mv_position+4(%esp),%eax
movl %eax,C(r_leftexit)+mv_position+4
movl mv_position+8(%esp),%eax
movl %eax,C(r_leftexit)+mv_position+8
jmp Lcontinue
// }
Ltestright:
// else if (clip->rightedge)
// {
testb %ah,%ah
jz Lcontinue
// r_rightclipped = true;
// r_rightexit = clipvert;
movl $1,C(r_rightclipped)
movl mv_position+0(%esp),%eax
movl %eax,C(r_rightexit)+mv_position+0
movl mv_position+4(%esp),%eax
movl %eax,C(r_rightexit)+mv_position+4
movl mv_position+8(%esp),%eax
movl %eax,C(r_rightexit)+mv_position+8
// }
//
// R_ClipEdge (pv0, &clipvert, clip->next);
// return;
// }
jmp Lcontinue
// }
Lp3:
// // only point 0 is clipped
// r_lastvertvalid = false;
movl $0,C(r_lastvertvalid)
// f = d0 / (d0 - d1);
flds Ld0
flds Ld1
fsubr %st(1),%st(0)
// // we don't cache partially clipped edges
movl $0x7FFFFFFF,C(cacheoffset)
fdivrp %st(0),%st(1)
subl $(mv_size),%esp // allocate space for clipvert
// clipvert.position[0] = pv0->position[0] +
// f * (pv1->position[0] - pv0->position[0]);
// clipvert.position[1] = pv0->position[1] +
// f * (pv1->position[1] - pv0->position[1]);
// clipvert.position[2] = pv0->position[2] +
// f * (pv1->position[2] - pv0->position[2]);
flds mv_position+8(%edx)
fsubs mv_position+8(%esi)
flds mv_position+4(%edx)
fsubs mv_position+4(%esi)
flds mv_position+0(%edx)
fsubs mv_position+0(%esi) // 0 | 1 | 2
movl cp_leftedge(%ebx),%eax
testb %al,%al
fmul %st(3),%st(0)
fxch %st(1) // 1 | 0 | 2
fmul %st(3),%st(0)
fxch %st(2) // 2 | 0 | 1
fmulp %st(0),%st(3) // 0 | 1 | 2
fadds mv_position+0(%esi)
fxch %st(1) // 1 | 0 | 2
fadds mv_position+4(%esi)
fxch %st(2) // 2 | 0 | 1
fadds mv_position+8(%esi)
fxch %st(1) // 0 | 2 | 1
fstps mv_position+0(%esp) // 2 | 1
fstps mv_position+8(%esp) // 1
fstps mv_position+4(%esp)
// replace pv0 with the clip point
movl %esp,%esi
// if (clip->leftedge)
// {
jz Ltestright2
// r_leftclipped = true;
// r_leftenter = clipvert;
movl $1,C(r_leftclipped)
movl mv_position+0(%esp),%eax
movl %eax,C(r_leftenter)+mv_position+0
movl mv_position+4(%esp),%eax
movl %eax,C(r_leftenter)+mv_position+4
movl mv_position+8(%esp),%eax
movl %eax,C(r_leftenter)+mv_position+8
jmp Lcontinue
// }
Ltestright2:
// else if (clip->rightedge)
// {
testb %ah,%ah
jz Lcontinue
// r_rightclipped = true;
// r_rightenter = clipvert;
movl $1,C(r_rightclipped)
movl mv_position+0(%esp),%eax
movl %eax,C(r_rightenter)+mv_position+0
movl mv_position+4(%esp),%eax
movl %eax,C(r_rightenter)+mv_position+4
movl mv_position+8(%esp),%eax
movl %eax,C(r_rightenter)+mv_position+8
// }
jmp Lcontinue
// %esi = vec3_t point to transform and project
// %edx preserved
LTransformAndProject:
// // transform and project
// VectorSubtract (world, modelorg, local);
flds mv_position+0(%esi)
fsubs C(modelorg)+0
flds mv_position+4(%esi)
fsubs C(modelorg)+4
flds mv_position+8(%esi)
fsubs C(modelorg)+8
fxch %st(2) // local[0] | local[1] | local[2]
// TransformVector (local, transformed);
//
// if (transformed[2] < NEAR_CLIP)
// transformed[2] = NEAR_CLIP;
//
// lzi0 = 1.0 / transformed[2];
fld %st(0) // local[0] | local[0] | local[1] | local[2]
fmuls C(vpn)+0 // zm0 | local[0] | local[1] | local[2]
fld %st(1) // local[0] | zm0 | local[0] | local[1] |
// local[2]
fmuls C(vright)+0 // xm0 | zm0 | local[0] | local[1] | local[2]
fxch %st(2) // local[0] | zm0 | xm0 | local[1] | local[2]
fmuls C(vup)+0 // ym0 | zm0 | xm0 | local[1] | local[2]
fld %st(3) // local[1] | ym0 | zm0 | xm0 | local[1] |
// local[2]
fmuls C(vpn)+4 // zm1 | ym0 | zm0 | xm0 | local[1] |
// local[2]
fld %st(4) // local[1] | zm1 | ym0 | zm0 | xm0 |
// local[1] | local[2]
fmuls C(vright)+4 // xm1 | zm1 | ym0 | zm0 | xm0 |
// local[1] | local[2]
fxch %st(5) // local[1] | zm1 | ym0 | zm0 | xm0 |
// xm1 | local[2]
fmuls C(vup)+4 // ym1 | zm1 | ym0 | zm0 | xm0 |
// xm1 | local[2]
fxch %st(1) // zm1 | ym1 | ym0 | zm0 | xm0 |
// xm1 | local[2]
faddp %st(0),%st(3) // ym1 | ym0 | zm2 | xm0 | xm1 | local[2]
fxch %st(3) // xm0 | ym0 | zm2 | ym1 | xm1 | local[2]
faddp %st(0),%st(4) // ym0 | zm2 | ym1 | xm2 | local[2]
faddp %st(0),%st(2) // zm2 | ym2 | xm2 | local[2]
fld %st(3) // local[2] | zm2 | ym2 | xm2 | local[2]
fmuls C(vpn)+8 // zm3 | zm2 | ym2 | xm2 | local[2]
fld %st(4) // local[2] | zm3 | zm2 | ym2 | xm2 | local[2]
fmuls C(vright)+8 // xm3 | zm3 | zm2 | ym2 | xm2 | local[2]
fxch %st(5) // local[2] | zm3 | zm2 | ym2 | xm2 | xm3
fmuls C(vup)+8 // ym3 | zm3 | zm2 | ym2 | xm2 | xm3
fxch %st(1) // zm3 | ym3 | zm2 | ym2 | xm2 | xm3
faddp %st(0),%st(2) // ym3 | zm4 | ym2 | xm2 | xm3
fxch %st(4) // xm3 | zm4 | ym2 | xm2 | ym3
faddp %st(0),%st(3) // zm4 | ym2 | xm4 | ym3
fxch %st(1) // ym2 | zm4 | xm4 | ym3
faddp %st(0),%st(3) // zm4 | xm4 | ym4
fcoms Lfp_near_clip
fnstsw %ax
testb $1,%ah
jz LNoClip
fstp %st(0)
flds Lfp_near_clip
LNoClip:
fdivrs float_1 // lzi0 | x | y
fxch %st(1) // x | lzi0 | y
// // FIXME: build x/yscale into transform?
// scale = xscale * lzi0;
// u0 = (xcenter + scale*transformed[0]);
flds C(xscale) // xscale | x | lzi0 | y
fmul %st(2),%st(0) // scale | x | lzi0 | y
fmulp %st(0),%st(1) // scale*x | lzi0 | y
fadds C(xcenter) // u0 | lzi0 | y
// if (u0 < r_refdef.fvrectx_adj)
// u0 = r_refdef.fvrectx_adj;
// if (u0 > r_refdef.fvrectright_adj)
// u0 = r_refdef.fvrectright_adj;
// FIXME: use integer compares of floats?
fcoms C(r_refdef)+rd_fvrectx_adj
fnstsw %ax
testb $1,%ah
jz LClampP0
fstp %st(0)
flds C(r_refdef)+rd_fvrectx_adj
LClampP0:
fcoms C(r_refdef)+rd_fvrectright_adj
fnstsw %ax
testb $0x45,%ah
jnz LClampP1
fstp %st(0)
flds C(r_refdef)+rd_fvrectright_adj
LClampP1:
fld %st(1) // lzi0 | u0 | lzi0 | y
// scale = yscale * lzi0;
// v0 = (ycenter - scale*transformed[1]);
fmuls C(yscale) // scale | u0 | lzi0 | y
fmulp %st(0),%st(3) // u0 | lzi0 | scale*y
fxch %st(2) // scale*y | lzi0 | u0
fsubrs C(ycenter) // v0 | lzi0 | u0
// if (v0 < r_refdef.fvrecty_adj)
// v0 = r_refdef.fvrecty_adj;
// if (v0 > r_refdef.fvrectbottom_adj)
// v0 = r_refdef.fvrectbottom_adj;
// FIXME: use integer compares of floats?
fcoms C(r_refdef)+rd_fvrecty_adj
fnstsw %ax
testb $1,%ah
jz LClampP2
fstp %st(0)
flds C(r_refdef)+rd_fvrecty_adj
LClampP2:
fcoms C(r_refdef)+rd_fvrectbottom_adj
fnstsw %ax
testb $0x45,%ah
jnz LClampP3
fstp %st(0)
flds C(r_refdef)+rd_fvrectbottom_adj
LClampP3:
ret
#endif // id386
#endif

752
asm/r_edgea.s
View file

@ -1,752 +0,0 @@
/*
Copyright (C) 1996-1997 Id Software, Inc.
This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
See the GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*/
//
// r_edgea.s
// x86 assembly-language edge-processing code.
//
#ifndef NOASM
#include "asm_i386.h"
#include "asm.h"
#include "asm_draw.h"
#if id386broken
.data
Ltemp: .long 0
float_1_div_0100000h: .long 0x35800000 // 1.0/(float)0x100000
float_point_999: .single 0.999
float_1_point_001: .single 1.001
.text
//--------------------------------------------------------------------
#define edgestoadd 4+8 // note odd stack offsets because of interleaving
#define edgelist 8+12 // with pushes
.globl C(R_EdgeCodeStart)
C(R_EdgeCodeStart):
.globl C(R_InsertNewEdges)
C(R_InsertNewEdges):
pushl %edi
pushl %esi // preserve register variables
movl edgestoadd(%esp),%edx
pushl %ebx
movl edgelist(%esp),%ecx
LDoNextEdge:
movl et_u(%edx),%eax
movl %edx,%edi
LContinueSearch:
movl et_u(%ecx),%ebx
movl et_next(%ecx),%esi
cmpl %ebx,%eax
jle LAddedge
movl et_u(%esi),%ebx
movl et_next(%esi),%ecx
cmpl %ebx,%eax
jle LAddedge2
movl et_u(%ecx),%ebx
movl et_next(%ecx),%esi
cmpl %ebx,%eax
jle LAddedge
movl et_u(%esi),%ebx
movl et_next(%esi),%ecx
cmpl %ebx,%eax
jg LContinueSearch
LAddedge2:
movl et_next(%edx),%edx
movl et_prev(%esi),%ebx
movl %esi,et_next(%edi)
movl %ebx,et_prev(%edi)
movl %edi,et_next(%ebx)
movl %edi,et_prev(%esi)
movl %esi,%ecx
cmpl $0,%edx
jnz LDoNextEdge
jmp LDone
.align 4
LAddedge:
movl et_next(%edx),%edx
movl et_prev(%ecx),%ebx
movl %ecx,et_next(%edi)
movl %ebx,et_prev(%edi)
movl %edi,et_next(%ebx)
movl %edi,et_prev(%ecx)
cmpl $0,%edx
jnz LDoNextEdge
LDone:
popl %ebx // restore register variables
popl %esi
popl %edi
ret
//--------------------------------------------------------------------
#define predge 4+4
.globl C(R_RemoveEdges)
C(R_RemoveEdges):
pushl %ebx
movl predge(%esp),%eax
Lre_loop:
movl et_next(%eax),%ecx
movl et_nextremove(%eax),%ebx
movl et_prev(%eax),%edx
testl %ebx,%ebx
movl %edx,et_prev(%ecx)
jz Lre_done
movl %ecx,et_next(%edx)
movl et_next(%ebx),%ecx
movl et_prev(%ebx),%edx
movl et_nextremove(%ebx),%eax
movl %edx,et_prev(%ecx)
testl %eax,%eax
movl %ecx,et_next(%edx)
jnz Lre_loop
popl %ebx
ret
Lre_done:
movl %ecx,et_next(%edx)
popl %ebx
ret
//--------------------------------------------------------------------
#define pedgelist 4+4 // note odd stack offset because of interleaving
// with pushes
.globl C(R_StepActiveU)
C(R_StepActiveU):
pushl %edi
movl pedgelist(%esp),%edx
pushl %esi // preserve register variables
pushl %ebx
movl et_prev(%edx),%esi
LNewEdge:
movl et_u(%esi),%edi
LNextEdge:
movl et_u(%edx),%eax
movl et_u_step(%edx),%ebx
addl %ebx,%eax
movl et_next(%edx),%esi
movl %eax,et_u(%edx)
cmpl %edi,%eax
jl LPushBack
movl et_u(%esi),%edi
movl et_u_step(%esi),%ebx
addl %ebx,%edi
movl et_next(%esi),%edx
movl %edi,et_u(%esi)
cmpl %eax,%edi
jl LPushBack2
movl et_u(%edx),%eax
movl et_u_step(%edx),%ebx
addl %ebx,%eax
movl et_next(%edx),%esi
movl %eax,et_u(%edx)
cmpl %edi,%eax
jl LPushBack
movl et_u(%esi),%edi
movl et_u_step(%esi),%ebx
addl %ebx,%edi
movl et_next(%esi),%edx
movl %edi,et_u(%esi)
cmpl %eax,%edi
jnl LNextEdge
LPushBack2:
movl %edx,%ebx
movl %edi,%eax
movl %esi,%edx
movl %ebx,%esi
LPushBack:
// push it back to keep it sorted
movl et_prev(%edx),%ecx
movl et_next(%edx),%ebx
// done if the -1 in edge_aftertail triggered this
cmpl $(C(edge_aftertail)),%edx
jz LUDone
// pull the edge out of the edge list
movl et_prev(%ecx),%edi
movl %ecx,et_prev(%esi)
movl %ebx,et_next(%ecx)
// find out where the edge goes in the edge list
LPushBackLoop:
movl et_prev(%edi),%ecx
movl et_u(%edi),%ebx
cmpl %ebx,%eax
jnl LPushBackFound
movl et_prev(%ecx),%edi
movl et_u(%ecx),%ebx
cmpl %ebx,%eax
jl LPushBackLoop
movl %ecx,%edi
// put the edge back into the edge list
LPushBackFound:
movl et_next(%edi),%ebx
movl %edi,et_prev(%edx)
movl %ebx,et_next(%edx)
movl %edx,et_next(%edi)
movl %edx,et_prev(%ebx)
movl %esi,%edx
movl et_prev(%esi),%esi
cmpl $(C(edge_tail)),%edx
jnz LNewEdge
LUDone:
popl %ebx // restore register variables
popl %esi
popl %edi
ret
//--------------------------------------------------------------------
#define surf 4 // note this is loaded before any pushes
.align 4
TrailingEdge:
movl st_spanstate(%esi),%eax // check for edge inversion
decl %eax
jnz LInverted
movl %eax,st_spanstate(%esi)
movl st_insubmodel(%esi),%ecx
movl 0x12345678,%edx // surfaces[1].st_next
LPatch0:
movl C(r_bmodelactive),%eax
subl %ecx,%eax
cmpl %esi,%edx
movl %eax,C(r_bmodelactive)
jnz LNoEmit // surface isn't on top, just remove
// emit a span (current top going away)
movl et_u(%ebx),%eax
shrl $20,%eax // iu = integral pixel u
movl st_last_u(%esi),%edx
movl st_next(%esi),%ecx
cmpl %edx,%eax
jle LNoEmit2 // iu <= surf->last_u, so nothing to emit
movl %eax,st_last_u(%ecx) // surf->next->last_u = iu;
subl %edx,%eax
movl %edx,espan_t_u(%ebp) // span->u = surf->last_u;
movl %eax,espan_t_count(%ebp) // span->count = iu - span->u;
movl C(current_iv),%eax
movl %eax,espan_t_v(%ebp) // span->v = current_iv;
movl st_spans(%esi),%eax
movl %eax,espan_t_pnext(%ebp) // span->pnext = surf->spans;
movl %ebp,st_spans(%esi) // surf->spans = span;
addl $(espan_t_size),%ebp
movl st_next(%esi),%edx // remove the surface from the surface
movl st_prev(%esi),%esi // stack
movl %edx,st_next(%esi)
movl %esi,st_prev(%edx)
ret
LNoEmit2:
movl %eax,st_last_u(%ecx) // surf->next->last_u = iu;
movl st_next(%esi),%edx // remove the surface from the surface
movl st_prev(%esi),%esi // stack
movl %edx,st_next(%esi)
movl %esi,st_prev(%edx)
ret
LNoEmit:
movl st_next(%esi),%edx // remove the surface from the surface
movl st_prev(%esi),%esi // stack
movl %edx,st_next(%esi)
movl %esi,st_prev(%edx)
ret
LInverted:
movl %eax,st_spanstate(%esi)
ret
//--------------------------------------------------------------------
// trailing edge only
Lgs_trailing:
pushl $Lgs_nextedge
jmp TrailingEdge
.globl C(R_GenerateSpans)
C(R_GenerateSpans):
pushl %ebp // preserve caller's stack frame
pushl %edi
pushl %esi // preserve register variables
pushl %ebx
// clear active surfaces to just the background surface
movl C(surfaces),%eax
movl C(edge_head_u_shift20),%edx
addl $(st_size),%eax
// %ebp = span_p throughout
movl C(span_p),%ebp
movl $0,C(r_bmodelactive)
movl %eax,st_next(%eax)
movl %eax,st_prev(%eax)
movl %edx,st_last_u(%eax)
movl C(edge_head)+et_next,%ebx // edge=edge_head.next
// generate spans
cmpl $(C(edge_tail)),%ebx // done if empty list
jz Lgs_lastspan
Lgs_edgeloop:
movl et_surfs(%ebx),%edi
movl C(surfaces),%eax
movl %edi,%esi
andl $0xFFFF0000,%edi
andl $0xFFFF,%esi
jz Lgs_leading // not a trailing edge
// it has a left surface, so a surface is going away for this span
shll $(SURF_T_SHIFT),%esi
addl %eax,%esi
testl %edi,%edi
jz Lgs_trailing
// both leading and trailing
call TrailingEdge
movl C(surfaces),%eax
// ---------------------------------------------------------------
// handle a leading edge
// ---------------------------------------------------------------
Lgs_leading:
shrl $16-SURF_T_SHIFT,%edi
movl C(surfaces),%eax
addl %eax,%edi
movl 0x12345678,%esi // surf2 = surfaces[1].next;
LPatch2:
movl st_spanstate(%edi),%edx
movl st_insubmodel(%edi),%eax
testl %eax,%eax
jnz Lbmodel_leading
// handle a leading non-bmodel edge
// don't start a span if this is an inverted span, with the end edge preceding
// the start edge (that is, we've already seen the end edge)
testl %edx,%edx
jnz Lxl_done
// if (surf->key < surf2->key)
// goto newtop;
incl %edx
movl st_key(%edi),%eax
movl %edx,st_spanstate(%edi)
movl st_key(%esi),%ecx
cmpl %ecx,%eax
jl Lnewtop
// main sorting loop to search through surface stack until insertion point
// found. Always terminates because background surface is sentinel
// do
// {
// surf2 = surf2->next;
// } while (surf->key >= surf2->key);
Lsortloopnb:
movl st_next(%esi),%esi
movl st_key(%esi),%ecx
cmpl %ecx,%eax
jge Lsortloopnb
jmp LInsertAndExit
// handle a leading bmodel edge
.align 4
Lbmodel_leading:
// don't start a span if this is an inverted span, with the end edge preceding
// the start edge (that is, we've already seen the end edge)
testl %edx,%edx
jnz Lxl_done
movl C(r_bmodelactive),%ecx
incl %edx
incl %ecx
movl %edx,st_spanstate(%edi)
movl %ecx,C(r_bmodelactive)
// if (surf->key < surf2->key)
// goto newtop;
movl st_key(%edi),%eax
movl st_key(%esi),%ecx
cmpl %ecx,%eax
jl Lnewtop
// if ((surf->key == surf2->key) && surf->insubmodel)
// {
jz Lzcheck_for_newtop
// main sorting loop to search through surface stack until insertion point
// found. Always terminates because background surface is sentinel
// do
// {
// surf2 = surf2->next;
// } while (surf->key > surf2->key);
Lsortloop:
movl st_next(%esi),%esi
movl st_key(%esi),%ecx
cmpl %ecx,%eax
jg Lsortloop
jne LInsertAndExit
// Do 1/z sorting to see if we've arrived in the right position
movl et_u(%ebx),%eax
subl $0xFFFFF,%eax
movl %eax,Ltemp
fildl Ltemp
fmuls float_1_div_0100000h // fu = (float)(edge->u - 0xFFFFF) *
// (1.0 / 0x100000);
fld %st(0) // fu | fu
fmuls st_d_zistepu(%edi) // fu*surf->d_zistepu | fu
flds C(fv) // fv | fu*surf->d_zistepu | fu
fmuls st_d_zistepv(%edi) // fv*surf->d_zistepv | fu*surf->d_zistepu | fu
fxch %st(1) // fu*surf->d_zistepu | fv*surf->d_zistepv | fu
fadds st_d_ziorigin(%edi) // fu*surf->d_zistepu + surf->d_ziorigin |
// fv*surf->d_zistepv | fu
flds st_d_zistepu(%esi) // surf2->d_zistepu |
// fu*surf->d_zistepu + surf->d_ziorigin |
// fv*surf->d_zistepv | fu
fmul %st(3),%st(0) // fu*surf2->d_zistepu |
// fu*surf->d_zistepu + surf->d_ziorigin |
// fv*surf->d_zistepv | fu
fxch %st(1) // fu*surf->d_zistepu + surf->d_ziorigin |
// fu*surf2->d_zistepu |
// fv*surf->d_zistepv | fu
faddp %st(0),%st(2) // fu*surf2->d_zistepu | newzi | fu
flds C(fv) // fv | fu*surf2->d_zistepu | newzi | fu
fmuls st_d_zistepv(%esi) // fv*surf2->d_zistepv |
// fu*surf2->d_zistepu | newzi | fu
fld %st(2) // newzi | fv*surf2->d_zistepv |
// fu*surf2->d_zistepu | newzi | fu
fmuls float_point_999 // newzibottom | fv*surf2->d_zistepv |
// fu*surf2->d_zistepu | newzi | fu
fxch %st(2) // fu*surf2->d_zistepu | fv*surf2->d_zistepv |
// newzibottom | newzi | fu
fadds st_d_ziorigin(%esi) // fu*surf2->d_zistepu + surf2->d_ziorigin |
// fv*surf2->d_zistepv | newzibottom | newzi |
// fu
faddp %st(0),%st(1) // testzi | newzibottom | newzi | fu
fxch %st(1) // newzibottom | testzi | newzi | fu
// if (newzibottom >= testzi)
// goto Lgotposition;
fcomp %st(1) // testzi | newzi | fu
fxch %st(1) // newzi | testzi | fu
fmuls float_1_point_001 // newzitop | testzi | fu
fxch %st(1) // testzi | newzitop | fu
fnstsw %ax
testb $0x01,%ah
jz Lgotposition_fpop3
// if (newzitop >= testzi)
// {
fcomp %st(1) // newzitop | fu
fnstsw %ax
testb $0x45,%ah
jz Lsortloop_fpop2
// if (surf->d_zistepu >= surf2->d_zistepu)
// goto newtop;
flds st_d_zistepu(%edi) // surf->d_zistepu | newzitop| fu
fcomps st_d_zistepu(%esi) // newzitop | fu
fnstsw %ax
testb $0x01,%ah
jz Lgotposition_fpop2
fstp %st(0) // clear the FPstack
fstp %st(0)
movl st_key(%edi),%eax
jmp Lsortloop
Lgotposition_fpop3:
fstp %st(0)
Lgotposition_fpop2:
fstp %st(0)
fstp %st(0)
jmp LInsertAndExit
// emit a span (obscures current top)
Lnewtop_fpop3:
fstp %st(0)
Lnewtop_fpop2:
fstp %st(0)
fstp %st(0)
movl st_key(%edi),%eax // reload the sorting key
Lnewtop:
movl et_u(%ebx),%eax
movl st_last_u(%esi),%edx
shrl $20,%eax // iu = integral pixel u
movl %eax,st_last_u(%edi) // surf->last_u = iu;
cmpl %edx,%eax
jle LInsertAndExit // iu <= surf->last_u, so nothing to emit
subl %edx,%eax
movl %edx,espan_t_u(%ebp) // span->u = surf->last_u;
movl %eax,espan_t_count(%ebp) // span->count = iu - span->u;
movl C(current_iv),%eax
movl %eax,espan_t_v(%ebp) // span->v = current_iv;
movl st_spans(%esi),%eax
movl %eax,espan_t_pnext(%ebp) // span->pnext = surf->spans;
movl %ebp,st_spans(%esi) // surf->spans = span;
addl $(espan_t_size),%ebp
LInsertAndExit:
// insert before surf2
movl %esi,st_next(%edi) // surf->next = surf2;
movl st_prev(%esi),%eax
movl %eax,st_prev(%edi) // surf->prev = surf2->prev;
movl %edi,st_prev(%esi) // surf2->prev = surf;
movl %edi,st_next(%eax) // surf2->prev->next = surf;
// ---------------------------------------------------------------
// leading edge done
// ---------------------------------------------------------------
// ---------------------------------------------------------------
// see if there are any more edges
// ---------------------------------------------------------------
Lgs_nextedge:
movl et_next(%ebx),%ebx
cmpl $(C(edge_tail)),%ebx
jnz Lgs_edgeloop
// clean up at the right edge
Lgs_lastspan:
// now that we've reached the right edge of the screen, we're done with any
// unfinished surfaces, so emit a span for whatever's on top
movl 0x12345678,%esi // surfaces[1].st_next
LPatch3:
movl C(edge_tail_u_shift20),%eax
xorl %ecx,%ecx
movl st_last_u(%esi),%edx
subl %edx,%eax
jle Lgs_resetspanstate
movl %edx,espan_t_u(%ebp)
movl %eax,espan_t_count(%ebp)
movl C(current_iv),%eax
movl %eax,espan_t_v(%ebp)
movl st_spans(%esi),%eax
movl %eax,espan_t_pnext(%ebp)
movl %ebp,st_spans(%esi)
addl $(espan_t_size),%ebp
// reset spanstate for all surfaces in the surface stack
Lgs_resetspanstate:
movl %ecx,st_spanstate(%esi)
movl st_next(%esi),%esi
cmpl $0x12345678,%esi // &surfaces[1]
LPatch4:
jnz Lgs_resetspanstate
// store the final span_p
movl %ebp,C(span_p)
popl %ebx // restore register variables
popl %esi
popl %edi
popl %ebp // restore the caller's stack frame
ret
// ---------------------------------------------------------------
// 1/z sorting for bmodels in the same leaf
// ---------------------------------------------------------------
.align 4
Lxl_done:
incl %edx
movl %edx,st_spanstate(%edi)
jmp Lgs_nextedge
.align 4
Lzcheck_for_newtop:
movl et_u(%ebx),%eax
subl $0xFFFFF,%eax
movl %eax,Ltemp
fildl Ltemp
fmuls float_1_div_0100000h // fu = (float)(edge->u - 0xFFFFF) *
// (1.0 / 0x100000);
fld %st(0) // fu | fu
fmuls st_d_zistepu(%edi) // fu*surf->d_zistepu | fu
flds C(fv) // fv | fu*surf->d_zistepu | fu
fmuls st_d_zistepv(%edi) // fv*surf->d_zistepv | fu*surf->d_zistepu | fu
fxch %st(1) // fu*surf->d_zistepu | fv*surf->d_zistepv | fu
fadds st_d_ziorigin(%edi) // fu*surf->d_zistepu + surf->d_ziorigin |
// fv*surf->d_zistepv | fu
flds st_d_zistepu(%esi) // surf2->d_zistepu |
// fu*surf->d_zistepu + surf->d_ziorigin |
// fv*surf->d_zistepv | fu
fmul %st(3),%st(0) // fu*surf2->d_zistepu |
// fu*surf->d_zistepu + surf->d_ziorigin |
// fv*surf->d_zistepv | fu
fxch %st(1) // fu*surf->d_zistepu + surf->d_ziorigin |
// fu*surf2->d_zistepu |
// fv*surf->d_zistepv | fu
faddp %st(0),%st(2) // fu*surf2->d_zistepu | newzi | fu
flds C(fv) // fv | fu*surf2->d_zistepu | newzi | fu
fmuls st_d_zistepv(%esi) // fv*surf2->d_zistepv |
// fu*surf2->d_zistepu | newzi | fu
fld %st(2) // newzi | fv*surf2->d_zistepv |
// fu*surf2->d_zistepu | newzi | fu
fmuls float_point_999 // newzibottom | fv*surf2->d_zistepv |
// fu*surf2->d_zistepu | newzi | fu
fxch %st(2) // fu*surf2->d_zistepu | fv*surf2->d_zistepv |
// newzibottom | newzi | fu
fadds st_d_ziorigin(%esi) // fu*surf2->d_zistepu + surf2->d_ziorigin |
// fv*surf2->d_zistepv | newzibottom | newzi |
// fu
faddp %st(0),%st(1) // testzi | newzibottom | newzi | fu
fxch %st(1) // newzibottom | testzi | newzi | fu
// if (newzibottom >= testzi)
// goto newtop;
fcomp %st(1) // testzi | newzi | fu
fxch %st(1) // newzi | testzi | fu
fmuls float_1_point_001 // newzitop | testzi | fu
fxch %st(1) // testzi | newzitop | fu
fnstsw %ax
testb $0x01,%ah
jz Lnewtop_fpop3
// if (newzitop >= testzi)
// {
fcomp %st(1) // newzitop | fu
fnstsw %ax
testb $0x45,%ah
jz Lsortloop_fpop2
// if (surf->d_zistepu >= surf2->d_zistepu)
// goto newtop;
flds st_d_zistepu(%edi) // surf->d_zistepu | newzitop | fu
fcomps st_d_zistepu(%esi) // newzitop | fu
fnstsw %ax
testb $0x01,%ah
jz Lnewtop_fpop2
Lsortloop_fpop2:
fstp %st(0) // clear the FP stack
fstp %st(0)
movl st_key(%edi),%eax
jmp Lsortloop
.globl C(R_EdgeCodeEnd)
C(R_EdgeCodeEnd):
//----------------------------------------------------------------------
// Surface array address code patching routine
//----------------------------------------------------------------------
.align 4
.globl C(R_SurfacePatch)
C(R_SurfacePatch):
movl C(surfaces),%eax
addl $(st_size),%eax
movl %eax,LPatch4-4
addl $(st_next),%eax
movl %eax,LPatch0-4
movl %eax,LPatch2-4
movl %eax,LPatch3-4
ret
#endif // id386
#endif

66
asm/r_varsa.s
View file

@ -1,66 +0,0 @@
/*
Copyright (C) 1996-1997 Id Software, Inc.
This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
See the GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*/
//
// r_varsa.s
//
#ifndef NOASM
#include "asm_i386.h"
#include "asm.h"
#include "asm_draw.h"
#include "d_ifacea.h"
#if id386
.data
//-------------------------------------------------------
// ASM-only variables
//-------------------------------------------------------
.globl float_1, float_particle_z_clip, float_point5
.globl float_minus_1, float_0
float_0: .single 0.0
float_1: .single 1.0
float_minus_1: .single -1.0
float_particle_z_clip: .single PARTICLE_Z_CLIP
float_point5: .single 0.5
.globl fp_16, fp_64k, fp_1m, fp_64kx64k
.globl fp_1m_minus_1
.globl fp_8
fp_1m: .single 1048576.0
fp_1m_minus_1: .single 1048575.0
fp_64k: .single 65536.0
fp_8: .single 8.0
fp_16: .single 16.0
fp_64kx64k: .long 0x4f000000 // (float)0x8000*0x10000
.globl FloatZero, Float2ToThe31nd, FloatMinus2ToThe31nd
FloatZero: .long 0
Float2ToThe31nd: .long 0x4f000000
FloatMinus2ToThe31nd: .long 0xcf000000
.globl C(r_bmodelactive)
C(r_bmodelactive): .long 0
#endif // id386
#endif

221
asm/snd_mixa.s
View file

@ -1,221 +0,0 @@
/*
Copyright (C) 1996-1997 Id Software, Inc.
This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
See the GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*/
//
// snd_mixa.s
// x86 assembly-language sound code
//
#ifndef NOASM
#define GLQUAKE 1 // don't include unneeded client defs
#include "asm_i386.h"
#include "asm.h"
#if id386
.text
//----------------------------------------------------------------------
// 8-bit sound-mixing code
//----------------------------------------------------------------------
#define ch 4+16
#define sc 8+16
#define count 12+16
.globl C(SND_PaintChannelFrom8)
C(SND_PaintChannelFrom8):
pushl %esi // preserve register variables
pushl %edi
pushl %ebx
pushl %ebp
// int data;
// short *lscale, *rscale;
// unsigned char *sfx;
// int i;
movl ch(%esp),%ebx
movl sc(%esp),%esi
// if (ch->leftvol > 255)
// ch->leftvol = 255;
// if (ch->rightvol > 255)
// ch->rightvol = 255;
movl ch_leftvol(%ebx),%eax
movl ch_rightvol(%ebx),%edx
cmpl $255,%eax
jna LLeftSet
movl $255,%eax
LLeftSet:
cmpl $255,%edx
jna LRightSet
movl $255,%edx
LRightSet:
// lscale = snd_scaletable[ch->leftvol >> 3];
// rscale = snd_scaletable[ch->rightvol >> 3];
// sfx = (signed char *)sc->data + ch->pos;
// ch->pos += count;
andl $0xF8,%eax
addl $(sfxc_data),%esi
andl $0xF8,%edx
movl ch_pos(%ebx),%edi
movl count(%esp),%ecx
addl %edi,%esi
shll $7,%eax
addl %ecx,%edi
shll $7,%edx
movl %edi,ch_pos(%ebx)
addl $(C(snd_scaletable)),%eax
addl $(C(snd_scaletable)),%edx
subl %ebx,%ebx
movb -1(%esi,%ecx,1),%bl
testl $1,%ecx
jz LMix8Loop
movl (%eax,%ebx,4),%edi
movl (%edx,%ebx,4),%ebp
addl C(paintbuffer)+psp_left-psp_size(,%ecx,psp_size),%edi
addl C(paintbuffer)+psp_right-psp_size(,%ecx,psp_size),%ebp
movl %edi,C(paintbuffer)+psp_left-psp_size(,%ecx,psp_size)
movl %ebp,C(paintbuffer)+psp_right-psp_size(,%ecx,psp_size)
movb -2(%esi,%ecx,1),%bl
decl %ecx
jz LDone
// for (i=0 ; i<count ; i++)
// {
LMix8Loop:
// data = sfx[i];
// paintbuffer[i].left += lscale[data];
// paintbuffer[i].right += rscale[data];
movl (%eax,%ebx,4),%edi
movl (%edx,%ebx,4),%ebp
addl C(paintbuffer)+psp_left-psp_size(,%ecx,psp_size),%edi
addl C(paintbuffer)+psp_right-psp_size(,%ecx,psp_size),%ebp
movb -2(%esi,%ecx,1),%bl
movl %edi,C(paintbuffer)+psp_left-psp_size(,%ecx,psp_size)
movl %ebp,C(paintbuffer)+psp_right-psp_size(,%ecx,psp_size)
movl (%eax,%ebx,4),%edi
movl (%edx,%ebx,4),%ebp
movb -3(%esi,%ecx,1),%bl
addl C(paintbuffer)+psp_left-psp_size*2(,%ecx,psp_size),%edi
addl C(paintbuffer)+psp_right-psp_size*2(,%ecx,psp_size),%ebp
movl %edi,C(paintbuffer)+psp_left-psp_size*2(,%ecx,psp_size)
movl %ebp,C(paintbuffer)+psp_right-psp_size*2(,%ecx,psp_size)
// }
subl $2,%ecx
jnz LMix8Loop
LDone:
popl %ebp
popl %ebx
popl %edi
popl %esi
ret
//----------------------------------------------------------------------
// Transfer of stereo buffer to 16-bit DMA buffer code
//----------------------------------------------------------------------
.globl C(Snd_WriteLinearBlastStereo16)
C(Snd_WriteLinearBlastStereo16):
pushl %esi // preserve register variables
pushl %edi
pushl %ebx
// int i;
// int val;
movl C(snd_linear_count),%ecx
movl C(snd_p),%ebx
movl C(snd_vol),%esi
movl C(snd_out),%edi
// for (i=0 ; i<snd_linear_count ; i+=2)
// {
LWLBLoopTop:
// val = (snd_p[i]*snd_vol)>>8;
// if (val > 0x7fff)
// snd_out[i] = 0x7fff;
// else if (val < (short)0x8000)
// snd_out[i] = (short)0x8000;
// else
// snd_out[i] = val;
movl -8(%ebx,%ecx,4),%eax
imull %esi,%eax
sarl $8,%eax
cmpl $0x7FFF,%eax
jg LClampHigh
cmpl $0xFFFF8000,%eax
jnl LClampDone
movl $0xFFFF8000,%eax
jmp LClampDone
LClampHigh:
movl $0x7FFF,%eax
LClampDone:
// val = (snd_p[i+1]*snd_vol)>>8;
// if (val > 0x7fff)
// snd_out[i+1] = 0x7fff;
// else if (val < (short)0x8000)
// snd_out[i+1] = (short)0x8000;
// else
// snd_out[i+1] = val;
movl -4(%ebx,%ecx,4),%edx
imull %esi,%edx
sarl $8,%edx
cmpl $0x7FFF,%edx
jg LClampHigh2
cmpl $0xFFFF8000,%edx
jnl LClampDone2
movl $0xFFFF8000,%edx
jmp LClampDone2
LClampHigh2:
movl $0x7FFF,%edx
LClampDone2:
shll $16,%edx
andl $0xFFFF,%eax
orl %eax,%edx
movl %edx,-4(%edi,%ecx,2)
// }
subl $2,%ecx
jnz LWLBLoopTop
// snd_p += snd_linear_count;
popl %ebx
popl %edi
popl %esi
ret
#endif // id386
#endif

174
asm/surf16.s
View file

@ -1,174 +0,0 @@
/*
Copyright (C) 1996-1997 Id Software, Inc.
This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
See the GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*/
//
// surf16.s
// x86 assembly-language 16 bpp surface block drawing code.
//
#ifndef NOASM
#include "asm_i386.h"
#include "asm.h"
#include "asm_draw.h"
#if id386
//----------------------------------------------------------------------
// Surface block drawer
//----------------------------------------------------------------------
.data
k: .long 0
loopentry: .long 0
.align 4
blockjumptable16:
.long LEnter2_16
.long LEnter4_16
.long 0, LEnter8_16
.long 0, 0, 0, LEnter16_16
.text
.align 4
.globl C(R_Surf16Start)
C(R_Surf16Start):
.align 4
.globl C(R_DrawSurfaceBlock16)
C(R_DrawSurfaceBlock16):
pushl %ebp // preserve caller's stack frame
pushl %edi
pushl %esi // preserve register variables
pushl %ebx
movl C(blocksize),%eax
movl C(prowdestbase),%edi
movl C(pbasesource),%esi
movl C(sourcesstep),%ebx
movl blockjumptable16-4(,%eax,2),%ecx
movl %eax,k
movl %ecx,loopentry
movl C(lightleft),%edx
movl C(lightright),%ebp
Lblockloop16:
subl %edx,%ebp
movb C(blockdivshift),%cl
sarl %cl,%ebp
jns Lp1_16
testl C(blockdivmask),%ebp
jz Lp1_16
incl %ebp
Lp1_16:
subl %eax,%eax
subl %ecx,%ecx // high words must be 0 in loop for addressing
jmp *loopentry
.align 4
#include "block16.h"
movl C(pbasesource),%esi
movl C(lightleft),%edx
movl C(lightright),%ebp
movl C(sourcetstep),%eax
movl C(lightrightstep),%ecx
movl C(prowdestbase),%edi
addl %eax,%esi
addl %ecx,%ebp
movl C(lightleftstep),%eax
movl C(surfrowbytes),%ecx
addl %eax,%edx
addl %ecx,%edi
movl %esi,C(pbasesource)
movl %ebp,C(lightright)
movl k,%eax
movl %edx,C(lightleft)
decl %eax
movl %edi,C(prowdestbase)
movl %eax,k
jnz Lblockloop16
popl %ebx // restore register variables
popl %esi
popl %edi
popl %ebp // restore the caller's stack frame
ret
.globl C(R_Surf16End)
C(R_Surf16End):
//----------------------------------------------------------------------
// Code patching routines
//----------------------------------------------------------------------
.data
.align 4
LPatchTable16:
.long LBPatch0-4
.long LBPatch1-4
.long LBPatch2-4
.long LBPatch3-4
.long LBPatch4-4
.long LBPatch5-4
.long LBPatch6-4
.long LBPatch7-4
.long LBPatch8-4
.long LBPatch9-4
.long LBPatch10-4
.long LBPatch11-4
.long LBPatch12-4
.long LBPatch13-4
.long LBPatch14-4
.long LBPatch15-4
.text
.align 4
.globl C(R_Surf16Patch)
C(R_Surf16Patch):
pushl %ebx
movl C(colormap),%eax
movl $LPatchTable16,%ebx
movl $16,%ecx
LPatchLoop16:
movl (%ebx),%edx
addl $4,%ebx
movl %eax,(%edx)
decl %ecx
jnz LPatchLoop16
popl %ebx
ret
#endif // id386
#endif

788
asm/surf8.s
View file

@ -1,788 +0,0 @@
/*
Copyright (C) 1996-1997 Id Software, Inc.
This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
See the GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*/
//
// surf8.s
// x86 assembly-language 8 bpp surface block drawing code.
//
#ifndef NOASM
#include "asm_i386.h"
#include "asm.h"
#include "asm_draw.h"
#if id386
.data
sb_v: .long 0
.text
.align 4
.globl C(R_Surf8Start)
C(R_Surf8Start):
//----------------------------------------------------------------------
// Surface block drawer for mip level 0
//----------------------------------------------------------------------
.align 4
.globl C(R_DrawSurfaceBlock8_mip0)
C(R_DrawSurfaceBlock8_mip0):
pushl %ebp // preserve caller's stack frame
pushl %edi
pushl %esi // preserve register variables
pushl %ebx
// for (v=0 ; v<numvblocks ; v++)
// {
movl C(r_lightptr),%ebx
movl C(r_numvblocks),%eax
movl %eax,sb_v
movl C(prowdestbase),%edi
movl C(pbasesource),%esi
Lv_loop_mip0:
// lightleft = lightptr[0];
// lightright = lightptr[1];
// lightdelta = (lightleft - lightright) & 0xFFFFF;
movl (%ebx),%eax // lightleft
movl 4(%ebx),%edx // lightright
movl %eax,%ebp
movl C(r_lightwidth),%ecx
movl %edx,C(lightright)
subl %edx,%ebp
andl $0xFFFFF,%ebp
leal (%ebx,%ecx,4),%ebx
// lightptr += lightwidth;
movl %ebx,C(r_lightptr)
// lightleftstep = (lightptr[0] - lightleft) >> blockdivshift;
// lightrightstep = (lightptr[1] - lightright) >> blockdivshift;
// lightdeltastep = ((lightleftstep - lightrightstep) & 0xFFFFF) |
// 0xF0000000;
movl 4(%ebx),%ecx // lightptr[1]
movl (%ebx),%ebx // lightptr[0]
subl %eax,%ebx
subl %edx,%ecx
sarl $4,%ecx
orl $0xF0000000,%ebp
sarl $4,%ebx
movl %ecx,C(lightrightstep)
subl %ecx,%ebx
andl $0xFFFFF,%ebx
orl $0xF0000000,%ebx
subl %ecx,%ecx // high word must be 0 in loop for addressing
movl %ebx,C(lightdeltastep)
subl %ebx,%ebx // high word must be 0 in loop for addressing
Lblockloop8_mip0:
movl %ebp,C(lightdelta)
movb 14(%esi),%cl
sarl $4,%ebp
movb %dh,%bh
movb 15(%esi),%bl
addl %ebp,%edx
movb %dh,%ch
addl %ebp,%edx
movb 0x12345678(%ebx),%ah
LBPatch0:
movb 13(%esi),%bl
movb 0x12345678(%ecx),%al
LBPatch1:
movb 12(%esi),%cl
movb %dh,%bh
addl %ebp,%edx
rorl $16,%eax
movb %dh,%ch
addl %ebp,%edx
movb 0x12345678(%ebx),%ah
LBPatch2:
movb 11(%esi),%bl
movb 0x12345678(%ecx),%al
LBPatch3:
movb 10(%esi),%cl
movl %eax,12(%edi)
movb %dh,%bh
addl %ebp,%edx
movb %dh,%ch
addl %ebp,%edx
movb 0x12345678(%ebx),%ah
LBPatch4:
movb 9(%esi),%bl
movb 0x12345678(%ecx),%al
LBPatch5:
movb 8(%esi),%cl
movb %dh,%bh
addl %ebp,%edx
rorl $16,%eax
movb %dh,%ch
addl %ebp,%edx
movb 0x12345678(%ebx),%ah
LBPatch6:
movb 7(%esi),%bl
movb 0x12345678(%ecx),%al
LBPatch7:
movb 6(%esi),%cl
movl %eax,8(%edi)
movb %dh,%bh
addl %ebp,%edx
movb %dh,%ch
addl %ebp,%edx
movb 0x12345678(%ebx),%ah
LBPatch8:
movb 5(%esi),%bl
movb 0x12345678(%ecx),%al
LBPatch9:
movb 4(%esi),%cl
movb %dh,%bh
addl %ebp,%edx
rorl $16,%eax
movb %dh,%ch
addl %ebp,%edx
movb 0x12345678(%ebx),%ah
LBPatch10:
movb 3(%esi),%bl
movb 0x12345678(%ecx),%al
LBPatch11:
movb 2(%esi),%cl
movl %eax,4(%edi)
movb %dh,%bh
addl %ebp,%edx
movb %dh,%ch
addl %ebp,%edx
movb 0x12345678(%ebx),%ah
LBPatch12:
movb 1(%esi),%bl
movb 0x12345678(%ecx),%al
LBPatch13:
movb (%esi),%cl
movb %dh,%bh
addl %ebp,%edx
rorl $16,%eax
movb %dh,%ch
movb 0x12345678(%ebx),%ah
LBPatch14:
movl C(lightright),%edx
movb 0x12345678(%ecx),%al
LBPatch15:
movl C(lightdelta),%ebp
movl %eax,(%edi)
addl C(sourcetstep),%esi
addl C(surfrowbytes),%edi
addl C(lightrightstep),%edx
addl C(lightdeltastep),%ebp
movl %edx,C(lightright)
jc Lblockloop8_mip0
// if (pbasesource >= r_sourcemax)
// pbasesource -= stepback;
cmpl C(r_sourcemax),%esi
jb LSkip_mip0
subl C(r_stepback),%esi
LSkip_mip0:
movl C(r_lightptr),%ebx
decl sb_v
jnz Lv_loop_mip0
popl %ebx // restore register variables
popl %esi
popl %edi
popl %ebp // restore the caller's stack frame
ret
//----------------------------------------------------------------------
// Surface block drawer for mip level 1
//----------------------------------------------------------------------
.align 4
.globl C(R_DrawSurfaceBlock8_mip1)
C(R_DrawSurfaceBlock8_mip1):
pushl %ebp // preserve caller's stack frame
pushl %edi
pushl %esi // preserve register variables
pushl %ebx
// for (v=0 ; v<numvblocks ; v++)
// {
movl C(r_lightptr),%ebx
movl C(r_numvblocks),%eax
movl %eax,sb_v
movl C(prowdestbase),%edi
movl C(pbasesource),%esi
Lv_loop_mip1:
// lightleft = lightptr[0];
// lightright = lightptr[1];
// lightdelta = (lightleft - lightright) & 0xFFFFF;
movl (%ebx),%eax // lightleft
movl 4(%ebx),%edx // lightright
movl %eax,%ebp
movl C(r_lightwidth),%ecx
movl %edx,C(lightright)
subl %edx,%ebp
andl $0xFFFFF,%ebp
leal (%ebx,%ecx,4),%ebx
// lightptr += lightwidth;
movl %ebx,C(r_lightptr)
// lightleftstep = (lightptr[0] - lightleft) >> blockdivshift;
// lightrightstep = (lightptr[1] - lightright) >> blockdivshift;
// lightdeltastep = ((lightleftstep - lightrightstep) & 0xFFFFF) |
// 0xF0000000;
movl 4(%ebx),%ecx // lightptr[1]
movl (%ebx),%ebx // lightptr[0]
subl %eax,%ebx
subl %edx,%ecx
sarl $3,%ecx
orl $0x70000000,%ebp
sarl $3,%ebx
movl %ecx,C(lightrightstep)
subl %ecx,%ebx
andl $0xFFFFF,%ebx
orl $0xF0000000,%ebx
subl %ecx,%ecx // high word must be 0 in loop for addressing
movl %ebx,C(lightdeltastep)
subl %ebx,%ebx // high word must be 0 in loop for addressing
Lblockloop8_mip1:
movl %ebp,C(lightdelta)
movb 6(%esi),%cl
sarl $3,%ebp
movb %dh,%bh
movb 7(%esi),%bl
addl %ebp,%edx
movb %dh,%ch
addl %ebp,%edx
movb 0x12345678(%ebx),%ah
LBPatch22:
movb 5(%esi),%bl
movb 0x12345678(%ecx),%al
LBPatch23:
movb 4(%esi),%cl
movb %dh,%bh
addl %ebp,%edx
rorl $16,%eax
movb %dh,%ch
addl %ebp,%edx
movb 0x12345678(%ebx),%ah
LBPatch24:
movb 3(%esi),%bl
movb 0x12345678(%ecx),%al
LBPatch25:
movb 2(%esi),%cl
movl %eax,4(%edi)
movb %dh,%bh
addl %ebp,%edx
movb %dh,%ch
addl %ebp,%edx
movb 0x12345678(%ebx),%ah
LBPatch26:
movb 1(%esi),%bl
movb 0x12345678(%ecx),%al
LBPatch27:
movb (%esi),%cl
movb %dh,%bh
addl %ebp,%edx
rorl $16,%eax
movb %dh,%ch
movb 0x12345678(%ebx),%ah
LBPatch28:
movl C(lightright),%edx
movb 0x12345678(%ecx),%al
LBPatch29:
movl C(lightdelta),%ebp
movl %eax,(%edi)
movl C(sourcetstep),%eax
addl %eax,%esi
movl C(surfrowbytes),%eax
addl %eax,%edi
movl C(lightrightstep),%eax
addl %eax,%edx
movl C(lightdeltastep),%eax
addl %eax,%ebp
movl %edx,C(lightright)
jc Lblockloop8_mip1
// if (pbasesource >= r_sourcemax)
// pbasesource -= stepback;
cmpl C(r_sourcemax),%esi
jb LSkip_mip1
subl C(r_stepback),%esi
LSkip_mip1:
movl C(r_lightptr),%ebx
decl sb_v
jnz Lv_loop_mip1
popl %ebx // restore register variables
popl %esi
popl %edi
popl %ebp // restore the caller's stack frame
ret
//----------------------------------------------------------------------
// Surface block drawer for mip level 2
//----------------------------------------------------------------------
.align 4
.globl C(R_DrawSurfaceBlock8_mip2)
C(R_DrawSurfaceBlock8_mip2):
pushl %ebp // preserve caller's stack frame
pushl %edi
pushl %esi // preserve register variables
pushl %ebx
// for (v=0 ; v<numvblocks ; v++)
// {
movl C(r_lightptr),%ebx
movl C(r_numvblocks),%eax
movl %eax,sb_v
movl C(prowdestbase),%edi
movl C(pbasesource),%esi
Lv_loop_mip2:
// lightleft = lightptr[0];
// lightright = lightptr[1];
// lightdelta = (lightleft - lightright) & 0xFFFFF;
movl (%ebx),%eax // lightleft
movl 4(%ebx),%edx // lightright
movl %eax,%ebp
movl C(r_lightwidth),%ecx
movl %edx,C(lightright)
subl %edx,%ebp
andl $0xFFFFF,%ebp
leal (%ebx,%ecx,4),%ebx
// lightptr += lightwidth;
movl %ebx,C(r_lightptr)
// lightleftstep = (lightptr[0] - lightleft) >> blockdivshift;
// lightrightstep = (lightptr[1] - lightright) >> blockdivshift;
// lightdeltastep = ((lightleftstep - lightrightstep) & 0xFFFFF) |
// 0xF0000000;
movl 4(%ebx),%ecx // lightptr[1]
movl (%ebx),%ebx // lightptr[0]
subl %eax,%ebx
subl %edx,%ecx
sarl $2,%ecx
orl $0x30000000,%ebp
sarl $2,%ebx
movl %ecx,C(lightrightstep)
subl %ecx,%ebx
andl $0xFFFFF,%ebx
orl $0xF0000000,%ebx
subl %ecx,%ecx // high word must be 0 in loop for addressing
movl %ebx,C(lightdeltastep)
subl %ebx,%ebx // high word must be 0 in loop for addressing
Lblockloop8_mip2:
movl %ebp,C(lightdelta)
movb 2(%esi),%cl
sarl $2,%ebp
movb %dh,%bh
movb 3(%esi),%bl
addl %ebp,%edx
movb %dh,%ch
addl %ebp,%edx
movb 0x12345678(%ebx),%ah
LBPatch18:
movb 1(%esi),%bl
movb 0x12345678(%ecx),%al
LBPatch19:
movb (%esi),%cl
movb %dh,%bh
addl %ebp,%edx
rorl $16,%eax
movb %dh,%ch
movb 0x12345678(%ebx),%ah
LBPatch20:
movl C(lightright),%edx
movb 0x12345678(%ecx),%al
LBPatch21:
movl C(lightdelta),%ebp
movl %eax,(%edi)
movl C(sourcetstep),%eax
addl %eax,%esi
movl C(surfrowbytes),%eax
addl %eax,%edi
movl C(lightrightstep),%eax
addl %eax,%edx
movl C(lightdeltastep),%eax
addl %eax,%ebp
movl %edx,C(lightright)
jc Lblockloop8_mip2
// if (pbasesource >= r_sourcemax)
// pbasesource -= stepback;
cmpl C(r_sourcemax),%esi
jb LSkip_mip2
subl C(r_stepback),%esi
LSkip_mip2:
movl C(r_lightptr),%ebx
decl sb_v
jnz Lv_loop_mip2
popl %ebx // restore register variables
popl %esi
popl %edi
popl %ebp // restore the caller's stack frame
ret
//----------------------------------------------------------------------
// Surface block drawer for mip level 3
//----------------------------------------------------------------------
.align 4
.globl C(R_DrawSurfaceBlock8_mip3)
C(R_DrawSurfaceBlock8_mip3):
pushl %ebp // preserve caller's stack frame
pushl %edi
pushl %esi // preserve register variables
pushl %ebx
// for (v=0 ; v<numvblocks ; v++)
// {
movl C(r_lightptr),%ebx
movl C(r_numvblocks),%eax
movl %eax,sb_v
movl C(prowdestbase),%edi
movl C(pbasesource),%esi
Lv_loop_mip3:
// lightleft = lightptr[0];
// lightright = lightptr[1];
// lightdelta = (lightleft - lightright) & 0xFFFFF;
movl (%ebx),%eax // lightleft
movl 4(%ebx),%edx // lightright
movl %eax,%ebp
movl C(r_lightwidth),%ecx
movl %edx,C(lightright)
subl %edx,%ebp
andl $0xFFFFF,%ebp
leal (%ebx,%ecx,4),%ebx
movl %ebp,C(lightdelta)
// lightptr += lightwidth;
movl %ebx,C(r_lightptr)
// lightleftstep = (lightptr[0] - lightleft) >> blockdivshift;
// lightrightstep = (lightptr[1] - lightright) >> blockdivshift;
// lightdeltastep = ((lightleftstep - lightrightstep) & 0xFFFFF) |
// 0xF0000000;
movl 4(%ebx),%ecx // lightptr[1]
movl (%ebx),%ebx // lightptr[0]
subl %eax,%ebx
subl %edx,%ecx
sarl $1,%ecx
sarl $1,%ebx
movl %ecx,C(lightrightstep)
subl %ecx,%ebx
andl $0xFFFFF,%ebx
sarl $1,%ebp
orl $0xF0000000,%ebx
movl %ebx,C(lightdeltastep)
subl %ebx,%ebx // high word must be 0 in loop for addressing
movb 1(%esi),%bl
subl %ecx,%ecx // high word must be 0 in loop for addressing
movb %dh,%bh
movb (%esi),%cl
addl %ebp,%edx
movb %dh,%ch
movb 0x12345678(%ebx),%al
LBPatch16:
movl C(lightright),%edx
movb %al,1(%edi)
movb 0x12345678(%ecx),%al
LBPatch17:
movb %al,(%edi)
movl C(sourcetstep),%eax
addl %eax,%esi
movl C(surfrowbytes),%eax
addl %eax,%edi
movl C(lightdeltastep),%eax
movl C(lightdelta),%ebp
movb (%esi),%cl
addl %eax,%ebp
movl C(lightrightstep),%eax
sarl $1,%ebp
addl %eax,%edx
movb %dh,%bh
movb 1(%esi),%bl
addl %ebp,%edx
movb %dh,%ch
movb 0x12345678(%ebx),%al
LBPatch30:
movl C(sourcetstep),%edx
movb %al,1(%edi)
movb 0x12345678(%ecx),%al
LBPatch31:
movb %al,(%edi)
movl C(surfrowbytes),%ebp
addl %edx,%esi
addl %ebp,%edi
// if (pbasesource >= r_sourcemax)
// pbasesource -= stepback;
cmpl C(r_sourcemax),%esi
jb LSkip_mip3
subl C(r_stepback),%esi
LSkip_mip3:
movl C(r_lightptr),%ebx
decl sb_v
jnz Lv_loop_mip3
popl %ebx // restore register variables
popl %esi
popl %edi
popl %ebp // restore the caller's stack frame
ret
.globl C(R_Surf8End)
C(R_Surf8End):
//----------------------------------------------------------------------
// Code patching routines
//----------------------------------------------------------------------
.data
.align 4
LPatchTable8:
.long LBPatch0-4
.long LBPatch1-4
.long LBPatch2-4
.long LBPatch3-4
.long LBPatch4-4
.long LBPatch5-4
.long LBPatch6-4
.long LBPatch7-4
.long LBPatch8-4
.long LBPatch9-4
.long LBPatch10-4
.long LBPatch11-4
.long LBPatch12-4
.long LBPatch13-4
.long LBPatch14-4
.long LBPatch15-4
.long LBPatch16-4
.long LBPatch17-4
.long LBPatch18-4
.long LBPatch19-4
.long LBPatch20-4
.long LBPatch21-4
.long LBPatch22-4
.long LBPatch23-4
.long LBPatch24-4
.long LBPatch25-4
.long LBPatch26-4
.long LBPatch27-4
.long LBPatch28-4
.long LBPatch29-4
.long LBPatch30-4
.long LBPatch31-4
.text
.align 4
.globl C(R_Surf8Patch)
C(R_Surf8Patch):
pushl %ebx
movl C(colormap),%eax
movl $LPatchTable8,%ebx
movl $32,%ecx
LPatchLoop8:
movl (%ebx),%edx
addl $4,%ebx
movl %eax,(%edx)
decl %ecx
jnz LPatchLoop8
popl %ebx
ret
#endif // id386
#endif

735
asm/surf8fst.s
View file

@ -1,735 +0,0 @@
/*
Copyright (C) 1996-1997 Id Software, Inc.
This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
See the GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*/
//
// surf8.s
// x86 assembly-language 8 bpp surface block drawing code.
//
#ifndef NOASM
#include "asm_i386.h"
#include "asm.h"
#include "asm_draw.h"
#if id386
.data
sb_v: .long 0
.text
.align 4
.globl C(R_Surf8FastStart)
C(R_Surf8FastStart):
//----------------------------------------------------------------------
// Surface block drawer for mip level 0
//----------------------------------------------------------------------
.align 4
.globl C(R_DrawSurfaceBlock8Fast_mip0)
C(R_DrawSurfaceBlock8Fast_mip0):
pushl %ebp // preserve caller's stack frame
pushl %edi
pushl %esi // preserve register variables
pushl %ebx
// for (v=0 ; v<numvblocks ; v++)
// {
movl C(r_lightptr),%ebx
movl C(r_numvblocks),%eax
movl %eax,sb_v
movl C(prowdestbase),%edi
movl C(pbasesource),%esi
Lv_loop_mip0:
// lightleft = lightptr[0];
// lightright = lightptr[1];
// lightdelta = (lightleft - lightright) & 0xFFFFF;
movl (%ebx),%eax // lightleft
movl 4(%ebx),%edx // lightright
movl %eax,%ebp
movl C(r_lightwidth),%ecx
movl %edx,C(lightright)
subl %edx,%ebp
andl $0x0,%ebp
leal (%ebx,%ecx,4),%ebx
// lightptr += lightwidth;
movl %ebx,C(r_lightptr)
// lightleftstep = (lightptr[0] - lightleft) >> blockdivshift;
// lightrightstep = (lightptr[1] - lightright) >> blockdivshift;
// lightdeltastep = ((lightleftstep - lightrightstep) & 0xFFFFF) |
// 0xF0000000;
movl 4(%ebx),%ecx // lightptr[1]
movl (%ebx),%ebx // lightptr[0]
subl %eax,%ebx
subl %edx,%ecx
sarl $4,%ecx
orl $0xF0000000,%ebp
sarl $4,%ebx
movl %ecx,C(lightrightstep)
subl %ecx,%ebx
andl $0x0,%ebx
orl $0xF0000000,%ebx
subl %ecx,%ecx // high word must be 0 in loop for addressing
movl %ebx,C(lightdeltastep)
subl %ebx,%ebx // high word must be 0 in loop for addressing
Lblockloop8_mip0:
movl %ebp,C(lightdelta)
movb 14(%esi),%cl
movb %dh,%bh
movb 15(%esi),%bl
movb %dh,%ch
movb 0x12345678(%ebx),%ah
LBPatch0:
movb 13(%esi),%bl
movb 0x12345678(%ecx),%al
LBPatch1:
movb 12(%esi),%cl
movb %dh,%bh
rorl $16,%eax
movb %dh,%ch
movb 0x12345678(%ebx),%ah
LBPatch2:
movb 11(%esi),%bl
movb 0x12345678(%ecx),%al
LBPatch3:
movb 10(%esi),%cl
movl %eax,12(%edi)
movb 0x12345678(%ebx),%ah
LBPatch4:
movb 9(%esi),%bl
movb 0x12345678(%ecx),%al
LBPatch5:
movb 8(%esi),%cl
rorl $16,%eax
movb %dh,%ch
movb 0x12345678(%ebx),%ah
LBPatch6:
movb 7(%esi),%bl
movb 0x12345678(%ecx),%al
LBPatch7:
movb 6(%esi),%cl
movl %eax,8(%edi)
movb 0x12345678(%ebx),%ah
LBPatch8:
movb 5(%esi),%bl
movb 0x12345678(%ecx),%al
LBPatch9:
movb 4(%esi),%cl
rorl $16,%eax
movb 0x12345678(%ebx),%ah
LBPatch10:
movb 3(%esi),%bl
movb 0x12345678(%ecx),%al
LBPatch11:
movb 2(%esi),%cl
movl %eax,4(%edi)
movb 0x12345678(%ebx),%ah
LBPatch12:
movb 1(%esi),%bl
movb 0x12345678(%ecx),%al
LBPatch13:
movb (%esi),%cl
rorl $16,%eax
movb %dh,%ch
movb 0x12345678(%ebx),%ah
LBPatch14:
movl C(lightright),%edx
movb 0x12345678(%ecx),%al
LBPatch15:
movl C(lightdelta),%ebp
movl %eax,(%edi)
addl C(sourcetstep),%esi // Comment this out to do super low detail.
addl C(surfrowbytes),%edi
addl C(lightdeltastep),%ebp
movl %edx,C(lightleft)
jc Lblockloop8_mip0
// if (pbasesource >= r_sourcemax)
// pbasesource -= stepback;
cmpl C(r_sourcemax),%esi
jb LSkip_mip0
subl C(r_stepback),%esi
LSkip_mip0:
movl C(r_lightptr),%ebx
decl sb_v
jnz Lv_loop_mip0
popl %ebx // restore register variables
popl %esi
popl %edi
popl %ebp // restore the caller's stack frame
ret
//----------------------------------------------------------------------
// Surface block drawer for mip level 1
//----------------------------------------------------------------------
.align 4
.globl C(R_DrawSurfaceBlock8Fast_mip1)
C(R_DrawSurfaceBlock8Fast_mip1):
pushl %ebp // preserve caller's stack frame
pushl %edi
pushl %esi // preserve register variables
pushl %ebx
// for (v=0 ; v<numvblocks ; v++)
// {
movl C(r_lightptr),%ebx
movl C(r_numvblocks),%eax
movl %eax,sb_v
movl C(prowdestbase),%edi
movl C(pbasesource),%esi
Lv_loop_mip1:
// lightleft = lightptr[0];
// lightright = lightptr[1];
// lightdelta = (lightleft - lightright) & 0xFFFFF;
movl (%ebx),%eax // lightleft
movl 4(%ebx),%edx // lightright
movl %eax,%ebp
movl C(r_lightwidth),%ecx
movl %edx,C(lightright)
subl %edx,%ebp
andl $0x0,%ebp
leal (%ebx,%ecx,4),%ebx
// lightptr += lightwidth;
movl %ebx,C(r_lightptr)
// lightleftstep = (lightptr[0] - lightleft) >> blockdivshift;
// lightrightstep = (lightptr[1] - lightright) >> blockdivshift;
// lightdeltastep = ((lightleftstep - lightrightstep) & 0xFFFFF) |
// 0xF0000000;
movl 4(%ebx),%ecx // lightptr[1]
movl (%ebx),%ebx // lightptr[0]
subl %eax,%ebx
subl %edx,%ecx
sarl $3,%ecx
orl $0x70000000,%ebp
sarl $3,%ebx
movl %ecx,C(lightrightstep)
subl %ecx,%ebx
andl $0x0,%ebx
orl $0xF0000000,%ebx
subl %ecx,%ecx // high word must be 0 in loop for addressing
movl %ebx,C(lightdeltastep)
subl %ebx,%ebx // high word must be 0 in loop for addressing
Lblockloop8_mip1:
movl %ebp,C(lightdelta)
movb 6(%esi),%cl
sarl $3,%ebp
movb %dh,%bh
movb 7(%esi),%bl
movb %dh,%ch
movb 0x12345678(%ebx),%ah
LBPatch22:
movb 5(%esi),%bl
movb 0x12345678(%ecx),%al
LBPatch23:
movb 4(%esi),%cl
movb %dh,%bh
rorl $16,%eax
movb %dh,%ch
movb 0x12345678(%ebx),%ah
LBPatch24:
movb 3(%esi),%bl
movb 0x12345678(%ecx),%al
LBPatch25:
movb 2(%esi),%cl
movl %eax,4(%edi)
movb 0x12345678(%ebx),%ah
LBPatch26:
movb 1(%esi),%bl
movb 0x12345678(%ecx),%al
LBPatch27:
movb (%esi),%cl
rorl $16,%eax
movb 0x12345678(%ebx),%ah
LBPatch28:
movl C(lightright),%edx
movb 0x12345678(%ecx),%al
LBPatch29:
movl C(lightdelta),%ebp
movl %eax,(%edi)
movl C(sourcetstep),%eax
addl %eax,%esi
movl C(surfrowbytes),%eax
addl %eax,%edi
movl C(lightrightstep),%eax
addl %eax,%edx
movl C(lightdeltastep),%eax
addl %eax,%ebp
movl %edx,C(lightleft)
jc Lblockloop8_mip1
// if (pbasesource >= r_sourcemax)
// pbasesource -= stepback;
cmpl C(r_sourcemax),%esi
jb LSkip_mip1
subl C(r_stepback),%esi
LSkip_mip1:
movl C(r_lightptr),%ebx
decl sb_v
jnz Lv_loop_mip1
popl %ebx // restore register variables
popl %esi
popl %edi
popl %ebp // restore the caller's stack frame
ret
//----------------------------------------------------------------------
// Surface block drawer for mip level 2
//----------------------------------------------------------------------
.align 4
.globl C(R_DrawSurfaceBlock8Fast_mip2)
C(R_DrawSurfaceBlock8Fast_mip2):
pushl %ebp // preserve caller's stack frame
pushl %edi
pushl %esi // preserve register variables
pushl %ebx
// for (v=0 ; v<numvblocks ; v++)
// {
movl C(r_lightptr),%ebx
movl C(r_numvblocks),%eax
movl %eax,sb_v
movl C(prowdestbase),%edi
movl C(pbasesource),%esi
Lv_loop_mip2:
// lightleft = lightptr[0];
// lightright = lightptr[1];
// lightdelta = (lightleft - lightright) & 0xFFFFF;
movl (%ebx),%eax // lightleft
movl 4(%ebx),%edx // lightright
movl %eax,%ebp
movl C(r_lightwidth),%ecx
movl %edx,C(lightright)
subl %edx,%ebp
andl $0x0,%ebp
leal (%ebx,%ecx,4),%ebx
// lightptr += lightwidth;
movl %ebx,C(r_lightptr)
// lightleftstep = (lightptr[0] - lightleft) >> blockdivshift;
// lightrightstep = (lightptr[1] - lightright) >> blockdivshift;
// lightdeltastep = ((lightleftstep - lightrightstep) & 0xFFFFF) |
// 0xF0000000;
movl 4(%ebx),%ecx // lightptr[1]
movl (%ebx),%ebx // lightptr[0]
subl %eax,%ebx
subl %edx,%ecx
sarl $2,%ecx
orl $0x30000000,%ebp
sarl $2,%ebx
movl %ecx,C(lightrightstep)
subl %ecx,%ebx
andl $0x0,%ebx
orl $0xF0000000,%ebx
subl %ecx,%ecx // high word must be 0 in loop for addressing
movl %ebx,C(lightdeltastep)
subl %ebx,%ebx // high word must be 0 in loop for addressing
Lblockloop8_mip2:
movl %ebp,C(lightdelta)
movb 2(%esi),%cl
sarl $2,%ebp
movb %dh,%bh
movb 3(%esi),%bl
movb %dh,%ch
movb 0x12345678(%ebx),%ah
LBPatch18:
movb 1(%esi),%bl
movb 0x12345678(%ecx),%al
LBPatch19:
movb (%esi),%cl
rorl $16,%eax
movb %dh,%ch
movb 0x12345678(%ebx),%ah
LBPatch20:
movl C(lightright),%edx
movb 0x12345678(%ecx),%al
LBPatch21:
movl C(lightdelta),%ebp
movl %eax,(%edi)
movl C(sourcetstep),%eax
addl %eax,%esi
movl C(surfrowbytes),%eax
addl %eax,%edi
movl C(lightrightstep),%eax
addl %eax,%edx
movl C(lightdeltastep),%eax
addl %eax,%ebp
movl %edx,C(lightleft)
jc Lblockloop8_mip2
// if (pbasesource >= r_sourcemax)
// pbasesource -= stepback;
cmpl C(r_sourcemax),%esi
jb LSkip_mip2
subl C(r_stepback),%esi
LSkip_mip2:
movl C(r_lightptr),%ebx
decl sb_v
jnz Lv_loop_mip2
popl %ebx // restore register variables
popl %esi
popl %edi
popl %ebp // restore the caller's stack frame
ret
//----------------------------------------------------------------------
// Surface block drawer for mip level 3
//----------------------------------------------------------------------
.align 4
.globl C(R_DrawSurfaceBlock8Fast_mip3)
C(R_DrawSurfaceBlock8Fast_mip3):
pushl %ebp // preserve caller's stack frame
pushl %edi
pushl %esi // preserve register variables
pushl %ebx
// for (v=0 ; v<numvblocks ; v++)
// {
movl C(r_lightptr),%ebx
movl C(r_numvblocks),%eax
movl %eax,sb_v
movl C(prowdestbase),%edi
movl C(pbasesource),%esi
Lv_loop_mip3:
// lightleft = lightptr[0];
// lightright = lightptr[1];
// lightdelta = (lightleft - lightright) & 0xFFFFF;
movl (%ebx),%eax // lightleft
movl 4(%ebx),%edx // lightright
movl %eax,%ebp
movl C(r_lightwidth),%ecx
movl %edx,C(lightright)
subl %edx,%ebp
andl $0x0,%ebp
leal (%ebx,%ecx,4),%ebx
movl %ebp,C(lightdelta)
// lightptr += lightwidth;
movl %ebx,C(r_lightptr)
// lightleftstep = (lightptr[0] - lightleft) >> blockdivshift;
// lightrightstep = (lightptr[1] - lightright) >> blockdivshift;
// lightdeltastep = ((lightleftstep - lightrightstep) & 0xFFFFF) |
// 0xF0000000;
movl 4(%ebx),%ecx // lightptr[1]
movl (%ebx),%ebx // lightptr[0]
subl %eax,%ebx
subl %edx,%ecx
sarl $1,%ecx
sarl $1,%ebx
movl %ecx,C(lightrightstep)
subl %ecx,%ebx
andl $0x0,%ebx
sarl $1,%ebp
orl $0xF0000000,%ebx
movl %ebx,C(lightdeltastep)
subl %ebx,%ebx // high word must be 0 in loop for addressing
movb 1(%esi),%bl
subl %ecx,%ecx // high word must be 0 in loop for addressing
movb %dh,%bh
movb (%esi),%cl
movb %dh,%ch
movb 0x12345678(%ebx),%al
LBPatch16:
movl C(lightright),%edx
movb %al,1(%edi)
movb 0x12345678(%ecx),%al
LBPatch17:
movb %al,(%edi)
movl C(sourcetstep),%eax
addl %eax,%esi
movl C(surfrowbytes),%eax
addl %eax,%edi
movl C(lightdeltastep),%eax
movl C(lightdelta),%ebp
movb (%esi),%cl
addl %eax,%ebp
movl C(lightrightstep),%eax
sarl $1,%ebp
addl %eax,%edx
movb %dh,%bh
movb 1(%esi),%bl
movb 0x12345678(%ebx),%al
LBPatch30:
movl C(sourcetstep),%edx
movb %al,1(%edi)
movb 0x12345678(%ecx),%al
LBPatch31:
movb %al,(%edi)
movl C(surfrowbytes),%ebp
addl %edx,%esi
addl %ebp,%edi
// if (pbasesource >= r_sourcemax)
// pbasesource -= stepback;
cmpl C(r_sourcemax),%esi
jb LSkip_mip3
subl C(r_stepback),%esi
LSkip_mip3:
movl C(r_lightptr),%ebx
decl sb_v
jnz Lv_loop_mip3
popl %ebx // restore register variables
popl %esi
popl %edi
popl %ebp // restore the caller's stack frame
ret
.globl C(R_Surf8FastEnd)
C(R_Surf8FastEnd):
//----------------------------------------------------------------------
// Code patching routines
//----------------------------------------------------------------------
.data
.align 4
LPatchTable8:
.long LBPatch0-4
.long LBPatch1-4
.long LBPatch2-4
.long LBPatch3-4
.long LBPatch4-4
.long LBPatch5-4
.long LBPatch6-4
.long LBPatch7-4
.long LBPatch8-4
.long LBPatch9-4
.long LBPatch10-4
.long LBPatch11-4
.long LBPatch12-4
.long LBPatch13-4
.long LBPatch14-4
.long LBPatch15-4
.long LBPatch16-4
.long LBPatch17-4
.long LBPatch18-4
.long LBPatch19-4
.long LBPatch20-4
.long LBPatch21-4
.long LBPatch22-4
.long LBPatch23-4
.long LBPatch24-4
.long LBPatch25-4
.long LBPatch26-4
.long LBPatch27-4
.long LBPatch28-4
.long LBPatch29-4
.long LBPatch30-4
.long LBPatch31-4
.text
.align 4
.globl C(R_Surf8FastPatch)
C(R_Surf8FastPatch):
pushl %ebx
movl C(colormap),%eax
movl $LPatchTable8,%ebx
movl $32,%ecx
LPatchLoop8:
movl (%ebx),%edx
addl $4,%ebx
movl %eax,(%edx)
decl %ecx
jnz LPatchLoop8
popl %ebx
ret
#endif // id386
#endif

256
asm/sys.s
View file

@ -1,256 +0,0 @@
/*
Copyright (C) 1996-1997 Id Software, Inc.
This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
See the GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*/
//
// sys_dosa.s
// x86 assembly-language DOS-dependent routines.
#ifndef NOASM
#include "asm_i386.h"
#include "asm.h"
.data
.align 4
fpenv:
.long 0, 0, 0, 0, 0, 0, 0, 0
.text
.globl C(MaskExceptions)
C(MaskExceptions):
fnstenv fpenv
orl $0x3F,fpenv
fldenv fpenv
ret
#if 0
.globl C(unmaskexceptions)
C(unmaskexceptions):
fnstenv fpenv
andl $0xFFFFFFE0,fpenv
fldenv fpenv
ret
#endif
.data
.align 4
.globl ceil_cw, single_cw, full_cw, cw, pushed_cw
ceil_cw: .long 0
single_cw: .long 0
full_cw: .long 0
cw: .long 0
pushed_cw: .long 0
.text
.globl C(Sys_LowFPPrecision)
C(Sys_LowFPPrecision):
fldcw single_cw
ret
.globl C(Sys_HighFPPrecision)
C(Sys_HighFPPrecision):
fldcw full_cw
ret
.globl C(Sys_PushFPCW_SetHigh)
C(Sys_PushFPCW_SetHigh):
fnstcw pushed_cw
fldcw full_cw
ret
.globl C(Sys_PopFPCW)
C(Sys_PopFPCW):
fldcw pushed_cw
ret
.globl C(Sys_SetFPCW)
C(Sys_SetFPCW):
fnstcw cw
movl cw,%eax
#if id386
andb $0xF0,%ah
orb $0x03,%ah // round mode, 64-bit precision
#endif
movl %eax,full_cw
#if id386
andb $0xF0,%ah
orb $0x0C,%ah // chop mode, single precision
#endif
movl %eax,single_cw
#if id386
andb $0xF0,%ah
orb $0x08,%ah // ceil mode, single precision
#endif
movl %eax,ceil_cw
ret
.intel_syntax noprefix
.globl C(SetYourBlues)
C(SetYourBlues):
push ax
push dx
mov dx, 0x3C8
mov ax, 1
out dx, al
inc dx
mov ax, 1
out dx, al
mov ax, 5
out dx, al
mov ax, 16
out dx, al
pop dx
pop ax
ret
.globl C(SetYourBrowns)
C(SetYourBrowns):
// Quake startup text mode scheme
// background brown
push ax
push dx
mov dx, 0x3C8
mov ax, 1
out dx, al
inc dx
mov ax, 14
out dx, al
mov ax, 9
out dx, al
mov ax, 4
out dx, al
pop dx
pop ax
// Console-style REALLY background brown, kind of cool
push ax
push dx
mov dx, 0x3C8
mov ax, 0
out dx, al
inc dx
mov ax, 12
out dx, al
mov ax, 7
out dx, al
mov ax, 2
out dx, al
pop dx
pop ax
// status grays (are now brown)
/*
push ax
push dx
mov dx, 0x3C8
mov ax, 7
out dx, al
inc dx
mov ax, 121
out dx, al
mov ax, 110
out dx, al
mov ax, 22
out dx, al
pop dx
pop ax
*/
push ax
push dx
mov dx, 0x3C8
mov ax, 7
out dx, al
inc dx
mov ax, 48
out dx, al
mov ax, 48
out dx, al
mov ax, 48
out dx, al
pop dx
pop ax
// Title bar
push ax
push dx
mov dx, 0x3C8
mov ax, 2
out dx, al
inc dx
mov ax, 56
out dx, al
mov ax, 48
out dx, al
mov ax, 15
out dx, al
pop dx
pop ax
ret
#endif

146
asm/worlda.s
View file

@ -1,146 +0,0 @@
/*
Copyright (C) 1996-1997 Id Software, Inc.
This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
See the GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*/
//
// worlda.s
// x86 assembly-language server testing stuff
//
#ifndef NOASM
#define GLQUAKE 1 // don't include unneeded client defs
#include "asm_i386.h"
#include "asm.h"
//#include "d_ifacea.h" //don't include unneeded defs // 2001-12-28 Merged assembler files of Quake and QuakeWorld by Maddes
#if id386
.data
Ltemp: .long 0
.text
//----------------------------------------------------------------------
// hull-point test
//----------------------------------------------------------------------
#define hull 4+8 // because only partially pushed
#define num 8+4 // because only partially pushed
#define p 12+12 // because only partially pushed
.align 4
.globl C(SV_HullPointContents)
C(SV_HullPointContents):
pushl %edi // preserve register variables
movl num(%esp),%eax
testl %eax,%eax
js Lhquickout
// float d;
// dclipnode_t *node;
// mplane_t *plane;
pushl %ebx
movl hull(%esp),%ebx
pushl %ebp
movl p(%esp),%edx
movl hu_clipnodes(%ebx),%edi
movl hu_planes(%ebx),%ebp
subl %ebx,%ebx
pushl %esi
// %ebx: 0
// %eax: num
// %edx: p
// %edi: hull->clipnodes
// %ebp: hull->planes
// while (num >= 0)
// {
Lhloop:
// node = hull->clipnodes + num;
// plane = hull->planes + node->planenum;
// !!! if the size of dclipnode_t changes, the scaling of %eax needs to be
// changed !!!
movl nd_planenum(%edi,%eax,8),%ecx
movl nd_children(%edi,%eax,8),%eax
movl %eax,%esi
rorl $16,%eax
leal (%ecx,%ecx,4),%ecx
// if (plane->type < 3)
// d = p[plane->type] - plane->dist;
movb pl_type(%ebp,%ecx,4),%bl // QW SV was: movl pl_type(%ebp,%ecx,4),%bl // 2001-12-28 Merged assembler files of Quake and QuakeWorld by Maddes
cmpb $3,%bl
jb Lnodot
// else
// d = DotProduct (plane->normal, p) - plane->dist;
flds pl_normal(%ebp,%ecx,4)
fmuls 0(%edx)
flds pl_normal+4(%ebp,%ecx,4)
fmuls 4(%edx)
flds pl_normal+8(%ebp,%ecx,4)
fmuls 8(%edx)
fxch %st(1)
faddp %st(0),%st(2)
faddp %st(0),%st(1)
fsubs pl_dist(%ebp,%ecx,4)
jmp Lsub
Lnodot:
flds pl_dist(%ebp,%ecx,4)
fsubrs (%edx,%ebx,4)
Lsub:
sarl $16,%eax
sarl $16,%esi
// if (d < 0)
// num = node->children[1];
// else
// num = node->children[0];
fstps Ltemp
movl Ltemp,%ecx
sarl $31,%ecx
andl %ecx,%esi
xorl $0xFFFFFFFF,%ecx
andl %ecx,%eax
orl %esi,%eax
jns Lhloop
// return num;
Lhdone:
popl %esi
popl %ebp
popl %ebx // restore register variables
Lhquickout:
popl %edi
ret
#endif // id386
#endif

4
engine/cl_bot.c
View file

@ -193,12 +193,12 @@ char *PickBotName (int r)
else if (r == 4) return "Travis";
else if (r == 5) return "Shawn";
else if (r == 6) return "Steve";
else if (r == 7) return "Dave";
else if (r == 7) return "Eukos";
else if (r == 8) return "Croft";
else if (r == 9) return "James";
else if (r == 10) return "Scott";
else if (r == 11) return "Ridley";
else if (r == 12) return "Mister";
else if (r == 12) return "Joebama";
else if (r == 13) return "Cobocho";
else if (r == 14) return "Radon";
else if (r == 15) return "Maxwell";

20
engine/cl_chase.c
View file

@ -49,7 +49,7 @@ float deathcam_whenidied; // sets to time if died, used for timing deathcam eff
float deathcam_whenidiedafter; // used to time the sinks into the floor or the rankings appearing.....
vec3_t deathcam_angles; // this'll update chase angles when we're dead so we don't move the
// player - so we can rotate the death cam in cl_diecam 3.
int deathcam_yesiamdead; // pretty stupid indicator of dead.
int deathcam_active; // pretty stupid indicator of dead.
void Chase_Init_Cvars (void)
{
@ -90,7 +90,7 @@ void Chase_Update (void)
deest = sv.time - deathcam_whenidied;
if(deathcam_yesiamdead == 4)
if(deathcam_active == 4)
{
if (deest < 1)
{
@ -106,13 +106,13 @@ void Chase_Update (void)
}
// if can't see player, reset
if(deathcam_yesiamdead)
if(deathcam_active)
AngleVectors (deathcam_angles, forward, right, up);
else
AngleVectors (cl.viewangles, forward, right, up);
// calc exact destination
if (deathcam_yesiamdead == 2) // close, nonspinnable
if (deathcam_active == 2) // close, nonspinnable
{
AngleVectors (cl.viewangles, forward, right, up);
for (i=0 ; i<3 ; i++)
@ -120,13 +120,13 @@ void Chase_Update (void)
chase_dest[2] = r_refdef.vieworg[2];
dontspinme = 1;
}
else if (deathcam_yesiamdead == 3) // spinabble...
else if (deathcam_active == 3) // spinabble...
{
for (i=0 ; i<3 ; i++)
chase_dest[i] = r_refdef.vieworg[i] - forward[i]*150 - right[i]*0;
dontspinme = 0;
}
else if (deathcam_yesiamdead == 4) // non spinabble... and after a duration it kinda increases....
else if (deathcam_active == 4) // non spinabble... and after a duration it kinda increases....
{
if (deest < 1)
deest = 0;
@ -160,28 +160,28 @@ void Chase_Update (void)
// The..... style?
if (deathcam_yesiamdead == 1)
if (deathcam_active == 1)
{
r_refdef.viewangles[YAW] = deathcam_angles[YAW];
r_refdef.viewangles[PITCH] = deathcam_angles[PITCH];
r_refdef.viewangles[ROLL] = deathcam_angles[ROLL];
}
// The Q3 style - fixed pitch and yaw
else if (deathcam_yesiamdead == 2)
else if (deathcam_active == 2)
{
r_refdef.viewangles[YAW] = cl.viewangles[YAW];
r_refdef.viewangles[PITCH] = 0;
r_refdef.viewangles[ROLL] = 0;
}
// The U style
else if (deathcam_yesiamdead == 3)
else if (deathcam_active == 3)
{
r_refdef.viewangles[YAW] = deathcam_angles[YAW];
r_refdef.viewangles[PITCH] = deathcam_angles[PITCH];
r_refdef.viewangles[ROLL] = deathcam_angles[ROLL];
}
// The DX style
else if (deathcam_yesiamdead == 4)
else if (deathcam_active == 4)
{
if (deest < 1)
{

35
engine/cl_input.c
View file

@ -287,7 +287,7 @@ void CL_AdjustAngles (void)
}
extern int deathcam_yesiamdead;
extern int deathcam_active;
extern vec3_t deathcam_angles;
// leilei - deathcam hacks suck!
void CL_AdjustAnglesWhenYoureDead (void)
@ -343,8 +343,8 @@ void CL_BaseMove (usercmd_t *cmd)
return;
if (deathcam_yesiamdead)
CL_AdjustAnglesWhenYoureDead ();
if (deathcam_active)
CL_AdjustAnglesWhenYoureDead ();
else
CL_AdjustAngles ();
@ -368,9 +368,7 @@ void CL_BaseMove (usercmd_t *cmd)
cmd->forwardmove -= cl_backspeed->value * CL_KeyState (&in_back);
}
//
// adjust for speed key
//
// adjust for speed key
if (in_speed.state & 1)
{
cmd->forwardmove *= cl_movespeedkey->value;
@ -408,14 +406,10 @@ void CL_SendMove (usercmd_t *cmd)
cl.cmd = *cmd;
//
// send the movement message
//
// send the movement message
MSG_WriteByte (&buf, clc_move);
MSG_WriteFloat (&buf, cl.mtime[0]); // so server can get ping times
// 2000-05-01 NVS CLC_move precise aiming by Maddes start
if (nvs_current_cclc->value >= 0.50)
{
for (i=0 ; i<3 ; i++)
@ -425,18 +419,14 @@ void CL_SendMove (usercmd_t *cmd)
}
else
{
// 2000-05-01 NVS CLC_move precise aiming by Maddes end
for (i=0 ; i<3 ; i++)
MSG_WriteAngle (&buf, cl.viewangles[i]);
} // 2000-05-01 NVS CLC_move precise aiming by Maddes
}
MSG_WriteShort (&buf, cmd->forwardmove);
MSG_WriteShort (&buf, cmd->sidemove);
MSG_WriteShort (&buf, cmd->upmove);
//
// send button bits
//
// send button bits
bits = 0;
if ( in_attack.state & 3 )
@ -447,27 +437,18 @@ void CL_SendMove (usercmd_t *cmd)
bits |= 2;
in_jump.state &= ~2;
// 1999-10-29 +USE fix by Maddes start
if (in_use.state & 3)
bits |= 4;
in_use.state &= ~2;
// 1999-10-29 +USE fix by Maddes end
MSG_WriteByte (&buf, bits);
MSG_WriteByte (&buf, in_impulse);
in_impulse = 0;
//
// deliver the message
//
if (cls.demoplayback)
return;
//
// always dump the first two message, because it may contain leftover inputs
// from the last level
//
// always dump the first two messages, because it may contain leftover inputs from the last level
if (++cl.movemessages <= 2)
return;

433
engine/cl_main.c
View file

@ -22,10 +22,6 @@ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
#include "globaldef.h"
// we need to declare some mouse variables here, because the menu system
// references them even when on a unix system.
// these two are not intended to be set directly
cvar_t *cl_name;
cvar_t *cl_color;
@ -49,39 +45,26 @@ cvar_t *m_lockup;
cvar_t *m_lockdown;
cvar_t *cl_showfps; // 2001-11-31 FPS display by QuakeForge/Muff
cvar_t *cl_compatibility; // 2001-12-24 Keeping full backwards compatibility by Maddes
// 2001-09-20 Configurable entity limits by Maddes start
cvar_t *cl_entities_min;
cvar_t *cl_entities_min_static;
cvar_t *cl_entities_min_temp;
// 2001-09-20 Configurable entity limits by Maddes end
client_static_t cls;
client_state_t cl;
// split....
client_static_t clssplit;
client_state_t clsplit;
// FIXME: put these on hunk?
efrag_t cl_efrags[MAX_EFRAGS];
// 2001-09-20 Configurable entity limits by Maddes start
/*
entity_t cl_entities[MAX_EDICTS];
entity_t cl_static_entities[MAX_STATIC_ENTITIES];
*/
entity_t *cl_entities;
entity_t *cl_static_entities;
// 2001-09-20 Configurable entity limits by Maddes end
efrag_t cl_efrags[MAX_EFRAGS];
entity_t *cl_entities;
entity_t *cl_static_entities;
lightstyle_t cl_lightstyle[MAX_LIGHTSTYLES];
dlight_t cl_dlights[MAX_DLIGHTS];
shadow_t cl_shadows[MAX_SHADOWS];
wlight_t cl_wlights[MAX_WLIGHTS];
flare_t cl_flares[MAX_FLARES];
int cl_numvisedicts;
entity_t *cl_visedicts[MAX_VISEDICTS];
dlight_t cl_dlights[MAX_DLIGHTS];
shadow_t cl_shadows[MAX_SHADOWS];
wlight_t cl_wlights[MAX_WLIGHTS];
flare_t cl_flares[MAX_FLARES];
int cl_numvisedicts;
entity_t *cl_visedicts[MAX_VISEDICTS];
/*
=====================
@ -96,27 +79,24 @@ void CL_ClearState (void)
if (!sv.active)
Host_ClearMemory ();
// wipe the entire cl structure
// wipe the entire cl structure
memset (&cl, 0, sizeof(cl));
SZ_Clear (&cls.message);
// clear other arrays
// clear other arrays
memset (cl_efrags, 0, sizeof(cl_efrags));
// memset (cl_entities, 0, sizeof(cl_entities)); // 2001-09-20 Configurable entity limits by Maddes
memset (cl_dlights, 0, sizeof(cl_dlights));
memset (cl_shadows, 0, sizeof(cl_shadows));
memset (cl_wlights, 0, sizeof(cl_wlights));
memset (cl_lightstyle, 0, sizeof(cl_lightstyle));
// memset (cl_temp_entities, 0, sizeof(cl_temp_entities)); // 2001-09-20 Configurable entity limits by Maddes
memset (cl_beams, 0, sizeof(cl_beams));
//
// allocate the efrags and chain together into a free list
//
// allocate the efrags and chain together into a free list
cl.free_efrags = cl_efrags;
for (i=0 ; i<MAX_EFRAGS-1 ; i++)
cl.free_efrags[i].entnext = &cl.free_efrags[i+1];
cl.free_efrags[i].entnext = NULL;
}
@ -130,14 +110,10 @@ This is also called on Host_Error, so it shouldn't cause any errors
*/
void CL_Disconnect (void)
{
// stop sounds (especially looping!)
// stop sounds (especially looping!)
S_StopAllSounds (true);
// bring the console down and fade the colors back to normal
// SCR_BringDownConsole ();
// if running a local server, shut it down
// if running a local server, shut it down
if (cls.demoplayback)
CL_StopPlayback ();
else if (cls.state == ca_connected)
@ -164,13 +140,11 @@ void CL_Disconnect (void)
void CL_Disconnect_f (void)
{
CL_Disconnect ();
if (sv.active)
Host_ShutdownServer (false);
}
/*
=====================
CL_EstablishConnection
@ -215,39 +189,31 @@ void CL_SignonReply (void)
switch (cls.signon)
{
case 1:
// 2000-04-30 NVS HANDSHAKE SRV<->CL by Maddes start
if (!sv.active)
{
Cvar_Set(nvs_current_ssvc, "0");
}
Cvar_Set(nvs_current_csvc, "0");
Cvar_Set(nvs_current_cclc, "0");
// 2001-12-24 Keeping full backwards compatibility by Maddes start
if (!(cl_compatibility->value)) // request, unlike the original Quake executable
{
// 2001-12-24 Keeping full backwards compatibility by Maddes end
MSG_WriteByte (&cls.message, clc_stringcmd);
MSG_WriteString (&cls.message, va("nvs_request %1.2f\n", nvs_current_cclc->maxvalue));
} // 2001-12-24 Keeping full backwards compatibility by Maddes
// 2000-04-30 NVS HANDSHAKE SRV<->CL by Maddes end
}
// 2001-09-20 Configurable limits by Maddes start
// 2001-09-20 Configurable entity limits by Maddes start
cl.max_edicts = 0;
cl.max_static_edicts = 0;
cl.max_temp_edicts = 0;
cl_entities = NULL;
cl_static_entities = NULL;
cl_temp_entities = NULL;
// 2001-09-20 Configurable entity limits by Maddes end
// 2001-12-24 Keeping full backwards compatibility by Maddes start
if (!(cl_compatibility->value)) // request, unlike the original Quake executable
{
// 2001-12-24 Keeping full backwards compatibility by Maddes end
MSG_WriteByte (&cls.message, clc_stringcmd);
MSG_WriteString (&cls.message, "limit_request\n");
} // 2001-12-24 Keeping full backwards compatibility by Maddes
// 2001-09-20 Configurable limits by Maddes end
}
MSG_WriteByte (&cls.message, clc_stringcmd);
MSG_WriteString (&cls.message, "prespawn\n");
@ -332,50 +298,6 @@ void CL_PrintEntities_f (void)
}
}
/*
===============
SetPal
Debugging tool, just flashes the screen
===============
*/
void SetPal (int i)
{
#if 0
static int old;
byte pal[768];
int c;
if (i == old)
return;
old = i;
if (i==0)
VID_SetPalette (host_basepal);
else if (i==1)
{
for (c=0 ; c<768 ; c+=3)
{
pal[c] = 0;
pal[c+1] = 255;
pal[c+2] = 0;
}
VID_SetPalette (pal);
}
else
{
for (c=0 ; c<768 ; c+=3)
{
pal[c] = 0;
pal[c+1] = 0;
pal[c+2] = 255;
}
VID_SetPalette (pal);
}
#endif
}
/*
===============
CL_AllocDlight
@ -387,7 +309,6 @@ dlight_t *CL_AllocDlight (int key)
int i;
dlight_t *dl;
// first look for an exact key match
if (key)
{
dl = cl_dlights;
@ -397,20 +318,17 @@ dlight_t *CL_AllocDlight (int key)
{
memset (dl, 0, sizeof(*dl));
dl->key = key;
// 2001-09-11 Colored lightning by LordHavoc/Sarcazm/Maddes start
// dl->color[0] = dl->color[1] = dl->color[2] = 1.0f;
dl->color[0] = dl->color[1] = dl->color[2] = 1; // LordHavoc: .lit support
dl->flashcolor[0] = 1.0f;
dl->flashcolor[1] = 0.5f;
dl->flashcolor[2] = 0.0f;
dl->flashcolor[3] = 0.2f;
// 2001-09-11 Colored lightning by LordHavoc/Sarcazm/Maddes end
return dl;
}
}
}
// then look for anything else
// then look for anything else
dl = cl_dlights;
for (i=0 ; i<MAX_DLIGHTS ; i++, dl++)
{
@ -418,13 +336,11 @@ dlight_t *CL_AllocDlight (int key)
{
memset (dl, 0, sizeof(*dl));
dl->key = key;
// 2001-09-11 Colored lightning by LordHavoc/Sarcazm/Maddes start
dl->color[0] = dl->color[1] = dl->color[2] = 1; // LordHavoc: .lit support
dl->flashcolor[0] = 1.0f;
dl->flashcolor[1] = 0.5f;
dl->flashcolor[2] = 0.0f;
dl->flashcolor[3] = 0.2f;
// 2001-09-11 Colored lightning by LordHavoc/Sarcazm/Maddes end
return dl;
}
}
@ -432,22 +348,14 @@ dlight_t *CL_AllocDlight (int key)
dl = &cl_dlights[0];
memset (dl, 0, sizeof(*dl));
dl->key = key;
// 2001-09-11 Colored lightning by LordHavoc/Sarcazm/Maddes start
dl->color[0] = dl->color[1] = dl->color[2] = 1; // LordHavoc: .lit support
dl->flashcolor[0] = 1.0f;
dl->flashcolor[1] = 0.5f;
dl->flashcolor[2] = 0.0f;
dl->flashcolor[3] = 0.2f;
// 2001-09-11 Colored lightning by LordHavoc/Sarcazm/Maddes end
return dl;
}
/*
===============
CL_AllocShadow
@ -459,7 +367,7 @@ CL_AllocShadow
shadow_t *CL_AllocShadow (int key)
{
int i;
shadow_t *dl; //haha still called 'dl'
shadow_t *dl;
// first look for an exact key match
if (key)
@ -511,7 +419,7 @@ wlight_t *CL_AllocWlight (int key)
int i;
wlight_t *dl;
// first look for an exact key match
// first look for an exact key match
if (key)
{
dl = cl_wlights;
@ -521,18 +429,13 @@ wlight_t *CL_AllocWlight (int key)
{
memset (dl, 0, sizeof(*dl));
dl->key = key;
// 2001-09-11 Colored lightning by LordHavoc/Sarcazm/Maddes start
// dl->color[0] = dl->color[1] = dl->color[2] = 1.0f;
dl->color[0] = dl->color[1] = dl->color[2] = 1; // LordHavoc: .lit support
// 2001-09-11 Colored lightning by LordHavoc/Sarcazm/Maddes end
Con_Printf("got one\n");
return dl;
}
}
}
// then look for anything else
// then look for anything else
dl = cl_wlights;
for (i=0 ; i<MAX_WLIGHTS ; i++, dl++)
{
@ -540,11 +443,7 @@ wlight_t *CL_AllocWlight (int key)
{
memset (dl, 0, sizeof(*dl));
dl->key = key;
// 2001-09-11 Colored lightning by LordHavoc/Sarcazm/Maddes start
dl->color[0] = dl->color[1] = dl->color[2] = 1; // LordHavoc: .lit support
// 2001-09-11 Colored lightning by LordHavoc/Sarcazm/Maddes end
Con_Printf("got two\n");
return dl;
}
}
@ -552,10 +451,8 @@ wlight_t *CL_AllocWlight (int key)
dl = &cl_wlights[0];
memset (dl, 0, sizeof(*dl));
dl->key = key;
// 2001-09-11 Colored lightning by LordHavoc/Sarcazm/Maddes start
dl->color[0] = dl->color[1] = dl->color[2] = 1; // LordHavoc: .lit support
Con_Printf("got three\n");
// 2001-09-11 Colored lightning by LordHavoc/Sarcazm/Maddes end
return dl;
}
@ -597,12 +494,8 @@ void CL_DecayLights (void)
if (shd->radius < 0)
shd->radius = 0;
}
}
/*
===============
CL_LerpPoint
@ -613,7 +506,7 @@ should be put at.
*/
float CL_LerpPoint (void)
{
float f, frac;
float f, frac;
f = cl.mtime[0] - cl.mtime[1];
@ -624,41 +517,34 @@ float CL_LerpPoint (void)
}
if (f > 0.1)
{ // dropped packet, or start of demo
{
cl.mtime[1] = cl.mtime[0] - 0.1;
f = 0.1;
}
frac = (cl.time - cl.mtime[1]) / f;
//Con_Printf ("frac: %f\n",frac);
if (frac < 0)
{
if (frac < -0.01)
{
SetPal(1);
cl.time = cl.mtime[1];
// Con_Printf ("low frac\n");
}
frac = 0;
}
else if (frac > 1)
{
if (frac > 1.01)
{
SetPal(2);
cl.time = cl.mtime[0];
// Con_Printf ("high frac\n");
}
frac = 1;
}
else
SetPal(0);
return frac;
}
extern int shadowhack;
extern int dyncolor;
extern int particleset;
extern int deathcam_yesiamdead; // leilei - deathcam
extern int deathcam_active; // leilei - deathcam
extern cvar_t *r_coloredlights;
extern cvar_t *r_coloreddyns;
/*
@ -666,11 +552,12 @@ extern cvar_t *r_coloreddyns;
CL_RelinkEntities
===============
*/
extern int particleblood;
extern cvar_t *r_flares;
extern cvar_t *r_flamehack;
extern int particleblood;
extern cvar_t *r_flares;
extern cvar_t *r_flamehack;
extern cvar_t *temp1;
extern cvar_t *temp2;
void CL_RelinkEntities (void)
{
entity_t *ent;
@ -686,53 +573,49 @@ void CL_RelinkEntities (void)
dlight_t *dl;
shadow_t *shd; // leilei - shadows
unsigned int shadpacity;
float shadorigin;
unsigned int shadpacity;
float shadorigin;
float blend;
vec3_t dee;
int iee;
float blend;
vec3_t dee;
int iee;
// determine partial update time
frac = CL_LerpPoint ();
cl_numvisedicts = 0;
//
// interpolate player info
//
// interpolate player info
//
for (i=0 ; i<3 ; i++)
cl.velocity[i] = cl.mvelocity[1][i] +
frac * (cl.mvelocity[0][i] - cl.mvelocity[1][i]);
if (cls.demoplayback)
{
// interpolate the angles
// interpolate the angles
// leilei - unrolled these
{
d = cl.mviewangles[0][0] - cl.mviewangles[1][0];
if (d > 180)
d -= 360;
else if (d < -180)
d += 360;
cl.viewangles[0] = cl.mviewangles[1][0] + frac*d;
d = cl.mviewangles[0][0] - cl.mviewangles[1][0];
if (d > 180)
d -= 360;
else if (d < -180)
d += 360;
cl.viewangles[0] = cl.mviewangles[1][0] + frac*d;
d = cl.mviewangles[0][1] - cl.mviewangles[1][1];
if (d > 180)
d -= 360;
else if (d < -180)
d += 360;
cl.viewangles[1] = cl.mviewangles[1][1] + frac*d;
d = cl.mviewangles[0][1] - cl.mviewangles[1][1];
if (d > 180)
d -= 360;
else if (d < -180)
d += 360;
cl.viewangles[1] = cl.mviewangles[1][1] + frac*d;
d = cl.mviewangles[0][2] - cl.mviewangles[1][2];
if (d > 180)
d -= 360;
else if (d < -180)
d += 360;
cl.viewangles[2] = cl.mviewangles[1][2] + frac*d;
}
d = cl.mviewangles[0][2] - cl.mviewangles[1][2];
if (d > 180)
d -= 360;
else if (d < -180)
d += 360;
cl.viewangles[2] = cl.mviewangles[1][2] + frac*d;
}
bobjrotate = anglemod(100*cl.time);
@ -768,43 +651,41 @@ void CL_RelinkEntities (void)
else
{ // if the delta is large, assume a teleport and don't lerp
f = frac;
for (j=0 ; j<3 ; j++)
{
for (j=0 ; j<3 ; j++)
{
delta[j] = ent->msg_origins[0][j] - ent->msg_origins[1][j];
if (delta[j] > 100 || delta[j] < -100)
f = 1; // assume a teleportation, not a motion
}
f = 1; // assume a teleportation, not a motion
}
ent->origin[0] = ent->msg_origins[1][0] + f*delta[0];
d = ent->msg_angles[0][0] - ent->msg_angles[1][0];
if (d > 180)
d -= 360;
else if (d < -180)
d += 360;
ent->origin[0] = ent->msg_origins[1][0] + f*delta[0];
ent->angles[0] = ent->msg_angles[1][0] + f*d;
ent->origin[1] = ent->msg_origins[1][1] + f*delta[1];
d = ent->msg_angles[0][0] - ent->msg_angles[1][0];
if (d > 180)
d -= 360;
else if (d < -180)
d += 360;
ent->angles[0] = ent->msg_angles[1][0] + f*d;
d = ent->msg_angles[0][1] - ent->msg_angles[1][1];
if (d > 180)
d -= 360;
else if (d < -180)
d += 360;
ent->origin[1] = ent->msg_origins[1][1] + f*delta[1];
d = ent->msg_angles[0][1] - ent->msg_angles[1][1];
if (d > 180)
d -= 360;
else if (d < -180)
d += 360;
ent->angles[1] = ent->msg_angles[1][1] + f*d;
ent->origin[2] = ent->msg_origins[1][2] + f*delta[2];
d = ent->msg_angles[0][2] - ent->msg_angles[1][2];
if (d > 180)
d -= 360;
else if (d < -180)
d += 360;
ent->angles[2] = ent->msg_angles[1][2] + f*d;
ent->angles[1] = ent->msg_angles[1][1] + f*d;
ent->origin[2] = ent->msg_origins[1][2] + f*delta[2];
d = ent->msg_angles[0][2] - ent->msg_angles[1][2];
if (d > 180)
d -= 360;
else if (d < -180)
d += 360;
ent->angles[2] = ent->msg_angles[1][2] + f*d;
}
@ -981,99 +862,78 @@ void CL_RelinkEntities (void)
}
// QC Glows!
if (ent->glowsize)
{
dl = CL_AllocDlight (i);
VectorCopy (ent->origin, dl->origin);
if (dyncolor){
if (dyncolor)
{
byte *tempcolor;
tempcolor = (byte *)&d_8to24table[ent->glowcolor];
dl->color[0] = (float)tempcolor[0] * (1.0f / 299.0f);
dl->color[1] = (float)tempcolor[1] * (1.0f / 299.0f);
dl->color[2] = (float)tempcolor[2] * (1.0f / 299.0f);
// if (r_flares->value > 1)
// R_FlareTest(ent->origin, 4, (int)tempcolor[0], (int)tempcolor[1], (int)tempcolor[2], 0, ent); // we moved it to dynamic lights now
}
tempcolor = (byte *)&d_8to24table[ent->glowcolor];
dl->color[0] = (float)tempcolor[0] * (1.0f / 299.0f);
dl->color[1] = (float)tempcolor[1] * (1.0f / 299.0f);
dl->color[2] = (float)tempcolor[2] * (1.0f / 299.0f);
}
dl->radius = ent->glowsize;
dl->die = cl.time + 0.01;
}
if (ent->model->flags & EF_GIB)
if (particleblood > 2){
if (particleblood > 2)
R_GusherizeCurlyBloodTrail (oldorg, ent->origin, 5);
// if (!ent->gushed){
// vec3_t eheheh;
// eheheh[0] = rand() * 1000 - 500; eheheh[1] = rand() * 1000 - 500; eheheh[2] = rand() * 1000 - 500;
// ent->gushed = 1;
// R_RunParticleEffect(ent->origin, eheheh, 79, 60);
// R_RunParticleEffect(oldorg, eheheh, 79, 60);
//
// Con_Printf("GUSH!!!!!!!! %s\n", sfx->name);
// }
}
else if (particleblood < 0)
ent->effects |= EF_NODRAW; // hide gibs on blood removal mode
else
R_RocketTrail (oldorg, ent->origin, 2);
R_RocketTrail (oldorg, ent->origin, 2);
else if (ent->model->flags & EF_ZOMGIB)
if (particleblood > 2)
R_SpiralBloodTrail (oldorg, ent->origin); // by the way - blood removal code
else // should NEVER REMOVE EF_ZOMGIB ENTITIES
R_RocketTrail (oldorg, ent->origin, 4); // because it is a gameplay element (zombie gib throws)
// instead we can make it appear less graphic by blue gelmap
R_SpiralBloodTrail (oldorg, ent->origin); // by the way - blood removal code
else // should NEVER REMOVE EF_ZOMGIB ENTITIES
R_RocketTrail (oldorg, ent->origin, 4); // because it is a gameplay element (zombie gib throws)
// instead we can make it appear less graphic by blue gelmap
else if (ent->model->flags & EF_TRACER)
R_RocketTrail (oldorg, ent->origin, 3);
else if (ent->model->flags & EF_TRACER2)
R_RocketTrail (oldorg, ent->origin, 5);
else if (ent->model->flags & EF_ROCKET)
{
if (particleset == 2){
R_RocketTrailSprites (oldorg, ent->origin, 0);
}
if (particleset == 2)
R_RocketTrailSprites (oldorg, ent->origin, 0);
else
{
R_RocketTrail (oldorg, ent->origin, 0);
}
R_RocketTrail (oldorg, ent->origin, 0);
dl = CL_AllocDlight (i);
VectorCopy (ent->origin, dl->origin);
if (dyncolor){
if (dyncolor)
{
dl->color[0] = 1.5f;
dl->color[1] = 0.75f;
dl->color[2] = 0.25f; // darkplaces values /3
}
}
dl->radius = 200;
dl->die = cl.time + 0.01;
// if (r_flares->value > 1)
// R_FlareTest(ent->origin, 4, 95, 65, 22, 0, ent); // we moved it to dynamic lights now
dl->die = cl.time + 0.01;
}
else if (ent->model->flags & EF_GRENADE){
else if (ent->model->flags & EF_GRENADE)
{
if (particleset == 2)
R_RocketTrailSprites (oldorg, ent->origin, 1);
R_RocketTrailSprites (oldorg, ent->origin, 1);
else
R_RocketTrail (oldorg, ent->origin, 1);
R_RocketTrail (oldorg, ent->origin, 1);
}
else if (ent->model->flags & EF_TRACER3)
if (particleset == 2)
R_RocketTrailSprites (oldorg, ent->origin, 6);
else
R_RocketTrail (oldorg, ent->origin, 6);
if (particleset == 2)
R_RocketTrailSprites (oldorg, ent->origin, 6);
else
R_RocketTrail (oldorg, ent->origin, 6);
ent->forcelink = false;
if (i == cl.viewentity && !chase_active->value && !deathcam_yesiamdead)
if (i == cl.viewentity && !chase_active->value && !deathcam_active)
continue;
if ( ent->effects & EF_NODRAW )
@ -1130,9 +990,6 @@ int CL_ReadFromServer (void)
CL_RelinkEntities ();
CL_UpdateTEnts ();
//
// bring the links up to date
//
return 0;
}
@ -1150,15 +1007,14 @@ void CL_SendCmd (void)
if (cls.signon == SIGNONS)
{
// get basic movement from keyboard
// get basic movement from keyboard
CL_BaseMove (&cmd);
// allow mice or other external controllers to add to the move
// allow mice or other external controllers to add to the move
IN_Move (&cmd);
// send the unreliable message
// send the unreliable message
CL_SendMove (&cmd);
}
if (cls.demoplayback)
@ -1167,9 +1023,8 @@ void CL_SendCmd (void)
return;
}
// send the reliable message
if (!cls.message.cursize)
return; // no message at all
return;
if (!NET_CanSendMessage (cls.netcon))
{
@ -1183,15 +1038,12 @@ void CL_SendCmd (void)
SZ_Clear (&cls.message);
}
// 2001-12-16 M_LOOK cvar by Heffo/Maddes start
void Callback_M_Look (cvar_t *var)
{
if ( !((in_mlook.state & 1) ^ ((int)m_look->value & 1)) && lookspring->value)
V_StartPitchDrift();
}
// 2001-12-16 M_LOOK cvar by Heffo/Maddes end
// 2001-09-18 New cvar system by Maddes (Init) start
/*
=================
CL_Init_Cvars
@ -1211,10 +1063,8 @@ void CL_Init_Cvars (void)
cl_pitchspeed = Cvar_Get ("cl_pitchspeed", "150", CVAR_ORIGINAL);
cl_anglespeedkey = Cvar_Get ("cl_anglespeedkey", "1.5", CVAR_ORIGINAL);
cl_shownet = Cvar_Get ("cl_shownet", "0", CVAR_ORIGINAL);
// 2001-09-18 New cvar system by Maddes start
Cvar_SetRangecheck (cl_shownet, Cvar_RangecheckInt, 0, 2);
Cvar_Set(cl_shownet, cl_shownet->string); // do rangecheck
// 2001-09-18 New cvar system by Maddes end
Cvar_Set(cl_shownet, cl_shownet->string);
cl_nolerp = Cvar_Get ("cl_nolerp", "0", CVAR_ORIGINAL);
lookspring = Cvar_Get ("lookspring", "0", CVAR_ARCHIVE|CVAR_ORIGINAL);
lookstrafe = Cvar_Get ("lookstrafe", "0", CVAR_ARCHIVE|CVAR_ORIGINAL);
@ -1224,7 +1074,6 @@ void CL_Init_Cvars (void)
m_yaw = Cvar_Get ("m_yaw", "0.022", CVAR_ARCHIVE|CVAR_ORIGINAL);
m_forward = Cvar_Get ("m_forward", "1", CVAR_ARCHIVE|CVAR_ORIGINAL);
m_side = Cvar_Get ("m_side", "0.8", CVAR_ARCHIVE|CVAR_ORIGINAL);
// 2001-12-16 M_LOOK cvar by Heffo/Maddes start
m_look = Cvar_Get ("m_look", "1", CVAR_ARCHIVE);
m_lockup = Cvar_Get ("m_lockup", "-90", CVAR_ARCHIVE);
@ -1232,39 +1081,30 @@ void CL_Init_Cvars (void)
Cvar_SetRangecheck (m_look, Cvar_RangecheckBool, 0, 1);
Cvar_SetCallback (m_look, Callback_M_Look);
Cvar_Set(m_look, m_look->string); // do rangecheck
// 2001-12-16 M_LOOK cvar by Heffo/Maddes end
Cvar_Set(m_look, m_look->string);
// 2001-11-31 FPS display by QuakeForge/Muff start
cl_showfps = Cvar_Get ("cl_showfps", "0", CVAR_NONE);
Cvar_SetRangecheck (cl_showfps, Cvar_RangecheckBool, 0, 1);
Cvar_Set(cl_showfps, cl_showfps->string); // do rangecheck
// 2001-11-31 FPS display by QuakeForge/Muff end
// 2001-12-24 Keeping full backwards compatibility by Maddes start
Cvar_Set(cl_showfps, cl_showfps->string);
cl_compatibility = Cvar_Get ("cl_compatibility", "0", CVAR_ARCHIVE);
Cvar_SetRangecheck (cl_compatibility, Cvar_RangecheckBool, 0, 1);
Cvar_SetDescription (cl_compatibility, "When set to 1, this client will not request enhanced information from the server (server's entity limit, NVS handshake, etc.) and disables enhanced client messages (precise client aiming, etc.). This is necessary for recording demos that shall run on all Quake executables. Also see SV_COMPATIBILITY.");
Cvar_Set(cl_compatibility, cl_compatibility->string); // do rangecheck
// 2001-12-24 Keeping full backwards compatibility by Maddes end
// 2001-09-20 Configurable entity limits by Maddes start
Cvar_Set(cl_compatibility, cl_compatibility->string);
cl_entities_min = Cvar_Get ("cl_entities_min", "0", CVAR_NONE);
Cvar_SetRangecheck (cl_entities_min, Cvar_RangecheckInt, MIN_EDICTS, MAX_EDICTS);
Cvar_Set(cl_entities_min, cl_entities_min->string); // do rangecheck
Cvar_Set(cl_entities_min, cl_entities_min->string);
cl_entities_min_static = Cvar_Get ("cl_entities_min_static", "0", CVAR_NONE);
Cvar_SetRangecheck (cl_entities_min_static, Cvar_RangecheckInt, MIN_STATIC_ENTITIES, MAX_EDICTS);
Cvar_Set(cl_entities_min_static, cl_entities_min_static->string); // do rangecheck
Cvar_Set(cl_entities_min_static, cl_entities_min_static->string);
cl_entities_min_temp = Cvar_Get ("cl_entities_min_temp", "0", CVAR_NONE);
Cvar_SetRangecheck (cl_entities_min_temp, Cvar_RangecheckInt, MIN_TEMP_ENTITIES, MAX_EDICTS);
Cvar_Set(cl_entities_min_temp, cl_entities_min_temp->string); // do rangecheck
// 2001-09-20 Configurable entity limits by Maddes end
Cvar_Set(cl_entities_min_temp, cl_entities_min_temp->string);
cl_sbar = Cvar_Get ("cl_sbar", "1", CVAR_ARCHIVE | CVAR_ORIGINAL);
}
// 2001-09-18 New cvar system by Maddes (Init) end
void TheForceLoadLighting (void)
{
LoadPointLighting(sv.worldmodel->entities);
@ -1282,9 +1122,6 @@ void CL_Init (void)
CL_InitInput ();
CL_InitTEnts ();
//
// register our commands
//
Cmd_AddCommand ("entities", CL_PrintEntities_f);
Cmd_AddCommand ("disconnect", CL_Disconnect_f);
Cmd_AddCommand ("demo_record", CL_Record_f);

80
engine/console.c
View file

@ -554,52 +554,33 @@ void Con_DrawInput (void)
if (key_dest != key_console && !con_forcedup)
return; // don't draw anything
// 2000-01-05 Console typing enhancement by Radix start
/*
text = key_lines[edit_line];
// add the cursor frame
text[key_linepos] = 10+((int)(realtime*con_cursorspeed)&1);
// fill out remainder with spaces
for (i=key_linepos+1 ; i< con_linewidth ; i++)
text[i] = ' ';
*/
text = strcpy(editlinecopy, key_lines[edit_line]);
// fill out remainder with spaces
// fill out remainder with spaces
y = strlen(text);
for (i = y; i < 256; i++)
{
text[i] = ' ';
}
// add the cursor frame
// add the cursor frame
if ((int)(realtime * con_cursorspeed) & 1) // cursor is visible
{
text[key_linepos] = 11 + 130 * key_insert; // either solid block or triagle facing right
text[key_linepos] = 11 + 130 * key_insert;
}
// 2000-01-05 Console typing enhancement by Radix end
// prestep if horizontally scrolling
if (key_linepos >= con_linewidth)
text += 1 + key_linepos - con_linewidth;
// draw it
y = con_vislines-16;
for (i=0 ; i<con_linewidth ; i++)
// 2001-12-10 Reduced compiler warnings by Jeff Ford start
{
if (console_scaled)
Draw_Character_Scaled ( (i+1)<<3, y, text[i]);
else
Draw_Character ( (i+1)<<3, y, text[i]);
}
// 2001-12-10 Reduced compiler warnings by Jeff Ford end
// remove cursor
// key_lines[edit_line][key_linepos] = 0; // 2000-01-05 Console typing enhancement by Radix
}
@ -695,77 +676,56 @@ The typing input line at the bottom should only be drawn if typing is allowed
*/
void Con_DrawConsole (int lines, qboolean drawinput)
{
int i, x, y;
int rows;
char *text;
int j;
int sb; // 2001-12-15 Avoid automatic console scrolling by Fett
int i, x, y;
int rows;
char *text;
int j;
int sb; // 2001-12-15 Avoid automatic console scrolling by Fett
if (lines <= 0)
return;
// draw the background
Draw_ConsoleBackground (lines);
// draw the text
con_vislines = lines;
rows = (lines-16)>>3; // rows of text to draw
y = lines - 16 - (rows<<3); // may start slightly negative
// 2000-01-05 Console scrolling fix by Maddes start
if (con_backscroll >= con_current)
con_backscroll = con_current - 1;
if (con_backscroll >= con_totallines)
con_backscroll = con_totallines - 1;
if (con_backscroll < 0)
con_backscroll = 0;
// 2000-01-05 Console scrolling fix by Maddes end
// 2001-12-15 Avoid automatic console scrolling by Fett start
if (con_backscroll)
{
sb=1; // reserve line for scrollback indicator
}
else
{
sb=0;
}
// 2001-12-15 Avoid automatic console scrolling by Fett end
// 2000-01-05 Console scrolling fix by Maddes start
// for (i= con_current - rows + 1 ; i<=con_current ; i++, y+=8 )
// 2001-12-15 Avoid automatic console scrolling by Fett start
// for (i= con_current - rows; i<con_current ; i++, y+=8 )
for (i= con_current - rows + sb; i<con_current ; i++, y+=8)
// 2001-12-15 Avoid automatic console scrolling by Fett end
// 2000-01-05 Console scrolling fix by Maddes end
{
j = i - con_backscroll;
// 2000-01-05 Console scrolling fix by Maddes start
/*
if (j<0)
j = 0;
*/
if ((j<0) || (j < (con_current - con_totallines)))
{
continue;
}
// 2000-01-05 Console scrolling fix by Maddes end
text = con_text + (j % con_totallines)*con_linewidth;
if (console_scaled){
for (x=0 ; x<con_linewidth ; x++)
Draw_Character_Scaled ( (x+1)<<3, y, text[x]);
if (console_scaled)
{
for (x=0 ; x<con_linewidth ; x++)
Draw_Character_Scaled ( (x+1)<<3, y, text[x]);
}
else
{
for (x=0 ; x<con_linewidth ; x++)
Draw_Character ( (x+1)<<3, y, text[x]);
for (x=0 ; x<con_linewidth ; x++)
Draw_Character ( (x+1)<<3, y, text[x]);
}
}
// 2001-12-15 Avoid automatic console scrolling by Fett start
if (sb) // are we scrolled back?
{
if (console_scaled){
@ -778,9 +738,7 @@ void Con_DrawConsole (int lines, qboolean drawinput)
Draw_Character ((x+1)<<3, y, '^');
}
// 2001-12-15 Avoid automatic console scrolling by Fett end
// draw the input prompt, user text, and cursor if desired
if (drawinput)
Con_DrawInput ();
}

279
engine/draw.c
View file

@ -23,8 +23,6 @@ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
// vid buffer
#include "globaldef.h"
// 2000-08-04 "Transparent" console background for software renderer by Norberto Alfredo Bensa/Maddes start
extern cvar_t *con_alpha;
//pixel_t ditherTable[32768][4];
@ -60,8 +58,8 @@ qpic_t *draw_backtile;
/* Support Routines */
#define MAX_CACHED_PICS 128
cachepic_t menu_cachepics[MAX_CACHED_PICS];
int menu_numcachepics;
cachepic_t menu_cachepics[MAX_CACHED_PICS];
int menu_numcachepics;
qpic_t *Draw_PicFromWad (char *name)
@ -80,13 +78,6 @@ qpic_t *Draw_PicFromWad (char *name)
}
}
#ifdef _WIN32
extern qboolean WinNT;
#endif
/*
===============
BestColor
@ -100,16 +91,7 @@ byte BestColor (int r, int g, int b, int start, int stop)
int berstcolor;
byte *pal;
#ifdef _WIN32
// lei - nt hack, so we never see illegal colors on Windows NT
//if (WinNT){
// if(start == 0) start = 1;
// if(stop == 255) stop = 254;
// }
#endif
//
// let any color go to 0 as a last resort
//
// let any color go to 0 as a last resort
bestdistortion = 256*256*4;
berstcolor = 0;
@ -260,7 +242,6 @@ unsigned char palmap3[65535]; // for 888rgb...
byte palmapnofb[32][32][32]; // for hl map conversion only
// this is just a lookup table version of the above
int FindColor (int r, int g, int b)
{
int bestcolor;
@ -302,7 +283,7 @@ Draw_CachePic
qpic_t *Draw_CachePic (char *path)
{
cachepic_t *pic;
int i;
int i;
qpic_t *dat;
for (pic=menu_cachepics, i=0 ; i<menu_numcachepics ; pic++, i++)
@ -322,15 +303,13 @@ qpic_t *Draw_CachePic (char *path)
if (dat)
return dat;
//
// load the pic from disk
//
// load the pic from disk
COM_LoadCacheFile (path, &pic->cache);
dat = (qpic_t *)pic->cache.data;
if (!dat)
{
Con_DPrintf ("Draw_CachePic: failed to load %s\n", path);
Con_DPrintf ("[DRAW] Failed to load %s\n", path);
return NULL;
}
@ -359,12 +338,6 @@ void MakeMy15to8(unsigned char *palette)
FILE *f;
char s[255];
// HWND hDlg, hProgress;
// float gamma;
// pal = host_basepal *3;
//
// 8 8 8 encoding
//
pal = palette;
table = d_8to24table;
for (i=0 ; i<256 ; i++)
@ -373,9 +346,6 @@ void MakeMy15to8(unsigned char *palette)
g = pal[1];
b = pal[2];
pal += 3;
// v = (255<<24) + (r<<16) + (g<<8) + (b<<0);
// v = (255<<0) + (r<<8) + (g<<16) + (b<<24);
v = (255<<24) + (r<<0) + (g<<8) + (b<<16);
*table++ = v;
}
@ -393,17 +363,11 @@ void MakeMy15to8(unsigned char *palette)
v = (255<<24) + (r<<0) + (g<<8) + (b<<16);
*table++ = v;
}
// d_8to24table[255] &= 0xffffff; // 255 is transparent
// JACK: 3D distance calcs - k is last closest, l is the distance.
// FIXME: Precalculate this and cache to disk.
for (i=0; i < (1<<15); i++) {
/* Maps
000000000000000
000000000011111 = Red = 0x1F
000001111100000 = Blue = 0x03E0
111110000000000 = Grn = 0x7C00
*/
for (i=0; i < (1<<15); i++)
{
r = ((i & 0x1F) << 3)+4;
g = ((i & 0x03E0) >> 2)+4;
b = ((i & 0x7C00) >> 7)+4;
@ -422,11 +386,8 @@ void MakeMy15to8(unsigned char *palette)
}
}
byte *lmmap;
byte *lmmap;
// are we done with lookup tables yet? I DONT THINK SO!
// despite the name these are actually gray
void IdnitColorColormaps (void) {
int levels, brights;
@ -438,14 +399,14 @@ void IdnitColorColormaps (void) {
char savename[1024];
char dest[1024];
range = 2;
range = 2;
levels = 16;
brights = 1; // ignore 255 (transparent)
brights = 1; // ignore 255 (transparent)
cropped = malloc((levels+256)*256);
lump_p = cropped;
// shaded levels
// shaded levels
for (l=0;l<levels;l++)
{
frac = range - range*(float)l/(levels-1);
@ -463,8 +424,6 @@ void IdnitColorColormaps (void) {
host_colormap[l] = lump_p[l];
}
}
}
/*
@ -482,48 +441,51 @@ fullbright colors start at the top of the palette.
*/
void GrabColorMap (void) //qbism - fixed, was a little screwy
{
int l, c, red, green, blue;
float frac, cscale, fracscaled;
float rscaled, gscaled, bscaled;
byte *colmap;
int l, c, red, green, blue;
float frac, cscale, fracscaled;
float rscaled, gscaled, bscaled;
byte *colmap;
int RANGE = 2;
int COLORLEVELS = 64;
int PALBRIGHTS;
RANGE = 2;
if(!fullbrights) PALBRIGHTS = 0;
else
if(!fullbrights)
PALBRIGHTS = 0;
else
PALBRIGHTS = 256 - host_fullbrights;
colmap = host_colormap;
colmap = host_colormap;
// shaded levels
for (l=0; l<COLORLEVELS; l++)
{
// frac = (float)l/(COLORLEVELS-1);
frac = RANGE - RANGE*(float)l/(COLORLEVELS-1);
if (!overbrights){ if (frac > 1) frac = 1;} // leilei - clamp it out for glsuck
for (c=0 ; c<256-PALBRIGHTS ; c++)
// shaded levels
for (l=0; l<COLORLEVELS; l++)
{
frac = RANGE - RANGE*(float)l/(COLORLEVELS-1);
if (!overbrights)
{
if (frac > 1)
frac = 1;
}
for (c=0 ; c<256-PALBRIGHTS ; c++)
{
red = (int)((float)host_basepal[c*3]*frac);
green = (int)((float)host_basepal[c*3+1]*frac);
blue = (int)((float)host_basepal[c*3+2]*frac);
red = (int)((float)host_basepal[c*3]*frac);
green = (int)((float)host_basepal[c*3+1]*frac);
blue = (int)((float)host_basepal[c*3+2]*frac);
//
// note: 254 instead of 255 because 255 is the transparent color, and we
// don't want anything remapping to that
//
*colmap++ = BestColor(red,green,blue, 0, 254);
// note: 254 instead of 255 because 255 is the transparent color, and we
// don't want anything remapping to that
*colmap++ = BestColor(red,green,blue, 0, 254);
}
for ( ; c<256 ; c++)
{
red = (int)host_basepal[c*3];
green = (int)host_basepal[c*3+1];
blue = (int)host_basepal[c*3+2];
red = (int)host_basepal[c*3];
green = (int)host_basepal[c*3+1];
blue = (int)host_basepal[c*3+2];
*colmap++ = BestColor(red,green,blue, 0, 254);
*colmap++ = BestColor(red,green,blue, 0, 254);
}
}
}
@ -897,11 +859,6 @@ byte menumap[256][16]; // Used for menu backgrounds and simple colormod
byte gelmap[256]; // Unused id effect TO be used somehow. made redundant by menumap
byte remapmap[256]; // For translating an old palette to new on load
int translate_bsp;
int translate_mdl;
int translate_gfx;
int translate_spr;
float fademap[256]; // Used in generation of certain alpha tables
byte coltranslate[256]; // TranslateToCustomPal - used for taking one palette to another without going through a whole 8to24to15to8 thing
pixel_t addTable[256][256]; // Additive blending effect
@ -1469,83 +1426,58 @@ void WaterTableGet (void)
ooh = (int)r_tranquality->value;
// Use these for now
ae = 0.66;
ay = 0.33;
// or not.
ay = r_wateralpha->value; // water surface
ae = 1 - ay; // base pixels
{
for (l=0;l<255;l++)
for (l=0;l<255;l++)
{
for (c=0 ; c<255 ; c++)
{
if (oldwaterblend == 1){ // additive
red = host_basepal[c*3] + (host_basepal[l*3] *ay);
green = host_basepal[c*3+1] + (host_basepal[l*3+1] *ay);
blue = host_basepal[c*3+2] + (host_basepal[l*3+2] *ay);
if (oldwaterblend == 1)
{ // additive
red = host_basepal[c*3] + (host_basepal[l*3] *ay);
green = host_basepal[c*3+1] + (host_basepal[l*3+1] *ay);
blue = host_basepal[c*3+2] + (host_basepal[l*3+2] *ay);
}
else if (oldwaterblend == 2){ // multiplicative
red = host_basepal[c*3] *ae + ((host_basepal[c*3] * (host_basepal[l*3] * 0.05)) * ay);
green = host_basepal[c*3+1] *ae + ((host_basepal[c*3+1]* (host_basepal[l*3+1] * 0.05)) * ay);
blue = host_basepal[c*3+2] *ae + ((host_basepal[c*3+2] * (host_basepal[l*3+2] * 0.05)) * ay);
else if (oldwaterblend == 2)
{ // multiplicative
red = host_basepal[c*3] *ae + ((host_basepal[c*3] * (host_basepal[l*3] * 0.05)) * ay);
green = host_basepal[c*3+1] *ae + ((host_basepal[c*3+1]* (host_basepal[l*3+1] * 0.05)) * ay);
blue = host_basepal[c*3+2] *ae + ((host_basepal[c*3+2] * (host_basepal[l*3+2] * 0.05)) * ay);
}
else if (oldwaterblend == 4){ // multiplicative
red = host_basepal[c*3] *ae + ((host_basepal[l*3] * 0.1 * (host_basepal[c*3] * 0.5)) * ay);
green = host_basepal[c*3+1] *ae + ((host_basepal[l*3+1] * 0.1 * (host_basepal[c*3+1] * 0.5)) * ay);
blue = host_basepal[c*3+2] *ae + ((host_basepal[l*3+2] * 0.1 * (host_basepal[c*3+2] * 0.5)) * ay);
else if (oldwaterblend == 4)
{ // multiplicative
red = host_basepal[c*3] *ae + ((host_basepal[l*3] * 0.1 * (host_basepal[c*3] * 0.5)) * ay);
green = host_basepal[c*3+1] *ae + ((host_basepal[l*3+1] * 0.1 * (host_basepal[c*3+1] * 0.5)) * ay);
blue = host_basepal[c*3+2] *ae + ((host_basepal[l*3+2] * 0.1 * (host_basepal[c*3+2] * 0.5)) * ay);
}
else if (oldwaterblend == 5){ // weird alpha thing
// how it works - goes through each color row from transparent(0) to opaque (16)
// this would also be used for the future (can you say decals?)
red = host_basepal[c*3] *(fademap[l] * ae) + (host_basepal[l*3] * (fademap[l]+0.3 * ay));
green = host_basepal[c*3+1] *(fademap[l] * ae) + (host_basepal[l*3+1] * (fademap[l]+0.3 * ay));
blue = host_basepal[c*3+2] * (fademap[l] * ae) + (host_basepal[l*3+2] * (fademap[l]+0.3 * ay));
else if (oldwaterblend == 5)
{ // weird alpha thing
red = host_basepal[c*3] *(fademap[l] * ae) + (host_basepal[l*3] * (fademap[l]+0.3 * ay));
green = host_basepal[c*3+1] *(fademap[l] * ae) + (host_basepal[l*3+1] * (fademap[l]+0.3 * ay));
blue = host_basepal[c*3+2] * (fademap[l] * ae) + (host_basepal[l*3+2] * (fademap[l]+0.3 * ay));
}
/*
else if (oldwaterblend == 6){ // like above sort of
red = host_basepal[c*3] *host_basepal[l*3] + (host_basepal[l*3] * host_basepal[c*3]) / 768;
green = host_basepal[c*3+1] *host_basepal[l*3+1] + (host_basepal[l*3+1] * host_basepal[c*3+1]) / 768;
blue = host_basepal[c*3+2] *host_basepal[l*3+2]+ (host_basepal[l*3+2] * host_basepal[c*3+2]) / 768;
}
else if (oldwaterblend == 13){ // weird ass blend, black is black, but is a mix of alpha!?
red = host_basepal[c*3] *host_basepal[l*3] + (host_basepal[l*3] * host_basepal[c*3]) / 768;
green = host_basepal[c*3+1] *host_basepal[l*3+1] + (host_basepal[l*3+1] * host_basepal[c*3+1]) / 768;
blue = host_basepal[c*3+2] *host_basepal[l*3+2]+ (host_basepal[l*3+2] * host_basepal[c*3+2]) / 768;
}
*/
else
{
red = host_basepal[c*3] *ae + (host_basepal[l*3] * ay);
green = host_basepal[c*3+1] *ae + (host_basepal[l*3+1] * ay);
blue = host_basepal[c*3+2] *ae + (host_basepal[l*3+2] * ay);
red = host_basepal[c*3] *ae + (host_basepal[l*3] * ay);
green = host_basepal[c*3+1] *ae + (host_basepal[l*3+1] * ay);
blue = host_basepal[c*3+2] *ae + (host_basepal[l*3+2] * ay);
}
if (red > 255) red = 255;
if (green > 255) green = 255;
if (blue > 255) blue = 255;
if (red < 0) red = 0;
if (green < 0) green = 0;
if (blue < 0) blue = 0;
if (ooh) waterTable[l][c] = BestColor(red,green,blue, 0, 255); // High quality color tables get best color
else if (palmap2) waterTable[l][c] = FindColor18(red,green,blue);
else waterTable[l][c] = FindColor(red,green,blue); // Since we do this live we must do this
// fast! or i'll cry.
}
}
if (ooh)
waterTable[l][c] = BestColor(red,green,blue, 0, 255); // High quality color tables get best color
else if (palmap2)
waterTable[l][c] = FindColor18(red,green,blue);
else
waterTable[l][c] = FindColor(red,green,blue); // Since we do this live we must do this
}
}
}
@ -1586,29 +1518,20 @@ void Draw_Init (void)
for (j=14; j>7; j--)
menumap[i][j] = (j * 16) + 15 - r;
menumap[i][14] = 14*16 + r; // forward hack for the muzzleflash fire colors
// and yes, color ramp #15 is left all black. any further is possibly reserved for slow
// hexen 2 style menus which use a translucency table
}
// and no you can't skip it. i'll use it for colored text and other coolities
}
void RemapMenuMap (void)
{
int i, j, l, c, r;
// really for the 16 color mode
int i, j;
for (i=0 ; i<256 ; i++)
{
for (j=0; j<15; j++)
menumap[i][j] = coltranslate[menumap[i][j]];
menumap[i][j] = coltranslate[menumap[i][j]];
}
};
}
int lilchar = 1;
@ -1736,7 +1659,7 @@ void Draw_Character_Scaled (int x, int y, unsigned int num)
col = num&15;
source = draw_chars + (row<<10) + (col<<3);
if (y < 0)
if (y < 0)
{ // clipped
drawline = 8 + y;
source -= 128*y;
@ -1745,43 +1668,26 @@ void Draw_Character_Scaled (int x, int y, unsigned int num)
else
drawline = 8;
// if (y < 0)
// { // clipped
// drawline = 8 + y;
// source -= 256*y;
// y = 0;
// }
// else
// drawline = 8;
height = drawline;
width = 8;
vmax = height * vid.height / (float)vid.vconheight;
umax = width * vid.width / (float)vid.vconwidth;
byte *dest = vid.conbuffer + (y * vid.height / vid.vconheight) * vid.conrowbytes + (x * vid.width / vid.vconwidth);
for (v = 0; v < vmax; v++)
{
byte *dest = vid.conbuffer + (y * vid.height / vid.vconheight) * vid.conrowbytes
+ (x * vid.width / vid.vconwidth);
for (v = 0; v < vmax; v++)
for (u = 0; u < umax; u++)
{
for (u = 0; u < umax; u++)
{
s = u * vid.vconwidth / vid.width
+ (v * vid.vconheight / vid.height) * 128;
if (source[s])
dest[u] = source[s];
s = u * vid.vconwidth / vid.width + (v * vid.vconheight / vid.height) * 128;
if (source[s])
dest[u] = source[s];
}
dest += vid.conrowbytes;
}
}
dest += vid.conrowbytes;
}
}
@ -1866,13 +1772,6 @@ void Draw_Pic (int x, int y, qpic_t *pic)
unsigned short *pusdest;
int v, u;
/* if (x < 0 || (unsigned)(x + pic->width) > vid.width || y < 0 ||
(unsigned)(y + pic->height) > vid.height)
{
Con_Printf("WARNING: Wrong coordinates for pic at %ix%i!\n", x, y);
return;
}
*/
if(x < 0) x = 0;
if(y < 0) y = 0;
if((x + pic->width) > vid.vconwidth) x = vid.vconwidth - pic->width;
@ -2031,8 +1930,8 @@ void Draw_Pic_Scaled_Two (int x, int y, qpic_t *pic, float scel)
void Draw_PicCropped (int x, int y, qpic_t *pic)
{
byte *source, tbyte;
int v, u, height;
byte *source, tbyte;
int v, u, height;
if ((x < 0) || (x+pic->width > vid.width))
{
@ -2791,7 +2690,6 @@ Call before beginning any disc IO.
*/
void Draw_BeginDisc (void)
{
D_BeginDirectRect (vid.width - 24, 0, draw_disc->data, 24, 24);
}
@ -2806,6 +2704,5 @@ Call after completing any disc IO
*/
void Draw_EndDisc (void)
{
D_EndDirectRect (vid.width - 24, 0, 24, 24);
}

6
engine/host.c
View file

@ -1167,10 +1167,6 @@ void Colormap_Generate(const unsigned char palette[768], unsigned char out_color
}
}
int translate_bsp;
int translate_mdl;
int translate_gfx;
int translate_spr;
byte colorthis;
extern byte gfx_fallback_palette[];
@ -1264,8 +1260,6 @@ void Palette_Init (void)
}
if (host_basepal != host_otherpal){
// Make a translation table for converting stuff that uses otherpal to our new pal
translate_bsp = 1;
#ifdef EGAHACK
InitRemap(host_origpal);
//GrabColorMapEGA();

6
engine/sbar.c
View file

@ -484,16 +484,16 @@ Sbar_DrawScoreboard
===============
*/
extern int deathcam_yesiamdead;
extern int deathcam_active;
extern float deathcam_whenidied;
void Sbar_DrawScoreboard (void)
{
Sbar_SoloScoreboard ();
if (cl.gametype == GAME_DEATHMATCH){
if (deathcam_yesiamdead && ((sv.time - deathcam_whenidied) > 2))
if (deathcam_active && ((sv.time - deathcam_whenidied) > 2))
Sbar_DeathmatchOverlay ();
else if (!deathcam_yesiamdead)
else if (!deathcam_active)
Sbar_DeathmatchOverlay ();
}

45
engine/sv_move.c
View file

@ -170,22 +170,22 @@ qboolean SV_movestep (edict_t *ent, vec3_t move, qboolean relink)
{
neworg[2] -= STEPSIZE;
trace = SV_Move (neworg, ent->v.mins, ent->v.maxs, end, false, ent);
if (trace.allsolid || trace.startsolid)
return false;
}
if (trace.fraction == 1)
{
// if monster had the ground pulled out, go ahead and fall
// if monster had the ground pulled out, go ahead and fall
if ( (int)ent->v.flags & FL_PARTIALGROUND )
{
VectorAdd (ent->v.origin, move, ent->v.origin);
if (relink)
SV_LinkEdict (ent, true);
ent->v.flags = (int)ent->v.flags & ~FL_ONGROUND;
// Con_Printf ("fall down\n");
return true;
}
return false; // walked off an edge
}
@ -206,15 +206,14 @@ qboolean SV_movestep (edict_t *ent, vec3_t move, qboolean relink)
}
if ( (int)ent->v.flags & FL_PARTIALGROUND )
{
// Con_Printf ("back on ground\n");
ent->v.flags = (int)ent->v.flags & ~FL_PARTIALGROUND;
}
ent->v.groundentity = EDICT_TO_PROG(trace.ent);
// the move is ok
// the move is ok
if (relink)
SV_LinkEdict (ent, true);
return true;
}
@ -268,8 +267,6 @@ SV_FixCheckBottom
*/
void SV_FixCheckBottom (edict_t *ent)
{
// Con_Printf ("SV_FixCheckBottom\n");
ent->v.flags = (int)ent->v.flags | FL_PARTIALGROUND;
}
@ -284,15 +281,16 @@ SV_NewChaseDir
#define DI_NODIR -1
void SV_NewChaseDir (edict_t *actor, edict_t *enemy, float dist)
{
float deltax,deltay;
float d[3];
float tdir, olddir, turnaround;
float deltax,deltay;
float d[3];
float tdir, olddir, turnaround;
olddir = anglemod( (int)(actor->v.ideal_yaw/45)*45 );
turnaround = anglemod(olddir - 180);
deltax = enemy->v.origin[0] - actor->v.origin[0];
deltay = enemy->v.origin[1] - actor->v.origin[1];
if (deltax>10)
d[1]= 0;
else if (deltax<-10)
@ -326,12 +324,10 @@ void SV_NewChaseDir (edict_t *actor, edict_t *enemy, float dist)
d[2]=tdir;
}
if (d[1]!=DI_NODIR && d[1]!=turnaround
&& SV_StepDirection(actor, d[1], dist))
if (d[1]!=DI_NODIR && d[1]!=turnaround && SV_StepDirection(actor, d[1], dist))
return;
if (d[2]!=DI_NODIR && d[2]!=turnaround
&& SV_StepDirection(actor, d[2], dist))
if (d[2]!=DI_NODIR && d[2]!=turnaround && SV_StepDirection(actor, d[2], dist))
return;
/* there is no direct path to the player, so pick another direction */
@ -395,9 +391,6 @@ void SV_MoveToGoal (void)
{
edict_t *ent, *goal;
float dist;
#ifdef QUAKE2
edict_t *enemy;
#endif
ent = PROG_TO_EDICT(pr_global_struct->self);
goal = PROG_TO_EDICT(ent->v.goalentity);
@ -409,20 +402,12 @@ void SV_MoveToGoal (void)
return;
}
// if the next step hits the enemy, return immediately
#ifdef QUAKE2
enemy = PROG_TO_EDICT(ent->v.enemy);
if (enemy != sv.edicts && SV_CloseEnough (ent, enemy, dist) )
#else
// if the next step hits the enemy, return immediately
if ( PROG_TO_EDICT(ent->v.enemy) != sv.edicts && SV_CloseEnough (ent, goal, dist) )
#endif
return;
// bump around...
if ( (rand()&3)==1 ||
!SV_StepDirection (ent, ent->v.ideal_yaw, dist))
{
// bump around...
if ( (rand()&3)==1 || !SV_StepDirection (ent, ent->v.ideal_yaw, dist))
SV_NewChaseDir (ent, goal, dist);
}
}

142
engine/sv_user.c
View file

@ -169,27 +169,7 @@ SV_Accelerate
*/
cvar_t *sv_maxspeed;
cvar_t *sv_accelerate;
#if 0
void SV_Accelerate (vec3_t wishvel)
{
int i;
float addspeed, accelspeed;
vec3_t pushvec;
if (wishspeed == 0)
return;
VectorSubtract (wishvel, velocity, pushvec);
addspeed = VectorNormalize (pushvec);
accelspeed = sv_accelerate->value*host_frametime*addspeed;
if (accelspeed > addspeed)
accelspeed = addspeed;
for (i=0 ; i<3 ; i++)
velocity[i] += accelspeed*pushvec[i];
}
#endif
void SV_Accelerate (void)
{
int i;
@ -394,6 +374,7 @@ void SV_NoclipMove (void)
wishvel[2] *= -2;
VectorCopy (wishvel, velocity);
}
/*
===================
SV_ClientThink
@ -402,46 +383,40 @@ the move fields specify an intended velocity in pix/sec
the angle fields specify an exact angular motion in degrees
===================
*/
extern int aimlock;
extern float aimlockangle = 15; // maximum extremities of aiming in the aimlock
extern float aimlockangled;
extern vec3_t lockedangle;
extern vec3_t deathcam_angles;
extern float aimlockangle = 15; // maximum extremities of aiming in the aimlock
extern float aimlockangled;
extern vec3_t lockedangle;
extern vec3_t deathcam_angles;
extern cvar_t *cl_diecam;
vec3_t dangles;
extern int deathcam_yesiamdead;
extern float deathcam_whenidied;
extern float thestandstill;
vec3_t dangles;
extern int deathcam_active;
extern float deathcam_whenidied;
extern float thestandstill;
void SV_ClientThink (void)
{
vec3_t v_angle;
int yeahdead;
if (sv_player->v.movetype == MOVETYPE_NONE)
return;
if (cl.stats[STAT_HEALTH] <= 0) {
yeahdead = 1;
if (!deathcam_yesiamdead){
if (cl.stats[STAT_HEALTH] <= 0)
{
if (!deathcam_active)
{
deathcam_angles[PITCH] = 50;
// deathcam_angles[YAW] = 20;
deathcam_angles[ROLL] = 0;
deathcam_whenidied = sv.time;
//Con_Printf("I died at %f. sob.\n", deathcam_whenidied);
}
if (cl_diecam->value)
deathcam_yesiamdead = cl_diecam->value;
deathcam_active = cl_diecam->value;
}
else
{
yeahdead = 0;
deathcam_yesiamdead = 0;
}
deathcam_active = 0;
onground = (int)sv_player->v.flags & FL_ONGROUND;
@ -496,28 +471,32 @@ void SV_ClientThink (void)
angles = sv_player->v.angles;
// leilei - aim lock
if (aimlock){
if ((lockedangle[YAW] + aimlockangle) > 360){
// Con_Printf("goddamnit.\n");
if (cl.viewangles[YAW] > (lockedangle[YAW] + aimlockangle > 360)) sv_player->v.angles[YAW] -= 360;
if (cl.viewangles[YAW] > lockedangle[YAW] + aimlockangle) cl.viewangles[YAW] = lockedangle[YAW] + aimlockangle;
if ((lockedangle[YAW] + aimlockangle) > 360)
{
if (cl.viewangles[YAW] > (lockedangle[YAW] + aimlockangle > 360))
sv_player->v.angles[YAW] -= 360;
if (cl.viewangles[YAW] > lockedangle[YAW] + aimlockangle)
cl.viewangles[YAW] = lockedangle[YAW] + aimlockangle;
}
else
if (cl.viewangles[YAW] > lockedangle[YAW] + aimlockangle) cl.viewangles[YAW] = lockedangle[YAW] + aimlockangle;
if ((lockedangle[YAW] - aimlockangle) < 0){
if (cl.viewangles[YAW] < lockedangle[YAW] - aimlockangle) cl.viewangles[YAW] = lockedangle[YAW] - aimlockangle + 360;
if (cl.viewangles[YAW] < lockedangle[YAW] - aimlockangle) cl.viewangles[YAW] = lockedangle[YAW] - aimlockangle;
// Con_Printf("mother\n");
{
if (cl.viewangles[YAW] > lockedangle[YAW] + aimlockangle)
cl.viewangles[YAW] = lockedangle[YAW] + aimlockangle;
if ((lockedangle[YAW] - aimlockangle) < 0)
{
if (cl.viewangles[YAW] < lockedangle[YAW] - aimlockangle)
cl.viewangles[YAW] = lockedangle[YAW] - aimlockangle + 360;
if (cl.viewangles[YAW] < lockedangle[YAW] - aimlockangle)
cl.viewangles[YAW] = lockedangle[YAW] - aimlockangle;
}
else
if (cl.viewangles[YAW] < lockedangle[YAW] - aimlockangle) cl.viewangles[YAW] = lockedangle[YAW] - aimlockangle;
// TODO: wrap angle, wrapangle
if (cl.viewangles[PITCH] < lockedangle[PITCH] - aimlockangle) cl.viewangles[PITCH] = lockedangle[PITCH] - aimlockangle;
if (cl.viewangles[PITCH] > lockedangle[PITCH] + aimlockangle) cl.viewangles[PITCH] = lockedangle[PITCH] + aimlockangle;
// if (cl.viewangles[YAW] < lockedangle[YAW] - aimlockangle) cl.viewangles[YAW] = lockedangle[YAW] - aimlockangle;
// if (cl.viewangles[YAW] > lockedangle[YAW] + aimlockangle) cl.viewangles[YAW] = lockedangle[YAW] + aimlockangle;
if (cl.viewangles[YAW] < lockedangle[YAW] - aimlockangle) cl.viewangles[YAW] = lockedangle[YAW] - aimlockangle;
}
if (cl.viewangles[PITCH] < lockedangle[PITCH] - aimlockangle)
cl.viewangles[PITCH] = lockedangle[PITCH] - aimlockangle;
if (cl.viewangles[PITCH] > lockedangle[PITCH] + aimlockangle)
cl.viewangles[PITCH] = lockedangle[PITCH] + aimlockangle;
}
@ -529,7 +508,6 @@ void SV_ClientThink (void)
{
angles[PITCH] = -v_angle[PITCH]/3;
angles[YAW] = v_angle[YAW];
}
if ( (int)sv_player->v.flags & FL_WATERJUMP )
@ -537,9 +515,6 @@ void SV_ClientThink (void)
SV_WaterJump ();
return;
}
//
// walk
//
if (sv_player->v.movetype == MOVETYPE_NOCLIP)
SV_NoclipMove ();
@ -561,13 +536,11 @@ void SV_ReadClientMove (usercmd_t *move)
vec3_t angle;
int bits;
// read ping time
// read ping time
host_client->ping_times[host_client->num_pings%NUM_PING_TIMES]
= sv.time - MSG_ReadFloat ();
host_client->num_pings++;
// read current angles
// 2000-05-01 NVS CLC_move precise aiming by Maddes start
if (host_client->nvs_cclc >= 0.50)
{
for (i=0 ; i<3 ; i++)
@ -577,37 +550,28 @@ void SV_ReadClientMove (usercmd_t *move)
}
else
{
// 2000-05-01 NVS CLC_move precise aiming by Maddes end
for (i=0 ; i<3 ; i++)
angle[i] = MSG_ReadAngle ();
} // 2000-05-01 NVS CLC precise_move aiming by Maddes
}
VectorCopy (angle, host_client->edict->v.v_angle);
// read movement
// read movement
move->forwardmove = MSG_ReadShort ();
move->sidemove = MSG_ReadShort ();
move->upmove = MSG_ReadShort ();
// read buttons
// read buttons
bits = MSG_ReadByte ();
host_client->edict->v.button0 = bits & 1;
// 1999-10-29 +USE fix by Maddes start
if (!nouse)
{
host_client->edict->v.button1 = (bits & 4)>>2;
}
// 1999-10-29 +USE fix by Maddes end
host_client->edict->v.button2 = (bits & 2)>>1;
i = MSG_ReadByte ();
if (i)
host_client->edict->v.impulse = i;
#ifdef QUAKE2
// read light level
host_client->edict->v.light_level = MSG_ReadByte ();
#endif
}
/*
@ -654,21 +618,17 @@ nextmsg:
{
case -1:
goto nextmsg; // end of message
default:
Sys_Printf ("SV_ReadClientMessage: unknown command char\n");
return false;
case clc_nop:
// Sys_Printf ("clc_nop\n");
break;
case clc_stringcmd:
s = MSG_ReadString ();
if (host_client->privileged)
ret = 2;
else
ret = 0;
if (Q_strncasecmp(s, "status", 6) == 0)
ret = 1;
else if (Q_strncasecmp(s, "god", 3) == 0)
@ -707,22 +667,15 @@ nextmsg:
ret = 1;
else if (Q_strncasecmp(s, "ban", 3) == 0)
ret = 1;
// 2000-01-09 QCExec by FrikaC/Maddes start
else if (Q_strncasecmp(s, "qcexec", 6) == 0)
ret = 1;
// 2000-01-09 QCExec by FrikaC/Maddes end
// 2000-01-20 Enhanced version command by Maddes start
else if (Q_strncasecmp(s, "version", 7) == 0)
ret = 1;
// 2000-01-20 Enhanced version command by Maddes end
// 2000-04-30 NVS HANDSHAKE SRV<->CL by Maddes
else if (Q_strncasecmp(s, "nvs_request", 11) == 0)
ret = 1;
// 2000-04-30 NVS HANDSHAKE SRV<->CL by Maddes
// 2001-09-20 Configurable limits by Maddes start
else if (Q_strncasecmp(s, "limit_request", 11) == 0)
ret = 1;
// 2001-09-20 Configurable limits by Maddes end
if (ret == 2)
Cbuf_InsertText (s);
else if (ret == 1)
@ -732,7 +685,6 @@ nextmsg:
break;
case clc_disconnect:
// Sys_Printf ("SV_ReadClientMessage: client disconnected\n");
return false;
case clc_move:

198
engine/view.c
View file

@ -135,7 +135,7 @@ vec3_t lockedangle;
extern cvar_t *cl_diecam;
extern float deathcamtime;
extern vec3_t deathcam_angles;
extern int deathcam_yesiamdead;
extern int deathcam_active;
/*
===============
@ -182,24 +182,15 @@ float V_CalcBob (void)
{
float bob;
float cycle;
int caycle;
// float xyspeed;
// float bspeed;
cycle = cl.time - (int)(cl.time/cl_bobcycle->value)*cl_bobcycle->value;
cycle /= cl_bobcycle->value;
if (cycle < cl_bobup->value)
cycle = M_PI * cycle / cl_bobup->value;
else
cycle = M_PI + M_PI*(cycle-cl_bobup->value)/(1.0 - cl_bobup->value);
caycle =1;
// bob is proportional to velocity in the xy plane
// (don't count Z, or jumping messes it up)
bob = sqrt(cl.velocity[0]*cl.velocity[0] + cl.velocity[1]*cl.velocity[1]) * cl_bob->value;
//bob = sqrt(cl.velocity[0]*cl.velocity[0] + cl.velocity[1]*cl.velocity[1]);
if (!cl_bobmodel->value){
@ -752,12 +743,10 @@ void V_UpdatePalette (void)
byte *basepal, *newpal;
byte pal[768];
int r,g,b,s;
float sat, cont, gamma;
float sat, cont;
qboolean force, forcetwo, forcethree;
gamma = v_gamma->value;
sat = v_saturation->value;
cont = v_contrast->value;
foralphashift = r_alphashift->value;
@ -903,10 +892,7 @@ void V_UpdatePalette (void)
}
shiftalpha = ((int)cl.cshifts[j].percent);
// if (!foralphashift)
VID_SetPalette (pal);
// else
// V_CalcAlphaShift();
}
@ -985,11 +971,6 @@ void CalcGunAngle (void)
cl.viewent.angles[ROLL] -= v_idlescale->value * sin(cl.time*v_iroll_cycle->value) * v_iroll_level->value;
cl.viewent.angles[PITCH] -= v_idlescale->value * sin(cl.time*v_ipitch_cycle->value) * v_ipitch_level->value;
cl.viewent.angles[YAW] -= v_idlescale->value * sin(cl.time*v_iyaw_cycle->value) * v_iyaw_level->value;
// cl.viewent.angles[PITCH] -= bob * sin(cl.time*v_ipitch_cycle->value) * v_ipitch_level->value;
// cl.viewent.angles[YAW] -= bob * sin(cl.time*v_iyaw_cycle->value) * v_iyaw_level->value;
}
/*
@ -1275,7 +1256,7 @@ static void V_CalcRefdef(void)
else
oldz = ent->origin[2];
if (chase_active->value || deathcam_yesiamdead)
if (chase_active->value || deathcam_active)
Chase_Update ();
@ -1302,9 +1283,7 @@ void V_CalcRefdef (void)
{
entity_t *ent, *view;
int i;
vec3_t desiredaim;
float s;
// struct model_s oldmodel; // Was to be used for cl_gundraw 4 (show old model holstering first)
float s;
float t;
vec3_t forward, right, up;
vec3_t angles;
@ -1334,7 +1313,7 @@ void V_CalcRefdef (void)
ent->angles[PITCH] = -cl.viewangles[PITCH];
bob = V_CalcBob ();
if (chase_active->value || deathcam_yesiamdead)
if (chase_active->value || deathcam_active)
skipbob = 1; // don't bob in the chase cam...
// refresh position
@ -1850,10 +1829,11 @@ if (cl.stats[STAT_HEALTH] >= 1){
V_AddIdle (); // leilei - moved it way down here.
if (chase_active->value || deathcam_yesiamdead)
if (chase_active->value || deathcam_active)
Chase_Update ();
if (skipbob)
skipbob = 0;
skipbob = 0;
}
@ -1876,29 +1856,26 @@ void V_CalcRefdefOld (void)
V_DriftPitch ();
// ent is the player model (visible when out of body)
// ent is the player model (visible when out of body)
ent = &cl_entities[cl.viewentity];
// view is the weapon model (only visible from inside body)
// view is the weapon model (only visible from inside body)
view = &cl.viewent;
// transform the view offset by the model's matrix to get the offset from
// model origin for the view
ent->angles[YAW] = cl.viewangles[YAW]; // the model should face
// the view dir
ent->angles[PITCH] = -cl.viewangles[PITCH]; // the model should face
// the view dir
// transform the view offset by the model's matrix to get the offset from
// model origin for the view
ent->angles[YAW] = cl.viewangles[YAW];
ent->angles[PITCH] = -cl.viewangles[PITCH];
bob = V_CalcBob ();
// refresh position
// refresh position
VectorCopy (ent->origin, r_refdef.vieworg);
r_refdef.vieworg[2] += cl.viewheight + bob;
// never let it sit exactly on a node line, because a water plane can
// dissapear when viewed with the eye exactly on it.
// the server protocol only specifies to 1/16 pixel, so add 1/32 in each axis
// never let it sit exactly on a node line, because a water plane can
// dissapear when viewed with the eye exactly on it.
// the server protocol only specifies to 1/16 pixel, so add 1/32 in each axis
r_refdef.vieworg[0] += 1.0/32;
r_refdef.vieworg[1] += 1.0/32;
r_refdef.vieworg[2] += 1.0/32;
@ -1907,9 +1884,9 @@ void V_CalcRefdefOld (void)
V_CalcViewRoll ();
V_AddIdle ();
// offsets
// offsets
angles[PITCH] = -ent->angles[PITCH]; // because entity pitches are
// actually backward
// actually backward
angles[YAW] = ent->angles[YAW];
angles[ROLL] = ent->angles[ROLL];
@ -1920,53 +1897,49 @@ void V_CalcRefdefOld (void)
+ scr_ofsy->value*right[i]
+ scr_ofsz->value*up[i];
V_BoundOffsets ();
// set up gun position
// set up gun position
VectorCopy (cl.viewangles, view->angles);
CalcGunAngle ();
VectorCopy (ent->origin, view->origin);
view->origin[2] += cl.viewheight;
for (i=0 ; i<3 ; i++)
{
view->origin[i] += forward[i]*bob*0.4;
// view->origin[i] += right[i]*bob*0.4;
// view->origin[i] += up[i]*bob*0.8;
}
view->origin[2] += bob + 1;
view->model = cl.model_precache[cl.stats[STAT_WEAPON]];
view->frame = cl.stats[STAT_WEAPONFRAME];
view->colormap = vid.colormap;
// set up the refresh position
// set up the refresh position
VectorAdd (r_refdef.viewangles, cl.punchangle, r_refdef.viewangles);
// smooth out stair step ups
if (cl.onground && ent->origin[2] - oldz > 0)
{
float steptime;
// smooth out stair step ups
if (cl.onground && ent->origin[2] - oldz > 0)
{
float steptime;
steptime = cl.time - cl.oldtime;
if (steptime < 0)
//FIXME I_Error ("steptime < 0");
steptime = 0;
steptime = cl.time - cl.oldtime;
if (steptime < 0)
steptime = 0;
oldz += steptime * 80;
if (oldz > ent->origin[2])
oldz = ent->origin[2];
if (ent->origin[2] - oldz > 12)
oldz = ent->origin[2] - 12;
r_refdef.vieworg[2] += oldz - ent->origin[2];
view->origin[2] += oldz - ent->origin[2];
}
oldz += steptime * 80;
if (oldz > ent->origin[2])
oldz = ent->origin[2];
if (ent->origin[2] - oldz > 12)
oldz = ent->origin[2] - 12;
r_refdef.vieworg[2] += oldz - ent->origin[2];
view->origin[2] += oldz - ent->origin[2];
}
else
oldz = ent->origin[2];
if (chase_active->value || deathcam_yesiamdead)
if (chase_active->value || deathcam_active)
Chase_Update ();
@ -1994,7 +1967,7 @@ void V_RenderView (void)
if (con_forcedup)
return;
// don't allow cheats in multiplayer
// don't allow cheats in multiplayer
if (cl.maxclients > 1)
{
Cvar_Set (scr_ofsx, "0");
@ -2003,75 +1976,58 @@ void V_RenderView (void)
}
#ifdef VMTOC
V_CalcRefdef ();
V_CalcRefdef ();
#else
// wat...
// leilei - some crosshair.
if (aimlock){
AngleVectors (cl.viewangles, forward, right, up);
forward[0] *= 566;
forward[1] *= 566;
forward[2] *= 566;
// D_DrawSparkTrans(r_refdef.vieworg,r_refdef.vieworg,15, 0);
}
if (aimlock)
{
AngleVectors (cl.viewangles, forward, right, up);
forward[0] *= 566;
forward[1] *= 566;
forward[2] *= 566;
}
if (cl.intermission)
{ // intermission / finale rendering
V_CalcIntermissionRefdef ();
}
else
{
if (!cl.paused /* && (sv.maxclients > 1 || key_dest == key_game) */ )
if (!cl.paused)
if (cl_oldview->value)
V_CalcRefdefOld ();
else
V_CalcRefdef ();
V_CalcRefdefOld ();
else
V_CalcRefdef ();
}
#endif
#ifndef GLQUAKE
R_PushShadows (); // this is used and msvc is a paranoid liar for warning about it being unused
#endif
R_PushShadows ();
R_PushDlights ();
// R_PushWlights ();
// leilei - aim lock
if (aimlock){
r_refdef.viewangles[0] = lockedangle[0];
r_refdef.viewangles[1] = lockedangle[1];
// r_refdef.viewangles[2] = lockedangle[2];
if (aimlock)
{
r_refdef.viewangles[0] = lockedangle[0];
r_refdef.viewangles[1] = lockedangle[1];
}
R_RenderView ();
#ifndef GLQUAKE
if (crosshair->value && !deathcam_yesiamdead){
vec3_t crossthere;
if (aimlock){
R_RenderView ();
if (crosshair->value && !deathcam_active)
{
vec3_t crossthere;
if (aimlock)
{
crossthere[0] = r_refdef.viewangles[0] - lockedangle[0];
crossthere[1] = r_refdef.viewangles[1] - lockedangle[1];
// crossthere[2] = r_refdef.viewangles[2] - lockedangle[2];
}
else
{
crossthere[0] = 0;
crossthere[1] = 0;
crossthere[2] = 0;
}
Draw_Character (scr_vrect.x + scr_vrect.width/2 + cl_crossx->value + crossthere[0],scr_vrect.y + scr_vrect.height/2 + cl_crossy->value+ crossthere[1], '+');
}
#endif
else
{
crossthere[0] = 0;
crossthere[1] = 0;
crossthere[2] = 0;
}
Draw_Character (scr_vrect.x + scr_vrect.width/2 + cl_crossx->value + crossthere[0],scr_vrect.y + scr_vrect.height/2 + cl_crossy->value+ crossthere[1], '+');
}
}
//============================================================================

114
icon.xpm
View file

@ -1,62 +1,62 @@
/* XPM */
static char * icon_xpm[] = {
"48 48 11 1",
" c #000000",
". c #EEEEEC",
" c None",
". c #000000",
"+ c #204A87",
"@ c #888A85",
"@ c #555753",
"# c #3465A4",
"$ c #BABDB6",
"% c #729FCF",
"& c #555753",
"* c #D3D7CF",
"= c #4E9A06",
"- c #E9B96E",
" ",
" ",
" ",
" ",
" ",
" .++++++++++ ..+++++++++++ ",
" .++++++++++ @.++++++++++++ ",
" .++++++++++ ..++++++++++++ ",
" .+#+#+#+#+# @.#+#+#+#+#+#+# ",
" .#+#+#+#+#+ ..+#+#+#+#+#+#+ ",
" .+#+#+#+#+# @.+#+#+#+#+#+#+# ",
" .########## ..############## ",
" .########## $.############### ",
" .########## ..############### ",
" .#%###%#%#% @.#%#%#%###%#%#%## ",
" .########## ..################ ",
" .+%+%+%+%+% $.%+%+%+%#%#%+%+%+% ",
" .%###%###%# .##%###%.##%###%### ",
" .@%&%&%&%&% $.&%&%&%&.&%&%&%%%&% ",
" .%@%@%@%@%@ .@%@%@%@ .%@%@%@%@%@ ",
" .%%@%%%@%%% *.%@%%%@% .@%%%@%%%@% ",
" .%@%@%@%@%@ &.%@%@%@% .%@%@%@%@%@ ",
" .$$$$$$$$$$ *.$$$$$$$ .$$$$$$$$$$ ",
" .$$$$$$$$$$ &.$$$$$$$ .$$$$$$$$$$ ",
" .$*$*$*$*$* *.*$*$*$* .$*$*$*$*$* ",
" .=*=*=*=*=* &.=*=*=*= .=*=*=*=*=* ",
" .*=*=*=*=*= *.*=*=*=* .*=*=*=*=*= ",
" .********** &.*=***** .=********* ",
" .********** ..******* .********** ",
" .**********@.******* .********** ",
" .**********..***.*.. ...*....-.. ",
" .**********.******* .********** ",
" .*=*=*=*=*=.=*=*=*= .*=*=*=*=*= ",
" .$$$$$$$$$$$$$$$$$ .$$$$$$$$$$ ",
" .$=$=$=$=$=$=$=$= .$=$=$=$=$= ",
" .=*=*=*=*=*=*=*=* .=*=*=*=*=* ",
" .==$===$===$===$ .$===$===$= ",
" .=$=$=$=$=$=$=$= .=$=$=$=$=$ ",
" .@===@===@===@= .==@===@=== ",
" .=@=@=@=@=@=@=@ .=@=@=@=@=@ ",
" .============= .========== ",
" .=&=&=&=&=&=&= .=&=&=&=&=& ",
" .====&======= .==&===&=== ",
" .============ .========== ",
" .=========== .========== ",
" ",
" ",
" "};
"$ c #4E9A06",
"% c #888A85",
"& c #729FCF",
"* c #BABDB6",
"= c #D3D7CF",
"- c #EEEEEC",
"................................................",
"................................................",
"................................................",
"................................................",
"................................................",
".....-++++++++++.............--+++++++++++......",
".....-++++++++++............%-++++++++++++......",
".....-++++++++++............--++++++++++++......",
".....-+#+#+#+#+#...........%-#+#+#+#+#+#+#......",
".....-#+#+#+#+#+...........--+#+#+#+#+#+#+......",
".....-+#+#+#+#+#..........%-+#+#+#+#+#+#+#......",
".....-##########..........--##############......",
".....-##########.........*-###############......",
".....-##########.........--###############......",
".....-#&###&#&#&........%-#&#&#&###&#&#&##......",
".....-##########........--################......",
".....-+&+&+&+&+&.......*-&+&+&+&#&#&+&+&+&......",
".....-&###&###&#.......-##&###&-##&###&###......",
".....-%&@&@&@&@&......*-@&@&@&@-@&@&@&&&@&......",
".....-&%&%&%&%&%......-%&%&%&%.-&%&%&%&%&%......",
".....-&&%&&&%&&&.....=-&%&&&%&.-%&&&%&&&%&......",
".....-&%&%&%&%&%....@-&%&%&%&..-&%&%&%&%&%......",
".....-**********....=-*******..-**********......",
".....-**********...@-*******...-**********......",
".....-*=*=*=*=*=...=-=*=*=*=...-*=*=*=*=*=......",
".....-$=$=$=$=$=..@-$=$=$=$....-$=$=$=$=$=......",
".....-=$=$=$=$=$..=-=$=$=$=....-=$=$=$=$=$......",
".....-==========.@-=======.....-==========......",
".....-==========.--=======.....-==========......",
".....-==========%-=======......-==========......",
".....-==========--=======......-==========......",
".....-==================.......-==========......",
".....-=$=$=$=$=$=$=$=$=$.......-=$=$=$=$=$......",
".....-*****************........-**********......",
".....-*$*$*$*$*$*$*$*$.........-*$*$*$*$*$......",
".....-$=$=$=$=$=$=$=$=.........-$=$=$=$=$=......",
".....-$$*$$$*$$$*$$$*..........-*$$$*$$$*$......",
".....-$*$*$*$*$*$*$*$..........-$*$*$*$*$*......",
".....-%$$$%$$$%$$$%$...........-$$%$$$%$$$......",
".....-$%$%$%$%$%$%$%...........-$%$%$%$%$%......",
".....-$$$$$$$$$$$$$............-$$$$$$$$$$......",
".....-$@$@$@$@$@$@$............-$@$@$@$@$@......",
".....-$$$$@$$$$$$$.............-$$@$$$@$$$......",
".....-$$$$$$$$$$$$.............-$$$$$$$$$$......",
".....-$$$$$$$$$$$..............-$$$$$$$$$$......",
"................................................",
"................................................",
"................................................"};

17
include/common.h
View file

@ -324,19 +324,4 @@ typedef enum {
pt_static, pt_grav, pt_slowgrav, pt_fire, pt_explode, pt_explode2, pt_blob, pt_blob2, pt_fastgrav, pt_smoke, pt_decel, pt_blood, pt_add, pt_staticfade, pt_addfade,pt_staticfadeadd, pt_slowgravaddfade, pt_bloodsplatten, pt_bloodsplat, pt_blooddrip, pt_bloodrun, pt_bloodfloor, pt_trail, pt_spark, pt_snow, pt_fire6, pt_decal, pt_flare, pt_flare_will_die, pt_sparkvel, pt_drip
} ptype_t;
extern struct entity_s;
/*
typedef struct
{
vec3_t origin;
float radius;
vec3_t color;
struct model_t *model;
struct entity_t *owner;
} flare_t;
*/
void TheForceLoadLighting (void); // gotta try to call this somewhere that works.
void TheForceLoadLighting (void); // gotta try to call this somewhere that works.

24
include/globaldef.h
View file

@ -36,16 +36,6 @@ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
#define INTERPOL7 // other interpolation again (still buggy)*WIP*
// -----------------------------------------
// Audio Features
// -----------------------------------------
int inthedos;
//#define NOASM
#define EFFINGMOUSE // disables "Enhance Pointer Precision"
// a definite MUST for debugging
// -----------------------------------------
// Gameplay Features
// -----------------------------------------
@ -64,7 +54,7 @@ int Nehahrademcompatibility; // LordHavoc: to allow playback of the early Nehah
int dpprotocol;
#define DPPROTOCOLS
#define VERSION 0.6
#define VERSION 0.7
#define PROTOCOL_STOCK 0 // old 1.09
#define PROTOCOL_QUAKEDP 1 // dp105
@ -106,15 +96,9 @@ int dpprotocol;
#define VID_UnlockBuffer()
#endif
#if defined __i386__ && !defined NOASM // && !defined __sun__
#define id386 1
#define id386poly 0
#define id386rgb 0
#else
#define id386 0
#define id386poly 0
#define id386rgb 0
#endif
#define id386 0
#define id386poly 0
#define id386rgb 0
#if id386
#define UNALIGNED_OK 1 // set to 0 if unaligned accesses are not supported

250
renderer/d_polyse.c
View file

@ -323,10 +323,6 @@ void D_DrawNonSubdiv (void)
}
D_PolysetSetEdgeTable ();
/* if (r_filter->value)
D_RasterizeAliasPolySmooth ();
else*/
D_RasterizeAliasPolySmooth ();
}
}
@ -751,7 +747,6 @@ void D_PolysetDrawSpans8 (spanpackage_t *pspanpackage)
#endif // !id386
extern vec3_t lightcolor;
extern byte gelmap[256];
extern byte bumpmap[256];
extern pixel_t transTable[256][256];
@ -784,14 +779,11 @@ extern int kernel[2][2][2];
void D_PolysetDrawSpans8RGB_C_Filter (spanpackage_t *pspanpackage)
{
byte *lpdest;
byte *lpbuf;
byte *lptex;
int lcount;
int lsfrac, ltfrac;
int llight;
int llightrgb[3];
int colme[3];
int rgb;
int lzi;
short *lpz;
unsigned char *pix24; // leilei - colored lighting
@ -954,17 +946,13 @@ void D_PolysetDrawSpans8RGB_C (spanpackage_t *pspanpackage)
{
int lcount;
byte *lpdest;
byte *lpbuf;
byte *lptex;
int forg; // leilei - fog
int lsfrac, ltfrac;
int llight;
int llightrgb[3];
int colme[3];
int rgb;
int lzi;
int lzf; // leilei - fog
float zf; // leilei - fog
// leilei - fog
short *lpz;
unsigned char *pix24; // leilei - colored lighting
int trans[3];
@ -1153,7 +1141,6 @@ void D_PolysetDrawSpans8_C (spanpackage_t *pspanpackage)
{
int lcount;
byte *lpdest;
byte *lpbuf;
byte *lptex;
int forg; // leilei - fog
int lsfrac, ltfrac;
@ -1162,25 +1149,14 @@ void D_PolysetDrawSpans8_C (spanpackage_t *pspanpackage)
int llightd;
int llightrgb[3];
int llightrgbd[3];
int colme[3];
int rgb;
int lzi;
short *lpz;
unsigned char *pix24; // leilei - colored lighting
int trans[3];
int shad = 0; // leilei - shade offset
float bhad = 1;
int ta, te, tv;
int dith, det; // leilei - shading dither
int det; // leilei - shading dither
int dodith, doshine;
int s, t;
int s2, t2;
#if 0 // for now
if (coloredmethod == 1){
D_PolysetDrawSpans8_Low_C (pspanpackage);
return;
}
#endif
dodith = r_shadedither->value;
doshine = r_shinygrays->value;
if (currententity->effects & EF_NODRAW || currententity->leifect)
@ -1290,9 +1266,6 @@ void D_PolysetDrawSpans8_C (spanpackage_t *pspanpackage)
// Shine crap
if ((doshine == 2)&& *lptex < 16){
int ti;
llightrgb[0] &= 0xAF00;
llightrgb[1] &= 0xAF00;
llightrgb[2] &= 0xAF00;
@ -1473,29 +1446,25 @@ void D_PolysetDrawSpans8_Low_C (spanpackage_t *pspanpackage)
{
int lcount;
byte *lpdest;
byte *lpbuf;
byte *lptex;
int forg; // leilei - fog
int lsfrac, ltfrac;
int lsfrac, ltfrac;
int llight;
int llightd;
int llightrgb[3];
int llightrgbd[3];
int colme[3];
int rgb;
int lzi;
int llight;
int llightd;
int llightrgb[3];
int llightrgbd[3];
int lzi;
short *lpz;
unsigned char *pix24; // leilei - colored lighting
int trans[3];
int shad = 0; // leilei - shade offset
float bhad = 1;
int ta, te, tv;
int dith, det; // leilei - shading dither
int dodith, doshine;
int s, t;
int shad = 0; // leilei - shade offset
int det; // leilei - shading dither
int dodith, doshine;
dodith = r_shadedither->value;
doshine = r_shinygrays->value;
if (currententity->effects & EF_NODRAW || currententity->leifect)
return; // haha don't do it
det = 0;
@ -1522,9 +1491,6 @@ void D_PolysetDrawSpans8_Low_C (spanpackage_t *pspanpackage)
lpz = pspanpackage->pz;
lsfrac = pspanpackage->sfrac;
ltfrac = pspanpackage->tfrac;
s = lsfrac;
t = ltfrac;
det++;
if (det > 3)
@ -1596,7 +1562,6 @@ void D_PolysetDrawSpans8_Low_C (spanpackage_t *pspanpackage)
// metal shine...
// Shine crap
if ((doshine == 2)&& *lptex < 16){
int ti;
llightrgb[0] &= 0xAF00;
llightrgb[1] &= 0xAF00;
llightrgb[2] &= 0xAF00;
@ -1764,14 +1729,11 @@ void D_PolysetDrawSpans8_C_Dither (spanpackage_t *pspanpackage)
{
int lcount;
byte *lpdest;
byte *lpbuf;
byte *lptex;
int lsfrac, ltfrac;
int llight;
int llightrgb[3];
int colme[3];
int rgb;
int lzi;
short *lpz;
unsigned char *pix24; // leilei - colored lighting
@ -1958,23 +1920,20 @@ void D_PolysetDrawSpans8_C_Filter (spanpackage_t *pspanpackage)
{
int lcount;
byte *lpdest;
byte *lpbuf;
byte *lptex;
int lsfrac, ltfrac;
int llight;
int llightrgb[3];
int colme[3];
int rgb;
int n;
int lzi;
short *lpz;
unsigned char *pix24; // leilei - colored lighting
unsigned char *dix24; // leilei - colored dithering
int trans[3];
if (currententity->effects & EF_NODRAW || currententity->leifect)
return; // haha don't do it
return; // haha don't do it
do
{
lcount = d_aspancount - pspanpackage->count;
@ -1986,9 +1945,7 @@ void D_PolysetDrawSpans8_C_Filter (spanpackage_t *pspanpackage)
errorterm -= erroradjustdown;
}
else
{
d_aspancount += ubasestep;
}
if (lcount)
{
@ -2008,69 +1965,49 @@ void D_PolysetDrawSpans8_C_Filter (spanpackage_t *pspanpackage)
{
if ((lzi >> 16) >= *lpz)
{
/* int idiths = lsfrac;
{
int idiths = s;
int iditht = t;
int idiths = lsfrac; int iditht = lsfrac;
int X = (lsfrac + d_aspancount) & 1;
int Y = (ltfrac)&1;
int X = (pspan->u + spancount) & 1;
int Y = (pspan->v)&1;
idiths += kernel[X][Y][0];
iditht += kernel[X][Y][1];
idiths += kernel[X][Y][0];
iditht += kernel[X][Y][1];
idiths = idiths >> 16;
idiths = idiths ? idiths -1 : idiths;
iditht = iditht >> 16;
iditht = iditht ? iditht -1 : iditht;
*pdest++ = *(pbase + idiths + iditht * cachewidth);
*/
{
int idiths = lsfrac; int iditht = lsfrac;
int X = (lsfrac + d_aspancount) & 1;
int Y = (ltfrac)&1;
idiths += kernel[X][Y][0];
iditht += kernel[X][Y][1];
idiths = idiths >> 16;
idiths = idiths ? idiths -1 : idiths;
idiths = idiths >> 16;
idiths = idiths ? idiths -1 : idiths;
iditht = iditht >> 16;
iditht = iditht ? iditht -1 : iditht;
iditht = iditht >> 16;
iditht = iditht ? iditht -1 : iditht;
pix24 = (unsigned char *)&d_8to24table[((byte *)acolormap)[*lptex + + idiths + iditht + (8192 & 0xFF00)]];
pix24 = (unsigned char *)&d_8to24table[((byte *)acolormap)[*lptex + + idiths + iditht + (8192 & 0xFF00)]];
// TODO FIXME: colored light vectors similar to dp105/q3
trans[0] = (pix24[0] * (16384 - llightrgb[0])) >> 15;
trans[1] = (pix24[1] * (16384 - llightrgb[1])) >> 15;
trans[2] = (pix24[2] * (16384 - llightrgb[2])) >> 15;
trans[0] = (pix24[0] * (16384 - llightrgb[0])) >> 15;
trans[1] = (pix24[1] * (16384 - llightrgb[1])) >> 15;
trans[2] = (pix24[2] * (16384 - llightrgb[2])) >> 15;
if (trans[0] < 0) trans[0] = 0; if (trans[1] < 0) trans[1] = 0; if (trans[2] < 0) trans[2] = 0;
if (trans[0] > 63) trans[0] = 63; if (trans[1] > 63) trans[1] = 63; if (trans[2] > 63) trans[2] = 63;
// 18-Bit lighting - Vanilla Blending
//*lpdest = *(lptex + idiths + iditht);
*lpdest = palmap2[trans[0]][trans[1]][trans[2]];
*lpz = lzi >> 16;
if (trans[0] < 0) trans[0] = 0; if (trans[1] < 0) trans[1] = 0; if (trans[2] < 0) trans[2] = 0;
if (trans[0] > 63) trans[0] = 63; if (trans[1] > 63) trans[1] = 63; if (trans[2] > 63) trans[2] = 63;
*lpdest = palmap2[trans[0]][trans[1]][trans[2]];
*lpz = lzi >> 16;
}
}
lpdest++;
lzi += r_zistepx;
lpz++;
llight += r_lstepx;
if(coloredlights){
llightrgb[0] += r_lrstepx;
llightrgb[1] += r_lgstepx;
llightrgb[2] += r_lbstepx;
if(coloredlights)
{
llightrgb[0] += r_lrstepx;
llightrgb[1] += r_lgstepx;
llightrgb[2] += r_lbstepx;
}
lptex += a_ststepxwhole;
lsfrac += a_sstepxfrac;
lptex += lsfrac >> 16;
@ -2082,6 +2019,7 @@ void D_PolysetDrawSpans8_C_Filter (spanpackage_t *pspanpackage)
lptex += r_affinetridesc.skinwidth;
ltfrac &= 0xFFFF;
}
} while (--lcount);
}
@ -2425,22 +2363,7 @@ void D_RasterizeAliasPolySmooth (void)
originalcount = a_spans[initialrightheight].count;
a_spans[initialrightheight].count = -999999; // mark end of the spanpackages
// eukara - not sure what is going on here
#ifdef dithermodelhack
if (coloredlights == 2)
D_PolysetDrawSpans8_C (a_spans);
else
#endif
if (coloredlights)
{
if (r_filter->value)
D_PolysetDrawSpans8_C (a_spans);
else
D_PolysetDrawSpans8_C (a_spans);
}
else
D_PolysetDrawSpans8_C (a_spans);
D_PolysetDrawSpans8_C (a_spans);
// scan out the bottom part of the right edge, if it exists
if (pedgetable->numrightedges == 2)
@ -2464,21 +2387,7 @@ void D_RasterizeAliasPolySmooth (void)
d_countextrastep = ubasestep + 1;
a_spans[initialrightheight + height].count = -999999; // mark end of the spanpackages
#ifdef dithermodelhack
if (coloredlights == 2)
D_PolysetDrawSpans8_C (pstart);
else
#endif
if (coloredlights)
{
if (r_filter->value)
D_PolysetDrawSpans8_C (pstart);
else
D_PolysetDrawSpans8_C (pstart);
}
else
D_PolysetDrawSpans8_C (pstart);
D_PolysetDrawSpans8_C (pstart);
}
}
/*
@ -2489,12 +2398,12 @@ D_RasterizeAliasPolySmoothFilter
void D_RasterizeAliasPolySmoothFilter (void)
{
int initialleftheight, initialrightheight;
int *plefttop, *prighttop, *pleftbottom, *prightbottom;
int working_lstepx, originalcount;
int working_lrstepx;
int working_lgstepx;
int working_lbstepx;
int initialleftheight, initialrightheight;
int *plefttop, *prighttop, *pleftbottom, *prightbottom;
int working_lstepx, originalcount;
int working_lrstepx;
int working_lgstepx;
int working_lbstepx;
plefttop = pedgetable->pleftedgevert0;
prighttop = pedgetable->prightedgevert0;
@ -2748,10 +2657,7 @@ void D_RasterizeAliasPolySmoothFilter (void)
originalcount = a_spans[initialrightheight].count;
a_spans[initialrightheight].count = -999999; // mark end of the spanpackages
if (coloredlights)
D_PolysetDrawSpans8_C (a_spans);
else
D_PolysetDrawSpans8_C (a_spans);
D_PolysetDrawSpans8_C (a_spans);
// scan out the bottom part of the right edge, if it exists
if (pedgetable->numrightedges == 2)
@ -2775,13 +2681,7 @@ void D_RasterizeAliasPolySmoothFilter (void)
d_countextrastep = ubasestep + 1;
a_spans[initialrightheight + height].count = -999999;
// mark end of the spanpackages
if (coloredlights)
D_PolysetDrawSpans8_C (pstart);
else
D_PolysetDrawSpans8_C (pstart);
// D_PolysetDrawSpans8_C (pstart);
// D_PolysetDrawSpans8_C (pstart);
D_PolysetDrawSpans8_C (pstart);
}
}
@ -2794,14 +2694,10 @@ D_PolysetSetEdgeTable
void D_PolysetSetEdgeTable (void)
{
int edgetableindex;
edgetableindex = 0; // assume the vertices are already in
// top to bottom order
//
// determine which edges are right & left, and the order in which
// to rasterize them
//
// determine which edges are right & left, and the order in which
// to rasterize them
if (r_p0[1] >= r_p1[1])
{
if (r_p0[1] == r_p1[1])
@ -2889,35 +2785,3 @@ split:
D_PolysetRecursiveDrawLine (lp1, new);
D_PolysetRecursiveDrawLine (new, lp2);
}
/*
void D_PolysetRecursiveTriangle2 (int *lp1, int *lp2, int *lp3)
{
int d;
int new[4];
d = lp2[0] - lp1[0];
if (d < -1 || d > 1)
goto split;
d = lp2[1] - lp1[1];
if (d < -1 || d > 1)
goto split;
return;
split:
// split this edge
new[0] = (lp1[0] + lp2[0]) >> 1;
new[1] = (lp1[1] + lp2[1]) >> 1;
new[5] = (lp1[5] + lp2[5]) >> 1;
new[2] = (lp1[2] + lp2[2]) >> 1;
new[3] = (lp1[3] + lp2[3]) >> 1;
new[4] = (lp1[4] + lp2[4]) >> 1;
D_PolysetRecursiveDrawLine (new, lp3);
// recursively continue
D_PolysetRecursiveTriangle (lp1, new, lp3);
D_PolysetRecursiveTriangle (new, lp2, lp3);
}
*/

18
renderer/d_surf.c
View file

@ -318,21 +318,17 @@ surfcache_t *D_CacheSurface (msurface_t *surface, int miplevel)
merp = 1;
if (truecolor)
merp = 4;
if (truecolor)
merp = 4;
//
// allocate memory if needed
//
// allocate memory if needed
if (!cache) // if a texture just animated, don't reallocate it
{
if (coloredlights == 2 || truecolor)
cache = D_SCAlloc (r_drawsurf.surfwidth, merp, r_drawsurf.surfwidth * r_drawsurf.surfheight * 2); // leilei - DITHERDITHER
else
cache = D_SCAlloc (r_drawsurf.surfwidth, 1, r_drawsurf.surfwidth * r_drawsurf.surfheight * 2); // leilei - also increased this.
if (coloredlights == 2 || truecolor)
cache = D_SCAlloc (r_drawsurf.surfwidth, merp, r_drawsurf.surfwidth * r_drawsurf.surfheight * 2); // leilei - DITHERDITHER
else if (inthedos)
cache = D_SCAlloc (r_drawsurf.surfwidth, 1, r_drawsurf.surfwidth * r_drawsurf.surfheight); // leilei - can't go as high in dos :(
else
cache = D_SCAlloc (r_drawsurf.surfwidth, 1, r_drawsurf.surfwidth * r_drawsurf.surfheight * 2); // leilei - also increased this.
surface->cachespots[miplevel] = cache;
cache->owner = &surface->cachespots[miplevel];
cache->mipscale = surfscale;

15
renderer/r_main.c
View file

@ -954,7 +954,7 @@ R_DrawEntitiesOnList
extern vec3_t lightcolor; // used by model rendering
extern cvar_t *r_shading;
extern cvar_t *temp1;
extern int deathcam_yesiamdead;
extern int deathcam_active;
void R_DrawEntitiesOnList (void)
{
int i, j;
@ -987,7 +987,7 @@ void R_DrawEntitiesOnList (void)
if (currententity == &cl_entities[cl.viewentity])
// 2000-01-09 ChaseCam fix by FrikaC start
{
if (!chase_active->value && !deathcam_yesiamdead)
if (!chase_active->value && !deathcam_active)
{
// 2000-01-09 ChaseCam fix by FrikaC end
continue; // don't draw the player
@ -1233,19 +1233,10 @@ void R_DrawViewModel (void)
if (!r_drawviewmodel->value)
return;
// 2000-01-09 ChaseCam fix by FrikaC start
if (chase_active->value || deathcam_yesiamdead)
{
if (chase_active->value || deathcam_active)
return;
}
// 2000-01-09 ChaseCam fix by FrikaC end
if (!r_muzzlehack->value && cl.items & IT_INVISIBILITY)
return;
if (cl.stats[STAT_HEALTH] <= 0)
return;

415
renderer/r_part.c
View file

@ -115,9 +115,7 @@ void R_InitFlares (void)
r_numflares = ABSOLUTE_MIN_PARTICLES;
}
else
{
r_numflares = 256;
}
flares = (flare_t *)
Hunk_AllocName (r_numparticles * sizeof(flare_t), "flares");
@ -201,17 +199,14 @@ void R_EntityFireParticles (entity_t *ent, vec3_t org, float sizefix)
int i, g;
particle_t *p;
float angle;
float sp, sy, cp, cy, sr, cr; // 2001-12-10 Reduced compiler warnings by Jeff Ford
vec3_t forward, right;
float sp, sy, cp, cy; // 2001-12-10 Reduced compiler warnings by Jeff Ford
vec3_t forward;
float dist;
float langth;
int moed;
langth = 5;
dist = 1;
// count = 50; // 2001-12-10 Reduced compiler warnings by Jeff Ford
moed = 1;
if (!avelocities[0][0])
{
for (i=0 ; i<NUMVERTEXNORMALS*3 ; i++)
@ -234,16 +229,10 @@ void R_EntityFireParticles (entity_t *ent, vec3_t org, float sizefix)
angle = cl.time * avelocities[g][1];
sp = sin(angle);
cp = cos(angle);
angle = cl.time * avelocities[g][2];
sr = sin(angle); // 2001-12-10 Reduced compiler warnings by Jeff Ford
cr = cos(angle); // 2001-12-10 Reduced compiler warnings by Jeff Ford
forward[0] = cp*cy;
forward[1] = cp*sy;
forward[2] = -sp;
right[0] = cp*cr;
right[1] = cp*sr;
right[2] = -sr;
if (!free_particles)
return;
@ -296,16 +285,10 @@ void R_EntityFireParticles (entity_t *ent, vec3_t org, float sizefix)
angle = cl.time * avelocities[i][1];
sp = sin(angle);
cp = cos(angle);
angle = cl.time * avelocities[i][2];
sr = sin(angle); // 2001-12-10 Reduced compiler warnings by Jeff Ford
cr = cos(angle); // 2001-12-10 Reduced compiler warnings by Jeff Ford
forward[0] = cp*cy;
forward[1] = cp*sy;
forward[2] = -sp;
right[0] = cp*cr;
right[1] = cp*sr;
right[2] = -sr;
if (!free_particles)
return;
@ -371,18 +354,11 @@ void R_FireTrail (vec3_t start, vec3_t end, entity_t *ent)
int j;
particle_t *p;
int dec;
static int tracercount;
VectorSubtract (end, start, vec);
len = VectorNormalize (vec);
dec = 1;
// if (len < 0)
// {
// R_EntityFireParticles (ent, ent->origin); // if not moving, go to the still fire effect
// return;
// }
dec = 1;
while (len > 0)
{
@ -615,9 +591,6 @@ void R_ParticleExplosionSpritey (vec3_t org)
{
int i, j;
particle_t *p;
flare_t *f;
for (i=0 ; i<2 ; i++)
{
@ -682,51 +655,6 @@ void R_ParticleExplosionSpritey (vec3_t org)
// p->vel[2] = (rand()%356)-128;
}
}
// then the flare.
// else
/*
if (!free_flares)
return;
f = free_flares;
free_flares = f->next;
f->next = active_flares;
active_flares = f;
f->frame = 12;
f->scale = 0.2;
f->scalexvel = 6;
p->scaleyvel = 0;
f->blend = 3;
f->polor = 79;
// f->alpha = 1.2f;
f->die = cl.time + 0.3;
f->alphavel = -1.9f;
f->angles[2] = 0;
f->anglevel[2] = 0;
f->sprtype = 5;
for (j=0 ; j<3 ; j++)
{
f->org[j] = org[j];
f->vel[j] = 0;
}
{
trace_t tarce;
tarce = Particle_TraceLine(org, r_refdef.vieworg);
if(tarce.fraction < 1)
f->alpha = 0;
else
f->alpha = 1;
}
*/
}
extern cvar_t *r_particletrails;
@ -739,7 +667,7 @@ R_ParticleTrail
*/
void R_ParticleTrail (vec3_t org, vec3_t veloc, int trl, float tim, int coll, float alf, int blend)
{
int i, j;
int j;
particle_t *p;
@ -918,9 +846,8 @@ void R_ParticleExplosion2 (vec3_t org, int colorStart, int colorLength)
void R_ParticleBloodSpewism (vec3_t org, int much)
{
int i, j;
vec3_t fe;
int colorMod = 0;
int i, j;
vec3_t fe;
for (i=1; i<much; i+=2)
{
@ -1051,7 +978,7 @@ void R_RunParticleEffect (vec3_t org, vec3_t dir, int color, int count)
return; //we disable the blood!
if (particleblood > 1 && (color > 63) && (color < 80) && count != 1024){
int o, m, f, g;
int o;
vec3_t shoo, ting, tha, tway;
// Blood Spurt of some sort.
@ -1066,19 +993,18 @@ void R_RunParticleEffect (vec3_t org, vec3_t dir, int color, int count)
}
o = (particleblood * 0.3)* count;
m = o;
for (j=0 ; j<3 ; j++)
{
shoo[j] = dir[j] + (rand()%5)-2.5 * -1;
ting[j] = dir[j] + (rand()%5)-2.5;
tha[j] = dir[j] + (rand()%5)-2.5;
tway[j] = dir[j] + (rand()%5)-2.5;
}
for (j=0 ; j<3 ; j++)
{
shoo[j] = dir[j] + (rand()%5)-2.5 * -1;
ting[j] = dir[j] + (rand()%5)-2.5;
tha[j] = dir[j] + (rand()%5)-2.5;
tway[j] = dir[j] + (rand()%5)-2.5;
}
for (i=-3 ; i<o ; i+=density)
{
{
if (!free_particles)
return;
p = free_particles;
@ -1426,18 +1352,13 @@ void R_Decal (vec3_t org, int decframe, int blend, float sceel, int splat)
{
int i, j;
particle_t *p;
int nexte = 1;
int count = 1;
trace_t trace;
float bestfrac, bestorg[3], bestnormal[3];
float org2[3];
float fraccy = 0;
vec3_t heer;
vec3_t nermal;
vec3_t teer;
int besthitent = 0, hitent;
int maxdist = 9;
bestfrac = 10;
//decframe = 4;
@ -1521,33 +1442,22 @@ void R_Decal (vec3_t org, int decframe, int blend, float sceel, int splat)
}
}
void R_NormalFromHerePlease (vec3_t org, vec3_t steer)
{
int i, j;
particle_t *p;
int nexte = 1;
int count = 1;
int i;
trace_t trace;
float bestfrac, bestorg[3], bestnormal[3];
float bestfrac, bestnormal[3];
float org2[3];
float org4[3];
float fraccy = 0;
vec3_t heer;
vec3_t nermal;
vec3_t teer;
int besthitent = 0, hitent;
int maxdist = 9;
bestfrac = 10;
//decframe = 4;
org4[0] = org[0];
org4[1] = org[1];
org4[2] = org[2];
for (i = 0;i < 32;i++)
for (i = 0;i < 32;i++)
{
org2[0] = rand()%4 - rand()%2;
org2[1] = rand()%4 - rand()%2;
@ -1555,58 +1465,38 @@ void R_NormalFromHerePlease (vec3_t org, vec3_t steer)
VectorMA(org4, maxdist, org2, org2);
trace = Particle_TraceLine(org4, org2);
// take the closest trace result that doesn't end up hitting a NOMARKS
// surface (sky for example)
if (bestfrac > trace.fraction)
{
bestfrac = trace.fraction;
// besthitent = hitent;
VectorCopy(trace.endpos, bestorg);
VectorCopy(trace.plane.normal, bestnormal);
}
}
if (bestfrac < 1) // it's time to create.
if (bestfrac < 1) // it's time to create.
{
steer[0] = bestnormal[0];
steer[1] = bestnormal[1];
steer[2] = bestnormal[2];
//steer[2] *= -1;
//org[0] = bestorg[0]; // don't return orgies if we don't want them
//org[1] = bestorg[1];
//org[2] = bestorg[2];
vectoangles(steer, steer);
}
}
int R_GimmeTheColorOfThisWall (vec3_t org)
{
int i, j;
particle_t *p;
int nexte = 1;
int count = 1;
int i;
int color;
trace_t trace;
float bestfrac, bestorg[3], bestnormal[3];
float bestfrac;
float org2[3];
float fraccy = 0;
vec3_t heer;
vec3_t nermal;
vec3_t teer;
int besthitent = 0, hitent;
int maxdist = 9;
bestfrac = 10;
//decframe = 4;
for (i = 0;i < 32;i++)
for (i = 0;i < 32;i++)
{
org2[0] = rand()%4 - rand()%2;
org2[1] = rand()%4 - rand()%2;
@ -1618,8 +1508,7 @@ int R_GimmeTheColorOfThisWall (vec3_t org)
bestfrac = trace.fraction;
}
}
if (bestfrac < 1) // it's time to create.
{
color = trace.color;
@ -1632,8 +1521,6 @@ void R_FlareInstant (vec3_t org, int decframe, int colr, int colg, int colb, int
{
int i, j;
particle_t *p;
int nexte = 1;
int count = 1;
int gmcol;
@ -1697,13 +1584,10 @@ void R_FlareTest (vec3_t org, int decframe, int colr, int colg, int colb, float
{
int i, j;
flare_t *p;
int nexte = 1;
int count = 1;
int gmcol;
int ownin;
int gonnadie = 0;
float initialalpha;
trace_t tarce;
if (!r_flares->value)
return; // don't draw flares if we don't want flares.
@ -2672,7 +2556,6 @@ void R_ParticleTrail2 (vec3_t start, vec3_t end, int type, int blend, int color,
int j;
particle_t *p;
int dec;
static int tracercount;
int thetrail;
thetrail = r_particletrails->value;
@ -2730,14 +2613,9 @@ void R_ParticleBeam (vec3_t start, vec3_t end, int thecol)
{
vec3_t vec;
float len;
int j;
int j;
particle_t *p;
int dec;
static int tracercount;
int wat;
//int thecol;
int dec;
VectorSubtract (end, start, vec);
len = VectorNormalize (vec);
@ -2752,37 +2630,19 @@ void R_ParticleBeam (vec3_t start, vec3_t end, int thecol)
p = free_particles;
free_particles = p->next;
p->next = active_particles;
// p->owner = NULL;
active_particles = p;
p->frame = 0;
VectorCopy (vec3_origin, p->vel);
p->die = cl.time;
// wat = rand()&2;
{
/* if (wat == 2){ // Outer Glow
p->polor = thecol;
p->type = pt_staticfadeadd;
p->die = cl.time + 2;
p->alpha = 0.6;
p->alphavel = -0.7;
for (j=0 ; j<3 ; j++)
p->org[j] = start[j] + ((rand()%4)-2);
}
else */
{ // Inner Line
p->polor = thecol;
p->type = pt_staticfadeadd;
p->die = cl.time + 0.01;
p->alpha = 1;
p->alphavel = -0.9;
for (j=0 ; j<3 ; j++)
p->org[j] = start[j];
}
}
p->polor = thecol;
p->type = pt_staticfadeadd;
p->die = cl.time + 0.01;
p->alpha = 1;
p->alphavel = -0.9;
for (j=0 ; j<3 ; j++)
p->org[j] = start[j];
VectorAdd (start, vec, start);
}
}
@ -2793,11 +2653,9 @@ void R_BeamBeam (vec3_t start, vec3_t end, int thecol, float thesize)
{
vec3_t vec;
float len;
int j;
int j;
particle_t *p;
int dec;
static int tracercount;
//int thecol;
int dec;
vec3_t angel;
@ -2828,22 +2686,17 @@ void R_BeamBeam (vec3_t start, vec3_t end, int thecol, float thesize)
p->angles[0] = angel[0] + 90;
p->angles[1] = angel[1];
p->angles[2] = angel[2];
//p->angles[0] = 0;
//p->angles[1] = 0;
//p->angles[2] = 0;
p->scale = 0.03f;
{
p->polor = thecol;
p->type = pt_staticfadeadd;
p->die = cl.time + 0.01;
p->alpha = 1;
p->alphavel = -0.9;
for (j=0 ; j<3 ; j++)
p->org[j] = start[j];
}
p->polor = thecol;
p->type = pt_staticfadeadd;
p->die = cl.time + 0.01;
p->alpha = 1;
p->alphavel = -0.9;
for (j=0 ; j<3 ; j++)
p->org[j] = start[j];
VectorAdd (start, vec, start);
}
@ -3140,22 +2993,10 @@ void R_DrawParticles (void)
vec3_t below;
qboolean in_solid;
#ifdef GLQUAKE
vec3_t up, right;
float scale;
GL_Bind(particletexture);
glEnable (GL_BLEND);
glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
glBegin (GL_TRIANGLES);
VectorScale (vup, 8.5, up);
VectorScale (vright, 8.5, right);
#else
VectorScale (vright, xscaleshrink, r_pright);
VectorScale (vup, yscaleshrink, r_pup);
VectorCopy (vpn, r_ppn);
#endif
frametime = cl.time - cl.oldtime;
time3 = frametime * 15;
time2 = frametime * 10; // 15;
@ -3193,46 +3034,12 @@ void R_DrawParticles (void)
}
break;
}
/* if (particletypeonly == 1 && p->sprtype == 5)
{
model_t *hello;
if ((p->model = Mod_ForName("particle.spr", false)))
{
currentparticle = p;
VectorCopy(p->org, r_entorigin);
VectorSubtract(r_origin, r_entorigin, modelorg);
R_DrawSprite2();
return;
}
}*/
#ifdef GLQUAKE
// hack a scale up to keep particles from disapearing
scale = (p->org[0] - r_origin[0])*vpn[0] + (p->org[1] - r_origin[1])*vpn[1]
+ (p->org[2] - r_origin[2])*vpn[2];
if (scale < 20)
scale = 1;
else
scale = 1 + scale * 0.004;
glColor3ubv ((byte *)&d_8to24table[(int)p->polor]);
glTexCoord2f (0,0);
glVertex3fv (p->org);
glTexCoord2f (1,0);
glVertex3f (p->org[0] + up[0]*scale, p->org[1] + up[1]*scale, p->org[2] + up[2]*scale);
glTexCoord2f (0,1);
glVertex3f (p->org[0] + right[0]*scale, p->org[1] + right[1]*scale, p->org[2] + right[2]*scale);
#else
if (p->blend == 5)
p->blend = 1;
if (p->sprtype == 5)
p->sprtype = 4;
// if (p->stickable == 2){
// VectorCopy(p->vstuck1, p->org);
//
// }
if (particleset == 1){
p->frame = 3; // glquake style particle hack
p->anglevel[2] = 0;
@ -3249,106 +3056,7 @@ void R_DrawParticles (void)
// COLOR PRECALCULATE
/*
// LIT PARTICLES
if (p->lit){
int la, ra, ga, ba;
float lightvec[3];
float rlightvec[3];
float glightvec[3];
float blightvec[3];
float rlightvec2[3];
float glightvec2[3];
float blightvec2[3];
vec3_t dist;
float add;
float radd;
float gadd;
float badd;
int lnum;
dlight_t *dl;
vec3_t t;
vec3_t ar;
vec3_t ag;
vec3_t ab;
la = R_LightPoint(p->org);
// add dynamic lights
for (lnum=0 ; lnum<MAX_DLIGHTS ; lnum++)
{
dl = &cl_dlights[lnum];
if (!dl->radius)
continue;
if (dl->die < cl.time)
continue;
if (dl->unmark) // leilei - skip world light
continue;
VectorSubtract (p->org, dl->origin, dist);
add = dl->radius - Length(dist);
radd = dl->radius * dl->color[0] - Length(dist) ;
gadd = dl->radius * dl->color[1] - Length(dist) ;
badd = dl->radius * dl->color[2] - Length(dist) ;
if (add > 0)
{
float scale = 1.0-(Length(dist)/dl->radius);
scale *= scale; // scale ^ 2
la += add*(scale);
ra += radd*(scale);
ga += gadd*(scale);
ba += badd*(scale);
}
if (radd > 0)
{
float scale = 1.0-(Length(dist)/dl->radius);
scale *= scale; // scale ^ 2
ra += radd*(scale);
VectorScale (dist, scale, dist);
}
if (gadd > 0)
{
float scale = 1.0-(Length(dist)/dl->radius);
scale *= scale; // scale ^ 2
ga += gadd*(scale);
VectorScale (dist, scale, dist);
}
if (badd > 0)
{
float scale = 1.0-(Length(dist)/dl->radius);
scale *= scale; // scale ^ 2
ba += badd*(scale);
VectorScale (dist, scale, dist);
}
}
la *= -64; la += 16300;
if (la < 0) la = 0;
polor = ((byte *)host_colormap)[p->polor + (la & 0xFF00)];
}
else
*/
polor = p->polor;
// FOGGED PARTICLES
if (foguse){
@ -3398,14 +3106,13 @@ else
}
#endif// PARTICLE COLLISION CODE FROM HEXEN II! (It used to be for snow now it's for everything!)
// BEIGN
// leilei - particle sprites
if (p->frame && r_particlesprite->value && !particletypeonly)
{
model_t *hello;
if ((p->model = Mod_ForName("particle.spr", false)))
{
currentparticle = p;
@ -3513,19 +3220,6 @@ else
p->scaleyvel = 0.0f;
if (p->scale > 3)
p->die = -1; // leilei - too much blood...
// does this actually work???
{
trace_t trace;
vec3_t nah;
vec3_t there;
VectorAdd(p->org, p->vel, there);
VectorAdd(p->org, p->vel, there);
VectorAdd(p->org, p->vel, there);
VectorAdd(p->org, p->vel, there);
VectorAdd(p->org, p->vel, there);
}
whare[0] = p->org[0]; whare[1] = p->org[1];
whare[2] = p->org[2] - 6;
@ -4229,16 +3923,9 @@ void R_TestFlares (void)
int liftoff;
int amiseen;
#ifndef GLQUAKE
VectorScale (vright, xscaleshrink, r_pright);
VectorScale (vup, yscaleshrink, r_pup);
VectorCopy (vpn, r_ppn);
#else
// VectorScale (vright, xscale, r_pright);
// VectorScale (vup, yscale, r_pup);
// VectorCopy (vpn, r_ppn);
#endif
for ( ;; )
{

8
video/vid_gdk.c
View file

@ -50,7 +50,7 @@ static float mouse_x, mouse_y;
static float old_mouse_x, old_mouse_y;
static qboolean mouse_enabled;
cvar_t *m_filter;
extern int deathcam_yesiamdead;
extern int deathcam_active;
extern vec3_t deathcam_angles;
GtkWidget *x_win;
@ -556,7 +556,7 @@ void IN_Move (usercmd_t *cmd)
mouse_y *= sensitivity->value;
}
if (deathcam_yesiamdead)
if (deathcam_active)
{
tangles[0] = deathcam_angles[0];
tangles[1] = deathcam_angles[1];
@ -580,7 +580,7 @@ void IN_Move (usercmd_t *cmd)
if ( ((in_mlook.state & 1) ^ ((int)m_look->value & 1)) && !(in_strafe.state & 1))
{
tangles[PITCH] += m_pitch->value * mouse_y;
if (!deathcam_yesiamdead)
if (!deathcam_active)
{
if (tangles[PITCH] > m_lockdown->value)
tangles[PITCH] = m_lockdown->value;
@ -597,7 +597,7 @@ void IN_Move (usercmd_t *cmd)
}
if (deathcam_yesiamdead)
if (deathcam_active)
{
deathcam_angles[0] = tangles[0];
deathcam_angles[1] = tangles[1];

8
video/vid_x11.c
View file

@ -57,7 +57,7 @@ int p_mouse_x;
int p_mouse_y;
int ignorenext;
int bits_per_pixel;
extern int deathcam_yesiamdead; // eukara - deathcam
extern int deathcam_active; // eukara - deathcam
typedef struct
{
@ -1271,7 +1271,7 @@ void IN_Move (usercmd_t *cmd)
mouse_x *= sensitivity->value;
mouse_y *= sensitivity->value;
if (deathcam_yesiamdead){
if (deathcam_active){
tangles[0] = deathcam_angles[0]; tangles[1] = deathcam_angles[1]; tangles[2] = deathcam_angles[2];
}
else{
@ -1287,7 +1287,7 @@ void IN_Move (usercmd_t *cmd)
if ( ((in_mlook.state & 1) ^ ((int)m_look->value & 1)) && !(in_strafe.state & 1)) { // 2001-12-16 M_LOOK cvar by Heffo/Maddes
tangles[PITCH] += m_pitch->value * mouse_y;
if (!deathcam_yesiamdead){
if (!deathcam_active){
if (tangles[PITCH] > m_lockdown->value) // eukara - was cl.viewangles, not tangles
tangles[PITCH] = m_lockdown->value; // ditto for the next few lines
if (tangles[PITCH] < m_lockup->value)
@ -1300,7 +1300,7 @@ void IN_Move (usercmd_t *cmd)
}
if (deathcam_yesiamdead){
if (deathcam_active){
deathcam_angles[0] = tangles[0]; deathcam_angles[1] = tangles[1]; deathcam_angles[2] = tangles[2];
}
else{