133 lines
5.0 KiB
C++
Executable File
133 lines
5.0 KiB
C++
Executable File
//-----------------------------------------------------------------------------
|
|
// Torque Game Engine
|
|
// Copyright (C) GarageGames.com, Inc.
|
|
//-----------------------------------------------------------------------------
|
|
|
|
#ifndef _GAMEINTERFACE_H_
|
|
#define _GAMEINTERFACE_H_
|
|
|
|
#include "platform/event.h"
|
|
#include "core/tVector.h"
|
|
|
|
class FileStream;
|
|
|
|
class GameInterface
|
|
{
|
|
enum JournalMode {
|
|
JournalOff,
|
|
JournalSave,
|
|
JournalPlay,
|
|
};
|
|
JournalMode mJournalMode;
|
|
bool mRunning;
|
|
bool mJournalBreak;
|
|
bool mRequiresRestart;
|
|
|
|
/// Events are stored here by any thread, for processing by the main thread.
|
|
Vector<Event*> eventQueue1, eventQueue2, *eventQueue;
|
|
|
|
public:
|
|
GameInterface();
|
|
|
|
/// @name Platform Interface
|
|
/// The platform calls these functions to control execution of the game.
|
|
/// @{
|
|
virtual int main(int argc, const char **argv);
|
|
virtual void textureKill();
|
|
virtual void textureResurrect();
|
|
virtual void refreshWindow();
|
|
|
|
/// Place an event in Game's event queue.
|
|
virtual void postEvent(Event &event);
|
|
/// Process all the events in Game's event queue. Only the main thread should call this.
|
|
virtual void processEvents();
|
|
/// @}
|
|
|
|
/// @name Event Handlers
|
|
/// default event behavior with journaling support
|
|
/// default handler forwards events to appropriate routines
|
|
/// @{
|
|
virtual void processEvent(Event *event);
|
|
|
|
virtual void processPacketReceiveEvent(PacketReceiveEvent *event);
|
|
virtual void processMouseMoveEvent(MouseMoveEvent *event);
|
|
virtual void processInputEvent(InputEvent *event);
|
|
virtual void processQuitEvent();
|
|
virtual void processTimeEvent(TimeEvent *event);
|
|
virtual void processConsoleEvent(ConsoleEvent *event);
|
|
virtual void processConnectedAcceptEvent(ConnectedAcceptEvent *event);
|
|
virtual void processConnectedReceiveEvent(ConnectedReceiveEvent *event);
|
|
virtual void processConnectedNotifyEvent(ConnectedNotifyEvent *event);
|
|
/// @}
|
|
|
|
/// @name Running
|
|
/// @{
|
|
void setRunning(bool running) { mRunning = running; }
|
|
bool isRunning() { return mRunning; }
|
|
void setRestart( bool restart ) { mRequiresRestart = restart; }
|
|
bool requiresRestart() { return mRequiresRestart; }
|
|
/// @}
|
|
|
|
/// @name Journaling
|
|
///
|
|
/// Journaling is used in order to make a "demo" of the actual game. It logs
|
|
/// all processes that happen throughout code execution (NOT script). This is
|
|
/// very handy for debugging. Say an end user finds a crash in the program.
|
|
/// The user can start up the engine with journal recording enabled, reproduce
|
|
/// the crash, then send in the journal file to the development team. The
|
|
/// development team can then play back the journal file and see exactly what
|
|
/// happened to cause the crash. This will result in the ability to run the
|
|
/// program through the debugger to easily track what went wrong and easily
|
|
/// create a stack trace.
|
|
///
|
|
/// Actually enabling journaling may be different in different distributions
|
|
/// if the developers decided to change how it works. However, by default,
|
|
/// run the program with the "-jSave filename" command argument. The filename
|
|
/// does not need an extension, and only requires write access. If the file
|
|
/// does not exist, it will be created. In order to play back a journal,
|
|
/// use the "-jPlay filename" command argument, and just watch the magic happen.
|
|
/// Examples:
|
|
/// @code
|
|
/// torqueDemo_DEBUG.exe -jSave crash
|
|
/// torqueDemo_DEBUG.exe -jPlay crash
|
|
/// @endcode
|
|
/// @{
|
|
|
|
/// If we're doing a journal playback, this function is responsible for reading
|
|
/// events from the journal file and dispatching them.
|
|
void journalProcess();
|
|
|
|
/// Start loading journal data from the specified file.
|
|
void loadJournal(const char *fileName);
|
|
|
|
/// Start saving journal data to the specified file (must be able to write it).
|
|
void saveJournal(const char *fileName);
|
|
|
|
/// Play back the specified journal.
|
|
///
|
|
/// @param fileName Journal file to play back.
|
|
/// @param journalBreak Should we break execution after we're done?
|
|
void playJournal(const char *fileName, bool journalBreak = false);
|
|
|
|
JournalMode getJournalMode() { return mJournalMode; };
|
|
|
|
/// Are we reading back from the journal?
|
|
bool isJournalReading() { return mJournalMode == JournalPlay; }
|
|
|
|
/// Are we writing to the journal?
|
|
bool isJournalWriting() { return mJournalMode == JournalSave; }
|
|
|
|
void journalRead(U32 *val); ///< Read a U32 from the journal.
|
|
void journalWrite(U32 val); ///< Write a U32 to the journal.
|
|
void journalRead(U32 size, void *buffer); ///< Read a block of data from the journal.
|
|
void journalWrite(U32 size, const void *buffer);///< Write a block of data to the journal.
|
|
|
|
FileStream *getJournalStream();
|
|
/// @}
|
|
};
|
|
|
|
/// Global game instance.
|
|
extern GameInterface *Game;
|
|
|
|
#endif
|