mod bindings;
pub mod cube_render_target;
mod direct_render_pipeline;
mod info;
mod mipmap;
mod occlusion;
mod pass;
pub mod pmrem;
mod present;
mod programs;
mod reflector;
mod render_list;
mod render_pipeline;
mod render_target;
mod ssaa_pass;
use std::collections::{HashMap, HashSet};
use std::rc::{Rc, Weak};
use bindings::{
BindGroupKey, DrawKey, LayoutKey, Occurrences, Resource, SamplerKey, Serial, Serials, SlotKey,
SlotOwner, VERTEX_SLOTS,
};
pub use direct_render_pipeline::DirectRenderPipeline;
pub use info::{BuildCounts, ComputeCounts, Info, MemoryCounts, RenderCounts};
use mipmap::{create_mipmap_pipeline, MipmapShader};
pub use pass::{pass, CameraRef, PassNode, PassOptions, SceneRef, DEPTH_ATTACHMENT};
pub use pmrem::PmremGenerator;
pub(crate) use programs::RenderState;
use programs::{
ComputeProgramGpu, ExtraColorTarget, PipelineKey, Program, MAX_EXTRA_COLOR_ATTACHMENTS,
};
pub use programs::{LightState, UniformContext};
pub(crate) use render_list::{project_object, ProjectCamera, RenderItem, RenderList};
pub use render_pipeline::RenderPipeline;
pub use render_target::{RenderTarget, RenderTargetOptions, OUTPUT_ATTACHMENT};
pub use ssaa_pass::SsaaPassNode;
use crate::cameras::{OrthographicCamera, PerspectiveCamera, RenderCamera};
use crate::core::{BufferGeometry, Group, Index, Layers, Node};
use crate::error::Error;
use crate::geometries::{quad_geometry, sphere_geometry};
use crate::lights::{
LightKind, LightObject, LightShadow, ShadowFilter, ShadowFilterMap, ShadowMapType,
CUBE_DIRECTIONS, CUBE_UPS,
};
use crate::materials::phong::{LightDesc, ShadowMap};
use crate::materials::{self, MeshBasicNodeMaterial, MrtContext, SetupContext, Side, ToneMapping};
use crate::math::{Color, Matrix4, Vector2, Vector4};
use crate::nodes::builder::VertexBufferSource;
use crate::nodes::node::{BufferSource, TextureSource};
use crate::nodes::tsl::FogNode;
use crate::nodes::tsl::StorageArray;
use crate::nodes::wgsl::TextureKind;
use crate::nodes::{BindingDesc, ComputeFlow, NodeBuilder, NodeProgram, Type};
use crate::objects::{Background, InstancedBufferAttribute, QuadMesh, Scene, SceneFog, SubDraw};
use crate::testing::DeterministicRandom;
use crate::textures::{
CubeDepthTexture, CubeTexture, Data3DTexture, DataArrayTexture, DataTexture, DataTextureData,
DepthTexture, Texture, TextureFilter, TextureOwner, TextureType,
};
const CACHE_GRACE_FRAMES: u64 = 4;
pub const COMPRESSION_FEATURES: wgpu::Features = wgpu::Features::TEXTURE_COMPRESSION_BC
.union(wgpu::Features::TEXTURE_COMPRESSION_ETC2)
.union(wgpu::Features::TEXTURE_COMPRESSION_ASTC);
struct BufferEntry {
buffer: Serial<wgpu::Buffer>,
last_used: u64,
data: Option<Rc<Vec<f32>>>,
}
struct SlotBuffer {
buffer: Serial<wgpu::Buffer>,
usage: wgpu::BufferUsages,
last_used: u64,
}
struct ViewEntry {
texture: wgpu::Texture,
view: Serial<wgpu::TextureView>,
last_used: u64,
owner: TextureOwner,
}
struct BindGroupEntry {
group: wgpu::BindGroup,
last_used: u64,
}
struct GeometryEntry {
gpu: GeometryGpu,
owner: Weak<BufferGeometry>,
}
struct GeometryGpu {
position: Option<wgpu::Buffer>,
normal: Option<wgpu::Buffer>,
uv: Option<wgpu::Buffer>,
other: Vec<(String, wgpu::Buffer)>,
index: Option<(wgpu::Buffer, wgpu::IndexFormat, u32)>,
wireframe_index: Option<(wgpu::Buffer, wgpu::IndexFormat, u32)>,
vertex_count: u32,
versions: [u32; 3],
}
const UPLOADED_ATTRIBUTES: [&str; 3] = ["position", "normal", "uv"];
impl GeometryGpu {
fn draw_index(&self, wireframe: bool) -> Option<&(wgpu::Buffer, wgpu::IndexFormat, u32)> {
if wireframe {
self.wireframe_index.as_ref()
} else {
self.index.as_ref()
}
}
fn slot(&self, index: usize) -> Option<&wgpu::Buffer> {
match index {
0 => self.position.as_ref(),
1 => self.normal.as_ref(),
2 => self.uv.as_ref(),
other => panic!("three-rs: no uploaded attribute slot {other}"),
}
}
fn set_slot(&mut self, index: usize, buffer: wgpu::Buffer) {
match index {
0 => self.position = Some(buffer),
1 => self.normal = Some(buffer),
2 => self.uv = Some(buffer),
other => panic!("three-rs: no uploaded attribute slot {other}"),
}
}
fn attribute(&self, name: &str) -> &wgpu::Buffer {
let buffer = match UPLOADED_ATTRIBUTES
.iter()
.position(|candidate| *candidate == name)
{
Some(index) => self.slot(index),
None => self
.other
.iter()
.find(|(key, _)| key == name)
.map(|(_, buffer)| buffer),
};
buffer.unwrap_or_else(|| panic!("three-rs: the geometry has no {name} attribute"))
}
}
struct CanvasTarget {
width: u32,
height: u32,
sample_count: u32,
color: wgpu::Texture,
msaa: Option<wgpu::Texture>,
depth: Option<wgpu::Texture>,
}
#[derive(Clone, Copy)]
struct Primitive {
topology: wgpu::PrimitiveTopology,
strip_index_format: Option<wgpu::IndexFormat>,
wireframe: bool,
}
impl Primitive {
const TRIANGLES: Self = Self {
topology: wgpu::PrimitiveTopology::TriangleList,
strip_index_format: None,
wireframe: false,
};
fn of(object: &crate::core::Object3D, geometry: &BufferGeometry, wireframe: bool) -> Self {
let wireframe = wireframe && object.is_mesh();
let topology = if object.is_points() {
wgpu::PrimitiveTopology::PointList
} else if object.is_line_segments() || wireframe {
wgpu::PrimitiveTopology::LineList
} else if object.is_line() {
wgpu::PrimitiveTopology::LineStrip
} else {
wgpu::PrimitiveTopology::TriangleList
};
let strip_index_format = match &geometry.index {
Some(index) if object.is_line() && !object.is_line_segments() => Some(match index {
crate::core::Index::U16(_) => wgpu::IndexFormat::Uint16,
crate::core::Index::U32(_) => wgpu::IndexFormat::Uint32,
}),
_ => None,
};
Self {
topology,
strip_index_format,
wireframe,
}
}
}
#[derive(Clone)]
struct Renderable {
object: Option<Node>,
geometry: Rc<BufferGeometry>,
material: MeshBasicNodeMaterial,
key: MaterialKey,
setup: SetupContext,
fog: Option<FogNode>,
model_world: Matrix4,
instance_matrix: Option<InstancedBufferAttribute>,
instance_color: Option<InstancedBufferAttribute>,
instance_count: u32,
morph_influences: Vec<f64>,
morph_base: f64,
bind_matrix: Matrix4,
bind_matrix_inverse: Matrix4,
bone_matrices: Vec<f32>,
object_center: Vector2,
primitive: Primitive,
sub_draws: Vec<SubDraw>,
texture_overrides: Vec<(usize, Texture)>,
group: Option<Group>,
}
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
struct MaterialKey {
id: usize,
version: u32,
variant: u64,
}
impl MaterialKey {
fn of(material: &MeshBasicNodeMaterial) -> Self {
Self {
id: material.id.get(),
version: material.version,
variant: 0,
}
}
fn variant(self, variant: u64) -> Self {
Self { variant, ..self }
}
}
const VARIANT_SHADOW: u64 = 1;
const VARIANT_QUAD: u64 = 2;
const VARIANT_BACK_SIDE: u64 = 4;
const VARIANT_TOON_OUTLINE: u64 = 6;
const VARIANT_FRONT_SIDE: u64 = 5;
struct MaterialStates {
version: u32,
last_used: u64,
by_dynamic_key: HashMap<u64, Rc<NodeProgram>>,
}
struct Texture2DEntry {
gpu: wgpu::Texture,
version: u32,
needs_mipmap: bool,
owner: TextureOwner,
}
struct CubeTextureEntry {
gpu: wgpu::Texture,
owner: TextureOwner,
}
trait Counted {
fn count(build: &mut BuildCounts);
}
impl Counted for wgpu::Buffer {
fn count(build: &mut BuildCounts) {
build.buffers_created += 1;
}
}
impl Counted for wgpu::TextureView {
fn count(build: &mut BuildCounts) {
build.views_created += 1;
}
}
impl Counted for wgpu::Sampler {
fn count(build: &mut BuildCounts) {
build.samplers_created += 1;
}
}
struct Draw {
geometry_id: usize,
vertex_buffers: Vec<wgpu::Buffer>,
pipeline: PipelineKey,
bind_groups: Vec<wgpu::BindGroup>,
instance_count: u32,
sub_draws: Vec<SubDraw>,
first: u32,
elements: u32,
indirect: Option<wgpu::Buffer>,
object: Option<u32>,
occlusion_test: bool,
sub_cameras: Vec<SubCameraDraw>,
wireframe: bool,
}
struct SubCameraDraw {
viewport: [f32; 4],
camera_index: Option<(u32, wgpu::BindGroup)>,
}
struct PassTarget {
color: wgpu::TextureView,
extra_colors: Vec<(wgpu::TextureView, Option<wgpu::TextureView>)>,
extra_color_targets: Vec<ExtraColorTarget>,
resolve: Option<wgpu::TextureView>,
color_texture: Option<wgpu::Texture>,
depth: Option<wgpu::TextureView>,
color_format: wgpu::TextureFormat,
depth_format: Option<wgpu::TextureFormat>,
sample_count: u32,
width: u32,
height: u32,
viewport: Rect,
scissor: Option<Rect>,
}
#[derive(Clone, Copy, Debug, Default)]
struct ClearOps {
color: Option<[f64; 4]>,
depth: bool,
}
impl ClearOps {
fn all(color: [f64; 4]) -> Self {
Self {
color: Some(color),
depth: true,
}
}
}
struct VsmPasses {
vertical: RenderTarget,
horizontal: RenderTarget,
vertical_material: MeshBasicNodeMaterial,
horizontal_material: MeshBasicNodeMaterial,
}
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
struct Rect {
x: u32,
y: u32,
width: u32,
height: u32,
}
impl Rect {
fn of(rect: Vector4, pixel_ratio: f64, width: u32, height: u32) -> Self {
let x = (rect.x * pixel_ratio).floor().max(0.0) as u32;
let y = (rect.y * pixel_ratio).floor().max(0.0) as u32;
let w = (rect.z * pixel_ratio).floor().max(0.0) as u32;
let h = (rect.w * pixel_ratio).floor().max(0.0) as u32;
let x = x.min(width);
let y = y.min(height);
Self {
x,
y,
width: w.min(width - x),
height: h.min(height - y),
}
}
fn to_vector4(self) -> Vector4 {
Vector4::new(
self.x as f64,
self.y as f64,
self.width as f64,
self.height as f64,
)
}
fn full(width: u32, height: u32) -> Self {
Self {
x: 0,
y: 0,
width,
height,
}
}
}
pub struct Renderer {
device: wgpu::Device,
queue: wgpu::Queue,
adapter_info: wgpu::AdapterInfo,
adapter: wgpu::Adapter,
samples: u32,
pixel_ratio: f64,
width: f64,
height: f64,
clear_color: [f64; 4],
viewport: Vector4,
scissor: Vector4,
scissor_test: bool,
pub auto_clear: bool,
pub auto_clear_color: bool,
pub auto_clear_depth: bool,
pub opaque: bool,
pub transparent: bool,
pub lighting_enabled: bool,
pub(crate) toon_outline: Option<Rc<MeshBasicNodeMaterial>>,
pub(crate) camera_layers: Option<Layers>,
pub sort_objects: bool,
canvas: Option<CanvasTarget>,
render_target: Option<RenderTarget>,
mrt: Option<crate::nodes::MrtNode>,
frame_buffer_target: Option<RenderTarget>,
opaque_frame: Option<Texture>,
output_buffer_type: TextureType,
mipmap_shader: MipmapShader,
programs: HashMap<u64, Program>,
node_builder_states: HashMap<usize, MaterialStates>,
node_frame: crate::nodes::NodeFrameState,
call_depth: u32,
occlusion: occlusion::Occlusion,
occlusion_context: Option<occlusion::ContextKey>,
texture_overrides: Vec<(usize, Texture)>,
in_reflector: bool,
default_material: MeshBasicNodeMaterial,
background_material: MeshBasicNodeMaterial,
output_hook: Option<crate::materials::OutputContext>,
output_material: MeshBasicNodeMaterial,
pipelines: HashMap<PipelineKey, wgpu::RenderPipeline>,
geometries: HashMap<usize, GeometryEntry>,
textures_2d: HashMap<usize, Texture2DEntry>,
cube_textures: HashMap<usize, CubeTextureEntry>,
mipmap_pipelines: HashMap<wgpu::TextureFormat, wgpu::RenderPipeline>,
buffers: HashMap<usize, BufferEntry>,
storage_buffers: HashMap<usize, Serial<wgpu::Buffer>>,
slot_buffers: HashMap<SlotKey, SlotBuffer>,
views: HashMap<(usize, Option<wgpu::TextureViewDimension>, bool), Vec<ViewEntry>>,
samplers: HashMap<SamplerKey, Serial<wgpu::Sampler>>,
bind_group_cache: HashMap<BindGroupKey, BindGroupEntry>,
serials: Serials,
compute_programs: HashMap<u64, Rc<crate::nodes::ComputeProgram>>,
compute_pipelines: HashMap<u64, ComputeProgramGpu>,
background_geometry: Option<Rc<BufferGeometry>>,
quad_geometry: Option<Rc<BufferGeometry>>,
quad_camera: OrthographicCamera,
output_color_space: crate::math::ColorSpace,
neutral_output: bool,
fullscreen_pass: bool,
pub tone_mapping_exposure: f64,
present: Option<present::Present>,
random: DeterministicRandom,
pub tone_mapping: ToneMapping,
pub shadow_map_enabled: bool,
pub shadow_map_type: ShadowMapType,
pub shadow_map_transmitted: bool,
shadow_maps: HashMap<usize, ShadowMap>,
shadow_targets: HashMap<usize, RenderTarget>,
cube_shadow_targets: HashMap<usize, (CubeDepthTexture, wgpu::Texture)>,
vsm_passes: HashMap<usize, VsmPasses>,
float32_filterable: bool,
info: Info,
}
#[derive(Clone, Copy, Debug, Default)]
#[non_exhaustive]
pub struct RendererParameters {
pub antialias: bool,
}
#[cfg(not(target_arch = "wasm32"))]
pub const BACKENDS: wgpu::Backends = wgpu::Backends::VULKAN;
#[cfg(target_arch = "wasm32")]
pub const BACKENDS: wgpu::Backends = wgpu::Backends::BROWSER_WEBGPU;
#[cfg(target_arch = "wasm32")]
thread_local! {
static ADOPTED_DEVICE: std::cell::RefCell<
Option<(wgpu::Adapter, wgpu::Device, wgpu::Queue)>,
> = const { std::cell::RefCell::new(None) };
}
#[cfg(target_arch = "wasm32")]
pub fn adopt_device(adapter: wgpu::Adapter, device: wgpu::Device, queue: wgpu::Queue) {
ADOPTED_DEVICE.with(|slot| *slot.borrow_mut() = Some((adapter, device, queue)));
}
impl Renderer {
#[cfg(not(target_arch = "wasm32"))]
pub fn new(parameters: RendererParameters) -> Result<Self, Error> {
let instance = wgpu::Instance::new(wgpu::InstanceDescriptor {
backends: BACKENDS,
..wgpu::InstanceDescriptor::new_without_display_handle()
});
Self::with_instance(parameters, instance)
}
#[cfg(target_arch = "wasm32")]
pub fn new(parameters: RendererParameters) -> Result<Self, Error> {
let adopted = ADOPTED_DEVICE.with(|slot| slot.borrow().clone());
match adopted {
Some((adapter, device, queue)) => {
Ok(Self::with_device(parameters, adapter, device, queue))
}
None => Err(Error::NoAdoptedDevice),
}
}
#[cfg(not(target_arch = "wasm32"))]
pub fn with_instance(
parameters: RendererParameters,
instance: wgpu::Instance,
) -> Result<Self, Error> {
pollster::block_on(Self::with_instance_async(parameters, instance))
}
pub async fn with_instance_async(
parameters: RendererParameters,
instance: wgpu::Instance,
) -> Result<Self, Error> {
let adapter = pick_adapter(&instance).await?;
let wanted = wgpu::Features::FLOAT32_FILTERABLE | COMPRESSION_FEATURES;
let required_features = adapter.features() & wanted;
let (device, queue) = adapter
.request_device(&wgpu::DeviceDescriptor {
label: Some("three-rs device"),
required_features,
required_limits: wgpu::Limits::default(),
experimental_features: wgpu::ExperimentalFeatures::disabled(),
memory_hints: wgpu::MemoryHints::MemoryUsage,
trace: wgpu::Trace::Off,
})
.await?;
Ok(Self::with_device(parameters, adapter, device, queue))
}
pub fn with_device(
parameters: RendererParameters,
adapter: wgpu::Adapter,
device: wgpu::Device,
queue: wgpu::Queue,
) -> Self {
let adapter_info = adapter.get_info();
let float32_filterable = device
.features()
.contains(wgpu::Features::FLOAT32_FILTERABLE);
crate::nodes::builder::set_uniform_buffer_limit(
device.limits().max_uniform_buffer_binding_size as usize,
);
let mipmap_shader = MipmapShader::new(&device);
Self {
device,
queue,
adapter_info,
adapter,
samples: if parameters.antialias { 4 } else { 0 },
pixel_ratio: 1.0,
width: 300.0,
height: 150.0,
clear_color: [0.0, 0.0, 0.0, 0.0],
viewport: Vector4::new(0.0, 0.0, 300.0, 150.0),
scissor: Vector4::new(0.0, 0.0, 300.0, 150.0),
scissor_test: false,
auto_clear: true,
auto_clear_color: true,
auto_clear_depth: true,
opaque: true,
transparent: true,
lighting_enabled: true,
toon_outline: None,
camera_layers: None,
sort_objects: true,
canvas: None,
render_target: None,
mrt: None,
frame_buffer_target: None,
opaque_frame: None,
output_buffer_type: TextureType::HalfFloat,
mipmap_shader,
programs: HashMap::new(),
node_builder_states: HashMap::new(),
node_frame: crate::nodes::NodeFrameState::default(),
call_depth: 0,
occlusion: occlusion::Occlusion::default(),
occlusion_context: None,
texture_overrides: Vec::new(),
in_reflector: false,
default_material: MeshBasicNodeMaterial::new(),
output_hook: None,
background_material: {
let mut material = MeshBasicNodeMaterial::new();
material.name = "Background.material";
material.vertex_node = Some(materials::background_vertex_node());
material.side = Side::Back;
material.depth_test = false;
material.depth_write = false;
material
},
output_material: {
let mut material = MeshBasicNodeMaterial::new();
material.name = "outputColorTransform";
material
},
pipelines: HashMap::new(),
geometries: HashMap::new(),
textures_2d: HashMap::new(),
cube_textures: HashMap::new(),
mipmap_pipelines: HashMap::new(),
buffers: HashMap::new(),
storage_buffers: HashMap::new(),
slot_buffers: HashMap::new(),
views: HashMap::new(),
samplers: HashMap::new(),
bind_group_cache: HashMap::new(),
serials: Serials::default(),
compute_programs: HashMap::new(),
compute_pipelines: HashMap::new(),
background_geometry: None,
quad_geometry: None,
quad_camera: OrthographicCamera::new(-1.0, 1.0, 1.0, -1.0, 0.0, 1.0),
output_color_space: crate::math::ColorSpace::Srgb,
neutral_output: false,
tone_mapping_exposure: 1.0,
fullscreen_pass: false,
present: None,
random: DeterministicRandom::new(),
tone_mapping: ToneMapping::None,
shadow_map_enabled: false,
shadow_map_type: ShadowMapType::default(),
shadow_map_transmitted: false,
vsm_passes: HashMap::new(),
shadow_maps: HashMap::new(),
shadow_targets: HashMap::new(),
cube_shadow_targets: HashMap::new(),
float32_filterable,
info: Info::new(),
}
}
pub fn adapter_info(&self) -> &wgpu::AdapterInfo {
&self.adapter_info
}
pub fn get_max_anisotropy(&self) -> u16 {
16
}
pub fn features(&self) -> wgpu::Features {
self.device.features()
}
pub fn set_pixel_ratio(&mut self, pixel_ratio: f64) {
self.pixel_ratio = pixel_ratio;
self.canvas = None;
}
pub fn set_size(&mut self, width: f64, height: f64) {
self.width = width;
self.height = height;
self.viewport = Vector4::new(0.0, 0.0, width, height);
self.scissor = Vector4::new(0.0, 0.0, width, height);
self.canvas = None;
}
pub fn set_viewport(&mut self, x: f64, y: f64, width: f64, height: f64) {
self.viewport = Vector4::new(x, y, width, height);
}
pub fn viewport(&self) -> Vector4 {
self.viewport
}
pub fn set_scissor(&mut self, x: f64, y: f64, width: f64, height: f64) {
self.scissor = Vector4::new(x, y, width, height);
}
pub fn scissor(&self) -> Vector4 {
self.scissor
}
pub fn set_scissor_test(&mut self, scissor_test: bool) {
self.scissor_test = scissor_test;
}
pub fn scissor_test(&self) -> bool {
self.scissor_test
}
pub fn drawing_buffer_size(&self) -> (u32, u32) {
(
(self.width * self.pixel_ratio).floor() as u32,
(self.height * self.pixel_ratio).floor() as u32,
)
}
#[cfg(not(target_arch = "wasm32"))]
#[doc(hidden)]
pub fn rebuilt_on(&self, instance: wgpu::Instance) -> Result<Self, Error> {
let mut renderer = Self::with_instance(
RendererParameters {
antialias: self.samples > 0,
},
instance,
)?;
renderer.shadow_map_enabled = self.shadow_map_enabled;
renderer.shadow_map_type = self.shadow_map_type;
renderer.shadow_map_transmitted = self.shadow_map_transmitted;
renderer.tone_mapping = self.tone_mapping;
renderer.tone_mapping_exposure = self.tone_mapping_exposure;
renderer.random = self.random.clone();
Ok(renderer)
}
#[doc(hidden)]
pub fn skip_random_draws(&mut self, n: usize) {
self.random.skip(n);
}
pub fn set_render_target(&mut self, render_target: Option<RenderTarget>) {
self.render_target = render_target;
}
pub fn set_mrt(&mut self, mrt: Option<crate::nodes::MrtNode>) {
self.mrt = mrt;
}
pub fn mrt(&self) -> Option<crate::nodes::MrtNode> {
self.mrt.clone()
}
pub fn set_clear_color(&mut self, color: Color, alpha: f64) {
self.clear_color = [color.r, color.g, color.b, alpha];
}
pub fn clear_color(&self) -> Color {
Color::new(
self.clear_color[0],
self.clear_color[1],
self.clear_color[2],
)
}
pub fn clear_alpha(&self) -> f64 {
self.clear_color[3]
}
pub fn clear(&mut self, color: bool, depth: bool) {
let use_frame_buffer_target =
self.needs_frame_buffer_target() && self.render_target.is_none();
let target = if use_frame_buffer_target {
Some(self.frame_buffer_target())
} else {
self.render_target.clone()
};
let mut pass_target = match &target {
Some(render_target) => self.render_target_pass(render_target),
None => self.canvas_pass(true),
};
pass_target.viewport = Rect::full(pass_target.width, pass_target.height);
pass_target.scissor = None;
let clear = ClearOps {
color: color.then_some(self.clear_color),
depth,
};
self.draw(&[], UniformContext::default(), &pass_target, clear);
if use_frame_buffer_target {
self.render_output(
target
.as_ref()
.expect("three-rs: the frame buffer target is there in this branch"),
);
}
}
pub fn clear_depth(&mut self) {
self.clear(false, true);
}
pub fn render(&mut self, scene: &mut Scene, camera: &mut dyn RenderCamera) {
if self.info.auto_reset && self.call_depth == 0 {
self.info.reset();
}
let render = self.begin_frame();
let previous_fullscreen_pass = std::mem::replace(&mut self.fullscreen_pass, false);
self.poll_occlusion();
scene.update_matrix_world();
camera.update_matrix_world();
self.render_scene(scene, camera);
self.fullscreen_pass = previous_fullscreen_pass;
self.end_frame(render);
}
pub(crate) fn render_shared(
&mut self,
scene: &Scene,
camera: &std::cell::RefCell<dyn RenderCamera>,
) {
if self.info.auto_reset && self.call_depth == 0 {
self.info.reset();
}
let render = self.begin_frame();
let previous_fullscreen_pass = std::mem::replace(&mut self.fullscreen_pass, false);
self.poll_occlusion();
scene.update_matrix_world();
if let Ok(mut camera) = camera.try_borrow_mut() {
camera.update_matrix_world();
}
self.render_scene(scene, &*camera.borrow());
self.fullscreen_pass = previous_fullscreen_pass;
self.end_frame(render);
}
pub(crate) fn render_nested(&mut self, scene: &Scene, camera: &mut dyn RenderCamera) {
if self.info.auto_reset && self.call_depth == 0 {
self.info.reset();
}
let render = self.begin_frame();
let previous_fullscreen_pass = std::mem::replace(&mut self.fullscreen_pass, false);
self.poll_occlusion();
scene.update_matrix_world();
camera.update_matrix_world();
self.render_scene(scene, camera);
self.fullscreen_pass = previous_fullscreen_pass;
self.end_frame(render);
}
fn poll_occlusion(&mut self) {
if self.occlusion.has_pending() {
let _ = self.device.poll(wgpu::PollType::Poll);
self.occlusion.collect();
}
}
fn render_scene(&mut self, scene: &Scene, camera: &dyn RenderCamera) {
let output_context = self
.output_hook
.clone()
.filter(|_| self.render_target.is_none());
let mut render_list = self.project_scene(scene, camera);
let mut items = Vec::with_capacity(render_list.len() + 1);
let mrt_context = match (&self.render_target, &self.mrt) {
(Some(render_target), Some(node)) => Some(MrtContext {
node: node.clone(),
attachments: render_target.attachment_names(),
}),
_ => None,
};
let background = match scene.background.clone() {
Some(Background::CubeTexture(background)) => Some((
materials::background_color_node(&background),
hash_of(&("cube", background.id())),
)),
Some(Background::Node(node)) => Some((
hash_of(&("node", node.key())),
materials::background_node_color_node(node),
))
.map(|(variant, color_node)| (color_node, variant)),
Some(Background::Pmrem(pmrem)) => {
let variant = hash_of(&("pmrem", pmrem.texture.id()));
Some((materials::background_pmrem_color_node(&pmrem), variant))
}
Some(Background::EnvironmentNode(node)) => {
let variant = hash_of(&("environment node", &node));
Some((materials::background_environment_color_node(&node), variant))
}
_ => None,
};
if let Some((color_node, variant)) = background.filter(|_| self.opaque) {
let key = MaterialKey::of(&self.background_material).variant(variant);
let mut material = self.background_material.clone();
material.color_node = Some(color_node);
items.push(Renderable {
object: None,
geometry: self.background_geometry(),
material,
key,
setup: SetupContext {
output: output_context.clone(),
mrt: mrt_context.clone(),
..SetupContext::default()
},
fog: None,
model_world: Matrix4::identity(),
instance_matrix: None,
instance_color: None,
instance_count: 1,
morph_influences: Vec::new(),
morph_base: 1.0,
bind_matrix: Matrix4::identity(),
bind_matrix_inverse: Matrix4::identity(),
object_center: Vector2::new(0.5, 0.5),
bone_matrices: Vec::new(),
primitive: Primitive::TRIANGLES,
sub_draws: Vec::new(),
texture_overrides: Vec::new(),
group: None,
});
}
if !self.lighting_enabled {
render_list.lights.clear();
}
render_list.lights.sort_by_key(|node| node.borrow().id);
self.render_shadows(scene, &render_list, camera);
let light_descs: Vec<(LightKind, bool)> = render_list
.lights
.iter()
.map(|node| {
let object = node.borrow();
let light = object
.light()
.expect("three-rs: the light list only holds lights");
(light.kind, object.cast_shadow && light.shadow.is_some())
})
.collect();
let fog_node = scene
.fog_node
.clone()
.or_else(|| scene.fog.as_ref().map(SceneFog::node));
let (fog_color, fog_near, fog_far, fog_density) = match &scene.fog {
Some(SceneFog::Linear(fog)) => (fog.color, fog.near, fog.far, 0.00025),
Some(SceneFog::Exp2(fog)) => (fog.color, 1.0, 1000.0, fog.density),
None => (Color::new(1.0, 1.0, 1.0), 1.0, 1000.0, 0.00025),
};
let batch_camera = crate::objects::BatchCamera {
projection_matrix: camera.projection_matrix(),
matrix_world_inverse: camera.matrix_world_inverse(),
matrix_world: camera.matrix_world(),
coordinate_system: camera.coordinate_system(),
far: camera.far(),
};
let viewport = self.viewport();
for item in render_list.items() {
let matrix_world = item.matrix_world;
let mut object = item.node.borrow_mut();
if let Some(batched) = object.payload.batched_mesh_mut() {
batched.on_before_render(&matrix_world, &batch_camera);
}
if let Some(segments) = object
.payload
.mesh_mut()
.and_then(|mesh| mesh.line_segments.as_mut())
{
segments.resolution = crate::math::Vector2::new(viewport.z, viewport.w);
}
}
let transmits = render_list.items().any(|item| {
let object = item.node.borrow();
scene
.override_material
.as_ref()
.or(item.material(&object))
.is_some_and(|material| material.transmission > 0.0)
});
let opaque_frame = transmits.then(|| {
let (width, height) = self.drawing_buffer_size();
materials::transmission::OpaqueFrame {
texture: self.opaque_frame_texture(width, height),
}
});
let mut draws: Vec<(&RenderItem, Option<Side>)> = Vec::new();
if self.opaque {
draws.extend(render_list.opaque.iter().map(|item| (item, None)));
}
if self.transparent {
for item in &render_list.transparent {
let object = item.node.borrow();
let material = scene
.override_material
.as_ref()
.or(item.material(&object))
.unwrap_or(&self.default_material);
let split = material.transparent
&& material.side == Side::Double
&& !material.force_single_pass;
drop(object);
if split {
draws.push((item, Some(Side::Back)));
draws.push((item, Some(Side::Front)));
} else {
draws.push((item, None));
}
}
}
for (item, side) in draws {
let object = item.node.borrow();
let geometry = object
.geometry()
.expect("three-rs: the render list only holds drawables")
.clone();
let material: &MeshBasicNodeMaterial = scene
.override_material
.as_ref()
.or(item.material(&object))
.unwrap_or(&self.default_material);
let primitive = Primitive::of(&object, &geometry, material.wireframe);
let morph = crate::nodes::morph::get_entry(&geometry);
let morph_influences = object.payload.morph_target_influences().to_vec();
let morph_base = if morph.is_some() && !geometry.morph_targets_relative {
1.0 - morph_influences.iter().sum::<f64>()
} else {
1.0
};
let instance_count = geometry
.instance_count
.map_or_else(|| object.instance_count(), |count| count as u32);
let instance_matrix = object.instance_matrix().cloned();
let instance_color = object.instance_color().cloned();
let skeleton = object
.payload
.skinned_mesh()
.and_then(|mesh| mesh.skeleton.clone());
if let Some(skeleton) = &skeleton {
update_skeleton(&mut self.node_frame, skeleton);
}
let skin = object.payload.skinned_mesh().and_then(|mesh| {
let skeleton = skeleton.as_ref()?;
let skeleton = skeleton.borrow();
Some((
crate::nodes::skinning::SkinEntry {
bones: skeleton.bones.len(),
},
mesh.bind_matrix,
mesh.bind_matrix_inverse,
skeleton.bone_matrices.clone(),
))
});
let (batch, sub_draws) = match object.payload.batched_mesh() {
Some(batched) => (Some(batched.batch_entry()), batched.sub_draws()),
None => (None, Vec::new()),
};
let scene_environment = match material.pmrem_env {
Some(_) => None,
None => scene
.environment_node
.clone()
.map(materials::environment::Environment::Node)
.or_else(|| {
scene
.environment
.clone()
.map(materials::environment::Environment::Pmrem)
}),
};
let side_variant = match side {
Some(Side::Back) => VARIANT_BACK_SIDE,
Some(Side::Front) => VARIANT_FRONT_SIDE,
_ => 0,
};
let key = MaterialKey::of(material).variant(side_variant);
let mut material = material.clone();
if let Some(side) = side {
material.side = side;
}
let item_opaque_frame = (material.transmission > 0.0)
.then(|| opaque_frame.clone())
.flatten();
let renderable = Renderable {
object: Some(item.node.clone()),
geometry: geometry.clone(),
material: material.clone(),
key,
setup: SetupContext {
array_cameras: camera.sub_cameras().len(),
environment: scene_environment,
lighting_disabled: !self.lighting_enabled,
viewport_opaque_mip: item_opaque_frame,
instance_count: instance_matrix.as_ref().map(|a| a.count()),
instanced: instance_matrix.is_some(),
instance_color: instance_color.as_ref().map(|a| a.count()),
lights: light_descs
.iter()
.enumerate()
.map(|(index, (kind, casts))| LightDesc {
index,
kind: *kind,
shadow_map: (*casts
&& object.receive_shadow
&& self.shadow_map_enabled)
.then(|| self.shadow_maps.get(&index).cloned())
.flatten(),
})
.collect(),
morph: morph.clone(),
skin: skin.as_ref().map(|s| s.0),
batch: batch.clone(),
line_segments: object.payload.line_segments().cloned(),
sprite: object.payload.is_sprite(),
mrt: mrt_context.clone(),
output: output_context.clone(),
vertex_color_size: geometry
.get_attribute("color")
.map(|attribute| attribute.item_size)
.unwrap_or(0),
geometry_missing_normal: !geometry.has_attribute("normal"),
has_tangent_attribute: geometry.has_attribute("tangent"),
instanced_attributes: geometry
.attributes()
.filter(|(_, attribute)| attribute.is_instanced())
.map(|(name, _)| name.to_string())
.collect(),
},
fog: fog_node.clone(),
model_world: item.matrix_world,
instance_matrix,
instance_color,
instance_count,
morph_influences,
morph_base,
bind_matrix: skin.as_ref().map(|s| s.1).unwrap_or_else(Matrix4::identity),
bind_matrix_inverse: skin.as_ref().map(|s| s.2).unwrap_or_else(Matrix4::identity),
object_center: object
.payload
.sprite()
.map_or(Vector2::new(0.5, 0.5), |sprite| sprite.center),
bone_matrices: skin.map(|s| s.3).unwrap_or_default(),
primitive,
sub_draws,
texture_overrides: Vec::new(),
group: item.group,
};
if let Some(outline) = self
.toon_outline
.as_ref()
.filter(|_| renderable.material.kind == materials::MaterialKind::Toon)
{
items.push(Renderable {
material: (**outline).clone(),
key: key.variant(hash_of(&(VARIANT_TOON_OUTLINE, outline.id.get()))),
..renderable.clone()
});
}
items.push(renderable);
}
if crate::nodes::reflector_node::any() {
self.call_depth += 1;
self.update_reflectors(scene, camera, &mut items);
self.call_depth -= 1;
}
let (clear_color, force_clear) = match &scene.background {
Some(Background::Color(Color { r, g, b })) => ([*r, *g, *b, 1.0], true),
_ => (self.clear_color, false),
};
let mut clear = if self.auto_clear || force_clear {
ClearOps {
color: self.auto_clear_color.then_some(clear_color),
depth: self.auto_clear_depth,
}
} else {
ClearOps::default()
};
if let Some(target) = &self.render_target {
if target.depth_buffer() && !target.depth_initialized() {
if !self.auto_clear || !self.auto_clear_depth {
clear.depth = true;
}
target.set_depth_initialized(true);
}
}
let lights: Vec<LightState> = render_list
.lights
.iter()
.map(|node| {
let object = node.borrow();
let light = object
.light()
.expect("three-rs: the light list only holds lights");
let mut view_position = LightObject::world_position(&object.matrix_world);
view_position.apply_matrix4(&camera.matrix_world_inverse());
let shadow = light.shadow.as_deref();
LightState {
color: light.color_intensity(),
view_position,
distance: light.distance,
decay: light.decay,
world_position: LightObject::world_position(&object.matrix_world),
target_position: light.target_world_position(),
ground_color: light.ground_color_intensity(),
cone_cos: light.cone_cos(),
penumbra_cos: light.penumbra_cos(),
shadow_matrix: shadow.map_or_else(Matrix4::identity, |s| s.matrix),
shadow_camera_near: shadow.map_or(0.5, |s| s.camera.near()),
shadow_camera_far: shadow.map_or(500.0, |s| s.camera.far()),
shadow_bias: shadow.map_or(0.0, |s| s.bias),
shadow_normal_bias: shadow.map_or(0.0, |s| s.normal_bias),
shadow_radius: shadow.map_or(1.0, |s| s.radius),
shadow_blur_samples: shadow.map_or(8.0, |s| s.blur_samples as f64),
shadow_map_size: shadow.map_or(Vector2::new(512.0, 512.0), |s| s.map_size),
shadow_intensity: shadow.map_or(1.0, |s| s.intensity),
}
})
.collect();
let sub_cameras = camera.sub_cameras();
let camera_view_matrices: Vec<f32> = sub_cameras
.iter()
.flat_map(|c| c.matrix_world_inverse.to_f32_array())
.collect();
let camera_projection_matrices: Vec<f32> = sub_cameras
.iter()
.flat_map(|c| c.projection_matrix.to_f32_array())
.collect();
let camera_viewports: Vec<Vector4> = sub_cameras
.iter()
.map(|c| c.viewport.unwrap_or(Vector4::new(0.0, 0.0, 0.0, 0.0)))
.collect();
let camera_uniforms = UniformContext {
camera_projection: camera.projection_matrix(),
camera_projection_inverse: camera.projection_matrix_inverse(),
camera_view: camera.matrix_world_inverse(),
camera_world: camera.matrix_world(),
camera_view_matrices: &camera_view_matrices,
camera_projection_matrices: &camera_projection_matrices,
camera_viewports: &camera_viewports,
time: self.node_frame.time,
delta_time: self.node_frame.delta_time,
frame_id: self.node_frame.frame_id as u32,
lights: &lights,
background_blurriness: scene.background_blurriness,
fog_color,
fog_near,
fog_far,
fog_density,
..Default::default()
};
self.occlusion_context = occlusion::supported(self.adapter_info.backend).then(|| {
(
scene.node.borrow().id,
self.render_target
.as_ref()
.map(|target| target.texture().id()),
)
});
self.render_list(&items, camera_uniforms, clear);
self.occlusion_context = None;
}
fn render_shadows(
&mut self,
scene: &Scene,
render_list: &RenderList,
camera: &dyn RenderCamera,
) {
if !self.shadow_map_enabled {
return;
}
let shadow_type = self.shadow_map_type.resolved();
for (index, node) in render_list.lights.iter().enumerate() {
let custom_shadow_node = {
let object = node.borrow();
object
.cast_shadow
.then(|| {
object
.light()
.and_then(|l| l.shadow.as_ref())
.and_then(|s| s.shadow_node.clone())
})
.flatten()
};
if let Some(shadow_node) = custom_shadow_node {
self.shadow_maps.insert(index, ShadowMap::Node(shadow_node));
continue;
}
let is_point = {
let object = node.borrow();
object.cast_shadow
&& object
.light()
.is_some_and(|l| l.kind == LightKind::Point && l.shadow.is_some())
};
if is_point {
self.render_point_shadow(index, node, scene, camera);
continue;
}
let prepared = {
let mut object = node.borrow_mut();
if !object.cast_shadow {
None
} else {
let light_position = LightObject::world_position(&object.matrix_world);
let light = object
.light_mut()
.expect("three-rs: the light list only holds lights");
let (kind, angle, distance) = (light.kind, light.angle, light.distance);
let target_position = light.target_world_position();
light.shadow.as_mut().map(|shadow| {
if kind == LightKind::Spot {
shadow.update_spot_projection(angle, distance);
}
shadow.camera.update_projection_matrix();
shadow.update_matrices(light_position, target_position);
(
shadow.map_size,
shadow.camera.projection_matrix(),
shadow.camera.matrix_world_inverse(),
shadow.camera.matrix_world(),
shadow.clone(),
)
})
}
};
let Some((map_size, projection, view, world, shadow)) = prepared else {
continue;
};
let vsm = shadow_type == ShadowMapType::Vsm;
let (width, height) = (map_size.x as u32, map_size.y as u32);
let target = self
.shadow_targets
.entry(index)
.or_insert_with(|| {
let target = RenderTarget::new_with_options(
width,
height,
RenderTargetOptions {
texture_type: TextureType::UnsignedByte,
samples: 0,
depth_buffer: true,
min_filter: TextureFilter::Linear,
mag_filter: TextureFilter::Linear,
},
)
.expect("three-rs: the shadow target is an UnsignedByte colour type");
let depth = DepthTexture::new();
depth.set_filters(TextureFilter::Linear, TextureFilter::Linear);
target.set_depth_texture(depth);
target
})
.clone();
target.set_size(width, height);
let depth_filter = if shadow_type == ShadowMapType::Pcf {
TextureFilter::Linear
} else {
TextureFilter::Nearest
};
target
.depth_texture()
.expect("three-rs: the shadow target has a depth texture")
.set_filters(depth_filter, depth_filter);
let mut shadow_list = RenderList::new();
project_object(
&scene.node,
&ProjectCamera::from_parts(
camera.layers(),
&projection,
&view,
camera.coordinate_system(),
),
0.0,
&mut shadow_list,
self.sort_objects,
);
shadow_list.sort();
let mut items = Vec::with_capacity(shadow_list.len());
for item in shadow_list.items() {
let object = item.node.borrow();
if !(object.cast_shadow || (vsm && object.receive_shadow)) {
continue;
}
let geometry = object
.geometry()
.expect("three-rs: the render list only holds drawables")
.clone();
let source = item.material(&object).unwrap_or(&self.default_material);
let primitive = Primitive::of(&object, &geometry, false);
let instance_matrix = object.instance_matrix().cloned();
let instance_color = object.instance_color().cloned();
let instance_count = object.instance_count();
items.push(Renderable {
object: Some(item.node.clone()),
geometry: geometry.clone(),
material: materials::shadow_material_for(source, shadow_type),
key: MaterialKey::of(source).variant(VARIANT_SHADOW),
setup: SetupContext {
array_cameras: 0,
environment: None,
lighting_disabled: false,
viewport_opaque_mip: None,
instance_count: instance_matrix.as_ref().map(|_| instance_count as usize),
instanced: instance_matrix.is_some(),
instance_color: instance_color.as_ref().map(|a| a.count()),
output: None,
lights: Vec::new(),
morph: None,
skin: None,
batch: None,
line_segments: None,
sprite: false,
mrt: None,
vertex_color_size: 0,
geometry_missing_normal: false,
has_tangent_attribute: false,
instanced_attributes: Vec::new(),
},
fog: None,
model_world: item.matrix_world,
instance_matrix,
instance_color,
instance_count,
morph_influences: Vec::new(),
morph_base: 1.0,
bind_matrix: Matrix4::identity(),
bind_matrix_inverse: Matrix4::identity(),
object_center: Vector2::new(0.5, 0.5),
bone_matrices: Vec::new(),
primitive,
sub_draws: Vec::new(),
texture_overrides: Vec::new(),
group: item.group,
});
}
let uniforms = UniformContext {
camera_projection: projection,
camera_projection_inverse: {
let mut inverse = projection;
inverse.invert();
inverse
},
camera_view: view,
camera_world: world,
time: self.node_frame.time,
delta_time: self.node_frame.delta_time,
frame_id: self.node_frame.frame_id as u32,
..Default::default()
};
let pass_target = self.render_target_pass(&target);
self.draw(
&items,
uniforms,
&pass_target,
ClearOps::all([0.0, 0.0, 0.0, 0.0]),
);
let depth = target
.depth_texture()
.expect("three-rs: the shadow target has a depth texture");
let filter = ShadowFilter::of(shadow_type, shadow.filter_node.as_ref());
let shadow_map = if vsm {
let moments = self.render_vsm_passes(index, &depth, &shadow);
ShadowMap::Filtered {
map: ShadowFilterMap::Moments(moments),
filter,
}
} else if matches!(filter, ShadowFilter::Pcf) {
ShadowMap::Planar(depth)
} else {
ShadowMap::Filtered {
map: ShadowFilterMap::Depth(depth),
filter,
}
};
let shadow_map = if self.shadow_map_transmitted {
ShadowMap::Transmitted {
map: Box::new(shadow_map),
color: target.texture(),
}
} else {
shadow_map
};
self.shadow_maps.insert(index, shadow_map);
}
}
fn render_vsm_passes(
&mut self,
index: usize,
depth: &DepthTexture,
shadow: &LightShadow,
) -> Texture {
let (width, height) = (shadow.map_size.x as u32, shadow.map_size.y as u32);
let passes = self.vsm_passes.entry(index).or_insert_with(|| {
let target = || {
let target = RenderTarget::new_with_options(
width,
height,
RenderTargetOptions {
texture_type: TextureType::HalfFloat,
samples: 0,
depth_buffer: false,
min_filter: TextureFilter::Linear,
mag_filter: TextureFilter::Linear,
},
)
.expect("three-rs: HalfFloat is a colour type");
target.set_rg_format();
target
};
let vertical = target();
let horizontal = target();
let mut vertical_material = MeshBasicNodeMaterial::new();
vertical_material.name = "VSMVertical";
vertical_material.fragment_node = Some(crate::lights::vsm_pass_vertical(index, depth));
let mut horizontal_material = MeshBasicNodeMaterial::new();
horizontal_material.name = "VSMHorizontal";
horizontal_material.fragment_node = Some(crate::lights::vsm_pass_horizontal(
index,
&vertical.texture(),
));
VsmPasses {
vertical,
horizontal,
vertical_material,
horizontal_material,
}
});
passes.vertical.set_size(width, height);
passes.horizontal.set_size(width, height);
let steps = [
(
passes.vertical.clone(),
MaterialKey::of(&passes.vertical_material).variant(VARIANT_QUAD),
passes.vertical_material.clone(),
),
(
passes.horizontal.clone(),
MaterialKey::of(&passes.horizontal_material).variant(VARIANT_QUAD),
passes.horizontal_material.clone(),
),
];
let moments = passes.horizontal.texture();
let mut lights = vec![LightState::default(); index + 1];
lights[index].shadow_radius = shadow.radius;
lights[index].shadow_blur_samples = shadow.blur_samples as f64;
lights[index].shadow_map_size = shadow.map_size;
let previous_fullscreen_pass = std::mem::replace(&mut self.fullscreen_pass, true);
for (target, key, material) in steps {
let mut material = material;
material.vertex_node = Some(materials::quad_vertex_node());
let items = [Renderable {
object: None,
fog: None,
geometry: self.quad_geometry(),
material,
key,
setup: SetupContext::default(),
model_world: Matrix4::identity(),
instance_matrix: None,
instance_color: None,
instance_count: 1,
morph_influences: Vec::new(),
morph_base: 1.0,
bind_matrix: Matrix4::identity(),
bind_matrix_inverse: Matrix4::identity(),
bone_matrices: Vec::new(),
primitive: Primitive::TRIANGLES,
sub_draws: Vec::new(),
texture_overrides: Vec::new(),
group: None,
object_center: Vector2::new(0.5, 0.5),
}];
let uniforms = UniformContext {
lights: &lights,
..self.quad_camera_uniforms()
};
let pass_target = self.render_target_pass(&target);
self.draw(
&items,
uniforms,
&pass_target,
ClearOps {
color: Some([0.0, 0.0, 0.0, 0.0]),
depth: false,
},
);
}
self.fullscreen_pass = previous_fullscreen_pass;
moments
}
fn render_point_shadow(
&mut self,
index: usize,
node: &Node,
scene: &Scene,
camera: &dyn RenderCamera,
) {
let shadow_type = self.shadow_map_type.resolved();
let (light_world_position, near, far, size, filter_node) = {
let mut object = node.borrow_mut();
let light_world_position = LightObject::world_position(&object.matrix_world);
let light = object
.light_mut()
.expect("three-rs: the light list only holds lights");
let distance = light.distance;
let shadow = light
.shadow
.as_mut()
.expect("three-rs: a point light carries a PointLightShadow");
shadow.update_point_matrices(light_world_position, distance);
(
light_world_position,
shadow.camera.near(),
shadow.camera.far(),
shadow.map_size.x as u32,
shadow.filter_node.clone(),
)
};
let (depth_texture, color) = self
.cube_shadow_targets
.get(&index)
.cloned()
.unwrap_or_else(|| {
let depth_texture = CubeDepthTexture::new(size);
let gpu = self.device.create_texture(&wgpu::TextureDescriptor {
label: Some("three-rs point shadow depth"),
size: wgpu::Extent3d {
width: size,
height: size,
depth_or_array_layers: 6,
},
mip_level_count: 1,
sample_count: 1,
dimension: wgpu::TextureDimension::D2,
format: depth_texture.gpu_format(),
usage: wgpu::TextureUsages::RENDER_ATTACHMENT
| wgpu::TextureUsages::TEXTURE_BINDING,
view_formats: &[],
});
depth_texture.inner().borrow_mut().gpu = Some(gpu);
let color = self.device.create_texture(&wgpu::TextureDescriptor {
label: Some("three-rs point shadow map"),
size: wgpu::Extent3d {
width: size,
height: size,
depth_or_array_layers: 6,
},
mip_level_count: 1,
sample_count: 1,
dimension: wgpu::TextureDimension::D2,
format: wgpu::TextureFormat::Rgba8Unorm,
usage: wgpu::TextureUsages::RENDER_ATTACHMENT,
view_formats: &[],
});
let entry = (depth_texture, color);
self.cube_shadow_targets.insert(index, entry.clone());
entry
});
let cube_filter = if shadow_type == ShadowMapType::Pcf {
TextureFilter::Linear
} else {
TextureFilter::Nearest
};
depth_texture.set_filters(cube_filter, cube_filter);
for face in 0..6 {
let mut face_camera = PerspectiveCamera::new(90.0, 1.0, near, far);
{
let mut object = face_camera.node.borrow_mut();
object.position = light_world_position;
object.up = CUBE_UPS[face];
}
let mut target = light_world_position;
target.add(&CUBE_DIRECTIONS[face]);
face_camera.look_at(&target);
face_camera.update_matrix_world();
let mut face_list = RenderList::new();
project_object(
&scene.node,
&ProjectCamera::from_parts(
camera.layers(),
&face_camera.projection_matrix,
&face_camera.matrix_world_inverse,
camera.coordinate_system(),
),
0.0,
&mut face_list,
self.sort_objects,
);
face_list.sort();
let mut items = Vec::with_capacity(face_list.len());
for item in face_list.items() {
let object = item.node.borrow();
let vsm = shadow_type == ShadowMapType::Vsm;
if !(object.cast_shadow || (vsm && object.receive_shadow)) {
continue;
}
let geometry = object
.geometry()
.expect("three-rs: the render list only holds drawables")
.clone();
let source = item.material(&object).unwrap_or(&self.default_material);
let primitive = Primitive::of(&object, &geometry, false);
let instance_matrix = object.instance_matrix().cloned();
let instance_color = object.instance_color().cloned();
let instance_count = object.instance_count();
items.push(Renderable {
object: Some(item.node.clone()),
geometry: geometry.clone(),
material: materials::shadow_material_for(source, shadow_type),
key: MaterialKey::of(source).variant(VARIANT_SHADOW),
setup: SetupContext {
array_cameras: 0,
environment: None,
lighting_disabled: false,
viewport_opaque_mip: None,
instance_count: instance_matrix.as_ref().map(|_| instance_count as usize),
instanced: instance_matrix.is_some(),
instance_color: instance_color.as_ref().map(|a| a.count()),
output: None,
lights: Vec::new(),
morph: None,
skin: None,
batch: None,
line_segments: None,
sprite: false,
mrt: None,
vertex_color_size: 0,
geometry_missing_normal: false,
has_tangent_attribute: false,
instanced_attributes: Vec::new(),
},
fog: None,
model_world: item.matrix_world,
instance_matrix,
instance_color,
instance_count,
morph_influences: Vec::new(),
morph_base: 1.0,
bind_matrix: Matrix4::identity(),
bind_matrix_inverse: Matrix4::identity(),
object_center: Vector2::new(0.5, 0.5),
bone_matrices: Vec::new(),
primitive,
sub_draws: Vec::new(),
texture_overrides: Vec::new(),
group: item.group,
});
}
let color_view = color.create_view(&wgpu::TextureViewDescriptor {
dimension: Some(wgpu::TextureViewDimension::D2),
base_array_layer: face as u32,
array_layer_count: Some(1),
..Default::default()
});
let depth_view = {
let inner = depth_texture.inner().borrow();
inner
.gpu
.as_ref()
.expect("three-rs: the cube shadow target's depth texture is created before the pass runs")
.create_view(&wgpu::TextureViewDescriptor {
dimension: Some(wgpu::TextureViewDimension::D2),
base_array_layer: face as u32,
array_layer_count: Some(1),
..Default::default()
})
};
let pass_target = PassTarget {
color: color_view,
extra_colors: Vec::new(),
extra_color_targets: Vec::new(),
resolve: None,
color_texture: None,
depth: Some(depth_view),
color_format: wgpu::TextureFormat::Rgba8Unorm,
depth_format: Some(depth_texture.gpu_format()),
sample_count: 1,
width: size,
height: size,
viewport: Rect::full(size, size),
scissor: None,
};
let uniforms = UniformContext {
camera_projection: face_camera.projection_matrix,
camera_projection_inverse: {
let mut inverse = face_camera.projection_matrix;
inverse.invert();
inverse
},
camera_view: face_camera.matrix_world_inverse,
camera_world: face_camera.node.borrow().matrix_world,
time: self.node_frame.time,
delta_time: self.node_frame.delta_time,
frame_id: self.node_frame.frame_id as u32,
..Default::default()
};
self.draw(
&items,
uniforms,
&pass_target,
ClearOps::all([1.0, 1.0, 1.0, 1.0]),
);
}
let filter = match (filter_node, shadow_type) {
(Some(filter), _) => ShadowFilter::Custom(filter),
(None, ShadowMapType::Basic) => ShadowFilter::Basic,
(None, _) => ShadowFilter::Pcf,
};
let shadow_map = match filter {
ShadowFilter::Pcf => ShadowMap::Cube(depth_texture),
filter => ShadowMap::Filtered {
map: ShadowFilterMap::Cube(depth_texture),
filter,
},
};
self.shadow_maps.insert(index, shadow_map);
}
pub(crate) fn project_scene(&self, scene: &Scene, camera: &dyn RenderCamera) -> RenderList {
let mut render_list = RenderList::new();
let mut project_camera = ProjectCamera::new(camera);
if let Some(layers) = self.camera_layers {
project_camera.layers = layers;
}
project_object(
&scene.node,
&project_camera,
0.0,
&mut render_list,
self.sort_objects,
);
render_list.sort();
render_list
}
pub fn render_quad(&mut self, quad: &QuadMesh) {
let render = self.begin_frame();
self.render_quad_mesh(quad);
self.end_frame(render);
}
fn render_quad_mesh(&mut self, quad: &QuadMesh) {
let previous_fullscreen_pass = std::mem::replace(&mut self.fullscreen_pass, true);
let key = MaterialKey::of(&quad.material).variant(VARIANT_QUAD);
let mut material = quad.material.clone();
material.vertex_node = Some(materials::quad_vertex_node());
let items = [Renderable {
object: None,
fog: None,
geometry: self.quad_geometry(),
material,
key,
setup: SetupContext::default(),
model_world: Matrix4::identity(),
instance_matrix: None,
instance_color: None,
instance_count: 1,
morph_influences: Vec::new(),
morph_base: 1.0,
bind_matrix: Matrix4::identity(),
bind_matrix_inverse: Matrix4::identity(),
object_center: Vector2::new(0.5, 0.5),
bone_matrices: Vec::new(),
primitive: Primitive::TRIANGLES,
sub_draws: Vec::new(),
texture_overrides: Vec::new(),
group: None,
}];
let camera_uniforms = self.quad_camera_uniforms();
let clear = if self.auto_clear {
ClearOps {
color: self.auto_clear_color.then_some(self.clear_color),
depth: self.auto_clear_depth,
}
} else {
ClearOps::default()
};
self.render_list(&items, camera_uniforms, clear);
self.fullscreen_pass = previous_fullscreen_pass;
}
fn quad_camera_uniforms(&self) -> UniformContext<'static> {
UniformContext {
camera_projection: self.quad_camera.projection_matrix,
camera_projection_inverse: self.quad_camera.projection_matrix_inverse,
camera_view: self.quad_camera.matrix_world_inverse,
camera_world: self.quad_camera.object.matrix_world,
time: self.node_frame.time,
delta_time: self.node_frame.delta_time,
frame_id: self.node_frame.frame_id as u32,
..Default::default()
}
}
fn render_list(
&mut self,
items: &[Renderable],
camera_uniforms: UniformContext,
clear: ClearOps,
) {
let use_frame_buffer_target =
self.needs_frame_buffer_target() && self.render_target.is_none();
let target = if use_frame_buffer_target {
let target = self.frame_buffer_target();
let (viewport, scissor) = (self.viewport, self.scissor);
let pixel_ratio = self.pixel_ratio;
target.set_viewport(
viewport.x * pixel_ratio,
viewport.y * pixel_ratio,
viewport.z * pixel_ratio,
viewport.w * pixel_ratio,
);
target.set_scissor(
scissor.x * pixel_ratio,
scissor.y * pixel_ratio,
scissor.z * pixel_ratio,
scissor.w * pixel_ratio,
);
target.set_scissor_test(self.scissor_test);
Some(target)
} else {
self.render_target.clone()
};
let pass_target = match &target {
Some(render_target) => self.render_target_pass(render_target),
None => self.canvas_pass(true),
};
self.draw(items, camera_uniforms, &pass_target, clear);
if use_frame_buffer_target {
self.render_output(target.as_ref().expect(
"three-rs: use_frame_buffer_target means the frame buffer target is there",
));
}
}
fn draw(
&mut self,
items: &[Renderable],
camera_uniforms: UniformContext,
target: &PassTarget,
clear: ClearOps,
) {
let mut draws = Vec::with_capacity(items.len());
let mut occurrences = Occurrences::default();
let occlusion_context = self.occlusion_context.take();
let occluded = occlusion_context
.and_then(|key| self.occlusion.occluded(key))
.cloned();
let transmission_split = target
.color_texture
.is_some()
.then(|| {
items
.iter()
.position(|item| item.material.transmission > 0.0)
})
.flatten();
for item in items {
let geometry_id = item.geometry.id();
self.ensure_geometry(&item.geometry);
if item.primitive.wireframe {
self.ensure_wireframe_index(&item.geometry);
}
let node = self.node_builder_state(
item,
target.color_format.components(),
target.sample_count,
);
let program_key = node.cache_key;
for entry in &node.update_before {
self.update_before_node(entry);
}
for entry in &node.update {
self.update_node(entry);
}
let mut extra_color_targets = [None; MAX_EXTRA_COLOR_ATTACHMENTS];
for (slot, extra) in extra_color_targets
.iter_mut()
.zip(&target.extra_color_targets)
{
*slot = Some(*extra);
}
let state = RenderState {
color_format: target.color_format,
color_attachments: 1 + target.extra_colors.len() as u32,
extra_color_targets,
depth_format: target.depth_format,
sample_count: target.sample_count,
side: item.material.side,
depth_test: item.material.depth_test,
depth_write: item.material.depth_write,
depth_func: item.material.depth_func,
alpha_to_coverage: item.material.alpha_to_coverage,
blend: item.material.blend_state(),
topology: item.primitive.topology,
strip_index_format: item.primitive.strip_index_format,
};
let pipeline = PipelineKey {
program: program_key,
state,
};
self.ensure_pipeline(pipeline);
let object = item.object.as_ref().map(|node| node.borrow());
let uniforms = UniformContext {
object: object.as_deref(),
occluded: occluded.as_ref(),
model_world: item.model_world,
material_color: item.material.color,
material_opacity: item.material.opacity,
material_alpha_test: item.material.alpha_test,
material_rotation: item.material.rotation,
material_reflectivity: item.material.reflectivity,
material_shininess: item.material.shininess,
material_specular: item.material.specular,
material_emissive: item.material.emissive,
material_emissive_intensity: item.material.emissive_intensity,
morph_base: item.morph_base,
morph_influences: &item.morph_influences,
bind_matrix: item.bind_matrix,
bind_matrix_inverse: item.bind_matrix_inverse,
object_center: item.object_center,
bone_matrices: &item.bone_matrices,
material_metalness: item.material.metalness,
material_roughness: item.material.roughness,
material_bump_scale: item.material.bump_scale,
material_ior: item.material.ior,
material_specular_intensity: item.material.specular_intensity,
material_specular_color: item.material.specular_color,
material_sheen: item.material.sheen,
material_sheen_color: item.material.sheen_color,
material_sheen_roughness: item.material.sheen_roughness,
material_diffuse_roughness: item.material.diffuse_roughness,
material_normal_scale: item.material.normal_scale,
material_anisotropy: item.material.anisotropy,
material_anisotropy_rotation: item.material.anisotropy_rotation,
material_clearcoat: item.material.clearcoat,
material_clearcoat_roughness: item.material.clearcoat_roughness,
material_clearcoat_normal_scale: item.material.clearcoat_normal_scale,
material_transmission: item.material.transmission,
material_thickness: item.material.thickness,
material_attenuation_distance: item.material.attenuation_distance,
material_attenuation_color: item.material.attenuation_color,
material_ao_map_intensity: item.material.ao_map_intensity,
tone_mapping_exposure: self.tone_mapping_exposure,
material_line_width: item.material.linewidth,
viewport_size: Vector2::new(target.width as f64, target.height as f64),
viewport: target.viewport.to_vector4(),
screen_dpr: self.pixel_ratio,
..camera_uniforms
};
let owner = SlotOwner::Draw(occurrences.next(DrawKey {
object: object.as_ref().map(|object| object.id),
geometry: geometry_id,
material: item.key.id,
variant: item.key.variant,
occurrence: 0,
}));
self.texture_overrides.clone_from(&item.texture_overrides);
let bind_groups = self.bind_groups(
program_key,
owner,
&node,
&uniforms,
&item.instance_matrix,
&item.instance_color,
);
self.texture_overrides.clear();
let vertex_buffers = node
.vertex_buffers()
.iter()
.enumerate()
.map(|(slot, desc)| match &desc.source {
VertexBufferSource::Geometry(name) => {
self.geometries[&geometry_id].gpu.attribute(name).clone()
}
VertexBufferSource::Instance(buffer) => self.instance_buffer(
SlotKey {
owner,
group: VERTEX_SLOTS,
binding: slot as u32,
},
buffer,
&item.instance_matrix,
&item.instance_color,
),
})
.collect();
let gpu = &self.geometries[&geometry_id].gpu;
let available = match gpu.draw_index(item.primitive.wireframe) {
Some((_, _, count)) => *count,
None => gpu.vertex_count,
};
let range_factor: u64 = if item.primitive.wireframe { 2 } else { 1 };
let draw_start = item.geometry.draw_range.start as u64 * range_factor;
let mut last = item
.geometry
.draw_range
.count
.map_or(u64::MAX, |count| draw_start + count as u64 * range_factor);
let mut first = draw_start;
if let Some(group) = item.group {
first = first.max(group.start as u64 * range_factor);
last = last.min((group.start as u64 + group.count as u64) * range_factor);
}
let last = last.min(available as u64);
let first = first.min(last) as u32;
let elements = last as u32 - first;
if item.sub_draws.is_empty() {
self.info
.record_draw(item.primitive.topology, elements, item.instance_count);
} else {
for sub in &item.sub_draws {
self.info.record_draw(
item.primitive.topology,
sub.index_count,
item.instance_count,
);
}
}
let sub_cameras = if item.setup.array_cameras > 0 {
self.sub_camera_draws(program_key, &node, uniforms.camera_viewports)
} else {
Vec::new()
};
let indirect = item
.geometry
.indirect()
.map(|attribute| self.indirect_buffer(attribute).gpu);
draws.push(Draw {
geometry_id,
vertex_buffers,
pipeline,
bind_groups,
instance_count: item.instance_count,
sub_draws: item.sub_draws.clone(),
first,
elements,
indirect,
object: object.as_ref().map(|object| object.id),
occlusion_test: object.as_ref().is_some_and(|object| object.occlusion_test),
sub_cameras,
wireframe: item.primitive.wireframe,
});
drop(object);
for entry in &node.update_after {
self.update_after_node(entry);
}
}
let query_objects = match occlusion_context {
Some(_) => occlusion::query_objects(
draws[..transmission_split.unwrap_or(draws.len())]
.iter()
.map(|draw| (draw.object, draw.occlusion_test)),
),
None => Vec::new(),
};
let query_set = occlusion_context.and_then(|key| {
self.occlusion
.begin(&self.device, key, query_objects.len() as u32)
});
match transmission_split {
None => {
let mut encoder =
self.device
.create_command_encoder(&wgpu::CommandEncoderDescriptor {
label: Some("three-rs pass"),
});
self.record_pass(&mut encoder, &draws, target, clear, query_set.as_ref());
if let (Some(key), Some(set)) = (occlusion_context, &query_set) {
self.occlusion
.finish(&self.device, &mut encoder, key, set, query_objects);
}
self.queue.submit(Some(encoder.finish()));
}
Some(split) => {
let mut encoder =
self.device
.create_command_encoder(&wgpu::CommandEncoderDescriptor {
label: Some("three-rs pass"),
});
self.record_pass(
&mut encoder,
&draws[..split],
target,
clear,
query_set.as_ref(),
);
if let (Some(key), Some(set)) = (occlusion_context, &query_set) {
self.occlusion
.finish(&self.device, &mut encoder, key, set, query_objects);
}
self.queue.submit(Some(encoder.finish()));
let source = target
.color_texture
.clone()
.expect("three-rs: a split pass only happens on a target with a copy source");
self.copy_framebuffer_to_opaque_frame(&source);
let mut encoder =
self.device
.create_command_encoder(&wgpu::CommandEncoderDescriptor {
label: Some("three-rs transmission pass"),
});
self.record_pass(
&mut encoder,
&draws[split..],
target,
ClearOps::default(),
None,
);
self.queue.submit(Some(encoder.finish()));
}
}
}
fn record_pass(
&self,
encoder: &mut wgpu::CommandEncoder,
draws: &[Draw],
target: &PassTarget,
clear: ClearOps,
occlusion_query_set: Option<&wgpu::QuerySet>,
) {
let load = match clear.color {
Some(color) => wgpu::LoadOp::Clear(wgpu::Color {
r: color[0],
g: color[1],
b: color[2],
a: color[3],
}),
None => wgpu::LoadOp::Load,
};
let mut color_attachments = vec![Some(wgpu::RenderPassColorAttachment {
view: &target.color,
depth_slice: None,
resolve_target: target.resolve.as_ref(),
ops: wgpu::Operations {
load,
store: wgpu::StoreOp::Store,
},
})];
let extra_load = match clear.color {
Some(_) => wgpu::LoadOp::Clear(wgpu::Color {
r: 0.0,
g: 0.0,
b: 0.0,
a: 1.0,
}),
None => wgpu::LoadOp::Load,
};
for (view, resolve) in &target.extra_colors {
color_attachments.push(Some(wgpu::RenderPassColorAttachment {
view,
depth_slice: None,
resolve_target: resolve.as_ref(),
ops: wgpu::Operations {
load: extra_load,
store: wgpu::StoreOp::Store,
},
}));
}
let mut pass = encoder.begin_render_pass(&wgpu::RenderPassDescriptor {
label: Some("three-rs pass"),
color_attachments: &color_attachments,
depth_stencil_attachment: target.depth.as_ref().map(|view| {
wgpu::RenderPassDepthStencilAttachment {
view,
depth_ops: Some(wgpu::Operations {
load: if clear.depth {
wgpu::LoadOp::Clear(1.0)
} else {
wgpu::LoadOp::Load
},
store: wgpu::StoreOp::Store,
}),
stencil_ops: None,
}
}),
occlusion_query_set,
timestamp_writes: None,
multiview_mask: None,
});
let vp = target.viewport;
pass.set_viewport(
vp.x as f32,
vp.y as f32,
vp.width as f32,
vp.height as f32,
0.0,
1.0,
);
if let Some(sc) = target.scissor {
pass.set_scissor_rect(sc.x, sc.y, sc.width, sc.height);
}
let mut last_object: Option<(Option<u32>, bool)> = None;
let mut query_index = 0;
for draw in draws.iter() {
if occlusion_query_set.is_some()
&& last_object.map(|(object, _)| object) != Some(draw.object)
{
if let Some((_, true)) = last_object {
pass.end_occlusion_query();
query_index += 1;
}
if draw.occlusion_test {
pass.begin_occlusion_query(query_index);
}
last_object = Some((draw.object, draw.occlusion_test));
}
pass.set_pipeline(
self.pipelines
.get(&draw.pipeline)
.expect("three-rs: the draw's pipeline was built into the cache above"),
);
for (index, group) in draw.bind_groups.iter().enumerate() {
pass.set_bind_group(index as u32, group, &[]);
}
for (slot, buffer) in draw.vertex_buffers.iter().enumerate() {
pass.set_vertex_buffer(slot as u32, buffer.slice(..));
}
if draw.sub_cameras.is_empty() {
self.issue_draw(&mut pass, draw);
continue;
}
for sub in &draw.sub_cameras {
let [x, y, width, height] = sub.viewport;
pass.set_viewport(x, y, width, height, 0.0, 1.0);
if let Some((index, group)) = &sub.camera_index {
pass.set_bind_group(*index, group, &[]);
}
self.issue_draw(&mut pass, draw);
}
}
if let Some((_, true)) = last_object {
pass.end_occlusion_query();
}
}
fn issue_draw(&self, pass: &mut wgpu::RenderPass, draw: &Draw) {
let geometry = &self.geometries[&draw.geometry_id].gpu;
if !draw.sub_draws.is_empty() {
let (buffer, format, _) = geometry
.index
.as_ref()
.expect("three-rs: a batched mesh is always indexed");
pass.set_index_buffer(buffer.slice(..), *format);
for sub in &draw.sub_draws {
pass.draw_indexed(
sub.first_index..sub.first_index + sub.index_count,
0,
sub.first_instance..sub.first_instance + 1,
);
}
return;
}
if let Some(indirect) = &draw.indirect {
match &geometry.index {
Some((buffer, format, _)) => {
pass.set_index_buffer(buffer.slice(..), *format);
pass.draw_indexed_indirect(indirect, 0);
}
None => pass.draw_indirect(indirect, 0),
}
return;
}
match geometry.draw_index(draw.wireframe) {
Some((buffer, format, _)) => {
pass.set_index_buffer(buffer.slice(..), *format);
pass.draw_indexed(
draw.first..draw.first + draw.elements,
0,
0..draw.instance_count,
);
}
None => pass.draw(
draw.first..draw.first + draw.elements,
0..draw.instance_count,
),
}
}
fn render_output(&mut self, render_target: &RenderTarget) {
let texture = render_target.texture();
let key = MaterialKey::of(&self.output_material)
.variant(hash_of(&(texture.id(), self.tone_mapping)));
let mut material = self.output_material.clone();
material.fragment_node = Some(materials::output_fragment_node(&texture, self.tone_mapping));
let items = [Renderable {
object: None,
fog: None,
geometry: self.quad_geometry(),
material,
key,
setup: SetupContext::default(),
model_world: Matrix4::identity(),
instance_matrix: None,
instance_color: None,
instance_count: 1,
morph_influences: Vec::new(),
morph_base: 1.0,
bind_matrix: Matrix4::identity(),
bind_matrix_inverse: Matrix4::identity(),
object_center: Vector2::new(0.5, 0.5),
bone_matrices: Vec::new(),
primitive: Primitive::TRIANGLES,
sub_draws: Vec::new(),
texture_overrides: Vec::new(),
group: None,
}];
let camera_uniforms = self.quad_camera_uniforms();
let pass_target = self.canvas_pass(true);
self.draw(&items, camera_uniforms, &pass_target, ClearOps::default());
}
pub fn compute(&mut self, flow: &ComputeFlow) -> Result<(), Error> {
self.compute_dispatch(flow, None)
}
fn skeleton_bone_buffer(
&mut self,
slot: SlotKey,
skeleton: &crate::nodes::node::SkeletonRef,
count: usize,
) -> Serial<wgpu::Buffer> {
update_skeleton(&mut self.node_frame, &skeleton.0);
let skeleton = skeleton.0.borrow();
let mut data = vec![0f32; count * 16];
let n = data.len().min(skeleton.bone_matrices.len());
data[..n].copy_from_slice(&skeleton.bone_matrices[..n]);
self.slot_buffer(
slot,
"three-rs computeSkinning boneMatrices",
bytemuck::cast_slice(&data),
wgpu::BufferUsages::UNIFORM,
)
}
pub fn compute_indirect(
&mut self,
flow: &ComputeFlow,
dispatch: &crate::core::IndirectStorageBufferAttribute,
) -> Result<(), Error> {
assert!(
dispatch.array().len() >= 3,
"three-rs: an indirect dispatch reads three u32 workgroup counts"
);
self.compute_dispatch(flow, Some(dispatch))
}
fn compute_dispatch(
&mut self,
flow: &ComputeFlow,
indirect: Option<&crate::core::IndirectStorageBufferAttribute>,
) -> Result<(), Error> {
let key = compute_flow_key(flow);
let program = match self.compute_programs.get(&key) {
Some(program) => program.clone(),
None => {
self.info.build.programs_compiled += 1;
let program = Rc::new(NodeBuilder::new().build_compute(flow));
self.compute_programs.insert(key, program.clone());
program
}
};
let fresh = !self.compute_pipelines.contains_key(&program.cache_key);
if fresh {
self.info.build.pipelines_built += 1;
self.info.memory.programs += 1;
let gpu = ComputeProgramGpu::new(&self.device, &program);
self.compute_pipelines.insert(program.cache_key, gpu);
}
if fresh {
if let Some(on_init) = &flow.on_init {
self.compute(on_init)?;
}
}
let uniforms = UniformContext {
time: self.node_frame.time,
..Default::default()
};
let bind_groups = self.compute_bind_groups(program.cache_key, &program, &uniforms);
let indirect = indirect.map(|attribute| self.indirect_buffer(attribute).gpu);
let mut encoder = self
.device
.create_command_encoder(&wgpu::CommandEncoderDescriptor {
label: Some("three-rs compute"),
});
{
let gpu = &self.compute_pipelines[&program.cache_key];
let mut pass = encoder.begin_compute_pass(&wgpu::ComputePassDescriptor {
label: Some("three-rs compute pass"),
timestamp_writes: None,
});
pass.set_pipeline(&gpu.pipeline);
for (index, group) in bind_groups.iter().enumerate() {
pass.set_bind_group(index as u32, group, &[]);
}
match &indirect {
Some(buffer) => pass.dispatch_workgroups_indirect(buffer, 0),
None => {
let [x, y, z] = program.dispatch;
pass.dispatch_workgroups(x, y, z);
}
}
}
self.queue.submit(Some(encoder.finish()));
self.info.compute.calls += 1;
Ok(())
}
fn compute_bind_groups(
&mut self,
program_key: u64,
program: &crate::nodes::ComputeProgram,
uniforms: &UniformContext,
) -> Vec<wgpu::BindGroup> {
let mut out = Vec::with_capacity(program.groups.len());
for (group_index, descs) in program.groups.iter().enumerate() {
let mut resources = Vec::with_capacity(descs.len());
for desc in descs {
resources.push(match desc {
BindingDesc::Uniforms { members, size, .. } => {
let bytes = uniforms.bytes(members, *size);
Resource::Buffer(self.slot_buffer(
SlotKey {
owner: SlotOwner::Compute(program_key),
group: group_index as u32,
binding: resources.len() as u32,
},
"three-rs compute uniforms",
&bytes,
wgpu::BufferUsages::UNIFORM,
))
}
BindingDesc::Buffer {
source: BufferSource::SkeletonBoneMatrices(skeleton),
count,
..
} => Resource::Buffer(self.skeleton_bone_buffer(
SlotKey {
owner: SlotOwner::Compute(program_key),
group: group_index as u32,
binding: resources.len() as u32,
},
skeleton,
*count,
)),
BindingDesc::Buffer {
id,
count,
element_ty,
source,
..
} => {
Resource::Buffer(self.storage_buffer_for(*id, source, *count, *element_ty))
}
BindingDesc::Texture { source, kind, .. } => {
Resource::View(self.texture_view(source, *kind))
}
BindingDesc::Sampler { source, .. } => {
Resource::Sampler(self.texture_sampler(source))
}
});
}
out.push(self.bind_group(LayoutKey::Compute(program_key), group_index, &resources));
}
out
}
#[doc(hidden)]
pub fn read_storage_buffer(&mut self, array: &StorageArray) -> Result<Vec<f32>, Error> {
let components = array.element_ty().components();
assert_eq!(
storage_stride(array.element_ty()),
components * 4,
"three-rs: read_storage_buffer does not unpick a padded element stride"
);
let buffer = self
.storage_buffer(
array.id().get(),
(array.count() * storage_stride(array.element_ty())) as u64,
None,
)
.gpu;
let bytes = self.read_buffer(&buffer)?;
Ok(bytemuck::cast_slice(&bytes).to_vec())
}
#[doc(hidden)]
pub fn read_storage_buffer_u32(&mut self, array: &StorageArray) -> Result<Vec<u32>, Error> {
assert_eq!(
array.element_ty().component_type(),
Type::U32,
"three-rs: read_storage_buffer_u32 reads u32 arrays"
);
let buffer = self
.storage_buffer(
array.id().get(),
(array.count() * storage_stride(array.element_ty())) as u64,
None,
)
.gpu;
let bytes = self.read_buffer(&buffer)?;
Ok(bytemuck::cast_slice(&bytes).to_vec())
}
fn read_buffer(&mut self, buffer: &wgpu::Buffer) -> Result<Vec<u8>, Error> {
let size = buffer.size();
let staging = self.device.create_buffer(&wgpu::BufferDescriptor {
label: Some("three-rs storage readback"),
size,
usage: wgpu::BufferUsages::COPY_DST | wgpu::BufferUsages::MAP_READ,
mapped_at_creation: false,
});
let mut encoder = self
.device
.create_command_encoder(&wgpu::CommandEncoderDescriptor {
label: Some("three-rs storage readback"),
});
encoder.copy_buffer_to_buffer(buffer, 0, &staging, 0, size);
self.queue.submit(Some(encoder.finish()));
let slice = staging.slice(..);
slice.map_async(wgpu::MapMode::Read, |_| {});
self.device
.poll(wgpu::PollType::wait_indefinitely())
.map_err(|e| Error::Readback {
reason: e.to_string(),
})?;
let bytes = slice
.get_mapped_range()
.map_err(|e| Error::Readback {
reason: e.to_string(),
})?
.to_vec();
staging.unmap();
Ok(bytes)
}
pub fn read_canvas_pixels(&mut self) -> Result<(u32, u32, Vec<u8>), Error> {
let (texture, width, height) = self.canvas_color();
self.read_texture_pixels(&texture, width, height)
}
pub async fn read_canvas_pixels_async(&mut self) -> Result<(u32, u32, Vec<u8>), Error> {
#[cfg(not(target_arch = "wasm32"))]
{
self.read_canvas_pixels()
}
#[cfg(target_arch = "wasm32")]
{
let (texture, width, height) = self.canvas_color();
let readback = self.submit_readback(&texture, width, height)?;
let slice = readback.buffer.slice(..);
let mapped = MapFuture::default();
let done = mapped.state.clone();
slice.map_async(wgpu::MapMode::Read, move |result| {
let mut state = done.borrow_mut();
state.0 = Some(result);
if let Some(waker) = state.1.take() {
waker.wake();
}
});
mapped.await.map_err(|e| Error::Readback {
reason: e.to_string(),
})?;
readback.finish()
}
}
fn canvas_color(&mut self) -> (wgpu::Texture, u32, u32) {
if self.canvas.is_none() {
self.prepare_canvas(false, 1);
}
let canvas = self
.canvas
.as_ref()
.expect("three-rs: prepare_canvas() has just created the canvas");
(canvas.color.clone(), canvas.width, canvas.height)
}
#[doc(hidden)]
pub fn read_target_pixels(
&mut self,
render_target: &RenderTarget,
) -> Result<(u32, u32, Vec<u8>), Error> {
self.prepare_render_target(render_target);
let inner = render_target.inner().borrow();
let (width, height) = (inner.width, inner.height);
let texture = inner.texture.with_gpu(|gpu| gpu.clone());
drop(inner);
self.read_texture_pixels(&texture, width, height)
}
pub fn read_render_target_pixels(
&mut self,
render_target: &RenderTarget,
x: u32,
y: u32,
width: u32,
height: u32,
texture_index: usize,
) -> Result<Vec<u8>, Error> {
self.prepare_render_target(render_target);
let textures = render_target.textures();
let Some(texture) = textures.get(texture_index) else {
return Err(Error::Readback {
reason: format!(
"renderTarget.textures[ {texture_index} ] does not exist ({} attachments)",
textures.len()
),
});
};
let texture = texture.with_gpu(|gpu| gpu.clone());
let (full_width, full_height) = render_target.size();
if x + width > full_width || y + height > full_height {
return Err(Error::Readback {
reason: format!(
"the rectangle ( {x}, {y}, {width}, {height} ) is outside the \
{full_width}x{full_height} target"
),
});
}
let (_, _, pixels) = self.read_texture_pixels(&texture, full_width, full_height)?;
if (x, y, width, height) == (0, 0, full_width, full_height) {
return Ok(pixels);
}
let row = full_width as usize * 4;
let mut out = Vec::with_capacity(width as usize * height as usize * 4);
for r in y as usize..(y + height) as usize {
let start = r * row + x as usize * 4;
out.extend_from_slice(&pixels[start..start + width as usize * 4]);
}
Ok(out)
}
#[doc(hidden)]
pub fn read_target_pixels_rgba16f(
&mut self,
render_target: &RenderTarget,
) -> Result<(u32, u32, Vec<f32>), Error> {
self.prepare_render_target(render_target);
let inner = render_target.inner().borrow();
let (width, height) = (inner.width, inner.height);
let texture = inner.texture.with_gpu(|gpu| gpu.clone());
drop(inner);
let format = texture.format();
if format != wgpu::TextureFormat::Rgba16Float {
return Err(Error::Readback {
reason: format!("{format:?} is not rgba16float"),
});
}
let (width, height, bytes) = self.read_texture_bytes(&texture, width, height)?;
let pixels = bytes
.as_chunks::<2>()
.0
.iter()
.map(|half| crate::extras::from_half_float(u16::from_le_bytes(*half)))
.collect();
Ok((width, height, pixels))
}
fn read_texture_pixels(
&self,
texture: &wgpu::Texture,
width: u32,
height: u32,
) -> Result<(u32, u32, Vec<u8>), Error> {
let format = texture.format();
if format.block_copy_size(None) != Some(4) {
return Err(Error::Readback {
reason: format!("{format:?} is not a four-byte-per-pixel format"),
});
}
self.read_texture_bytes(texture, width, height)
}
fn read_texture_bytes(
&self,
texture: &wgpu::Texture,
width: u32,
height: u32,
) -> Result<(u32, u32, Vec<u8>), Error> {
let readback = self.submit_readback(texture, width, height)?;
let slice = readback.buffer.slice(..);
slice.map_async(wgpu::MapMode::Read, |_| {});
self.device
.poll(wgpu::PollType::wait_indefinitely())
.map_err(|e| Error::Readback {
reason: e.to_string(),
})?;
readback.finish()
}
#[doc(hidden)]
pub fn read_cube_pixels_rgba16f(
&mut self,
cube: &CubeTexture,
layer: u32,
mip_level: u32,
) -> Result<(u32, u32, Vec<f32>), Error> {
let texture = self.ensure_cube_texture(cube);
let format = texture.format();
if format != wgpu::TextureFormat::Rgba16Float {
return Err(Error::Readback {
reason: format!("{format:?} is not rgba16float"),
});
}
let size = texture.width() >> mip_level;
let readback = self.submit_readback_at(&texture, mip_level, layer, size, size)?;
let slice = readback.buffer.slice(..);
slice.map_async(wgpu::MapMode::Read, |_| {});
self.device
.poll(wgpu::PollType::wait_indefinitely())
.map_err(|e| Error::Readback {
reason: e.to_string(),
})?;
let (width, height, bytes) = readback.finish()?;
let pixels = bytes
.as_chunks::<2>()
.0
.iter()
.map(|half| crate::extras::from_half_float(u16::from_le_bytes(*half)))
.collect();
Ok((width, height, pixels))
}
fn submit_readback(
&self,
texture: &wgpu::Texture,
width: u32,
height: u32,
) -> Result<PendingReadback, Error> {
self.submit_readback_at(texture, 0, 0, width, height)
}
fn submit_readback_at(
&self,
texture: &wgpu::Texture,
mip_level: u32,
layer: u32,
width: u32,
height: u32,
) -> Result<PendingReadback, Error> {
let format = texture.format();
let bytes_per_texel = format
.block_copy_size(None)
.ok_or_else(|| Error::Readback {
reason: format!("{format:?} has no single block size"),
})?;
let unpadded_bytes_per_row = width * bytes_per_texel;
let bytes_per_row = unpadded_bytes_per_row.div_ceil(256) * 256;
let buffer = self.device.create_buffer(&wgpu::BufferDescriptor {
label: Some("three-rs readback"),
size: (bytes_per_row * height) as u64,
usage: wgpu::BufferUsages::COPY_DST | wgpu::BufferUsages::MAP_READ,
mapped_at_creation: false,
});
let mut encoder = self
.device
.create_command_encoder(&wgpu::CommandEncoderDescriptor {
label: Some("three-rs readback"),
});
encoder.copy_texture_to_buffer(
wgpu::TexelCopyTextureInfo {
texture,
mip_level,
origin: wgpu::Origin3d {
x: 0,
y: 0,
z: layer,
},
aspect: wgpu::TextureAspect::All,
},
wgpu::TexelCopyBufferInfo {
buffer: &buffer,
layout: wgpu::TexelCopyBufferLayout {
offset: 0,
bytes_per_row: Some(bytes_per_row),
rows_per_image: Some(height),
},
},
wgpu::Extent3d {
width,
height,
depth_or_array_layers: 1,
},
);
self.queue.submit(Some(encoder.finish()));
Ok(PendingReadback {
buffer,
width,
height,
bytes_per_row,
unpadded_bytes_per_row,
})
}
fn node_builder_state(
&mut self,
item: &Renderable,
output_components: u8,
sample_count: u32,
) -> Rc<NodeProgram> {
let alpha_to_coverage_samples = item.material.alpha_to_coverage && sample_count > 1;
let dynamic_key = hash_of(&(
item.key.variant,
&item.setup,
&item.fog,
output_components,
alpha_to_coverage_samples,
));
let frames = self.node_frame.frame_id;
let states = self
.node_builder_states
.entry(item.key.id)
.or_insert_with(|| MaterialStates {
version: item.key.version,
last_used: frames,
by_dynamic_key: HashMap::new(),
});
states.last_used = frames;
if states.version != item.key.version {
states.by_dynamic_key.clear();
states.version = item.key.version;
}
if let Some(node) = states.by_dynamic_key.get(&dynamic_key) {
return node.clone();
}
warn_unsupported(item.key.id, &item.material, &item.setup);
crate::nodes::frame::sync_before_build(self.samples);
let _samples = crate::nodes::builder::push_context(|cx| {
cx.alpha_to_coverage_samples = alpha_to_coverage_samples;
});
let flow = materials::setup(&item.material, &item.setup, item.fog.as_ref());
let node = Rc::new(
NodeBuilder::new()
.with_output_components(output_components as u32)
.with_array_cameras(item.setup.array_cameras)
.build(&flow)
.with_instanced_attributes(&item.setup.instanced_attributes),
);
self.info.build.programs_compiled += 1;
self.programs
.entry(node.cache_key)
.or_insert_with(|| Program::new(&self.device, &node));
self.info.memory.programs = self.programs.len();
states.by_dynamic_key.insert(dynamic_key, node.clone());
node
}
pub fn info(&self) -> &Info {
&self.info
}
pub fn info_mut(&mut self) -> &mut Info {
&mut self.info
}
fn bind_groups(
&mut self,
program_key: u64,
owner: SlotOwner,
node: &NodeProgram,
uniforms: &UniformContext,
instance_matrix: &Option<InstancedBufferAttribute>,
instance_color: &Option<InstancedBufferAttribute>,
) -> Vec<wgpu::BindGroup> {
let mut out = Vec::with_capacity(node.groups.len());
for (group_index, descs) in node.groups.iter().enumerate() {
let mut resources = Vec::with_capacity(descs.len());
for desc in descs {
let slot = SlotKey {
owner,
group: group_index as u32,
binding: resources.len() as u32,
};
resources.push(match desc {
BindingDesc::Uniforms { members, size, .. } => {
let bytes = uniforms.bytes(members, *size);
Resource::Buffer(self.slot_buffer(
slot,
"three-rs uniforms",
&bytes,
wgpu::BufferUsages::UNIFORM,
))
}
BindingDesc::Buffer {
id,
source,
count,
element_ty,
..
} => Resource::Buffer(self.node_buffer(
slot,
*id,
source,
*count,
*element_ty,
instance_matrix,
instance_color,
uniforms,
)),
BindingDesc::Texture { source, kind, .. } => {
Resource::View(self.texture_view(source, *kind))
}
BindingDesc::Sampler { source, .. } => {
Resource::Sampler(self.texture_sampler(source))
}
});
}
out.push(self.bind_group(LayoutKey::Render(program_key), group_index, &resources));
}
out
}
fn sub_camera_draws(
&mut self,
program_key: u64,
node: &NodeProgram,
viewports: &[Vector4],
) -> Vec<SubCameraDraw> {
let pixel_ratio = if self.render_target.is_none() {
self.pixel_ratio
} else {
1.0
};
let group_index = node.groups.iter().position(|descs| {
descs.iter().any(|desc| {
matches!(
desc,
BindingDesc::Uniforms {
group: crate::nodes::UniformGroup::CameraIndex,
..
}
)
})
});
viewports
.iter()
.enumerate()
.map(|(i, vp)| {
let camera_index = group_index.map(|group| {
let data: [u32; 4] = [i as u32, 0, 0, 0];
let buffer = self.slot_buffer(
SlotKey {
owner: SlotOwner::CameraIndex(i as u32),
group: 0,
binding: 0,
},
"three-rs cameraIndex",
bytemuck::cast_slice(&data),
wgpu::BufferUsages::UNIFORM,
);
let bind_group = self.bind_group(
LayoutKey::Render(program_key),
group,
&[Resource::Buffer(buffer)],
);
(group as u32, bind_group)
});
SubCameraDraw {
viewport: [
(vp.x * pixel_ratio).floor() as f32,
(vp.y * pixel_ratio).floor() as f32,
(vp.z * pixel_ratio).floor() as f32,
(vp.w * pixel_ratio).floor() as f32,
],
camera_index,
}
})
.collect()
}
fn bind_group(
&mut self,
layout: LayoutKey,
group: usize,
resources: &[Resource],
) -> wgpu::BindGroup {
let key = BindGroupKey::of(layout, group as u32, resources);
let frames = self.node_frame.frame_id;
if let Some(entry) = self.bind_group_cache.get_mut(&key) {
entry.last_used = frames;
return entry.group.clone();
}
let entries: Vec<wgpu::BindGroupEntry> = resources
.iter()
.enumerate()
.map(|(binding, resource)| wgpu::BindGroupEntry {
binding: binding as u32,
resource: resource.binding(),
})
.collect();
let (label, layout) = match layout {
LayoutKey::Render(program) => (
"three-rs bind group",
&self.programs[&program].layouts[group],
),
LayoutKey::Compute(program) => (
"three-rs compute bind group",
&self.compute_pipelines[&program].layouts[group],
),
};
let bind_group = self.device.create_bind_group(&wgpu::BindGroupDescriptor {
label: Some(label),
layout,
entries: &entries,
});
self.info.build.bind_groups_created += 1;
self.bind_group_cache.insert(
key,
BindGroupEntry {
group: bind_group.clone(),
last_used: frames,
},
);
bind_group
}
fn serial<T: Counted>(&mut self, gpu: T) -> Serial<T> {
T::count(&mut self.info.build);
Serial {
serial: self.serials.next(),
gpu,
}
}
#[allow(clippy::too_many_arguments)]
fn node_buffer(
&mut self,
slot: SlotKey,
id: usize,
source: &BufferSource,
count: usize,
element_ty: Type,
instance_matrix: &Option<InstancedBufferAttribute>,
instance_color: &Option<InstancedBufferAttribute>,
uniforms: &UniformContext,
) -> Serial<wgpu::Buffer> {
if let BufferSource::CameraViewMatrices | BufferSource::CameraProjectionMatrices = source {
let matrices = match source {
BufferSource::CameraViewMatrices => uniforms.camera_view_matrices,
_ => uniforms.camera_projection_matrices,
};
let mut data = vec![0f32; count * 16];
let n = data.len().min(matrices.len());
data[..n].copy_from_slice(&matrices[..n]);
return self.slot_buffer(
slot,
"three-rs camera matrices",
bytemuck::cast_slice(&data),
wgpu::BufferUsages::UNIFORM,
);
}
if let BufferSource::BoneMatrices = source {
let mut data = vec![0f32; count * 16];
let n = data.len().min(uniforms.bone_matrices.len());
data[..n].copy_from_slice(&uniforms.bone_matrices[..n]);
return self.slot_buffer(
slot,
"three-rs boneMatrices",
bytemuck::cast_slice(&data),
wgpu::BufferUsages::UNIFORM,
);
}
if let BufferSource::SkeletonBoneMatrices(skeleton) = source {
return self.skeleton_bone_buffer(slot, skeleton, count);
}
if let BufferSource::MorphInfluences = source {
let mut data = vec![0f32; count * 4];
for (i, influence) in uniforms.morph_influences.iter().enumerate().take(count) {
data[i * 4] = *influence as f32;
}
return self.slot_buffer(
slot,
"three-rs morphTargetInfluences",
bytemuck::cast_slice(&data),
wgpu::BufferUsages::UNIFORM,
);
}
if source.is_storage() {
return self.storage_buffer_for(id, source, count, element_ty);
}
self.buffer_for(
slot,
id,
source,
count,
instance_matrix,
instance_color,
wgpu::BufferUsages::UNIFORM,
)
}
fn storage_buffer(
&mut self,
id: usize,
size: u64,
init: Option<&[u32]>,
) -> Serial<wgpu::Buffer> {
if let Some(buffer) = self.storage_buffers.get(&id) {
return buffer.clone();
}
let buffer = self.device.create_buffer(&wgpu::BufferDescriptor {
label: Some("three-rs storage buffer"),
size,
usage: wgpu::BufferUsages::STORAGE
| wgpu::BufferUsages::VERTEX
| wgpu::BufferUsages::INDIRECT
| wgpu::BufferUsages::COPY_SRC
| wgpu::BufferUsages::COPY_DST,
mapped_at_creation: false,
});
if let Some(init) = init {
self.queue
.write_buffer(&buffer, 0, bytemuck::cast_slice(init));
}
let buffer = self.serial(buffer);
self.storage_buffers.insert(id, buffer.clone());
buffer
}
fn storage_buffer_for(
&mut self,
id: usize,
source: &BufferSource,
count: usize,
element_ty: Type,
) -> Serial<wgpu::Buffer> {
match source {
BufferSource::Struct { init, .. } | BufferSource::StorageData { init, .. } => {
self.storage_buffer(id, (init.len() * 4) as u64, Some(init))
}
_ => self.storage_buffer(id, (count * storage_stride(element_ty)) as u64, None),
}
}
fn indirect_buffer(
&mut self,
attribute: &crate::core::IndirectStorageBufferAttribute,
) -> Serial<wgpu::Buffer> {
let init = attribute.array();
self.storage_buffer(attribute.id().get(), (init.len() * 4) as u64, Some(&init))
}
pub fn read_indirect_buffer(
&mut self,
attribute: &crate::core::IndirectStorageBufferAttribute,
) -> Result<Vec<u32>, Error> {
let buffer = self.indirect_buffer(attribute).gpu;
let bytes = self.read_buffer(&buffer)?;
Ok(bytemuck::cast_slice(&bytes).to_vec())
}
fn instance_buffer(
&mut self,
slot: SlotKey,
buffer: &Rc<crate::nodes::node::InstanceBuffer>,
instance_matrix: &Option<InstancedBufferAttribute>,
instance_color: &Option<InstancedBufferAttribute>,
) -> wgpu::Buffer {
let id = buffer.id.get();
if buffer.source.is_storage() {
let size = (buffer.count * buffer.item_size * 4) as u64;
let init = match &buffer.source {
BufferSource::StorageData { init, .. } => Some(init.clone()),
_ => None,
};
return self
.storage_buffer(id, size, init.as_deref().map(|v| v.as_slice()))
.gpu;
}
self.buffer_for(
slot,
id,
&buffer.source,
buffer.count,
instance_matrix,
instance_color,
wgpu::BufferUsages::VERTEX,
)
.gpu
}
#[allow(clippy::too_many_arguments)]
fn buffer_for(
&mut self,
slot: SlotKey,
id: usize,
source: &BufferSource,
count: usize,
instance_matrix: &Option<InstancedBufferAttribute>,
instance_color: &Option<InstancedBufferAttribute>,
usage: wgpu::BufferUsages,
) -> Serial<wgpu::Buffer> {
match source {
BufferSource::MorphInfluences
| BufferSource::BoneMatrices
| BufferSource::CameraViewMatrices
| BufferSource::CameraProjectionMatrices
| BufferSource::Storage
| BufferSource::AtomicStorage
| BufferSource::Struct { .. }
| BufferSource::StorageData { .. }
| BufferSource::SkeletonBoneMatrices(_) => {
unreachable!("three-rs: this buffer source is resolved by node_buffer")
}
BufferSource::InstanceMatrix => {
let attribute = instance_matrix
.as_ref()
.expect("three-rs: instanceMatrix needs an InstancedMesh");
self.slot_buffer(
slot,
"three-rs instanceMatrix",
bytemuck::cast_slice(&attribute.array),
usage,
)
}
BufferSource::InstanceColor => {
let attribute = instance_color
.as_ref()
.expect("three-rs: instanceColor needs an InstancedMesh with setColorAt");
self.slot_buffer(
slot,
"three-rs instanceColor",
bytemuck::cast_slice(&attribute.array),
usage,
)
}
BufferSource::UniformArray(data) => {
let frames = self.node_frame.frame_id;
if let Some(entry) = self.buffers.get_mut(&id) {
entry.last_used = frames;
return entry.buffer.clone();
}
let buffer = self.create_buffer_init(
"three-rs uniformArray",
bytemuck::cast_slice(data.as_slice()),
usage,
);
let buffer = self.serial(buffer);
self.buffers.insert(
id,
BufferEntry {
buffer: buffer.clone(),
last_used: frames,
data: None,
},
);
buffer
}
BufferSource::Attribute(data) => {
let frames = self.node_frame.frame_id;
if let Some(entry) = self.buffers.get_mut(&id) {
if entry.data.as_ref().is_some_and(|d| Rc::ptr_eq(d, data)) {
entry.last_used = frames;
return entry.buffer.clone();
}
}
let buffer = self.create_buffer_init(
"three-rs instanced attribute",
bytemuck::cast_slice(data.as_slice()),
usage,
);
let buffer = self.serial(buffer);
self.buffers.insert(
id,
BufferEntry {
buffer: buffer.clone(),
last_used: frames,
data: Some(data.clone()),
},
);
buffer
}
BufferSource::Range { min, max } => {
let frames = self.node_frame.frame_id;
if let Some(entry) = self.buffers.get_mut(&id) {
entry.last_used = frames;
return entry.buffer.clone();
}
let (min, max) = (*min, *max);
let range = fill_range(&mut self.random, min, max, count);
let buffer = self.create_buffer_init(
"three-rs range()",
bytemuck::cast_slice(&range),
usage,
);
let buffer = self.serial(buffer);
self.buffers.insert(
id,
BufferEntry {
buffer: buffer.clone(),
last_used: frames,
data: None,
},
);
buffer
}
}
}
fn texture_view(
&mut self,
source: &TextureSource,
kind: TextureKind,
) -> Serial<wgpu::TextureView> {
let overridden = self.texture_override(source);
let source = overridden.as_ref().unwrap_or(source);
let storage = source.is_storage_binding();
let (id, gpu, dimension) = match source {
TextureSource::Texture2D(texture) => {
let gpu = self.ensure_texture_2d(texture);
self.update_storage_mipmaps(texture);
let dimension = texture
.is_array()
.then_some(wgpu::TextureViewDimension::D2Array);
(texture.id(), gpu, dimension)
}
TextureSource::Storage(texture, _) => {
assert!(matches!(kind, TextureKind::Storage { dim3: false, .. }));
let gpu = self.ensure_texture_2d(texture);
if let Some(entry) = self.textures_2d.get_mut(&texture.id()) {
entry.needs_mipmap = true;
}
(texture.id(), gpu, None)
}
TextureSource::Texture3D(data) | TextureSource::Storage3D(data, _) => {
let gpu = self.ensure_data3d_texture(data);
(data.id(), gpu, Some(wgpu::TextureViewDimension::D3))
}
TextureSource::Depth(depth) | TextureSource::ShadowMap(depth) => {
let gpu = depth
.inner()
.borrow()
.gpu
.clone()
.expect("three-rs: the depth texture has not been rendered into yet");
(depth.id(), gpu, None)
}
TextureSource::DataArray(data) => {
assert_eq!(kind, TextureKind::Float2DArray);
let gpu = self.ensure_data_array_texture(data);
(data.id(), gpu, Some(wgpu::TextureViewDimension::D2Array))
}
TextureSource::Data(data) => {
assert!(matches!(
kind,
TextureKind::FloatData2D | TextureKind::Uint2D
));
(data.id(), self.ensure_data_texture(data), None)
}
TextureSource::Cube(cube) => {
assert_eq!(kind, TextureKind::Cube);
let gpu = self.ensure_cube_texture(cube);
(cube.id(), gpu, Some(wgpu::TextureViewDimension::Cube))
}
TextureSource::CubeDepth(cube) => {
let gpu = cube
.inner()
.borrow()
.gpu
.clone()
.expect("three-rs: the shadow map has not been rendered into yet");
(cube.id(), gpu, Some(wgpu::TextureViewDimension::Cube))
}
};
let frames = self.node_frame.frame_id;
let key = (id, dimension, storage);
if let Some(entry) = self
.views
.get_mut(&key)
.and_then(|entries| entries.iter_mut().find(|entry| entry.texture == gpu))
{
entry.last_used = frames;
return entry.view.clone();
}
let view = gpu.create_view(&wgpu::TextureViewDescriptor {
dimension,
mip_level_count: storage.then_some(1),
..Default::default()
});
let view = self.serial(view);
self.views.entry(key).or_default().push(ViewEntry {
texture: gpu,
view: view.clone(),
last_used: frames,
owner: source.owner(),
});
view
}
fn texture_override(&self, source: &TextureSource) -> Option<TextureSource> {
match source {
TextureSource::Texture2D(texture) if !self.texture_overrides.is_empty() => self
.texture_overrides
.iter()
.find(|(id, _)| *id == texture.id())
.map(|(_, value)| TextureSource::Texture2D(value.clone())),
_ => None,
}
}
fn texture_sampler(&mut self, source: &TextureSource) -> Serial<wgpu::Sampler> {
let overridden = self.texture_override(source);
let source = overridden.as_ref().unwrap_or(source);
let key = SamplerKey::of(source);
if let Some(sampler) = self.samplers.get(&key) {
return sampler.clone();
}
let sampler = self.device.create_sampler(&key.descriptor());
let sampler = self.serial(sampler);
self.samplers.insert(key, sampler.clone());
sampler
}
fn update_storage_mipmaps(&mut self, texture: &Texture) {
if !texture.is_storage() {
return;
}
let mips = texture.mip_level_count();
let Some(entry) = self.textures_2d.get_mut(&texture.id()) else {
return;
};
if !entry.needs_mipmap || mips <= 1 {
return;
}
entry.needs_mipmap = false;
let gpu = entry.gpu.clone();
self.generate_mipmaps(&gpu, texture.format(), mips, 1);
}
fn ensure_data3d_texture(&mut self, texture: &Data3DTexture) -> wgpu::Texture {
let (width, height, depth) = texture.size();
let format = texture.format();
let storage = texture.is_storage();
if !texture.has_gpu() {
let mut usage = wgpu::TextureUsages::COPY_DST | wgpu::TextureUsages::TEXTURE_BINDING;
if storage {
self.assert_storage_format(format);
usage |= wgpu::TextureUsages::STORAGE_BINDING;
}
let gpu = self.device.create_texture(&wgpu::TextureDescriptor {
label: Some("three-rs data 3d texture"),
size: wgpu::Extent3d {
width,
height,
depth_or_array_layers: depth,
},
mip_level_count: 1,
sample_count: 1,
dimension: wgpu::TextureDimension::D3,
format,
usage,
view_formats: &[],
});
texture.set_gpu(gpu);
}
if texture.needs_upload() {
let bytes_per_texel = format
.block_copy_size(None)
.expect("three-rs: the 3D texture format has no single block size");
let gpu = texture.with_gpu(|gpu| gpu.clone());
let inner = texture.borrow();
let data = inner
.data
.as_ref()
.expect("three-rs: the Data3DTexture has no data");
self.queue.write_texture(
wgpu::TexelCopyTextureInfo {
texture: &gpu,
mip_level: 0,
origin: wgpu::Origin3d::ZERO,
aspect: wgpu::TextureAspect::All,
},
data,
wgpu::TexelCopyBufferLayout {
offset: 0,
bytes_per_row: Some(width * bytes_per_texel),
rows_per_image: Some(height),
},
wgpu::Extent3d {
width,
height,
depth_or_array_layers: depth,
},
);
drop(inner);
texture.mark_uploaded();
self.info.build.textures_uploaded += 1;
}
texture.with_gpu(|gpu| gpu.clone())
}
fn assert_storage_format(&self, format: wgpu::TextureFormat) {
let features = format.guaranteed_format_features(self.device.features());
assert!(
features
.allowed_usages
.contains(wgpu::TextureUsages::STORAGE_BINDING),
"three-rs: {format:?} cannot be a storage texture on this device"
);
}
fn background_geometry(&mut self) -> Rc<BufferGeometry> {
self.background_geometry
.get_or_insert_with(|| Rc::new(sphere_geometry(1.0, 32, 32)))
.clone()
}
fn quad_geometry(&mut self) -> Rc<BufferGeometry> {
self.quad_geometry
.get_or_insert_with(|| Rc::new(quad_geometry()))
.clone()
}
fn ensure_data_texture(&mut self, texture: &DataTexture) -> wgpu::Texture {
let (width, height) = texture.size();
let uint = texture.is_uint();
if !texture.has_gpu() {
let gpu = self.device.create_texture(&wgpu::TextureDescriptor {
label: Some("three-rs data texture"),
size: wgpu::Extent3d {
width,
height,
depth_or_array_layers: 1,
},
mip_level_count: 1,
sample_count: 1,
dimension: wgpu::TextureDimension::D2,
format: if uint {
wgpu::TextureFormat::R32Uint
} else {
wgpu::TextureFormat::Rgba32Float
},
usage: wgpu::TextureUsages::COPY_DST | wgpu::TextureUsages::TEXTURE_BINDING,
view_formats: &[],
});
texture.set_gpu(gpu);
}
if texture.needs_upload() {
let bytes_per_row = width * if uint { 4 } else { 16 };
let gpu = texture.with_gpu(|gpu| gpu.clone());
let inner = texture.borrow();
let bytes: &[u8] = match &inner.data {
DataTextureData::F32(v) => bytemuck::cast_slice(&v[..]),
DataTextureData::U32(v) => bytemuck::cast_slice(&v[..]),
};
self.queue.write_texture(
wgpu::TexelCopyTextureInfo {
texture: &gpu,
mip_level: 0,
origin: wgpu::Origin3d::ZERO,
aspect: wgpu::TextureAspect::All,
},
bytes,
wgpu::TexelCopyBufferLayout {
offset: 0,
bytes_per_row: Some(bytes_per_row),
rows_per_image: Some(height),
},
wgpu::Extent3d {
width,
height,
depth_or_array_layers: 1,
},
);
drop(inner);
texture.mark_uploaded();
self.info.build.textures_uploaded += 1;
}
texture.with_gpu(|gpu| gpu.clone())
}
fn ensure_data_array_texture(&mut self, texture: &DataArrayTexture) -> wgpu::Texture {
if texture.has_gpu() {
return texture.with_gpu(|gpu| gpu.clone());
}
let (width, height, depth) = texture.size();
let gpu = self.device.create_texture(&wgpu::TextureDescriptor {
label: Some("three-rs data array texture"),
size: wgpu::Extent3d {
width,
height,
depth_or_array_layers: depth,
},
mip_level_count: 1,
sample_count: 1,
dimension: wgpu::TextureDimension::D2,
format: wgpu::TextureFormat::Rgba32Float,
usage: wgpu::TextureUsages::COPY_DST | wgpu::TextureUsages::TEXTURE_BINDING,
view_formats: &[],
});
{
let inner = texture.borrow();
self.queue.write_texture(
wgpu::TexelCopyTextureInfo {
texture: &gpu,
mip_level: 0,
origin: wgpu::Origin3d::ZERO,
aspect: wgpu::TextureAspect::All,
},
bytemuck::cast_slice(&inner.data),
wgpu::TexelCopyBufferLayout {
offset: 0,
bytes_per_row: Some(width * 16),
rows_per_image: Some(height),
},
wgpu::Extent3d {
width,
height,
depth_or_array_layers: depth,
},
);
}
texture.set_gpu(gpu.clone());
self.info.build.textures_uploaded += 1;
gpu
}
fn ensure_texture_2d(&mut self, texture: &Texture) -> wgpu::Texture {
if !texture.borrow().own_gpu {
return texture.with_gpu(|gpu| gpu.clone());
}
let id = texture.id();
let version = texture.version();
let format = texture.format();
let mip_level_count = texture.mip_level_count();
if let Some(cached) = self.textures_2d.get(&id) {
if cached.version == version {
return cached.gpu.clone();
}
let gpu = cached.gpu.clone();
self.upload_texture_2d(&gpu, texture);
if mip_level_count > 1 && !texture.has_mipmaps() {
self.generate_mipmaps(&gpu, format, mip_level_count, 1);
}
self.textures_2d.insert(
id,
Texture2DEntry {
gpu: gpu.clone(),
version,
needs_mipmap: false,
owner: texture.owner(),
},
);
self.info.build.textures_uploaded += 1;
return gpu;
}
let (width, height) = texture.size();
if matches!(
format,
wgpu::TextureFormat::R32Float
| wgpu::TextureFormat::Rg32Float
| wgpu::TextureFormat::Rgba32Float
) {
assert!(
self.float32_filterable,
"three-rs: {format:?} needs wgpu::Features::FLOAT32_FILTERABLE, \
which this adapter does not expose"
);
}
let missing = format.required_features() - self.device.features();
assert!(
missing.is_empty(),
"three-rs: {format:?} needs {missing:?}, which this device does not have \
(see Ktx2Loader::detect_support)"
);
let has_mipmaps = texture.has_mipmaps();
let mut usage = wgpu::TextureUsages::COPY_DST
| wgpu::TextureUsages::COPY_SRC
| wgpu::TextureUsages::TEXTURE_BINDING;
if !has_mipmaps {
usage |= wgpu::TextureUsages::RENDER_ATTACHMENT;
}
let storage = texture.is_storage();
if storage {
self.assert_storage_format(format);
usage |= wgpu::TextureUsages::STORAGE_BINDING;
}
let gpu = self.device.create_texture(&wgpu::TextureDescriptor {
label: Some("three-rs texture"),
size: wgpu::Extent3d {
width,
height,
depth_or_array_layers: texture.borrow().depth.max(1),
},
mip_level_count,
sample_count: 1,
dimension: wgpu::TextureDimension::D2,
format,
usage,
view_formats: &[],
});
if !storage {
self.upload_texture_2d(&gpu, texture);
if mip_level_count > 1 && !has_mipmaps {
self.generate_mipmaps(&gpu, format, mip_level_count, 1);
}
}
texture.set_gpu(gpu.clone());
self.textures_2d.insert(
id,
Texture2DEntry {
gpu: gpu.clone(),
version,
needs_mipmap: false,
owner: texture.owner(),
},
);
self.info.build.textures_uploaded += 1;
self.info.memory.textures = self.textures_2d.len() + self.cube_textures.len();
gpu
}
fn upload_texture_2d(&self, gpu: &wgpu::Texture, texture: &Texture) {
let (width, height) = texture.size();
let format = texture.format();
let inner = texture.borrow();
let as_stored = format.block_dimensions() != (1, 1) || inner.depth > 0 || !inner.flip_y;
if !inner.mipmaps.is_empty() && as_stored {
drop(inner);
self.upload_mipmaps(gpu, texture);
return;
}
if !inner.mipmaps.is_empty() {
for (level, image) in inner.mipmaps.iter().enumerate() {
self.write_texture_level(
gpu,
format,
level as u32,
image.width,
image.height,
&image.data,
inner.flip_y,
);
}
return;
}
let data = inner
.data
.as_ref()
.expect("three-rs: the texture has no image data");
self.write_texture_level(gpu, format, 0, width, height, data, inner.flip_y);
}
#[allow(clippy::too_many_arguments)]
fn write_texture_level(
&self,
gpu: &wgpu::Texture,
format: wgpu::TextureFormat,
mip_level: u32,
width: u32,
height: u32,
data: &[u8],
flip_y: bool,
) {
let bytes_per_texel = format
.block_copy_size(None)
.expect("three-rs: the texture format has no single block size");
let rows: Vec<u8> = if flip_y {
let stride = (width * bytes_per_texel) as usize;
let mut flipped = Vec::with_capacity(data.len());
for row in (0..height as usize).rev() {
flipped.extend_from_slice(&data[row * stride..(row + 1) * stride]);
}
flipped
} else {
data.to_vec()
};
self.queue.write_texture(
wgpu::TexelCopyTextureInfo {
texture: gpu,
mip_level,
origin: wgpu::Origin3d::ZERO,
aspect: wgpu::TextureAspect::All,
},
&rows,
wgpu::TexelCopyBufferLayout {
offset: 0,
bytes_per_row: Some(width * bytes_per_texel),
rows_per_image: Some(height),
},
wgpu::Extent3d {
width,
height,
depth_or_array_layers: 1,
},
);
}
fn upload_mipmaps(&self, gpu: &wgpu::Texture, texture: &Texture) {
let inner = texture.borrow();
let format = inner.format;
let layers = inner.depth.max(1);
let (block_width, block_height) = format.block_dimensions();
let block_bytes = format
.block_copy_size(None)
.expect("three-rs: the texture format has no single block size");
for (level, mip) in inner.mipmaps.iter().enumerate() {
let blocks_x = mip.width.div_ceil(block_width);
let blocks_y = mip.height.div_ceil(block_height);
let bytes_per_row = blocks_x * block_bytes;
assert_eq!(
mip.data.len(),
(bytes_per_row * blocks_y * layers) as usize,
"three-rs: mip {level} of a {}x{} {format:?} texture has the wrong size",
mip.width,
mip.height
);
self.queue.write_texture(
wgpu::TexelCopyTextureInfo {
texture: gpu,
mip_level: level as u32,
origin: wgpu::Origin3d::ZERO,
aspect: wgpu::TextureAspect::All,
},
&mip.data,
wgpu::TexelCopyBufferLayout {
offset: 0,
bytes_per_row: Some(bytes_per_row),
rows_per_image: Some(blocks_y),
},
wgpu::Extent3d {
width: blocks_x * block_width,
height: blocks_y * block_height,
depth_or_array_layers: layers,
},
);
}
}
pub fn copy_texture_to_texture(
&mut self,
src_texture: &Texture,
dst_texture: &Texture,
src_region: Option<&crate::math::Box2>,
dst_position: Option<&Vector2>,
) {
let source = self.ensure_texture_2d(src_texture);
let destination = self.ensure_texture_2d(dst_texture);
let (mut src_x, mut src_y) = (0, 0);
let (mut src_width, mut src_height) = src_texture.size();
if let Some(region) = src_region {
src_x = region.min.x as u32;
src_y = region.min.y as u32;
src_width = (region.max.x - region.min.x) as u32;
src_height = (region.max.y - region.min.y) as u32;
}
let (dst_x, dst_y) = dst_position.map_or((0, 0), |p| (p.x as u32, p.y as u32));
let mut encoder = self
.device
.create_command_encoder(&wgpu::CommandEncoderDescriptor {
label: Some(&format!(
"copyTextureToTexture_{}_{}",
src_texture.id(),
dst_texture.id()
)),
});
encoder.copy_texture_to_texture(
wgpu::TexelCopyTextureInfo {
texture: &source,
mip_level: 0,
origin: wgpu::Origin3d {
x: src_x,
y: src_y,
z: 0,
},
aspect: wgpu::TextureAspect::All,
},
wgpu::TexelCopyTextureInfo {
texture: &destination,
mip_level: 0,
origin: wgpu::Origin3d {
x: dst_x,
y: dst_y,
z: 0,
},
aspect: wgpu::TextureAspect::All,
},
wgpu::Extent3d {
width: src_width,
height: src_height,
depth_or_array_layers: 1,
},
);
self.queue.submit([encoder.finish()]);
let mips = destination.mip_level_count();
if mips > 1 && dst_texture.borrow().generate_mipmaps {
self.generate_mipmaps(&destination, destination.format(), mips, 1);
}
}
pub(crate) fn copy_to_cube_layer(
&mut self,
source: &RenderTarget,
cube: &CubeTexture,
layer: u32,
mip: u32,
) {
let destination = self.ensure_cube_texture(cube);
let (width, height) = source.size();
let source = source.texture().with_gpu(|gpu| gpu.clone());
let mut encoder = self
.device
.create_command_encoder(&wgpu::CommandEncoderDescriptor {
label: Some("three-rs cube face copy"),
});
encoder.copy_texture_to_texture(
wgpu::TexelCopyTextureInfo {
texture: &source,
mip_level: 0,
origin: wgpu::Origin3d::ZERO,
aspect: wgpu::TextureAspect::All,
},
wgpu::TexelCopyTextureInfo {
texture: &destination,
mip_level: mip,
origin: wgpu::Origin3d {
x: 0,
y: 0,
z: layer,
},
aspect: wgpu::TextureAspect::All,
},
wgpu::Extent3d {
width,
height,
depth_or_array_layers: 1,
},
);
self.queue.submit([encoder.finish()]);
}
pub(crate) fn generate_cube_mipmaps(&mut self, cube: &CubeTexture) {
let gpu = self.ensure_cube_texture(cube);
let count = gpu.mip_level_count();
if count > 1 {
self.generate_mipmaps(&gpu, cube.gpu_format(), count, 6);
}
}
fn ensure_cube_texture(&mut self, texture: &CubeTexture) -> wgpu::Texture {
let id = texture.id();
if let Some(entry) = self.cube_textures.get(&id) {
return entry.gpu.clone();
}
let (width, height) = texture.size();
let format = texture.gpu_format();
let mip_level_count = texture.mip_level_count();
let gpu = self.device.create_texture(&wgpu::TextureDescriptor {
label: Some("three-rs cube texture"),
size: wgpu::Extent3d {
width,
height,
depth_or_array_layers: 6,
},
mip_level_count,
sample_count: 1,
dimension: wgpu::TextureDimension::D2,
format,
usage: wgpu::TextureUsages::COPY_DST
| wgpu::TextureUsages::COPY_SRC
| wgpu::TextureUsages::TEXTURE_BINDING
| wgpu::TextureUsages::RENDER_ATTACHMENT,
view_formats: &[],
});
let bytes_per_texel = format
.block_copy_size(None)
.expect("three-rs: the cube texture format has no single block size");
let has_mipmaps = {
let inner = texture.inner().borrow();
assert!(!inner.flip_y, "three-rs: CubeTexture.flipY is false");
for (layer, image) in inner.images.iter().enumerate() {
if image.data.is_empty() {
continue;
}
write_face(&self.queue, &gpu, 0, layer as u32, image, bytes_per_texel);
for (j, level) in inner.mipmaps.iter().enumerate() {
write_face(
&self.queue,
&gpu,
j as u32 + 1,
layer as u32,
&level[layer],
bytes_per_texel,
);
}
}
!inner.mipmaps.is_empty()
};
let is_render_target = texture.inner().borrow().images[0].data.is_empty();
if mip_level_count > 1 && !has_mipmaps && !is_render_target {
self.generate_mipmaps(&gpu, format, mip_level_count, 6);
}
texture.inner().borrow_mut().gpu = Some(gpu.clone());
self.cube_textures.insert(
id,
CubeTextureEntry {
gpu: gpu.clone(),
owner: texture.owner(),
},
);
self.info.build.textures_uploaded += 1;
self.info.memory.textures = self.textures_2d.len() + self.cube_textures.len();
gpu
}
fn generate_mipmaps(
&mut self,
texture: &wgpu::Texture,
format: wgpu::TextureFormat,
mip_level_count: u32,
layers: u32,
) {
if !self.mipmap_pipelines.contains_key(&format) {
let pipeline = create_mipmap_pipeline(&self.device, &self.mipmap_shader, format);
self.mipmap_pipelines.insert(format, pipeline);
}
let pipeline = &self.mipmap_pipelines[&format];
let sampler = self.device.create_sampler(&wgpu::SamplerDescriptor {
label: Some("three-rs mipmap sampler"),
min_filter: wgpu::FilterMode::Linear,
..Default::default()
});
let flip = self.create_buffer_init(
"three-rs mipmap noFlip",
bytemuck::cast_slice(&[0u32]),
wgpu::BufferUsages::UNIFORM,
);
let mut encoder = self
.device
.create_command_encoder(&wgpu::CommandEncoderDescriptor {
label: Some("three-rs mipmapEncoder"),
});
for base_mip_level in 1..mip_level_count {
for base_array_layer in 0..layers {
let source = texture.create_view(&wgpu::TextureViewDescriptor {
label: None,
format: None,
dimension: Some(wgpu::TextureViewDimension::D2Array),
usage: None,
aspect: wgpu::TextureAspect::All,
base_mip_level: base_mip_level - 1,
mip_level_count: Some(1),
base_array_layer: 0,
array_layer_count: None,
});
let destination = texture.create_view(&wgpu::TextureViewDescriptor {
label: None,
format: None,
dimension: Some(wgpu::TextureViewDimension::D2),
usage: None,
aspect: wgpu::TextureAspect::All,
base_mip_level,
mip_level_count: Some(1),
base_array_layer,
array_layer_count: Some(1),
});
let bind_group = self.device.create_bind_group(&wgpu::BindGroupDescriptor {
label: None,
layout: &self.mipmap_shader.layout,
entries: &[
wgpu::BindGroupEntry {
binding: 0,
resource: wgpu::BindingResource::Sampler(&sampler),
},
wgpu::BindGroupEntry {
binding: 1,
resource: wgpu::BindingResource::TextureView(&source),
},
wgpu::BindGroupEntry {
binding: 2,
resource: flip.as_entire_binding(),
},
],
});
let mut pass = encoder.begin_render_pass(&wgpu::RenderPassDescriptor {
label: None,
color_attachments: &[Some(wgpu::RenderPassColorAttachment {
view: &destination,
depth_slice: None,
resolve_target: None,
ops: wgpu::Operations {
load: wgpu::LoadOp::Clear(wgpu::Color::TRANSPARENT),
store: wgpu::StoreOp::Store,
},
})],
depth_stencil_attachment: None,
occlusion_query_set: None,
timestamp_writes: None,
multiview_mask: None,
});
pass.set_pipeline(pipeline);
pass.set_bind_group(0, &bind_group, &[]);
pass.draw(0..3, base_array_layer..base_array_layer + 1);
}
}
self.queue.submit(Some(encoder.finish()));
}
fn ensure_pipeline(&mut self, key: PipelineKey) {
if !self.pipelines.contains_key(&key) {
let pipeline = self.programs[&key.program].create_pipeline(&self.device, key.state);
self.pipelines.insert(key, pipeline);
self.info.build.pipelines_built += 1;
}
}
fn ensure_geometry(&mut self, geometry: &Rc<BufferGeometry>) {
let id = geometry.id();
if self.geometries.contains_key(&id) {
self.refresh_geometry(geometry);
return;
}
let owner = Rc::downgrade(geometry);
let vertex_buffer = |attribute: &crate::core::BufferAttribute| {
self.create_buffer_init(
"three-rs attribute",
&attribute_bytes(attribute),
wgpu::BufferUsages::VERTEX,
)
};
let position = geometry.position().map(vertex_buffer);
let normal = geometry.normal().map(vertex_buffer);
let uv = geometry.uv().map(vertex_buffer);
let other: Vec<(String, wgpu::Buffer)> = geometry
.attributes()
.filter(|(name, _)| !matches!(*name, "position" | "normal" | "uv"))
.map(|(name, attribute)| (name.to_string(), vertex_buffer(attribute)))
.collect();
let index = geometry.index.as_ref().map(|index| {
let (bytes, format): (Vec<u8>, wgpu::IndexFormat) = match index {
Index::U16(v) => (bytemuck::cast_slice(v).to_vec(), wgpu::IndexFormat::Uint16),
Index::U32(v) => (bytemuck::cast_slice(v).to_vec(), wgpu::IndexFormat::Uint32),
};
let buffer =
self.create_buffer_init("three-rs index", &bytes, wgpu::BufferUsages::INDEX);
(buffer, format, index.count() as u32)
});
let vertex_count = geometry.position().map(|p| p.count() as u32).unwrap_or(0);
let versions = UPLOADED_ATTRIBUTES.map(|name| {
geometry
.get_attribute(name)
.map(|attribute| attribute.version())
.unwrap_or(0)
});
self.info.build.geometries_uploaded += 1;
self.info.build.buffers_written += [
position.is_some(),
normal.is_some(),
uv.is_some(),
index.is_some(),
]
.iter()
.filter(|written| **written)
.count() as u64
+ other.len() as u64;
self.geometries.insert(
id,
GeometryEntry {
gpu: GeometryGpu {
position,
normal,
uv,
other,
index,
wireframe_index: None,
vertex_count,
versions,
},
owner,
},
);
self.info.memory.geometries = self.geometries.len();
}
fn ensure_wireframe_index(&mut self, geometry: &Rc<BufferGeometry>) {
let id = geometry.id();
if self.geometries[&id].gpu.wireframe_index.is_some() {
return;
}
let vertex_count = geometry.position().map(|p| p.count()).unwrap_or(0);
let source: Option<Vec<u32>> = geometry.index.as_ref().map(|index| match index {
Index::U16(v) => v.iter().map(|&i| u32::from(i)).collect(),
Index::U32(v) => v.clone(),
});
let count = match &source {
Some(array) => array.len(),
None => vertex_count.saturating_sub(1),
};
let mut indices: Vec<u32> = vec![0; count.div_ceil(3) * 6];
let mut j = 0;
let mut i = 0;
while i < count {
let (a, b, c) = match &source {
Some(array) => (
array[i],
array.get(i + 1).copied().unwrap_or(0),
array.get(i + 2).copied().unwrap_or(0),
),
None => (i as u32, i as u32 + 1, i as u32 + 2),
};
indices[j..j + 6].copy_from_slice(&[a, b, b, c, c, a]);
j += 6;
i += 3;
}
let (bytes, format) = (
bytemuck::cast_slice(&indices).to_vec(),
wgpu::IndexFormat::Uint32,
);
let buffer = self.create_buffer_init(
"three-rs wireframe index",
&bytes,
wgpu::BufferUsages::INDEX,
);
self.info.build.buffers_written += 1;
self.geometries.get_mut(&id).unwrap().gpu.wireframe_index =
Some((buffer, format, indices.len() as u32));
}
fn refresh_geometry(&mut self, geometry: &Rc<BufferGeometry>) {
let id = geometry.id();
for (slot, name) in UPLOADED_ATTRIBUTES.iter().enumerate() {
let Some(attribute) = geometry.get_attribute(name) else {
continue;
};
let version = attribute.version();
let entry = &self.geometries[&id];
if entry.gpu.versions[slot] == version {
continue;
}
let Some(buffer) = entry.gpu.slot(slot).cloned() else {
continue;
};
let bytes = attribute_bytes(attribute);
let bytes: &[u8] = &bytes;
if buffer.size() == bytes.len() as u64 {
self.queue.write_buffer(&buffer, 0, bytes);
} else {
let buffer = self.create_buffer_init(
"three-rs attribute",
bytes,
wgpu::BufferUsages::VERTEX,
);
let gpu = &mut self
.geometries
.get_mut(&id)
.expect("three-rs: the entry was found above")
.gpu;
gpu.set_slot(slot, buffer);
}
let gpu = &mut self
.geometries
.get_mut(&id)
.expect("three-rs: the entry was found above")
.gpu;
gpu.versions[slot] = version;
if *name == "position" {
gpu.vertex_count = attribute.count() as u32;
}
self.info.build.buffers_written += 1;
}
}
fn begin_frame(&mut self) -> (u64, bool) {
let to_screen = self.render_target.is_none() && self.call_depth == 0;
self.call_depth += 1;
let previous = self.node_frame.begin_render(crate::utils::now_ms());
self.sweep_caches();
(previous, to_screen)
}
fn end_frame(&mut self, (previous, to_screen): (u64, bool)) {
self.call_depth -= 1;
self.node_frame.end_render(previous, to_screen);
}
pub fn node_frame(&self) -> &crate::nodes::NodeFrameState {
&self.node_frame
}
pub(crate) fn update_before_node(&mut self, entry: &crate::nodes::UpdateNode) {
use crate::nodes::frame::UpdatePhase;
let ty = entry.node.update_before_type();
if let Some(claim) = self
.node_frame
.claim(UpdatePhase::Before, entry.reference, ty)
{
let counted = entry.node.update_before(self);
self.node_frame.settle(claim, counted);
}
}
pub(crate) fn update_node(&mut self, entry: &crate::nodes::UpdateNode) {
use crate::nodes::frame::UpdatePhase;
let ty = entry.node.update_type();
if let Some(claim) = self
.node_frame
.claim(UpdatePhase::Update, entry.reference, ty)
{
let counted = entry.node.update(self);
self.node_frame.settle(claim, counted);
}
}
pub(crate) fn update_after_node(&mut self, entry: &crate::nodes::UpdateNode) {
use crate::nodes::frame::UpdatePhase;
let ty = entry.node.update_after_type();
if let Some(claim) = self
.node_frame
.claim(UpdatePhase::After, entry.reference, ty)
{
let counted = entry.node.update_after(self);
self.node_frame.settle(claim, counted);
}
}
fn sweep_caches(&mut self) {
self.geometries
.retain(|_, entry| entry.owner.strong_count() > 0);
self.info.memory.geometries = self.geometries.len();
let cutoff = self.node_frame.frame_id.saturating_sub(CACHE_GRACE_FRAMES);
self.node_frame.sweep(CACHE_GRACE_FRAMES);
self.node_builder_states
.retain(|_, states| states.last_used >= cutoff);
self.buffers.retain(|_, entry| entry.last_used >= cutoff);
let frames = self.node_frame.frame_id;
self.slot_buffers
.retain(|_, entry| bindings::is_fresh(entry.last_used, frames));
self.textures_2d
.retain(|_, entry| entry.owner.strong_count() > 0);
self.cube_textures
.retain(|_, entry| entry.owner.strong_count() > 0);
self.info.memory.textures = self.textures_2d.len() + self.cube_textures.len();
let mut orphaned = HashSet::new();
self.views.retain(|_, entries| {
entries.retain(|entry| {
if entry.owner.strong_count() == 0 {
orphaned.insert(entry.view.serial);
return false;
}
bindings::is_fresh(entry.last_used, frames)
});
!entries.is_empty()
});
self.bind_group_cache.retain(|key, entry| {
bindings::is_fresh(entry.last_used, frames)
&& (orphaned.is_empty() || !key.binds_any(&orphaned))
});
}
#[doc(hidden)]
pub fn geometry_cache_len(&self) -> usize {
self.geometries.len()
}
#[doc(hidden)]
pub fn material_cache_len(&self) -> usize {
self.node_builder_states.len()
}
#[doc(hidden)]
pub fn buffer_cache_len(&self) -> usize {
self.buffers.len()
}
#[doc(hidden)]
pub fn binding_cache_lens(&self) -> (usize, usize, usize) {
(
self.slot_buffers.len(),
self.views.values().map(Vec::len).sum(),
self.bind_group_cache.len(),
)
}
fn slot_buffer(
&mut self,
slot: SlotKey,
label: &str,
contents: &[u8],
usage: wgpu::BufferUsages,
) -> Serial<wgpu::Buffer> {
let frames = self.node_frame.frame_id;
let bytes = bindings::padded(contents);
if let Some(entry) = self.slot_buffers.get_mut(&slot) {
if entry.usage == usage && entry.buffer.gpu.size() >= bytes.len() as u64 {
entry.last_used = frames;
self.queue.write_buffer(&entry.buffer.gpu, 0, &bytes);
return entry.buffer.clone();
}
}
let buffer = self.create_buffer_init(label, &bytes, usage);
let buffer = self.serial(buffer);
self.slot_buffers.insert(
slot,
SlotBuffer {
buffer: buffer.clone(),
usage,
last_used: frames,
},
);
buffer
}
fn create_buffer_init(
&self,
label: &str,
contents: &[u8],
usage: wgpu::BufferUsages,
) -> wgpu::Buffer {
let mut padded = contents.to_vec();
while !padded.len().is_multiple_of(4) {
padded.push(0);
}
let buffer = self.device.create_buffer(&wgpu::BufferDescriptor {
label: Some(label),
size: padded.len() as u64,
usage: usage | wgpu::BufferUsages::COPY_DST,
mapped_at_creation: false,
});
self.queue.write_buffer(&buffer, 0, &padded);
buffer
}
fn needs_frame_buffer_target(&self) -> bool {
!self.neutral_output && self.output_color_space != crate::math::ColorSpace::LinearSrgb
}
pub fn set_output_color_space(&mut self, color_space: crate::math::ColorSpace) {
self.output_color_space = color_space;
}
pub(crate) fn with_neutral_output<R>(&mut self, f: impl FnOnce(&mut Self) -> R) -> R {
let previous = std::mem::replace(&mut self.neutral_output, true);
let result = f(self);
self.neutral_output = previous;
result
}
pub(crate) fn set_output_hook(
&mut self,
hook: Option<crate::materials::OutputContext>,
) -> Option<crate::materials::OutputContext> {
std::mem::replace(&mut self.output_hook, hook)
}
pub fn samples(&self) -> u32 {
self.samples
}
pub fn render_target(&self) -> Option<RenderTarget> {
self.render_target.clone()
}
fn current_samples(&self) -> u32 {
match &self.render_target {
Some(render_target) => render_target.samples(),
None => {
if self.needs_frame_buffer_target() || self.fullscreen_pass {
0
} else {
self.samples
}
}
}
}
fn opaque_frame_texture(&mut self, width: u32, height: u32) -> Texture {
let format = self.output_buffer_type.color_gpu_format();
let existing = self
.opaque_frame
.as_ref()
.filter(|texture| texture.size() == (width, height) && texture.format() == format);
if let Some(texture) = existing {
return texture.clone();
}
let mip_level_count = (width.max(height) as f32).log2().floor() as u32 + 1;
let gpu = self.device.create_texture(&wgpu::TextureDescriptor {
label: Some("three-rs viewportOpaqueMipTexture"),
size: wgpu::Extent3d {
width,
height,
depth_or_array_layers: 1,
},
mip_level_count,
sample_count: 1,
dimension: wgpu::TextureDimension::D2,
format,
usage: wgpu::TextureUsages::COPY_DST
| wgpu::TextureUsages::TEXTURE_BINDING
| wgpu::TextureUsages::RENDER_ATTACHMENT,
view_formats: &[],
});
let texture = Texture::render_target(width, height, format);
texture.set_generate_mipmaps(true);
texture.set_min_filter(crate::textures::MinFilter::LinearMipmapLinear);
texture.set_gpu(gpu);
self.opaque_frame = Some(texture.clone());
texture
}
fn copy_framebuffer_to_opaque_frame(&mut self, source: &wgpu::Texture) {
let Some(texture) = self.opaque_frame.clone() else {
return;
};
let gpu = texture.with_gpu(|gpu| gpu.clone());
let mut encoder = self
.device
.create_command_encoder(&wgpu::CommandEncoderDescriptor {
label: Some("three-rs copyFramebufferToTexture"),
});
encoder.copy_texture_to_texture(
source.as_image_copy(),
gpu.as_image_copy(),
wgpu::Extent3d {
width: gpu.width().min(source.width()),
height: gpu.height().min(source.height()),
depth_or_array_layers: 1,
},
);
self.queue.submit(Some(encoder.finish()));
let format = gpu.format();
let mips = gpu.mip_level_count();
if mips > 1 {
self.generate_mipmaps(&gpu, format, mips, 1);
}
}
fn frame_buffer_target(&mut self) -> RenderTarget {
let (width, height) = self.drawing_buffer_size();
let target = self.frame_buffer_target.get_or_insert_with(|| {
RenderTarget::new_with_options(
width,
height,
RenderTargetOptions {
texture_type: self.output_buffer_type,
samples: self.samples,
depth_buffer: true,
min_filter: TextureFilter::Linear,
mag_filter: TextureFilter::Linear,
},
)
.expect("three-rs: the output buffer type is a colour type")
});
target.set_size(width, height);
target.clone()
}
fn render_target_pass(&self, render_target: &RenderTarget) -> PassTarget {
self.prepare_render_target(render_target);
let inner = render_target.inner().borrow();
let color_format = inner.texture.format();
let single = inner
.texture
.with_gpu(|gpu| gpu.create_view(&Default::default()));
let (color, resolve) = match &inner.msaa {
Some(msaa) => (msaa.create_view(&Default::default()), Some(single)),
None => (single, None),
};
let extra_colors: Vec<(wgpu::TextureView, Option<wgpu::TextureView>)> = inner
.extra_textures
.iter()
.enumerate()
.map(|(index, (_, texture))| {
let single = texture.with_gpu(|gpu| gpu.create_view(&Default::default()));
match inner.msaa_extra.get(index) {
Some(msaa) => (msaa.create_view(&Default::default()), Some(single)),
None => (single, None),
}
})
.collect();
let extra_color_targets: Vec<ExtraColorTarget> = inner
.extra_textures
.iter()
.map(|(name, texture)| ExtraColorTarget {
format: texture.format(),
blend: self
.mrt
.as_ref()
.and_then(|mrt| mrt.blend_mode(name))
.and_then(|blending| {
materials::blending::blending(&materials::BlendMode {
blending,
..Default::default()
})
}),
})
.collect();
let (depth, depth_format) = match (&inner.depth_texture, &inner.depth) {
(Some(depth_texture), _) => (
Some(
depth_texture
.inner()
.borrow()
.gpu
.as_ref()
.expect("three-rs: prepare_render_target() created the depth texture")
.create_view(&Default::default()),
),
Some(depth_texture.gpu_format()),
),
(None, Some(depth)) => (
Some(depth.create_view(&Default::default())),
Some(CANVAS_DEPTH_FORMAT),
),
(None, None) => (None, None),
};
PassTarget {
color,
extra_colors,
extra_color_targets,
resolve,
color_texture: Some(inner.texture.with_gpu(|gpu| gpu.clone())),
depth,
color_format,
depth_format,
sample_count: inner.samples.max(1),
width: inner.width,
height: inner.height,
viewport: Rect::of(inner.viewport, 1.0, inner.width, inner.height),
scissor: inner
.scissor_test
.then(|| Rect::of(inner.scissor, 1.0, inner.width, inner.height)),
}
}
fn canvas_pass(&mut self, needs_depth: bool) -> PassTarget {
let sample_count = self.current_samples().max(1);
self.prepare_canvas(needs_depth, sample_count);
let (viewport, scissor, scissor_test, pixel_ratio) = (
self.viewport,
self.scissor,
self.scissor_test,
self.pixel_ratio,
);
let canvas = self
.canvas
.as_ref()
.expect("three-rs: prepare_canvas() has just created the canvas");
let (color, resolve) = match &canvas.msaa {
Some(msaa) => (
msaa.create_view(&Default::default()),
Some(canvas.color.create_view(&Default::default())),
),
None => (canvas.color.create_view(&Default::default()), None),
};
let depth = canvas
.depth
.as_ref()
.map(|d| d.create_view(&Default::default()));
PassTarget {
color,
extra_colors: Vec::new(),
extra_color_targets: Vec::new(),
resolve,
color_texture: Some(canvas.color.clone()),
depth: depth.clone(),
color_format: CANVAS_FORMAT,
depth_format: depth.map(|_| CANVAS_DEPTH_FORMAT),
sample_count: canvas.sample_count,
width: canvas.width,
height: canvas.height,
viewport: Rect::of(viewport, pixel_ratio, canvas.width, canvas.height),
scissor: scissor_test
.then(|| Rect::of(scissor, pixel_ratio, canvas.width, canvas.height)),
}
}
fn prepare_canvas(&mut self, needs_depth: bool, sample_count: u32) {
let (width, height) = self.drawing_buffer_size();
if let Some(canvas) = &self.canvas {
if canvas.width == width
&& canvas.height == height
&& canvas.sample_count == sample_count
{
if needs_depth && canvas.depth.is_none() {
let depth = self.create_depth_buffer(width, height, sample_count);
self.canvas
.as_mut()
.expect("three-rs: the canvas is Some in this branch")
.depth = Some(depth);
}
return;
}
}
let color = self.device.create_texture(&wgpu::TextureDescriptor {
label: Some("three-rs canvas"),
size: wgpu::Extent3d {
width,
height,
depth_or_array_layers: 1,
},
mip_level_count: 1,
sample_count: 1,
dimension: wgpu::TextureDimension::D2,
format: CANVAS_FORMAT,
usage: wgpu::TextureUsages::RENDER_ATTACHMENT
| wgpu::TextureUsages::COPY_SRC
| wgpu::TextureUsages::TEXTURE_BINDING,
view_formats: &[],
});
let msaa = (sample_count > 1).then(|| {
self.device.create_texture(&wgpu::TextureDescriptor {
label: Some("three-rs canvas msaa"),
size: wgpu::Extent3d {
width,
height,
depth_or_array_layers: 1,
},
mip_level_count: 1,
sample_count,
dimension: wgpu::TextureDimension::D2,
format: CANVAS_FORMAT,
usage: wgpu::TextureUsages::RENDER_ATTACHMENT,
view_formats: &[],
})
});
let depth = needs_depth.then(|| self.create_depth_buffer(width, height, sample_count));
self.canvas = Some(CanvasTarget {
width,
height,
sample_count,
color,
msaa,
depth,
});
}
fn create_depth_buffer(&self, width: u32, height: u32, sample_count: u32) -> wgpu::Texture {
self.device.create_texture(&wgpu::TextureDescriptor {
label: Some("three-rs depth buffer"),
size: wgpu::Extent3d {
width,
height,
depth_or_array_layers: 1,
},
mip_level_count: 1,
sample_count,
dimension: wgpu::TextureDimension::D2,
format: CANVAS_DEPTH_FORMAT,
usage: wgpu::TextureUsages::RENDER_ATTACHMENT,
view_formats: &[],
})
}
fn prepare_render_target(&self, render_target: &RenderTarget) {
let mut inner = render_target.inner().borrow_mut();
let (width, height) = (inner.width, inner.height);
let sample_count = inner.samples.max(1);
let format = inner.texture.format();
if !inner.texture.has_gpu() {
inner
.texture
.set_gpu(self.device.create_texture(&wgpu::TextureDescriptor {
label: Some("three-rs render target"),
size: wgpu::Extent3d {
width,
height,
depth_or_array_layers: 1,
},
mip_level_count: 1,
sample_count: 1,
dimension: wgpu::TextureDimension::D2,
format,
usage: wgpu::TextureUsages::RENDER_ATTACHMENT
| wgpu::TextureUsages::TEXTURE_BINDING
| wgpu::TextureUsages::COPY_SRC,
view_formats: &[],
}));
}
for (name, texture) in inner.extra_textures.iter().chain(&inner.previous_textures) {
if !texture.has_gpu() {
texture.set_gpu(self.device.create_texture(&wgpu::TextureDescriptor {
label: Some("three-rs render target attachment"),
size: wgpu::Extent3d {
width,
height,
depth_or_array_layers: 1,
},
mip_level_count: 1,
sample_count: 1,
dimension: wgpu::TextureDimension::D2,
format: texture.format(),
usage: wgpu::TextureUsages::RENDER_ATTACHMENT
| wgpu::TextureUsages::TEXTURE_BINDING
| wgpu::TextureUsages::COPY_SRC,
view_formats: &[],
}));
let _ = name;
}
}
if sample_count > 1 && inner.msaa.is_none() {
inner.msaa = Some(self.device.create_texture(&wgpu::TextureDescriptor {
label: Some("three-rs render target msaa"),
size: wgpu::Extent3d {
width,
height,
depth_or_array_layers: 1,
},
mip_level_count: 1,
sample_count,
dimension: wgpu::TextureDimension::D2,
format,
usage: wgpu::TextureUsages::RENDER_ATTACHMENT,
view_formats: &[],
}));
}
if sample_count > 1 && inner.msaa_extra.len() != inner.extra_textures.len() {
inner.msaa_extra = inner
.extra_textures
.iter()
.map(|(_, texture)| {
self.device.create_texture(&wgpu::TextureDescriptor {
label: Some("three-rs render target attachment msaa"),
size: wgpu::Extent3d {
width,
height,
depth_or_array_layers: 1,
},
mip_level_count: 1,
sample_count,
dimension: wgpu::TextureDimension::D2,
format: texture.format(),
usage: wgpu::TextureUsages::RENDER_ATTACHMENT,
view_formats: &[],
})
})
.collect();
}
if inner.depth_texture.is_none() && inner.depth_buffer && inner.depth.is_none() {
inner.depth = Some(self.create_depth_buffer(width, height, sample_count));
}
if let Some(depth_texture) = &inner.depth_texture {
let format = depth_texture.gpu_format();
let mut depth = depth_texture.inner().borrow_mut();
if depth.gpu.is_none() {
depth.width = width;
depth.height = height;
depth.gpu = Some(self.device.create_texture(&wgpu::TextureDescriptor {
label: Some("three-rs depth texture"),
size: wgpu::Extent3d {
width,
height,
depth_or_array_layers: 1,
},
mip_level_count: 1,
sample_count,
dimension: wgpu::TextureDimension::D2,
format,
usage: wgpu::TextureUsages::RENDER_ATTACHMENT
| wgpu::TextureUsages::TEXTURE_BINDING,
view_formats: &[],
}));
}
}
}
}
struct PendingReadback {
buffer: wgpu::Buffer,
width: u32,
height: u32,
bytes_per_row: u32,
unpadded_bytes_per_row: u32,
}
impl PendingReadback {
fn finish(self) -> Result<(u32, u32, Vec<u8>), Error> {
let slice = self.buffer.slice(..);
let padded = slice
.get_mapped_range()
.map_err(|e| Error::Readback {
reason: e.to_string(),
})?
.to_vec();
self.buffer.unmap();
let mut data = Vec::with_capacity((self.unpadded_bytes_per_row * self.height) as usize);
for row in 0..self.height {
let start = (row * self.bytes_per_row) as usize;
data.extend_from_slice(&padded[start..start + self.unpadded_bytes_per_row as usize]);
}
Ok((self.width, self.height, data))
}
}
#[cfg(target_arch = "wasm32")]
#[derive(Default)]
struct MapFuture {
#[allow(clippy::type_complexity)]
state: std::rc::Rc<
std::cell::RefCell<(
Option<Result<(), wgpu::BufferAsyncError>>,
Option<std::task::Waker>,
)>,
>,
}
#[cfg(target_arch = "wasm32")]
impl std::future::Future for MapFuture {
type Output = Result<(), wgpu::BufferAsyncError>;
fn poll(
self: std::pin::Pin<&mut Self>,
cx: &mut std::task::Context<'_>,
) -> std::task::Poll<Self::Output> {
let mut state = self.state.borrow_mut();
match state.0.take() {
Some(result) => std::task::Poll::Ready(result),
None => {
state.1 = Some(cx.waker().clone());
std::task::Poll::Pending
}
}
}
}
const CANVAS_FORMAT: wgpu::TextureFormat = wgpu::TextureFormat::Rgba8Unorm;
const CANVAS_DEPTH_FORMAT: wgpu::TextureFormat = wgpu::TextureFormat::Depth24Plus;
fn write_face(
queue: &wgpu::Queue,
gpu: &wgpu::Texture,
mip_level: u32,
layer: u32,
image: &crate::textures::Image,
bytes_per_texel: u32,
) {
queue.write_texture(
wgpu::TexelCopyTextureInfo {
texture: gpu,
mip_level,
origin: wgpu::Origin3d {
x: 0,
y: 0,
z: layer,
},
aspect: wgpu::TextureAspect::All,
},
&image.data,
wgpu::TexelCopyBufferLayout {
offset: 0,
bytes_per_row: Some(image.width * bytes_per_texel),
rows_per_image: Some(image.height),
},
wgpu::Extent3d {
width: image.width,
height: image.height,
depth_or_array_layers: 1,
},
);
}
#[cfg(target_arch = "wasm32")]
async fn pick_adapter(instance: &wgpu::Instance) -> Result<wgpu::Adapter, Error> {
instance
.request_adapter(&wgpu::RequestAdapterOptions::default())
.await
.map_err(|_| Error::NoAdapter { wanted: None })
}
#[cfg(not(target_arch = "wasm32"))]
async fn pick_adapter(instance: &wgpu::Instance) -> Result<wgpu::Adapter, Error> {
let wanted = std::env::var("THREE_RS_ADAPTER_NAME").ok();
let adapters = instance.enumerate_adapters(BACKENDS).await;
if let Some(wanted) = &wanted {
if let Some(adapter) = adapters
.iter()
.find(|a| a.get_info().name.contains(wanted.as_str()))
{
return Ok(adapter.clone());
}
return Err(Error::NoAdapter {
wanted: Some(wanted.clone()),
});
}
if let Some(adapter) = adapters
.iter()
.find(|a| a.get_info().device_type == wgpu::DeviceType::IntegratedGpu)
{
return Ok(adapter.clone());
}
if let Some(adapter) = adapters
.iter()
.find(|a| a.get_info().device_type == wgpu::DeviceType::DiscreteGpu)
{
return Ok(adapter.clone());
}
adapters
.into_iter()
.next()
.ok_or(Error::NoAdapter { wanted: None })
}
fn attribute_bytes(attribute: &crate::core::BufferAttribute) -> Vec<u8> {
let array = attribute.array();
if attribute.integer() {
let indices: Vec<u32> = array.iter().map(|v| *v as u32).collect();
bytemuck::cast_slice(&indices).to_vec()
} else {
bytemuck::cast_slice(array.as_slice()).to_vec()
}
}
#[doc(hidden)]
pub fn fill_range(
random: &mut DeterministicRandom,
min: [f64; 4],
max: [f64; 4],
count: usize,
) -> Vec<f32> {
let stride = 4usize;
let mut range = vec![0f32; stride * count];
for (i, value) in range.iter_mut().enumerate() {
let index = i % stride;
let t = random.next();
*value = ((1.0 - t) * min[index] + t * max[index]) as f32;
}
range
}
fn hash_of(value: &impl std::hash::Hash) -> u64 {
use std::hash::Hasher;
let mut hasher = std::collections::hash_map::DefaultHasher::new();
value.hash(&mut hasher);
hasher.finish()
}
fn storage_stride(element_ty: Type) -> usize {
match element_ty.components() {
3 => 16,
n => n * 4,
}
}
fn compute_flow_key(flow: &ComputeFlow) -> u64 {
use std::hash::{Hash, Hasher};
let mut hasher = std::collections::hash_map::DefaultHasher::new();
for stmt in &flow.statements {
stmt.key().hash(&mut hasher);
}
flow.count.hash(&mut hasher);
flow.workgroup_size.hash(&mut hasher);
flow.name.hash(&mut hasher);
hasher.finish()
}
fn warn_unsupported(id: usize, material: &MeshBasicNodeMaterial, setup: &SetupContext) {
thread_local! {
static WARNED: std::cell::RefCell<std::collections::HashSet<(usize, &'static str)>> =
std::cell::RefCell::new(std::collections::HashSet::new());
}
let mut fields = material.unsupported_fields();
let direct_light = setup.lights.iter().any(|light| {
matches!(
light.kind,
LightKind::Point | LightKind::Spot | LightKind::Directional
)
});
if material.kind == materials::MaterialKind::Physical
&& material.anisotropy > 0.0
&& direct_light
&& material.lights
{
fields.push("anisotropy (under a direct light)");
}
if material.kind == materials::MaterialKind::Points && setup.sprite {
if material.size_attenuation {
fields.push("sizeAttenuation (PointsNodeMaterial on a Sprite)");
}
if material.size_node.is_none() {
fields.push("size without sizeNode (PointsNodeMaterial on a Sprite)");
}
}
WARNED.with(|warned| {
let mut warned = warned.borrow_mut();
for field in fields {
if warned.insert((id, field)) {
eprintln!(
"three-rs: material {id} ({:?}{}): {} is set but not supported, and is ignored",
material.kind,
if material.name.is_empty() {
String::new()
} else {
format!(" \"{}\"", material.name)
},
field,
);
}
}
});
}
fn update_skeleton(
node_frame: &mut crate::nodes::NodeFrameState,
skeleton: &Rc<std::cell::RefCell<crate::objects::Skeleton>>,
) {
use crate::nodes::frame::UpdatePhase;
let key = Rc::as_ptr(skeleton) as *const u8 as usize;
if let Some(claim) = node_frame.claim(
UpdatePhase::Update,
key,
crate::nodes::NodeUpdateType::Frame,
) {
skeleton.borrow_mut().update();
node_frame.settle(claim, true);
}
}