16 Jun 11:53

bbb6922

scenix v1.3.0 Latest

Latest

Scenix v1.3.0 Asset Pipeline

Scenix 1.3.0 turns scenix-loader into a production-oriented CPU asset pipeline while preserving explicit renderer-owned GPU upload.

Highlights

Workspace crates are bumped to 1.3.0.
New AssetPackage, AssetManager, dependency graph, diagnostics, async file loading, memory budget accounting, and hot-reload invalidation APIs.
New typed IDs: AssetId, SkinId, and AnimationClipId.
New glTF package APIs: load_package_file, load_package_bytes, and load_package_url.
glTF package imports now collect skins, skin attributes, morph targets, animation clip metadata, material extension metadata, texture transforms, variants, KTX2/BasisU notes, meshopt diagnostics, and Draco diagnostics.
New exporter helpers for glTF summary JSON/GLB bytes, OBJ, STL, PLY, and scene JSON.
New RendererAssetExt::register_asset_package facade bridge for explicit package-to-renderer upload.
New examples: asset_pipeline, asset_manager, export_scene, animation_import, and compressed_assets.

Install

[dependencies]
scenix = "1.3"

Asset pipeline:

[dependencies]
scenix = { version = "1.3", features = ["loader"] }

Asset pipeline with renderer upload:

[dependencies]
scenix = { version = "1.3", features = ["loader", "renderer"] }

Code Example

use scenix::{
    AssetManager, PerspectiveCamera, Renderer, RendererAssetExt, RendererConfig, ScenixError, Vec3,
};

# async fn run() -> Result<(), ScenixError> {
let mut manager = AssetManager::new();
let package = manager.load_file("assets/robot.glb")?;

let mut renderer = Renderer::headless(RendererConfig::new(512, 512)).await?;
let uploaded = renderer.register_asset_package(&package)?;

let camera = PerspectiveCamera::new(50.0, 1.0, 0.1, 100.0)
    .position(Vec3::new(0.0, 1.0, 4.0))
    .target(Vec3::ZERO);

let stats = renderer.render(package.scene(), &camera)?;
println!("meshes={}, draws={}", uploaded.meshes, stats.visible_meshes);
# Ok(())
# }

Supported Asset Matrix

Format	Support
glTF / GLB	Full CPU import with v1.3 metadata sidecars
OBJ / MTL	Full geometry import and material texture metadata
STL	Full ASCII/binary triangle import
PNG / JPEG / WebP / TGA / TIFF / EXR	Texture decode through `image`
KTX2 / HDR	Partial texture/HDR metadata and supported raw formats
DDS / PLY / VOX / SVG / IES / LUT	Recognized with partial metadata/diagnostics
FBX / USD / USDZ / 3MF / VTK / Rhino / LDraw / fonts / UltraHDR	Diagnostic-only; use an external converter
Draco / meshopt glTF compression	Explicit diagnostics unless preprocessed

Migration Notes

Existing GltfLoader::load_file and GltfAsset users keep working.
Use GltfLoader::load_package_file or AssetManager::load_file when you need v1.3 metadata, diagnostics, exporters, dependency tracking, or renderer upload helpers.
AssetPackage stores morph targets, skins, animation clips, and material extension metadata as sidecars so stable Geometry and GltfAsset struct literals remain compatible.
RendererAssetExt is a convenience API; GPU ownership still belongs to Renderer.

Animato 1.6.0 Gate

This release is prepared for animato = "1.6.0", but crates.io currently reports Animato 1.5.0 as the latest published version. Do not publish the final crates.io release until animato 1.6.0 resolves cleanly with the existing std, tween, spring, and serde feature set.

Known Limitations

Draco and meshopt decoding require external preprocessing in this release.
FBX/USD/USDZ and other proprietary or broad interchange formats are diagnostic-only.
Imported animation clips are metadata/keyframe sidecars; full clip mixer/action playback remains planned for the animation runtime milestone.
Loader output remains CPU-side; GPU upload is explicit.

What's Changed

[codex] Add v1.3.0 asset pipeline by @aarambh-darshan in #14

Full Changelog: v1.2.0...v1.3.0

Contributors

aarambh-darshan

Assets 2

13 Jun 08:45

github-actions

v1.2.0

d2fc36a

scenix v1.2.0

Scenix v1.2.0 Renderer And Material Parity

Scenix 1.2.0 moves the renderer from preview-oriented material color paths to real renderer-owned GPU resources for textures, lights, environment descriptors, render targets, diagnostics, and lifecycle workflows.

Highlights

