Commit 130e2219 authored by Tyrann's avatar Tyrann
Browse files

Import v0.47 sources

parents
This diff is collapsed.
GLQuake Drivers
Graphics Subsystem: Voodoo Graphics or Voodoo Rush
Copyright ( 1997 3Dfx Interactive, Inc. )
All Rights Reserved
3Dfx Interactive, Inc.
www: www.3dfx.com
news: news.3dfx.com
-----------------------------------------------------------------------
NOTE: GLQuake requires DirectX support DirectSound. DirectX can be
installed from the media provided with your Voodoo Based 3D Accelerator.
Glide 2.31 or HIGHER runtime drivers *MUST* be installed to use this
GLQuake driver. Please download these drivers from your board
manufacturer OR unsupported drivers from http://www.3dfx.com
-----------------------------------------------------------------------
Release Notes for GLQuake's mini-GL driver
What's in the distribution?
---------------------------
This distribution contains GLQuake Drivers for Voodoo Based 3D
Accelerators. These drivers were tested on the following boards:
Voodoo Graphics:
- Quantum 3D Obsidian
- Diamond Monster 3D
- Orchid Righteous 3D
- Deltron Realvision Flash 3D
- Guillemot MaxiGamer
- Skywell Magic 3D
Voodoo Rush:
- Hercules Stringray 128-3D
- Intergraph Intense 3D Voodoo
- Jazz Multimedia Adrenaline Rush
NOTE: The enclosed drivers are not meant to replace any Direct3D or
Glide drivers provided by your Voodoo Graphics card manufacturer.
Please obtain supported drivers from your board manufacturer.
OEMSR2 and NT users: Do NOT replace OPENGL32.DLL located in your
Windows\SYSTEM directory.
Requirements
------------
- Voodoo Graphics or Voodoo Rush Based 3D Accelerator
- Windows 95 (Windows NT is supported for Voodoo Rush)
- A PC with a Pentium 90 or higher CPU
- 16MB of RAM
- 2D Video card set at 16 bit color
Support and Frequently Asked Questions
--------------------------------------
GLQuake is currently unsupported. You may however find answers to
questions on various Quake dedicated websites. 3Dfx provides a GLQuake
newsgroup on news.3dfx.com (Newsgroup name is 3dfx.games.glquake ) to
discuss GLQuake with other users. 3Dfx also provides a regularly
updated GLQuake FAQ at: http://www.3dfx.com/game_dev/quake_faq.html
Voodoo Graphics and Voodoo Rush are trademarks of 3Dfx Interactive, Inc.
All other trademarks are the property of their respective owners.
\ No newline at end of file
# ------------
# NQ Makefile - to be called from the main makefile
# ------------
# Not quite ready for buildirs, etc.
# More seperation required:
# - Core engine
# - Renderer
# - System
.PHONY: default \
quake-sw-win32 quake-gl-win32 quake-sw-linux quake-gl-linux
# Rules to compile stuff from the common dir...
%.o: ../common/%.S
$(CC) -c $(CPPFLAGS) $(CFLAGS) -o $@ $^
%.o: ../common/%.c
$(CC) -c $(CPPFLAGS) $(CFLAGS) -o $@ $^
# Rule to make the resource file
%.res: %.rc
windres -i $^ -O coff -o $@
# Don't build anything by default
default:
quake-sw-win32: $(NQ_W32_SW_OBJS)
quake-gl-win32: $(NQ_W32_GL_OBJS)
quake-sw-linux: $(NQ_LINUX_SW_OBJS)
quake-gl-linux: $(NQ_LINUX_GL_OBJS)
/*
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.
*/
// chase.c -- chase camera code
#include "quakedef.h"
#include "world.h" /* trace_t */
cvar_t chase_back = { "chase_back", "100" };
cvar_t chase_up = { "chase_up", "16" };
cvar_t chase_right = { "chase_right", "0" };
cvar_t chase_active = { "chase_active", "0" };
vec3_t chase_pos;
vec3_t chase_angles;
vec3_t chase_dest;
vec3_t chase_dest_angles;
void
Chase_Init(void)
{
Cvar_RegisterVariable(&chase_back);
Cvar_RegisterVariable(&chase_up);
Cvar_RegisterVariable(&chase_right);
Cvar_RegisterVariable(&chase_active);
}
void
Chase_Reset(void)
{
// for respawning and teleporting
// start position 12 units behind head
}
void
TraceLine(vec3_t start, vec3_t end, vec3_t impact)
{
trace_t trace;
memset(&trace, 0, sizeof(trace));
SV_RecursiveHullCheck(cl.worldmodel->hulls, 0, 0, 1, start, end, &trace);
VectorCopy(trace.endpos, impact);
}
void
Chase_Update(void)
{
int i;
float dist;
vec3_t forward, up, right;
vec3_t dest, stop;
// if can't see player, reset
AngleVectors(cl.viewangles, forward, right, up);
// calc exact destination
for (i = 0; i < 3; i++)
chase_dest[i] = r_refdef.vieworg[i]
- forward[i] * chase_back.value - right[i] * chase_right.value;
chase_dest[2] = r_refdef.vieworg[2] + chase_up.value;
// find the spot the player is looking at
VectorMA(r_refdef.vieworg, 4096, forward, dest);
TraceLine(r_refdef.vieworg, dest, stop);
// calculate pitch to look at the same spot from camera
VectorSubtract(stop, r_refdef.vieworg, stop);
dist = DotProduct(stop, forward);
if (dist < 1)
dist = 1;
r_refdef.viewangles[PITCH] = -atan(stop[2] / dist) / M_PI * 180;
// move towards destination
VectorCopy(chase_dest, r_refdef.vieworg);
}
/*
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.
*/
#include "client.h"
#include "cmd.h"
#include "console.h"
#include "host.h"
#include "net.h"
#include "protocol.h"
#include "quakedef.h"
#include "sys.h"
static void CL_FinishTimeDemo(void);
/*
==============================================================================
DEMO CODE
When a demo is playing back, all NET_SendMessages are skipped, and
NET_GetMessages are read from the demo file.
Whenever cl.time gets past the last received message, another message is
read from the demo file.
==============================================================================
*/
/*
==============
CL_StopPlayback
Called when a demo file runs out, or the user starts a game
==============
*/
void
CL_StopPlayback(void)
{
if (!cls.demoplayback)
return;
fclose(cls.demofile);
cls.demoplayback = false;
cls.demofile = NULL;
cls.state = ca_disconnected;
if (cls.timedemo)
CL_FinishTimeDemo();
}
/*
====================
CL_WriteDemoMessage
Dumps the current net message, prefixed by the length and view angles
====================
*/
static void
CL_WriteDemoMessage(void)
{
int len;
int i;
float f;
len = LittleLong(net_message.cursize);
fwrite(&len, 4, 1, cls.demofile);
for (i = 0; i < 3; i++) {
f = LittleFloat(cl.viewangles[i]);
fwrite(&f, 4, 1, cls.demofile);
}
fwrite(net_message.data, net_message.cursize, 1, cls.demofile);
fflush(cls.demofile);
}
/*
====================
CL_GetMessage
Handles recording and playback of demos, on top of NET_ code
====================
*/
int
CL_GetMessage(void)
{
int r, i;
float f;
if (cls.demoplayback) {
// decide if it is time to grab the next message
// allways grab until fully connected
if (cls.state == ca_active) {
if (cls.timedemo) {
if (host_framecount == cls.td_lastframe)
return 0; // allready read this frame's message
cls.td_lastframe = host_framecount;
// if this is the second frame, grab the real td_starttime
// so the bogus time on the first frame doesn't count
if (host_framecount == cls.td_startframe + 1)
cls.td_starttime = realtime;
} else if (cl.time <= cl.mtime[0]) {
// don't need another message yet
return 0;
}
}
// get the next message
fread(&net_message.cursize, 4, 1, cls.demofile);
VectorCopy(cl.mviewangles[0], cl.mviewangles[1]);
for (i = 0; i < 3; i++) {
r = fread(&f, 4, 1, cls.demofile);
cl.mviewangles[0][i] = LittleFloat(f);
}
net_message.cursize = LittleLong(net_message.cursize);
if (net_message.cursize > MAX_MSGLEN)
Sys_Error("Demo message > MAX_MSGLEN");
r = fread(net_message.data, net_message.cursize, 1, cls.demofile);
if (r != 1) {
CL_StopPlayback();
return 0;
}
return 1;
}
while (1) {
r = NET_GetMessage(cls.netcon);
if (r != 1 && r != 2)
return r;
// discard nop keepalive message
if (net_message.cursize == 1 && net_message.data[0] == svc_nop)
Con_Printf("<-- server to client keepalive\n");
else
break;
}
if (cls.demorecording)
CL_WriteDemoMessage();
return r;
}
/*
====================
CL_Stop_f
stop recording a demo
====================
*/
void
CL_Stop_f(void)
{
if (cmd_source != src_command)
return;
if (!cls.demorecording) {
Con_Printf("Not recording a demo.\n");
return;
}
// write a disconnect message to the demo file
SZ_Clear(&net_message);
MSG_WriteByte(&net_message, svc_disconnect);
CL_WriteDemoMessage();
// finish up
fclose(cls.demofile);
cls.demofile = NULL;
cls.demorecording = false;
Con_Printf("Completed demo\n");
}
/*
====================
CL_Record_f
record <demoname> <map> [cd track]
====================
*/
void
CL_Record_f(void)
{
int c;
char name[MAX_OSPATH];
int track;
if (cmd_source != src_command)
return;
c = Cmd_Argc();
if (c != 2 && c != 3 && c != 4) {
Con_Printf("record <demoname> [<map> [cd track]]\n");
return;
}
if (strstr(Cmd_Argv(1), "..")) {
Con_Printf("Relative pathnames are not allowed.\n");
return;
}
if (c == 2 && cls.state >= ca_connected) {
Con_Printf("Can not record - already connected to server\n"
"Client demo recording must be started before"
" connecting\n");
return;
}
// write the forced cd track number, or -1
if (c == 4) {
track = atoi(Cmd_Argv(3));
Con_Printf("Forcing CD track to %i\n", cls.forcetrack);
} else
track = -1;
sprintf(name, "%s/%s", com_gamedir, Cmd_Argv(1));
//
// start the map up
//
if (c > 2)
Cmd_ExecuteString(va("map %s", Cmd_Argv(2)), src_command);
//
// open the demo file
//
COM_DefaultExtension(name, ".dem");
Con_Printf("recording to %s.\n", name);
cls.demofile = fopen(name, "wb");
if (!cls.demofile) {
Con_Printf("ERROR: couldn't open.\n");
return;
}
cls.forcetrack = track;
fprintf(cls.demofile, "%i\n", cls.forcetrack);
cls.demorecording = true;
}
/*
====================
CL_PlayDemo_f
play [demoname]
====================
*/
void
CL_PlayDemo_f(void)
{
char name[256];
int c;
qboolean neg = false;
if (cmd_source != src_command)
return;
if (Cmd_Argc() != 2) {
Con_Printf("play <demoname> : plays a demo\n");
return;
}
//
// disconnect from server
//
CL_Disconnect();
//
// open the demo file
//
strcpy(name, Cmd_Argv(1));
COM_DefaultExtension(name, ".dem");
Con_Printf("Playing demo from %s.\n", name);
COM_FOpenFile(name, &cls.demofile);
if (!cls.demofile) {
Con_Printf("ERROR: couldn't open.\n");
cls.demonum = -1; // stop demo loop
return;
}
cls.demoplayback = true;
cls.state = ca_connected;
cls.forcetrack = 0;
while ((c = getc(cls.demofile)) != '\n')
if (c == '-')
neg = true;
else
cls.forcetrack = cls.forcetrack * 10 + (c - '0');
if (neg)
cls.forcetrack = -cls.forcetrack;
// ZOID, fscanf is evil
// fscanf (cls.demofile, "%i\n", &cls.forcetrack);
}
/*
====================
CL_FinishTimeDemo
====================
*/
static void
CL_FinishTimeDemo(void)
{
int frames;
float time;
cls.timedemo = false;
// the first frame didn't count
frames = (host_framecount - cls.td_startframe) - 1;
time = realtime - cls.td_starttime;
if (!time)
time = 1;
Con_Printf("%i frames %5.1f seconds %5.1f fps\n", frames, time,
frames / time);
}
/*
====================
CL_TimeDemo_f
timedemo [demoname]
====================
*/
void
CL_TimeDemo_f(void)
{
if (cmd_source != src_command)
return;
if (Cmd_Argc() != 2) {
Con_Printf("timedemo <demoname> : gets demo speeds\n");
return;
}
CL_PlayDemo_f();
// cls.td_starttime will be grabbed at the second frame of the demo, so
// all the loading time doesn't get counted
cls.timedemo = true;
cls.td_startframe = host_framecount;
cls.td_lastframe = -1; // get a new message this frame
}
/*
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.
*/
// cl.input.c -- builds an intended movement command to send to the server
// Quake is a trademark of Id Software, Inc., (c) 1996 Id Software, Inc. All
// rights reserved.
#include "quakedef.h"
#include "host.h"
#include "client.h"
#include "cmd.h"
#include "console.h"
#include "net.h"
#include "protocol.h"
/*
===============================================================================
KEY BUTTONS
Continuous button event tracking is complicated by the fact that two different
input sources (say, mouse button 1 and the control key) can both press the
same button, but the button should only be released when both of the
pressing key have been released.
When a key event issues a button command (+forward, +attack, etc), it appends
its key number as a parameter to the command so it can be matched up with
the release.
state bit 0 is the current state of the key
state bit 1 is edge triggered on the up to down transition
state bit 2 is edge triggered on the down to up transition
===============================================================================
*/
kbutton_t in_mlook, in_klook;
kbutton_t in_left, in_right, in_forward, in_back;
kbutton_t in_lookup, in_lookdown, in_moveleft, in_moveright;
kbutton_t in_strafe, in_speed, in_use, in_jump, in_attack;
kbutton_t in_up, in_down;
int in_impulse;
void
KeyDown(kbutton_t *b)
{
int k;
char *c;
c = Cmd_Argv(1);
if (c[0])
k = atoi(c);
else
k = -1; // typed manually at the console for continuous down
if (k == b->down[0] || k == b->down[1])
return; // repeating key