xy Namespace Reference

Main xyginext namespace. More...

Namespaces
	ui
	Utility functions which act as ImGui wrappers. These are for a convenience, however it is possible to use ImGui directly if preferred. Immediate mode ui information is rendered to the status window via GuiClient::registerTabControl().

Classes
class	App
	Abstract base class for new games or applications. More...
class	AudioEmitter
	Audio emitter component. Audio emitter provide points within the scene to play audio, either one shot effects or streaming music. If the buffer used to supply the audio is monothen the AudioEmitter will be panned spatially relative to the current listener (usually the active scene camera), unless it has been set to absolute positioning. Requires a scene to have an AudioSystem. More...
class	AudioListener
	Audio Listener component. The AudioListener component defines the point at which the active AudioSystem hears any playing AudioSources. Only one listener is active at a time, by default on the Scene's active camera entity. When using mono AudioEmitters spatialisation is calculated based on an AudioSource's position relative to the active AudioListener. More...
class	AudioMixer
	Multichannel Audio mixer class. The AudioMixer allows AudioEmitter components to group their outputs into one of 16 channels, each of which may have their volume adjusted, affecting all of the AudioEmitters currently routed through that channel. The AudioMixer also has a master volume channel which is applied to all subsequent channels. By default AudioEmitter components are assigned to channel 0. For these AudioMixer settings to be applied a scene must have an active AudioSystem. More...
class	AudioResource
	Resource manager for sound files. More...
class	AudioScape
	Contains one or more definitions used to create AudioEmitter components. Similarly to the SpriteSheet class used for loading Sprites from configuration files, AudioScapes can be used to define the settings used to create AudioEmitter components. AudioScape files usually have the extension *.xas with the following ConfigFile compatible layout: More...
class	AudioSystem
	Audio System. While AudioEmitter components will still be audible without and active AudioSystem, and AudioSystem instance is required in the scene to update positional audio, as well as apply the values stored in the AudioMixer. It is, therefore, recommended that any scene which employs AudioEmitter components also has an AudioSystem. More...
class	BaseResource
	Abstract base class for resource management. More...
class	BitmapFont
	Bitmap font class. Bitmap fonts are created by loading a font atlas with the following layout: 10 characters wide, by 10 characters high, starting with ASCII character 32 (space) and ending with ASCII character 126 (tilde). Some or all of the characters may be implemented but unimplemented characters should be left blank. As bitmap fonts are very simplistic anything other than ASCII encoding is not supported. More...
class	BitmapText
	BitmapText class. BitmapText components are used to render text with a BitmapFont. BitmapText work similarly to Text components, in that they require a reference to a BitmapFont that exists at least as long as the BitmapText instance. Entities with a BitmapText component also require a Drawable component and a Transform component. More...
class	BitmapTextSystem
	System used for updating BitmapText components. Entities with a BitmapText component also require a Transform component and Drawable component. More...
struct	BroadphaseComponent
	Entities with broadphase components are returned from dynamic tree queries, which can then be used in collision testing. Narrow phase collision should be performed independently. More...
struct	Callback
	Allows attaching a callback function to an entity. More...
class	CallbackSystem
	Performs a given callback function on an entity. This is useful for behaviour code on entities which aren't used often. For example when a single entity of a type exists and is used rarely it can mean a lot of overhead writing a specific system and component for behaviour which is not often employed. In these cases it's easier to attach a Callback component and supply a function with entity specific behaviour. Overuse of this system is not recommended, however, as there is a certain amount of overhead in calling the behavioural functions, so this system should be reserved for specific cases where it makes sense or for rapid prototying of ideas that may or may not be expanded to a full system. More...
class	Camera
	Represents a 2D camera. Camera components can be attached to entities so that they take on the transform of any transform component, and also be used to bound the game world view. More...
class	CameraSystem
	The camera system updates any camera components which are attached to entities that also have a transform. Properties such as locked rotation or locked axis are applied by this system, so it needs to exist in a scene which uses any camera other than the default one. More...