All workspace crates are bumped to 1.2.0.
scenix-animato now targets animato = "1.5.0".
scenix-renderer uploads Texture2D, TextureCube, and Texture3D resources with mip-aware layout validation and sampler conversion.
PBR, physical, unlit, Lambert, toon, normal, and wireframe materials now feed the active renderer path through material uniforms and texture bind groups.
Ambient, hemisphere, directional, point, spot, area, and light-probe data can be registered with the renderer.
EnvironmentMap, renderer-owned render targets, render-to-texture, readback, resource diagnostics, and lifecycle APIs are available through additive APIs.
WebGL fallback now prefers a real WebGL2 renderer path when WebGPU is unavailable, with WebGL1 kept as a reduced last-resort path.

Install

[dependencies]
scenix = "1.2"

Renderer stack:

[dependencies]
scenix = { version = "1.2", features = ["renderer", "post"] }

Full optional stack:

[dependencies]
scenix = { version = "1.2", features = ["loader", "renderer", "post", "animato", "wasm"] }

Code Example

use scenix::{
    Color, MaterialId, MeshId, PbrMaterial, PerspectiveCamera, Renderer, RendererConfig,
    Sampler, SceneGraph, SceneNode, Texture2D, TextureFormat, TextureId, Vec3, sphere_geometry,
};

# async fn run() -> Result<(), scenix::ScenixError> {
let mut renderer = Renderer::headless(RendererConfig::new(512, 512)).await?;

let albedo_id = TextureId::new(10);
let albedo = Texture2D::new(
    1,
    1,
    TextureFormat::Rgba8UnormSrgb,
    vec![255, 180, 80, 255],
)?;
renderer.register_texture2d(albedo_id, &albedo, Sampler::new())?;

let mesh_id = MeshId::new(1);
let material_id = MaterialId::new(1);
renderer.register_mesh(mesh_id, &sphere_geometry(1.0, 48, 24))?;

let mut material = PbrMaterial::new()
    .albedo(Color::WHITE)
    .metallic_roughness(0.25, 0.4);
material.albedo_texture = Some(albedo_id);
renderer.register_pbr_material(material_id, &material)?;

let mut scene = SceneGraph::new();
scene.add(SceneNode::mesh("textured sphere", mesh_id, material_id));
scene.update_world_transforms();

let camera = PerspectiveCamera::new(50.0, 1.0, 0.1, 100.0)
    .position(Vec3::new(0.0, 0.0, 3.5))
    .target(Vec3::ZERO);

let stats = renderer.render(&scene, &camera)?;
println!("draws={}, textures={}", stats.opaque_draws, renderer.diagnostics().textures);
# Ok(())
# }

Migration Notes

Existing v1 renderer code keeps compiling; new APIs are additive.
Renderer::register_texture2d now uploads a real GPU texture instead of storing metadata only.
Use TextureId for render targets in v1.2.0: create targets with create_render_target, render with render_to_texture, and read with read_texture_pixel.
Enable the animato facade feature as before; the bridge now resolves to Animato 1.5.0.

WebGPU And WebGL

Browser rendering is WebGPU first. If WebGPU is unavailable or unsafe, BrowserRenderer falls back to WebGL2 and renders the generated scene through WebGL textures, material uniforms, directional/point lights, toon/physical approximations, post toggles, picking, and animation.
WebGL2 reports parity=full-fallback through diagnostics and is the intended full browser fallback for v1.2.0 demos.
WebGL1 remains a reduced last-resort fallback for old browsers and reports parity=reduced-fallback.

Known Limitations

v1.2.0 keeps GPU upload explicit; loaders still produce CPU-side assets.
Physical material transmission and environment response are realtime approximations.
Shadow support is designed for practical smoke scenes and editor previews; large production shadow systems remain future work.
GPU tests still require a Vulkan-capable device or Mesa lavapipe.

Scenix v1.1.0 Browser Fallback

Scenix 1.1.0 improves browser reliability by adding a real WebGL fallback inside scenix-wasm. The stable v1 API remains additive: the existing WebGPU WebRenderer stays available, and applications can now use BrowserRenderer when they want automatic backend selection.

Highlights

All workspace crates are bumped to 1.1.0.
scenix-wasm now provides BrowserRenderer, WebGlRenderer, BrowserBackendPreference, and BrowserBackendKind.
Browser startup now chooses WebGPU where safe, WebGL when WebGPU is unavailable or unsuitable, and leaves Canvas2D as the final website fallback.
The website demo uses the crate-level BrowserRenderer instead of website-only WebGPU detection.
WebGL renders the generated Scenix Engine Lab scene with depth testing, camera matrices, material color preview, helper visibility, wireframe preview, animation controls, and CPU raycast picking.
Publish and Pages workflows build the website with a Trunk-compatible NO_COLOR=false environment.

Install

[dependencies]
scenix = "1.1"

Browser support through the facade:

[dependencies]
scenix = { version = "1.1", features = ["wasm"] }

Optional full stack:

[dependencies]
scenix = { version = "1.1", features = ["loader", "renderer", "post", "animato", "wasm"] }

What Changed From 1.0.0

