| CMochi::Graphics::AbstractGUI | An abstract class meant to be extended with specific implementations for different renderers. It also provides basic methods called on update to manage navigation in the vertical axis. All overrideable methods on this class are meant to provide ways to implement a simple immediate GUI, not a stateful GUI |
| CMochi::Graphics::DummyGUI | |
| CMochi::Graphics::SDLGUI | Implementation of AbstractGUI that uses SDLRenderer and SDLTTF to show GUI elements |
| CMochi::Graphics::AbstractTextureFactory | This class must be inherited to generate textures of a compatible type with its own renderer |
| CMochi::Graphics::DummyTextureFactory | |
| CMochi::Graphics::SDLTextureFactory | This implementation of AbstractTextureFactory just loads textures using the SDL_Renderer provided in the constructor |
| CMochi::Input::Action | Set of performable actions that will be used to compute an "or" operation, making an action be considered performed if any of its performable actions are being performed |
| CMochi::ActionManagerSwappedEvent | |
| CMochi::Graphics::AnimationsData | All data needed to represent a set of animations for a sprite. It mostly contains a list of frames contained in the spritesheet and the metadata of the animations, which references the indexes |
| CMochi::ApplicationQuitEvent | |
| CMochi::AudioManagerSwappedEvent | |
| CMochi::Graphics::Camera | Allows conversion between a engine-defined world space and screen space. This class doesn't do any special process with the renderer, it just transforms positions of points and rects between world and screen |
| CMochi::CameraSwappedEvent | |
| CMochi::Time::Chrono | Utility class to count the pass of time. If ticked each frame, GetTime will return the passed time since the Chrono was created |
| CMochi::Color | Unsigned int vector of 4 elements, with the rgb elements of the color and an alpha channel. It also has automatic conversion to SDL_Color for ease of use with SDL |
| CMochi::Engine | Main class of the MochiEngine. It owns and coordinates all subsystems and layers, and drives the application lifecycle |
| CMochi::Event::EventBus | The event bus is a Pub-Sub implementation that accepts any type as event data |
| CMochi::FS::FileEntry | |
| CMochi::Audio::FMODMarkerEvent | |
| CMochi::Graphics::FrameData | |
| CMochi::Debug::FrameProfiler | A very simple profiler that captures the time spent between two lines of code and structures those times in sections |
| CMochi::Graphics::FrameTag | |
| CMochi::GamepadAddedEvent | |
| CMochi::Input::GamepadData | Data for Axis and Buttos of a single gamepad |
| CMochi::GamepadRemovedEvent | |
| CMochi::Graphics::GUIButtonOptions | The button options is a composite of 3 GUIOptions: the default, the focus and pressed states. It allows to, for example, make a button smaller when focused, or changing tints between states |
| CMochi::Graphics::GUIOptions | Options used by graphical GUI. This contains all the minimal data to show a sprite, including the path of the texture. Optional elements of the struct will be defaulted by the GUI implementation if not defined |
| CMochi::Graphics::GUIResult | Gives the space occupied by the GUI element, to be used as a parent of other GUI elements |
| CMochi::Graphics::GUIResultButton | Besides the space occupied by the button to be used as a parent, it gives its current state, indicating if it is focused (selected or focused by mouse), pressed or released. This way a button can trigger game logic when being pressed or release without changing the implementation |
| CMochi::Graphics::GUITextOptions | Options used by the graphical GUI specifically for texts. This contains all the minimal data to show text, besides the actual text. Optional elements of the struct will be defaulted by the GUI implementation if not defined |
| CMochi::Input::IActionManager | IActionManager is an interface with the purpose of giving the ability to identify which actions are being performed by the player. Do not mistake this by an input manager that returns true or false if some key is pressed. An action manager should identify is a button or key has been pressed this frame, or released, or the relative value of an analog control like a joystick. The responsibility of those features comes with the implementation |
| CMochi::Input::ActionManager | Implementation of IActionManager meant to be used on any context where the user has control over the game. Expected flow for this class is creating it, loading the actions config file, updating it each frame and checking the state of the actions at any time |
| CMochi::Input::VirtualActionManager | An implementation of IActionManager that receives mock action states and allows to poll them when needed. This is useful for testing and can be a base for emulating player actions on replays or similar features |
| CMochi::Graphics::IAnimationFactory | This interface is to implement different ways to generate the animation data depending on the source of the animation data |
| CMochi::Graphics::AsepriteAnimationFactory | This AnimationFactory takes Aseprites spritesheet export format and automatically generates all needed animation data for that spritesheet |
| CMochi::Graphics::DummyAnimationFactory | |
| CMochi::Audio::IAudioManager | Interface for audio management, including loading and unloading audio, playing it, changing volume and other parameters |
| CMochi::Audio::DummyAudioManager | |
| CMochi::Audio::FMODWrapper | Implementation of IAudioManager wrapping the C API of FMOD and FMOD Studio. FMOD uses audio banks generated with FMOD Studio instead of plain audio files |
| CMochi::Audio::SDLAudio | |
| CMochi::FS::IFileLoader | Interface to get files that are part of the game data. Note that the interface does not have any save or write function. This is not meant to create persistent file systems, but to create virtual file systems from which to read |
| CMochi::FS::PackFile | PackFile is a class with two purposes. First, it implements IFileLoader, allowing to be used as a simple file system. Second, it has the Pack and Unpack methods, used to create .pak files, used by this file system. Creating .pak files has several benefits. The first one is obfuscation, making it more difficult to end users to get access to your game assets. The second one is being loaded as a stream, as it allows to only load what is needed at the moment. It also is easily extended to, for example, zip all or only specific files, reducing final build size. Ownership: |
| CMochi::FS::SystemFileLoader | This class creates a very simple virtual file system from a directory. This allows read access to all files in that directory referencing them from their path as a unique identifier. As this doesn't give the benefits of asset obfuscation, it is only used on debug mode, and can't be configured at the moment |
| CMochi::Input::IGamepadProvider | |
| CMochi::Input::DummyGamepadProvider | |
| CMochi::Input::SDLGamepadProvider | Implementation of IGamepadProvider that uses SDL_GetGamepadAxis and SDL_GetGamepadButton to retrieve gamepad data |
| CMochi::Debug::IGizmos | Interface to show different debug gizmos during the game, useful for debugging positions, directions, collisions.. |
| CMochi::Debug::SDLGizmos | Implementation of IGizmos using SDL primitive methods for drawing shapes |
| CMochi::Graphics::DummyGizmos | |
| CMochi::Input::IKeyboardProvider | |
| CMochi::Input::DummyKeyboardProvider | |
| CMochi::Input::SDLKeyboardProvider | Implementation of IKeyboardProvider that uses SDL_GetKeyboardState to retrieve keyboard data |
| CMochi::Input::IMouseProvider | |
| CMochi::Input::DummyMouseProvider | |
| CMochi::Input::SDLMouseProvider | Implementation of IMouseProvider that uses SDL_GetMouseState and SDL_RenderCoordinatesFromWindow to retrieve mouse data |
| CMochi::Input::InputManager | Class that takes one IKeyboardProvider, one IMouseProvider and one IGamepadProvider and updates and collects data from them each frame automatically. It provides functions to poll the state of each provider, used by the ActionManager. This class is not meant to be implemented differently in any way, as it already receives different sets of providers for that purpose |
| CMochi::Input::IPerformableAction | An interface defining if an action is being performed and what its value is for a single trigger |
| CMochi::Input::PerformableActionGamepad | IPerformableAction implementation to check if actions requiring a gamepad button are being performed |
| CMochi::Input::PerformableActionGamepadAxis | IPerformableAction implementation to check the value of actions requiring gamepad axis |
| CMochi::Input::PerformableActionKeyboard | IPerformableAction implementation to check if actions requiring a keyboard key are being performed |
| CMochi::Input::PerformableActionMouse | IPerformableAction implementation to check if actions requiring a mouse button are being performed |
| CMochi::Input::PerformableActionMouseAxis | IPerformableAction implementation to check the value of actions requiring mouse position |
| CMochi::Graphics::IRenderer | This interface provides means to show graphics in the game and create the subsystems needed to create textures for the same renderer and GUI using the same renderer |
| CMochi::Graphics::DummyRenderer | |
| CMochi::Graphics::SDLRenderer | This class allows rendering with SDL3 in "the simple way", that is showing textures with SDL_RenderTexture instead of using the GPU module |
| CMochi::Event::ISystemEventDispatcher | Interface to poll the events of the operative system (input, window controls, application exit...) |
| CMochi::Event::DummyEventDispatcher | |
| CMochi::Event::SDLSystemEventDispatcher | Implementation of the ISystemEventDispatcher using the SDL_PollEvent method to retrieve the operative system events |
| CMochi::Graphics::ITexture | A texture interface to be implemented by renderer specific textures |
| CMochi::Graphics::DummyTexture | |
| CMochi::Graphics::SDLTexture | An implementation of ITexture used by SDLRenderer |
| CMochi::Layer | The layer class offers a simple way to organize domains of the application while having access to most of the Engine subsystems. Note that a layer is meant to be inherited from and can't be instantated as is. A layer will Update, Render and show the GUI as a small Engine class. So the layer is just a convenient responsability separator. Ownership: |
| CMochi::DebugLayer | The debug layer is a layer automatically injected in the Engine if the game is in debug mode. It provides a text indicating that it is a development build, an FPS counter and two perpendicular lines crossing at the center of the screen |
| CMochi::Scripting::ScriptingLayer | This layer is automatically injected in the engine in the setup phase and is designed to bind several useful methods to the lua environment and take ownership of entities generated by lua |
| CMochi::FS::PackCatalog | The pack catalog is a class that creates and owns file loaders and acts as a combined catalog for all of them at once. This means that opening pack A and pack B allows you to use GetFile with files that are in any or both of them. As it searches in reverse order of pack opening, files of the last opened packs are prioritized when using GetFile and HasFile, which allows you to "override" assets of a previous pack, allowing a simple but effective way of modding. Each file system inside the catalog starts at the root, so it is needed the same folder structure in two file systems to be able to override. Example: Pack A |
| CMochi::FS::PackHeader | |
| CMochi::Rectf | Float vector of 4 positions with an X, Y, W and H elements defining a rectangle and conversion with SDL_FRect for ease of use with SDL. It allows basic operations with other rectangles, vectors or scalars |
| CMochi::Graphics::RenderCommand | Defines a full rendering unit, which for the purpose of the engine is a texture (or part of it) on a specific point in space. Additionaly, it allows to present the texture based on the world or the screen position and in a tiled format, if needed. If TiledRenderOptions is not set, the texture will not be tiled |
| CMochi::RendererSwappedEvent | |
| Cstd::runtime_error | |
| CMochi::EngineError | Generic error that can be thrown inside the MochiEngine |
| CMochi::AudioOperationError | Specific implementation of EngineError thrown when there is an error on the audio subsystem |
| CMochi::MalformedInputAction | Specific implementation of EngineError thrown when actions loaded by an Input::IActionManager are malformed |
| CMochi::ResourceNotFoundError | Specific implementation of EngineError for resources that are not found in the specified path |
| CMochi::SystemInitializationError | Specific implementation of EngineError for subsystems that have not been initialized correctly |
| CMochi::Scripting::ScriptingManager | ScriptingManager is a class containing the necessary methods to load and execute lua scripts binded to the C++ code |
| CMochi::Physics::Shape | Abstract class representing a position in space where a physics shape is. This is meant to be extended and used for checking for collisions between different types of shapes |
| CMochi::Physics::Circle | Class representing a circle in space. The position represents the center of the circle, and the radius is, of course, the radius. This is meant to be used for checking for collisions between different types of shapes |
| CMochi::Physics::Line | Class representing a line between two points in space. The inherited position variable is the start of the line, and the end point is where it ends. This is meant to be used for checking for collisions between different types of shapes |
| CMochi::Physics::Point | Class representing a point in space. This is meant to be used for checking for collisions between different types of shapes |
| CMochi::Physics::Rectangle | Class representing a rectangle in space. The position is the center of the rectangle, and the extents is half the size (so, distance between the center and outermost part of the rectangle). This is meant to be used for checking for collisions between different types of shapes |
| CMochi::Graphics::SpriteBase | This class contains all the necessary data to show textures on screen |
| CMochi::Graphics::Spritesheet | Spritesheet takes all the functionality of SpriteBase, generates animation data for the texture, and expects it to be used manually |
| CMochi::Graphics::AnimatedSprite | AnimatedSprite does all the Spritesheet does and also provides an easy interface to animate and select animations for the sprite |
| CMochi::Graphics::OneshotAnimation | OneshotAnimation is an AnimatedSprite limited to a single loop of an animation. It features a callback that is called when finishing that animation loop. This makes the class useful for oneshot effects like explosions, and allows to destroy or hide them after finishing |
| CMochi::Graphics::TiledRenderOptions | |
| CMochi::Time::Timer | Utility class to count the pass of time. If ticked each frame, IsDone will return true when the time parameter in the construction has passed. It will also show the passed time like a Chrono in GetTime and the difference between the construction time and GetTime with GetRemainingTime |
| CMochi::Time::TimeSystem | Class that provides several time values useful for game development |
| CMochi::Transform | Minimal transform with a position and scale. Rotation is deliberately omited because of the incompatibility with pixel art. This class is meant to represent the space occupied by an entity, and reused for several elements of that same entity, as the game logic, sprite or collider |
| CMochi::Vector2f | Float vector of two positions with an X and Y elements and conversion with SDL_FPoint for ease of use with SDL. It allows basic operations like sum, substraction, multiplication and division of vectors, and also multiplication and division with scalars. It also gives useful methods like the Dot, or the length of the vector (the Distance from 0,0) |
1.16.1