Class Hierarchy

This inheritance list is sorted roughly, but not completely, alphabetically:

[detail level 12345]

Cxy::Sprite::Animation	Represents a single animation
Cxy::App	Abstract base class for new games or applications
Cxy::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
Cxy::Message::AudioEvent	Events raised by the AudioSystem
Cxy::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
Cxy::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
Cxy::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:
►Cxy::Detail::AudioSourceImpl
Cxy::Detail::AudioMusic
Cxy::Detail::AudioNull
Cxy::Detail::AudioSound
Cxy::BaseResource< T >	Abstract base class for resource management
►Cxy::BaseResource< sf::Font >
Cxy::FontResource	Resource manager for Fonts
►Cxy::BaseResource< sf::Image >
Cxy::ImageResource	Resource manager for sf::Image types
►Cxy::BaseResource< sf::SoundBuffer >
Cxy::AudioResource	Resource manager for sound files
►Cxy::BaseResource< sf::Texture >
Cxy::TextureResource	Resource manager for textures
Cxy::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
Cxy::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
Cxy::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
Cxy::Callback	Allows attaching a callback function to an entity
Cxy::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
Cxy::Command	Command struct. Each command encapsulates a mask of target IDs as well as a command in the form of a std::function
Cxy::CommandTarget	Attaches a command ID bitmask to an Entity. ID should be a bit mask of flags representing target IDs. For example:
Cxy::ComponentManager
►Cxy::ConfigItem	Base class for all items loaded from a configuration file
Cxy::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
Cxy::ConfigProperty	Properties are a name / value pair which can only reside in configuration objects
Cxy::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
Cxy::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
Cxy::State::Context	Contains information about the current application context
Cxy::SysTime::Data	Struct containing data/time information
Cxy::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
►CDrawable
Cxy::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
Cxy::ParticleSystem	ParticleSystem. Responsible for updating all ParticelEmitter components in the scene, and rendering the output
Cxy::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
Cxy::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
Cxy::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
Cxy::EmitterSettings	Settings used by a particle emitter to initialise new particles
Cxy::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()
Cxy::EntityManager	Manages the relationship between an Entity and its components
Cxy::FileSystem	Utilities for manipulating the current file system
Cxy::Detail::FixedStack< T, SIZE >
►Cxy::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
Cxy::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
Cxy::SystemManager
►Cstd::ios_base	STL class
►Cstd::basic_ios< Char >	STL class
►Cstd::basic_ostream< Char >	STL class
►Cstd::ostream	STL class
Cxy::Detail::LogStream
Cxy::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
Cxy::Message	Message class
Cxy::MessageBus	System wide message bus for custom event messaging
Cxy::NetClient	Creates a clientside host which can be used to create a peer connected to a NetHost server
►Cxy::NetClientImpl
Cxy::EnetClientImpl	Default networking library implmentation. This should never be used directly
Cxy::NetEvent	Network event. These are used to poll NetHost and NetClient objects for network activity
Cxy::NetHost	Creates a network host. Network hosts, or servers, can have multiple clients connected to them, via a reliable UDP stream
►Cxy::NetHostImpl
Cxy::EnetHostImpl	Default implementation of the networking library. This should never be used directly
Cxy::NetPeer	A peer represents a single, multichannel connection between a client and a host
Cxy::NetEvent::Packet	Event packet. Contains packet data recieved by PacketRecieved event. Not valid for other event types
Cxy::Particle	Represents a single particle in a system
Cxy::ParticleEmitter	Particle Emitter. Component struct used to emit particles from an entity
►Cxy::Detail::Pool
Cxy::Detail::ComponentPool< T >	Memory pooling for components
►Cxy::PostProcess	Abstract base class for full screen post processes
Cxy::PostAntique	Antique Post process effect. Creates an old 'filmic' look, with dust, jitter and desaturation
Cxy::PostBloom	Bloom post process effect
Cxy::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
Cxy::PostChromeAb	Creates a Chromatic Abberation effect
Cxy::PostOldSchool	Applies a colour dithering / degredation effect to emulate the appearance of older 16 or 8 bit graphics modes
Cxy::QuadTreeItem	Entities with a QuadTreeItem and Transform component will be actively partitioned an in QuadTree system which is added to the entities scene
Cxy::QuadTreeNode	Nodes which make up the branches and leaves of the QuadTree
Cxy::ResourceHandler	Class for generic resource management using handles
Cxy::ResourceLoader	Struct responsible for loading resources
Cxy::Message::SceneEvent	Events raised by the Scecne class
Cxy::ShaderResource	Specialised resource manager for shaders
Cxy::Sprite	Sprite component optimised to work with the ECS. Sprite components require their entity to also have a Drawable component and a Transform component
Cxy::SpriteAnimation	Component which contains information about the currently playing sprite animation. Requires a SpriteAnimator system in the scene
Cxy::SpriteSheet	Supports loading multiple sprites from a single texture atlas via the ConfigFile format
Cxy::State	Abstract base class for xygine states
Cxy::Message::StateEvent	Events raised by the StateStack
Cxy::StateStack	Maintains a stack of active states
►Cstreambuf
Cxy::Detail::LogBuf
Cxy::ui::Style
►Cxy::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
Cxy::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
Cxy::BitmapTextSystem	System used for updating BitmapText components. Entities with a BitmapText component also require a Transform component and Drawable component
Cxy::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
Cxy::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
Cxy::CommandSystem
Cxy::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/)
Cxy::ParticleSystem	ParticleSystem. Responsible for updating all ParticelEmitter components in the scene, and rendering the output
Cxy::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
Cxy::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
Cxy::SpriteAnimator	Sprite Animation system. Updates all active animations on entities which have Sprite and SpriteAnimation components
Cxy::SpriteSystem	System for updating sprites. Entities with Sprite components also require a Drawable component, as well as a Scene with a RenderSystem
Cxy::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
Cxy::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'
Cxy::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
Cxy::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
Cxy::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'
►CTransformable
Cxy::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
Cxy::TreeNode
Cxy::UIHitBox	Used to trigger callbacks when hit events occur in the component's area
Cxy::Vector4< T >	4 component vector class. Useful when storing floating point colour values, particularly with ConfigFile objects
Cxy::App::VideoSettings	VideoSettings struct
Cxy::Message::WindowEvent	Events raised by the RenderWindow