Bumped all workspace crates from 1.0.0 to 1.1.0.
Added a WebGL compatibility renderer inside scenix-wasm; no new crate is required.
Added automatic browser backend selection through BrowserRenderer.
Updated the website bridge so Firefox and browsers without usable WebGPU try WebGL before Canvas2D.
Updated documentation, changelog, tests, and GitHub Release automation for the v1.1.0 release.

Code Example

use scenix_wasm::BrowserRenderer;
use wasm_bindgen::JsCast;

# async fn run() -> Result<(), wasm_bindgen::JsValue> {
let canvas = web_sys::window()
    .unwrap()
    .document()
    .unwrap()
    .get_element_by_id("scenix-canvas")
    .unwrap()
    .dyn_into::<web_sys::HtmlCanvasElement>()?;

let mut renderer = BrowserRenderer::new(canvas).await?;
renderer.tick(0.0)?;
web_sys::console::log_1(&renderer.backend_label().into());
# Ok(())
# }

Migration Notes

Existing WebRenderer users do not need to change code if they require WebGPU directly.
Browser applications should prefer BrowserRenderer for production demos and websites because it handles WebGPU-to-WebGL fallback.
Canvas2D fallback remains application-level UI behavior; it is not exposed as a Scenix rendering backend.
Keep explicit feature flags for loader, renderer, post, Animato, and WASM paths.

Known Limitations

WebGL browser rendering is a compatibility preview path; it is not full wgpu feature parity.
WebGL does not implement real shadows, post-processing, GPU texture upload parity, or physically accurate PBR.
Loader APIs decode CPU assets but do not automatically upload them to either renderer.
GPU tests still depend on a working Vulkan backend or Mesa lavapipe.

Scenix v1.0.0 Stable

Scenix 1.0.0 is the first stable release of the modular Rust-native 3D scene workspace.

Highlights

Stable facade and crate versions: scenix = "1".
CPU authoring, raycasting, and helper geometry remain default facade features.
Loader, renderer, post-processing, Animato, and WASM support stay optional.
Renderer now uses camera view-projection matrices, world matrices, reusable uniform buffers, and cached material preview paths.
Built-in renderer material registration covers PBR, Physical, Unlit, Lambert, Toon, Wireframe, and Normal preview materials.
Static Leptos CSR website and demo deploy to GitHub Pages at /scenix/.
Animato bridge stays on animato = "1.4.0".

Install

[dependencies]
scenix = "1"

Optional full stack:

[dependencies]
scenix = { version = "1", features = ["loader", "renderer", "post", "animato", "wasm"] }

What Changed From 0.9.0

Bumped all workspace crates from 0.9.0 to 1.0.0.
Added a stable renderer frame path using camera/world uniforms instead of the previous clip-space smoke path.
Expanded renderer material registration to include advanced preview/debug material types.
Added the v1 website, docs folder, release notes, GitHub Pages workflow, coverage workflow step, and package checks.
Added the remaining architecture examples and registered them with the facade crate.
Expanded the WASM wrapper with demo controls, state getters, generated scene content, and clean browser fallback support.

Stable API Note

The v1 API is intended to be additive. Public APIs that become obsolete should be deprecated before removal.

Code Example

use std::collections::BTreeMap;
use scenix::{
    MaterialId, MeshId, NodeAnimationTarget, NodeAnimator, PbrMaterial, SceneGraph, SceneNode,
    ScenixAnimationDriver, Vec3, Vec3Track, box_geometry,
};

# fn run() -> Result<(), scenix::ValidationError> {
let mesh_id = MeshId::new(1);
let material_id = MaterialId::new(1);
let _cube = box_geometry(1.0, 1.0, 1.0, 1, 1, 1);

let mut scene = SceneGraph::new();
let cube_node = scene.add(SceneNode::mesh("cube", mesh_id, material_id));

let mut driver = ScenixAnimationDriver::new();
driver.add_node(NodeAnimator::new(
    cube_node,
    NodeAnimationTarget::Translation(Vec3Track::tween(Vec3::ZERO, Vec3::X, 0.5)),
));

let mut cameras = scenix::CameraStores {
    perspective: &mut BTreeMap::new(),
    orthographic: &mut BTreeMap::new(),
};
let mut materials = BTreeMap::from([(material_id, PbrMaterial::new())]);
let mut skeletons = Vec::new();

driver.tick(0.5, &mut scene, &mut cameras, &mut materials, &mut skeletons)?;
scene.update_world_transforms();
# Ok(())
# }

Migration Notes

Replace 0.9 dependency requirements with 1.
Keep explicit feature flags for loader/GPU/post/Animato/WASM paths.
Renderer users should register material variants through the matching stable register_*_material method.
Browser users can read demo state through the new WebRenderer getters instead of maintaining duplicate UI state.

Known Limitations

