Add Sampler API.

Author: tychedelia

crates/processing_pyo3/src/graphics.rs

@@ -132,6 +132,66 @@ impl PyBlendMode {
     const OP_MAX: u8 = 4;
 }
 
+/// Configures how an image is sampled when drawn.
+///
+/// Controls texture filtering and edge wrapping behavior.
+///
+/// - `filter` — `Sampler.LINEAR` (smooth) or `Sampler.NEAREST` (pixelated).
+/// - `wrap` — `Sampler.CLAMP` (default), `Sampler.REPEAT`, or `Sampler.MIRROR`.
+///   Use `wrap_x`/`wrap_y` to set each axis independently.
+#[pyclass]
+#[derive(Clone)]
+pub struct Sampler {
+    pub(crate) filter: u8,
+    pub(crate) wrap_x: u8,
+    pub(crate) wrap_y: u8,
+}
+
+#[pymethods]
+impl Sampler {
+    #[new]
+    #[pyo3(signature = (*, filter=0, wrap=0, wrap_x=None, wrap_y=None))]
+    fn new(filter: u8, wrap: u8, wrap_x: Option<u8>, wrap_y: Option<u8>) -> Self {
+        Self {
+            filter,
+            wrap_x: wrap_x.unwrap_or(wrap),
+            wrap_y: wrap_y.unwrap_or(wrap),
+        }
+    }
+
+    fn __repr__(&self) -> String {
+        let filter_name = match self.filter {
+            0 => "LINEAR",
+            1 => "NEAREST",
+            _ => "?",
+        };
+        let wrap_name = |v: u8| match v {
+            0 => "CLAMP",
+            1 => "REPEAT",
+            2 => "MIRROR",
+            _ => "?",
+        };
+        format!(
+            "Sampler(filter={}, wrap_x={}, wrap_y={})",
+            filter_name,
+            wrap_name(self.wrap_x),
+            wrap_name(self.wrap_y)
+        )
+    }
+
+    #[classattr]
+    const LINEAR: u8 = 0;
+    #[classattr]
+    const NEAREST: u8 = 1;
+
+    #[classattr]
+    const CLAMP: u8 = 0;
+    #[classattr]
+    const REPEAT: u8 = 1;
+    #[classattr]
+    const MIRROR: u8 = 2;
+}
+
 pub use crate::surface::Surface;
 
 #[pyclass]
@@ -197,6 +257,20 @@ impl<'a, 'py> FromPyObject<'a, 'py> for ImageRef {
     }
 }
 
