mirror of
https://github.com/id-Software/DOOM-3-BFG.git
synced 2026-03-20 09:00:25 +01:00
Initial commit
This commit is contained in:
Brian Harris
148
neo/sys/SnapshotProcessor.h
Normal file
148
neo/sys/SnapshotProcessor.h
Normal file
@@ -0,0 +1,148 @@
|
||||
/*
|
||||
===========================================================================
|
||||
|
||||
Doom 3 BFG Edition GPL Source Code
|
||||
Copyright (C) 1993-2012 id Software LLC, a ZeniMax Media company.
|
||||
|
||||
This file is part of the Doom 3 BFG Edition GPL Source Code ("Doom 3 BFG Edition Source Code").
|
||||
|
||||
Doom 3 BFG Edition 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 BFG Edition 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 BFG Edition Source Code. If not, see <http://www.gnu.org/licenses/>.
|
||||
|
||||
In addition, the Doom 3 BFG Edition 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 BFG Edition 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.
|
||||
|
||||
===========================================================================
|
||||
*/
|
||||
#ifndef __SNAP_PROCESSOR_H__
|
||||
#define __SNAP_PROCESSOR_H__
|
||||
|
||||
/*
|
||||
================================================
|
||||
idSnapshotProcessor
|
||||
================================================
|
||||
*/
|
||||
class idSnapshotProcessor {
|
||||
public:
|
||||
static const int INITIAL_SNAP_SEQUENCE = 42;
|
||||
|
||||
idSnapshotProcessor();
|
||||
~idSnapshotProcessor();
|
||||
|
||||
void Reset( bool cstor = false );
|
||||
|
||||
// TrySetPendingSnapshot Sets the currently pending snap.
|
||||
// No new snaps will be sent until this snap has been fully sent.
|
||||
// Returns true of the newly supplied snapshot was accepted (there were no pending snaps)
|
||||
bool TrySetPendingSnapshot( idSnapShot & ss );
|
||||
// Peek into delta to get deltaSequence, and deltaBaseSequence
|
||||
void PeekDeltaSequence( const char * deltaMem, int deltaSize, int & deltaSequence, int & deltaBaseSequence );
|
||||
// Apply a delta to the supplied snapshot
|
||||
bool ApplyDeltaToSnapshot( idSnapShot & snap, const char * deltaMem, int deltaSize, int visIndex );
|
||||
// Attempts to write the currently pending snap to the supplied buffer, which can then be sent as an unreliable msg.
|
||||
// SubmitPendingSnap will submit the pending snap to a job, so that it can be retrieved later for sending.
|
||||
void SubmitPendingSnap( int visIndex, uint8 * objMemory, int objMemorySize, lzwCompressionData_t * lzwData );
|
||||
// GetPendingSnapDelta
|
||||
int GetPendingSnapDelta( byte * outBuffer, int maxLength );
|
||||
// If PendingSnapReadyToSend is true, then GetPendingSnapDelta will return something to send
|
||||
bool PendingSnapReadyToSend() const { return jobMemory->lzwInOutData.numlzwDeltas > 0; }
|
||||
// When you call WritePendingSnapshot, and then send the resulting buffer as a unreliable msg, you will eventually
|
||||
// receive this on the client. Call this function to receive and apply it to the base state, and possibly return a fully received snap
|
||||
// to then apply to the client game state
|
||||
bool ReceiveSnapshotDelta( const byte * deltaData, int deltaLength, int visIndex, int & outSeq, int & outBaseSeq, idSnapShot & outSnap, bool & fullSnap );
|
||||
// Function to apply a received (or ack'd) delta to the base state
|
||||
bool ApplySnapshotDelta( int visIndex, int snapshotNumber );
|
||||
// Remove deltas for basestate we no longer have.
|
||||
// We know we can remove them, because we will never be able to apply them, since
|
||||
// the basestate needed to generate a full snap from these deltas is gone.
|
||||
void RemoveDeltasForOldBaseSequence();
|
||||
// Make sure delta sequence and basesequence values are valid, and in order, etc
|
||||
void SanityCheckDeltas();
|
||||
// HasPendingSnap will return true if there is more of the last TrySetPendingSnapshot to be sent
|
||||
bool HasPendingSnap() const { return hasPendingSnap; }
|
||||
|
||||
idSnapShot * GetBaseState() { return &baseState; }
|
||||
idSnapShot * GetPendingSnap(){ return &pendingSnap; }
|
||||
|
||||
int GetSnapSequence() { return snapSequence; }
|
||||
int GetBaseSequence() { return baseSequence; }
|
||||
int GetFullSnapBaseSequence() { return lastFullSnapBaseSequence; }
|
||||
|
||||
// This is used to ack the latest delta we have. If we have no deltas, we sent -1 to make sure
|
||||
// Server knows we don't want to ack, since we are as up to date as we can be
|
||||
int GetLastAppendedSequence() { return deltas.Num() == 0 ? -1 : deltas.ItemSequence( deltas.Num() - 1 ); }
|
||||
|
||||
int GetSnapQueueSize() { return deltas.Num(); }
|
||||
|
||||
bool IsBusyConfirmingPartialSnap();
|
||||
|
||||
void AddSnapObjTemplate( int objID, idBitMsg & msg );
|
||||
|
||||
static const int MAX_SNAPSHOT_QUEUE = 64;
|
||||
|
||||
private:
|
||||
|
||||
// Internal commands to set up, and flush the compressors
|
||||
static const int MAX_SNAP_SIZE = idPacketProcessor::MAX_MSG_SIZE;
|
||||
static const int MAX_SNAPSHOT_QUEUE_MEM = 64 * 1024; // 64k
|
||||
|
||||
// sequence number of the last snapshot we sent/received
|
||||
// on the server, the sequencing is different for each network peer (net_verboseSnapshot 1)
|
||||
// on the jobbed snapshot compression path, the sequence is incremented in NewLZWStream and pulled into this in idSnapshotProcessor::GetPendingSnapDelta
|
||||
int snapSequence;
|
||||
int baseSequence;
|
||||
int lastFullSnapBaseSequence; // Latest base sequence number that is a full snap
|
||||
|
||||
idSnapShot baseState; // known snapshot base on the client
|
||||
idDataQueue< MAX_SNAPSHOT_QUEUE, MAX_SNAPSHOT_QUEUE_MEM > deltas; // list of unacknowledged snapshot deltas
|
||||
|
||||
idSnapShot pendingSnap; // Current snap waiting to be fully sent
|
||||
bool hasPendingSnap; // true if pendingSnap is still waiting to be sent
|
||||
|
||||
struct jobMemory_t {
|
||||
static const int MAX_LZW_DELTAS = 1; // FIXME: cleanup the old multiple delta support completely
|
||||
|
||||
// @TODO this is a hack fix to allow online to load into coop (where there are lots of entities).
|
||||
// The real solution should be coming soon.
|
||||
// Doom MP: we encountered the same problem, going from 1024 to 4096 as well until a better solution is in place
|
||||
// (initial, useless, exchange of func_statics is killing us)
|
||||
static const int MAX_OBJ_PARMS = 4096;
|
||||
|
||||
static const int MAX_LZW_PARMS = 32;
|
||||
static const int MAX_OBJ_HEADERS = 256;
|
||||
static const int MAX_LZW_MEM = 1024 * 8; // 8k in the byte * lzwMem buffers, must be <= PS3_DMA_MAX
|
||||
|
||||
// Parm memory to jobs
|
||||
idArray<objParms_t, MAX_OBJ_PARMS> objParms;
|
||||
idArray<objHeader_t, MAX_OBJ_HEADERS> headers;
|
||||
idArray<lzwParm_t, MAX_LZW_PARMS> lzwParms;
|
||||
|
||||
// Output memory from jobs
|
||||
idArray<lzwDelta_t, MAX_LZW_DELTAS> lzwDeltas; // Info about each pending delta output from jobs
|
||||
idArray<byte, MAX_LZW_MEM> lzwMem; // Memory for output from lzw jobs
|
||||
|
||||
lzwInOutData_t lzwInOutData; // In/Out data used so lzw data can persist across lzw jobs
|
||||
};
|
||||
|
||||
jobMemory_t * jobMemory;
|
||||
|
||||
idSnapShot submittedState;
|
||||
|
||||
idSnapShot templateStates; // holds default snapshot states for some newly spawned object
|
||||
idSnapShot submittedTemplateStates;
|
||||
|
||||
int partialBaseSequence;
|
||||
};
|
||||
|
||||
#endif /* !__SNAP_PROCESSOR_H__ */
|
||||
Reference in New Issue
Block a user