Advanced physical material fields render through a stable preview path in v1.
Loader APIs decode CPU assets but do not automatically upload them to the GPU.
The website demo avoids large external model assets and uses generated geometry.
GPU tests depend on a working Vulkan backend or Mesa lavapipe.

Assets 2

27 May 02:40

github-actions

v0.9.0

0d6b73f

scenix v0.9.0

Install

[dependencies]
scenix = { version = "0.9.0", features = ["loader", "renderer", "post", "animato", "wasm"] }

Highlights

New optional scenix-animato crate bridges Animato 1.4.0 tweens and springs into scenix scene nodes, cameras, PBR materials, and skeleton pose arrays.
New optional scenix-wasm crate wraps the renderer for browser canvases, forwards DOM input into scenix input state, and includes a generated cube scene path.
The facade keeps v0.8 CPU authoring defaults unchanged; enable integration explicitly with features = ["animato"] or features = ["wasm"].
WASM checks now compile the browser wrapper and standalone generated-scene example for wasm32-unknown-unknown.
Loader, renderer, post, raycaster, and helper APIs remain compatible with v0.8 behavior.

Crates published to crates.io

Crate	Version	Description
`scenix-math`	`0.9.0`	Custom no_std 3D math primitives
`scenix-core`	`0.9.0`	Shared IDs, colors, errors, and traits
`scenix-input`	`0.9.0`	Platform-agnostic input state types
`scenix-scene`	`0.9.0`	GPU-free scene graph and traversal APIs
`scenix-camera`	`0.9.0`	GPU-free cameras, frustums, and controllers
`scenix-mesh`	`0.9.0`	CPU-side geometry, primitive generation, instancing, and batching
`scenix-material`	`0.9.0`	GPU-free material descriptions and pipeline keys
`scenix-light`	`0.9.0`	GPU-free lights, shadow configuration, and light probes
`scenix-texture`	`0.9.0`	CPU-side texture data, samplers, atlases, and mipmaps
`scenix-loader`	`0.9.0`	CPU-side glTF, OBJ, STL, image, KTX2, HDR, and cache loaders
`scenix-post`	`0.9.0`	Optional wgpu post-processing stack and full-screen effects
`scenix-renderer`	`0.9.0`	Optional wgpu renderer, resource registries, targets, passes, and pipeline cache
`scenix-raycaster`	`0.9.0`	BVH scene picking and exact CPU mesh intersections
`scenix-helpers`	`0.9.0`	Debug line helpers for grids, axes, bounds, cameras, lights, and skeletons
`scenix-animato`	`0.9.0`	Optional Animato 1.4 bridge for nodes, cameras, materials, and skeleton poses
`scenix-wasm`	`0.9.0`	Optional browser canvas renderer wrapper and DOM input mapping helpers
`scenix`	`0.9.0`	Facade crate with default CPU authoring, raycaster/helper APIs, and optional loader/GPU/integration APIs

Animation + WASM example

use std::collections::BTreeMap;
use scenix::{
    CameraId, CameraStores, MaterialId, NodeAnimationTarget, NodeAnimator,
    PerspectiveCamera, PbrMaterial, ScalarTrack, SceneGraph, SceneNode,
    ScenixAnimationDriver, Vec3, Vec3Track,
};

# fn run() -> Result<(), scenix::ValidationError> {
let mut scene = SceneGraph::new();
let node = scene.add(SceneNode::new("animated"));

let camera_id = CameraId::new(1);
let mut perspective = BTreeMap::from([(
    camera_id,
    PerspectiveCamera::new(60.0, 1.0, 0.1, 100.0),
)]);
let mut orthographic = BTreeMap::new();
let material_id = MaterialId::new(1);
let mut materials = BTreeMap::from([(material_id, PbrMaterial::new())]);
let mut skeletons = Vec::new();

let mut driver = ScenixAnimationDriver::new();
driver.add_node(NodeAnimator::new(
    node,
    NodeAnimationTarget::Translation(Vec3Track::tween(
        Vec3::ZERO,
        Vec3::new(1.0, 0.0, 0.0),
        0.25,
    )),
));

let mut cameras = CameraStores {
    perspective: &mut perspective,
    orthographic: &mut orthographic,
};
driver.tick(0.25, &mut scene, &mut cameras, &mut materials, &mut skeletons)?;

# Ok(())
# }

// Browser:
// let renderer = scenix::WebRenderer::new(canvas).await?;
// renderer.tick(timestamp_ms)?;

Verification

