mid-progress

game/assets/configs/final_shader.json

@@ -1,5 +1,7 @@
 {
     "pixel_scale": 1.0,
     "warp_factor": 0.65,
-    "scanline_darkness": 0.55
+    "scanline_darkness": 0.55,
+    "bloom_samples": 5.0,
+    "bloom_quality": 2.5
 }

game/assets/shaders/pixelart.fs

@@ -1,5 +1,6 @@
 /**
- * This shader is the last piece of the graphics pipeline. EVERYTHING is passed through it.
+ * This shader is the last piece of the graphics pipeline. EVERYTHING is passed
+ * through it.
  */
 
 #version 330
@@ -9,6 +10,7 @@ in vec2 fragTexCoord;
 
 // Whole input texture
 uniform sampler2D texture0;
+uniform vec4 colDiffuse;
 
 // Viewport size
 uniform vec2 viewport;
@@ -23,6 +25,10 @@ uniform vec2 pixelScale;
 uniform float warpFactor;
 uniform float scanlineDarkness;
 
+// Bloom parameters
+uniform float bloomSamples;
+uniform float bloomQuality;
+
 void main() {
   // Calculate the distance to merge pixels
   float dx = pixelScale.x * (1.0 / viewport.x);
@@ -38,20 +44,43 @@ void main() {
   // Calculate a UV for this new blocky pixel
   vec2 pixelatedUV = vec2(dx * floor(baseUV.x / dx), dy * floor(baseUV.y / dy));
 
+  // --- BEGIN BLOOM EFFECT ---
+
+  vec2 sizeFactor = vec2(1) / viewport * bloomQuality;
+  vec4 textureSum = vec4(0);
+
+  const int range = 2;
+  for (int x = -range; x <= range; x++) {
+    for (int y = -range; y <= range; y++) {
+      textureSum += texture(texture0, fragTexCoord + vec2(x, y) * sizeFactor);
+    }
+  }
+
+  // --- BEGIN CRT SHADER ---
+
   // Warp the UVs of the pixelated texture
   vec2 warpedUV = pixelatedUV;
-  warpedUV.x -= 0.5; warpedUV.x *= 1.0+(dist_center_sq.y * (0.3 * warpFactor)); warpedUV.x += 0.5;
+  warpedUV.x -= 0.5;
-  warpedUV.y -= 0.5; warpedUV.y *= 1.0+(dist_center_sq.x * (0.4 * warpFactor)); warpedUV.y += 0.5;
+  warpedUV.x *= 1.0 + (dist_center_sq.y * (0.3 * warpFactor));
+  warpedUV.x += 0.5;
+  warpedUV.y -= 0.5;
+  warpedUV.y *= 1.0 + (dist_center_sq.x * (0.4 * warpFactor));
+  warpedUV.y += 0.5;
 
   // If the UV is outside the texture, return black
-  if (warpedUV.x < 0.0 || warpedUV.x > 1.0 || warpedUV.y < 0.0 || warpedUV.y > 1.0) {
+  if (warpedUV.x < 0.0 || warpedUV.x > 1.0 || warpedUV.y < 0.0 ||
+      warpedUV.y > 1.0) {
     finalColor = vec4(0.0, 0.0, 0.0, 1.0);
     return;
   }
 
   // Determine factor of if we are rendering on a scanline
-  float scanlineFactor = abs(sin(fragTexCoord.y * viewport.y) * 0.5 * scanlineDarkness);
+  float scanlineFactor =
+      abs(sin(fragTexCoord.y * viewport.y) * 0.5 * scanlineDarkness);
 
   // Build the final pixel
-  finalColor = vec4(mix(texture(texture0, warpedUV).rgb, vec3(0.0), scanlineFactor), 1.0);
+  vec4 texWithBloom =
+      ((textureSum / (bloomSamples * bloomSamples)) + texture0) * colDiffuse;
+  finalColor = vec4(
+      mix(texture(texWithBloom, warpedUV).rgb, vec3(0.0), scanlineFactor), 1.0);
 }

game/src/lib.rs

@@ -186,12 +186,19 @@ pub async fn game_begin(game_config: &GameConfig) -> Result<(), Box<dyn std::err
     let mut pixel_shader = ShaderWrapper::new(
         None,
         Some(StaticGameData::get("shaders/pixelart.fs")).expect("Failed to load pixelart.fs"),
-        vec!["viewport", "pixelScale", "warpFactor", "scanlineDarkness"],
+        vec![
+            "viewport",
+            "pixelScale",
+            "warpFactor",
+            "scanlineDarkness",
+            "bloomSamples",
+            "bloomQuality",
+        ],
         &mut context.renderer.borrow_mut(),
         &raylib_thread,
     )?;
 
-    info!("Starting the render loop");
+
     while !context.renderer.borrow().window_should_close() {
         // Profile the main game loop
         puffin::profile_scope!("main_loop");
@@ -222,6 +229,8 @@ pub async fn game_begin(game_config: &GameConfig) -> Result<(), Box<dyn std::err
         )?;
         pixel_shader.set_variable("warpFactor", pixel_shader_config.warp_factor)?;
         pixel_shader.set_variable("scanlineDarkness", pixel_shader_config.scanline_darkness)?;
+        pixel_shader.set_variable("bloomSamples", pixel_shader_config.bloom_samples)?;
+        pixel_shader.set_variable("bloomQuality", pixel_shader_config.bloom_quality)?;
 
         // Render the game via the pixel shader
         render_to_texture(&mut dynamic_texture, || {

game/src/utilities/datastore.rs

@@ -65,3 +65,14 @@ pub fn load_texture_from_internal_data(
 
     Ok(texture)
 }
+
+pub fn load_tilemap_from_internal_data(&str path)
+    -> Result<Texture2D, TiledError> {
+
+        let temp_dir = tempdir()?;
+        let tmp_path = temp_dir.path().join(Path::new(path).file_name().unwrap());
+
+        std::fs::write(
+            &tmp_path
+        )
+}

game/src/utilities/game_config.rs

@@ -42,6 +42,8 @@ pub struct FinalShaderConfig {
     pub pixel_scale: f32,
     pub warp_factor: f32,
     pub scanline_darkness: f32,
+    pub bloom_samples: f32,
+    pub bloom_quality: f32,
 }
 
 impl FinalShaderConfig {

game/src/utilities/map_loader.rs

@@ -1,6 +0,0 @@
-use tiled::*
-
-pub struct Level {
-    pub map: Map,
-
-}

game/src/utilities/mod.rs

@@ -6,4 +6,3 @@ pub mod math;
 pub mod non_ref_raylib;
 pub mod render_layer;
 pub mod shaders;
-pub mod map_loader;