GlPortal Class Reference  0.1.1
Source code documentation of the free and open 3D action puzzle game.
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Pages
Namespaces | Data Structures | Typedefs | Enumerations | Functions | Variables
radix Namespace Reference

Namespaces

 Exception
 
 impl
 
 util
 

Data Structures

class  AnsiConsoleLogger
 Logger that outputs to an ANSI/vt-100 console. More...
 
class  ArgumentsParser
 
class  BaseGame
 
class  Camera
 
class  CheckCollisionCallback
 
class  CollisionDispatcher
 
struct  CollisionInfo
 
class  CollisionInfoEqual
 
class  CollisionInfoHash
 
class  CollisionShapeManager
 
class  Component
 Base class to create entity components. More...
 
class  Config
 Configuration class. More...
 
class  Console
 
class  ContactPlayerCallback
 
class  Entity
 ECS entity, Component container It is created like this:

Entity &trigger = world.entities.create();
Transform &t = trigger.addComponent<Transform>();
More...
 
class  EntityManager
 Manager and container of entities. More...
 
class  Environment
 Manager for config. More...
 
struct  Event
 
class  EventDispatcher
 
class  Font
 
class  FontLoader
 
class  Fps
 
class  GameState
 
class  GameWorld
 
class  GlGwenRenderer
 
class  Glyph
 
class  GWENInput
 
class  Health
 
class  InputSource
 
class  KinematicCharacterController
 KinematicCharacterController is an object that supports a sliding motion in a world. More...
 
class  KinematicClosestNotMeConvexResultCallback
 
class  KinematicClosestNotMeRayResultCallback
 
class  LightSource
 
class  Logger
 Base class to create log sinks. More...
 
class  LogInput
 std::cout-like object that sends the data it aggregated to a Logger when it dies More...
 
class  MapListLoader
 
class  MapLoader
 
class  Material
 
class  MaterialLoader
 
class  Math
 Math helper class. More...
 
class  Matrix3f
 
class  Matrix4f
 
class  Mesh
 
class  MeshDrawable
 
class  MeshLoader
 
class  NullInputSource
 
class  OperatingSystem
 
class  Path
 
class  PhysicsDebugDraw
 
class  PhysicsHelper
 
class  PhysicsSystem
 
class  Player
 
class  PlayerMoveTask
 
class  PlayerSystem
 
class  PlayerTask
 
class  PlayerTriggerTask
 
class  PortalRenderer
 
struct  Quaternion
 
class  Rectangle
 
struct  RenderContext
 
class  Renderer
 Main renderer - handles sub-renderers and provides low level render functions. More...
 
class  RigidBody
 
struct  Screen
 
class  ScreenRenderer
 
class  Shader
 
class  ShaderLoader
 
class  SoundListener
 
class  SoundManager
 
class  SoundSource
 
class  StdoutLogger
 Logger that outputs to an ANSI/vt-100 console. More...
 
class  SubRenderer
 
class  System
 
class  SystemManager
 
struct  Text
 
class  TextRenderer
 
struct  Texture
 
class  TextureLoader
 
class  TightDataPacker
 
class  TimeDelta
 
class  Transform
 
class  Trigger
 
class  Uncollider
 
class  Util
 
class  VBO
 
class  Vector2f
 2-dimensional float-based vector/point storage and manipulation struct More...
 
class  Vector3f
 3-dimensional float-based vector/point storage and manipulation struct More...
 
class  Vector4f
 4-dimensional float-based vector/point storage and manipulation struct More...
 
class  ViewFrame
 
struct  Viewport
 
class  Window
 
class  World
 
class  XmlHelper
 
class  XmlLoader
 
class  XmlMapLoader
 Load a map in GlPortal XML format. More...
 
class  XmlScreenLoader
 

Typedefs

using SystemGraphNode = SystemManager::SystemGraphNode
 
using SystemGraphNodeVector = SystemManager::SystemGraphNodeVector
 
using ComponentTypeId = std::size_t
 
using StaticEventType = const uint32_t
 
using EventType = uint32_t
 
using StaticEventTypeName = const char *const
 
using EventTypeName = std::string
 
using RectangleI = Rectangle< int >
 
using RectangleF = Rectangle< float >
 
using RectangleD = Rectangle< double >
 
using HandleGameFunction = std::function< void(BaseGame &game)>
 
using TDelta = TimeDelta
 
using EntityId = uint32_t
 
using SystemTypeId = std::size_t
 
typedef std::pair< Entity
*, Entity * > 
EntityPair
 

Enumerations

enum  LogLevel {
  Verbose, Debug, Info, Warning,
  Error, Failure
}
 

Functions

int getBackgroundColor (const std::string &tag)
 
