Finish up shader wrapper

game/assets/shaders/pixelart.fs

@@ -7,13 +7,11 @@ in vec4 fragColor;
 // Input uniform values
 uniform sampler2D texture0;
 uniform vec4 colDiffuse;
+uniform vec2 viewport;
 
 // Output fragment color
 out vec4 finalColor;
 
-// Viewport dimensions
-const vec2 viewport = vec2(1080.0, 720.0);
-
 // Pixel scaling
 const vec2 pixelScale = vec2(2.0, 2.0);
 

game/src/lib.rs

@@ -31,8 +31,9 @@ pub async fn game_begin() {
     // Set up profiling
     // #[cfg(debug_assertions)]
     // {
-        let _puffin_server = puffin_http::Server::new(&format!("0.0.0.0:{}", puffin_http::DEFAULT_PORT)).unwrap();
+    let _puffin_server =
-        puffin::set_scopes_on(true);
+        puffin_http::Server::new(&format!("0.0.0.0:{}", puffin_http::DEFAULT_PORT)).unwrap();
+    puffin::set_scopes_on(true);
     // }
 
     // Attempt to connect to a locally running Discord instance for rich presence access
@@ -73,9 +74,10 @@ pub async fn game_begin() {
 
     // Load the pixel art shader
     info!("Loading the pixel art shader");
-    let pixel_shader = ShaderWrapper::new(
+    let mut pixel_shader = ShaderWrapper::new(
         None,
         Some(StaticGameData::get("shaders/pixelart.fs")).expect("Failed to load pixelart.fs"),
+        vec!["viewport"],
         &mut rl,
         &thread,
     )
@@ -87,6 +89,9 @@ pub async fn game_begin() {
         puffin::GlobalProfiler::lock().new_frame();
         dynamic_texture.update(&mut rl, &thread).unwrap();
         let mut d = rl.begin_drawing(&thread);
+        let screen_size = Vector2::new(d.get_screen_width() as f32, d.get_screen_height() as f32);
+
+        pixel_shader.set_variable("viewport", screen_size).unwrap();
 
         render_to_texture(&mut dynamic_texture, || {
             puffin::profile_scope!("internal_shaded_render");

game/src/shaders/shader.rs

@@ -1,8 +1,10 @@
-use std::{ffi::CString, str::Utf8Error, string::FromUtf8Error};
+use std::collections::HashMap;
+use std::{ffi::CString, string::FromUtf8Error};
 
 use raylib::color::Color;
 use raylib::math::Vector2;
 use raylib::prelude::RaylibTexture2D;
+use raylib::shaders::ShaderV;
 use raylib::{
     math::Rectangle,
     prelude::{RaylibDraw, RaylibShaderModeExt},
@@ -11,16 +13,21 @@ use raylib::{
     RaylibHandle, RaylibThread,
 };
 use rust_embed::EmbeddedFile;
-use tracing::info;
 
 #[derive(Debug, Error)]
 pub enum ShaderError {
     #[error(transparent)]
     UtfConversionError(#[from] FromUtf8Error),
+    #[error(transparent)]
+    ShaderVarNameNulError(#[from] std::ffi::NulError),
+    #[error("Shader variable name not valid: {0}")]
+    ShaderVarNameError(String),
 }
 
+/// Utility wrapper around shader FFI
 pub struct ShaderWrapper {
     shader: Shader,
+    variables: HashMap<String, i32>,
 }
 
 impl ShaderWrapper {
@@ -28,39 +35,51 @@ impl ShaderWrapper {
     pub fn new(
         vertex_shader: Option<EmbeddedFile>,
         fragment_shader: Option<EmbeddedFile>,
+        variable_names: Vec<&str>,
         raylib: &mut RaylibHandle,
         thread: &RaylibThread,
     ) -> Result<Self, ShaderError> {
+        // Load shader code from files
         let vertex_shader_code = vertex_shader.map(|file| String::from_utf8(file.data.to_vec()));
         let fragment_shader_code =
             fragment_shader.map(|file| String::from_utf8(file.data.to_vec()));
 
-        Ok(Self {
+        // Create shader
-            shader: load_shader_from_heap(
+        let shader = load_shader_from_heap(
-                raylib,
+            raylib,
-                &thread,
+            &thread,
-                match vertex_shader_code {
+            match vertex_shader_code {
-                    Some(result) => match result {
+                Some(result) => match result {
-                        Ok(code) => Some(code),
+                    Ok(code) => Some(code),
-                        Err(err) => return Err(ShaderError::UtfConversionError(err)),
+                    Err(err) => return Err(ShaderError::UtfConversionError(err)),
-                    },
-                    None => None,
                 },
-                match fragment_shader_code {
+                None => None,
-                    Some(result) => match result {
+            },
-                        Ok(code) => Some(code),
+            match fragment_shader_code {
-                        Err(err) => return Err(ShaderError::UtfConversionError(err)),
+                Some(result) => match result {
-                    },
+                    Ok(code) => Some(code),
-                    None => None,
+                    Err(err) => return Err(ShaderError::UtfConversionError(err)),
                 },
-            ),
+                None => None,
-        })
+            },
+        );
+
+        // Create connections between CPU and GPU
+        let mut variables = HashMap::new();
+        for variable_name in variable_names {
+            variables.insert(variable_name.to_string(), unsafe {
+                raylib::ffi::GetShaderLocation(*shader, CString::new(variable_name)?.as_ptr())
+            });
+        }
+
+        Ok(Self { shader, variables })
     }
 
+    /// Handles rendering a texture to the screen via the shader. If run inside another shader context, this *should* chain with it.
     pub fn process_texture_and_render<H>(
         &self,
         raylib: &mut H,
-        thread: &RaylibThread,
+        _thread: &RaylibThread,
         texture: &RenderTexture2D,
     ) where
         H: RaylibShaderModeExt + RaylibDraw,
@@ -89,6 +108,19 @@ impl ShaderWrapper {
             Color::WHITE,
         );
     }
+
+    /// Set a variable in the shader.
+    pub fn set_variable<S>(&mut self, name: &str, value: S) -> Result<(), ShaderError>
+    where
+        S: ShaderV,
+    {
+        if let Some(ptr) = self.variables.get(name) {
+            self.shader.set_shader_value(*ptr, value);
+            Ok(())
+        } else {
+            Err(ShaderError::ShaderVarNameError(name.to_string()))
+        }
+    }
 }
 
 /// Too lazy to write this upstream

rust-toolchain.toml

@@ -1,2 +1,8 @@
+# If you see this, run `rustup self update` to get rustup 1.23 or newer.
+
+# NOTE: above comment is for older `rustup` (before TOML support was added),
+# which will treat the first line as the toolchain name, and therefore show it
+# to the user in the error, instead of "error: invalid channel name '[toolchain]'".
+
 [toolchain]
 channel = "beta"