cargo test --workspace --all-features
cargo test -p scenix-math -p scenix-core -p scenix-input -p scenix-scene -p scenix-camera -p scenix-mesh -p scenix-material -p scenix-light -p scenix-texture -p scenix-raycaster -p scenix-helpers --no-default-features
cargo test -p scenix-loader --all-features
cargo test -p scenix-raycaster -p scenix-helpers --all-features
cargo test -p scenix-animato --all-features
cargo check -p scenix-wasm --target wasm32-unknown-unknown --all-features
cargo check --manifest-path examples/wasm_viewer/Cargo.toml --target wasm32-unknown-unknown
SCENIX_RUN_GPU_TESTS=1 WGPU_BACKEND=vulkan cargo test -p scenix-renderer -p scenix-post --all-features
cargo clippy --workspace --all-features -- -D warnings
cargo fmt --check
cargo doc --workspace --all-features --no-deps
cargo publish --dry-run for every crate before publish

Assets 2

26 May 09:59

github-actions

v0.8.0

2751a5f

scenix v0.8.0

Install

[dependencies]
scenix = { version = "0.8.0", features = ["loader", "renderer", "post"] }

Highlights

New default scenix-raycaster crate for CPU-side scene picking with node-level SAH BVH traversal and exact mesh triangle intersections.
New default scenix-helpers crate for validated LineGeometry debug helpers: grids, axes, bounds, arrows, lights, cameras, and skeletons.
Raycaster::from_camera_ndc bridges camera screen rays into picking workflows without requiring renderer or GPU readback.
GeometryProvider lets applications keep mesh storage in their own maps or slices while still using BVH acceleration.
Loaders, renderer, and post-processing remain optional; WASM wrappers and animato integration remain deferred to later milestones.

Crates published to crates.io

Crate	Version	Description
`scenix-math`	`0.8.0`	Custom no_std 3D math primitives
`scenix-core`	`0.8.0`	Shared IDs, colors, errors, and traits
`scenix-input`	`0.8.0`	Platform-agnostic input state types
`scenix-scene`	`0.8.0`	GPU-free scene graph and traversal APIs
`scenix-camera`	`0.8.0`	GPU-free cameras, frustums, and controllers
`scenix-mesh`	`0.8.0`	CPU-side geometry, primitive generation, instancing, and batching
`scenix-material`	`0.8.0`	GPU-free material descriptions and pipeline keys
`scenix-light`	`0.8.0`	GPU-free lights, shadow configuration, and light probes
`scenix-texture`	`0.8.0`	CPU-side texture data, samplers, atlases, and mipmaps
`scenix-loader`	`0.8.0`	CPU-side glTF, OBJ, STL, image, KTX2, HDR, and cache loaders
`scenix-post`	`0.8.0`	Optional wgpu post-processing stack and full-screen effects
`scenix-renderer`	`0.8.0`	Optional wgpu renderer, resource registries, targets, passes, and pipeline cache
`scenix-raycaster`	`0.8.0`	BVH scene picking and exact CPU mesh intersections
`scenix-helpers`	`0.8.0`	Debug line helpers for grids, axes, bounds, cameras, lights, and skeletons
`scenix`	`0.8.0`	Facade crate with default CPU authoring, raycaster, helper APIs, and optional loader/GPU APIs

Raycasting + helpers example

use std::collections::BTreeMap;
use scenix::{
    AxesHelper, Geometry, GridHelper, LineGeometry, MaterialId, MeshId,
    PerspectiveCamera, Raycaster, SceneGraph, SceneNode, Vec2, Vec3,
    box_geometry,
};

# fn run() -> Result<(), scenix::ValidationError> {
let mesh_id = MeshId::new(1);
let material_id = MaterialId::new(1);
let mut meshes = BTreeMap::<MeshId, Geometry>::new();
meshes.insert(mesh_id, box_geometry(1.0, 1.0, 1.0, 1, 1, 1));

let mut scene = SceneGraph::new();
scene.add(SceneNode::mesh("cube", mesh_id, material_id));
scene.update_world_transforms();

let camera = PerspectiveCamera::new(60.0, 1.0, 0.1, 100.0)
    .position(Vec3::new(0.0, 0.0, 4.0))
    .target(Vec3::ZERO);
let ray = Raycaster::from_camera_ndc(&camera, Vec2::ZERO);

let mut raycaster = Raycaster::new();
raycaster.build_bvh(&scene, &meshes)?;
let hit = raycaster.cast_ray(ray, &scene, &meshes);

let mut helper_lines = LineGeometry::new();
helper_lines.merge(&GridHelper::new(10.0, 10).to_geometry());
helper_lines.merge(&AxesHelper::new(2.0).to_geometry());
helper_lines.validate()?;

assert!(hit.is_some());
# Ok(())
# }

Verification

cargo test --workspace --all-features
cargo test -p scenix-math -p scenix-core -p scenix-input -p scenix-scene -p scenix-camera -p scenix-mesh -p scenix-material -p scenix-light -p scenix-texture -p scenix-raycaster -p scenix-helpers --no-default-features
cargo test -p scenix-loader --all-features
cargo test -p scenix-raycaster -p scenix-helpers --all-features
SCENIX_RUN_GPU_TESTS=1 WGPU_BACKEND=vulkan cargo test -p scenix-renderer -p scenix-post --all-features
cargo clippy --workspace --all-features -- -D warnings
cargo fmt --check
cargo doc --workspace --all-features --no-deps
cargo publish --dry-run for every crate before publish

