Okay, here's the summary of the provided transcript:
"Remaking My First Game in C++: Live Tutorial (Part 1) - Multiplayer, 3D, Ray Tracing"
0:00-0:10 Introduction: The video introduces a new series focused on remaking the creator's first game, Squad, in C++, adding multiplayer over a network, 3D graphics and ray tracing. It aims to be a live tutorial, showing every line of code.
0:10-0:20 Series Goals: The goal is to fulfill promises made on the channel and discuss topics like application architecture, Vulkan, and ray tracing in a practical project.
0:20-0:45 YouTube Challenges and Solutions: Acknowledges that long, in-depth projects don't fit well on YouTube and tend to lead to slow progress. The solution is to make big, substantial videos showing significant progress rather than incremental ones.
0:45-1:00 Game and Tech Stack: The game remade is called "Cubed" (3D version of "Squared"), using the latest C++, MSVC, and Visual Studio. Compiles on all platforms. The base framework will be Walnut (a custom lightweight framework by the creator).
1:00-1:10 Framework Choice: The use of Walnut framework aims to build the game from scratch, unlike ready-made game engines. All third-party code must be open-source.
1:10-1:20 Source Code Availability: The project's code will be available on GitHub for free in a repository called "Cubed." The creator chose to make it publicly accessible instead of Patreon early access.
1:20-1:30 Video Structure & Goals: The video includes chapters in the description, and in this part, aims to create a server on Linux, that clients can connect to and see each other moving.
1:30- 2:00 Project Setup: The video starts with creating a new repository in GitHub for Cubed and then cloning it to a local machine. It then adds Walnut as a submodule to the project and initializes its dependencies using git submodule update --init --recursive
2:00-2:30 Server Setup: The creator then sets up a server through the video sponsor, Hostinger, choosing a KVM 2 or 4 and Ubuntu 24. They pick a server location, set a root password and then it is ready to use.
2:30- 3:00 Project Configuration & Structure: The video goes on to detail how they want the project structured, with a client and a server app, pulling a premake build structure from Walnut chat, to begin with.
3:00-3:40 PreMake & Build Scripts: The creator modifies existing PreMake build scripts to include client and server configurations, adjusting paths for the new project structure. They also modify build configurations with definitions and include paths for their project to work.
3:40- 4:30 SubModules: A reminder is made that everything used is either open source or has to be a git sub module to be a dependent of the new project. A deeper explanation of git submodules is provided.
4:30- 4:50 Code Organization & Setup: The client code is created by copying files, including application logic into a "client" directory, the server code into a "server" directory, and shared code into "common". These directories and subdirectories are then named based on project requirements.
4:50- 5:40 First Build Attempt: The video then showcases the first compilation attempt for the new project using the pre-make set up. Compilation errors related to including Walnut and setting up a project configuration are diagnosed and corrected one by one.
5:40- 6:00 Basic Rendering Setup: The video proceeds to create a main loop for client and server and begins drawing a simple rectange with ImGUI, with the addition of the required code for the rectangle position to render properly.
6:00-6:30 ImGUI Adjustments: The video includes how to remove the IMGUI doc space in order for the game application to work as the video creator envisioned.
6:30 -7:00 User Input and Player Movement: A very simple player movement system is implemented using an input and a directional vector and normalized velocity calculation.
7:00-7:30 Hostinger Advertisement: The video includes a call to action to the video sponsor, Hostinger.
7:30- 8:00 GitHub and Code Management: The creator goes back to the main project, after the advertisement, and showcases the current project and file structure within the Git management program Fork, to highlight how the project files are structured and what has been added and configured.
8:00- 8:55 Build System Setup: The video focuses on setting up the client and server applications to build correctly with pre-make, adjusting include paths, and fixing a few missing dependencies.
8:55-9:10 First Client Run: The client is successfully built, run, and the rectangle is displayed. The camera view is also moving based on user inputs.
9:10 - 10:00 Server Setup: The server project is compiled and set up. The light source is initialized with a call back function to a local function of the server class.
10:00-10:30 Networking Layer: A client/server connection is established. The client application is successfully connecting to the server and logging all the client connect and disconnect info using a call back. A server status logging implementation is shown in the console.
10:30-11:10 The importance of Dynamic Link Libraries. Explanation about shared libraries is provided, showcasing what makes the project not be able to start. Also a solution that involves setting an Environment Variable for the location of those libraries is shared as a temporary solution.
11:10-11:55 Build Script on Linux: The video continues by showing the creation of a Linux executable script with all the required information to build the project with PreMake correctly and that also sets the correct environment variables so that the project is able to find it's required libraries.
11:55 -12:20 Client Setup & Test: The client's build script is changed, the line endings of that script is corrected, and the client and server applications are finally both built and run successfully through a terminal window connected to the hosting server.
12:20-13:10 Player ID System: The video shows where client and server IDs are sent and read, and after a quick debugging session, the client's are showing up on the server with the correct ID values.
13:10-14:00 Client Movement Data: The client is sending player movement data to the server, with the server outputting the data to the console. Player movement is also shown on the screen, using IMGUI rendering.
14:00-14:45 Multiple Client Test: Another client is started so that multiple clients can be seen on the server and in other clients. A quick look at the Ping is performed.
14:45-15:20 Domain Name Resolution: The video details the steps needed to use a Domain Name instead of an IP, to connect to the server, and how it can be done in a simple and correct way within C++ 20.
15:20-16:20 Data Exchange & Structure: The video explains data structure and protocol considerations that have to be in place to have clients and server exchange the data that each other needs.
16:20-17:00 Client ID Explanation: Why assigning client IDs might be needed for a multiplayer game even when you're not using a 3D engine is described.
17:00-18:15 Client and Server Call Back: A few code implementations are made, to implement both the send and receive buffer callbacks in client and server.
18:15-19:00 SubModules and Data Transmission A few examples are provided for why git submodules can be useful when managing dependencies.
19:00 - 20:30 Server Data Transmission: The client is setup to properly use the server connection data and use the new method to get a more performant and correct access to all the needed information.
20:30 - 21:00 Data Structures & Threads: Explanation on shared access and threads is given, showcasing the importance of Mutex.
21:00 - 22:00 Code Overview A quick overview of all the code and configuration is provided as a summary of what was done so far.
22:00 - 23:00 ImGui and Game Loop. The game loop is changed to handle and display information from multiple clients, instead of just one.
23:00 - 24:00 Final Multi Client Test: Multiple clients are launched, all of them are connecting to the server and receiving the correct information as expected, a basic multiplayer game demo is now working in the cloud.
24:00 - 24:45 Conclusion and Next Steps: The video concludes with an outline for future videos in the series including Vulkan graphics and ray tracing. Viewers are prompted to leave comments.