DOOM-3-BFG/neo/sys/SnapshotProcessor.h

/*
===========================================================================

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__ */