Game Engine Architecture
Game Engine Architecture
Game Engine Architecture
Module:
Module:
Module:
Game Engine Architecture IMAT3904
Game Engine Architecture IMAT3904
Game Engine Architecture IMAT3904
Project Duration:
Project Duration:
Project Duration:
2 months
2 months
2 months
Language:
C++
Year:
Year:
Year:
2024
2024
2024
Overview
For the "Game Engine Architecture" module, I developed a basic 3D game engine using C++, OpenGL, and GLFW. The engine includes core functionalities like a rendering system, user input handling, event management, and logging. The rendering system supports basic 3D objects like cubes and pyramids, applies textures, and implements simple lighting through shaders. User input is managed via keyboard and mouse interactions, allowing objects in the scene to be moved and manipulated. The event system handles various interactions, such as window resizing, key presses, and mouse movements, while the logging system uses spdlog to track events and errors. The engine was built with a focus on modularity and extensibility, though the scope was limited due to time constraints and personal challenges.
For the "Game Engine Architecture" module, I developed a basic 3D game engine using C++, OpenGL, and GLFW. The engine includes core functionalities like a rendering system, user input handling, event management, and logging. The rendering system supports basic 3D objects like cubes and pyramids, applies textures, and implements simple lighting through shaders. User input is managed via keyboard and mouse interactions, allowing objects in the scene to be moved and manipulated. The event system handles various interactions, such as window resizing, key presses, and mouse movements, while the logging system uses spdlog to track events and errors. The engine was built with a focus on modularity and extensibility, though the scope was limited due to time constraints and personal challenges.
For the "Game Engine Architecture" module, I developed a basic 3D game engine using C++, OpenGL, and GLFW. The engine includes core functionalities like a rendering system, user input handling, event management, and logging. The rendering system supports basic 3D objects like cubes and pyramids, applies textures, and implements simple lighting through shaders. User input is managed via keyboard and mouse interactions, allowing objects in the scene to be moved and manipulated. The event system handles various interactions, such as window resizing, key presses, and mouse movements, while the logging system uses spdlog to track events and errors. The engine was built with a focus on modularity and extensibility, though the scope was limited due to time constraints and personal challenges.
Challenges
The project came with its fair share of hurdles. One of the biggest challenges was managing time effectively due to personal health issues, which caused delays and forced me to prioritize core functionalities over additional features. Implementing the rendering system, particularly shaders, was tricky—I ran into compilation and linking issues that required debugging with NVIDIA’s Nsight tool. Testing was another challenge; while I used Google Test for unit testing, I was only able to focus on the event handling system due to time constraints. Additionally, balancing feature implementation with testing and meeting the grading criteria within the limited timeframe was a constant struggle.
The project came with its fair share of hurdles. One of the biggest challenges was managing time effectively due to personal health issues, which caused delays and forced me to prioritize core functionalities over additional features. Implementing the rendering system, particularly shaders, was tricky—I ran into compilation and linking issues that required debugging with NVIDIA’s Nsight tool. Testing was another challenge; while I used Google Test for unit testing, I was only able to focus on the event handling system due to time constraints. Additionally, balancing feature implementation with testing and meeting the grading criteria within the limited timeframe was a constant struggle.
The project came with its fair share of hurdles. One of the biggest challenges was managing time effectively due to personal health issues, which caused delays and forced me to prioritize core functionalities over additional features. Implementing the rendering system, particularly shaders, was tricky—I ran into compilation and linking issues that required debugging with NVIDIA’s Nsight tool. Testing was another challenge; while I used Google Test for unit testing, I was only able to focus on the event handling system due to time constraints. Additionally, balancing feature implementation with testing and meeting the grading criteria within the limited timeframe was a constant struggle.
Approach
To tackle the project, I broke it down into manageable phases, focusing on core functionalities like rendering, input handling, and event management. I used GLFW for window management and OpenGL for rendering, implementing basic shaders for lighting and textures. For user input, I captured keyboard and mouse events, allowing for object manipulation in the scene. The event system was designed to handle various interactions efficiently, using dispatchers and handlers. I also integrated spdlog for logging events and errors to the console. Testing was done using Google Test, primarily focusing on the event system to ensure callbacks were triggered correctly. Profiling and debugging were done with NVIDIA’s Nsight, which helped resolve shader issues and optimize the rendering pipeline.
To tackle the project, I broke it down into manageable phases, focusing on core functionalities like rendering, input handling, and event management. I used GLFW for window management and OpenGL for rendering, implementing basic shaders for lighting and textures. For user input, I captured keyboard and mouse events, allowing for object manipulation in the scene. The event system was designed to handle various interactions efficiently, using dispatchers and handlers. I also integrated spdlog for logging events and errors to the console. Testing was done using Google Test, primarily focusing on the event system to ensure callbacks were triggered correctly. Profiling and debugging were done with NVIDIA’s Nsight, which helped resolve shader issues and optimize the rendering pipeline.
To tackle the project, I broke it down into manageable phases, focusing on core functionalities like rendering, input handling, and event management. I used GLFW for window management and OpenGL for rendering, implementing basic shaders for lighting and textures. For user input, I captured keyboard and mouse events, allowing for object manipulation in the scene. The event system was designed to handle various interactions efficiently, using dispatchers and handlers. I also integrated spdlog for logging events and errors to the console. Testing was done using Google Test, primarily focusing on the event system to ensure callbacks were triggered correctly. Profiling and debugging were done with NVIDIA’s Nsight, which helped resolve shader issues and optimize the rendering pipeline.
Solutions
To overcome the challenges, I prioritized core features and maintained a task list to track progress. For the rendering system, I used NVIDIA’s Nsight to debug and optimize shaders, resolving compilation and linking issues. This significantly improved the stability and performance of the rendering pipeline. For testing, I focused on unit tests for the event system, ensuring that callbacks were correctly triggered and handled. While I couldn’t perform extensive integration or system testing, the unit tests provided a solid foundation for verifying functionality. To manage time better, I adjusted my plan as needed, ensuring that the minimum requirements for each grading criterion were met.
Outcome
The project was a success in terms of delivering a functional game engine with core features like rendering, input handling, and event management. The rendering system supports basic 3D objects, textures, and lighting, while the input system allows for interactive object manipulation. The event system handles various interactions efficiently, and the logging system provides useful debugging information. Testing, though limited, ensured the event system worked as intended. Profiling and debugging with NVIDIA’s Nsight improved the rendering pipeline’s performance and stability. While there’s room for improvement—like implementing more advanced rendering techniques, enhancing the logging system, and expanding testing—the project provided valuable insights into game engine architecture. It was a challenging but rewarding experience that highlighted the importance of time management, early testing, and iterative development.
The project was a success in terms of delivering a functional game engine with core features like rendering, input handling, and event management. The rendering system supports basic 3D objects, textures, and lighting, while the input system allows for interactive object manipulation. The event system handles various interactions efficiently, and the logging system provides useful debugging information. Testing, though limited, ensured the event system worked as intended. Profiling and debugging with NVIDIA’s Nsight improved the rendering pipeline’s performance and stability. While there’s room for improvement—like implementing more advanced rendering techniques, enhancing the logging system, and expanding testing—the project provided valuable insights into game engine architecture. It was a challenging but rewarding experience that highlighted the importance of time management, early testing, and iterative development.
The project was a success in terms of delivering a functional game engine with core features like rendering, input handling, and event management. The rendering system supports basic 3D objects, textures, and lighting, while the input system allows for interactive object manipulation. The event system handles various interactions efficiently, and the logging system provides useful debugging information. Testing, though limited, ensured the event system worked as intended. Profiling and debugging with NVIDIA’s Nsight improved the rendering pipeline’s performance and stability. While there’s room for improvement—like implementing more advanced rendering techniques, enhancing the logging system, and expanding testing—the project provided valuable insights into game engine architecture. It was a challenging but rewarding experience that highlighted the importance of time management, early testing, and iterative development.