Create an project from scratch without template

    This site uses cookies. By continuing to browse this site, you are agreeing to our Cookie Policy.

    • Create an project from scratch without template

      Hello, this tutorial will show you how to create a project from scratch without using a project template. First you need to download the latest version from github github.com/Andy16823/GFX/releases/latest. Once you have downloaded the latest version, we will create a new project in Visual Studio. For this tutorial we will create a Winforms C# project using .Net Framework 4.8, dont worry we will not use a form within this project, we will use the Win32 window from the framework itself.

      Once you have created your project, you will need to set up the dependencies. We will start with the files from the release you have downloaded. Extract the zip file and add the following dll to your project Genesis.dll

      Create the Game Class

      After adding the Genesis.dll to the project, you must remove the existing form from the project. Then we will create a new class called "MyGame" and make it inherit from the "Game" class from the genesis.core namespace. Intelisense will now complain that we are missing the constructor. Let intelisense create it for you. Your class should now look like this

      C Source Code

      1. using Genesis.Core;
      2. using Genesis.Graphics;
      3. using System;
      4. using System.Collections.Generic;
      5. using System.Linq;
      6. using System.Text;
      7. using System.Threading.Tasks;
      9. namespace MyTutorialGame
      10. {
      11. public class MyGame : Game
      12. {
      13. public MyGame(IRenderDevice renderDevice, Viewport viewport) : base(renderDevice, viewport)
      14. {
      16. }
      17. }
      18. }
      Display All
      Now it is time to fill the class. But before we start, we need to create a folder inside our project called "Resources". Once this is done we will tell our game to load the assets from this folder and set the target fps to 200

      C Source Code

      1. // Load the textures and set the target fps
      2. this.AssetManager.LoadTextures();
      3. this.TargetFPS = 200;
      In order to use physics in our game, we need to create a physics handler, but don't worry, it's not as complicated as you might think. It is just one line of code

      C Source Code

      1. // Create an physics handler for the scene
      2. var physicsHandler = new PhysicsHandler2D(0f, 0f);
      Then we need to create the scene we want to render. You can think of a scene as a level. Everything in this scene will be rendered and updated within the game loop

      C Source Code

      1. // Setup the Scene with an sun, layer, camera and physics handler
      2. var scene = new Scene("MyTestScene");
      3. scene.AddLayer("BaseLayer");
      4. scene.Camera = new Camera(viewport, -1f, 1f);
      5. scene.PhysicHandler = physicsHandler;
      As you can see, we also assigned a camera and our previously created physichandler to this scene. This means that each scene is independent of the others. You can create 2D and 3D scenes within the same project. In the next step we will create our first game element, a simple sprite. To do this we need to copy the image for the sprite into the Resources directory we created earlier. Once you have placed your image in this folder, make sure that you tell Visual Studio to copy the image to the target directory within the build. This option can be found within the properties of the file. (see screenshot)



      Once you have copied the file into the resource folder, we will add the code to add the sprite to the level.

      C Source Code

      1. // Create your game elements
      2. var sprite = new Sprite("sprite", new Vec3(0, 0), new Vec3(100, 100), this.AssetManager.GetTexture("gfx.png"));
      3. var collider = sprite.AddBehavior<BoxCollider>(new BoxCollider(physicsHandler));
      4. collider.CreateCollider();
      5. scene.AddGameElement("BaseLayer", sprite);
      As you can see with the last parameter inside the sprite constructor, we can get any resource from this folder just by passing the game and the extension. Now we can finally add the created scene to the game and load it. Only 1 scene can be active at a time in the game!

      C Source Code

      1. this.AddScene(scene);
      2. this.LoadScene("MyTestScene");
      In order to have some control over our game, we should add some events. We do this in gfx using lambda expressions. Let us create a simple callback for the update. We can do this easily like this

      C Source Code

      1. this.OnUpdate += (g, r) =>
      2. {
      3. Console.WriteLine("Hello World");
      4. };
      So our game class is done for now. In total, your game class should look like this

      C Source Code

      1. using Genesis.Core;
      2. using Genesis.Core.Behaviors.Physics2D;
      3. using Genesis.Core.GameElements;
      4. using Genesis.Graphics;
      5. using Genesis.Graphics.Physics;
      6. using Genesis.Math;
      7. using Genesis.Physics;
      8. using System;
      9. using System.Collections.Generic;
      10. using System.Linq;
      11. using System.Text;
      12. using System.Threading.Tasks;
      14. namespace MyTutorialGame
      15. {
      16. public class MyGame : Game
      17. {
      18. public MyGame(IRenderDevice renderDevice, Viewport viewport) : base(renderDevice, viewport)
      19. {
      20. // Load the textures and set the target fps
      21. this.AssetManager.LoadTextures();
      22. this.TargetFPS = 200;
      24. // Create an physics handler for the scene
      25. var physicsHandler = new PhysicsHandler2D(0f, 0f);
      27. // Setup the Scene with an sun, layer, camera and physics handler
      28. var scene = new Scene("MyTestScene");
      29. scene.AddLayer("BaseLayer");
      30. scene.Camera = new Camera(viewport, -1f, 1f);
      31. scene.PhysicHandler = physicsHandler;
      33. // Create your game elements
      34. var sprite = new Sprite("sprite", new Vec3(0, 0), new Vec3(100, 100), this.AssetManager.GetTexture("gfx.png"));
      35. var collider = sprite.AddBehavior<BoxCollider>(new BoxCollider(physicsHandler));
      36. collider.CreateCollider();
      37. scene.AddGameElement("BaseLayer", sprite);
      39. // Add the Scene to the game and load it.
      40. this.AddScene(scene);
      41. this.LoadScene("MyTestScene");
      43. this.OnUpdate += (g, r) =>
      44. {
      45. Console.WriteLine("Hello World");
      46. };
      47. }
      48. }
      49. }
      Display All

      Create the Project.cs

      Ok, nice, but our game will not run yet. We need to change the code in Progamm.cs first. You can simply replace the Main function within the following code in your program.cs

      C Source Code

      1. static void Main()
      2. {
      3. // Create an window Handle
      4. Genesis.Core.Window window = new Genesis.Core.Window();
      5. Viewport viewport = new Viewport(1280, 720);
      6. var handle = window.CreateWindowHandle("Hello Window", viewport);
      8. // Create Render Settings for the renderer
      9. var renderSettings = new RenderSettings()
      10. {
      11. gamma = 0.5f
      12. };
      14. // Create the game
      15. var game = new MyGame(new BetaRenderer(handle, renderSettings), viewport, window);
      17. // Show and Run the Game
      18. window.RunGame(game);
      19. }
      Display All

      Change the Project Plattform

      Ok, now that we have our MyGame and our programming class, we could run the game, right? well, not yet. We need to change the build CPU architecture to x64. Within Visual Studio the default architecture is set to "Any CPU" but the engine requires a 64 bit CPU. So we need to change that. To do this, click on "Configuration Manager" in the combo box where "Any CPU" is displayed (see screenshot).



      A new window will pop up and we will click on <New> in the Platform drop down menu.



      Within the first combobox in the new window we will select x64 and click on ok.



      The Native Libarys

      Now we need to do one more step before we can run the build. We need to copy the native libraries from the release folder you downloaded into the project, and also have Visual Studio copy them into the output directory. These files need to be in the same folder as the exe of your game. Make sure you copy them to the root directory, not to any folder. The ddl you need to copy are libbulletc-windows-x64.dll and libbulletc.dll.

      Press Start and run the game now! In addition to this you also can find the tutorial project here: GFX/Examples/MyTutorialGame at main · Andy16823/GFX (github.com) and can download it here: gfx-engine.org/wp-content/uploads/2024/07/MyTutorialGame.zip