| NPhysicsCSAlevlProject | |
| CGame1 | Sign-in, authentication, and assignment/teacher window functionality |
| CConsoleCommandAttribute | Attribute to mark methods as console commands. The CommandPath property specifies the command path that will be used to invoke the method from the debug console. For example, a method marked with [ConsoleCommand("Mesh.AddTire")] can be invoked by entering "Mesh.AddTire" in the debug console, along with any required parameters. This attribute allows for easy registration and organization of debug commands within the application |
| CCommandRegistry | Registry for console commands that can be invoked from the debug console. This class allows for registering methods as console commands using the ConsoleCommandAttribute, and provides functionality to invoke these commands based on user input. The commands are stored in a dictionary for efficient lookup, and the registry supports invoking commands with parameters as well as listing all registered commands. This system enables a flexible and extensible way to add debug functionality to the application without hardcoding command handling logic in the main game loop |
| CImGuiLogger | Logger class for ImGui with support for different types of logs, auto condensing for repeated messages and colouring of the logs also includes a debug console support with command history |
| CMessageLog | Represents a log message with its content, count of occurrences, and log type (info, warning, error). This class is used to store log messages in the ImGuiLogger, allowing for features like message aggregation (counting repeated messages) and categorization by log type for filtering and display purposes in the debug console. Each MessageLog instance contains the actual log message, how many times it has been logged (for repeated messages), and the type of log to determine how it should be displayed in the UI |
| CCommand | Represents a console command with its command path, command name, and parameters. This class is used to store commands that are entered by the user in the debug console, allowing them to be queued for execution. Each Command instance contains the full path of the command (split into parts), the specific command to execute, and any parameters that were provided with the command. This structure enables the CommandRegistry to look up and invoke the correct method based on the command path and name when processing user input from the debug console |
| CFactory | Base class for factories that create different types of structures in the mesh. Each factory has a name, a method to execute when the factory is invoked, and a dictionary of parameters that can be configured by the user. The Factory class serves as a template for specific factories like TireFactory and ClothFactory, which define their own parameters and methods for creating specific structures in the mesh. This design allows for easy extension by simply creating new factory classes that inherit from Factory and implement their own creation logic and parameters. The factories can then be used in the UI to allow users to quickly create complex structures with configurable parameters without needing to write custom code for each structure type |
| CTireFactory | Factory for creating a hub-and-spoke tire structure in the mesh |
| CClothFactory | /// Factory for creating a rectangular cloth structure in the mesh |
| CGame1Database | |
| CUser | Class repesenting the User in the datbase matching the Users table with properties for Id, Username, RoleId and Password. This class is used to deserialize user information retrieved from the database and to create new users when saving to the database. It provides a structured way to represent user data within the application and facilitates interactions with the database for user-related operations |
| CStructureInfo | Class representing the structure information retrieved from the database, including properties for Id, AssignmentId, StudentId, StudentName, AssignmentTitle and SubmittedAt |
| CAssignment | Class representing an assignment in the database with properties for Id, Title, Description and TeacherId |
| CRoles | Class representing user roles in the database with static readonly properties for Teacher and Student role IDs |
| CCollider | The Collider class is the base class for all types of colliders this is so that they can be stored in the same list and used for collision detection |
| CCircleCollider | The CircleCollider class represents a circular collider with a specified radius and position |
| CRectangleCollider | The RectangleCollider class represents an axis-aligned rectangular collider defined by a Rectangle structure |
| CSeperatedAxisRectangleCollider | The SeperatedAxisRectangleCollider class represents a rectangle collider that can be rotated and uses the Separating Axis Theorem (SAT) for collision detection |
| CPolygonSeperatedAxisCollider | General polygon collider that uses the Separating Axis Theorem (SAT) for collision detection, which can represent any shape not self intersectiong such as rectangles, triangles, and more complex polygons |
| CFileWriteableMesh | The FileWriteableMesh class serves as a serializable representation of the Mesh class, allowing for easy saving and loading of mesh data to and from JSON format. It contains nested classes for particle and stick data, as well as collider information, and provides methods to convert between the FileWriteableMesh and the original Mesh class. This design enables the application to persist mesh configurations, including particle properties, stick connections, and colliders, while also supporting oscillating particles with their specific parameters. The ToMesh method reconstructs a Mesh instance from the stored data, ensuring that all relevant properties are correctly transferred for accurate physics simulations when loaded back into the application |
| COscillationData | Stores the data for a oscilating particle in a way that can be easily serialized to json, no anchor position as that is stored as the main position of the particle, but includes the amplitude, frequency and angle of the oscilation |
| CparticleData | Stores the data for a particle in a way that can be easily serialized to json |
| CstickData | Stores the data for a stick in a way that can be easily serialized to json |
| CMesh | The Mesh class stores everything that should be loadable in and savebal for undo/redo functionality to file saving |
| CMeshStick | |
| CParticle | The Particle class represents a single particle in the physics simulation, containing properties such as position, mass, accumulated force, and whether it is pinned or selected. The DrawableParticle class extends Particle by adding visual properties like color and size, and includes a method to draw itself using a SpriteBatch and PrimitiveBatch. The OscillatingParticle class further extends DrawableParticle to include oscillation parameters such as amplitude, frequency, and angle, allowing it to move in a sinusoidal pattern around an anchor position. This design allows for flexible representation of particles in the simulation, supporting both static and dynamic behaviors while also providing visual feedback for rendering |
| CDrawableParticle | |
| COscillatingParticle | OscillatingParticle class extends DrawableParticle to include oscillation parameters such as amplitude, frequency, and angle, allowing it to move in a sinusoidal pattern around an anchor position. The UpdateOscillation method updates the particle's position based on the oscillation parameters and the elapsed time, creating a dynamic movement effect. The SetAnchorPosition method allows changing the anchor point around which the particle oscillates, providing flexibility in how the particle behaves within the simulation |
| CStick | The Stick class represents a connection between two particles in the physics simulation, defined by its endpoints (P1 and P2) and its natural length. The DrawableStick class extends Stick by adding visual properties such as color and width, and includes a method to draw itself using a SpriteBatch and PrimitiveBatch. The IsCut property allows for simulating stick breakage, where a stick can be marked as cut to prevent it from being drawn or participating in physics interactions. This design allows for flexible representation of connections between particles, supporting both intact and broken sticks while also providing visual feedback for rendering the mesh structure |
| CDrawableStick | |
| CTool | |
| CProgram | |
| NVectorGraphics | |
| CPrimitiveBatch | The PrimitiveBatch class is responsible for drawing basic shapes such as lines, circles, rectangles, and triangles using a SpriteBatch. It creates textures for a white pixel and a filled circle, which are used to draw the shapes. T |
| CShape | Base class for all shapes that can be drawn using the PrimitiveBatch. Each shape has a position, color and a filled property to determine if the shape should be filled or just an outline |
| CLine | Represents a line shape defined by a start position, an end position, a color, and a width. The line can be drawn using the Draw method, which calculates the angle and length of the line to properly render it using the white pixel texture. The ConstrainToSide method is used to constrain a point to one side of the line, which can be useful for collision detection or ensuring that particles do not cross the line |
| CCircle | Represents a circle shape defined by a center position, a radius, a color, and a filled property |
| CRectangle | |
| CRoundedRectangle | |
| CRectangleTexture | |
| CPixel | |
| CTriangle | |
| CArrow | |
1.16.1