mirror of
https://github.com/dhewm/dhewm3.git
synced 2024-11-27 14:42:23 +00:00
736ec20d4d
Don't include the lazy precompiled.h everywhere, only what's required for the compilation unit. platform.h needs to be included instead to provide all essential defines and types. All includes use the relative path to the neo or the game specific root. Move all idlib related includes from idlib/Lib.h to precompiled.h. precompiled.h still exists for the MFC stuff in tools/. Add some missing header guards.
739 lines
22 KiB
C++
739 lines
22 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.
|
|
|
|
===========================================================================
|
|
*/
|
|
|
|
#include "sys/platform.h"
|
|
#include "idlib/geometry/JointTransform.h"
|
|
#include "framework/DeclSkin.h"
|
|
#include "framework/DemoFile.h"
|
|
#include "framework/EventLoop.h"
|
|
#include "framework/Session.h"
|
|
#include "renderer/GuiModel.h"
|
|
#include "renderer/ModelManager.h"
|
|
#include "renderer/RenderWorld_local.h"
|
|
#include "ui/UserInterface.h"
|
|
#include "sound/sound.h"
|
|
|
|
#include "renderer/tr_local.h"
|
|
|
|
//#define WRITE_GUIS
|
|
|
|
typedef struct {
|
|
int version;
|
|
int sizeofRenderEntity;
|
|
int sizeofRenderLight;
|
|
char mapname[256];
|
|
} demoHeader_t;
|
|
|
|
|
|
/*
|
|
==============
|
|
StartWritingDemo
|
|
==============
|
|
*/
|
|
void idRenderWorldLocal::StartWritingDemo( idDemoFile *demo ) {
|
|
int i;
|
|
|
|
// FIXME: we should track the idDemoFile locally, instead of snooping into session for it
|
|
|
|
WriteLoadMap();
|
|
|
|
// write the door portal state
|
|
for ( i = 0 ; i < numInterAreaPortals ; i++ ) {
|
|
if ( doublePortals[i].blockingBits ) {
|
|
SetPortalState( i+1, doublePortals[i].blockingBits );
|
|
}
|
|
}
|
|
|
|
// clear the archive counter on all defs
|
|
for ( i = 0 ; i < lightDefs.Num() ; i++ ) {
|
|
if ( lightDefs[i] ) {
|
|
lightDefs[i]->archived = false;
|
|
}
|
|
}
|
|
for ( i = 0 ; i < entityDefs.Num() ; i++ ) {
|
|
if ( entityDefs[i] ) {
|
|
entityDefs[i]->archived = false;
|
|
}
|
|
}
|
|
}
|
|
|
|
void idRenderWorldLocal::StopWritingDemo() {
|
|
// writeDemo = NULL;
|
|
}
|
|
|
|
/*
|
|
==============
|
|
ProcessDemoCommand
|
|
==============
|
|
*/
|
|
bool idRenderWorldLocal::ProcessDemoCommand( idDemoFile *readDemo, renderView_t *renderView, int *demoTimeOffset ) {
|
|
bool newMap = false;
|
|
|
|
if ( !readDemo ) {
|
|
return false;
|
|
}
|
|
|
|
demoCommand_t dc;
|
|
qhandle_t h;
|
|
|
|
if ( !readDemo->ReadInt( (int&)dc ) ) {
|
|
// a demoShot may not have an endFrame, but it is still valid
|
|
return false;
|
|
}
|
|
|
|
switch( dc ) {
|
|
case DC_LOADMAP:
|
|
// read the initial data
|
|
demoHeader_t header;
|
|
|
|
readDemo->ReadInt( header.version );
|
|
readDemo->ReadInt( header.sizeofRenderEntity );
|
|
readDemo->ReadInt( header.sizeofRenderLight );
|
|
for ( int i = 0; i < 256; i++ )
|
|
readDemo->ReadChar( header.mapname[i] );
|
|
// the internal version value got replaced by DS_VERSION at toplevel
|
|
if ( header.version != 4 ) {
|
|
common->Error( "Demo version mismatch.\n" );
|
|
}
|
|
|
|
if ( r_showDemo.GetBool() ) {
|
|
common->Printf( "DC_LOADMAP: %s\n", header.mapname );
|
|
}
|
|
InitFromMap( header.mapname );
|
|
|
|
newMap = true; // we will need to set demoTimeOffset
|
|
|
|
break;
|
|
|
|
case DC_RENDERVIEW:
|
|
readDemo->ReadInt( renderView->viewID );
|
|
readDemo->ReadInt( renderView->x );
|
|
readDemo->ReadInt( renderView->y );
|
|
readDemo->ReadInt( renderView->width );
|
|
readDemo->ReadInt( renderView->height );
|
|
readDemo->ReadFloat( renderView->fov_x );
|
|
readDemo->ReadFloat( renderView->fov_y );
|
|
readDemo->ReadVec3( renderView->vieworg );
|
|
readDemo->ReadMat3( renderView->viewaxis );
|
|
readDemo->ReadBool( renderView->cramZNear );
|
|
readDemo->ReadBool( renderView->forceUpdate );
|
|
// binary compatibility with win32 padded structures
|
|
char tmp;
|
|
readDemo->ReadChar( tmp );
|
|
readDemo->ReadChar( tmp );
|
|
readDemo->ReadInt( renderView->time );
|
|
for ( int i = 0; i < MAX_GLOBAL_SHADER_PARMS; i++ )
|
|
readDemo->ReadFloat( renderView->shaderParms[i] );
|
|
|
|
if ( !readDemo->ReadInt( (int&)renderView->globalMaterial ) ) {
|
|
return false;
|
|
}
|
|
|
|
if ( r_showDemo.GetBool() ) {
|
|
common->Printf( "DC_RENDERVIEW: %i\n", renderView->time );
|
|
}
|
|
|
|
// possibly change the time offset if this is from a new map
|
|
if ( newMap && demoTimeOffset ) {
|
|
*demoTimeOffset = renderView->time - eventLoop->Milliseconds();
|
|
}
|
|
return false;
|
|
|
|
case DC_UPDATE_ENTITYDEF:
|
|
ReadRenderEntity();
|
|
break;
|
|
case DC_DELETE_ENTITYDEF:
|
|
if ( !readDemo->ReadInt( h ) ) {
|
|
return false;
|
|
}
|
|
if ( r_showDemo.GetBool() ) {
|
|
common->Printf( "DC_DELETE_ENTITYDEF: %i\n", h );
|
|
}
|
|
FreeEntityDef( h );
|
|
break;
|
|
case DC_UPDATE_LIGHTDEF:
|
|
ReadRenderLight();
|
|
break;
|
|
case DC_DELETE_LIGHTDEF:
|
|
if ( !readDemo->ReadInt( h ) ) {
|
|
return false;
|
|
}
|
|
if ( r_showDemo.GetBool() ) {
|
|
common->Printf( "DC_DELETE_LIGHTDEF: %i\n", h );
|
|
}
|
|
FreeLightDef( h );
|
|
break;
|
|
|
|
case DC_CAPTURE_RENDER:
|
|
if ( r_showDemo.GetBool() ) {
|
|
common->Printf( "DC_CAPTURE_RENDER\n" );
|
|
}
|
|
renderSystem->CaptureRenderToImage( readDemo->ReadHashString() );
|
|
break;
|
|
|
|
case DC_CROP_RENDER:
|
|
if ( r_showDemo.GetBool() ) {
|
|
common->Printf( "DC_CROP_RENDER\n" );
|
|
}
|
|
int size[3];
|
|
readDemo->ReadInt( size[0] );
|
|
readDemo->ReadInt( size[1] );
|
|
readDemo->ReadInt( size[2] );
|
|
renderSystem->CropRenderSize( size[0], size[1], size[2] != 0 );
|
|
break;
|
|
|
|
case DC_UNCROP_RENDER:
|
|
if ( r_showDemo.GetBool() ) {
|
|
common->Printf( "DC_UNCROP\n" );
|
|
}
|
|
renderSystem->UnCrop();
|
|
break;
|
|
|
|
case DC_GUI_MODEL:
|
|
if ( r_showDemo.GetBool() ) {
|
|
common->Printf( "DC_GUI_MODEL\n" );
|
|
}
|
|
tr.demoGuiModel->ReadFromDemo( readDemo );
|
|
break;
|
|
|
|
case DC_DEFINE_MODEL:
|
|
{
|
|
idRenderModel *model = renderModelManager->AllocModel();
|
|
model->ReadFromDemoFile( session->readDemo );
|
|
// add to model manager, so we can find it
|
|
renderModelManager->AddModel( model );
|
|
|
|
// save it in the list to free when clearing this map
|
|
localModels.Append( model );
|
|
|
|
if ( r_showDemo.GetBool() ) {
|
|
common->Printf( "DC_DEFINE_MODEL\n" );
|
|
}
|
|
break;
|
|
}
|
|
case DC_SET_PORTAL_STATE:
|
|
{
|
|
int data[2];
|
|
readDemo->ReadInt( data[0] );
|
|
readDemo->ReadInt( data[1] );
|
|
SetPortalState( data[0], data[1] );
|
|
if ( r_showDemo.GetBool() ) {
|
|
common->Printf( "DC_SET_PORTAL_STATE: %i %i\n", data[0], data[1] );
|
|
}
|
|
}
|
|
|
|
break;
|
|
case DC_END_FRAME:
|
|
return true;
|
|
|
|
default:
|
|
common->Error( "Bad token in demo stream" );
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
/*
|
|
================
|
|
WriteLoadMap
|
|
================
|
|
*/
|
|
void idRenderWorldLocal::WriteLoadMap() {
|
|
|
|
// only the main renderWorld writes stuff to demos, not the wipes or
|
|
// menu renders
|
|
if ( this != session->rw ) {
|
|
return;
|
|
}
|
|
|
|
session->writeDemo->WriteInt( DS_RENDER );
|
|
session->writeDemo->WriteInt( DC_LOADMAP );
|
|
|
|
demoHeader_t header;
|
|
strncpy( header.mapname, mapName.c_str(), sizeof( header.mapname ) - 1 );
|
|
header.version = 4;
|
|
header.sizeofRenderEntity = sizeof( renderEntity_t );
|
|
header.sizeofRenderLight = sizeof( renderLight_t );
|
|
session->writeDemo->WriteInt( header.version );
|
|
session->writeDemo->WriteInt( header.sizeofRenderEntity );
|
|
session->writeDemo->WriteInt( header.sizeofRenderLight );
|
|
for ( int i = 0; i < 256; i++ )
|
|
session->writeDemo->WriteChar( header.mapname[i] );
|
|
|
|
if ( r_showDemo.GetBool() ) {
|
|
common->Printf( "write DC_DELETE_LIGHTDEF: %s\n", mapName.c_str() );
|
|
}
|
|
}
|
|
|
|
/*
|
|
================
|
|
WriteVisibleDefs
|
|
|
|
================
|
|
*/
|
|
void idRenderWorldLocal::WriteVisibleDefs( const viewDef_t *viewDef ) {
|
|
// only the main renderWorld writes stuff to demos, not the wipes or
|
|
// menu renders
|
|
if ( this != session->rw ) {
|
|
return;
|
|
}
|
|
|
|
// make sure all necessary entities and lights are updated
|
|
for ( viewEntity_t *viewEnt = viewDef->viewEntitys ; viewEnt ; viewEnt = viewEnt->next ) {
|
|
idRenderEntityLocal *ent = viewEnt->entityDef;
|
|
|
|
if ( ent->archived ) {
|
|
// still up to date
|
|
continue;
|
|
}
|
|
|
|
// write it out
|
|
WriteRenderEntity( ent->index, &ent->parms );
|
|
ent->archived = true;
|
|
}
|
|
|
|
for ( viewLight_t *viewLight = viewDef->viewLights ; viewLight ; viewLight = viewLight->next ) {
|
|
idRenderLightLocal *light = viewLight->lightDef;
|
|
|
|
if ( light->archived ) {
|
|
// still up to date
|
|
continue;
|
|
}
|
|
// write it out
|
|
WriteRenderLight( light->index, &light->parms );
|
|
light->archived = true;
|
|
}
|
|
}
|
|
|
|
|
|
/*
|
|
================
|
|
WriteRenderView
|
|
================
|
|
*/
|
|
void idRenderWorldLocal::WriteRenderView( const renderView_t *renderView ) {
|
|
int i;
|
|
|
|
// only the main renderWorld writes stuff to demos, not the wipes or
|
|
// menu renders
|
|
if ( this != session->rw ) {
|
|
return;
|
|
}
|
|
|
|
// write the actual view command
|
|
session->writeDemo->WriteInt( DS_RENDER );
|
|
session->writeDemo->WriteInt( DC_RENDERVIEW );
|
|
session->writeDemo->WriteInt( renderView->viewID );
|
|
session->writeDemo->WriteInt( renderView->x );
|
|
session->writeDemo->WriteInt( renderView->y );
|
|
session->writeDemo->WriteInt( renderView->width );
|
|
session->writeDemo->WriteInt( renderView->height );
|
|
session->writeDemo->WriteFloat( renderView->fov_x );
|
|
session->writeDemo->WriteFloat( renderView->fov_y );
|
|
session->writeDemo->WriteVec3( renderView->vieworg );
|
|
session->writeDemo->WriteMat3( renderView->viewaxis );
|
|
session->writeDemo->WriteBool( renderView->cramZNear );
|
|
session->writeDemo->WriteBool( renderView->forceUpdate );
|
|
// binary compatibility with old win32 version writing padded structures directly to disk
|
|
session->writeDemo->WriteUnsignedChar( 0 );
|
|
session->writeDemo->WriteUnsignedChar( 0 );
|
|
session->writeDemo->WriteInt( renderView->time );
|
|
for ( i = 0; i < MAX_GLOBAL_SHADER_PARMS; i++ )
|
|
session->writeDemo->WriteFloat( renderView->shaderParms[i] );
|
|
session->writeDemo->WriteInt( (int&)renderView->globalMaterial );
|
|
|
|
if ( r_showDemo.GetBool() ) {
|
|
common->Printf( "write DC_RENDERVIEW: %i\n", renderView->time );
|
|
}
|
|
}
|
|
|
|
/*
|
|
================
|
|
WriteFreeEntity
|
|
================
|
|
*/
|
|
void idRenderWorldLocal::WriteFreeEntity( qhandle_t handle ) {
|
|
|
|
// only the main renderWorld writes stuff to demos, not the wipes or
|
|
// menu renders
|
|
if ( this != session->rw ) {
|
|
return;
|
|
}
|
|
|
|
session->writeDemo->WriteInt( DS_RENDER );
|
|
session->writeDemo->WriteInt( DC_DELETE_ENTITYDEF );
|
|
session->writeDemo->WriteInt( handle );
|
|
|
|
if ( r_showDemo.GetBool() ) {
|
|
common->Printf( "write DC_DELETE_ENTITYDEF: %i\n", handle );
|
|
}
|
|
}
|
|
|
|
/*
|
|
================
|
|
WriteFreeLightEntity
|
|
================
|
|
*/
|
|
void idRenderWorldLocal::WriteFreeLight( qhandle_t handle ) {
|
|
|
|
// only the main renderWorld writes stuff to demos, not the wipes or
|
|
// menu renders
|
|
if ( this != session->rw ) {
|
|
return;
|
|
}
|
|
|
|
session->writeDemo->WriteInt( DS_RENDER );
|
|
session->writeDemo->WriteInt( DC_DELETE_LIGHTDEF );
|
|
session->writeDemo->WriteInt( handle );
|
|
|
|
if ( r_showDemo.GetBool() ) {
|
|
common->Printf( "write DC_DELETE_LIGHTDEF: %i\n", handle );
|
|
}
|
|
}
|
|
|
|
/*
|
|
================
|
|
WriteRenderLight
|
|
================
|
|
*/
|
|
void idRenderWorldLocal::WriteRenderLight( qhandle_t handle, const renderLight_t *light ) {
|
|
|
|
// only the main renderWorld writes stuff to demos, not the wipes or
|
|
// menu renders
|
|
if ( this != session->rw ) {
|
|
return;
|
|
}
|
|
|
|
session->writeDemo->WriteInt( DS_RENDER );
|
|
session->writeDemo->WriteInt( DC_UPDATE_LIGHTDEF );
|
|
session->writeDemo->WriteInt( handle );
|
|
|
|
session->writeDemo->WriteMat3( light->axis );
|
|
session->writeDemo->WriteVec3( light->origin );
|
|
session->writeDemo->WriteInt( light->suppressLightInViewID );
|
|
session->writeDemo->WriteInt( light->allowLightInViewID );
|
|
session->writeDemo->WriteBool( light->noShadows );
|
|
session->writeDemo->WriteBool( light->noSpecular );
|
|
session->writeDemo->WriteBool( light->pointLight );
|
|
session->writeDemo->WriteBool( light->parallel );
|
|
session->writeDemo->WriteVec3( light->lightRadius );
|
|
session->writeDemo->WriteVec3( light->lightCenter );
|
|
session->writeDemo->WriteVec3( light->target );
|
|
session->writeDemo->WriteVec3( light->right );
|
|
session->writeDemo->WriteVec3( light->up );
|
|
session->writeDemo->WriteVec3( light->start );
|
|
session->writeDemo->WriteVec3( light->end );
|
|
session->writeDemo->WriteInt( (int&)light->prelightModel );
|
|
session->writeDemo->WriteInt( light->lightId );
|
|
session->writeDemo->WriteInt( (int&)light->shader );
|
|
for ( int i = 0; i < MAX_ENTITY_SHADER_PARMS; i++)
|
|
session->writeDemo->WriteFloat( light->shaderParms[i] );
|
|
session->writeDemo->WriteInt( (int&)light->referenceSound );
|
|
|
|
if ( light->prelightModel ) {
|
|
session->writeDemo->WriteHashString( light->prelightModel->Name() );
|
|
}
|
|
if ( light->shader ) {
|
|
session->writeDemo->WriteHashString( light->shader->GetName() );
|
|
}
|
|
if ( light->referenceSound ) {
|
|
int index = light->referenceSound->Index();
|
|
session->writeDemo->WriteInt( index );
|
|
}
|
|
|
|
if ( r_showDemo.GetBool() ) {
|
|
common->Printf( "write DC_UPDATE_LIGHTDEF: %i\n", handle );
|
|
}
|
|
}
|
|
|
|
/*
|
|
================
|
|
ReadRenderLight
|
|
================
|
|
*/
|
|
void idRenderWorldLocal::ReadRenderLight( ) {
|
|
renderLight_t light;
|
|
int index;
|
|
|
|
session->readDemo->ReadInt( index );
|
|
if ( index < 0 ) {
|
|
common->Error( "ReadRenderLight: index < 0 " );
|
|
}
|
|
|
|
session->readDemo->ReadMat3( light.axis );
|
|
session->readDemo->ReadVec3( light.origin );
|
|
session->readDemo->ReadInt( light.suppressLightInViewID );
|
|
session->readDemo->ReadInt( light.allowLightInViewID );
|
|
session->readDemo->ReadBool( light.noShadows );
|
|
session->readDemo->ReadBool( light.noSpecular );
|
|
session->readDemo->ReadBool( light.pointLight );
|
|
session->readDemo->ReadBool( light.parallel );
|
|
session->readDemo->ReadVec3( light.lightRadius );
|
|
session->readDemo->ReadVec3( light.lightCenter );
|
|
session->readDemo->ReadVec3( light.target );
|
|
session->readDemo->ReadVec3( light.right );
|
|
session->readDemo->ReadVec3( light.up );
|
|
session->readDemo->ReadVec3( light.start );
|
|
session->readDemo->ReadVec3( light.end );
|
|
session->readDemo->ReadInt( (int&)light.prelightModel );
|
|
session->readDemo->ReadInt( light.lightId );
|
|
session->readDemo->ReadInt( (int&)light.shader );
|
|
for ( int i = 0; i < MAX_ENTITY_SHADER_PARMS; i++)
|
|
session->readDemo->ReadFloat( light.shaderParms[i] );
|
|
session->readDemo->ReadInt( (int&)light.referenceSound );
|
|
if ( light.prelightModel ) {
|
|
light.prelightModel = renderModelManager->FindModel( session->readDemo->ReadHashString() );
|
|
}
|
|
if ( light.shader ) {
|
|
light.shader = declManager->FindMaterial( session->readDemo->ReadHashString() );
|
|
}
|
|
if ( light.referenceSound ) {
|
|
int index;
|
|
session->readDemo->ReadInt( index );
|
|
light.referenceSound = session->sw->EmitterForIndex( index );
|
|
}
|
|
|
|
UpdateLightDef( index, &light );
|
|
|
|
if ( r_showDemo.GetBool() ) {
|
|
common->Printf( "DC_UPDATE_LIGHTDEF: %i\n", index );
|
|
}
|
|
}
|
|
|
|
/*
|
|
================
|
|
WriteRenderEntity
|
|
================
|
|
*/
|
|
void idRenderWorldLocal::WriteRenderEntity( qhandle_t handle, const renderEntity_t *ent ) {
|
|
|
|
// only the main renderWorld writes stuff to demos, not the wipes or
|
|
// menu renders
|
|
if ( this != session->rw ) {
|
|
return;
|
|
}
|
|
|
|
session->writeDemo->WriteInt( DS_RENDER );
|
|
session->writeDemo->WriteInt( DC_UPDATE_ENTITYDEF );
|
|
session->writeDemo->WriteInt( handle );
|
|
|
|
session->writeDemo->WriteInt( (int&)ent->hModel );
|
|
session->writeDemo->WriteInt( ent->entityNum );
|
|
session->writeDemo->WriteInt( ent->bodyId );
|
|
session->writeDemo->WriteVec3( ent->bounds[0] );
|
|
session->writeDemo->WriteVec3( ent->bounds[1] );
|
|
session->writeDemo->WriteInt( (int&)ent->callback );
|
|
session->writeDemo->WriteInt( (int&)ent->callbackData );
|
|
session->writeDemo->WriteInt( ent->suppressSurfaceInViewID );
|
|
session->writeDemo->WriteInt( ent->suppressShadowInViewID );
|
|
session->writeDemo->WriteInt( ent->suppressShadowInLightID );
|
|
session->writeDemo->WriteInt( ent->allowSurfaceInViewID );
|
|
session->writeDemo->WriteVec3( ent->origin );
|
|
session->writeDemo->WriteMat3( ent->axis );
|
|
session->writeDemo->WriteInt( (int&)ent->customShader );
|
|
session->writeDemo->WriteInt( (int&)ent->referenceShader );
|
|
session->writeDemo->WriteInt( (int&)ent->customSkin );
|
|
session->writeDemo->WriteInt( (int&)ent->referenceSound );
|
|
for ( int i = 0; i < MAX_ENTITY_SHADER_PARMS; i++ )
|
|
session->writeDemo->WriteFloat( ent->shaderParms[i] );
|
|
for ( int i = 0; i < MAX_RENDERENTITY_GUI; i++ )
|
|
session->writeDemo->WriteInt( (int&)ent->gui[i] );
|
|
session->writeDemo->WriteInt( (int&)ent->remoteRenderView );
|
|
session->writeDemo->WriteInt( ent->numJoints );
|
|
session->writeDemo->WriteInt( (int&)ent->joints );
|
|
session->writeDemo->WriteFloat( ent->modelDepthHack );
|
|
session->writeDemo->WriteBool( ent->noSelfShadow );
|
|
session->writeDemo->WriteBool( ent->noShadow );
|
|
session->writeDemo->WriteBool( ent->noDynamicInteractions );
|
|
session->writeDemo->WriteBool( ent->weaponDepthHack );
|
|
session->writeDemo->WriteInt( ent->forceUpdate );
|
|
|
|
if ( ent->customShader ) {
|
|
session->writeDemo->WriteHashString( ent->customShader->GetName() );
|
|
}
|
|
if ( ent->customSkin ) {
|
|
session->writeDemo->WriteHashString( ent->customSkin->GetName() );
|
|
}
|
|
if ( ent->hModel ) {
|
|
session->writeDemo->WriteHashString( ent->hModel->Name() );
|
|
}
|
|
if ( ent->referenceShader ) {
|
|
session->writeDemo->WriteHashString( ent->referenceShader->GetName() );
|
|
}
|
|
if ( ent->referenceSound ) {
|
|
int index = ent->referenceSound->Index();
|
|
session->writeDemo->WriteInt( index );
|
|
}
|
|
if ( ent->numJoints ) {
|
|
for ( int i = 0; i < ent->numJoints; i++) {
|
|
float *data = ent->joints[i].ToFloatPtr();
|
|
for ( int j = 0; j < 12; ++j)
|
|
session->writeDemo->WriteFloat( data[j] );
|
|
}
|
|
}
|
|
|
|
/*
|
|
if ( ent->decals ) {
|
|
ent->decals->WriteToDemoFile( session->readDemo );
|
|
}
|
|
if ( ent->overlay ) {
|
|
ent->overlay->WriteToDemoFile( session->writeDemo );
|
|
}
|
|
*/
|
|
|
|
#ifdef WRITE_GUIS
|
|
if ( ent->gui ) {
|
|
ent->gui->WriteToDemoFile( session->writeDemo );
|
|
}
|
|
if ( ent->gui2 ) {
|
|
ent->gui2->WriteToDemoFile( session->writeDemo );
|
|
}
|
|
if ( ent->gui3 ) {
|
|
ent->gui3->WriteToDemoFile( session->writeDemo );
|
|
}
|
|
#endif
|
|
|
|
// RENDERDEMO_VERSION >= 2 ( Doom3 1.2 )
|
|
session->writeDemo->WriteInt( ent->timeGroup );
|
|
session->writeDemo->WriteInt( ent->xrayIndex );
|
|
|
|
if ( r_showDemo.GetBool() ) {
|
|
common->Printf( "write DC_UPDATE_ENTITYDEF: %i = %s\n", handle, ent->hModel ? ent->hModel->Name() : "NULL" );
|
|
}
|
|
}
|
|
|
|
/*
|
|
================
|
|
ReadRenderEntity
|
|
================
|
|
*/
|
|
void idRenderWorldLocal::ReadRenderEntity() {
|
|
renderEntity_t ent;
|
|
int index, i;
|
|
|
|
session->readDemo->ReadInt( index );
|
|
if ( index < 0 ) {
|
|
common->Error( "ReadRenderEntity: index < 0" );
|
|
}
|
|
|
|
session->readDemo->ReadInt( (int&)ent.hModel );
|
|
session->readDemo->ReadInt( ent.entityNum );
|
|
session->readDemo->ReadInt( ent.bodyId );
|
|
session->readDemo->ReadVec3( ent.bounds[0] );
|
|
session->readDemo->ReadVec3( ent.bounds[1] );
|
|
session->readDemo->ReadInt( (int&)ent.callback );
|
|
session->readDemo->ReadInt( (int&)ent.callbackData );
|
|
session->readDemo->ReadInt( ent.suppressSurfaceInViewID );
|
|
session->readDemo->ReadInt( ent.suppressShadowInViewID );
|
|
session->readDemo->ReadInt( ent.suppressShadowInLightID );
|
|
session->readDemo->ReadInt( ent.allowSurfaceInViewID );
|
|
session->readDemo->ReadVec3( ent.origin );
|
|
session->readDemo->ReadMat3( ent.axis );
|
|
session->readDemo->ReadInt( (int&)ent.customShader );
|
|
session->readDemo->ReadInt( (int&)ent.referenceShader );
|
|
session->readDemo->ReadInt( (int&)ent.customSkin );
|
|
session->readDemo->ReadInt( (int&)ent.referenceSound );
|
|
for ( i = 0; i < MAX_ENTITY_SHADER_PARMS; i++ ) {
|
|
session->readDemo->ReadFloat( ent.shaderParms[i] );
|
|
}
|
|
for ( i = 0; i < MAX_RENDERENTITY_GUI; i++ ) {
|
|
session->readDemo->ReadInt( (int&)ent.gui[i] );
|
|
}
|
|
session->readDemo->ReadInt( (int&)ent.remoteRenderView );
|
|
session->readDemo->ReadInt( ent.numJoints );
|
|
session->readDemo->ReadInt( (int&)ent.joints );
|
|
session->readDemo->ReadFloat( ent.modelDepthHack );
|
|
session->readDemo->ReadBool( ent.noSelfShadow );
|
|
session->readDemo->ReadBool( ent.noShadow );
|
|
session->readDemo->ReadBool( ent.noDynamicInteractions );
|
|
session->readDemo->ReadBool( ent.weaponDepthHack );
|
|
session->readDemo->ReadInt( ent.forceUpdate );
|
|
ent.callback = NULL;
|
|
if ( ent.customShader ) {
|
|
ent.customShader = declManager->FindMaterial( session->readDemo->ReadHashString() );
|
|
}
|
|
if ( ent.customSkin ) {
|
|
ent.customSkin = declManager->FindSkin( session->readDemo->ReadHashString() );
|
|
}
|
|
if ( ent.hModel ) {
|
|
ent.hModel = renderModelManager->FindModel( session->readDemo->ReadHashString() );
|
|
}
|
|
if ( ent.referenceShader ) {
|
|
ent.referenceShader = declManager->FindMaterial( session->readDemo->ReadHashString() );
|
|
}
|
|
if ( ent.referenceSound ) {
|
|
int index;
|
|
session->readDemo->ReadInt( index );
|
|
ent.referenceSound = session->sw->EmitterForIndex( index );
|
|
}
|
|
if ( ent.numJoints ) {
|
|
ent.joints = (idJointMat *)Mem_Alloc16( ent.numJoints * sizeof( ent.joints[0] ) );
|
|
for ( int i = 0; i < ent.numJoints; i++) {
|
|
float *data = ent.joints[i].ToFloatPtr();
|
|
for ( int j = 0; j < 12; ++j)
|
|
session->readDemo->ReadFloat( data[j] );
|
|
}
|
|
}
|
|
|
|
ent.callbackData = NULL;
|
|
|
|
/*
|
|
if ( ent.decals ) {
|
|
ent.decals = idRenderModelDecal::Alloc();
|
|
ent.decals->ReadFromDemoFile( session->readDemo );
|
|
}
|
|
if ( ent.overlay ) {
|
|
ent.overlay = idRenderModelOverlay::Alloc();
|
|
ent.overlay->ReadFromDemoFile( session->readDemo );
|
|
}
|
|
*/
|
|
|
|
for ( i = 0; i < MAX_RENDERENTITY_GUI; i++ ) {
|
|
if ( ent.gui[ i ] ) {
|
|
ent.gui[ i ] = uiManager->Alloc();
|
|
#ifdef WRITE_GUIS
|
|
ent.gui[ i ]->ReadFromDemoFile( session->readDemo );
|
|
#endif
|
|
}
|
|
}
|
|
|
|
// >= Doom3 v1.2 only
|
|
if ( session->renderdemoVersion >= 2 ) {
|
|
session->readDemo->ReadInt( ent.timeGroup );
|
|
session->readDemo->ReadInt( ent.xrayIndex );
|
|
} else {
|
|
ent.timeGroup = 0;
|
|
ent.xrayIndex = 0;
|
|
}
|
|
|
|
UpdateEntityDef( index, &ent );
|
|
|
|
if ( r_showDemo.GetBool() ) {
|
|
common->Printf( "DC_UPDATE_ENTITYDEF: %i = %s\n", index, ent.hModel ? ent.hModel->Name() : "NULL" );
|
|
}
|
|
}
|