struct	Command
	Command struct. Each command encapsulates a mask of target IDs as well as a command in the form of a std::function. More...
class	CommandSystem
struct	CommandTarget
	Attaches a command ID bitmask to an Entity. ID should be a bit mask of flags representing target IDs. For example: More...
class	ComponentManager
class	ConfigItem
	Base class for all items loaded from a configuration file. More...
class	ConfigObject
	A configuration object can hold one or more nested objects or configuration properties. All objects require a name, and may have an optional id as a string value. More...
class	ConfigProperty
	Properties are a name / value pair which can only reside in configuration objects. More...
class	Console
	Console class. The console class provides a feedback window and interface with xygine. Any class can register a command with the console as long as it inherits the ConsoleClient interface. More...
class	ConsoleClient
	Interface for registering console commands. To register a command with the console a class needs to inherit this interface, which ensures proper lifetime of console commands which refer to specific instances of an object. More...
class	Director
	Abstract Base Class for Directors. A director is an 'observer' of the scene to which it belongs, and has the ability to command, or direct entities within it. While Directors do not exist within the world, they can receive both external events, such as player input, and system messages emitted from the scene. Based on this input the Director can then use a CommandSystem (one of which is automatically added to the scene when a Director is first added, if it does not exist) to send commands to entities within the scene. For example a Director may take player input, process it then send movement commands to a player entity. It may also be used to implement gameplay rules by using the events it has observed to decide when new enemies should be spawned, where a player should restart and so on. More...
class	Drawable
	Drawable component. The drawable component encapsulates an sf::VertexArray which can be used to draw custom shapes, as well as being required for entities which have a sprite or text component. The purpose of the Drawable component is to allow mixing Sprite, Text and custom drawable types in a single drawing pass with variable depth. A Scene must have a RenderSystem added to it to enable any drawable entities. More...
