Yet Another Game Engine
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Pages
Namespaces | Classes | Typedefs | Enumerations | Functions
yage Namespace Reference

Project namespace. More...

Namespaces

 details
 
 IoManager
 
 matrix
 Namespace containing functions that operate on matrices.
 

Classes

class  Camera
 
class  FileLoadException
 
class  ImageLoader
 
class  LogMessage
 
class  LogSink
 
class  Logger
 
class  ResourceManager
 
class  TextureCache
 
class  Window
 
struct  Texture
 
struct  Position
 
struct  Colour
 
struct  UV
 
struct  Vertex
 
class  BaseComponent
 
class  Component
 
class  ComponentGroup
 
class  EntityManager
 Has to keep track of all the different entities and their current state. More...
 
class  BaseSystem
 
class  System
 
class  Matrix
 Base Matrix class used by other similar classes. More...
 
class  Vector
 
class  Vector2
 2D Vector class. More...
 
class  Vector3
 3D Vector class. More...
 
class  Vector4
 4D Vector class More...
 
class  Body
 
class  Collider
 
class  CollisionBody
 
class  ParticleBody
 
class  RectangleCollider
 
class  RigidBody
 
class  Shader
 
class  SpriteBatch
 
class  Active
 
class  NonCopyable
 
class  SyncQueue
 

Typedefs

typedef std::bitset< 64 > ComponentMask
 The component mask represents all the components that the entity is currently attached to. More...
 
typedef unsigned int GroupId
 
typedef unsigned int Entity
 The entity is currently just an unsigned integer, which may change to a class in the future. More...
 
using Vector2d = Vector2< double >
 Definition of a 2D vector. More...
 
using Vector2f = Vector2< float >
 
using Vector2i = Vector2< int >
 
using Vector3d = Vector3< double >
 Definition of a 3D vector. More...
 
using Vector3f = Vector3< float >
 
using Vector3i = Vector3< int >
 
using Vector4d = Vector4< double >
 Definition of a 4D vector. More...
 
using Vector4f = Vector4< float >
 
using Vector4i = Vector4< int >
 

Enumerations

enum  LogLevel {
  LogLevel::DEBUG, LogLevel::INFO, LogLevel::WARNING, LogLevel::ERROR,
  LogLevel::FATAL
}
 Different log levels that can be assigned to each message sent to the Logger. More...
 
enum  WindowFlags : unsigned { SHOWN = 0x1, HIDDEN = 0x2, FULLSCREEN = 0x4, BORDERLESS = 0x8 }
 