Assets 2

26 May 05:49

github-actions

v0.7.0

65f199a

scenix v0.7.0

Install

[dependencies]
scenix = { version = "0.7.0", features = ["loader", "renderer", "post"] }

Highlights

New optional scenix-loader crate for CPU-side glTF/GLB, OBJ/MTL, STL, PNG/JPEG/WebP, KTX2, HDR/EXR, and canonical path cache loading.
New optional scenix-post crate for a wgpu full-screen post stack with bloom, SSAO, tonemap, FXAA, TAA, SMAA, depth of field, fog, outline, and motion blur passes.
Renderer can now apply an optional post stack through Renderer::set_post_stack without changing the existing Renderer::render signature.
The facade crate still keeps CPU authoring features enabled by default; opt into loaders with features = ["loader"] and GPU post-processing with features = ["renderer", "post"].
Raycasting, debug helpers, WASM wrappers, and animato integration remain deferred to later milestones.

Crates published to crates.io

Crate	Version	Description
`scenix-math`	`0.7.0`	Custom no_std 3D math primitives
`scenix-core`	`0.7.0`	Shared IDs, colors, errors, and traits
`scenix-input`	`0.7.0`	Platform-agnostic input state types
`scenix-scene`	`0.7.0`	GPU-free scene graph and traversal APIs
`scenix-camera`	`0.7.0`	GPU-free cameras, frustums, and controllers
`scenix-mesh`	`0.7.0`	CPU-side geometry, primitive generation, instancing, and batching
`scenix-material`	`0.7.0`	GPU-free material descriptions and pipeline keys
`scenix-light`	`0.7.0`	GPU-free lights, shadow configuration, and light probes
`scenix-texture`	`0.7.0`	CPU-side texture data, samplers, atlases, and mipmaps
`scenix-loader`	`0.7.0`	CPU-side glTF, OBJ, STL, image, KTX2, HDR, and cache loaders
`scenix-post`	`0.7.0`	Optional wgpu post-processing stack and full-screen effects
`scenix-renderer`	`0.7.0`	Optional wgpu renderer, resource registries, targets, passes, and pipeline cache
`scenix`	`0.7.0`	Facade crate with optional loader, renderer, and post APIs

glTF + post-processing example

use scenix::{
    BloomConfig, FxaaConfig, GltfLoader, PerspectiveCamera, PostStack,
    Renderer, RendererConfig, ToneMapper, Vec3,
};

# async fn run() -> Result<(), scenix::ScenixError> {
let asset = GltfLoader::new().load_file("scene.gltf")?;
let mut renderer = Renderer::headless(RendererConfig::new(256, 256)).await?;
renderer.set_post_stack(Some(
    PostStack::new()
        .with_bloom(BloomConfig::default())
        .with_tonemap(ToneMapper::Aces)
        .with_fxaa(FxaaConfig::default()),
));

for (mesh_id, geometry) in &asset.meshes {
    renderer.register_mesh(*mesh_id, geometry)?;
}
for (material_id, material) in &asset.materials {
    renderer.register_pbr_material(*material_id, material)?;
}

let camera = PerspectiveCamera::new(60.0, 16.0 / 9.0, 0.1, 100.0)
    .position(Vec3::new(0.0, 0.0, 4.0))
    .target(Vec3::ZERO);
let stats = renderer.render(&asset.scene, &camera)?;

assert!(stats.visible_meshes > 0);
# Ok(())
# }

Verification

cargo test --workspace --all-features
cargo test -p scenix-math -p scenix-core -p scenix-input -p scenix-scene -p scenix-camera -p scenix-mesh -p scenix-material -p scenix-light -p scenix-texture --no-default-features
cargo test -p scenix-loader --all-features
SCENIX_RUN_GPU_TESTS=1 WGPU_BACKEND=vulkan cargo test -p scenix-renderer -p scenix-post --all-features
cargo clippy --workspace --all-features -- -D warnings
cargo fmt --check
cargo doc --workspace --all-features --no-deps
cargo publish --dry-run for every crate before publish

Assets 2

25 May 11:56

github-actions

v0.6.0

30f6c9f

scenix v0.6.0

Install

[dependencies]
scenix = { version = "0.6.0", features = ["renderer"] }

Highlights

New optional scenix-renderer crate powered by wgpu 29 with surface and headless render targets.
Renderer-owned mesh, material, texture, and light registration keeps SceneGraph renderer-agnostic while enabling real GPU frame submission.
Added RendererConfig, FrameContext, FrameStats, GpuScene, GpuMaterial, PipelineCache, GBuffer, ShadowMapAtlas, culling helpers, transparent sorting, and embedded WGSL shader entry points.
The facade crate remains CPU-only by default; opt into GPU APIs with features = ["renderer"].
Loader, image decoding, post-processing, WASM wrappers, and GLTF asset pipelines remain deferred to later milestones.

