New scene items system

src/dawn/display/IRenderHost.hpp

@@ -0,0 +1,44 @@
+// Copyright (c) 2023 Dominic Masters
+// 
+// This software is released under the MIT License.
+// https://opensource.org/licenses/MIT
+
+#pragma once
+#include "dawnlibs.hpp"
+
+namespace Dawn {
+  class Game;
+
+  class IRenderHost {
+    public:
+      /**
+       * Initializes the render host, called by the game during the initial 
+       * set up of the engine.
+       * 
+       * @param game Game that requested the render host to initialize.
+       */
+      virtual void init(const std::shared_ptr<Game> game) = 0;
+
+      /**
+       * Performs an update/tick of the render host. This would be the game 
+       * asking the RenderHost to the rendering.
+       */
+      virtual void update() = 0;
+
+      /**
+       * Overridable request from the game that asks if the RenderHost has any
+       * reason that it should need to close. For most libraries this would be
+       * whether or not the window was closed.
+       * 
+       * @return True if the render host requests the game to gracefully exit.
+       */
+      virtual bool_t isCloseRequested() = 0;
+
+      /**
+       * Destroys the render host.
+       */
+      virtual ~IRenderHost() {
+
+      }
+  };
+}

src/dawn/display/mesh/IMesh.hpp

@@ -0,0 +1,103 @@
+// Copyright (c) 2022 Dominic Masters
+// 
+// This software is released under the MIT License.
+// https://opensource.org/licenses/MIT
+
+#pragma once
+#include "dawnlibs.hpp"
+
+namespace Dawn {
+  enum MeshDrawMode {
+    TRIANGLES,
+    TRIANGLE_STRIP,
+    TRIANGLE_FAN,
+    LINES,
+    POINTS
+    // LINE_STRIP,
+  };
+
+  class IMesh {
+    protected:
+      /** How many vertices are in the mesh */
+      int32_t verticeCount = -1;
+      /** How many indices are in the mesh */
+      int32_t indiceCount = -1;
+
+    public:
+      /**
+       * Create a new set of buffers for the mesh to use.
+       * 
+       * @param verticeCount How many Vertices will this buffer support.
+       * @param indiceCount How many Indices will this buffer support.
+       */
+      virtual void createBuffers(
+        const int32_t verticeCount,
+        const int32_t indiceCount
+      ) = 0;
+      
+      /**
+       * Cleanup the buffers on a given mesh. This is useful if you intend to
+       * expand the count of vertices your mesh supports.
+       */
+      virtual void disposeBuffers() = 0;
+
+      /**
+       * Write vertice positions to the mesh.
+       * 
+       * @param pos Position, within the buffer, to write to.
+       * @param vertices Array of positions to write.
+       * @param len How many positions are in the array.
+       */
+      virtual void bufferPositions(
+        const int32_t pos,
+        const glm::vec3 positions[],
+        const int32_t len
+      ) = 0;
+
+      /**
+       * Write vertice coordinates to the mesh.
+       * 
+       * @param pos Position, within the buffer, to write to.
+       * @param coordinates Array of coordinates to write.
+       * @param len How many coordinates are in the array.
+       */
+      virtual void bufferCoordinates(
+        const int32_t pos,
+        const glm::vec2 coordinates[],
+        const int32_t len
+      ) = 0;
+
+      /**
+       * Write indices to the mesh.
+       * 
+       * @param pos Position, within the buffer, to write to.
+       * @param indices Array of indices to write.
+       * @param len How many indices are in the array.
+       */
+      virtual void bufferIndices(
+        const int32_t pos,
+        const int32_t indices[],
+        const int32_t len
+      ) = 0;
+
+      /**
+       * Draw a primitive. Primitives are drawn by their indices.
+       * 
+       * @param drawMode Which drawing mode to use to draw the primitive.
+       * @param start Start indice (index) to draw.
+       * @param count Count of indices to draw. Use -1 to draw all.
+       */
+      virtual void draw(
+        const enum MeshDrawMode drawMode,
+        const int32_t start,
+        const int32_t count
+      ) = 0;
+
+      /**
+       * Cleanup a previously initiated mesh.
+       */
+      virtual ~IMesh() {
+        this->disposeBuffers();
+      }
+  };
+}