enum  key {
  key::UNKNOWN = GLFW_KEY_UNKNOWN, key::SPACE = GLFW_KEY_SPACE, key::APOSTROPHE = GLFW_KEY_APOSTROPHE, key::COMMA = GLFW_KEY_COMMA,
  key::MINUS = GLFW_KEY_MINUS, key::PERIOD = GLFW_KEY_PERIOD, key::SLASH = GLFW_KEY_SLASH, key::NUM0 = GLFW_KEY_0,
  key::NUM1 = GLFW_KEY_1, key::NUM2 = GLFW_KEY_2, key::NUM3 = GLFW_KEY_3, key::NUM4 = GLFW_KEY_4,
  key::NUM5 = GLFW_KEY_5, key::NUM6 = GLFW_KEY_6, key::NUM7 = GLFW_KEY_7, key::NUM8 = GLFW_KEY_8,
  key::NUM9 = GLFW_KEY_9, key::SEMICOLON = GLFW_KEY_SEMICOLON, key::EQUAL = GLFW_KEY_EQUAL, key::A = GLFW_KEY_A,
  key::B = GLFW_KEY_B, key::C = GLFW_KEY_C, key::D = GLFW_KEY_D, key::E = GLFW_KEY_E,
  key::F = GLFW_KEY_F, key::G = GLFW_KEY_G, key::H = GLFW_KEY_H, key::I = GLFW_KEY_I,
  key::J = GLFW_KEY_J, key::K = GLFW_KEY_K, key::L = GLFW_KEY_L, key::M = GLFW_KEY_M,
  key::N = GLFW_KEY_N, key::O = GLFW_KEY_O, key::P = GLFW_KEY_P, key::Q = GLFW_KEY_Q,
  key::R = GLFW_KEY_R, key::S = GLFW_KEY_S, key::T = GLFW_KEY_T, key::U = GLFW_KEY_U,
  key::V = GLFW_KEY_V, key::W = GLFW_KEY_W, key::X = GLFW_KEY_X, key::Y = GLFW_KEY_Y,
  key::Z = GLFW_KEY_Z, key::LEfT_BRACKET = GLFW_KEY_LEFT_BRACKET, key::BACKSLASH = GLFW_KEY_BACKSLASH, key::RIGHT_BRACKET = GLFW_KEY_RIGHT_BRACKET,
  key::GRAVE_ACCENT = GLFW_KEY_GRAVE_ACCENT, key::WORLD_1 = GLFW_KEY_WORLD_1, key::WORLD_2 = GLFW_KEY_WORLD_2, key::ESCAPE = GLFW_KEY_ESCAPE,
  key::ENTER = GLFW_KEY_ENTER, key::TAB = GLFW_KEY_TAB, key::BACKSPACE = GLFW_KEY_BACKSPACE, key::INSERT = GLFW_KEY_INSERT,
  key::DELETE = GLFW_KEY_DELETE, key::RIGHT = GLFW_KEY_RIGHT, key::LEFT = GLFW_KEY_LEFT, key::DOWN = GLFW_KEY_DOWN,
  key::UP = GLFW_KEY_UP, key::PAGE_UP = GLFW_KEY_PAGE_UP, key::PAGE_DOWN = GLFW_KEY_PAGE_DOWN, key::HOME = GLFW_KEY_HOME,
  key::END = GLFW_KEY_END, key::CAPS_LOCK = GLFW_KEY_CAPS_LOCK, key::SCROLL_LOCK = GLFW_KEY_SCROLL_LOCK, key::NUM_LOCK = GLFW_KEY_NUM_LOCK,
  key::PRINT_SCREEN = GLFW_KEY_PRINT_SCREEN, key::PAUSE = GLFW_KEY_PAUSE, key::F1 = GLFW_KEY_F1, key::F2 = GLFW_KEY_F2,
  key::F3 = GLFW_KEY_F3, key::F4 = GLFW_KEY_F4, key::F5 = GLFW_KEY_F5, key::F6 = GLFW_KEY_F6,
  key::F7 = GLFW_KEY_F7, key::F8 = GLFW_KEY_F8, key::F9 = GLFW_KEY_F9, key::F10 = GLFW_KEY_F10,
  key::F11 = GLFW_KEY_F11, key::F12 = GLFW_KEY_F12, key::F13 = GLFW_KEY_F13, key::F14 = GLFW_KEY_F14,
  key::F15 = GLFW_KEY_F15, key::F16 = GLFW_KEY_F16, key::F17 = GLFW_KEY_F17, key::F18 = GLFW_KEY_F18,
  key::F19 = GLFW_KEY_F19, key::F20 = GLFW_KEY_F20, key::F21 = GLFW_KEY_F21, key::F22 = GLFW_KEY_F22,
  key::F23 = GLFW_KEY_F23, key::F24 = GLFW_KEY_F24, key::F25 = GLFW_KEY_F25, key::KP_0 = GLFW_KEY_KP_0,
  key::KP_1 = GLFW_KEY_KP_1, key::KP_2 = GLFW_KEY_KP_2, key::KP_3 = GLFW_KEY_KP_3, key::KP_4 = GLFW_KEY_KP_4,
  key::KP_5 = GLFW_KEY_KP_5, key::KP_6 = GLFW_KEY_KP_6, key::KP_7 = GLFW_KEY_KP_7, key::KP_8 = GLFW_KEY_KP_8,
  key::KP_9 = GLFW_KEY_KP_9, key::KP_DECIMAL = GLFW_KEY_KP_DECIMAL, key::KP_DIVIDE = GLFW_KEY_KP_DIVIDE, key::KP_MULTIPLY = GLFW_KEY_KP_MULTIPLY,
  key::KP_SUBTRACT = GLFW_KEY_KP_SUBTRACT, key::KP_ADD = GLFW_KEY_KP_ADD, key::KP_ENTER = GLFW_KEY_KP_ENTER, key::KP_EQUAL = GLFW_KEY_KP_EQUAL,
  key::LEFT_SHIFT = GLFW_KEY_LEFT_SHIFT, key::LEFT_CONTROL = GLFW_KEY_LEFT_CONTROL, key::LEFT_ALT = GLFW_KEY_LEFT_ALT, key::LEFT_SUPER = GLFW_KEY_LEFT_SUPER,
  key::RIGHT_SHIFT = GLFW_KEY_RIGHT_SHIFT, key::RIGHT_CONTROL = GLFW_KEY_RIGHT_CONTROL, key::RIGHT_ALT = GLFW_KEY_RIGHT_ALT, key::RIGHT_SUPER = GLFW_KEY_RIGHT_SUPER,
  key::MENU = GLFW_KEY_MENU, key::LAST = GLFW_KEY_LAST
}
 

