add renderer

Cargo.toml

@@ -7,6 +7,8 @@ members = [
     "Engine/Source/platform",
     "Engine/Source/run",
     "Engine/Source/resource_manager",
+    "Engine/Source/utils",
+    "Engine/Source/renderer",
     "Engine/Source/world",
     "Engine/Shaders"
 ]
@@ -29,15 +31,20 @@ derive-getters = "0.5"
 
 # Engine modules
 build = { path = "Engine/Source/build" }
+utils = { path = "Engine/Source/utils" }
 logging = { path = "Engine/Source/logging" }
 engine = { path = "Engine/Source/engine" }
 platform = { path = "Engine/Source/platform" }
+renderer = { path = "Engine/Source/renderer" }
 resource_manager = { path = "Engine/Source/resource_manager" }
 world = { path = "Engine/Source/world" }
 shaders = { path = "Engine/Shaders" }
 
 # Main Engine Dependencies
 winit = "0.31.0-beta.2"
+ash = { version = "0.38", features = ["loaded"] }
+ash-window = "0.13"
+raw-window-handle = "0.6"
 glam = "0.32"
 gltf = "1"
 shaderc = "0.10"

Engine/Shaders/shaders/shader.frag

@@ -1,6 +1,6 @@
 #version 450
 
-layout(binding = 1) uniform sampler2D texSampler;
+layout(set = 2, binding = 2) uniform sampler2D texSampler;
 
 layout(location = 0) in vec3 fragColor;
 layout(location = 1) in vec2 fragTexCoord;

Engine/Shaders/shaders/shader.vert

@@ -1,10 +1,13 @@
 #version 450
 
-layout(binding = 0) uniform ModelViewProjection {
-    mat4 model;
+layout(set = 0, binding = 0) uniform SceneUbo {
     mat4 view;
     mat4 proj;
-} mvp;
+} scene;
+
+layout(set = 1, binding = 1) uniform ProxyUbo {
+    mat4 model;
+} proxy;
 
 layout(location = 0) in vec3 inPosition;
 layout(location = 1) in vec3 inColor;
@@ -14,7 +17,7 @@ layout(location = 0) out vec3 fragColor;
 layout(location = 1) out vec2 fragTexCoord;
 
 void main() {
-    gl_Position = mvp.proj * mvp.view * mvp.model * vec4(inPosition, 1.0);
+    gl_Position = scene.proj * scene.view * proxy.model * vec4(inPosition, 1.0);
     fragColor = inColor;
     fragTexCoord = inTexCoord;
 }

Engine/Shaders/src/lib.rs

@@ -1,19 +1,32 @@
 //! This crate contains all the shaders used in the engine.
 
+use std::ffi::CStr;
+
 /// A simple struct that holds a block of shader bytecode and
 /// the name of the shader's entrypoint.
 pub struct Shader {
     code: &'static [u8],
-    entrypoint: &'static str,
+    entrypoint: &'static CStr,
 }
 
 impl Shader {
     /// Returns the shader code
     pub const fn code(&self) -> &[u8] {
         self.code
     }
+    /// Returns the code but in blocks of u32
+    pub fn code_as_u32(&self) -> Vec<u32> {
+        assert!(
+            self.code.len().is_multiple_of(4),
+            "SPIR-V size must be a multiple of 4"
+        );
+        self.code
+            .chunks_exact(4)
+            .map(|c| u32::from_le_bytes(c.try_into().unwrap()))
+            .collect()
+    }
     /// Returns the entrypoint of this shader
-    pub const fn entrypoint(&self) -> &str {
+    pub const fn entrypoint(&self) -> &CStr {
         self.entrypoint
     }
 }
@@ -27,5 +40,5 @@ macro_rules! shader {
     };
 }
 
-pub const VERT: Shader = shader!("shader.vert", "main");
-pub const FRAG: Shader = shader!("shader.frag", "main");
+pub const VERT: Shader = shader!("shader.vert", c"main");
+pub const FRAG: Shader = shader!("shader.frag", c"main");

Engine/Source/engine/Cargo.toml

@@ -12,4 +12,10 @@ thiserror.workspace = true
 log.workspace = true
 
 logging.workspace = true
+utils.workspace = true
 platform.workspace = true
+renderer.workspace = true
+world.workspace = true
+resource_manager.workspace = true
+
+glam.workspace = true

Engine/Source/engine/src/lib.rs

@@ -1,31 +1,46 @@
-use std::time::Instant;
+use std::{collections::HashMap, f32::consts::PI, ffi::CString, str::FromStr, time::Instant};
 
 use anyhow::Context;
