liangsheng8708
/
ruffle
mirror of https://mirror.ghproxy.com/https://github.com/ruffle-rs/ruffle.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
ruffle/render/naga-agal/Cargo.toml

22 lines
405 B
TOML
Raw Normal View History

render: Add 'naga-agal' crate to compile AGAL shaders to Naga This is the first part of the Stage3D implementation, and can be reviewed independently. Stage3D shaders use the Adobe Graphics Assembly Language (AGAL), which is a binary shader format. It supports vertex attributes, varying registers, program constants (uniforms), and texture sampling. This PR only implements a few parts of AGAL: * The 'mov' and 'm44' opcodes * Vertex attributes, varying registers, program constants, and 'output' registers (position or color, depending on shader type) This is sufficient to get a non-trivial Stage3D program running (the rotating cube demo from the Adobe docs). The output of `naga-agal` is a `naga::Module`. This can be passed directly to wgpu, or compiled into a shader language using a Naga backend (glsl, wgsl, SPIR-V, etc). The test suite output WGSL files, and uses the 'insta' crate to compare against saved files on disk. Currently, the only real way to write AGAL bytecode is using the Adobe-provided 'AGALMiniAssembler' flash class. This class assembles the textual reprentation of AGAL into the binary format. To make writing tests easier, I've added a 'agal_compiler' test, which can easily be modified to add more Agal textual assembly.
2022-09-23 00:44:49 +00:00
[package]
name = "naga-agal"
chore: Inherit cargo metadata from workspace Use workspace inheritance added in Rust 1.64 to de-duplicate various settings across all packages.
2022-12-16 23:09:19 +00:00
authors.workspace = true
edition.workspace = true
homepage.workspace = true
license.workspace = true
repository.workspace = true
version.workspace = true
render: Add 'naga-agal' crate to compile AGAL shaders to Naga This is the first part of the Stage3D implementation, and can be reviewed independently. Stage3D shaders use the Adobe Graphics Assembly Language (AGAL), which is a binary shader format. It supports vertex attributes, varying registers, program constants (uniforms), and texture sampling. This PR only implements a few parts of AGAL: * The 'mov' and 'm44' opcodes * Vertex attributes, varying registers, program constants, and 'output' registers (position or color, depending on shader type) This is sufficient to get a non-trivial Stage3D program running (the rotating cube demo from the Adobe docs). The output of `naga-agal` is a `naga::Module`. This can be passed directly to wgpu, or compiled into a shader language using a Naga backend (glsl, wgsl, SPIR-V, etc). The test suite output WGSL files, and uses the 'insta' crate to compare against saved files on disk. Currently, the only real way to write AGAL bytecode is using the Adobe-provided 'AGALMiniAssembler' flash class. This class assembles the textual reprentation of AGAL into the binary format. To make writing tests easier, I've added a 'agal_compiler' test, which can easily be modified to add more Agal textual assembly.
2022-09-23 00:44:49 +00:00
chore: Delegate `[lints]` in `Cargo.toml` of all packages to the workspace
2024-01-04 21:30:32 +00:00
[lints]
workspace = true
render: Add 'naga-agal' crate to compile AGAL shaders to Naga This is the first part of the Stage3D implementation, and can be reviewed independently. Stage3D shaders use the Adobe Graphics Assembly Language (AGAL), which is a binary shader format. It supports vertex attributes, varying registers, program constants (uniforms), and texture sampling. This PR only implements a few parts of AGAL: * The 'mov' and 'm44' opcodes * Vertex attributes, varying registers, program constants, and 'output' registers (position or color, depending on shader type) This is sufficient to get a non-trivial Stage3D program running (the rotating cube demo from the Adobe docs). The output of `naga-agal` is a `naga::Module`. This can be passed directly to wgpu, or compiled into a shader language using a Naga backend (glsl, wgsl, SPIR-V, etc). The test suite output WGSL files, and uses the 'insta' crate to compare against saved files on disk. Currently, the only real way to write AGAL bytecode is using the Adobe-provided 'AGALMiniAssembler' flash class. This class assembles the textual reprentation of AGAL into the binary format. To make writing tests easier, I've added a 'agal_compiler' test, which can easily be modified to add more Agal textual assembly.
2022-09-23 00:44:49 +00:00
[dependencies]
fix(deps): update rust dependencies
2024-01-22 01:48:50 +00:00
bitflags = "2.4.2"
wpgu: Initial implementation of PixelBender shader execution (#11441) * wpgu: Initial implementation of PixelBender shader execution The implementation is split across four crates: * `ruffle_render` now holds the main PixelBender bytecode parsing implementation (previously, this was in `ruffle_core`). * `ruffle_core` holds some helper functions for converting between AVM2 `Value`s and the PixelBender vector types. * `naga-pixelbender` (newly created) constructs a Naga `Module` from parsed PixelBender bytecode * `ruffle_render_wgpu` sets up the render pipeline for the shader constructed by `naga-pixelbender`, and actually executes the shader. The Actionscript-side shader parameters are passed in through uniforms. This allows us to cache the compiled `naga::Module` and associated wgpu types inside `ShaderData`, when it's first created. Each invocation of a `ShaderJob` only needs to create a bind group and render pass. Limitations: * Only a few of the PixelBender opcodes are implemented - however, this is enough to get Stemlands cannon rotation working, as well as a cool "donut" shader that I found and included as a test. * PixelBender matrix types are not supported. * Only BitmapData is supported as an input/output type - Flash Player also supports using Vector and ByteArray * ShaderJob execution is always synchronous. * Adjust comments * Address review comments
2023-06-15 22:50:24 +00:00
naga = { workspace = true }
fix(deps): update rust dependencies
2023-10-09 21:59:27 +00:00
num-derive = "0.4.1"
num-traits = "0.2.17"
render: Add 'naga-agal' crate to compile AGAL shaders to Naga This is the first part of the Stage3D implementation, and can be reviewed independently. Stage3D shaders use the Adobe Graphics Assembly Language (AGAL), which is a binary shader format. It supports vertex attributes, varying registers, program constants (uniforms), and texture sampling. This PR only implements a few parts of AGAL: * The 'mov' and 'm44' opcodes * Vertex attributes, varying registers, program constants, and 'output' registers (position or color, depending on shader type) This is sufficient to get a non-trivial Stage3D program running (the rotating cube demo from the Adobe docs). The output of `naga-agal` is a `naga::Module`. This can be passed directly to wgpu, or compiled into a shader language using a Naga backend (glsl, wgsl, SPIR-V, etc). The test suite output WGSL files, and uses the 'insta' crate to compare against saved files on disk. Currently, the only real way to write AGAL bytecode is using the Adobe-provided 'AGALMiniAssembler' flash class. This class assembles the textual reprentation of AGAL into the binary format. To make writing tests easier, I've added a 'agal_compiler' test, which can easily be modified to add more Agal textual assembly.
2022-09-23 00:44:49 +00:00
[dev-dependencies]
fix(deps): update rust dependencies
2023-10-16 00:51:05 +00:00
insta = "1.34.0"
wgpu: Update wgpu and naga to 0.19
2024-01-09 23:01:58 +00:00
naga = { workspace = true, features = ["wgsl-out"] }