Functions

void glfwErrorCallback (int, char const *)
 
void init ()
 Initializes YAGE. More...
 
void quit ()
 Quit and cleanup YAGE. More...
 
 min_level_ (LogLevel::INFO)
 
LogSink makeConsoleSink ()
 
LogSink makeFileSink (std::string const &filename)
 
LogSink makeFileSink (std::string &&filename)
 
template<int M, int N, class T >
Matrix< M, N, T > operator+ (Matrix< M, N, T > lhs, const Matrix< M, N, T > &rhs)
 
template<int M, int N, class T >
Matrix< M, N, T > operator- (Matrix< M, N, T > lhs, const Matrix< M, N, T > &rhs)
 
template<int M, int N, class T >
Matrix< M, N, T > operator+ (Matrix< M, N, T > lhs, const T &rhs)
 
template<int M, int N, class T >
Matrix< M, N, T > operator+ (const T &lhs, Matrix< M, N, T > rhs)
 
template<int M, int N, class T >
Matrix< M, N, T > operator- (Matrix< M, N, T > lhs, const T &rhs)
 
template<int M, int N, class T >
Matrix< M, N, T > operator- (const T &lhs, Matrix< M, N, T > rhs)
 
template<int M, int N, class T >
Matrix< M, N, T > operator* (Matrix< M, N, T > lhs, const T &rhs)
 
template<int M, int N, class T >
Matrix< M, N, T > operator* (const T &lhs, Matrix< M, N, T > rhs)
 
template<int M, int N, class T >
Matrix< M, N, T > operator/ (Matrix< M, N, T > lhs, const T &rhs)
 
template<int M, int N, class T >
bool operator== (const Matrix< M, N, T > &lhs, const Matrix< M, N, T > &rhs)
 
template<int M, int N, class T >
std::ostream & operator<< (std::ostream &os, const Matrix< M, N, T > &mat)
 

Detailed Description

Project namespace.

Avoids collision as all the classes and global functions are wrapped in.

Typedef Documentation

typedef std::bitset<64> yage::ComponentMask

The component mask represents all the components that the entity is currently attached to.

typedef unsigned int yage::Entity

The entity is currently just an unsigned integer, which may change to a class in the future.

typedef unsigned int yage::GroupId
using yage::Vector2d = typedef Vector2<double>

Definition of a 2D vector.

using yage::Vector2f = typedef Vector2<float>
using yage::Vector2i = typedef Vector2<int>
using yage::Vector3d = typedef Vector3<double>

Definition of a 3D vector.

using yage::Vector3f = typedef Vector3<float>
using yage::Vector3i = typedef Vector3<int>
using yage::Vector4d = typedef Vector4<double>

Definition of a 4D vector.

using yage::Vector4f = typedef Vector4<float>
using yage::Vector4i = typedef Vector4<int>

Enumeration Type Documentation

