mirror of
https://github.com/dhewm/dhewm3-sdk.git
synced 2024-11-22 20:51:40 +00:00
f8efcf5e90
Alot of stack and event variables are pointers. Align the size of all script and event variable types to sizeof(intptr_t) so that the CPU needs only one fetch insn on 64bit archs. Tested on x86 and x86_64 and found no different script behaviours compared to the binary from id. Savegames on x86_64 do work, but are not compatible to x86 and vice versa (among other issues, the stack is written to file as-is). x86 builds can still load savegames from the official binary and vice versa.
872 lines
23 KiB
C++
872 lines
23 KiB
C++
/*
|
|
===========================================================================
|
|
|
|
Doom 3 GPL Source Code
|
|
Copyright (C) 1999-2011 id Software LLC, a ZeniMax Media company.
|
|
|
|
This file is part of the Doom 3 GPL Source Code ("Doom 3 Source Code").
|
|
|
|
Doom 3 Source Code 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 3 of the License, or
|
|
(at your option) any later version.
|
|
|
|
Doom 3 Source Code 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 Doom 3 Source Code. If not, see <http://www.gnu.org/licenses/>.
|
|
|
|
In addition, the Doom 3 Source Code is also subject to certain additional terms. You should have received a copy of these additional terms immediately following the terms and conditions of the GNU General Public License which accompanied the Doom 3 Source Code. If not, please request a copy in writing from id Software at the address below.
|
|
|
|
If you have questions concerning this license or the applicable additional terms, you may contact in writing id Software LLC, c/o ZeniMax Media Inc., Suite 120, Rockville, Maryland 20850 USA.
|
|
|
|
===========================================================================
|
|
*/
|
|
/*
|
|
sys_event.cpp
|
|
|
|
Event are used for scheduling tasks and for linking script commands.
|
|
|
|
*/
|
|
|
|
#include "../../idlib/precompiled.h"
|
|
#pragma hdrstop
|
|
|
|
#include "../Game_local.h"
|
|
|
|
#define MAX_EVENTSPERFRAME 4096
|
|
//#define CREATE_EVENT_CODE
|
|
|
|
/***********************************************************************
|
|
|
|
idEventDef
|
|
|
|
***********************************************************************/
|
|
|
|
idEventDef *idEventDef::eventDefList[MAX_EVENTS];
|
|
int idEventDef::numEventDefs = 0;
|
|
|
|
static bool eventError = false;
|
|
static char eventErrorMsg[ 128 ];
|
|
|
|
/*
|
|
================
|
|
idEventDef::idEventDef
|
|
================
|
|
*/
|
|
idEventDef::idEventDef( const char *command, const char *formatspec, char returnType ) {
|
|
idEventDef *ev;
|
|
int i;
|
|
unsigned int bits;
|
|
|
|
assert( command );
|
|
assert( !idEvent::initialized );
|
|
|
|
// Allow NULL to indicate no args, but always store it as ""
|
|
// so we don't have to check for it.
|
|
if ( !formatspec ) {
|
|
formatspec = "";
|
|
}
|
|
|
|
this->name = command;
|
|
this->formatspec = formatspec;
|
|
this->returnType = returnType;
|
|
|
|
numargs = strlen( formatspec );
|
|
assert( numargs <= D_EVENT_MAXARGS );
|
|
if ( numargs > D_EVENT_MAXARGS ) {
|
|
eventError = true;
|
|
sprintf( eventErrorMsg, "idEventDef::idEventDef : Too many args for '%s' event.", name );
|
|
return;
|
|
}
|
|
|
|
// make sure the format for the args is valid, calculate the formatspecindex, and the offsets for each arg
|
|
bits = 0;
|
|
argsize = 0;
|
|
memset( argOffset, 0, sizeof( argOffset ) );
|
|
for( i = 0; i < numargs; i++ ) {
|
|
argOffset[ i ] = argsize;
|
|
switch( formatspec[ i ] ) {
|
|
case D_EVENT_FLOAT :
|
|
bits |= 1 << i;
|
|
argsize += sizeof( intptr_t );
|
|
break;
|
|
|
|
case D_EVENT_INTEGER :
|
|
argsize += sizeof( intptr_t );
|
|
break;
|
|
|
|
case D_EVENT_VECTOR :
|
|
argsize += E_EVENT_SIZEOF_VEC;
|
|
break;
|
|
|
|
case D_EVENT_STRING :
|
|
argsize += MAX_STRING_LEN;
|
|
break;
|
|
|
|
case D_EVENT_ENTITY :
|
|
argsize += sizeof( idEntityPtr<idEntity> );
|
|
break;
|
|
|
|
case D_EVENT_ENTITY_NULL :
|
|
argsize += sizeof( idEntityPtr<idEntity> );
|
|
break;
|
|
|
|
case D_EVENT_TRACE :
|
|
argsize += sizeof( trace_t ) + MAX_STRING_LEN + sizeof( bool );
|
|
break;
|
|
|
|
default :
|
|
eventError = true;
|
|
sprintf( eventErrorMsg, "idEventDef::idEventDef : Invalid arg format '%s' string for '%s' event.", formatspec, name );
|
|
return;
|
|
break;
|
|
}
|
|
}
|
|
|
|
// calculate the formatspecindex
|
|
formatspecIndex = ( 1 << ( numargs + D_EVENT_MAXARGS ) ) | bits;
|
|
|
|
// go through the list of defined events and check for duplicates
|
|
// and mismatched format strings
|
|
eventnum = numEventDefs;
|
|
for( i = 0; i < eventnum; i++ ) {
|
|
ev = eventDefList[ i ];
|
|
if ( strcmp( command, ev->name ) == 0 ) {
|
|
if ( strcmp( formatspec, ev->formatspec ) != 0 ) {
|
|
eventError = true;
|
|
sprintf( eventErrorMsg, "idEvent '%s' defined twice with same name but differing format strings ('%s'!='%s').",
|
|
command, formatspec, ev->formatspec );
|
|
return;
|
|
}
|
|
|
|
if ( ev->returnType != returnType ) {
|
|
eventError = true;
|
|
sprintf( eventErrorMsg, "idEvent '%s' defined twice with same name but differing return types ('%c'!='%c').",
|
|
command, returnType, ev->returnType );
|
|
return;
|
|
}
|
|
// Don't bother putting the duplicate event in list.
|
|
eventnum = ev->eventnum;
|
|
return;
|
|
}
|
|
}
|
|
|
|
ev = this;
|
|
|
|
if ( numEventDefs >= MAX_EVENTS ) {
|
|
eventError = true;
|
|
sprintf( eventErrorMsg, "numEventDefs >= MAX_EVENTS" );
|
|
return;
|
|
}
|
|
eventDefList[numEventDefs] = ev;
|
|
numEventDefs++;
|
|
}
|
|
|
|
/*
|
|
================
|
|
idEventDef::NumEventCommands
|
|
================
|
|
*/
|
|
int idEventDef::NumEventCommands( void ) {
|
|
return numEventDefs;
|
|
}
|
|
|
|
/*
|
|
================
|
|
idEventDef::GetEventCommand
|
|
================
|
|
*/
|
|
const idEventDef *idEventDef::GetEventCommand( int eventnum ) {
|
|
return eventDefList[ eventnum ];
|
|
}
|
|
|
|
/*
|
|
================
|
|
idEventDef::FindEvent
|
|
================
|
|
*/
|
|
const idEventDef *idEventDef::FindEvent( const char *name ) {
|
|
idEventDef *ev;
|
|
int num;
|
|
int i;
|
|
|
|
assert( name );
|
|
|
|
num = numEventDefs;
|
|
for( i = 0; i < num; i++ ) {
|
|
ev = eventDefList[ i ];
|
|
if ( strcmp( name, ev->name ) == 0 ) {
|
|
return ev;
|
|
}
|
|
}
|
|
|
|
return NULL;
|
|
}
|
|
|
|
/***********************************************************************
|
|
|
|
idEvent
|
|
|
|
***********************************************************************/
|
|
|
|
static idLinkList<idEvent> FreeEvents;
|
|
static idLinkList<idEvent> EventQueue;
|
|
static idEvent EventPool[ MAX_EVENTS ];
|
|
|
|
bool idEvent::initialized = false;
|
|
|
|
idDynamicBlockAlloc<byte, 16 * 1024, 256> idEvent::eventDataAllocator;
|
|
|
|
/*
|
|
================
|
|
idEvent::~idEvent()
|
|
================
|
|
*/
|
|
idEvent::~idEvent() {
|
|
Free();
|
|
}
|
|
|
|
/*
|
|
================
|
|
idEvent::Alloc
|
|
================
|
|
*/
|
|
idEvent *idEvent::Alloc( const idEventDef *evdef, int numargs, va_list args ) {
|
|
idEvent *ev;
|
|
size_t size;
|
|
const char *format;
|
|
idEventArg *arg;
|
|
byte *dataPtr;
|
|
int i;
|
|
const char *materialName;
|
|
|
|
if ( FreeEvents.IsListEmpty() ) {
|
|
gameLocal.Error( "idEvent::Alloc : No more free events" );
|
|
}
|
|
|
|
ev = FreeEvents.Next();
|
|
ev->eventNode.Remove();
|
|
|
|
ev->eventdef = evdef;
|
|
|
|
if ( numargs != evdef->GetNumArgs() ) {
|
|
gameLocal.Error( "idEvent::Alloc : Wrong number of args for '%s' event.", evdef->GetName() );
|
|
}
|
|
|
|
size = evdef->GetArgSize();
|
|
if ( size ) {
|
|
ev->data = eventDataAllocator.Alloc( size );
|
|
memset( ev->data, 0, size );
|
|
} else {
|
|
ev->data = NULL;
|
|
}
|
|
|
|
format = evdef->GetArgFormat();
|
|
for( i = 0; i < numargs; i++ ) {
|
|
arg = va_arg( args, idEventArg * );
|
|
if ( format[ i ] != arg->type ) {
|
|
// when NULL is passed in for an entity, it gets cast as an integer 0, so don't give an error when it happens
|
|
if ( !( ( ( format[ i ] == D_EVENT_TRACE ) || ( format[ i ] == D_EVENT_ENTITY ) ) && ( arg->type == 'd' ) && ( arg->value == 0 ) ) ) {
|
|
gameLocal.Error( "idEvent::Alloc : Wrong type passed in for arg # %d on '%s' event.", i, evdef->GetName() );
|
|
}
|
|
}
|
|
|
|
dataPtr = &ev->data[ evdef->GetArgOffset( i ) ];
|
|
|
|
switch( format[ i ] ) {
|
|
case D_EVENT_FLOAT :
|
|
case D_EVENT_INTEGER :
|
|
*reinterpret_cast<int *>( dataPtr ) = arg->value;
|
|
break;
|
|
|
|
case D_EVENT_VECTOR :
|
|
if ( arg->value ) {
|
|
*reinterpret_cast<idVec3 *>( dataPtr ) = *reinterpret_cast<const idVec3 *>( arg->value );
|
|
}
|
|
break;
|
|
|
|
case D_EVENT_STRING :
|
|
if ( arg->value ) {
|
|
idStr::Copynz( reinterpret_cast<char *>( dataPtr ), reinterpret_cast<const char *>( arg->value ), MAX_STRING_LEN );
|
|
}
|
|
break;
|
|
|
|
case D_EVENT_ENTITY :
|
|
case D_EVENT_ENTITY_NULL :
|
|
*reinterpret_cast< idEntityPtr<idEntity> * >( dataPtr ) = reinterpret_cast<idEntity *>( arg->value );
|
|
break;
|
|
|
|
case D_EVENT_TRACE :
|
|
if ( arg->value ) {
|
|
*reinterpret_cast<bool *>( dataPtr ) = true;
|
|
*reinterpret_cast<trace_t *>( dataPtr + sizeof( bool ) ) = *reinterpret_cast<const trace_t *>( arg->value );
|
|
|
|
// save off the material as a string since the pointer won't be valid in save games.
|
|
// since we save off the entire trace_t structure, if the material is NULL here,
|
|
// it will be NULL when we process it, so we don't need to save off anything in that case.
|
|
if ( reinterpret_cast<const trace_t *>( arg->value )->c.material ) {
|
|
materialName = reinterpret_cast<const trace_t *>( arg->value )->c.material->GetName();
|
|
idStr::Copynz( reinterpret_cast<char *>( dataPtr + sizeof( bool ) + sizeof( trace_t ) ), materialName, MAX_STRING_LEN );
|
|
}
|
|
} else {
|
|
*reinterpret_cast<bool *>( dataPtr ) = false;
|
|
}
|
|
break;
|
|
|
|
default :
|
|
gameLocal.Error( "idEvent::Alloc : Invalid arg format '%s' string for '%s' event.", format, evdef->GetName() );
|
|
break;
|
|
}
|
|
}
|
|
|
|
return ev;
|
|
}
|
|
|
|
/*
|
|
================
|
|
idEvent::CopyArgs
|
|
================
|
|
*/
|
|
void idEvent::CopyArgs( const idEventDef *evdef, int numargs, va_list args, intptr_t data[ D_EVENT_MAXARGS ] ) {
|
|
int i;
|
|
const char *format;
|
|
idEventArg *arg;
|
|
|
|
format = evdef->GetArgFormat();
|
|
if ( numargs != evdef->GetNumArgs() ) {
|
|
gameLocal.Error( "idEvent::CopyArgs : Wrong number of args for '%s' event.", evdef->GetName() );
|
|
}
|
|
|
|
for( i = 0; i < numargs; i++ ) {
|
|
arg = va_arg( args, idEventArg * );
|
|
if ( format[ i ] != arg->type ) {
|
|
// when NULL is passed in for an entity, it gets cast as an integer 0, so don't give an error when it happens
|
|
if ( !( ( ( format[ i ] == D_EVENT_TRACE ) || ( format[ i ] == D_EVENT_ENTITY ) ) && ( arg->type == 'd' ) && ( arg->value == 0 ) ) ) {
|
|
gameLocal.Error( "idEvent::CopyArgs : Wrong type passed in for arg # %d on '%s' event.", i, evdef->GetName() );
|
|
}
|
|
}
|
|
|
|
data[ i ] = arg->value;
|
|
}
|
|
}
|
|
|
|
/*
|
|
================
|
|
idEvent::Free
|
|
================
|
|
*/
|
|
void idEvent::Free( void ) {
|
|
if ( data ) {
|
|
eventDataAllocator.Free( data );
|
|
data = NULL;
|
|
}
|
|
|
|
eventdef = NULL;
|
|
time = 0;
|
|
object = NULL;
|
|
typeinfo = NULL;
|
|
|
|
eventNode.SetOwner( this );
|
|
eventNode.AddToEnd( FreeEvents );
|
|
}
|
|
|
|
/*
|
|
================
|
|
idEvent::Schedule
|
|
================
|
|
*/
|
|
void idEvent::Schedule( idClass *obj, const idTypeInfo *type, int time ) {
|
|
idEvent *event;
|
|
|
|
assert( initialized );
|
|
if ( !initialized ) {
|
|
return;
|
|
}
|
|
|
|
object = obj;
|
|
typeinfo = type;
|
|
|
|
// wraps after 24 days...like I care. ;)
|
|
this->time = gameLocal.time + time;
|
|
|
|
eventNode.Remove();
|
|
|
|
event = EventQueue.Next();
|
|
while( ( event != NULL ) && ( this->time >= event->time ) ) {
|
|
event = event->eventNode.Next();
|
|
}
|
|
|
|
if ( event ) {
|
|
eventNode.InsertBefore( event->eventNode );
|
|
} else {
|
|
eventNode.AddToEnd( EventQueue );
|
|
}
|
|
}
|
|
|
|
/*
|
|
================
|
|
idEvent::CancelEvents
|
|
================
|
|
*/
|
|
void idEvent::CancelEvents( const idClass *obj, const idEventDef *evdef ) {
|
|
idEvent *event;
|
|
idEvent *next;
|
|
|
|
if ( !initialized ) {
|
|
return;
|
|
}
|
|
|
|
for( event = EventQueue.Next(); event != NULL; event = next ) {
|
|
next = event->eventNode.Next();
|
|
if ( event->object == obj ) {
|
|
if ( !evdef || ( evdef == event->eventdef ) ) {
|
|
event->Free();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/*
|
|
================
|
|
idEvent::ClearEventList
|
|
================
|
|
*/
|
|
void idEvent::ClearEventList( void ) {
|
|
int i;
|
|
|
|
//
|
|
// initialize lists
|
|
//
|
|
FreeEvents.Clear();
|
|
EventQueue.Clear();
|
|
|
|
//
|
|
// add the events to the free list
|
|
//
|
|
for( i = 0; i < MAX_EVENTS; i++ ) {
|
|
EventPool[ i ].Free();
|
|
}
|
|
}
|
|
|
|
/*
|
|
================
|
|
idEvent::ServiceEvents
|
|
================
|
|
*/
|
|
void idEvent::ServiceEvents( void ) {
|
|
idEvent *event;
|
|
int num;
|
|
intptr_t args[ D_EVENT_MAXARGS ];
|
|
int offset;
|
|
int i;
|
|
int numargs;
|
|
const char *formatspec;
|
|
trace_t **tracePtr;
|
|
const idEventDef *ev;
|
|
byte *data;
|
|
const char *materialName;
|
|
|
|
num = 0;
|
|
while( !EventQueue.IsListEmpty() ) {
|
|
event = EventQueue.Next();
|
|
assert( event );
|
|
|
|
if ( event->time > gameLocal.time ) {
|
|
break;
|
|
}
|
|
|
|
// copy the data into the local args array and set up pointers
|
|
ev = event->eventdef;
|
|
formatspec = ev->GetArgFormat();
|
|
numargs = ev->GetNumArgs();
|
|
for( i = 0; i < numargs; i++ ) {
|
|
offset = ev->GetArgOffset( i );
|
|
data = event->data;
|
|
switch( formatspec[ i ] ) {
|
|
case D_EVENT_FLOAT :
|
|
case D_EVENT_INTEGER :
|
|
args[ i ] = *reinterpret_cast<int *>( &data[ offset ] );
|
|
break;
|
|
|
|
case D_EVENT_VECTOR :
|
|
*reinterpret_cast<idVec3 **>( &args[ i ] ) = reinterpret_cast<idVec3 *>( &data[ offset ] );
|
|
break;
|
|
|
|
case D_EVENT_STRING :
|
|
*reinterpret_cast<const char **>( &args[ i ] ) = reinterpret_cast<const char *>( &data[ offset ] );
|
|
break;
|
|
|
|
case D_EVENT_ENTITY :
|
|
case D_EVENT_ENTITY_NULL :
|
|
*reinterpret_cast<idEntity **>( &args[ i ] ) = reinterpret_cast< idEntityPtr<idEntity> * >( &data[ offset ] )->GetEntity();
|
|
break;
|
|
|
|
case D_EVENT_TRACE :
|
|
tracePtr = reinterpret_cast<trace_t **>( &args[ i ] );
|
|
if ( *reinterpret_cast<bool *>( &data[ offset ] ) ) {
|
|
*tracePtr = reinterpret_cast<trace_t *>( &data[ offset + sizeof( bool ) ] );
|
|
|
|
if ( ( *tracePtr )->c.material != NULL ) {
|
|
// look up the material name to get the material pointer
|
|
materialName = reinterpret_cast<const char *>( &data[ offset + sizeof( bool ) + sizeof( trace_t ) ] );
|
|
( *tracePtr )->c.material = declManager->FindMaterial( materialName, true );
|
|
}
|
|
} else {
|
|
*tracePtr = NULL;
|
|
}
|
|
break;
|
|
|
|
default:
|
|
gameLocal.Error( "idEvent::ServiceEvents : Invalid arg format '%s' string for '%s' event.", formatspec, ev->GetName() );
|
|
}
|
|
}
|
|
|
|
// the event is removed from its list so that if then object
|
|
// is deleted, the event won't be freed twice
|
|
event->eventNode.Remove();
|
|
assert( event->object );
|
|
event->object->ProcessEventArgPtr( ev, args );
|
|
|
|
#if 0
|
|
// event functions may never leave return values on the FPU stack
|
|
// enable this code to check if any event call left values on the FPU stack
|
|
if ( !sys->FPU_StackIsEmpty() ) {
|
|
gameLocal.Error( "idEvent::ServiceEvents %d: %s left a value on the FPU stack\n", num, ev->GetName() );
|
|
}
|
|
#endif
|
|
|
|
// return the event to the free list
|
|
event->Free();
|
|
|
|
// Don't allow ourselves to stay in here too long. An abnormally high number
|
|
// of events being processed is evidence of an infinite loop of events.
|
|
num++;
|
|
if ( num > MAX_EVENTSPERFRAME ) {
|
|
gameLocal.Error( "Event overflow. Possible infinite loop in script." );
|
|
}
|
|
}
|
|
}
|
|
|
|
/*
|
|
================
|
|
idEvent::Init
|
|
================
|
|
*/
|
|
void idEvent::Init( void ) {
|
|
gameLocal.Printf( "Initializing event system\n" );
|
|
|
|
if ( eventError ) {
|
|
gameLocal.Error( "%s", eventErrorMsg );
|
|
}
|
|
|
|
#ifdef CREATE_EVENT_CODE
|
|
void CreateEventCallbackHandler();
|
|
CreateEventCallbackHandler();
|
|
gameLocal.Error( "Wrote event callback handler" );
|
|
#endif
|
|
|
|
if ( initialized ) {
|
|
gameLocal.Printf( "...already initialized\n" );
|
|
ClearEventList();
|
|
return;
|
|
}
|
|
|
|
ClearEventList();
|
|
|
|
eventDataAllocator.Init();
|
|
|
|
gameLocal.Printf( "...%i event definitions\n", idEventDef::NumEventCommands() );
|
|
|
|
// the event system has started
|
|
initialized = true;
|
|
}
|
|
|
|
/*
|
|
================
|
|
idEvent::Shutdown
|
|
================
|
|
*/
|
|
void idEvent::Shutdown( void ) {
|
|
gameLocal.Printf( "Shutdown event system\n" );
|
|
|
|
if ( !initialized ) {
|
|
gameLocal.Printf( "...not started\n" );
|
|
return;
|
|
}
|
|
|
|
ClearEventList();
|
|
|
|
eventDataAllocator.Shutdown();
|
|
|
|
// say it is now shutdown
|
|
initialized = false;
|
|
}
|
|
|
|
/*
|
|
================
|
|
idEvent::Save
|
|
================
|
|
*/
|
|
void idEvent::Save( idSaveGame *savefile ) {
|
|
char *str;
|
|
int i, size;
|
|
idEvent *event;
|
|
byte *dataPtr;
|
|
bool validTrace;
|
|
const char *format;
|
|
|
|
savefile->WriteInt( EventQueue.Num() );
|
|
|
|
event = EventQueue.Next();
|
|
while( event != NULL ) {
|
|
savefile->WriteInt( event->time );
|
|
savefile->WriteString( event->eventdef->GetName() );
|
|
savefile->WriteString( event->typeinfo->classname );
|
|
savefile->WriteObject( event->object );
|
|
savefile->WriteInt( event->eventdef->GetArgSize() );
|
|
format = event->eventdef->GetArgFormat();
|
|
for ( i = 0, size = 0; i < event->eventdef->GetNumArgs(); ++i) {
|
|
dataPtr = &event->data[ event->eventdef->GetArgOffset( i ) ];
|
|
switch( format[ i ] ) {
|
|
case D_EVENT_FLOAT :
|
|
savefile->WriteFloat( *reinterpret_cast<float *>( dataPtr ) );
|
|
size += sizeof( float );
|
|
break;
|
|
case D_EVENT_INTEGER :
|
|
case D_EVENT_ENTITY :
|
|
case D_EVENT_ENTITY_NULL :
|
|
savefile->WriteInt( *reinterpret_cast<int *>( dataPtr ) );
|
|
size += sizeof( int );
|
|
break;
|
|
case D_EVENT_VECTOR :
|
|
savefile->WriteVec3( *reinterpret_cast<idVec3 *>( dataPtr ) );
|
|
size += sizeof( idVec3 );
|
|
break;
|
|
case D_EVENT_TRACE :
|
|
validTrace = *reinterpret_cast<bool *>( dataPtr );
|
|
savefile->WriteBool( validTrace );
|
|
size += sizeof( bool );
|
|
if ( validTrace ) {
|
|
size += sizeof( trace_t );
|
|
const trace_t &t = *reinterpret_cast<trace_t *>( dataPtr + sizeof( bool ) );
|
|
SaveTrace( savefile, t );
|
|
if ( t.c.material ) {
|
|
size += MAX_STRING_LEN;
|
|
str = reinterpret_cast<char *>( dataPtr + sizeof( bool ) + sizeof( trace_t ) );
|
|
savefile->Write( str, MAX_STRING_LEN );
|
|
}
|
|
}
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
assert( size == event->eventdef->GetArgSize() );
|
|
event = event->eventNode.Next();
|
|
}
|
|
}
|
|
|
|
/*
|
|
================
|
|
idEvent::Restore
|
|
================
|
|
*/
|
|
void idEvent::Restore( idRestoreGame *savefile ) {
|
|
char *str;
|
|
int num, argsize, i, j, size;
|
|
idStr name;
|
|
byte *dataPtr;
|
|
idEvent *event;
|
|
const char *format;
|
|
|
|
savefile->ReadInt( num );
|
|
|
|
for ( i = 0; i < num; i++ ) {
|
|
if ( FreeEvents.IsListEmpty() ) {
|
|
gameLocal.Error( "idEvent::Restore : No more free events" );
|
|
}
|
|
|
|
event = FreeEvents.Next();
|
|
event->eventNode.Remove();
|
|
event->eventNode.AddToEnd( EventQueue );
|
|
|
|
savefile->ReadInt( event->time );
|
|
|
|
// read the event name
|
|
savefile->ReadString( name );
|
|
event->eventdef = idEventDef::FindEvent( name );
|
|
if ( !event->eventdef ) {
|
|
savefile->Error( "idEvent::Restore: unknown event '%s'", name.c_str() );
|
|
}
|
|
|
|
// read the classtype
|
|
savefile->ReadString( name );
|
|
event->typeinfo = idClass::GetClass( name );
|
|
if ( !event->typeinfo ) {
|
|
savefile->Error( "idEvent::Restore: unknown class '%s' on event '%s'", name.c_str(), event->eventdef->GetName() );
|
|
}
|
|
|
|
savefile->ReadObject( event->object );
|
|
|
|
// read the args
|
|
savefile->ReadInt( argsize );
|
|
if ( argsize != event->eventdef->GetArgSize() ) {
|
|
savefile->Error( "idEvent::Restore: arg size (%d) doesn't match saved arg size(%d) on event '%s'", event->eventdef->GetArgSize(), argsize, event->eventdef->GetName() );
|
|
}
|
|
if ( argsize ) {
|
|
event->data = eventDataAllocator.Alloc( argsize );
|
|
format = event->eventdef->GetArgFormat();
|
|
assert( format );
|
|
for ( j = 0, size = 0; j < event->eventdef->GetNumArgs(); ++j) {
|
|
dataPtr = &event->data[ event->eventdef->GetArgOffset( j ) ];
|
|
switch( format[ j ] ) {
|
|
case D_EVENT_FLOAT :
|
|
savefile->ReadFloat( *reinterpret_cast<float *>( dataPtr ) );
|
|
size += sizeof( float );
|
|
break;
|
|
case D_EVENT_INTEGER :
|
|
case D_EVENT_ENTITY :
|
|
case D_EVENT_ENTITY_NULL :
|
|
savefile->ReadInt( *reinterpret_cast<int *>( dataPtr ) );
|
|
size += sizeof( int );
|
|
break;
|
|
case D_EVENT_VECTOR :
|
|
savefile->ReadVec3( *reinterpret_cast<idVec3 *>( dataPtr ) );
|
|
size += sizeof( idVec3 );
|
|
break;
|
|
case D_EVENT_TRACE :
|
|
savefile->ReadBool( *reinterpret_cast<bool *>( dataPtr ) );
|
|
size += sizeof( bool );
|
|
if ( *reinterpret_cast<bool *>( dataPtr ) ) {
|
|
size += sizeof( trace_t );
|
|
trace_t &t = *reinterpret_cast<trace_t *>( dataPtr + sizeof( bool ) );
|
|
RestoreTrace( savefile, t) ;
|
|
if ( t.c.material ) {
|
|
size += MAX_STRING_LEN;
|
|
str = reinterpret_cast<char *>( dataPtr + sizeof( bool ) + sizeof( trace_t ) );
|
|
savefile->Read( str, MAX_STRING_LEN );
|
|
}
|
|
}
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
assert( size == event->eventdef->GetArgSize() );
|
|
} else {
|
|
event->data = NULL;
|
|
}
|
|
}
|
|
}
|
|
|
|
/*
|
|
================
|
|
idEvent::ReadTrace
|
|
|
|
idRestoreGame has a ReadTrace procedure, but unfortunately idEvent wants the material
|
|
string name at the of the data structure rather than in the middle
|
|
================
|
|
*/
|
|
void idEvent::RestoreTrace( idRestoreGame *savefile, trace_t &trace ) {
|
|
savefile->ReadFloat( trace.fraction );
|
|
savefile->ReadVec3( trace.endpos );
|
|
savefile->ReadMat3( trace.endAxis );
|
|
savefile->ReadInt( (int&)trace.c.type );
|
|
savefile->ReadVec3( trace.c.point );
|
|
savefile->ReadVec3( trace.c.normal );
|
|
savefile->ReadFloat( trace.c.dist );
|
|
savefile->ReadInt( trace.c.contents );
|
|
savefile->ReadInt( (int&)trace.c.material );
|
|
savefile->ReadInt( trace.c.contents );
|
|
savefile->ReadInt( trace.c.modelFeature );
|
|
savefile->ReadInt( trace.c.trmFeature );
|
|
savefile->ReadInt( trace.c.id );
|
|
}
|
|
|
|
/*
|
|
================
|
|
idEvent::WriteTrace
|
|
|
|
idSaveGame has a WriteTrace procedure, but unfortunately idEvent wants the material
|
|
string name at the of the data structure rather than in the middle
|
|
================
|
|
*/
|
|
void idEvent::SaveTrace( idSaveGame *savefile, const trace_t &trace ) {
|
|
savefile->WriteFloat( trace.fraction );
|
|
savefile->WriteVec3( trace.endpos );
|
|
savefile->WriteMat3( trace.endAxis );
|
|
savefile->WriteInt( trace.c.type );
|
|
savefile->WriteVec3( trace.c.point );
|
|
savefile->WriteVec3( trace.c.normal );
|
|
savefile->WriteFloat( trace.c.dist );
|
|
savefile->WriteInt( trace.c.contents );
|
|
savefile->WriteInt( (int&)trace.c.material );
|
|
savefile->WriteInt( trace.c.contents );
|
|
savefile->WriteInt( trace.c.modelFeature );
|
|
savefile->WriteInt( trace.c.trmFeature );
|
|
savefile->WriteInt( trace.c.id );
|
|
}
|
|
|
|
|
|
|
|
#ifdef CREATE_EVENT_CODE
|
|
/*
|
|
================
|
|
CreateEventCallbackHandler
|
|
================
|
|
*/
|
|
void CreateEventCallbackHandler( void ) {
|
|
int num;
|
|
int count;
|
|
int i, j, k;
|
|
char argString[ D_EVENT_MAXARGS + 1 ];
|
|
idStr string1;
|
|
idStr string2;
|
|
idFile *file;
|
|
|
|
file = fileSystem->OpenFileWrite( "Callbacks.cpp" );
|
|
|
|
file->Printf( "// generated file - see CREATE_EVENT_CODE\n\n" );
|
|
|
|
for( i = 1; i <= D_EVENT_MAXARGS; i++ ) {
|
|
|
|
file->Printf( "\t/*******************************************************\n\n\t\t%d args\n\n\t*******************************************************/\n\n", i );
|
|
|
|
for ( j = 0; j < ( 1 << i ); j++ ) {
|
|
for ( k = 0; k < i; k++ ) {
|
|
argString[ k ] = j & ( 1 << k ) ? 'f' : 'i';
|
|
}
|
|
argString[ i ] = '\0';
|
|
|
|
string1.Empty();
|
|
string2.Empty();
|
|
|
|
for( k = 0; k < i; k++ ) {
|
|
if ( j & ( 1 << k ) ) {
|
|
string1 += "const float";
|
|
string2 += va( "*( float * )&data[ %d ]", k );
|
|
} else {
|
|
string1 += "const intptr_t";
|
|
string2 += va( "data[ %d ]", k );
|
|
}
|
|
|
|
if ( k < i - 1 ) {
|
|
string1 += ", ";
|
|
string2 += ", ";
|
|
}
|
|
}
|
|
|
|
file->Printf( "\tcase %d :\n\t\ttypedef void ( idClass::*eventCallback_%s_t )( %s );\n", ( 1 << ( i + D_EVENT_MAXARGS ) ) + j, argString, string1.c_str() );
|
|
file->Printf( "\t\t( this->*( eventCallback_%s_t )callback )( %s );\n\t\tbreak;\n\n", argString, string2.c_str() );
|
|
|
|
}
|
|
}
|
|
|
|
fileSystem->CloseFile( file );
|
|
}
|
|
|
|
#endif
|