YAGE  v0.1.4.0
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
 
 matrix
 Namespace containing functions that operate on matrices.
 

Classes

class  Camera
 
class  ImageLoader
 
class  IoManager
 
class  Logger
 

Logger

More...
 
class  LogMessage
 
class  LogSink
 
class  ResourceManager
 
class  SpriteSheet
 
class  TextureCache
 
class  Window
 
struct  Texture
 
struct  Position
 
struct  Colour
 
struct  UV
 
struct  Vertex
 
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  Batch
 The Batch class will be the base class for all the different batching processes that might use different shaders and attributes. More...
 
class  Drawable
 
class  Rectangle
 
class  Shader
 
class  Shape
 
class  Sprite
 
class  SpriteBatch
 
class  Active
 
class  SyncQueue
 

Typedefs

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
}
 
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

LogSink makeConsoleSink ()
 
LogSink makeFileSink (const std::string &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)
 
void glfwErrorCallback (int, const char *description)
 
void init ()
 Initializes yage. More...
 
void quit ()
 Quit and cleanup yage. More...
 

Detailed Description

Project namespace.

Todo:
remove the include to make compilation faster
Todo:
think of removing this, by, for example, using a pointer This could be more efficient when copying the texture out of the spritesheet.

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

Typedef Documentation

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
Enumerator
DEBUG 
INFO 
WARNING 
ERROR 
FATAL 
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 only there to initialize glfw.

Returns
Returns true if the initialization was successful.
LogSink yage::makeConsoleSink ( )
LogSink yage::makeFileSink ( const std::string &  filename)
LogSink yage::makeFileSink ( std::string &&  filename)
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.

glfw needs to clean itself up.