enum yage::key
strong
Enumerator
UNKNOWN 
SPACE 
APOSTROPHE 
COMMA 
MINUS 
PERIOD 
SLASH 
NUM0 
NUM1 
NUM2 
NUM3 
NUM4 
NUM5 
NUM6 
NUM7 
NUM8 
NUM9 
SEMICOLON 
EQUAL 
A 
B 
C 
D 
E 
F 
G 
H 
I 
J 
K 
L 
M 
N 
O 
P 
Q 
R 
S 
T 
U 
V 
W 
X 
Y 
Z 
LEfT_BRACKET 
BACKSLASH 
RIGHT_BRACKET 
GRAVE_ACCENT 
WORLD_1 
WORLD_2 
ESCAPE 
ENTER 
TAB 
BACKSPACE 
INSERT 
DELETE 
RIGHT 
LEFT 
DOWN 
UP 
PAGE_UP 
PAGE_DOWN 
HOME 
END 
CAPS_LOCK 
SCROLL_LOCK 
NUM_LOCK 
PRINT_SCREEN 
PAUSE 
F1 
F2 
F3 
F4 
F5 
F6 
F7 
F8 
F9 
F10 
F11 
F12 
F13 
F14 
F15 
F16 
F17 
F18 
F19 
F20 
F21 
F22 
F23 
F24 
F25 
KP_0 
KP_1 
KP_2 
KP_3 
KP_4 
KP_5 
KP_6 
KP_7 
KP_8 
KP_9 
KP_DECIMAL 
KP_DIVIDE 
KP_MULTIPLY 
KP_SUBTRACT 
KP_ADD 
KP_ENTER 
KP_EQUAL 
LEFT_SHIFT 
LEFT_CONTROL 
LEFT_ALT 
LEFT_SUPER 
RIGHT_SHIFT 
RIGHT_CONTROL 
RIGHT_ALT 
RIGHT_SUPER 
MENU 
LAST 
enum yage::LogLevel
strong

Different log levels that can be assigned to each message sent to the Logger.

The logger then outputs the message if it is above the minimum log level, or does not process it.

Enumerator
DEBUG 

Lowest log level. This is used by the game engine to output debugging information but is turned off in the logger by default.

INFO 

Information message.

WARNING 

Warning message.

ERROR 

Error message.

FATAL 

Fatal message that should be output when the game crashes.

enum yage::WindowFlags : unsigned
Enumerator
SHOWN 
HIDDEN 
FULLSCREEN 
BORDERLESS 

Function Documentation

void yage::glfwErrorCallback ( int  ,
const char *  description 
)
void yage::init ( )

Initializes YAGE.

This is there to initialize GLFW, which is the current window manager that is used with OpenGL.

LogSink yage::makeConsoleSink ( )
LogSink yage::makeFileSink ( std::string const &  filename)
LogSink yage::makeFileSink ( std::string &&  filename)
yage::min_level_ ( LogLevel::INFO  )
template<int M, int N, class T >
Matrix<M, N, T> yage::operator* ( Matrix< M, N, T >  lhs,
const T &  rhs 
)
template<int M, int N, class T >
Matrix<M, N, T> yage::operator* ( const T &  lhs,
Matrix< M, N, T >  rhs 
)
template<int M, int N, class T >
Matrix<M, N, T> yage::operator+ ( Matrix< M, N, T >  lhs,
const Matrix< M, N, T > &  rhs 
)
template<int M, int N, class T >
Matrix<M, N, T> yage::operator+ ( Matrix< M, N, T >  lhs,
const T &  rhs 
)
template<int M, int N, class T >
Matrix<M, N, T> yage::operator+ ( const T &  lhs,
Matrix< M, N, T >  rhs 
)
template<int M, int N, class T >
Matrix<M, N, T> yage::operator- ( Matrix< M, N, T >  lhs,
const Matrix< M, N, T > &  rhs 
)
template<int M, int N, class T >
Matrix<M, N, T> yage::operator- ( Matrix< M, N, T >  lhs,
const T &  rhs 
)
template<int M, int N, class T >
Matrix<M, N, T> yage::operator- ( const T &  lhs,
Matrix< M, N, T >  rhs 
)
template<int M, int N, class T >
Matrix<M, N, T> yage::operator/ ( Matrix< M, N, T >  lhs,
const T &  rhs 
)
template<int M, int N, class T >
std::ostream& yage::operator<< ( std::ostream &  os,
const Matrix< M, N, T > &  mat 
)
template<int M, int N, class T >
bool yage::operator== ( const Matrix< M, N, T > &  lhs,
const Matrix< M, N, T > &  rhs 
)
void yage::quit ( )

Quit and cleanup YAGE.

This also cleans up GLFW after it was initialized.