Crates published to crates.io

Crate	Version	Description
`scenix-math`	`0.6.0`	Custom no_std 3D math primitives
`scenix-core`	`0.6.0`	Shared IDs, colors, errors, and traits
`scenix-input`	`0.6.0`	Platform-agnostic input state types
`scenix-scene`	`0.6.0`	GPU-free scene graph and traversal APIs
`scenix-camera`	`0.6.0`	GPU-free cameras, frustums, and controllers
`scenix-mesh`	`0.6.0`	CPU-side geometry, primitive generation, instancing, and batching
`scenix-material`	`0.6.0`	GPU-free material descriptions and pipeline keys
`scenix-light`	`0.6.0`	GPU-free lights, shadow configuration, and light probes
`scenix-texture`	`0.6.0`	CPU-side texture data, samplers, atlases, and mipmaps
`scenix-renderer`	`0.6.0`	Optional wgpu renderer, resource registries, targets, passes, and pipeline cache
`scenix`	`0.6.0`	Facade crate with optional renderer APIs

Headless renderer example

use scenix::{
    Color, MaterialId, MeshId, PerspectiveCamera, PbrMaterial, Renderer,
    RendererConfig, SceneGraph, SceneNode, Vec3, box_geometry,
};

# async fn run() -> Result<(), scenix::ScenixError> {
let mut renderer = Renderer::headless(RendererConfig::new(256, 256)).await?;
let mesh_id = MeshId::new(1);
let material_id = MaterialId::new(1);

renderer.register_mesh(mesh_id, &box_geometry(1.0, 1.0, 1.0, 1, 1, 1))?;
renderer.register_pbr_material(
    material_id,
    &PbrMaterial::new().albedo(Color::from_rgb(0.8, 0.25, 0.15)),
)?;

let mut scene = SceneGraph::new();
scene.add(SceneNode::mesh("cube", mesh_id, material_id));
scene.update_world_transforms();

let camera = PerspectiveCamera::new(60.0, 16.0 / 9.0, 0.1, 100.0)
    .position(Vec3::new(0.0, 0.0, 4.0))
    .target(Vec3::ZERO);
let stats = renderer.render(&scene, &camera)?;

assert_eq!(stats.visible_meshes, 1);
# Ok(())
# }

Verification

cargo test --workspace --all-features
cargo test -p scenix-math -p scenix-core -p scenix-input -p scenix-scene -p scenix-camera -p scenix-mesh -p scenix-material -p scenix-light -p scenix-texture --no-default-features
SCENIX_RUN_GPU_TESTS=1 WGPU_BACKEND=vulkan cargo test -p scenix-renderer --all-features
cargo clippy --workspace --all-features -- -D warnings
cargo fmt --check
cargo doc --workspace --all-features --no-deps
cargo publish --dry-run for every crate before publish

Assets 2

23 May 05:03

github-actions

v0.5.0

0e32e31

scenix v0.5.0

Install

[dependencies]
scenix = "0.5.0"

Highlights

New scenix-texture crate with raw CPU texture containers, sampler metadata, deterministic atlas packing, video-frame updates, and RGBA8 mipmap generation.
New scenix-camera crate with perspective, orthographic, and cube cameras, WebGPU-depth frustum extraction, screen-to-ray helpers, and orbit/fly controllers.
The facade crate now enables the camera and texture features by default alongside scene, mesh, material, and light APIs.
Image file decoding and GPU upload remain deferred to the loader and renderer milestones, keeping v0.5.0 dependency-light and renderer-agnostic.

Crates published to crates.io

Crate	Version	Description
`scenix-math`	`0.5.0`	Custom no_std 3D math primitives
`scenix-core`	`0.5.0`	Shared IDs, colors, errors, and traits
`scenix-input`	`0.5.0`	Platform-agnostic input state types
`scenix-scene`	`0.5.0`	GPU-free scene graph and traversal APIs
`scenix-camera`	`0.5.0`	GPU-free cameras, frustums, and controllers
`scenix-mesh`	`0.5.0`	CPU-side geometry, primitive generation, instancing, and batching
`scenix-material`	`0.5.0`	GPU-free material descriptions and pipeline keys
`scenix-light`	`0.5.0`	GPU-free lights, shadow configuration, and light probes
`scenix-texture`	`0.5.0`	CPU-side texture data, samplers, atlases, and mipmaps
`scenix`	`0.5.0`	Facade crate for scenix Textures and Camera APIs

Textures and camera example

use scenix::{PerspectiveCamera, Texture2D, TextureFormat, Vec2, Vec3};

