pub use crate::cameras::Camera;
pub use crate::cameras::{OrthographicCamera, PerspectiveCamera};
pub use crate::core::{
BufferAttribute, BufferGeometry, Clock, InstancedMesh, Layers, LineSegments, Mesh, Object3D,
ObjectId, ObjectKind, Points, Raycaster, Sprite,
};
pub use crate::geometries::{
BoxGeometry, CapsuleGeometry, CircleGeometry, ConeGeometry, CylinderGeometry, ExtrudeGeometry,
IcosahedronGeometry, LatheGeometry, MeshBuilder, MeshReport, PlaneGeometry, QuadGeometry,
RingGeometry, SphereGeometry, TorusGeometry, TorusKnotGeometry, TubeGeometry,
};
pub use crate::lights::{
AmbientLight, DirectionalLight, HemisphereLight, Light, PointLight, RectAreaLight,
ShadowSettings, ShadowType, SpotLight,
};
pub use crate::materials::{
BasicMaterial, DepthMaterial, LambertMaterial, LineBasicMaterial, MatcapMaterial, Material,
MaterialKind, NormalMaterial, PhongMaterial, PhysicalMaterial, PointsMaterial, ShaderMaterial,
SpriteMaterial, StandardMaterial, ToonMaterial, TransparencyMode,
};
pub use crate::math::{Color, Euler, Matrix3, Matrix4, Quaternion, Vector2, Vector3, Vector4};
pub use crate::easing::Easing;
pub use crate::extras::SimplexNoise;
pub use crate::math::ToneMapping;
pub use crate::math::{
convex_hull, delaunay, inverse_lerp, lerp, map_range, map_range_clamped, smootherstep,
smoothstep, ticks, voronoi_cells, ColorRamp, RampSpace, Rng, ScaleLinear, ScaleLog, ScalePow,
};
pub use crate::math::{ColorScale, ColorSpace, Palette, ScaleKind};
pub use crate::overlay::Overlay;
#[cfg(feature = "render")]
pub use crate::renderer::{RenderTarget, Renderer};
pub use crate::scene::{FogParams, Scene};
pub use crate::textures::{
CubeTexture, DataTexture, Texture, TextureFilter, TextureFormat, TextureWrap,
};
#[cfg(all(feature = "render", not(target_arch = "wasm32")))]
pub use crate::renderer::headless::{HeadlessBuilder, HeadlessConfig, HeadlessRenderer};
cfg_apple! {
#[cfg(feature = "render")]
pub use crate::renderer::layer::{LayerGpu, LayerRenderer};
}
pub use crate::utils::png::{decode_png, encode_png, PngImage};
pub use crate::renderers::{svg_from_rgba, SvgOptions, SvgRenderer, SvgShading};
cfg_metal! {
pub use crate::metal::{
MetalDevice, MetalError, MetalHeadlessRenderer, MetalRenderTarget, MetalRenderer, RenderView,
};
}
#[cfg(all(feature = "visionos", target_os = "visionos"))]
pub use crate::metal::visionos::{ImmersiveRenderer, WorldTracking};
pub mod controls {
pub use crate::controls::{
ArcballControls, DragControls, FirstPersonControls, OrbitControls, PointerEvent,
PointerLockControls, TrackballControls,
};
}
pub mod animation {
pub use crate::animation::{
AnimationAction, AnimationClip, AnimationMixer, Interpolation, KeyframeTrack, TrackTarget,
};
}
pub mod loaders {
pub use crate::loaders::{
AlembicArchive, AlembicError, ColladaError, ColladaLoader, DracoError, ExrError, ExrLoader,
FbxError, FbxLoader, FbxScene, GcodeLoader, GcodeToolpath, GltfError, GltfImages,
GltfLoader, GltfScene, HdrError, HdrLoader, Ktx2, Ktx2Error, MeshoptError, ObjLoader, PlyLoader, PolyMesh, StlLoader,
TtfError, TtfFont, TtfGlyph,
};
pub use crate::loaders::{scene_to_glb, scene_to_gltf, GltfExportOptions};
}
pub mod helpers {
pub use crate::helpers::{
ArrowHelper, AxesHelper, BoxHelper, CameraHelper, DirectionalLightHelper, GridHelper,
HemisphereLightHelper, PointLightHelper, PolarGridHelper, SkeletonHelper, SpotLightHelper,
VertexNormalsHelper, VertexTangentsHelper,
};
}
pub mod lattice {
pub use crate::geometries::{
Conform, Cuboct, Field, Infill, Lattice, LatticeKind, LatticeMetrics, LatticeStyle, Region,
ScaleRich, ScaleRichAngles, ScaleRichLigament, ScaleRichNet, SeedLayout, SolidMaterial,
Stiffness, Stochastic, Strut, Tpms,
};
}
#[cfg(feature = "bvh-csg")]
pub mod csg {
pub use crate::csg::{
CsgBrush, CsgEvaluator, CsgNode, CsgOperation, CsgOperationGroup, TriangleIntersection,
ADDITION, DIFFERENCE, INTERSECTION, SUBTRACTION,
};
}
#[cfg(feature = "openscad")]
pub mod openscad {
pub use crate::openscad::scad::parse_scad;
pub use crate::openscad::{cone, cube, cylinder, sphere, Solid};
}
#[cfg(feature = "nurbs")]
pub mod nurbs {
pub use crate::geometries::NurbsGeometry;
pub use crate::nurbs::{NurbsCurve, NurbsSurface, TessellationOptions};
}
#[cfg(feature = "raytrace")]
pub mod raytrace {
pub use crate::raytrace::{
Aov, BackgroundMode, CpuBackend, RaytraceBackend, RaytraceError, RaytraceRenderer,
RaytraceScene, RaytraceSettings,
};
}
#[cfg(feature = "native-codec")]
pub mod video {
#[cfg(feature = "native-decode")]
pub use crate::codec::decode::{Backend, DecodedFrame, Decoder, NativeDecoder};
pub use crate::codec::hevc::Yuv420Frame;
pub use crate::codec::hw::{EncodeBackend, EncodeOptions, Mp4Encoder};
#[cfg(feature = "gif")]
pub use crate::codec::GifEncoder;
pub use crate::codec::{
encode_animation_rgba, encode_webm, h264, hevc, mp4, mp4_demux, AnimationEncodeOptions,
ApngEncoder, BrowserCodec,
};
}
cfg_metal! {
pub mod metal {
pub use crate::metal::enums::pixel_format;
pub use crate::metal::{
MetalBloom, MetalDevice, MetalError, MetalHeadlessBuilder, MetalHeadlessConfig,
MetalHeadlessRenderer, MetalJob, MetalJobError, MetalRenderPool, MetalRenderPoolConfig,
MetalRenderStats, MetalRenderTarget, MetalRenderer, MetalSsao, MetalSurface, MetalWorker,
MetalWorkerQos, PassAttachments, PostFxChain, RenderView, SsaoSettings, SurfaceFrame,
};
#[cfg(feature = "fluid")]
pub use crate::metal::{fluid_shader_source, MetalFluid};
#[cfg(all(feature = "visionos", target_os = "visionos"))]
pub use crate::metal::visionos::{ImmersiveRenderer, WorldTracking};
}
}
#[cfg(feature = "ui")]
pub mod ui {
#[cfg(feature = "render")]
pub use crate::renderer::UiPass;
pub use crate::ui::prelude::*;
pub use crate::ui::{paint_to_rgba, OverlayPainter};
}
#[cfg(feature = "xr")]
pub mod xr {
pub use crate::xr::{
App, Frame, Gpu, Handedness, HoverArea, HoverTarget, Panel, PanelInput, PanelPass,
PanelPlane, Pointer, TargetRayMode, XrEvent, XrEventKind, XrEye, XrInput, XrSource,
};
}
#[cfg(feature = "captions")]
pub mod captions {
pub use crate::captions::{
CaptionAlign, CaptionAnchor, CaptionError, CaptionFont, CaptionFormat, CaptionOverlay,
CaptionPainter, CaptionStyle, CaptionTrack, Cue,
};
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn a_scene_can_be_built_from_the_prelude_alone() {
let mut scene = Scene::new();
scene.background = Color::from_hex(0x101010);
let id = scene.add(Object3D::mesh(Mesh::new(
SphereGeometry::new(1.0, 16, 12),
Material::Standard(StandardMaterial::new(Color::WHITE).with_roughness(0.4)),
)));
scene.add_light(AmbientLight::new(Color::WHITE, 0.2));
scene.add(Object3D::light(DirectionalLight::new(Color::WHITE, 2.0)));
if let Some(object) = scene.get_mut(id) {
object.position = Vector3::new(0.0, 1.0, 0.0);
object.quaternion = Quaternion::from_axis_angle(Vector3::UP, 0.5);
object.scale = Vector3::ONE * 2.0;
}
scene.update_world();
let world = scene.get(id).unwrap().matrix_world;
assert_eq!(world.elements[13], 1.0);
}
#[test]
fn the_camera_trait_is_in_scope() {
let mut camera = PerspectiveCamera::new(50.0, 1.5, 0.1, 100.0);
camera.position = Vector3::new(0.0, 0.0, 5.0);
camera.look_at(Vector3::ZERO);
let view = camera.view_matrix();
assert_eq!(view.elements[14], -5.0);
let ortho = OrthographicCamera::new(-1.0, 1.0, 1.0, -1.0, 0.1, 10.0);
assert_eq!(ortho.near_far(), (0.1, 10.0));
}
#[test]
fn glass_shadows_and_colour_from_the_prelude_alone() {
let glass = PhysicalMaterial::new(Color::WHITE)
.with_transmission(1.0, 1.5, 0.5)
.with_transparency(TransparencyMode::Refract);
assert_eq!(glass.transparency, TransparencyMode::Refract);
let mut sun = DirectionalLight::new(Color::WHITE, 2.0);
sun.shadow.filter = Some(ShadowType::Pcss);
assert_eq!(sun.shadow.filter, Some(ShadowType::Pcss));
let (red, alpha) = Color::parse_css("oklch(62.8% 0.2577 29.23 / 0.5)").unwrap();
assert!(red.r > 0.9 && red.g < 0.05 && alpha == 0.5);
let scale = ColorScale::sequential(ColorRamp::viridis(), 0.0, 1.0).log(10.0);
let _ = scale.map(0.5);
let palette = Palette::from_hex(&[0xff0000, 0x00ff00]);
let _ = (palette, ScaleKind::Linear, ColorSpace::Oklch);
}
#[test]
fn geometry_and_texture_types_are_reachable() {
let mut geometry = BufferGeometry::new();
geometry.set_attribute(
"position",
BufferAttribute::new(vec![0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 1.0, 0.0], 3),
);
assert_eq!(geometry.draw_count(), 3);
let texture = Texture::new(1, 1, TextureFormat::Rgba8Unorm, vec![255, 0, 0, 255]);
assert_eq!(texture.mag_filter, TextureFilter::Linear);
assert_eq!(texture.wrap_s, TextureWrap::ClampToEdge);
}
#[test]
fn png_round_trips_through_the_prelude() {
let rgba = vec![255u8, 0, 0, 255, 0, 255, 0, 255];
let png = encode_png(2, 1, &rgba);
let image: PngImage = decode_png(&png).unwrap();
assert_eq!((image.width, image.height), (2, 1));
assert_eq!(image.rgba, rgba);
}
cfg_metal! {
#[test]
fn nested_metal_module_names_the_working_set() {
use super::metal::*;
let config = MetalRenderPoolConfig::for_this_device();
assert!(config.threads >= 1);
let _ = (pixel_format::BGRA8_UNORM_SRGB, MetalWorkerQos::UserInteractive);
let _ = std::mem::size_of::<(MetalSurface, MetalRenderPool, PassAttachments, PostFxChain)>();
}
}
#[cfg(feature = "ui")]
#[test]
fn nested_ui_module_builds_a_ui() {
use super::ui::*;
let mut ui = Ui::new();
let root = ui.root();
let card = ui.add_box(root, style! { padding: 8px; });
ui.token_style(card, &[("background", Token::Surface)]);
let mut g = gauge_styled(
&mut ui,
card,
"Load",
0.0..=1.0,
GaugeKind::Circular,
GaugeStyle {
tint: GaugeTint::levels(),
animate: false,
..Default::default()
},
);
g.set(&mut ui, 0.9);
ui.layout(200.0, 200.0, &mut FixedWidthText(7.0));
let rgba = paint_to_rgba(&ui, 1.0, 200, 200);
assert_eq!(rgba.len(), 200 * 200 * 4);
assert_eq!(ui.hover_regions().len(), 0, "a gauge is not pressed");
let _: Option<ArcShape> = ArcShape::from_svg("M50 10 A40 40 0 0 1 90 50");
}
#[cfg(feature = "xr")]
#[test]
fn nested_xr_module_places_a_panel() {
use super::xr::*;
let mut panel = Panel::new(1280.0, 800.0);
panel.place_facing(&Matrix4::translation(Vector3::new(0.0, 1.6, 0.0)).elements);
let plane: PanelPlane = panel.plane().unwrap();
assert!(plane.half.0 > 0.0);
let _ = (
HoverArea {
id: 1,
rect: [0.0; 4],
radius: 0.0,
},
TargetRayMode::Gaze,
XrEventKind::Select,
);
}
#[test]
fn nested_controls_module_exports_orbit() {
use super::controls::OrbitControls;
let _ = std::mem::size_of::<OrbitControls>();
}
}