-
-use crate::errors::{InitResult, RenderResult, ShutdownResult};
-
-mod errors;
+use world::{World, WorldId};
 
 /// This is the main struct that holds global engine state.
 pub struct Engine {
+    // order is important as renderer should be dropped before platform
+    renderer: renderer::Renderer,
     platform: platform::Platform,
+
+    next_world_id: WorldId,
+    worlds: HashMap<WorldId, World>,
+
     is_requesting_exit: bool,
     exit_error: Option<anyhow::Error>,
     last_tick: Instant,
 }
 
 impl Engine {
-    pub fn init() -> InitResult<Self> {
+    pub fn init() -> anyhow::Result<Self> {
         let logger = logging::Logger::new(true, true, true);
         logging::init(logger);
 
-        let platform = platform::Platform::init();
+        let version = utils::Version::from_str(env!("CARGO_PKG_VERSION"))?;
+        let name = "DirkEngine";
+
+        let platform = platform::Platform::init().context("platform init")?;
+        let renderer = renderer::Renderer::init(
+            renderer::RendererCreateInfo {
+                engine_name: CString::from_str(name)?,
+                engine_version: version,
+                app_name: CString::from_str(name)?,
+                app_version: version,
+            },
+            platform.main_window(),
+        )
+        .context("renderer init")?;
 
         /* A rough idea of the flow of the C++ Engine
          *
          * Intialize Main Engine Objects:
          * - EventManager
-         * - Renderer
          * - World
          *
          * ImGui:
@@ -35,12 +50,96 @@ impl Engine {
          *
          * Create main viewport
          */
-        Ok(Self {
-            is_requesting_exit: false,
+        let mut engine = Self {
             platform,
+            renderer,
+
+            next_world_id: 0,
+            worlds: HashMap::new(),
+
+            is_requesting_exit: false,
             exit_error: None,
             last_tick: Instant::now(),
-        })
+        };
+
+        // TODO: this should be initialized when needed, not now
+        engine
+            .renderer
+            .upload_model(
+                resource_manager::ResourceManager::load_model("Shrek").context("loading shrek")?,
+            )
+            .context("uploading shrek")?;
+        engine
+            .renderer
+            .upload_model(
+                resource_manager::ResourceManager::load_model("Duck").context("loading duck")?,
+            )
+            .context("uploading duck")?;
+
+        let world_id = engine.create_world()?;
+
+        // THIS IS JUST TEMPORARY FOR TESTING
+        {
+            use world::components;
+            let world = engine.worlds.get_mut(&world_id).unwrap();
+
+            let player = world.spawn();
+            world.insert(
+                player,
+                components::Transform {
+                    location: glam::vec3(0., 1000., 1000.),
+                    rotation: glam::vec3(0., PI / 2., PI / 2.),
+                    scale: glam::Vec3::splat(1.),
+                },
+            );
+            world.insert(
+                player,
+                components::Camera {
+                    fov: (45_f32).to_radians(),
+                    near_clip: 0.1,
+                    far_clip: 100000.,
+                    width: 100.,
+                    height: 100.,
+                },
+            );
+
+            let shrek = world.spawn();
+            world.insert(
+                shrek,
+                components::Transform {
+                    location: glam::Vec3::ZERO,
+                    rotation: glam::Vec3::ZERO,
+                    scale: glam::Vec3::splat(1.),
+                },
+            );
+            world.insert(
+                shrek,
+                components::Renderable {
+                    model: "Shrek".to_string(),
+                },
+            );
+
+            let duck = world.spawn();
+            world.insert(
+                duck,
+                components::Transform {
+                    location: glam::vec3(100., 0., 0.),
+                    rotation: glam::Vec3::ZERO,
+                    scale: glam::Vec3::splat(1.),
+                },
+            );
+            world.insert(
+                shrek,
+                components::Renderable {
+                    model: "Duck".to_string(),
+                },
+            );
+
+            // TODO: see engine::create_world
+            engine.renderer.create_scene(world)?;
+        }
+
+        Ok(engine)
     }
     /// Engine tick.
     /// Returns if the engine should continue ticking.
@@ -51,6 +150,10 @@ impl Engine {
 
         let delta_time = self.capture_delta_time();
 
+        // TODO: renders too fast and semaphores have problem.
+        // remove when rendering takes longer
+        std::thread::sleep(std::time::Duration::from_millis(10));
+
         self.platform.tick(delta_time).context("ticking platform")?;
         if self.is_requesting_exit() {
             return Ok(false);
@@ -61,11 +164,14 @@ impl Engine {
          *
          * World Tick
          * Main Viewport tick
-         * Render
          */
-        Ok(self.is_requesting_exit())
+
+        self.render().context("tick: render")?;
+
+        Ok(!self.is_requesting_exit())
     }
-    pub fn render(&self) -> RenderResult<()> {
+    pub fn render(&mut self) -> anyhow::Result<()> {
+        self.renderer.render()?;
         /* Renderer::render
          *
          * ImGui:
@@ -78,7 +184,7 @@ impl Engine {
          */
         Ok(())
     }
-    pub fn shutdown(&self) -> ShutdownResult<()> {
+    pub fn shutdown(&mut self) -> anyhow::Result<()> {
         /*
          * Shutdown ImGui (renderer then platform)
          *
@@ -106,4 +212,22 @@ impl Engine {
         self.last_tick = current_time;
         delta
     }
+
+    fn create_world(&mut self) -> anyhow::Result<WorldId> {
+        let id = self.next_world_id;
+        self.next_world_id += 1;
+
+        let world = World::new(id);
+        // TODO: have the world submitted here, once not having camera doesn't panic.
+        // self.renderer
+        //     .create_scene(&world)
+        //     .context("create renderer scene")?;
+        self.worlds.insert(id, world);
+        Ok(id)
+    }
+    #[allow(unused)]
+    fn destroy_world(&mut self, id: WorldId) {
+        // TODO: delete renderer scene
+        self.worlds.remove(&id);
+    }
 }

Engine/Source/platform/Cargo.toml

@@ -12,5 +12,7 @@ anyhow.workspace = true
 thiserror.workspace = true
 winit.workspace = true
 
+utils.workspace = true
+
 [build-dependencies]
 build.workspace = true

Engine/Source/platform/src/errors.rs

@@ -1,9 +1,13 @@
 use thiserror::Error;
 
-pub type Result<T> = std::result::Result<T, PlatformError>;
+pub type Result<T> = std::result::Result<T, Error>;
 
 #[derive(Debug, Error)]
-pub enum PlatformError {
+pub enum Error {
     #[error("Error in winit event loop: {0}")]
     EventLoopError(#[from] winit::error::EventLoopError),
+    #[error("Error fetching handle: {0}")]
+    HandleError(#[from] winit::raw_window_handle::HandleError),
+    #[error("Application exited with code {0}")]
+    AppExited(i32),
 }