qf/quakeforge
0
0
Fork 0
mirror of https://git.code.sf.net/p/quake/quakeforge synced 2025-04-02 23:41:28 +00:00
Code Issues Projects Releases Packages Wiki Activity

FIXME cleanup and a missed win32 compile fix

Browse source 
This is an imperfect revision of history.
This commit is contained in:
Bill Currie 2004-11-06 02:21:00 +00:00 committed by Jeff Teunissen
parent 0bfac8dd88
commit 201252c1c0
13 changed files with 21 additions and 2620 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
libs/audio/cd.c
View file

@ -121,5 +121,5 @@ CDAudio_Init (void)
"play (track number) - Plays the specified track one time.\n"
"stop - Stops the currently playing track.");
Sys_Printf ("CD Audio Initialized\n");
return 0; // FIXME: Assumes success
return 0;
}

1
libs/audio/cd/cd_sgi.c
View file

@ -2,7 +2,6 @@
cd_sgi.c
audio cd playback support for sgi irix machines
FIXME: Update for plugin API
Copyright (C) 1996-1997 Id Software, Inc.

4
libs/audio/cd/cd_win.c
View file

@ -50,8 +50,6 @@ static general_data_t plugin_info_general_data;
static general_funcs_t plugin_info_general_funcs;
static cd_funcs_t plugin_info_cd_funcs;
extern HWND mainwindow; //FIXME
static qboolean cdValid = false;
static qboolean playing = false;
static qboolean wasPlaying = false;
@ -208,7 +206,7 @@ I_CDAudio_Play (int track, qboolean looping)
return;
}
if (track < 0 || track >= sizeof (remap)) {
if (track < 0 || track >= (int) sizeof (remap)) {
Sys_Printf ("CDAudio: invalid track number\n");
return;
}

2
libs/audio/renderer/midi.c
View file

@ -91,7 +91,6 @@ get_info (void * handle) {
static int
midi_stream_read (void *file, byte *buf, int count, wavinfo_t *info)
{
// FIXME: need to check what the return of this function /should/ be
return WildMidi_GetOutput (file, (char *)buf, (unsigned long int)count);
}
@ -103,7 +102,6 @@ midi_stream_seek (void *file, int pos, wavinfo_t *info)
pos += info->dataofs;
new_pos = pos;
// FIXME: need to check what the return of this function /should/ be
return WildMidi_SampledSeek(file, &new_pos);
}

285
libs/audio/renderer/snd_mixa.S
View file

@ -1,285 +0,0 @@
/*
snd_mixa.S
x86 assembly-language sound code
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:
Free Software Foundation, Inc.
59 Temple Place - Suite 330
Boston, MA 02111-1307, USA
$Id$
*/
#ifdef HAVE_CONFIG_H
# include <config.h>
#endif
#include "asm_i386.h"
// #include "quakeasm.h"
#ifdef USE_INTEL_ASM
#ifdef _WIN32
# undef PIC //no such thing in win32
#endif
.text
.extern C(snd_scaletable)
.extern C(paintbuffer)
.extern C(snd_linear_count)
.extern C(snd_p)
.extern C(snd_vol)
.extern C(snd_out)
//----------------------------------------------------------------------
// 8-bit sound-mixing code
//----------------------------------------------------------------------
#define ch 4+16
#define sc 8+16
#define count 12+16
.globl C(NOT_SND_PaintChannelFrom8)
#ifdef PIC
.type C(NOT_SND_PaintChannelFrom8),@function
#endif
C(NOT_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
addl %ecx,%esi
shll $7,%edx
movl %edi,ch_pos(%ebx)
#ifdef PIC
call .Lpic1
.Lpic1: popl %ebx
addl $C(_GLOBAL_OFFSET_TABLE_)+[.-.Lpic1],%ebx
movl C(snd_scaletable)@GOT(%ebx,%eax),%eax
movl C(snd_scaletable)@GOT(%ebx,%edx),%edx
movl C(paintbuffer)@GOT(%ebx),%ebx
#else
leal C(snd_scaletable)(%eax),%eax
leal C(snd_scaletable)(%edx),%edx
leal C(paintbuffer),%ebx
#endif
pushl %ebx // save paintbuffer offset
testl $1,%ecx
leal 0(%ebx,%ecx,psp_size),%ecx
movl $0,%ebx
movb -1(%esi),%bl
jz LMix8Loop
movl (%eax,%ebx,4),%edi
movl (%edx,%ebx,4),%ebp
addl psp_left-psp_size(%ecx),%edi
addl psp_right-psp_size(%ecx),%ebp
movl %edi,psp_left-psp_size(%ecx)
movl %ebp,psp_right-psp_size(%ecx)
movb -2(%esi),%bl
subl $psp_size,%ecx
decl %esi
cmpl (%esp),%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 psp_left-psp_size(%ecx),%edi
addl psp_right-psp_size(%ecx),%ebp
movb -2(%esi),%bl
movl %edi,psp_left-psp_size(%ecx)
movl %ebp,psp_right-psp_size(%ecx)
movl (%eax,%ebx,4),%edi
movl (%edx,%ebx,4),%ebp
movb -3(%esi),%bl
addl psp_left-psp_size*2(%ecx),%edi
addl psp_right-psp_size*2(%ecx),%ebp
movl %edi,psp_left-psp_size*2(%ecx)
movl %ebp,psp_right-psp_size*2(%ecx)
// }
subl $2*psp_size,%ecx
subl $2,%esi
cmpl (%esp),%ecx
jnz LMix8Loop
LDone:
addl $4,%esp // remove paintbuffer offset
popl %ebp
popl %ebx
popl %edi
popl %esi
ret
#ifdef PIC
.Lfe1:
.size C(NOT_SND_PaintChannelFrom8),.Lfe1-C(NOT_SND_PaintChannelFrom8)
#endif
//----------------------------------------------------------------------
// Transfer of stereo buffer to 16-bit DMA buffer code
//----------------------------------------------------------------------
.globl C(SND_WriteLinearBlastStereo16)
#ifdef PIC
.type C(SND_WriteLinearBlastStereo16),@function
#endif
C(SND_WriteLinearBlastStereo16):
pushl %esi // preserve register variables
pushl %edi
pushl %ebx
#ifdef PIC
call .Lpic2
.Lpic2:
popl %ebx
addl $C(_GLOBAL_OFFSET_TABLE_)+[.-.Lpic2],%ebx
#endif
// int i;
// int val;
#ifdef PIC
movl C(snd_linear_count)@GOTOFF(%ebx),%ecx
movl C(snd_vol)@GOTOFF(%ebx),%esi
movl C(snd_out)@GOTOFF(%ebx),%edi
movl C(snd_p)@GOTOFF(%ebx),%ebx
#else
movl C(snd_linear_count),%ecx
movl C(snd_vol),%esi
movl C(snd_out),%edi
movl C(snd_p),%ebx
#endif
// 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
#ifdef PIC
.Lfe2:
.size C(SND_WriteLinearBlastStereo16),.Lfe2-C(SND_WriteLinearBlastStereo16)
#endif
#endif // USE_INTEL_ASM

327
libs/audio/targets/snd_mme.c
View file

@ -1,327 +0,0 @@
/*
snd_mme.c
(description)
Copyright (C) 1996-1997 Id Software, Inc.
Copyright (C) 1999-2000 Marcus Sundberg [mackan@stacken.kth.se]
Copyright (C) 1999,2000 contributors of the QuakeForge project
Please see the file "AUTHORS" for a list of contributors
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:
Free Software Foundation, Inc.
59 Temple Place - Suite 330
Boston, MA 02111-1307, USA
*/
#ifdef HAVE_CONFIG_H
# include "config.h"
#endif
static __attribute__ ((unused)) const char rcsid[] =
"$Id$";
#include <mme/mmsystem.h>
#ifdef HAVE_MME_MME_PUBLIC_H
# include <mme/mme_public.h>
#endif
#include "sound.h"
#include "QF/sys.h"
// 64K is > 1 second at 16-bit, 11025 Hz
#define WAV_BUFFERS 64
#define WAV_MASK 0x3F
#define WAV_BUFFER_SIZE 0x0400
static qboolean wav_init;
static qboolean snd_firsttime = true, snd_iswave;
static int sample16;
static int snd_sent, snd_completed;
static int snd_blocked = 0;
static HPSTR lpData;
static LPWAVEHDR lpWaveHdr;
static HWAVEOUT hWaveOut;
static DWORD gSndBufSize;
static volatile dma_t sn;
/* MME Callback function */
static void
mme_callback ( HANDLE h, UINT wMsg, DWORD instance, LPARAM p1, LPARAM p2 )
{
if (wMsg == WOM_DONE) {
snd_completed++;
}
}
static void
S_BlockSound ( void )
{
if (++snd_blocked == 1)
waveOutReset(hWaveOut);
}
static void
S_UnblockSound ( void )
{
if (!snd_blocked)
return;
snd_blocked--;
}
static void
FreeSound ( void )
{
// only release primary buffer if it's not also the mixing buffer we just released
if (hWaveOut) {
waveOutReset (hWaveOut);
waveOutClose (hWaveOut);
if (lpWaveHdr) {
mmeFreeMem(lpWaveHdr);
}
if (lpData) {
mmeFreeBuffer(lpData);
}
}
hWaveOut = 0;
lpWaveHdr = 0;
lpData = NULL;
lpWaveHdr = NULL;
wav_init = false;
}
/*
SNDDM_InitWav
Crappy windows multimedia base
*/
static qboolean
SNDDMA_InitWav ( void )
{
int hr, i;
LPPCMWAVEFORMAT format;
if ((format = (LPPCMWAVEFORMAT)
mmeAllocMem(sizeof(*format))) == NULL) {
Sys_Printf("Failed to allocate PCMWAVEFORMAT struct\n");
return false;
}
snd_sent = 0;
snd_completed = 0;
sn.channels = 2;
sn.samplebits = 16;
sn.speed = 11025;
memset(format, 0, sizeof(*format));
format->wf.wFormatTag = WAVE_FORMAT_PCM;
format->wf.nChannels = sn.channels;
format->wBitsPerSample = sn.samplebits;
format->wf.nSamplesPerSec = sn.speed;
format->wf.nBlockAlign = format->wf.nChannels
*format->wBitsPerSample / 8;
format->wf.nAvgBytesPerSec = format->wf.nSamplesPerSec
*format->wf.nBlockAlign;
/* Open a waveform device for output using our callback function. */
while ((hr = waveOutOpen((LPHWAVEOUT)&hWaveOut, WAVE_MAPPER,
(LPWAVEFORMAT)format,
(void (*)())mme_callback, 0,
CALLBACK_FUNCTION | WAVE_OPEN_SHAREABLE))
!= MMSYSERR_NOERROR)
{
if (hr != MMSYSERR_ALLOCATED) {
mmeFreeMem(format);
Sys_Printf ("waveOutOpen failed: %d\n", hr);
return false;
} else {
Sys_Printf ("waveOutOpen failed 2222\n");
}
}
mmeFreeMem(format);
/*
Allocate and lock memory for the waveform data. The memory
for waveform data must be globally allocated with
GMEM_MOVEABLE and GMEM_SHARE flags.
*/
gSndBufSize = WAV_BUFFERS*WAV_BUFFER_SIZE;
lpData = mmeAllocBuffer(gSndBufSize);
if (!lpData) {
Sys_Printf ("Sound: Out of memory.\n");
FreeSound ();
return false;
}
memset (lpData, 0, gSndBufSize);
/*
Allocate and lock memory for the header. This memory must
also be globally allocated with GMEM_MOVEABLE and
GMEM_SHARE flags.
*/
lpWaveHdr = mmeAllocMem(sizeof(WAVEHDR) * WAV_BUFFERS);
if (lpWaveHdr == NULL)
{
Sys_Printf ("Sound: Failed to Alloc header.\n");
FreeSound ();
return false;
}
memset (lpWaveHdr, 0, sizeof(WAVEHDR) * WAV_BUFFERS);
/* After allocation, set up and prepare headers. */
for (i=0 ; i<WAV_BUFFERS ; i++) {
lpWaveHdr[i].dwBufferLength = WAV_BUFFER_SIZE;
lpWaveHdr[i].lpData = lpData + i*WAV_BUFFER_SIZE;
}
sn.soundalive = true;
sn.splitbuffer = false;
sn.samples = gSndBufSize/(sn.samplebits/8);
sn.samplepos = 0;
sn.submission_chunk = 1;
sn.buffer = (unsigned char *) lpData;
sample16 = (sn.samplebits/8) - 1;
wav_init = true;
return true;
}
/*
SNDDMA_Init
Try to find a sound device to mix for.
Returns false if nothing is found.
*/
static volatile dma_t *
SNDDMA_Init ( void )
{
wav_init = 0;
if (snd_firsttime || snd_iswave) {
snd_iswave = SNDDMA_InitWav ();
if (snd_iswave) {
if (snd_firsttime)
Sys_Printf ("Wave sound initialized\n");
} else {
Sys_Printf ("Wave sound failed to init\n");
}
}
snd_firsttime = false;
if (!wav_init) {
if (snd_firsttime)
Sys_Printf ("No sound device initialized\n");
return 0;
}
return &sn;
}
/*
SNDDMA_GetDMAPos
return the current sample position (in mono samples read)
inside the recirculating dma buffer, so the mixing code will know
how many sample are required to fill it up.
*/
static int
SNDDMA_GetDMAPos ( void )
{
int s = 0;
if (wav_init) {
s = snd_sent * WAV_BUFFER_SIZE;
}
s >>= sample16;
s &= (sn.samples-1);
return s;
}
/*
SNDDMA_Submit
Send sound to device if buffer isn't really the dma buffer
*/
static void
SNDDMA_Submit ( void )
{
int wResult;
LPWAVEHDR h;
if (!wav_init) return;
if (mmeCheckForCallbacks()) mmeProcessCallbacks();
if (snd_completed == snd_sent) {
Sys_DPrintf ("Sound overrun\n");
}
// submit two new sound blocks
while (((snd_sent - snd_completed) >> sample16) < 4)
{
int i = (snd_sent&WAV_MASK);
h = lpWaveHdr + i;
h->dwBufferLength = WAV_BUFFER_SIZE;
h->lpData = lpData + i*WAV_BUFFER_SIZE;
snd_sent++;
/*
Now the data block can be sent to the output device. The
waveOutWrite function returns immediately and waveform
data is sent to the output device in the background.
*/
wResult = waveOutWrite(hWaveOut, h, sizeof(WAVEHDR));
if (wResult != MMSYSERR_NOERROR)
{
Sys_Printf ("Failed to write block to device\n");
FreeSound ();
return;
}
}
}
/*
SNDDMA_Shutdown
Reset the sound device for exiting
*/
static void
SNDDMA_Shutdown ( void )
{
FreeSound ();
}

1
libs/gamecode/builtins/pr_cmds.c
View file

@ -52,7 +52,6 @@ static __attribute__ ((unused)) const char rcsid[] =
#include "compat.h"
//FIXME lines to #undef U really shouldn't be here
#include "QF/csqc.h"
#define U __attribute__ ((unused))
static U void (*const gib_progs_init)(progs_t *) = GIB_Progs_Init;

10
libs/image/png.c
View file

@ -67,6 +67,13 @@ user_write_data (png_structp png_ptr, png_bytep data, png_size_t length)
Qwrite ((QFile *) png_get_io_ptr (png_ptr), data, length);
}
/* Qflush wrapper for libpng */
static void
user_flush_data (png_structp png_ptr)
{
Qflush ((QFile *) png_get_io_ptr (png_ptr));
}
/* Basicly taken from the libpng example rpng-x */
static int
readpng_init (QFile *infile, png_structp *png_ptr, png_infop *info_ptr)
@ -223,8 +230,7 @@ WritePNG (const char *fileName, byte *data, int width, int height)
return; /* Can't open file */
}
/* FIXME: NULL should be a QF equiv to fflush? */
png_set_write_fn (png_ptr, outfile, user_write_data, NULL);
png_set_write_fn (png_ptr, outfile, user_write_data, user_flush_data);
/* Write the header */
if (setjmp(png_jmpbuf(png_ptr))) {

19
nq/source/sv_main.c
View file

@ -35,6 +35,7 @@ static __attribute__ ((unused)) const char rcsid[] =
#include "QF/cmd.h"
#include "QF/cvar.h"
#include "QF/msg.h"
#include "QF/mathlib.h"
#include "QF/sys.h"
#include "QF/va.h"
@ -121,7 +122,8 @@ void
SV_StartSound (edict_t *entity, int channel, const char *sample, int volume,
float attenuation)
{
int ent, field_mask, sound_num, i;
int ent, field_mask, sound_num;
vec3_t v;
if (volume < 0 || volume > 255)
Sys_Error ("SV_StartSound: volume = %i", volume);
@ -165,10 +167,9 @@ SV_StartSound (edict_t *entity, int channel, const char *sample, int volume,
MSG_WriteByte (&sv.datagram, attenuation * 64);
MSG_WriteShort (&sv.datagram, channel);
MSG_WriteByte (&sv.datagram, sound_num);
for (i=0; i < 3; i++) // FIXME: replace with MSG_WriteCoordV?
MSG_WriteCoord (&sv.datagram, SVvector (entity, origin)[i] + 0.5 *
(SVvector (entity, mins)[i] +
SVvector (entity, maxs)[i]));
VectorBlend (SVvector (entity, mins), SVvector (entity, maxs), 0.5, v);
VectorAdd (v, SVvector (entity, origin), v);
MSG_WriteCoordV (&sv.datagram, v);
}
// CLIENT SPAWNING ============================================================
@ -509,6 +510,7 @@ void
SV_WriteClientdataToMessage (edict_t *ent, sizebuf_t *msg)
{
int bits, items, i;
vec3_t v;
edict_t *other;
// send a damage message
@ -517,10 +519,9 @@ SV_WriteClientdataToMessage (edict_t *ent, sizebuf_t *msg)
MSG_WriteByte (msg, svc_damage);
MSG_WriteByte (msg, SVfloat (ent, dmg_save));
MSG_WriteByte (msg, SVfloat (ent, dmg_take));
for (i=0; i < 3; i++) // FIXME: replace with MSG_WriteCoordV
MSG_WriteCoord (msg, SVvector (other, origin)[i] + 0.5 *
(SVvector (other, mins)[i] +
SVvector (other, maxs)[i]));
VectorBlend (SVvector (other, mins), SVvector (other, maxs), 0.5, v);
VectorAdd (v, SVvector (other, origin), v);
MSG_WriteCoordV (msg, v);
SVfloat (ent, dmg_take) = 0;
SVfloat (ent, dmg_save) = 0;
}

469
qw/include/net_svc.h
View file

@ -1,469 +0,0 @@
/*
net_svc.h
(description)
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:
Free Software Foundation, Inc.
59 Temple Place - Suite 330
Boston, MA 02111-1307, USA
$Id$
*/
#ifndef NET_SVC_H
#define NET_SVC_H
#include "QF/mathlib.h"
#include "QF/msg.h"
#include "bothdefs.h"
#include "pmove.h"
typedef enum
{
NET_OK,
NET_SHORT,
NET_ERROR
} net_status_t;
typedef struct net_svc_nop_s
{
} net_svc_nop_t;
typedef struct net_svc_disconnect_s
{
} net_svc_disconnect_t;
typedef struct net_svc_print_s
{
byte level;
const char *message;
} net_svc_print_t;
typedef struct net_svc_centerprint_s
{
const char *message;
} net_svc_centerprint_t;
typedef struct net_svc_stufftext_s
{
const char *commands;
} net_svc_stufftext_t;
typedef struct net_svc_damage_s
{
byte armor;
byte blood;
vec3_t from;
} net_svc_damage_t;
typedef struct net_svc_serverdata_s
{
int protocolversion;
int servercount; // FIXME: rename this
const char *gamedir;
byte playernum;
qboolean spectator;
const char *levelname;
movevars_t movevars;
} net_svc_serverdata_t;
typedef struct net_svc_setangle_s
{
vec3_t angles;
} net_svc_setangle_t;
typedef struct net_svc_lightstyle_s
{
byte stylenum;
const char *map;
} net_svc_lightstyle_t;
typedef struct net_svc_sound_s
{
short channel;
float volume;
float attenuation;
byte sound_num;
vec3_t position;
int entity;
} net_svc_sound_t;
typedef struct net_svc_stopsound_s
{
int entity;
int channel;
} net_svc_stopsound_t;
typedef struct net_svc_updatefrags_s
{
byte player;
short frags;
} net_svc_updatefrags_t;
typedef struct net_svc_updateping_s
{
byte player;
short ping;
} net_svc_updateping_t;
typedef struct net_svc_updatepl_s
{
byte player;
byte packetloss;
} net_svc_updatepl_t;
typedef struct net_svc_updateentertime_s
{
byte player;
float secondsago;
} net_svc_updateentertime_t;
typedef struct net_svc_spawnbaseline_s
{
short num;
byte modelindex;
byte frame;
byte colormap;
byte skinnum;
vec3_t origin;
vec3_t angles;
} net_svc_spawnbaseline_t;
typedef struct net_svc_spawnstatic_s
{
byte modelindex;
byte frame;
byte colormap;
byte skinnum;
vec3_t origin;
vec3_t angles;
} net_svc_spawnstatic_t;
typedef struct net_svc_tempentity_s
{
byte type;
vec3_t position;
byte gunshotcount; // gunshot sparks
byte colorstart; // palette start (I think?)
byte colorlength; // palette length
vec3_t beamend; // beam endpos
short beamentity; // beam entity
} net_svc_tempentity_t;
typedef struct net_svc_killedmonster_s
{
} net_svc_killedmonster_t;
typedef struct net_svc_foundsecret_s
{
} net_svc_foundsecret_t;
typedef struct net_svc_spawnstaticsound_s
{
vec3_t position;
byte sound_num;
byte volume;
byte attenuation; // FIXME: should be a float (convert usages)
} net_svc_spawnstaticsound_t;
typedef struct net_svc_updatestat_s
{
byte stat;
byte value;
} net_svc_updatestat_t;
typedef struct net_svc_updatestatlong_s
{
byte stat;
int value;
} net_svc_updatestatlong_t;
typedef struct net_svc_cdtrack_s
{
byte cdtrack;
} net_svc_cdtrack_t;
typedef struct net_svc_intermission_s
{
vec3_t origin;
vec3_t angles;
} net_svc_intermission_t;
typedef struct net_svc_finale_s
{
const char *message;
} net_svc_finale_t;
typedef struct net_svc_sellscreen_s
{
} net_svc_sellscreen_t;
typedef struct net_svc_smallkick_s
{
} net_svc_smallkick_t;
typedef struct net_svc_bigkick_s
{
} net_svc_bigkick_t;
typedef struct net_svc_muzzleflash_s
{
short player;
} net_svc_muzzleflash_t;
typedef struct net_svc_updateuserinfo_s
{
byte slot;
int userid;
const char *userinfo;
} net_svc_updateuserinfo_t;
typedef struct net_svc_setinfo_s
{
byte slot;
const char *key;
const char *value;
} net_svc_setinfo_t;
typedef struct net_svc_serverinfo_s
{
const char *key;
const char *value;
} net_svc_serverinfo_t;
typedef struct net_svc_download_s
{
short size;
byte percent;
const char *name; // only one of name or data will be set
const byte *data;
} net_svc_download_t;
typedef struct net_svc_playerinfo_s
{
byte playernum;
int flags;
vec3_t origin;
byte frame;
byte msec;
usercmd_t usercmd;
vec3_t velocity;
byte modelindex;
byte skinnum;
byte effects;
byte weaponframe;
} net_svc_playerinfo_t;
typedef struct net_svc_nails_s
{
byte numnails;
struct {
vec3_t origin;
vec3_t angles;
} nails[MAX_PROJECTILES];
} net_svc_nails_t;
typedef struct net_svc_chokecount_s
{
byte count;
} net_svc_chokecount_t;
typedef struct net_svc_modellist_s
{
byte startmodel;
const char *models[MAX_MODELS + 1]; // space left for terminating
// empty string
byte nextmodel;
} net_svc_modellist_t;
typedef struct net_svc_soundlist_s
{
byte startsound;
const char *sounds[MAX_SOUNDS + 1]; // space left for terminating
// empty string
byte nextsound;
} net_svc_soundlist_t;
typedef struct net_svc_packetentities_s
{
int numwords, numdeltas;
unsigned int words[MAX_PACKET_ENTITIES * 2 + 1];
entity_state_t deltas[MAX_PACKET_ENTITIES];
} net_svc_packetentities_t;
typedef struct net_svc_deltapacketentities_s
{
int numwords, numdeltas;
byte from;
unsigned int words[MAX_PACKET_ENTITIES * 2 + 1];
entity_state_t deltas[MAX_PACKET_ENTITIES];
} net_svc_deltapacketentities_t;
typedef struct net_svc_maxspeed_s
{
float maxspeed;
} net_svc_maxspeed_t;
typedef struct net_svc_entgravity_s
{
float gravity;
} net_svc_entgravity_t;
typedef struct net_svc_setpause_s
{
byte paused;
} net_svc_setpause_t;
const char *NET_SVC_GetString (int type);
net_status_t NET_SVC_NOP_Emit (net_svc_nop_t *block, sizebuf_t *buf);
net_status_t NET_SVC_NOP_Parse (net_svc_nop_t *block, qmsg_t *msg);
net_status_t NET_SVC_Disconnect_Emit (net_svc_disconnect_t *block,
sizebuf_t *buf);
net_status_t NET_SVC_Disconnect_Parse (net_svc_disconnect_t *block, qmsg_t *msg);
net_status_t NET_SVC_Print_Emit (net_svc_print_t *block, sizebuf_t *buf);
net_status_t NET_SVC_Print_Parse (net_svc_print_t *block, qmsg_t *msg);
net_status_t NET_SVC_Centerprint_Emit (net_svc_centerprint_t *block,
sizebuf_t *buf);
net_status_t NET_SVC_Centerprint_Parse (net_svc_centerprint_t *block,
qmsg_t *msg);
net_status_t NET_SVC_Stufftext_Emit (net_svc_stufftext_t *block,
sizebuf_t *buf);
net_status_t NET_SVC_Stufftext_Parse (net_svc_stufftext_t *block, qmsg_t *msg);
net_status_t NET_SVC_Damage_Emit (net_svc_damage_t *block, sizebuf_t *buf);
net_status_t NET_SVC_Damage_Parse (net_svc_damage_t *block, qmsg_t *msg);
net_status_t NET_SVC_ServerData_Emit (net_svc_serverdata_t *block,
sizebuf_t *buf);
net_status_t NET_SVC_ServerData_Parse (net_svc_serverdata_t *block, qmsg_t *msg);
net_status_t NET_SVC_SetAngle_Emit (net_svc_setangle_t *block, sizebuf_t *buf);
net_status_t NET_SVC_SetAngle_Parse (net_svc_setangle_t *block, qmsg_t *msg);
net_status_t NET_SVC_LightStyle_Emit (net_svc_lightstyle_t *block,
sizebuf_t *buf);
net_status_t NET_SVC_LightStyle_Parse (net_svc_lightstyle_t *block, qmsg_t *msg);
net_status_t NET_SVC_Sound_Emit (net_svc_sound_t *block, sizebuf_t *buf);
net_status_t NET_SVC_Sound_Parse (net_svc_sound_t *block, qmsg_t *msg);
net_status_t NET_SVC_StopSound_Emit (net_svc_stopsound_t *block,
sizebuf_t *buf);
net_status_t NET_SVC_StopSound_Parse (net_svc_stopsound_t *block, qmsg_t *msg);
net_status_t NET_SVC_UpdateFrags_Emit (net_svc_updatefrags_t *block,
sizebuf_t *buf);
net_status_t NET_SVC_UpdateFrags_Parse (net_svc_updatefrags_t *block,
qmsg_t *msg);
net_status_t NET_SVC_UpdatePing_Emit (net_svc_updateping_t *block,
sizebuf_t *buf);
net_status_t NET_SVC_UpdatePing_Parse (net_svc_updateping_t *block, qmsg_t *msg);
net_status_t NET_SVC_UpdatePL_Emit (net_svc_updatepl_t *block, sizebuf_t *buf);
net_status_t NET_SVC_UpdatePL_Parse (net_svc_updatepl_t *block, qmsg_t *msg);
net_status_t NET_SVC_UpdateEnterTime_Emit (net_svc_updateentertime_t *block,
sizebuf_t *buf);
net_status_t NET_SVC_UpdateEnterTime_Parse (net_svc_updateentertime_t *block,
qmsg_t *msg);
net_status_t NET_SVC_SpawnBaseline_Emit (net_svc_spawnbaseline_t *block,
sizebuf_t *buf);
net_status_t NET_SVC_SpawnBaseline_Parse (net_svc_spawnbaseline_t *block,
qmsg_t *msg);
net_status_t NET_SVC_SpawnStatic_Emit (net_svc_spawnstatic_t *block,
sizebuf_t *buf);
net_status_t NET_SVC_SpawnStatic_Parse (net_svc_spawnstatic_t *block,
qmsg_t *msg);
net_status_t NET_SVC_TempEntity_Emit (net_svc_tempentity_t *block,
sizebuf_t *buf);
net_status_t NET_SVC_TempEntity_Parse (net_svc_tempentity_t *block, qmsg_t *msg);
net_status_t NET_SVC_KilledMonster_Emit (net_svc_killedmonster_t *block,
sizebuf_t *buf);
net_status_t NET_SVC_KilledMonster_Parse (net_svc_killedmonster_t *block,
qmsg_t *msg);
net_status_t NET_SVC_FoundSecret_Emit (net_svc_foundsecret_t *block,
sizebuf_t *buf);
net_status_t NET_SVC_FoundSecret_Parse (net_svc_foundsecret_t *block,
qmsg_t *msg);
net_status_t NET_SVC_SpawnStaticSound_Emit (net_svc_spawnstaticsound_t *block,
sizebuf_t *buf);
net_status_t NET_SVC_SpawnStaticSound_Parse (net_svc_spawnstaticsound_t *block,
qmsg_t *msg);
net_status_t NET_SVC_UpdateStat_Emit (net_svc_updatestat_t *block,
sizebuf_t *buf);
net_status_t NET_SVC_UpdateStat_Parse (net_svc_updatestat_t *block, qmsg_t *msg);
net_status_t NET_SVC_UpdateStatLong_Emit (net_svc_updatestatlong_t *block,
sizebuf_t *buf);
net_status_t NET_SVC_UpdateStatLong_Parse (net_svc_updatestatlong_t *block,
qmsg_t *msg);
net_status_t NET_SVC_CDTrack_Emit (net_svc_cdtrack_t *block, sizebuf_t *buf);
net_status_t NET_SVC_CDTrack_Parse (net_svc_cdtrack_t *block, qmsg_t *msg);
net_status_t NET_SVC_Intermission_Emit (net_svc_intermission_t *block,
sizebuf_t *buf);
net_status_t NET_SVC_Intermission_Parse (net_svc_intermission_t *block,
qmsg_t *msg);
net_status_t NET_SVC_Finale_Emit (net_svc_finale_t *block, sizebuf_t *buf);
net_status_t NET_SVC_Finale_Parse (net_svc_finale_t *block, qmsg_t *msg);
net_status_t NET_SVC_SellScreen_Emit (net_svc_sellscreen_t *block,
sizebuf_t *buf);
net_status_t NET_SVC_SellScreen_Parse (net_svc_sellscreen_t *block, qmsg_t *msg);
net_status_t NET_SVC_SmallKick_Emit (net_svc_smallkick_t *block,
sizebuf_t *buf);
net_status_t NET_SVC_SmallKick_Parse (net_svc_smallkick_t *block, qmsg_t *msg);
net_status_t NET_SVC_BigKick_Emit (net_svc_bigkick_t *block, sizebuf_t *buf);
net_status_t NET_SVC_BigKick_Parse (net_svc_bigkick_t *block, qmsg_t *msg);
net_status_t NET_SVC_MuzzleFlash_Emit (net_svc_muzzleflash_t *block,
sizebuf_t *buf);
net_status_t NET_SVC_MuzzleFlash_Parse (net_svc_muzzleflash_t *block,
qmsg_t *msg);
net_status_t NET_SVC_UpdateUserInfo_Emit (net_svc_updateuserinfo_t *block,
sizebuf_t *buf);
net_status_t NET_SVC_UpdateUserInfo_Parse (net_svc_updateuserinfo_t *block,
qmsg_t *msg);
net_status_t NET_SVC_SetInfo_Emit (net_svc_setinfo_t *block, sizebuf_t *buf);
net_status_t NET_SVC_SetInfo_Parse (net_svc_setinfo_t *block, qmsg_t *msg);
net_status_t NET_SVC_ServerInfo_Emit (net_svc_serverinfo_t *block,
sizebuf_t *buf);
net_status_t NET_SVC_ServerInfo_Parse (net_svc_serverinfo_t *block, qmsg_t *msg);
net_status_t NET_SVC_Download_Emit (net_svc_download_t *block, sizebuf_t *buf);
net_status_t NET_SVC_Download_Parse (net_svc_download_t *block, qmsg_t *msg);
net_status_t NET_SVC_Playerinfo_Emit (net_svc_playerinfo_t *block,
sizebuf_t *buf);
net_status_t NET_SVC_Playerinfo_Parse (net_svc_playerinfo_t *block, qmsg_t *msg);
net_status_t NET_SVC_Nails_Emit (net_svc_nails_t *block, sizebuf_t *buf);
net_status_t NET_SVC_Nails_Parse (net_svc_nails_t *block, qmsg_t *msg);
net_status_t NET_SVC_ChokeCount_Emit (net_svc_chokecount_t *block,
sizebuf_t *buf);
net_status_t NET_SVC_ChokeCount_Parse (net_svc_chokecount_t *block, qmsg_t *msg);
net_status_t NET_SVC_Modellist_Emit (net_svc_modellist_t *block,
sizebuf_t *buf);
net_status_t NET_SVC_Modellist_Parse (net_svc_modellist_t *block, qmsg_t *msg);
net_status_t NET_SVC_Soundlist_Emit (net_svc_soundlist_t *block,
sizebuf_t *buf);
net_status_t NET_SVC_Soundlist_Parse (net_svc_soundlist_t *block, qmsg_t *msg);
net_status_t NET_SVC_PacketEntities_Emit (net_svc_packetentities_t *block,
sizebuf_t *buf);
net_status_t NET_SVC_PacketEntities_Parse (net_svc_packetentities_t *block,
qmsg_t *msg);
net_status_t NET_SVC_DeltaPacketEntities_Emit (net_svc_deltapacketentities_t *block,
sizebuf_t *buf);
net_status_t NET_SVC_DeltaPacketEntities_Parse (net_svc_deltapacketentities_t *block,
qmsg_t *msg);
net_status_t NET_SVC_MaxSpeed_Emit (net_svc_maxspeed_t *block, sizebuf_t *buf);
net_status_t NET_SVC_MaxSpeed_Parse (net_svc_maxspeed_t *block, qmsg_t *msg);
net_status_t NET_SVC_EntGravity_Emit (net_svc_entgravity_t *block,
sizebuf_t *buf);
net_status_t NET_SVC_EntGravity_Parse (net_svc_entgravity_t *block, qmsg_t *msg);
net_status_t NET_SVC_SetPause_Emit (net_svc_setpause_t *block, sizebuf_t *buf);
net_status_t NET_SVC_SetPause_Parse (net_svc_setpause_t *block, qmsg_t *msg);
#endif // NET_SVC_H

133
qw/source/msg_ucmd.c
View file

@ -1,133 +0,0 @@
/*
msg.c
(description)
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:
Free Software Foundation, Inc.
59 Temple Place - Suite 330
Boston, MA 02111-1307, USA
*/
#ifdef HAVE_CONFIG_H
# include "config.h"
#endif
static __attribute__ ((unused)) const char rcsid[] =
"$Id$";
#ifdef HAVE_STRING_H
# include <string.h>
#endif
#ifdef HAVE_STRINGS_H
# include <strings.h>
#endif
#include "QF/msg.h"
#include "QF/qendian.h"
#include "QF/sys.h"
#include "qw/msg_ucmd.h"
#include "qw/protocol.h"
#include "netchan.h"
struct usercmd_s nullcmd;
void
MSG_WriteDeltaUsercmd (sizebuf_t *buf, usercmd_t *from, usercmd_t *cmd)
{
int bits;
// send the movement message
bits = 0;
if (cmd->angles[0] != from->angles[0])
bits |= CM_ANGLE1;
if (cmd->angles[1] != from->angles[1])
bits |= CM_ANGLE2;
if (cmd->angles[2] != from->angles[2])
bits |= CM_ANGLE3;
if (cmd->forwardmove != from->forwardmove)
bits |= CM_FORWARD;
if (cmd->sidemove != from->sidemove)
bits |= CM_SIDE;
if (cmd->upmove != from->upmove)
bits |= CM_UP;
if (cmd->buttons != from->buttons)
bits |= CM_BUTTONS;
if (cmd->impulse != from->impulse)
bits |= CM_IMPULSE;
MSG_WriteByte (buf, bits);
if (bits & CM_ANGLE1)
MSG_WriteAngle16 (buf, cmd->angles[0]);
if (bits & CM_ANGLE2)
MSG_WriteAngle16 (buf, cmd->angles[1]);
if (bits & CM_ANGLE3)
MSG_WriteAngle16 (buf, cmd->angles[2]);
if (bits & CM_FORWARD)
MSG_WriteShort (buf, cmd->forwardmove);
if (bits & CM_SIDE)
MSG_WriteShort (buf, cmd->sidemove);
if (bits & CM_UP)
MSG_WriteShort (buf, cmd->upmove);
if (bits & CM_BUTTONS)
MSG_WriteByte (buf, cmd->buttons);
if (bits & CM_IMPULSE)
MSG_WriteByte (buf, cmd->impulse);
MSG_WriteByte (buf, cmd->msec);
}
void
MSG_ReadDeltaUsercmd (usercmd_t *from, usercmd_t *move)
{
int bits;
memcpy (move, from, sizeof (*move));
bits = MSG_ReadByte (net_message);
// read current angles
if (bits & CM_ANGLE1)
move->angles[0] = MSG_ReadAngle16 (net_message);
if (bits & CM_ANGLE2)
move->angles[1] = MSG_ReadAngle16 (net_message);
if (bits & CM_ANGLE3)
move->angles[2] = MSG_ReadAngle16 (net_message);
// read movement
if (bits & CM_FORWARD)
move->forwardmove = MSG_ReadShort (net_message);
if (bits & CM_SIDE)
move->sidemove = MSG_ReadShort (net_message);
if (bits & CM_UP)
move->upmove = MSG_ReadShort (net_message);
// read buttons
if (bits & CM_BUTTONS)
move->buttons = MSG_ReadByte (net_message);
if (bits & CM_IMPULSE)
move->impulse = MSG_ReadByte (net_message);
// read time to run command
move->msec = MSG_ReadByte (net_message);
}

1386
qw/source/net_svc.c
View file

File diff suppressed because it is too large Load diff

2
tools/qfcc/test/defs.h
View file

@ -441,7 +441,7 @@
//================================================
//
// world fields (FIXME: make globals)
// world fields
//
@extern .string wad;
@extern .string map;