 |
xyginext
0.2.0
Second generation of xygine game creation framework
|
|
xyginext
0.2.0
Second generation of xygine game creation framework
|
| ▼Nxy | Main xyginext namespace |
| ►NDetail | |
| ►Nui | 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() |
| ►NUtil | |
| ►CApp | Abstract base class for new games or applications |
| CAudioEmitter | 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 |
| CAudioListener | 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 |
| CAudioMixer | 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 |
| CAudioResource | Resource manager for sound files |
| CAudioScape | 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: |
| CAudioSystem | 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 |
| CBaseResource | Abstract base class for resource management |
| CBitmapFont | 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 |
| CBitmapText | 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 |
| CBitmapTextSystem | System used for updating BitmapText components. Entities with a BitmapText component also require a Transform component and Drawable component |
| CBroadphaseComponent | 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 |
| CCallback | Allows attaching a callback function to an entity |
| CCallbackSystem | 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 |
| CCamera | 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 |
| CCameraSystem | 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 |
| CCommand | Command struct. Each command encapsulates a mask of target IDs as well as a command in the form of a std::function |
| CCommandSystem | |
| CCommandTarget | Attaches a command ID bitmask to an Entity. ID should be a bit mask of flags representing target IDs. For example: |
| CComponentManager | |
| CConfigItem | Base class for all items loaded from a configuration file |
| CConfigObject | 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 |
| CConfigProperty | Properties are a name / value pair which can only reside in configuration objects |
| CConsole | 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 |
| CConsoleClient | 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 |
| CDirector | 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 | 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 |
| CDynamicTreeSystem | 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/) |
| CEmitterSettings | Settings used by a particle emitter to initialise new particles |
| CEnetClientImpl | Default networking library implmentation. This should never be used directly |
| CEnetHostImpl | Default implementation of the networking library. This should never be used directly |
| CEntity | 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() |
| CEntityManager | Manages the relationship between an Entity and its components |
| CFileSystem | Utilities for manipulating the current file system |
| CFontResource | Resource manager for Fonts |
| CGuiClient | 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 |
| CImageResource | Resource manager for sf::Image types |
| CLogger | 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 |
| ►CMessage | Message class |
| CMessageBus | System wide message bus for custom event messaging |
| CNetClient | Creates a clientside host which can be used to create a peer connected to a NetHost server |
| CNetClientImpl | |
| ►CNetEvent | Network event. These are used to poll NetHost and NetClient objects for network activity |
| CNetHost | Creates a network host. Network hosts, or servers, can have multiple clients connected to them, via a reliable UDP stream |
| CNetHostImpl | |
| CNetPeer | A peer represents a single, multichannel connection between a client and a host |
| CParticle | Represents a single particle in a system |
| CParticleEmitter | Particle Emitter. Component struct used to emit particles from an entity |
| CParticleSystem | ParticleSystem. Responsible for updating all ParticelEmitter components in the scene, and rendering the output |
| CPostAntique | Antique Post process effect. Creates an old 'filmic' look, with dust, jitter and desaturation |
| CPostBloom | Bloom post process effect |
| CPostBlur | 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 |
| CPostChromeAb | Creates a Chromatic Abberation effect |
| CPostOldSchool | Applies a colour dithering / degredation effect to emulate the appearance of older 16 or 8 bit graphics modes |
| CPostProcess | Abstract base class for full screen post processes |
| CQuadTree | 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 |
| CQuadTreeItem | Entities with a QuadTreeItem and Transform component will be actively partitioned an in QuadTree system which is added to the entities scene |
| CQuadTreeNode | Nodes which make up the branches and leaves of the QuadTree |
| CRenderSystem | 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 |
| CResourceHandler | Class for generic resource management using handles |
| CResourceLoader | Struct responsible for loading resources |
| CScene | 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 |
| CShaderResource | Specialised resource manager for shaders |
| ►CSprite | Sprite component optimised to work with the ECS. Sprite components require their entity to also have a Drawable component and a Transform component |
| CSpriteAnimation | Component which contains information about the currently playing sprite animation. Requires a SpriteAnimator system in the scene |
| CSpriteAnimator | Sprite Animation system. Updates all active animations on entities which have Sprite and SpriteAnimation components |
| CSpriteSheet | Supports loading multiple sprites from a single texture atlas via the ConfigFile format |
| CSpriteSystem | System for updating sprites. Entities with Sprite components also require a Drawable component, as well as a Scene with a RenderSystem |
| ►CState | Abstract base class for xygine states |
| CStateStack | Maintains a stack of active states |
| CSystem | 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 |
| CSystemManager | |
| ►CSysTime | 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 |
| CText | 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' |
| CTextRenderer | 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 |
| CTextSystem | 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' |
| CTextureResource | Resource manager for textures |
| CTransform | 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 |
| CTreeNode | |
| CUIHitBox | Used to trigger callbacks when hit events occur in the component's area |
| CUISystem | 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 |
| CVector4 | 4 component vector class. Useful when storing floating point colour values, particularly with ConfigFile objects |
1.8.18