blendo
/
quadrilateralcowboy
mirror of https://github.com/blendogames/quadrilateralcowboy.git
0
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
quadrilateralcowboy/renderer/RenderWorld_demo.cpp

730 lines
21 KiB
C++
Raw Normal View History

Initial commit
2020-06-12 21:06:25 +00:00
/*
===========================================================================
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 "../idlib/precompiled.h"
#pragma hdrstop
#include "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" );
}
}