PBR Materials (#75)

Co-authored-by: Moon Davé <moon@softmoon.world>

Author: tychedelia

Cargo.toml

@@ -68,6 +68,14 @@ path = "examples/custom_attribute.rs"
 name = "lights"
 path = "examples/lights.rs"
 
+[[example]]
+name = "materials"
+path = "examples/materials.rs"
+
+[[example]]
+name = "pbr"
+path = "examples/pbr.rs"
+
 [profile.wasm-release]
 inherits = "release"
 opt-level = "z"

crates/processing_ffi/src/lib.rs

@@ -1092,6 +1092,14 @@ pub extern "C" fn processing_geometry_box(width: f32, height: f32, depth: f32) -
         .unwrap_or(0)
 }
 
+#[unsafe(no_mangle)]
+pub extern "C" fn processing_geometry_sphere(radius: f32, sectors: u32, stacks: u32) -> u64 {
+    error::clear_error();
+    error::check(|| geometry_sphere(radius, sectors, stacks))
+        .map(|e| e.to_bits())
+        .unwrap_or(0)
+}
+
 #[unsafe(no_mangle)]
 pub extern "C" fn processing_light_create_directional(
     graphics_id: u64,
@@ -1146,3 +1154,70 @@ pub extern "C" fn processing_light_create_spot(
     .map(|e| e.to_bits())
     .unwrap_or(0)
 }
+
+#[unsafe(no_mangle)]
+pub extern "C" fn processing_material_create_pbr() -> u64 {
+    error::clear_error();
+    error::check(material_create_pbr)
+        .map(|e| e.to_bits())
+        .unwrap_or(0)
+}
+
+/// Set float value for `name` field on Material.
+///
+/// # Safety
+/// - `name` must be non-null
+#[unsafe(no_mangle)]
+pub unsafe extern "C" fn processing_material_set_float(
+    mat_id: u64,
+    name: *const std::ffi::c_char,
+    value: f32,
+) {
+    error::clear_error();
+    let name = unsafe { std::ffi::CStr::from_ptr(name) }.to_str().unwrap();
+    error::check(|| {
+        material_set(
+            Entity::from_bits(mat_id),
+            name,
+            material::MaterialValue::Float(value),
+        )
+    });
+}
+
+/// Set float4 value for `name` field on Material.
+///
+/// # Safety
+/// - `name` must be non-null
+#[unsafe(no_mangle)]
+pub unsafe extern "C" fn processing_material_set_float4(
+    mat_id: u64,
+    name: *const std::ffi::c_char,
+    r: f32,
+    g: f32,
+    b: f32,
+    a: f32,
+) {
+    error::clear_error();
+    let name = unsafe { std::ffi::CStr::from_ptr(name) }.to_str().unwrap();
+    error::check(|| {
+        material_set(
+            Entity::from_bits(mat_id),
+            name,
+            material::MaterialValue::Float4([r, g, b, a]),
+        )
+    });
+}
+
+#[unsafe(no_mangle)]
+pub extern "C" fn processing_material_destroy(mat_id: u64) {
+    error::clear_error();
+    error::check(|| material_destroy(Entity::from_bits(mat_id)));
+}
+
+#[unsafe(no_mangle)]
+pub extern "C" fn processing_material(window_id: u64, mat_id: u64) {
+    error::clear_error();
+    let window_entity = Entity::from_bits(window_id);
+    let mat_entity = Entity::from_bits(mat_id);
+    error::check(|| graphics_record_command(window_entity, DrawCommand::Material(mat_entity)));
+}

crates/processing_pyo3/examples/materials.py

@@ -0,0 +1,27 @@
+from processing import *
+
+mat = None
+
+def setup():
+    global mat
+    size(800, 600)
+    mode_3d()
+
+    dir_light = create_directional_light(1.0, 0.98, 0.95, 1500.0)
+    point_light = create_point_light(1.0, 1.0, 1.0, 100000.0, 800.0, 0.0)
+    point_light.position(200.0, 200.0, 400.0)
+
+    mat = Material()
+    mat.set_float("roughness", 0.3)
+    mat.set_float("metallic", 0.8)
+    mat.set_float4("base_color", 1.0, 0.85, 0.57, 1.0)
+
+def draw():
+    camera_position(0.0, 0.0, 200.0)
+    camera_look_at(0.0, 0.0, 0.0)
+    background(12, 12, 18)
+
+    use_material(mat)
+    draw_sphere(50.0)
+
+run()

crates/processing_pyo3/src/graphics.rs

@@ -293,11 +293,23 @@ impl Graphics {
             .map_err(|e| PyRuntimeError::new_err(format!("{e}")))
     }
 
+    pub fn draw_sphere(&self, radius: f32, sectors: u32, stacks: u32) -> PyResult<()> {
+        let sphere_geo = geometry_sphere(radius, sectors, stacks)
+            .map_err(|e| PyRuntimeError::new_err(format!("{e}")))?;
+        graphics_record_command(self.entity, DrawCommand::Geometry(sphere_geo))
+            .map_err(|e| PyRuntimeError::new_err(format!("{e}")))
+    }
+
     pub fn draw_geometry(&self, geometry: &Geometry) -> PyResult<()> {
         graphics_record_command(self.entity, DrawCommand::Geometry(geometry.entity))
             .map_err(|e| PyRuntimeError::new_err(format!("{e}")))
     }
 
+    pub fn use_material(&self, material: &crate::material::Material) -> PyResult<()> {
+        graphics_record_command(self.entity, DrawCommand::Material(material.entity))
+            .map_err(|e| PyRuntimeError::new_err(format!("{e}")))
+    }
+
     pub fn scale(&self, x: f32, y: f32) -> PyResult<()> {
         graphics_record_command(self.entity, DrawCommand::Scale { x, y })
             .map_err(|e| PyRuntimeError::new_err(format!("{e}")))
@@ -313,6 +325,11 @@ impl Graphics {
             .map_err(|e| PyRuntimeError::new_err(format!("{e}")))
     }
 
+    pub fn set_material(&self, material: &crate::material::Material) -> PyResult<()> {
+        graphics_record_command(self.entity, DrawCommand::Material(material.entity))
+            .map_err(|e| PyRuntimeError::new_err(format!("{e}")))
+    }
+
     pub fn begin_draw(&self) -> PyResult<()> {
         graphics_begin_draw(self.entity).map_err(|e| PyRuntimeError::new_err(format!("{e}")))
     }

crates/processing_pyo3/src/lib.rs

@@ -10,8 +10,10 @@
 //! functions that forward to a singleton Graphics object pub(crate) behind the scenes.
 mod glfw;
 mod graphics;
+pub(crate) mod material;
 
 use graphics::{Geometry, Graphics, Image, Light, Topology, get_graphics, get_graphics_mut};
+use material::Material;
 use pyo3::{
     exceptions::PyRuntimeError,
     prelude::*,
@@ -27,6 +29,7 @@ fn processing(m: &Bound<'_, PyModule>) -> PyResult<()> {
     m.add_class::<Image>()?;
     m.add_class::<Light>()?;
     m.add_class::<Topology>()?;
+    m.add_class::<Material>()?;
     m.add_function(wrap_pyfunction!(size, m)?)?;
     m.add_function(wrap_pyfunction!(run, m)?)?;
     m.add_function(wrap_pyfunction!(mode_3d, m)?)?;
@@ -48,6 +51,8 @@ fn processing(m: &Bound<'_, PyModule>) -> PyResult<()> {
     m.add_function(wrap_pyfunction!(create_directional_light, m)?)?;
     m.add_function(wrap_pyfunction!(create_point_light, m)?)?;
     m.add_function(wrap_pyfunction!(create_spot_light, m)?)?;
+    m.add_function(wrap_pyfunction!(draw_sphere, m)?)?;
+    m.add_function(wrap_pyfunction!(use_material, m)?)?;
 
     Ok(())
 }
@@ -112,7 +117,7 @@ fn run(module: &Bound<'_, PyModule>) -> PyResult<()> {
         let builtins = PyModule::import(py, "builtins")?;
         let locals = builtins.getattr("locals")?.call0()?;
 
-        let mut setup_fn = locals.get_item("setup")?;
+        let setup_fn = locals.get_item("setup")?;
         let mut draw_fn = locals.get_item("draw")?;
 
         // call setup
@@ -140,7 +145,7 @@ fn run(module: &Bound<'_, PyModule>) -> PyResult<()> {
                         }
                     }
 
-                    setup_fn = locals.get_item("setup").unwrap().unwrap();
+                    // setup_fn = locals.get_item("setup").unwrap().unwrap();
                     draw_fn = locals.get_item("draw").unwrap().unwrap();
 
                     dbg!(locals);
@@ -320,3 +325,20 @@ fn create_spot_light(
 ) -> PyResult<Light> {
     get_graphics(module)?.light_spot(r, g, b, intensity, range, radius, inner_angle, outer_angle)
 }
+
+#[pyfunction]
+#[pyo3(pass_module, signature = (radius, sectors=32, stacks=18))]
+fn draw_sphere(
+    module: &Bound<'_, PyModule>,
+    radius: f32,
+    sectors: u32,
+    stacks: u32,
+) -> PyResult<()> {
+    get_graphics(module)?.draw_sphere(radius, sectors, stacks)
+}
+
+#[pyfunction]
+#[pyo3(pass_module, signature = (material))]
+fn use_material(module: &Bound<'_, PyModule>, material: &Bound<'_, Material>) -> PyResult<()> {
+    get_graphics(module)?.use_material(&*material.extract::<PyRef<Material>>()?)
+}

crates/processing_pyo3/src/material.rs

@@ -0,0 +1,37 @@
+use bevy::prelude::Entity;
+use processing::prelude::*;
+use pyo3::{exceptions::PyRuntimeError, prelude::*};
+
+#[pyclass(unsendable)]
+pub struct Material {
+    pub(crate) entity: Entity,
+}
+
+#[pymethods]
+impl Material {
+    #[new]
+    pub fn new() -> PyResult<Self> {
+        let entity = material_create_pbr().map_err(|e| PyRuntimeError::new_err(format!("{e}")))?;
+        Ok(Self { entity })
+    }
+
+    pub fn set_float(&self, name: &str, value: f32) -> PyResult<()> {
+        material_set(self.entity, name, material::MaterialValue::Float(value))
+            .map_err(|e| PyRuntimeError::new_err(format!("{e}")))
+    }
+
+    pub fn set_float4(&self, name: &str, r: f32, g: f32, b: f32, a: f32) -> PyResult<()> {
+        material_set(
+            self.entity,
+            name,
+            material::MaterialValue::Float4([r, g, b, a]),
+        )
+        .map_err(|e| PyRuntimeError::new_err(format!("{e}")))
+    }
+}
+
+impl Drop for Material {
+    fn drop(&mut self) {
+        let _ = material_destroy(self.entity);
+    }
+}

crates/processing_render/src/error.rs

@@ -30,4 +30,8 @@ pub enum ProcessingError {
     LayoutNotFound,
     #[error("Transform not found")]
     TransformNotFound,
+    #[error("Material not found")]
+    MaterialNotFound,
+    #[error("Unknown material property: {0}")]
+    UnknownMaterialProperty(String),
 }

crates/processing_render/src/geometry/mod.rs

@@ -11,12 +11,13 @@ use std::collections::HashMap;
 
 use bevy::{
     asset::RenderAssetUsages,
-    mesh::{Indices, MeshVertexAttributeId, Meshable, VertexAttributeValues},
+    mesh::{Indices, MeshVertexAttributeId, VertexAttributeValues},
     prelude::*,
     render::render_resource::PrimitiveTopology,
 };
 
 use crate::error::{ProcessingError, Result};
+use crate::render::primitive::{box_mesh, sphere_mesh};
 
 pub struct GeometryPlugin;
 
@@ -158,9 +159,27 @@ pub fn create_box(
     mut meshes: ResMut<Assets<Mesh>>,
     builtins: Res<BuiltinAttributes>,
 ) -> Entity {
-    let cuboid = Cuboid::new(width, height, depth);
-    let mesh = cuboid.mesh().build();
-    let handle = meshes.add(mesh);
+    let handle = meshes.add(box_mesh(width, height, depth));
+
+    let layout_entity = commands
+        .spawn(VertexLayout::with_attributes(vec![
+            builtins.position,
+            builtins.normal,
+            builtins.color,
+            builtins.uv,
+        ]))
+        .id();
+
+    commands.spawn(Geometry::new(handle, layout_entity)).id()
+}
+
+pub fn create_sphere(
+    In((radius, sectors, stacks)): In<(f32, u32, u32)>,
+    mut commands: Commands,
+    mut meshes: ResMut<Assets<Mesh>>,
+    builtins: Res<BuiltinAttributes>,
+) -> Entity {
+    let handle = meshes.add(sphere_mesh(radius, sectors, stacks));
 
     let layout_entity = commands
         .spawn(VertexLayout::with_attributes(vec![

crates/processing_render/src/graphics.rs

@@ -243,7 +243,7 @@ pub fn create(
             Transform::from_xyz(0.0, 0.0, 999.9),
             render_layer,
             CommandBuffer::new(),
-            RenderState::default(),
+            RenderState::new(),
             SurfaceSize(width, height),
             Graphics {
                 readback_buffer,