Leviathan  0.8.0.0
Leviathan game engine
ForwardDeclarations.h
Go to the documentation of this file.
1 // ------------------ This file contains forward declarations for all possible things
2 // that need to be included (or forward declared)
3 #pragma once
4 
5 #include <cstdint>
6 
7 
8 namespace Leviathan {
9 
10 // Core systems //
11 class Logger;
12 class FileSystem;
13 class Engine;
14 class Graphics;
15 class ScriptExecutor;
16 class NetworkHandler;
17 class ScriptExecutor;
18 class GameWorld;
19 class AppDef;
20 class Convert;
21 class EventHandler;
22 class DataStore;
23 class OutOfMemoryHandler;
24 class RenderingStatistics;
25 class IDFactory;
26 class Time;
27 class ConsoleInput;
28 
29 class Locker;
30 
31 class Visitor;
32 class Visitable;
33 
34 
35 class InputReceiver;
36 class InputController;
37 
38 namespace GUI {
39 
40 class GuiManager;
41 class View;
43 class JSAsyncCustom;
44 class CefApplication;
45 } // namespace GUI
46 
47 // Entities //
48 
49 // Component types //
50 class Sendable;
51 class Position;
52 class Constraintable;
53 class Parentable;
54 class Parent;
55 class Physics;
56 class RenderNode;
57 class Received;
58 class BoxGeometry;
59 class Model;
60 class ManualObject;
61 
62 
63 
64 
65 // Networking //
66 class RemoteConsole;
67 class NetworkRequest;
68 class NetworkResponse;
69 class Connection;
70 class NetworkCache;
71 
72 // Constraints //
73 class BaseConstraint;
74 
75 
76 // DeltaStates //
77 
78 
79 
80 // Exceptions //
81 class Exception;
82 class InvalidAccess;
83 class InvalidArgument;
84 class InvalidState;
85 class InvalidType;
86 class NotFound;
87 class NULLPtr;
88 
89 
92 
93 class ObjectFileList;
94 
95 
96 // Network Response //
97 class ResponseCacheUpdated;
98 class ResponseWorldFrozen;
99 class ResponseCacheRemoved;
100 class ResponseIdentification;
101 
102 // Network Request //
103 class RequestWorldClockSync;
104 
105 // Threading //
106 class ThreadingManager;
107 class QueuedTask;
108 class DelayedTask;
109 class ConditionalTask;
113 class TaskThread;
114 
115 class NetworkCache;
116 
117 class ConnectedPlayer;
118 class CommandSender;
119 class CommandHandler;
120 
122 
125 
126 class UTF8DataIterator;
127 template<class DTypeName>
129 class SyncedResource;
130 
131 class ViewerCameraPos;
132 class SoundDevice;
134 class ScriptConsole;
135 
136 class LeapManager;
137 class LeapListener;
138 
139 class GameModule;
140 
141 class ObjectLoader;
146 class NamedVariableBlock;
147 class SyncedVariables;
148 class SyncedValue;
149 class NetworkInterface;
150 class NamedVars;
151 class NamedVariableList;
154 class SentNetworkThing;
155 class BaseEntityController;
156 class BaseNotifiableAll;
157 class BaseNotifierAll;
158 class BaseNotifierEntity;
159 class BaseNotifiableEntity;
160 template<class ParentType, class ChildType>
161 class BaseNotifier;
162 template<class ParentType, class ChildType>
163 class BaseNotifiable;
164 class GameConfiguration;
165 class KeyConfiguration;
166 class Engine;
168 struct RayCastData;
169 class ScriptModule;
170 class ScriptScript;
171 class Event;
172 class GenericEvent;
173 struct Int2;
174 struct Int3;
176 class StringIterator;
177 class Window;
178 class Random;
179 class VariableBlock;
180 class TimingMonitor;
181 class ScopeTimer;
183 class GlobalCEFHandler;
184 } // namespace Leviathan
185 
186 #ifdef LEAK_INTO_GLOBAL
187 using Leviathan::Locker;
188 
189 using Leviathan::AppDef;
195 using Leviathan::Convert;
196 using Leviathan::Engine;
197 using Leviathan::Event;
207 using Leviathan::Logger;
225 
226 
234 
235 
237 
243 #endif
Base class for all user defined response packets.
Interface for object file lists to implement.
Definition: ObjectFile.h:21
Class that synchronizes some key variables with another instance.
hosts one or more VariableBlocks keeping only one name for all of them
Definition: NamedVars.h:27
Class that represents a statically defined event.
Definition: Event.h:106
Template class for syncing basic types.
Provides client applications and modules (not done) support for defining custom request responses.
Object used by ThreadingManager to easily create properly initialized threads.
Definition: TaskThread.h:22
Class to collect all entity creations to one class.
Definition: ObjectLoader.h:16
Entity is received from a server.
Definition: Components.h:170
Holds common conversion functions.
Definition: Convert.h:16
Non-template class for working with all types of DataBlocks.
Definition: DataBlock.h:425
Unicode iterator for utf8 on top of string.
Holds key configuration for an application.
Class that represents a template definition.
Definition: ObjectFile.h:310
Random number generator based on Mersenne Twister.
Definition: Random.h:15
Encapsulates a function that can later be ran in a free thread.
Definition: QueuedTask.h:82
Manages loading the audio library and provides some helpers.
Definition: SoundDevice.h:15
Encapsulates a function that is ran after a time period.
Definition: QueuedTask.h:130
Allows object to register for events that can be fired from anywhere.
Definition: EventHandler.h:15
Class for indexing and searching game data directory.
Definition: FileSystem.h:65
Specialized class for accepting all parent/child objects.
Definition: BaseNotifier.h:103
Handler for new render processes.
The main class of the Leviathan Game Engine.
Definition: Engine.h:37
GUI controller for a Window.
Definition: GuiManager.h:20
Base class for all exceptions thrown by Leviathan.
Definition: Exceptions.h:10
Logger class for all text output.
Definition: Logger.h:10
Handles asynchronous javascript requests.
Encapsulates a function that is ran after a time period and repeated certain amount.
Definition: QueuedTask.h:238
Class that represents a dynamically defined event.
Definition: Event.h:140
Forms a connection between a ScriptModule and a ScriptArgumentsProvider which either can disconnect.
Entity has a box for geometry/model, possibly also physics.
Definition: Components.h:212
Entity has position and direction it is looking at.
Definition: Components.h:36
Entity has a scene node.
Definition: Components.h:82
Iterator class for getting parts of a string.
Manages delayed execution of functions through use of QueuedTask and subclasses.
Encapsulates a function that can later be ran in a free thread.
Definition: QueuedTask.h:34
Encapsulates a function that is ran after a time period.
Definition: QueuedTask.h:160
Allows various resource loaders to get notified when the file on disk changes.
Class that encapsulates a value that can be used for syncing.
Specialized class for accepting all parent/child objects.
Centralized variables that AI can use on clients to replicate server behavior.
Definition: NetworkCache.h:21
Entity has a physical component.
Definition: Components.h:347
Handles construction of all game specific packets.
Singleton class for handling CEF initialization that needs to be done right away.
Base class for all values that are to be automatically synced between clients.
Represents an entity that can execute commands.
Represents a template instantiation.
Definition: ObjectFile.h:281
A file listener instance which listens for file changes in a folder.
Entity has a model.
Definition: Components.h:233
A class that represents a human player.
Contains a material list for applying automatic properties to PhysicsBody and collision callbacks.
Encapsulates a function that can later be ran in a free thread.
Definition: QueuedTask.h:102
Class that handles a single connection to another instance.
Definition: Connection.h:105
Class that encapsulates common networking functionality required by server programs.
Class that contains all data associated with a game specific packet.
Represents a scriptable part of a program.
Definition: GameModule.h:18
Base class for all leviathan programs.
Definition: Application.h:16
The access mask controls which registered functions and classes a script sees.
Definition: GameModule.h:12
Class used to handle remote server commands and receiving messages.
Definition: RemoteConsole.h:45
Entity is sendable to clients.
Definition: Components.h:115
DataBlock variant with name.
Definition: DataBlock.h:762
Class that encapsulates common networking functionality required by client programs.
Class that encapsulates common networking functionality that is required by all networked programs.
Handles all commands sent by the players on the server.
Base class for all user defined request packets.
Represents a world that contains entities.
Definition: GameWorld.h:57
Represents a sent packet and holds all kinds of data for it.
A class that represents a single GUI layer that has it's own chromium browser.
Definition: GuiView.h:53