+#[pymethods]
+impl Image {
+    /// Applies a `Sampler` to this image, controlling filtering and wrapping.
+    ///
+    /// ```python
+    /// s = Sampler(filter=Sampler.NEAREST, wrap=Sampler.REPEAT)
+    /// img.sampler(s)
+    /// ```
+    fn sampler(&self, sampler: &Sampler) -> PyResult<()> {
+        image_set_sampler(self.entity, sampler.filter, sampler.wrap_x, sampler.wrap_y)
+            .map_err(|e| PyRuntimeError::new_err(format!("{e}")))
+    }
+}
+
 impl Drop for Image {
     fn drop(&mut self) {
         let _ = image_destroy(self.entity);
@@ -1073,21 +1147,6 @@ impl Graphics {
             .map_err(|e| PyRuntimeError::new_err(format!("{e}")))
     }
 
-    pub fn texture(&self, source: ImageRef) -> PyResult<()> {
-        graphics_record_command(self.entity, DrawCommand::Texture(source.entity))
-            .map_err(|e| PyRuntimeError::new_err(format!("{e}")))
-    }
-
-    pub fn no_texture(&self) -> PyResult<()> {
-        graphics_record_command(self.entity, DrawCommand::NoTexture)
-            .map_err(|e| PyRuntimeError::new_err(format!("{e}")))
-    }
-
-    pub fn texture_transform(&self, transform: crate::math::PyAffine2) -> PyResult<()> {
-        graphics_record_command(self.entity, DrawCommand::TextureTransform(transform.0))
-            .map_err(|e| PyRuntimeError::new_err(format!("{e}")))
-    }
-
     pub fn unlit(&self) -> PyResult<()> {
         graphics_record_command(self.entity, DrawCommand::Unlit)
             .map_err(|e| PyRuntimeError::new_err(format!("{e}")))

crates/processing_pyo3/src/lib.rs

@@ -26,7 +26,8 @@ mod time;
 mod webcam;
 
 use graphics::{
-    Geometry, Graphics, Image, Light, PyBlendMode, Topology, get_graphics, get_graphics_mut,
+    Geometry, Graphics, Image, Light, PyBlendMode, Sampler, Topology, get_graphics,
+    get_graphics_mut,
 };
 use material::Material;
 
@@ -340,6 +341,8 @@ mod mewnala {
     #[pymodule_export]
     use super::PyBlendMode;
     #[pymodule_export]
+    use super::Sampler;
+    #[pymodule_export]
     use super::Shader;
     #[pymodule_export]
     use super::Topology;
@@ -1518,27 +1521,6 @@ mod mewnala {
         graphics!(module).emissive(args)
     }
 
-    #[pyfunction]
-    #[pyo3(pass_module)]
-    fn texture(module: &Bound<'_, PyModule>, source: graphics::ImageRef) -> PyResult<()> {
-        graphics!(module).texture(source)
-    }
-
-    #[pyfunction]
-    #[pyo3(pass_module)]
-    fn no_texture(module: &Bound<'_, PyModule>) -> PyResult<()> {
-        graphics!(module).no_texture()
-    }
-
-    #[pyfunction]
-    #[pyo3(pass_module)]
-    fn texture_transform(
-        module: &Bound<'_, PyModule>,
-        transform: crate::math::PyAffine2,
-    ) -> PyResult<()> {
-        graphics!(module).texture_transform(transform)
-    }
-
     #[pyfunction]
     #[pyo3(pass_module)]
     fn unlit(module: &Bound<'_, PyModule>) -> PyResult<()> {

crates/processing_render/src/image.rs

@@ -9,6 +9,7 @@ use bevy::{
         io::{AssetSourceId, embedded::GetAssetServer},
     },
     ecs::system::RunSystemOnce,
+    image::{ImageAddressMode, ImageFilterMode, ImageSampler, ImageSamplerDescriptor},
     prelude::*,
     render::{
         RenderApp,
@@ -466,6 +467,50 @@ pub fn create_readback_buffer(
     }))
 }
 
+pub fn set_sampler(
+    In((entity, filter, wrap_x, wrap_y)): In<(Entity, u8, u8, u8)>,
+    p_images: Query<&Image>,
+    mut images: ResMut<Assets<bevy::image::Image>>,
+) -> Result<()> {
+    let p_image = p_images
+        .get(entity)
+        .map_err(|_| ProcessingError::ImageNotFound)?;
+
+    let mut image = images
+        .get_mut(&p_image.handle)
+        .ok_or(ProcessingError::ImageNotFound)?;
+
+    let filter_mode = match filter {
+        0 => ImageFilterMode::Linear,
+        1 => ImageFilterMode::Nearest,
+        _ => {
+            return Err(ProcessingError::InvalidArgument(format!(
+                "unknown filter mode: {filter}"
+            )));
+        }
+    };
+
+    let addr_mode = |v: u8| match v {
+        0 => Ok(ImageAddressMode::ClampToEdge),
+        1 => Ok(ImageAddressMode::Repeat),
+        2 => Ok(ImageAddressMode::MirrorRepeat),
+        _ => Err(ProcessingError::InvalidArgument(format!(
+            "unknown wrap mode: {v}"
+        ))),
+    };
+
+    image.sampler = ImageSampler::Descriptor(ImageSamplerDescriptor {
+        mag_filter: filter_mode,
+        min_filter: filter_mode,
+        mipmap_filter: filter_mode,
+        address_mode_u: addr_mode(wrap_x)?,
+        address_mode_v: addr_mode(wrap_y)?,
+        ..Default::default()
+    });
+
+    Ok(())
+}
+
 pub fn gpu_image(app: &mut App, entity: Entity) -> Result<&GpuImage> {
     let handle = app
         .world()

crates/processing_render/src/lib.rs

@@ -933,6 +933,15 @@ pub fn image_update_region(
     })
 }
 
+/// Set the sampler for an image (filter mode + wrap modes).
+pub fn image_set_sampler(entity: Entity, filter: u8, wrap_x: u8, wrap_y: u8) -> error::Result<()> {
+    app_mut(|app| {
+        app.world_mut()
+            .run_system_cached_with(image::set_sampler, (entity, filter, wrap_x, wrap_y))
+            .unwrap()
+    })
+}
+
 /// Destroy an existing image and free its resources.
 pub fn image_destroy(entity: Entity) -> error::Result<()> {
     app_mut(|app| {

crates/processing_render/src/render/command.rs

@@ -1,4 +1,3 @@
-use bevy::math::Affine2;
 use bevy::prelude::*;
 use bevy::render::render_resource::{BlendComponent, BlendFactor, BlendOperation, BlendState};
 use processing_core::error::{self, ProcessingError};
@@ -307,9 +306,6 @@ pub enum DrawCommand {
     Roughness(f32),
     Metallic(f32),
     Emissive(Color),
-    Texture(Entity),
-    NoTexture,
-    TextureTransform(Affine2),
     Unlit,
     Tint(Color),
     NoTint,

crates/processing_render/src/render/mod.rs

@@ -217,25 +217,6 @@ pub fn flush_draw_commands(
                     pbr.blend_state = None;
                     state.material_key = pbr.into();
                 }
-                DrawCommand::Texture(entity) => {
-                    if let Ok(img) = p_images.get(entity) {
-                        let mut pbr = state.material_key.as_pbr();
-                        pbr.base_color_texture = Some(img.handle.clone());
-                        state.material_key = pbr.into();
-                    }
-                }
-                DrawCommand::NoTexture => {
-                    if let MaterialKey::Pbr { .. } = &state.material_key {
-                        let mut pbr = state.material_key.as_pbr();
-                        pbr.base_color_texture = None;
-                        state.material_key = pbr.into();
-                    }
-                }
-                DrawCommand::TextureTransform(transform) => {
-                    let mut pbr = state.material_key.as_pbr();
-                    pbr.uv_transform = transform;
-                    state.material_key = pbr.into();
-                }
                 DrawCommand::Unlit => {
                     state.material_key = MaterialKey::Color {
                         transparent: state.fill_is_transparent(),