render: Move Pixel Bender stuff to its own crate

Cargo.toml

@@ -19,6 +19,7 @@ members = [
     "render",
     "render/canvas",
     "render/naga-agal",
+    "render/pixel_bender",
     "render/wgpu",
     "render/webgl",
 

core/src/avm2/globals/flash/display/shader_job.rs

@@ -15,9 +15,10 @@ use crate::avm2_stub_method;
 use ruffle_render::backend::{PixelBenderOutput, PixelBenderTarget};
 use ruffle_render::bitmap::PixelRegion;
 use ruffle_render::pixel_bender::{
-    ImageInputTexture, PixelBenderParam, PixelBenderParamQualifier, PixelBenderShaderArgument,
-    PixelBenderShaderHandle, PixelBenderType, OUT_COORD_NAME,
+    PixelBenderParam, PixelBenderParamQualifier, PixelBenderShaderHandle, PixelBenderType,
+    OUT_COORD_NAME,
 };
+use ruffle_render::pixel_bender_support::{ImageInputTexture, PixelBenderShaderArgument};
 
 pub fn get_shader_args<'gc>(
     shader_obj: Object<'gc>,

render/Cargo.toml

@@ -13,6 +13,7 @@ workspace = true
 [dependencies]
 ruffle_wstr = { path = "../wstr" }
 swf = { path = "../swf"}
+pixel_bender = { path = "pixel_bender"}
 tracing = { workspace = true }
 gif = "0.13.3"
 png = "0.17.16"

render/canvas/src/lib.rs

@@ -574,7 +574,7 @@ impl RenderBackend for WebCanvasRenderBackend {
     fn run_pixelbender_shader(
         &mut self,
         _handle: ruffle_render::pixel_bender::PixelBenderShaderHandle,
-        _arguments: &[ruffle_render::pixel_bender::PixelBenderShaderArgument],
+        _arguments: &[ruffle_render::pixel_bender_support::PixelBenderShaderArgument],
         _target: &PixelBenderTarget,
     ) -> Result<PixelBenderOutput, Error> {
         Err(Error::Unimplemented("run_pixelbender_shader".into()))

render/naga-pixelbender/Cargo.toml

@@ -14,4 +14,3 @@ workspace = true
 ruffle_render = { path = "../" }
 naga = { workspace = true }
 anyhow = { workspace = true }
-

render/pixel_bender/Cargo.toml

@@ -0,0 +1,17 @@
+[package]
+name = "pixel_bender"
+authors.workspace = true
+edition.workspace = true
+homepage.workspace = true
+license.workspace = true
+repository.workspace = true
+version.workspace = true
+
+[lints]
+workspace = true
+
+[dependencies]
+thiserror = { workspace = true }
+num-traits = { workspace = true }
+num-derive = { workspace = true }
+byteorder = { workspace = true }

render/src/pixel_bender/disassembly.rs → render/pixel_bender/src/disassembly.rs

@@ -1,6 +1,6 @@
 use std::fmt::{Display, Formatter};
 
-use crate::pixel_bender::{
+use crate::parser::{
     Opcode, Operation, PixelBenderMetadata, PixelBenderParam, PixelBenderParamQualifier,
     PixelBenderReg, PixelBenderRegChannel, PixelBenderRegKind, PixelBenderShader, PixelBenderType,
     PixelBenderTypeOpcode,

render/pixel_bender/src/lib.rs

@@ -0,0 +1,7 @@
+#[cfg(test)]
+mod tests;
+
+pub mod disassembly;
+mod parser;
+
+pub use parser::*;

render/src/pixel_bender.rs → render/pixel_bender/src/parser.rs

@@ -1,11 +1,6 @@
 //! Pixel bender bytecode parsing code.
 //! This is heavily based on https://github.com/jamesward/pbjas and https://github.com/HaxeFoundation/format/tree/master/format/pbj
 
-#[cfg(test)]
-mod tests;
-
-pub mod disassembly;
-
 use byteorder::{BigEndian, LittleEndian, ReadBytesExt};
 use num_traits::FromPrimitive;
 use std::{
@@ -16,8 +11,6 @@ use std::{
 };
 use thiserror::Error;
 
-use crate::{backend::RawTexture, bitmap::BitmapHandle};
-
 /// The name of a special parameter, which gets automatically filled in with the coordinates
 /// of the pixel being processed.
 pub const OUT_COORD_NAME: &str = "_OutCoord";
@@ -307,61 +300,6 @@ pub enum Operation {
     },
 }
 
-#[derive(Debug, Clone, PartialEq)]
-pub enum PixelBenderShaderArgument<'a> {
-    ImageInput {
-        index: u8,
-        channels: u8,
-        name: String,
-        texture: Option<ImageInputTexture<'a>>,
-    },
-    ValueInput {
-        index: u8,
-        value: PixelBenderType,
-    },
-}
-
-/// An image input.
-///
-/// This accepts both an owned BitmapHandle, and a borrowed texture
-/// (used when applying a filter to a texture that we don't have
-/// ownership of, and therefore cannot construct a BitmapHandle for).
-#[derive(Debug, Clone)]
-pub enum ImageInputTexture<'a> {
-    Bitmap(BitmapHandle),
-    TextureRef(&'a dyn RawTexture),
-    Bytes {
-        width: u32,
-        height: u32,
-        channels: u32,
-        bytes: Vec<u8>,
-    },
-}
-
-impl PartialEq for ImageInputTexture<'_> {
-    fn eq(&self, other: &Self) -> bool {
-        match (self, other) {
-            (Self::Bitmap(self_bitmap), Self::Bitmap(other_bitmap)) => self_bitmap == other_bitmap,
-            (Self::TextureRef(self_texture), Self::TextureRef(other_texture)) => {
-                self_texture.equals(*other_texture)
-            }
-            _ => false,
-        }
-    }
-}
-
-impl From<BitmapHandle> for ImageInputTexture<'_> {
-    fn from(b: BitmapHandle) -> Self {
-        ImageInputTexture::Bitmap(b)
-    }
-}
-
-impl<'a> From<&'a dyn RawTexture> for ImageInputTexture<'a> {
-    fn from(t: &'a dyn RawTexture) -> Self {
-        ImageInputTexture::TextureRef(t)
-    }
-}
-
 #[derive(Debug, PartialEq, Clone)]
 pub struct PixelBenderShader {
     pub name: String,

render/src/pixel_bender/tests.rs → render/pixel_bender/src/tests.rs

@@ -1,10 +1,10 @@
-use crate::pixel_bender::{
+use crate::parser::{
     Opcode, Operation, PixelBenderMetadata, PixelBenderParam, PixelBenderParamQualifier,
     PixelBenderReg, PixelBenderRegChannel, PixelBenderRegKind, PixelBenderShader, PixelBenderType,
     PixelBenderTypeOpcode,
 };
 
-use super::parse_shader;
+use super::parser::parse_shader;
 
 #[test]
 fn simple_shader() {

render/src/backend.rs

@@ -4,7 +4,8 @@ use crate::bitmap::{Bitmap, BitmapHandle, BitmapSource, PixelRegion, RgbaBufRead
 use crate::commands::CommandList;
 use crate::error::Error;
 use crate::filters::Filter;
-use crate::pixel_bender::{PixelBenderShader, PixelBenderShaderArgument, PixelBenderShaderHandle};
+use crate::pixel_bender::{PixelBenderShader, PixelBenderShaderHandle};
+use crate::pixel_bender_support::PixelBenderShaderArgument;
 use crate::quality::StageQuality;
 use crate::shape_utils::DistilledShape;
 use ruffle_wstr::WStr;

render/src/backend/null.rs

@@ -10,7 +10,8 @@ use crate::bitmap::{
 };
 use crate::commands::CommandList;
 use crate::error::Error;
-use crate::pixel_bender::{PixelBenderShader, PixelBenderShaderArgument, PixelBenderShaderHandle};
+use crate::pixel_bender::{PixelBenderShader, PixelBenderShaderHandle};
+use crate::pixel_bender_support::PixelBenderShaderArgument;
 use crate::quality::StageQuality;
 use crate::shape_utils::DistilledShape;
 use swf::Color;

render/src/filters.rs

@@ -1,7 +1,6 @@
-use crate::{
-    bitmap::BitmapHandle,
-    pixel_bender::{PixelBenderShaderArgument, PixelBenderShaderHandle},
-};
+use crate::bitmap::BitmapHandle;
+use crate::pixel_bender::PixelBenderShaderHandle;
+use crate::pixel_bender_support::PixelBenderShaderArgument;
 use std::{any::Any, fmt::Debug};
 use swf::{Color, Rectangle, Twips};
 

render/src/lib.rs

@@ -10,7 +10,7 @@ pub mod lines;
 pub mod matrix;
 pub mod matrix3d;
 pub mod perspective_projection;
-pub mod pixel_bender;
+pub mod pixel_bender_support;
 // The `renderdoc` crate doesn't compile on apple platforms
 #[cfg(all(feature = "renderdoc", not(target_vendor = "apple")))]
 pub mod renderdoc;
@@ -23,3 +23,5 @@ pub mod commands;
 pub mod quality;
 #[cfg(feature = "tessellator")]
 pub mod tessellator;
+
+pub use pixel_bender;

render/src/pixel_bender_support.rs

@@ -0,0 +1,58 @@
+use crate::backend::RawTexture;
+use crate::bitmap::BitmapHandle;
+use crate::pixel_bender::PixelBenderType;
+
+#[derive(Debug, Clone, PartialEq)]
+pub enum PixelBenderShaderArgument<'a> {
+    ImageInput {
+        index: u8,
+        channels: u8,
+        name: String,
+        texture: Option<ImageInputTexture<'a>>,
+    },
+    ValueInput {
+        index: u8,
+        value: PixelBenderType,
+    },
+}
+
+/// An image input.
+///
+/// This accepts both an owned BitmapHandle, and a borrowed texture
+/// (used when applying a filter to a texture that we don't have
+/// ownership of, and therefore cannot construct a BitmapHandle for).
+#[derive(Debug, Clone)]
+pub enum ImageInputTexture<'a> {
+    Bitmap(BitmapHandle),
+    TextureRef(&'a dyn RawTexture),
+    Bytes {
+        width: u32,
+        height: u32,
+        channels: u32,
+        bytes: Vec<u8>,
+    },
+}
+
+impl PartialEq for ImageInputTexture<'_> {
+    fn eq(&self, other: &Self) -> bool {
+        match (self, other) {
+            (Self::Bitmap(self_bitmap), Self::Bitmap(other_bitmap)) => self_bitmap == other_bitmap,
+            (Self::TextureRef(self_texture), Self::TextureRef(other_texture)) => {
+                self_texture.equals(*other_texture)
+            }
+            _ => false,
+        }
+    }
+}
+
+impl From<BitmapHandle> for ImageInputTexture<'_> {
+    fn from(b: BitmapHandle) -> Self {
+        ImageInputTexture::Bitmap(b)
+    }
+}
+
+impl<'a> From<&'a dyn RawTexture> for ImageInputTexture<'a> {
+    fn from(t: &'a dyn RawTexture) -> Self {
+        ImageInputTexture::TextureRef(t)
+    }
+}

render/webgl/src/lib.rs

@@ -1217,7 +1217,7 @@ impl RenderBackend for WebGlRenderBackend {
     fn run_pixelbender_shader(
         &mut self,
         _handle: ruffle_render::pixel_bender::PixelBenderShaderHandle,
-        _arguments: &[ruffle_render::pixel_bender::PixelBenderShaderArgument],
+        _arguments: &[ruffle_render::pixel_bender_support::PixelBenderShaderArgument],
         _target: &PixelBenderTarget,
     ) -> Result<PixelBenderOutput, BitmapError> {
         Err(BitmapError::Unimplemented("run_pixelbender_shader".into()))

render/wgpu/src/backend.rs

@@ -24,9 +24,8 @@ use ruffle_render::bitmap::{
 use ruffle_render::commands::CommandList;
 use ruffle_render::error::Error as BitmapError;
 use ruffle_render::filters::Filter;
-use ruffle_render::pixel_bender::{
-    PixelBenderShader, PixelBenderShaderArgument, PixelBenderShaderHandle,
-};
+use ruffle_render::pixel_bender::{PixelBenderShader, PixelBenderShaderHandle};
+use ruffle_render::pixel_bender_support::PixelBenderShaderArgument;
 use ruffle_render::quality::StageQuality;
 use ruffle_render::shape_utils::DistilledShape;
 use ruffle_render::tessellator::ShapeTessellator;

render/wgpu/src/filters/shader.rs

@@ -1,6 +1,6 @@
 use ruffle_render::{
     filters::ShaderFilter as ShaderFilterArgs,
-    pixel_bender::{ImageInputTexture, PixelBenderShaderArgument},
+    pixel_bender_support::{ImageInputTexture, PixelBenderShaderArgument},
 };
 
 use crate::{

render/wgpu/src/pixel_bender.rs

@@ -5,15 +5,13 @@ use std::num::NonZeroU64;
 use std::{borrow::Cow, cell::Cell, sync::Arc};
 
 use indexmap::IndexMap;
+use ruffle_render::bitmap::BitmapHandle;
 use ruffle_render::error::Error as BitmapError;
 use ruffle_render::pixel_bender::{
-    ImageInputTexture, PixelBenderShaderHandle, PixelBenderShaderImpl, PixelBenderType,
-    OUT_COORD_NAME,
-};
-use ruffle_render::{
-    bitmap::BitmapHandle,
-    pixel_bender::{PixelBenderParam, PixelBenderShader, PixelBenderShaderArgument},
+    PixelBenderParam, PixelBenderShader, PixelBenderShaderHandle, PixelBenderShaderImpl,
+    PixelBenderType, OUT_COORD_NAME,
 };
+use ruffle_render::pixel_bender_support::{ImageInputTexture, PixelBenderShaderArgument};
 use smallvec::{smallvec_inline, SmallVec};
 use wgpu::util::{DeviceExt, StagingBelt};
 use wgpu::{

render/wgpu/src/surface.rs

@@ -12,7 +12,7 @@ use crate::surface::commands::{chunk_blends, Chunk, CommandRenderer};
 use crate::utils::{remove_srgb, supported_sample_count};
 use crate::{Descriptors, MaskState, Pipelines};
 use ruffle_render::commands::CommandList;
-use ruffle_render::pixel_bender::{ImageInputTexture, PixelBenderShaderArgument};
+use ruffle_render::pixel_bender_support::{ImageInputTexture, PixelBenderShaderArgument};
 use ruffle_render::quality::StageQuality;
 use std::sync::Arc;
 use target::CommandTarget;