wip

.cargo/config.toml

@@ -1,3 +0,0 @@
-[target.'cfg(target_os = "linux")']
-linker = "clang"
-rustflags = ["-C", "link-arg=-fuse-ld=/path/to/mold"]

.gitignore

@@ -1 +1,2 @@
 /target
+result

Cargo.toml

@@ -5,4 +5,4 @@ edition = "2024"
 
 
 [dependencies]
-bevy = "0.16.1"
+bevy = { version = "0.16.1", features = ["shader_format_glsl"] }

flake.nix

@@ -19,11 +19,13 @@
       let
         overlays = [ (import rust-overlay) ];
         pkgs = import nixpkgs { inherit system overlays; };
+        stdenv = pkgs.stdenvAdapters.useMoldLinker pkgs.clangStdenv;
         rustToolchain = pkgs.pkgsBuildHost.rust-bin.fromRustupToolchainFile ./rust-toolchain.toml;
         nativeBuildInputs = with pkgs; [
           rustToolchain
           mold
           pkg-config
+          clang
         ];
         xorgBuildInputs = with pkgs; [
           xorg.libX11
@@ -44,25 +46,21 @@
           ++ xorgBuildInputs
           ++ waylandBuildInputs;
 
-        # Build target for the binary
+        mkShell = pkgs.mkShell.override {
-        default_package = pkgs.rustPlatform.buildRustPackage {
+          stdenv = stdenv;
+        };
+      in
+      {
+        packages.default = pkgs.rustPlatform.buildRustPackage {
+          inherit stdenv buildInputs nativeBuildInputs;
           pname = (builtins.fromTOML (builtins.readFile ./Cargo.toml)).package.name;
           version = (builtins.fromTOML (builtins.readFile ./Cargo.toml)).package.version;
           src = ./.;
           cargoLock = {
             lockFile = ./Cargo.lock;
           };
-          nativeBuildInputs = nativeBuildInputs;
-          buildInputs = buildInputs;
         };
 
-        mkShell = pkgs.mkShell.override {
-          stdenv = pkgs.stdenvAdapters.useMoldLinker pkgs.clangStdenv;
-        };
-      in
-      {
-        packages.default = default_package;
-
         devShells.default = mkShell {
           inherit buildInputs nativeBuildInputs;
 

src/main.rs

@@ -1,7 +1,69 @@
-use bevy::prelude::*;
+//! A shader that uses the GLSL shading language.
+
+use bevy::{
+    prelude::*, reflect::TypePath, render::render_resource::AsBindGroup, render::render_resource::ShaderRef,
+};
+
+/// This example uses shader source files from the assets subdirectory
+const VERTEX_SHADER_ASSET_PATH: &str = "shaders/custom_material.vert";
+const FRAGMENT_SHADER_ASSET_PATH: &str = "shaders/custom_material.frag";
 
 fn main() {
     App::new()
-        .add_plugins(DefaultPlugins)
+        .add_plugins((DefaultPlugins, MaterialPlugin::<CustomMaterial>::default()))
+        .add_systems(Startup, setup)
         .run();
 }
+
+/// set up a simple 3D scene
+fn setup(
+    mut commands: Commands,
+    mut meshes: ResMut<Assets<Mesh>>,
+    mut materials: ResMut<Assets<CustomMaterial>>,
+    asset_server: Res<AssetServer>,
+) {
+    // cube
+    commands.spawn((
+        Mesh3d(meshes.add(Cuboid::default())),
+        MeshMaterial3d(materials.add(CustomMaterial {
+            color: LinearRgba::BLUE,
+            color_texture: None,
+            alpha_mode: AlphaMode::Blend,
+        })),
+        Transform::from_xyz(0.0, 0.5, 0.0),
+    ));
+
+    // camera
+    commands.spawn((
+        Camera3d::default(),
+        Transform::from_xyz(-2.0, 2.5, 5.0).looking_at(Vec3::ZERO, Vec3::Y),
+    ));
+}
+
+// This is the struct that will be passed to your shader
+#[derive(Asset, TypePath, AsBindGroup, Clone)]
+struct CustomMaterial {
+    #[uniform(0)]
+    color: LinearRgba,
+    #[texture(1)]
+    #[sampler(2)]
+    color_texture: Option<Handle<Image>>,
+    alpha_mode: AlphaMode,
+}
+
+/// The Material trait is very configurable, but comes with sensible defaults for all methods.
+/// You only need to implement functions for features that need non-default behavior. See the Material api docs for details!
+/// When using the GLSL shading language for your shader, the specialize method must be overridden.
+impl Material for CustomMaterial {
+    fn vertex_shader() -> ShaderRef {
+        VERTEX_SHADER_ASSET_PATH.into()
+    }
+
+    fn fragment_shader() -> ShaderRef {
+        FRAGMENT_SHADER_ASSET_PATH.into()
+    }
+
+    fn alpha_mode(&self) -> AlphaMode {
+        self.alpha_mode
+    }
+}