bool needBlackText (int bgcol)
 
static constexpr GLenum getGlUsage (const VBO::Usage usage)
 
Matrix3f transpose (const Matrix3f &m)
 
float determinant (const Matrix3f &m)
 
Matrix3f inverse (const Matrix3f &m)
 
Matrix4f toMatrix4f (const Matrix3f &m)
 
Matrix4f transpose (const Matrix4f &m)
 
float determinant (const Matrix4f &m)
 
Matrix4f inverse (const Matrix4f &m)
 
Matrix3f toMatrix3f (const Matrix4f &m)
 
Vector3f cross (const Vector3f &v1, const Vector3f &v2)
 
static constexpr GLenum getGlShaderType (const Shader::Type type)
 
static btVector3 getNormalizedVector (const btVector3 &v)
 
static void strongconnect (SystemTypeId &index, std::stack< SystemTypeId > &S, SystemTypeId stid, SystemGraphNode &si, SystemGraphNodeVector &sinfo, SystemManager::SystemLoopVector &stronglyConnected)
 
static bool isReachableBySuccessors (const SystemGraphNode &start, SystemTypeId targetstid, const SystemGraphNodeVector &sinfo, std::stack< SystemTypeId > &path)
 
static void df (SystemGraphNode &vertex0, SystemGraphNode &child0, std::set< SystemTypeId > &done, SystemGraphNodeVector &sinfo)
 
ComponentTypeId getNewComponentTypeId ()
 
constexpr VBO::Usage operator| (const VBO::Usage a, const VBO::Usage b)
 
constexpr float deg (float rad)
 
constexpr float rad (float deg)
 
constexpr float dot (const Vector2f &v1, const Vector2f &v2)
 
Vector2f normalize (const Vector2f &v)
 
constexpr float dot (const Vector3f &v1, const Vector3f &v2)
 
Vector3f normalize (const Vector3f &v)
 
constexpr float length2 (const Vector4f &v)
 
float length (const Vector4f &v)
 
constexpr float dot (const Vector4f &v, const Vector4f &w)
 
Vector4f normalize (const Vector4f &v)
 
Quaternion normalize (const Quaternion &q)
 
constexpr Quaternion conjugate (const Quaternion &q)
 
SystemTypeId getNewSystemTypeId ()
 
constexpr int conststrlen (const char *str)
 
constexpr uint32_t Hash32 (const char *str)
 
constexpr uint32_t Hash32 (const std::string &str)
 

Variables

static const Vector3f PLAYER_SIZE (0.5, 1, 0.5)
 
static float Identity3 [3 *3]
 
static float Identity4 [4 *4]
 
static constexpr GLint MaxGlLogSize = 1024 * 1024 * 2
 
const int UPDATE_RATE = 60
 
const int SKIP_TIME = 1000 / UPDATE_RATE
 
const int MAX_SKIP = 5
 
static const float RUNNING_SPEED = 0.1f
 
static const float JUMP_SPEED = 0.15f
 
static const float HURT_VELOCITY = 0.18f
 
static const std::array< const
std::string, 2 > 
PLAYER_PANTING_SOUND
 
static const std::array< const
std::string, 2 > 
PLAYER_JUMP_SOUND
 
static const std::array< const
std::string, 2 > 
PLAYER_FALL_SOUND
 
static const std::array< const
std::string, 6 > 
PLAYER_FOOT_SOUND
 

Typedef Documentation

using radix::ComponentTypeId = typedef std::size_t
using radix::EntityId = typedef uint32_t
typedef std::pair<Entity*, Entity*> radix::EntityPair
using radix::EventType = typedef uint32_t
using radix::EventTypeName = typedef std::string
using radix::HandleGameFunction = typedef std::function<void (BaseGame &game)>
using radix::RectangleD = typedef Rectangle<double>
using radix::RectangleF = typedef Rectangle<float>
using radix::RectangleI = typedef Rectangle<int>
using radix::StaticEventType = typedef const uint32_t
using radix::StaticEventTypeName = typedef const char *const
using radix::SystemTypeId = typedef std::size_t
using radix::TDelta = typedef TimeDelta

Enumeration Type Documentation

Enumerator
Verbose 
Debug 
Info 
Warning 
Error 
Failure 

Function Documentation