let texture = Texture2D::new(
    1,
    1,
    TextureFormat::Rgba8UnormSrgb,
    vec![255, 255, 255, 255],
)?;

let camera = PerspectiveCamera::new(60.0, 16.0 / 9.0, 0.1, 100.0)
    .position(Vec3::new(0.0, 0.0, 5.0))
    .target(Vec3::ZERO);
let ray = camera.screen_to_ray(Vec2::ZERO);

assert_eq!(texture.base_level_len()?, 4);
assert!(ray.direction.z < 0.0);
# Ok::<(), scenix::ValidationError>(())

Verification

cargo test --workspace --all-features
cargo test -p scenix-math -p scenix-core -p scenix-input -p scenix-scene -p scenix-camera -p scenix-mesh -p scenix-material -p scenix-light -p scenix-texture --no-default-features
cargo clippy --workspace --all-features -- -D warnings
cargo fmt --check
cargo doc --workspace --all-features --no-deps
cargo publish --dry-run for every crate before publish

Assets 2

20 May 10:03

github-actions

v0.4.0

c7b7e5c

scenix v0.4.0

Install

[dependencies]
scenix = "0.4.0"

Highlights

New scenix-material crate with the Material trait, compact PipelineKey, alpha modes, PBR, physical, toon, line, points, and custom WGSL shader materials.
New scenix-light crate with ambient, directional, point, spot, hemisphere, and area lights.
Validated ShadowConfig and texture-free LightProbe projection from raw cube-face or equirectangular linear RGB samples.
The facade crate now enables the material and light features by default alongside scene and mesh.

Crates published to crates.io

Crate	Version	Description
`scenix-math`	`0.4.0`	Custom no_std 3D math primitives
`scenix-core`	`0.4.0`	Shared IDs, colors, errors, and traits
`scenix-input`	`0.4.0`	Platform-agnostic input state types
`scenix-scene`	`0.4.0`	GPU-free scene graph and traversal APIs
`scenix-mesh`	`0.4.0`	CPU-side geometry, primitive generation, instancing, and batching
`scenix-material`	`0.4.0`	GPU-free material descriptions and pipeline keys
`scenix-light`	`0.4.0`	GPU-free lights, shadow configuration, and light probes
`scenix`	`0.4.0`	Facade crate for scenix Materials and Lights APIs

Materials and lights example

use scenix::{Color, DirectionalLight, Material, PbrMaterial, ShadowConfig, Vec3};

let material = PbrMaterial::new()
    .albedo(Color::from_hex(0xCC_88_44).to_linear())
    .metallic_roughness(0.0, 0.55);

let sun = DirectionalLight::new(Vec3::new(-1.0, -2.0, -1.0), Color::WHITE, 3.0)
    .shadow(ShadowConfig::default());

assert!(!material.is_transparent());
assert!(sun.shadow.unwrap().validate().is_ok());

Verification

cargo test --workspace --all-features
cargo test -p scenix-math -p scenix-core -p scenix-input -p scenix-scene -p scenix-mesh -p scenix-material -p scenix-light --no-default-features
cargo clippy --workspace --all-features -- -D warnings
cargo fmt --check
cargo doc --workspace --all-features --no-deps
cargo publish --dry-run for every crate before publish

Assets 2

Uh oh!

Releases: AarambhDevHub/scenix

scenix v1.3.0

Scenix v1.3.0 Asset Pipeline

Highlights

Install

Code Example

Supported Asset Matrix

Migration Notes

Animato 1.6.0 Gate

Known Limitations

Links

What's Changed

Contributors

Uh oh!

scenix v1.2.0

Scenix v1.2.0 Renderer And Material Parity

Highlights

Install

Code Example

Migration Notes

WebGPU And WebGL

Known Limitations

Links

Uh oh!

scenix v1.1.0

Scenix v1.1.0 Browser Fallback

Highlights

Install

What Changed From 1.0.0

Code Example

Migration Notes

Known Limitations

Links

Uh oh!

scenix v1.0.0

Scenix v1.0.0 Stable

Highlights

Install

What Changed From 0.9.0

Stable API Note

Links

Code Example

Migration Notes

Known Limitations

Uh oh!

scenix v0.9.0

scenix v0.9.0

Install

Highlights

Crates published to crates.io

Animation + WASM example

Verification

Uh oh!

scenix v0.8.0

scenix v0.8.0

Install

Highlights

Crates published to crates.io

Raycasting + helpers example

Verification

Uh oh!

scenix v0.7.0

scenix v0.7.0

Install

Highlights

Crates published to crates.io

glTF + post-processing example

Verification

Uh oh!

scenix v0.6.0

scenix v0.6.0

Install

Highlights

Crates published to crates.io

Headless renderer example

Verification

Uh oh!

scenix v0.5.0

scenix v0.5.0