class	DynamicTreeSystem
	Dynamic AABB tree for broadphase queries. Based on Erin Catto's dynamic tree in Box2D (http://www.box2d.org) which is in turn inspired by Nathanael Presson's btDbvt. (https://pybullet.org/wordpress/) More...
struct	EmitterSettings
	Settings used by a particle emitter to initialise new particles. More...
class	EnetClientImpl
	Default networking library implmentation. This should never be used directly. More...
class	EnetHostImpl
	Default implementation of the networking library. This should never be used directly. More...
class	Entity
	Entity class Entity objects are handles to the underlying collection of components, and as such should be treated similarly to a pointer. That is, they are lightweight enough to copy around, but you should remain aware of the lifetime of the entity being handled, using Entity::isValid() or Entity::destroyed() More...
class	EntityManager
	Manages the relationship between an Entity and its components. More...
class	FileSystem
	Utilities for manipulating the current file system. More...
class	FontResource
	Resource manager for Fonts. More...
class	GuiClient
	Allows registering GUI controls with the default output window, or registering custom windows using the ui namespace. Classes which inherit this interface may register controls with the imgui renderer. This is usually used for debugging output or when creating tooling. More...
class	ImageResource
	Resource manager for sf::Image types. More...
class	Logger
	Class to allowing messages to be logged to a combination of one or more destinations such as the console, log file or output window in Visual Studio. More...
class	Message
	Message class. More...
class	MessageBus
	System wide message bus for custom event messaging. More...
class	NetClient
	Creates a clientside host which can be used to create a peer connected to a NetHost server. More...
class	NetClientImpl
struct	NetEvent
	Network event. These are used to poll NetHost and NetClient objects for network activity. More...
class	NetHost
	Creates a network host. Network hosts, or servers, can have multiple clients connected to them, via a reliable UDP stream. More...
class	NetHostImpl
struct	NetPeer
	A peer represents a single, multichannel connection between a client and a host. More...
struct	Particle
	Represents a single particle in a system. More...
class	ParticleEmitter
	Particle Emitter. Component struct used to emit particles from an entity. More...
class	ParticleSystem
	ParticleSystem. Responsible for updating all ParticelEmitter components in the scene, and rendering the output. More...
class	PostAntique
	Antique Post process effect. Creates an old 'filmic' look, with dust, jitter and desaturation. More...
class	PostBloom
	Bloom post process effect. More...
class	PostBlur
	Post process effect which applies a screen-wide gaussian blur. This effect can be enabled and disabled as needed via direct call to setEnabled(). Blur amount is animated when enabling or disabling for a smoother transition. More...
class	PostChromeAb
	Creates a Chromatic Abberation effect. More...
class	PostOldSchool
	Applies a colour dithering / degredation effect to emulate the appearance of older 16 or 8 bit graphics modes. More...
class	PostProcess
	Abstract base class for full screen post processes. More...
class	QuadTree
	Partition system for entities with QuadTreeItem components. Entities are sorted in a tree hierarchy which can be queried with a given area to return a set of entities which are contained or intersect said area. Generally more useful for scenes with a lot of static entities such as a platform game with fixed scenery. If using a scene with a lot of dynamic objects consider using xy::DynamicTreeSystem instead. More...
class	QuadTreeItem
	Entities with a QuadTreeItem and Transform component will be actively partitioned an in QuadTree system which is added to the entities scene. More...
class	QuadTreeNode
	Nodes which make up the branches and leaves of the QuadTree. More...
class	RenderSystem
	Used to draw all entities which have a Drawable and Transform component. The RenderSystem is used to depth sort and draw all entities which have a Drawable and Transform component attached, and optionally a Sprite component. NOTE multiple components which rely on a Drawable component cannot exist on the same entity, as only one set of vertices will be available. More...
class	ResourceHandler
	Class for generic resource management using handles. More...
struct	ResourceLoader
	Struct responsible for loading resources. More...
class	Scene
	Encapsulates a single scene. The scene class contains everything needed to create a scene graph by encapsulating the ECS and providing factory functions for entities. Multple scenes can exist at one time, for instance one to draw the game world, and another to draw the HUD. Everything is rendered through renderable systems which, in turn, require an ECS - therefore every state which wishes to draw something requires at least a scene, right down to menus. All systems should be added before attempting to create any entities else existing entities will not be processed by new systems. More...
class	ShaderResource
	Specialised resource manager for shaders. More...
class	Sprite
	Sprite component optimised to work with the ECS. Sprite components require their entity to also have a Drawable component and a Transform component. More...
struct	SpriteAnimation
	Component which contains information about the currently playing sprite animation. Requires a SpriteAnimator system in the scene. More...
class	SpriteAnimator
	Sprite Animation system. Updates all active animations on entities which have Sprite and SpriteAnimation components. More...
class	SpriteSheet
	Supports loading multiple sprites from a single texture atlas via the ConfigFile format. More...
class	SpriteSystem
	System for updating sprites. Entities with Sprite components also require a Drawable component, as well as a Scene with a RenderSystem. More...
class	State
	Abstract base class for xygine states. More...
class	StateStack
	Maintains a stack of active states. More...
class	System
	Base class for systems. Systems should all derive from this base class, and instanciated before any entities are created. Concrete system types should declare a list component types via requireComponent() on construction, so that only entities with the relevant components are added to the system. More...
class	SystemManager
class	SysTime
	Static functions for common date/time queries using the system clock. These are not thread safe so appropriate care should be taken when accessing the time from multiple threads. More...
class	Text
	ECS friendly implementation of Text. Text components should appear on entities which also have a transform and drawable component. Text is drawn with a RenderSystem. NOTE As text is rendered via a drawable component in the same way as sprites and other drawables, the drawable component should use setDepth() to increase the depth value of a text renderable so that it appears above other drawables. This should be the first thing to check if text appears 'invisible'. More...
class	TextRenderer
	System for rendering text objects. Usually this would be added last to the Scene after existing drawable systems, as the text ought to be rendered on top of everything else DEPRECATED: use the TextSystem and RenderSystem with Text components and Drawable components. More...
class	TextSystem
	Updates the vertices of the drawable components associated with Text components. NOTE As text is rendered via a drawable component in the same way as sprites and other drawables, the drawable component should use setDepth() to increase the depth value of a text renderable so that it appears above other drawables. This should be the first thing to check if text appears 'invisible'. More...
class	TextureResource
	Resource manager for textures. More...
class	Transform
	Wraps the SFML transformable class in a component friendly format, parentable to other transforms in a scene graph hierachy. Transforms are non-copyable, but are moveable. More...
struct	TreeNode
class	UIHitBox
	Used to trigger callbacks when hit events occur in the component's area. More...
class	UISystem
	Updates entities with UIHitBox components. Any entity with a UIHitBox component will be processed by this system, which detects user input and activates the appropriate callback as necessary. More...
class	Vector4
	4 component vector class. Useful when storing floating point colour values, particularly with ConfigFile objects More...

Typedefs
using	ConfigFile = xy::ConfigObject
using	StateID = sf::Int32
using	Vector4i = Vector4< int >
using	Vector4f = Vector4< float >
using	CallbackFunction = std::function< void(Entity, float)>
using	ComponentMask = std::bitset< Detail::MaxComponents >
using	UniqueType = std::type_index
using	ResourceHandle = std::size_t
	Handle for a Resource. More...
using	ResourceHolder = ResourceHandler

Enumerations
enum	NetFlag { Reliable = 0x1, NetFlag::Unsequenced = 0x2, NetFlag::Unreliable = 0x4 }
	Reliability enum. These are used to flag sent packets with a requested reliability. More...

Functions
static const sf::Vector2f	DefaultSceneSize (1920.f, 1080.f)
template<typename T >
Vector4< T >	operator- (const Vector4< T > &left)
	Overload of unary operator -.
template<typename T >
Vector4< T > &	operator+= (Vector4< T > &left, const Vector4< T > &right)
	Overload of binary operator +=.
template<typename T >
Vector4< T > &	operator-= (Vector4< T > &left, const Vector4< T > &right)
	Overload of binary operator -=.
template<typename T >
Vector4< T >	operator+ (const Vector4< T > &left, const Vector4< T > &right)
	Overload of binary operator +.
template<typename T >
Vector4< T >	operator- (const Vector4< T > &left, const Vector4< T > &right)
	Overload of binary operator -.
template<typename T >
Vector4< T >	operator* (const Vector4< T > &left, T right)
	Overload of binary operator *.
template<typename T >
Vector4< T >	operator* (T left, const Vector4< T > &right)
	Overload of binary operator *.
template<typename T >
Vector4< T > &	operator*= (Vector4< T > &left, T right)
	Overload of binary operator *=.
template<typename T >
Vector4< T >	operator/ (const Vector4< T > &left, T right)
	Overload of binary operator /.
template<typename T >
Vector4< T > &	operator/= (Vector4< T > &left, T right)
	Overload of binary operator /=.
template<typename T >
bool	operator== (const Vector4< T > &left, const Vector4< T > &right)
	Overload of binary operator ==.
template<typename T >
bool	operator!= (const Vector4< T > &left, const Vector4< T > &right)
	Overload of binary operator !=.

Variables
static constexpr std::size_t	MessageSize = sizeof(Message)

Detailed Description

Main xyginext namespace.

/brief Interface for networking implementations. By default the networking classes wrap the enet library, although in some cases it may be desirable to use 3rd party networking such as that available in the Steam API. This interface is designed to allow flexible switching of services. For NetClient and NetHost the type can be provided by the create<T>() and start<T>() functions respectively.

Typedef Documentation

ResourceHandle

using xy::ResourceHandle = typedef std::size_t

Handle for a Resource.

Basically just an index to the resource in the vector

Enumeration Type Documentation

NetFlag

enum xy::NetFlag

strong

Reliability enum. These are used to flag sent packets with a requested reliability.

Enumerator
Unsequenced	<packet must be received by the remote connection, and resend attemps are made until delivered
Unreliable	<packet will not be sequenced with other packets. Not supported on reliable packets