constexpr Quaternion radix::conjugate ( const Quaternion &  q)
inline
constexpr int radix::conststrlen ( const char *  str)
Vector3f radix::cross ( const Vector3f &  v1,
const Vector3f &  v2 
)
constexpr float radix::deg ( float  rad)
inline
float radix::determinant ( const Matrix3f &  m)
float radix::determinant ( const Matrix4f &  m)
static void radix::df ( SystemGraphNode &  vertex0,
SystemGraphNode &  child0,
std::set< SystemTypeId > &  done,
SystemGraphNodeVector &  sinfo 
)
static
constexpr float radix::dot ( const Vector2f &  v1,
const Vector2f &  v2 
)
inline
constexpr float radix::dot ( const Vector3f &  v1,
const Vector3f &  v2 
)
inline
constexpr float radix::dot ( const Vector4f &  v,
const Vector4f &  w 
)
inline
int radix::getBackgroundColor ( const std::string &  tag)
static constexpr GLenum radix::getGlShaderType ( const Shader::Type  type)
static
static constexpr GLenum radix::getGlUsage ( const VBO::Usage  usage)
static
ComponentTypeId radix::getNewComponentTypeId ( )
inline
SystemTypeId radix::getNewSystemTypeId ( )
inline
static btVector3 radix::getNormalizedVector ( const btVector3 &  v)
static
constexpr uint32_t radix::Hash32 ( const std::string &  str)
constexpr uint32_t radix::Hash32 ( const char *  str)
Matrix3f radix::inverse ( const Matrix3f &  m)
Matrix4f radix::inverse ( const Matrix4f &  m)
static bool radix::isReachableBySuccessors ( const SystemGraphNode &  start,
SystemTypeId  targetstid,
const SystemGraphNodeVector &  sinfo,
std::stack< SystemTypeId > &  path 
)
static
float radix::length ( const Vector4f &  v)
inline
constexpr float radix::length2 ( const Vector4f &  v)
inline
bool radix::needBlackText ( int  bgcol)
Vector2f radix::normalize ( const Vector2f &  v)
inline
Vector3f radix::normalize ( const Vector3f &  v)
inline
Vector4f radix::normalize ( const Vector4f &  v)
inline
Quaternion radix::normalize ( const Quaternion &  q)
inline
constexpr VBO::Usage radix::operator| ( const VBO::Usage  a,
const VBO::Usage  b 
)
inline
constexpr float radix::rad ( float  deg)
inline
static void radix::strongconnect ( SystemTypeId &  index,
std::stack< SystemTypeId > &  S,
SystemTypeId  stid,
SystemGraphNode &  si,
SystemGraphNodeVector &  sinfo,
SystemManager::SystemLoopVector &  stronglyConnected 
)
static
Matrix3f radix::toMatrix3f ( const Matrix4f &  m)
Matrix4f radix::toMatrix4f ( const Matrix3f &  m)
Matrix3f radix::transpose ( const Matrix3f &  m)
Matrix4f radix::transpose ( const Matrix4f &  m)

Variable Documentation

const float radix::HURT_VELOCITY = 0.18f
static
float radix::Identity3[3 *3]
static
Initial value:
= {
1.f, 0.f, 0.f,
0.f, 1.f, 0.f,
0.f, 0.f, 1.f
}
float radix::Identity4[4 *4]
static
Initial value:
= {
1.f, 0.f, 0.f, 0.f,
0.f, 1.f, 0.f, 0.f,
0.f, 0.f, 1.f, 0.f,
0.f, 0.f, 0.f, 1.f
}
const float radix::JUMP_SPEED = 0.15f
static
const int radix::MAX_SKIP = 5
constexpr GLint radix::MaxGlLogSize = 1024 * 1024 * 2
static
const std::array<const std::string, 2> radix::PLAYER_FALL_SOUND
static
Initial value:
= {
"/audio/sfx/character/fem_fall_1.ogg",
"/audio/sfx/character/fem_fall_2.ogg"
}
const std::array<const std::string, 6> radix::PLAYER_FOOT_SOUND
static
Initial value:
= {
"/audio/sfx/character/fem_foot_1.ogg",
"/audio/sfx/character/fem_foot_2.ogg",
"/audio/sfx/character/fem_foot_3.ogg",
"/audio/sfx/character/fem_foot_4.ogg",
"/audio/sfx/character/fem_foot_5.ogg",
"/audio/sfx/character/fem_foot_6.ogg"
}
const std::array<const std::string, 2> radix::PLAYER_JUMP_SOUND
static
Initial value:
= {
"/audio/sfx/character/fem_jump_1.ogg",
"/audio/sfx/character/fem_jump_2.ogg"
}
const std::array<const std::string, 2> radix::PLAYER_PANTING_SOUND
static
Initial value:
= {
"/audio/sfx/character/fem_panting_1.ogg",
"/audio/sfx/character/fem_panting_2.ogg"
}
const Vector3f radix::PLAYER_SIZE(0.5, 1, 0.5)
static
const float radix::RUNNING_SPEED = 0.1f
static
const int radix::SKIP_TIME = 1000 / UPDATE_RATE
const int radix::UPDATE_RATE = 60