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 renderer_state;
mod screen_reads;
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,
};
pub use cube_render_target::CubeRenderTarget;
pub use direct_render_pipeline::DirectRenderPipeline;
pub use info::{BuildCounts, ComputeCounts, Info, MemoryCounts, RenderCounts};
use mipmap::{create_mipmap_pipeline, MipmapShader};
pub use pass::{depth_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::BufferKey;
use crate::core::{BufferGeometry, Group, Index, Layers, ObjectRef};
use crate::error::Error;
use crate::geometries::{quad_geometry, sphere_geometry};
use crate::lights::{
LightKind, LightObject, LightShadow, ShadowCamera, 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, InstanceData, 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);
pub const SUBGROUP_FEATURES: wgpu::Features = wgpu::Features::SUBGROUP;
struct BufferEntry {
buffer: Serial<wgpu::Buffer>,
last_used: u64,
data: Option<Rc<Vec<f32>>>,
}
struct AttributeBuffer {
buffer: Serial<wgpu::Buffer>,
version: u32,
last_used: u64,
}
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 {
buffers: Vec<(BufferKey, wgpu::Buffer, u32)>,
index: Option<(wgpu::Buffer, wgpu::IndexFormat, u32)>,
wireframe_index: Option<(wgpu::Buffer, wgpu::IndexFormat, u32)>,
vertex_count: u32,
}
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 buffer(&self, key: BufferKey) -> Option<&wgpu::Buffer> {
self.buffers
.iter()
.find(|(candidate, _, _)| *candidate == key)
.map(|(_, buffer, _)| buffer)
}
}
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,
}
}
}
pub(crate) trait RenderObjectFunction {
fn material(&self, material: &MeshBasicNodeMaterial, background: bool)
-> MeshBasicNodeMaterial;
fn variant(&self) -> u64;
}
#[derive(Clone)]
struct Renderable {
object: Option<ObjectRef>,
geometry: Rc<BufferGeometry>,
material: MeshBasicNodeMaterial,
key: MaterialKey,
setup: SetupContext,
fog: Option<FogNode>,
model_world: Matrix4,
instance_matrix: Option<InstanceData>,
instance_color: Option<InstanceData>,
instance_count: u32,
morph_influences: Vec<f64>,
morph_base: f64,
bind_matrix: Matrix4,
bind_matrix_inverse: Matrix4,
bone_matrices: Vec<f32>,
previous_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;
const VARIANT_RENDER_OBJECT_FUNCTION: u64 = 7;
enum SceneCamera<'a> {
Exclusive(&'a mut dyn RenderCamera),
Shared(&'a std::cell::RefCell<dyn RenderCamera>),
}
#[derive(Clone)]
pub(crate) struct OutlineSelection {
pub(crate) selected: Rc<HashSet<u32>>,
pub(crate) draw_selected: bool,
pub(crate) material: Rc<MeshBasicNodeMaterial>,
pub(crate) sprite_material: Rc<MeshBasicNodeMaterial>,
}
impl OutlineSelection {
fn material_for(&self, object: &crate::core::Object3D) -> Option<&MeshBasicNodeMaterial> {
(self.selected.contains(&object.id) == self.draw_selected).then(|| {
if object.payload.is_sprite() {
&*self.sprite_material
} else {
&*self.material
}
})
}
}
struct ProgramEntry {
program: Program,
last_named: u64,
}
struct ComputePipelineEntry {
gpu: ComputeProgramGpu,
last_used: u64,
}
struct ComputeEntry {
statements: Vec<Weak<crate::nodes::node::Node>>,
program: Rc<crate::nodes::ComputeProgram>,
}
impl ComputeEntry {
fn new(flow: &ComputeFlow, program: Rc<crate::nodes::ComputeProgram>) -> Self {
Self {
statements: flow
.statements
.iter()
.map(|stmt| Rc::downgrade(stmt.as_rc()))
.collect(),
program,
}
}
fn is_for(&self, flow: &ComputeFlow) -> bool {
self.statements.len() == flow.statements.len()
&& self
.statements
.iter()
.zip(&flow.statements)
.all(|(weak, stmt)| {
weak.strong_count() > 0 && std::ptr::eq(weak.as_ptr(), Rc::as_ptr(stmt.as_rc()))
})
}
fn is_live(&self) -> bool {
self.statements.iter().all(|weak| weak.strong_count() > 0)
}
}
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,
stencil_ref: Option<u32>,
}
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>,
color_blend: Option<Option<wgpu::BlendState>>,
clear_colors: Vec<Option<[f64; 4]>>,
resolve: Option<wgpu::TextureView>,
color_texture: Option<wgpu::Texture>,
depth: Option<wgpu::TextureView>,
depth_texture: Option<wgpu::Texture>,
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,
stencil: bool,
}
impl ClearOps {
fn all(color: [f64; 4]) -> Self {
Self {
color: Some(color),
depth: true,
stencil: 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,
stencil: bool,
clip_distances: bool,
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) context_shadow: Option<pass::ShadowContext>,
pub(crate) context_ao: Option<crate::nodes::NodeRef>,
pub(crate) toon_outline: Option<Rc<MeshBasicNodeMaterial>>,
pub(crate) render_object_function: Option<Rc<dyn RenderObjectFunction>>,
pub(crate) oit: Option<crate::nodes::display::OitRenderObjects>,
pub(crate) outline_selection: Option<OutlineSelection>,
pub(crate) camera_layers: Option<Layers>,
pub sort_objects: bool,
canvas: Option<CanvasTarget>,
render_target: Option<RenderTarget>,
active_mipmap_level: u32,
mrt: Option<crate::nodes::MrtNode>,
frame_buffer_target: Option<RenderTarget>,
opaque_frame: Option<Texture>,
back_side_frame: Option<Texture>,
screen_reads: Option<screen_reads::ScreenReads>,
screen_read_textures: screen_reads::Destinations,
output_buffer_type: TextureType,
mipmap_shader: MipmapShader,
programs: HashMap<u64, ProgramEntry>,
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>,
attribute_buffers: HashMap<(usize, wgpu::BufferUsages), AttributeBuffer>,
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, ComputeEntry>,
compute_pipelines: HashMap<u64, ComputePipelineEntry>,
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,
pub stencil: 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 adapter = shared_adapter()?;
pollster::block_on(Self::with_adapter_async(parameters, adapter))
}
#[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?;
Self::with_adapter_async(parameters, adapter).await
}
async fn with_adapter_async(
parameters: RendererParameters,
adapter: wgpu::Adapter,
) -> Result<Self, Error> {
let wanted = wgpu::Features::FLOAT32_FILTERABLE
| wgpu::Features::RG11B10UFLOAT_RENDERABLE
| wgpu::Features::CLIP_DISTANCES
| COMPRESSION_FEATURES
| SUBGROUP_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);
let clip_distances = device.features().contains(wgpu::Features::CLIP_DISTANCES);
Self {
device,
queue,
adapter_info,
adapter,
samples: if parameters.antialias { 4 } else { 0 },
stencil: parameters.stencil,
clip_distances,
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,
context_shadow: None,
context_ao: None,
toon_outline: None,
render_object_function: None,
oit: None,
outline_selection: None,
camera_layers: None,
sort_objects: true,
canvas: None,
render_target: None,
active_mipmap_level: 0,
mrt: None,
frame_buffer_target: None,
opaque_frame: None,
back_side_frame: None,
screen_reads: None,
screen_read_textures: screen_reads::Destinations::default(),
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(),
attribute_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 size(&self) -> (f64, f64) {
(self.width, self.height)
}
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,
stencil: self.stencil,
},
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.set_render_target_level(render_target, 0);
}
pub fn set_render_target_level(
&mut self,
render_target: Option<RenderTarget>,
active_mipmap_level: u32,
) {
self.render_target = render_target;
self.active_mipmap_level = active_mipmap_level;
}
pub fn active_mipmap_level(&self) -> u32 {
self.active_mipmap_level
}
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_velocity_projection_matrix(&mut self, projection: Option<Matrix4>) {
self.node_frame.velocity.set_projection_matrix(projection);
}
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) {
self.clear_buffers(color, depth, depth);
}
fn clear_buffers(&mut self, color: bool, depth: bool, stencil: 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,
stencil,
};
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_buffers(false, true, false);
}
pub fn render(&mut self, scene: &mut Scene, camera: &mut dyn RenderCamera) {
self.render_with_camera(scene, SceneCamera::Exclusive(camera));
}
pub(crate) fn render_shared(
&mut self,
scene: &Scene,
camera: &std::cell::RefCell<dyn RenderCamera>,
) {
self.render_with_camera(scene, SceneCamera::Shared(camera));
}
pub(crate) fn render_nested(&mut self, scene: &Scene, camera: &mut dyn RenderCamera) {
self.render_with_camera(scene, SceneCamera::Exclusive(camera));
}
fn render_with_camera(&mut self, scene: &Scene, camera: SceneCamera<'_>) {
if self.info.auto_reset && self.call_depth == 0 {
self.info.reset();
}
let render = self.begin_frame();
self.with_fullscreen_pass(false, |renderer| {
renderer.poll_occlusion();
scene.update_matrix_world();
match camera {
SceneCamera::Exclusive(camera) => {
camera.update_matrix_world();
renderer.render_scene(scene, camera);
}
SceneCamera::Shared(camera) => {
if let Ok(mut camera) = camera.try_borrow_mut() {
camera.update_matrix_world();
}
renderer.render_scene(scene, &*camera.borrow());
}
}
});
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());
self.call_scene_hook(scene, camera, false);
let mut render_list = self.project_scene(scene, camera);
let mut items = Vec::with_capacity(render_list.len() + 1);
let needs_previous_data = self.mrt.as_ref().is_some_and(|mrt| mrt.has("velocity"));
let mrt_context = match (&self.render_target, &self.mrt) {
(Some(render_target), Some(node)) => {
Some(MrtContext::for_target(node.clone(), render_target))
}
_ => None,
};
let scene_background = scene
.background
.clone()
.filter(|_| self.outline_selection.is_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 mut key = MaterialKey::of(&self.background_material).variant(variant);
let mut material = self.background_material.clone();
material.color_node = Some(color_node);
if let Some(function) = &self.render_object_function {
material = function.material(&material, true);
key = key.variant(hash_of(&(
VARIANT_RENDER_OBJECT_FUNCTION,
function.variant(),
key.variant,
)));
}
items.push(Renderable {
object: None,
geometry: self.background_geometry(),
material,
key,
setup: SetupContext {
output: output_context.clone(),
orthographic: camera.is_orthographic_camera(),
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(),
previous_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);
if self.outline_selection.is_none() {
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 context_shadow = self.context_shadow.as_ref().and_then(|context| {
render_list
.lights
.iter()
.position(|light| ObjectRef::ptr_eq(light, &context.light))
.map(|index| (index, context.shadow.clone()))
});
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 (mut transmits, mut transmits_back) = (false, false);
for item in render_list.items() {
let object = item.node.borrow();
let Some(material) = scene.override_material.as_ref().or(item.material(&object)) else {
continue;
};
if material.transmission > 0.0 {
transmits = true;
transmits_back |= material.side == Side::Back
|| (material.transparent
&& material.side == Side::Double
&& !material.force_single_pass);
}
}
let (width, height) = self.drawing_buffer_size();
let opaque_frame = transmits.then(|| materials::transmission::OpaqueFrame {
texture: self.opaque_frame_texture(false, width, height),
});
let back_side_frame = transmits_back.then(|| materials::transmission::OpaqueFrame {
texture: self.opaque_frame_texture(true, 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 = match &self.outline_selection {
Some(selection) => match selection.material_for(&object) {
Some(material) => material,
None => continue,
},
None => 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));
}
}
}
if let Some(oit) = self.oit {
draws.retain(|(item, _)| {
let object = item.node.borrow();
let material = scene
.override_material
.as_ref()
.or(item.material(&object))
.unwrap_or(&self.default_material);
oit.draws(material)
});
}
let hooked = self.hooked_items(&draws);
self.call_object_hooks(&hooked, scene, camera, false);
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 = match &self.outline_selection {
Some(selection) => match selection.material_for(&object) {
Some(material) => material,
None => continue,
},
None => 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()
.map(InstancedBufferAttribute::snapshot);
let instance_color = object
.instance_color()
.map(InstancedBufferAttribute::snapshot);
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_rc = skeleton.as_ref()?;
let previous_bones = needs_previous_data
.then(|| self.node_frame.velocity.previous_bones(skeleton_rc));
let skeleton = skeleton_rc.borrow();
Some((
crate::nodes::skinning::SkinEntry {
bones: skeleton.bones.len(),
previous: previous_bones.is_some(),
},
mesh.bind_matrix,
mesh.bind_matrix_inverse,
skeleton.bone_matrices.clone(),
previous_bones.unwrap_or_default(),
))
});
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;
}
if self.oit == Some(crate::nodes::display::OitRenderObjects::Accumulate) {
material.depth_write = false;
}
let item_opaque_frame = (material.transmission > 0.0)
.then(|| match material.side {
Side::Back => back_side_frame.clone(),
_ => opaque_frame.clone(),
})
.flatten();
let (material, key) = match &self.render_object_function {
Some(function) => (
function.material(&material, false),
key.variant(hash_of(&(
VARIANT_RENDER_OBJECT_FUNCTION,
function.variant(),
key.variant,
))),
),
None => (material, key),
};
let renderable = Renderable {
object: Some(item.node.clone()),
geometry: geometry.clone(),
material: material.clone(),
key,
setup: SetupContext {
array_cameras: camera.sub_cameras().len(),
orthographic: camera.is_orthographic_camera(),
environment: scene_environment,
lighting_disabled: !self.lighting_enabled,
clipping: item.clipping.clone(),
ambient_occlusion: self
.context_ao
.clone()
.map(|node| materials::AoContext { node }),
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()
.map(|map| match &context_shadow {
Some((light, shadow)) if *light == index => {
ShadowMap::Context {
map: Box::new(map),
shadow: shadow.clone(),
}
}
_ => map,
}),
})
.collect(),
morph: morph.clone(),
skin: skin.as_ref().map(|s| s.0),
batch: batch.clone(),
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"),
geometry_attributes: geometry.attribute_descs(),
},
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),
previous_bone_matrices: skin.as_ref().map(|s| s.4.clone()).unwrap_or_default(),
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,
stencil: true,
}
} 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 camera_view = camera.matrix_world_inverse();
let shadow_map_enabled = self.shadow_map_enabled;
let lights: Vec<LightState> = render_list
.lights
.iter()
.map(|node| {
gather_light_state(&mut node.borrow_mut(), &camera_view, shadow_map_enabled)
})
.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 {
env_rotation: scene_env_rotation(scene),
camera_id: camera.id(),
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,
camera_near: camera.near(),
camera_far: camera.far(),
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,
background_intensity: scene.background_intensity,
scene_environment_intensity: scene.environment_intensity,
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;
self.call_object_hooks(&hooked, scene, camera, true);
self.call_scene_hook(scene, camera, true);
}
#[inline(never)]
fn hooked_items(
&self,
draws: &[(&RenderItem, Option<Side>)],
) -> Vec<(ObjectRef, Option<Group>)> {
let mut hooked = Vec::new();
for (item, side) in draws {
if *side == Some(Side::Front) {
continue;
}
let object = item.node.borrow();
if object.on_before_render.is_none() && object.on_after_render.is_none() {
continue;
}
if let Some(selection) = &self.outline_selection {
if selection.material_for(&object).is_none() {
continue;
}
}
drop(object);
hooked.push((item.node.clone(), item.group));
}
hooked
}
#[inline(never)]
fn call_object_hooks(
&self,
hooked: &[(ObjectRef, Option<Group>)],
scene: &Scene,
camera: &dyn RenderCamera,
after: bool,
) {
for (node, group) in hooked {
let taken = {
let mut object = node.borrow_mut();
if after {
object.on_after_render.take()
} else {
object.on_before_render.take()
}
};
let Some(mut hook) = taken else { continue };
hook(node, self, scene, camera, group.as_ref());
let mut object = node.borrow_mut();
let slot = if after {
&mut object.on_after_render
} else {
&mut object.on_before_render
};
if slot.is_none() {
*slot = Some(hook);
}
}
}
#[inline(never)]
fn call_scene_hook(&mut self, scene: &Scene, camera: &dyn RenderCamera, after: bool) {
let hook = if after {
scene.on_after_render.as_ref()
} else {
scene.on_before_render.as_ref()
};
let Some(hook) = hook else { return };
let target = if self.needs_frame_buffer_target() && self.render_target.is_none() {
Some(self.frame_buffer_target())
} else {
self.render_target.clone()
};
hook(self, scene, camera, target.as_ref());
}
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(),
self.clip_distances,
),
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()
.map(InstancedBufferAttribute::snapshot);
let instance_color = object
.instance_color()
.map(InstancedBufferAttribute::snapshot);
let instance_count = object.instance_count();
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()?.borrow();
Some((
crate::nodes::skinning::SkinEntry {
bones: skeleton.bones.len(),
previous: false,
},
mesh.bind_matrix,
mesh.bind_matrix_inverse,
skeleton.bone_matrices.clone(),
))
});
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,
orthographic: matches!(shadow.camera, ShadowCamera::Orthographic(_)),
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,
ambient_occlusion: None,
clipping: item.clipping.clone(),
lights: Vec::new(),
morph: None,
skin: skin.as_ref().map(|s| s.0),
batch: None,
sprite: false,
mrt: None,
vertex_color_size: 0,
geometry_missing_normal: false,
has_tangent_attribute: geometry.has_attribute("tangent"),
geometry_attributes: geometry.attribute_descs(),
},
fog: None,
model_world: item.matrix_world,
instance_matrix,
instance_color,
instance_count,
morph_influences: Vec::new(),
morph_base: 1.0,
bind_matrix: skin.as_ref().map_or(Matrix4::identity(), |s| s.1),
bind_matrix_inverse: skin.as_ref().map_or(Matrix4::identity(), |s| s.2),
object_center: Vector2::new(0.5, 0.5),
bone_matrices: skin.map(|s| s.3).unwrap_or_default(),
previous_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;
self.with_fullscreen_pass(true, |renderer| {
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: renderer.quad_geometry(),
material,
key,
setup: SetupContext {
orthographic: true,
..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(),
previous_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,
..renderer.quad_camera_uniforms()
};
let pass_target = renderer.render_target_pass(&target);
renderer.draw(
&items,
uniforms,
&pass_target,
ClearOps {
color: Some([0.0, 0.0, 0.0, 0.0]),
depth: false,
stencil: false,
},
);
}
});
moments
}
fn render_point_shadow(
&mut self,
index: usize,
node: &ObjectRef,
scene: &Scene,
camera: &dyn RenderCamera,
) {
let shadow_type = self.shadow_map_type.resolved();
let (light_world_position, near, far, light_depth_texture, 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.point_depth_texture(),
shadow.filter_node.clone(),
)
};
let cached = self
.cube_shadow_targets
.get(&index)
.filter(|(depth_texture, _)| depth_texture.id() == light_depth_texture.id())
.cloned();
let (depth_texture, color) = cached.unwrap_or_else(|| {
let depth_texture = light_depth_texture;
let size = depth_texture.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 size = depth_texture.size();
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(),
self.clip_distances,
),
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()
.map(InstancedBufferAttribute::snapshot);
let instance_color = object
.instance_color()
.map(InstancedBufferAttribute::snapshot);
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,
orthographic: false,
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,
ambient_occlusion: None,
clipping: item.clipping.clone(),
lights: Vec::new(),
morph: None,
skin: None,
batch: None,
sprite: false,
mrt: None,
vertex_color_size: 0,
geometry_missing_normal: false,
has_tangent_attribute: geometry.has_attribute("tangent"),
geometry_attributes: geometry.attribute_descs(),
},
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(),
previous_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(),
color_blend: None,
clear_colors: Vec::new(),
resolve: None,
color_texture: None,
depth: Some(depth_view),
depth_texture: None,
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, self.clip_distances);
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) {
self.with_fullscreen_pass(true, |renderer| renderer.draw_quad_mesh(quad));
}
fn draw_quad_mesh(&mut self, quad: &QuadMesh) {
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 {
orthographic: true,
..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(),
previous_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,
stencil: true,
}
} else {
ClearOps::default()
};
self.render_list(&items, camera_uniforms, clear);
}
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 mut transmission_copies: Vec<(usize, Texture)> = Vec::new();
if target.color_texture.is_some() {
for (index, item) in items.iter().enumerate() {
let Some(frame) = item
.setup
.viewport_opaque_mip
.as_ref()
.filter(|_| item.material.transmission > 0.0)
else {
continue;
};
if !transmission_copies
.iter()
.any(|(_, texture)| texture.id() == frame.texture.id())
{
transmission_copies.push((index, frame.texture.clone()));
}
}
}
let outer_screen_reads = self
.screen_reads
.replace(screen_reads::ScreenReads::new(target));
for item in items {
if let Some(reads) = self.screen_reads.as_mut() {
reads.draw_index = draws.len();
}
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,
);
if self.subgroups_unsupported(node.subgroups) {
continue;
}
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 stencil = target
.depth_format
.is_some_and(|format| format.has_stencil_aspect());
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,
color_write: item.material.color_write,
stencil_face: stencil.then(|| item.material.stencil_face()).flatten(),
stencil_read_mask: if stencil {
item.material.stencil_func_mask
} else {
0
},
stencil_write_mask: if stencil {
item.material.stencil_write_mask
} else {
0
},
alpha_to_coverage: item.material.alpha_to_coverage,
blend: target
.color_blend
.unwrap_or_else(|| 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 velocity = if node.reads_velocity {
let frame_id = self.node_frame.frame_id;
self.node_frame.velocity.update(
frame_id,
item.object.as_ref(),
item.model_world,
camera_uniforms.camera_id,
camera_uniforms.camera_projection,
camera_uniforms.camera_view,
)
} else {
Default::default()
};
let uniforms = UniformContext {
velocity,
previous_bone_matrices: &item.previous_bone_matrices,
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_refraction_ratio: item.material.refraction_ratio,
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_iridescence: item.material.iridescence,
material_iridescence_ior: item.material.iridescence_ior,
material_iridescence_thickness_range: item.material.iridescence_thickness_range,
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,
env_rotation: if item.material.env_map.is_some() {
Matrix4::identity()
} else {
camera_uniforms.env_rotation
},
material_light_map_intensity: item.material.light_map_intensity,
material_point_size: item.material.size,
material_env_intensity: if item.setup.environment.is_some() {
camera_uniforms.scene_environment_intensity
} else {
1.0
},
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,
clipping: item.setup.clipping.as_deref(),
..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();
if node.reads_velocity {
self.node_frame
.velocity
.update_after(item.object.as_ref(), item.model_world);
}
let vertex_buffers = node
.vertex_buffers()
.iter()
.map(|desc| match &desc.source {
VertexBufferSource::Geometry(slot) => {
self.geometry_vertex_buffer(&item.geometry, geometry_id, slot.name)
}
VertexBufferSource::Instance(buffer) => {
self.instance_buffer(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,
stencil_ref: (stencil && item.material.stencil_write)
.then_some(item.material.stencil_ref),
});
drop(object);
for entry in &node.update_after {
self.update_after_node(entry);
}
}
let screen_reads = std::mem::replace(&mut self.screen_reads, outer_screen_reads)
.expect("three-rs: draw() installed its screen reads above");
let mut copies: Vec<(usize, screen_reads::FramebufferCopy)> = transmission_copies
.into_iter()
.map(|(index, texture)| (index, screen_reads::FramebufferCopy::OpaqueFrame(texture)))
.chain(screen_reads.copies)
.collect();
copies.sort_by_key(|(index, _)| *index);
let first_copy = copies.first().map_or(draws.len(), |(index, _)| *index);
let query_objects = match occlusion_context {
Some(_) => occlusion::query_objects(
draws[..first_copy]
.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)
});
let mut encoder = self
.device
.create_command_encoder(&wgpu::CommandEncoderDescriptor {
label: Some("three-rs pass"),
});
self.record_pass(
&mut encoder,
&draws[..first_copy],
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 mut rest = copies.as_slice();
while let Some(&(start, _)) = rest.first() {
let boundary = rest.iter().take_while(|(index, _)| *index == start).count();
let (here, after) = rest.split_at(boundary);
rest = after;
self.run_framebuffer_copies(target, here.iter().map(|(_, copy)| copy));
let end = rest.first().map_or(draws.len(), |(index, _)| *index);
if end == start {
continue;
}
let mut encoder = self
.device
.create_command_encoder(&wgpu::CommandEncoderDescriptor {
label: Some("three-rs pass after copyFramebufferToTexture"),
});
self.record_pass(
&mut encoder,
&draws[start..end],
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_for = |index: usize, default: [f64; 4]| match clear.color {
Some(_) => {
let color = target
.clear_colors
.get(index)
.copied()
.flatten()
.unwrap_or(default);
wgpu::LoadOp::Clear(wgpu::Color {
r: color[0],
g: color[1],
b: color[2],
a: color[3],
})
}
None => wgpu::LoadOp::Load,
};
let load = load_for(0, clear.color.unwrap_or_default());
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,
},
})];
for (index, (view, resolve)) in target.extra_colors.iter().enumerate() {
color_attachments.push(Some(wgpu::RenderPassColorAttachment {
view,
depth_slice: None,
resolve_target: resolve.as_ref(),
ops: wgpu::Operations {
load: load_for(index + 1, [0.0, 0.0, 0.0, 1.0]),
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: target
.depth_format
.is_some_and(|format| format.has_stencil_aspect())
.then_some(wgpu::Operations {
load: if clear.stencil {
wgpu::LoadOp::Clear(0)
} else {
wgpu::LoadOp::Load
},
store: wgpu::StoreOp::Store,
}),
}
}),
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"),
);
if let Some(reference) = draw.stencil_ref {
pass.set_stencil_reference(reference);
}
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 {
orthographic: true,
..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(),
previous_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 subgroups_unsupported(&self, subgroups: bool) -> bool {
if !subgroups || self.device.features().contains(SUBGROUP_FEATURES) {
return false;
}
thread_local! {
static WARNED: std::cell::Cell<bool> = const { std::cell::Cell::new(false) };
}
if !WARNED.with(|warned| warned.replace(true)) {
eprintln!(
"three-rs: WGSLNodeBuilder: The 'subgroups' feature is not supported by the current device."
);
}
true
}
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(entry) if entry.is_for(flow) => entry.program.clone(),
_ => {
self.compute_programs.retain(|_, entry| entry.is_live());
self.info.build.programs_compiled += 1;
let program = Rc::new(NodeBuilder::new().build_compute(flow));
self.compute_programs
.insert(key, ComputeEntry::new(flow, program.clone()));
program
}
};
if self.subgroups_unsupported(program.subgroups) {
return Ok(());
}
let frames = self.node_frame.frame_id;
let fresh = match self.compute_pipelines.get_mut(&program.cache_key) {
Some(entry) => {
entry.last_used = frames;
false
}
None => {
self.info.build.pipelines_built += 1;
let gpu = ComputeProgramGpu::new(&self.device, &program);
self.compute_pipelines.insert(
program.cache_key,
ComputePipelineEntry {
gpu,
last_used: frames,
},
);
self.count_programs();
true
}
};
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].gpu;
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)?;
self.await_readback(readback).await
}
}
async fn await_readback(
&self,
readback: PendingReadback,
) -> Result<(u32, u32, Vec<u8>), Error> {
let slice = readback.buffer.slice(..);
#[cfg(not(target_arch = "wasm32"))]
{
slice.map_async(wgpu::MapMode::Read, |_| {});
self.device
.poll(wgpu::PollType::wait_indefinitely())
.map_err(|e| Error::Readback {
reason: e.to_string(),
})?;
}
#[cfg(target_arch = "wasm32")]
{
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 (width, height, bytes) = self.read_cube_bytes(cube, layer, mip_level, |format| {
format == wgpu::TextureFormat::Rgba16Float
})?;
Ok((width, height, decode_rgba16f(&bytes)))
}
#[doc(hidden)]
pub async fn read_cube_pixels_rgba16f_async(
&mut self,
cube: &CubeTexture,
layer: u32,
mip_level: u32,
) -> Result<(u32, u32, Vec<f32>), Error> {
let readback = self.submit_cube_readback(cube, layer, mip_level, |format| {
format == wgpu::TextureFormat::Rgba16Float
})?;
let (width, height, bytes) = self.await_readback(readback).await?;
Ok((width, height, decode_rgba16f(&bytes)))
}
pub fn read_cube_pixels_rgba8(
&mut self,
cube: &CubeTexture,
layer: u32,
mip_level: u32,
) -> Result<(u32, u32, Vec<u8>), Error> {
self.read_cube_bytes(cube, layer, mip_level, |format| {
matches!(
format,
wgpu::TextureFormat::Rgba8Unorm | wgpu::TextureFormat::Rgba8UnormSrgb
)
})
}
pub async fn read_cube_pixels_rgba8_async(
&mut self,
cube: &CubeTexture,
layer: u32,
mip_level: u32,
) -> Result<(u32, u32, Vec<u8>), Error> {
let readback = self.submit_cube_readback(cube, layer, mip_level, |format| {
matches!(
format,
wgpu::TextureFormat::Rgba8Unorm | wgpu::TextureFormat::Rgba8UnormSrgb
)
})?;
self.await_readback(readback).await
}
fn read_cube_bytes(
&mut self,
cube: &CubeTexture,
layer: u32,
mip_level: u32,
accepts: impl Fn(wgpu::TextureFormat) -> bool,
) -> Result<(u32, u32, Vec<u8>), Error> {
let readback = self.submit_cube_readback(cube, layer, mip_level, accepts)?;
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()
}
fn submit_cube_readback(
&mut self,
cube: &CubeTexture,
layer: u32,
mip_level: u32,
accepts: impl Fn(wgpu::TextureFormat) -> bool,
) -> Result<PendingReadback, Error> {
let texture = self.ensure_cube_texture(cube);
let format = texture.format();
if !accepts(format) {
return Err(Error::Readback {
reason: format!("{format:?} is not the format this readback decodes"),
});
}
let size = texture.width() >> mip_level;
self.submit_readback_at(&texture, mip_level, layer, size, size)
}
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,
item.material.texture_sampler_key(),
));
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 {
for node in states.by_dynamic_key.values() {
if let Some(entry) = self.programs.get_mut(&node.cache_key) {
entry.last_named = frames;
}
}
states.by_dynamic_key.clear();
states.version = item.key.version;
}
if let Some(node) = states.by_dynamic_key.get(&dynamic_key) {
return node.clone();
}
materials::fields::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),
);
self.info.build.programs_compiled += 1;
if !(node.subgroups && !self.device.features().contains(SUBGROUP_FEATURES)) {
self.programs
.entry(node.cache_key)
.and_modify(|entry| entry.last_named = frames)
.or_insert_with(|| ProgramEntry {
program: Program::new(&self.device, &node),
last_named: frames,
});
}
states.by_dynamic_key.insert(dynamic_key, node.clone());
self.count_programs();
node
}
fn count_programs(&mut self) {
self.info.memory.programs = self.programs.len() + self.compute_pipelines.len();
}
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<InstanceData>,
instance_color: &Option<InstanceData>,
) -> 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].program.layouts[group],
),
LayoutKey::Compute(program) => (
"three-rs compute bind group",
&self.compute_pipelines[&program].gpu.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<InstanceData>,
instance_color: &Option<InstanceData>,
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::ClippingIntersection | BufferSource::ClippingUnion = source {
let planes = match (source, uniforms.clipping) {
(BufferSource::ClippingIntersection, Some(c)) => c.intersection.as_slice(),
(_, Some(c)) => c.union.as_slice(),
(_, None) => &[],
};
let padded;
let planes = if planes.len() == count {
planes
} else {
padded = (0..count)
.map(|i| planes.get(i).copied().unwrap_or_default())
.collect::<Vec<[f32; 4]>>();
&padded
};
return self.slot_buffer(
slot,
"three-rs clipping planes",
bytemuck::cast_slice(planes),
wgpu::BufferUsages::UNIFORM,
);
}
if let BufferSource::BoneMatrices | BufferSource::PreviousBoneMatrices = source {
let (matrices, label) = match source {
BufferSource::BoneMatrices => (uniforms.bone_matrices, "three-rs boneMatrices"),
_ => (
uniforms.previous_bone_matrices,
"three-rs previousBoneMatrices",
),
};
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,
label,
bytemuck::cast_slice(&data),
wgpu::BufferUsages::UNIFORM,
);
}
if let BufferSource::SkeletonBoneMatrices(skeleton) = source {
return self.skeleton_bone_buffer(slot, skeleton, count);
}
if let BufferSource::LightProbe(index) = source {
let sh = uniforms.lights.get(*index).map_or([[0.0; 4]; 9], |l| l.sh);
return self.slot_buffer(
slot,
"three-rs lightProbe",
bytemuck::cast_slice(&sh),
wgpu::BufferUsages::UNIFORM,
);
}
if let BufferSource::Live(value) = source {
let mut data = vec![0f32; count * 4];
for (out, v) in data.iter_mut().zip(value.get()) {
*out = v as f32;
}
return self.slot_buffer(
slot,
"three-rs live uniformArray",
bytemuck::cast_slice(&data),
wgpu::BufferUsages::UNIFORM,
);
}
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(
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,
buffer: &Rc<crate::nodes::node::InstanceBuffer>,
instance_matrix: &Option<InstanceData>,
instance_color: &Option<InstanceData>,
) -> 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(
id,
&buffer.source,
buffer.count,
instance_matrix,
instance_color,
wgpu::BufferUsages::VERTEX,
)
.gpu
}
fn buffer_for(
&mut self,
id: usize,
source: &BufferSource,
count: usize,
instance_matrix: &Option<InstanceData>,
instance_color: &Option<InstanceData>,
usage: wgpu::BufferUsages,
) -> Serial<wgpu::Buffer> {
match source {
BufferSource::MorphInfluences
| BufferSource::LightProbe(_)
| BufferSource::Live(_)
| BufferSource::BoneMatrices
| BufferSource::PreviousBoneMatrices
| BufferSource::CameraViewMatrices
| BufferSource::CameraProjectionMatrices
| BufferSource::ClippingIntersection
| BufferSource::ClippingUnion
| 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.attribute_buffer("three-rs instanceMatrix", attribute, usage)
}
BufferSource::InstanceColor => {
let attribute = instance_color
.as_ref()
.expect("three-rs: instanceColor needs an InstancedMesh with setColorAt");
self.attribute_buffer("three-rs instanceColor", attribute, 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 format = gpu.format();
let aspect = if format.has_depth_aspect() && format.has_stencil_aspect() {
wgpu::TextureAspect::DepthOnly
} else {
wgpu::TextureAspect::All
};
let view = gpu.create_view(&wgpu::TextureViewDescriptor {
dimension,
aspect,
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 fn init_render_target(&mut self, render_target: &RenderTarget) {
self.prepare_render_target(render_target);
}
pub(crate) fn copy_render_texture(&mut self, source: &Texture, destination: &Texture) {
let size = source.size();
let source = source.with_gpu(|gpu| gpu.clone());
let destination = destination.with_gpu(|gpu| gpu.clone());
self.copy_whole_texture(&source, &destination, size, "three-rs texture copy");
}
pub(crate) fn copy_depth_texture(&mut self, source: &DepthTexture, destination: &DepthTexture) {
let (source, destination) = (
source.inner().borrow().gpu.clone(),
destination.inner().borrow().gpu.clone(),
);
let (Some(source), Some(destination)) = (source, destination) else {
return;
};
let size = (source.width(), source.height());
self.copy_whole_texture(&source, &destination, size, "three-rs depth copy");
}
fn copy_whole_texture(
&mut self,
source: &wgpu::Texture,
destination: &wgpu::Texture,
(width, height): (u32, u32),
label: &'static str,
) {
let mut encoder = self
.device
.create_command_encoder(&wgpu::CommandEncoderDescriptor { label: Some(label) });
encoder.copy_texture_to_texture(
source.as_image_copy(),
destination.as_image_copy(),
wgpu::Extent3d {
width,
height,
depth_or_array_layers: 1,
},
);
self.queue.submit([encoder.finish()]);
}
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]
.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 mut buffers: Vec<(BufferKey, wgpu::Buffer, u32)> = Vec::new();
for (_, attribute) in geometry.attributes() {
let key = attribute.buffer_key();
if matches!(key, BufferKey::Storage(_)) || buffers.iter().any(|(k, _, _)| *k == key) {
continue;
}
let buffer = self.create_buffer_init(
"three-rs attribute",
&attribute.upload_bytes(),
wgpu::BufferUsages::VERTEX,
);
buffers.push((key, buffer, attribute.version()));
}
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);
self.info.build.geometries_uploaded += 1;
self.info.build.buffers_written += buffers.len() as u64 + u64::from(index.is_some());
self.geometries.insert(
id,
GeometryEntry {
gpu: GeometryGpu {
buffers,
index,
wireframe_index: None,
vertex_count,
},
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();
let gpu = &mut self
.geometries
.get_mut(&id)
.expect("three-rs: refresh_geometry() on an uploaded geometry")
.gpu;
gpu.buffers.retain(|(key, _, _)| {
geometry
.attributes()
.any(|(_, attribute)| attribute.buffer_key() == *key)
});
for (name, attribute) in geometry.attributes() {
let key = attribute.buffer_key();
if matches!(key, BufferKey::Storage(_)) {
continue;
}
let version = attribute.version();
let gpu = &self.geometries[&id].gpu;
let slot = gpu.buffers.iter().position(|(k, _, _)| *k == key);
if let Some(slot) = slot {
if gpu.buffers[slot].2 == version {
continue;
}
}
let bytes = attribute.upload_bytes();
let existing = slot.map(|slot| gpu.buffers[slot].1.clone());
match existing {
Some(buffer) if buffer.size() == bytes.len() as u64 => {
self.queue.write_buffer(&buffer, 0, &bytes);
}
_ => {
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;
match slot {
Some(slot) => gpu.buffers[slot].1 = buffer,
None => gpu.buffers.push((key, buffer, version)),
}
}
}
let gpu = &mut self
.geometries
.get_mut(&id)
.expect("three-rs: the entry was found above")
.gpu;
if let Some(entry) = gpu.buffers.iter_mut().find(|(k, _, _)| *k == key) {
entry.2 = version;
}
if name == "position" {
gpu.vertex_count = attribute.count() as u32;
}
self.info.build.buffers_written += 1;
}
}
fn geometry_vertex_buffer(
&mut self,
geometry: &BufferGeometry,
geometry_id: usize,
name: &str,
) -> wgpu::Buffer {
let attribute = geometry
.get_attribute(name)
.unwrap_or_else(|| panic!("three-rs: the geometry has no {name} attribute"));
let key = attribute.buffer_key();
let BufferKey::Storage(id) = key else {
return self.geometries[&geometry_id]
.gpu
.buffer(key)
.unwrap_or_else(|| panic!("three-rs: the geometry has no {name} attribute"))
.clone();
};
let version = attribute.version();
let gpu = &self.geometries[&geometry_id].gpu;
let slot = gpu.buffers.iter().position(|(k, _, _)| *k == key);
if let Some(slot) = slot {
if gpu.buffers[slot].2 == version {
return gpu.buffers[slot].1.clone();
}
}
let storage = attribute
.storage_buffer()
.expect("three-rs: a storage key has a storage attribute");
let buffer = match self.storage_buffers.get(&id.get()) {
Some(buffer) => {
let buffer = buffer.gpu.clone();
if slot.is_some() {
let init = storage.init_words(attribute.normalized);
let bytes: &[u8] = bytemuck::cast_slice(&init);
let len = bytes.len().min(buffer.size() as usize);
self.queue.write_buffer(&buffer, 0, &bytes[..len]);
self.info.build.buffers_written += 1;
}
buffer
}
None => {
let init = storage.init_words(attribute.normalized);
self.storage_buffer(id.get(), (init.len() * 4) as u64, Some(&init))
.gpu
}
};
let gpu = &mut self
.geometries
.get_mut(&geometry_id)
.expect("three-rs: the entry was read above")
.gpu;
match slot {
Some(slot) => gpu.buffers[slot].2 = version,
None => gpu.buffers.push((key, buffer.clone(), version)),
}
buffer
}
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_texture_source(&mut self, texture_id: usize) {
self.node_frame.open(crate::utils::now_ms());
if let Some(entry) = crate::nodes::frame::texture_update(texture_id) {
self.update_before_node(&entry);
}
}
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);
self.attribute_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));
let dropped_layouts = if self.call_depth == 1 {
self.sweep_programs(frames)
} else {
HashSet::new()
};
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))
&& (dropped_layouts.is_empty() || !dropped_layouts.contains(&key.layout()))
});
}
fn sweep_programs(&mut self, frames: u64) -> HashSet<LayoutKey> {
let mut dropped = HashSet::new();
let named: HashSet<u64> = self
.node_builder_states
.values()
.flat_map(|states| states.by_dynamic_key.values().map(|node| node.cache_key))
.collect();
self.programs.retain(|key, entry| {
let keep = named.contains(key) || bindings::is_fresh(entry.last_named, frames);
if !keep {
dropped.insert(LayoutKey::Render(*key));
}
keep
});
if !dropped.is_empty() {
let programs = &self.programs;
self.pipelines
.retain(|key, _| programs.contains_key(&key.program));
}
self.compute_programs.retain(|_, entry| entry.is_live());
let named: HashSet<u64> = self
.compute_programs
.values()
.map(|entry| entry.program.cache_key)
.collect();
self.compute_pipelines.retain(|key, entry| {
let keep = named.contains(key) || bindings::is_fresh(entry.last_used, frames);
if !keep {
dropped.insert(LayoutKey::Compute(*key));
}
keep
});
self.count_programs();
dropped
}
#[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 program_cache_lens(&self) -> (usize, usize, usize, usize) {
(
self.programs.len(),
self.pipelines.len(),
self.compute_programs.len(),
self.compute_pipelines.len(),
)
}
#[doc(hidden)]
pub fn buffer_cache_len(&self) -> usize {
self.buffers.len() + self.attribute_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 attribute_buffer(
&mut self,
label: &str,
attribute: &InstanceData,
usage: wgpu::BufferUsages,
) -> Serial<wgpu::Buffer> {
let frames = self.node_frame.frame_id;
let bytes: &[u8] = bytemuck::cast_slice(attribute.array.as_slice());
if let Some(entry) = self.attribute_buffers.get_mut(&(attribute.id, usage)) {
entry.last_used = frames;
if entry.version == attribute.version {
return entry.buffer.clone();
}
if entry.buffer.gpu.size() >= bytes.len() as u64 {
self.queue.write_buffer(&entry.buffer.gpu, 0, bytes);
entry.version = attribute.version;
self.info.build.buffers_written += 1;
return entry.buffer.clone();
}
}
let buffer = self.create_buffer_init(label, bytes, usage);
let buffer = self.serial(buffer);
self.info.build.buffers_written += 1;
self.attribute_buffers.insert(
(attribute.id, usage),
AttributeBuffer {
buffer: buffer.clone(),
version: attribute.version,
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, back_side: bool, width: u32, height: u32) -> Texture {
let format = self.output_buffer_type.color_gpu_format();
let slot = if back_side {
&self.back_side_frame
} else {
&self.opaque_frame
};
let existing = slot
.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(if back_side {
"three-rs viewportBackSideTexture"
} else {
"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_mag_filter(crate::textures::TextureFilter::Nearest);
texture.set_gpu(gpu);
if back_side {
self.back_side_frame = Some(texture.clone());
} else {
self.opaque_frame = Some(texture.clone());
}
texture
}
fn copy_framebuffer_to_opaque_frame(&mut self, source: &wgpu::Texture, texture: &Texture) {
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.inner().borrow_mut().stencil_buffer = self.stencil;
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 level = self.active_mipmap_level;
debug_assert!(
level < inner.mip_level_count,
"three-rs: active mipmap level {level} is past the render target's {} level(s); \
call RenderTarget::set_mip_level_count() first",
inner.mip_level_count,
);
let level = level.min(inner.mip_level_count - 1);
assert!(
level == 0
|| (!inner.depth_buffer
&& inner.depth_texture.is_none()
&& inner.samples <= 1
&& inner.extra_textures.is_empty()),
"three-rs: drawing into mip level {level} of a render target needs it to have no \
depth buffer, no depth texture, no MSAA (samples <= 1) and no extra MRT \
attachments; per-level depth and MSAA textures are not ported",
);
let single = inner.texture.with_gpu(|gpu| {
gpu.create_view(&wgpu::TextureViewDescriptor {
base_mip_level: level,
mip_level_count: Some(1),
..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(|mode| materials::blending::blending(&mode)),
})
.collect();
let name0 = inner
.texture_name
.clone()
.unwrap_or_else(|| OUTPUT_ATTACHMENT.to_string());
let color_blend = self
.mrt
.as_ref()
.and_then(|mrt| match mrt.blend_mode(&name0) {
Some(mode) => Some(materials::blending::blending(&mode)),
None => (name0 != OUTPUT_ATTACHMENT).then_some(None),
});
let clear_colors: Vec<Option<[f64; 4]>> = match &self.mrt {
Some(mrt) => std::iter::once(name0.as_str())
.chain(inner.extra_textures.iter().map(|(name, _)| name.as_str()))
.map(|name| mrt.clear_color(name))
.collect(),
None => Vec::new(),
};
let (depth_texture, depth_format) = match (&inner.depth_texture, &inner.depth) {
(Some(depth_texture), _) => (
Some(
depth_texture
.inner()
.borrow()
.gpu
.clone()
.expect("three-rs: prepare_render_target() created the depth texture"),
),
Some(depth_texture.gpu_format()),
),
(None, Some(depth)) => (
Some(depth.clone()),
Some(depth_buffer_format(inner.stencil_buffer)),
),
(None, None) => (None, None),
};
let depth = depth_texture
.as_ref()
.map(|texture| texture.create_view(&Default::default()));
PassTarget {
color,
extra_colors,
extra_color_targets,
color_blend,
clear_colors,
resolve,
color_texture: Some(inner.texture.with_gpu(|gpu| gpu.clone())),
depth,
depth_texture,
color_format,
depth_format,
sample_count: inner.samples.max(1),
width: (inner.width >> level).max(1),
height: (inner.height >> level).max(1),
viewport: Rect::of(
mip_rect(inner.viewport, level),
1.0,
(inner.width >> level).max(1),
(inner.height >> level).max(1),
),
scissor: inner.scissor_test.then(|| {
Rect::of(
mip_rect(inner.scissor, level),
1.0,
(inner.width >> level).max(1),
(inner.height >> level).max(1),
)
}),
}
}
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(),
color_blend: None,
clear_colors: Vec::new(),
resolve,
color_texture: Some(canvas.color.clone()),
depth: depth.clone(),
depth_texture: canvas.depth.clone(),
color_format: CANVAS_FORMAT,
depth_format: depth.map(|_| depth_buffer_format(self.stencil)),
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.stencil);
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.stencil));
self.canvas = Some(CanvasTarget {
width,
height,
sample_count,
color,
msaa,
depth,
});
}
fn create_depth_buffer(
&self,
width: u32,
height: u32,
sample_count: u32,
stencil: bool,
) -> 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: depth_buffer_format(stencil),
usage: wgpu::TextureUsages::RENDER_ATTACHMENT | wgpu::TextureUsages::COPY_SRC,
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: inner.mip_level_count,
sample_count: 1,
dimension: wgpu::TextureDimension::D2,
format,
usage: wgpu::TextureUsages::RENDER_ATTACHMENT
| wgpu::TextureUsages::TEXTURE_BINDING
| wgpu::TextureUsages::COPY_SRC
| if inner.copy_destination {
wgpu::TextureUsages::COPY_DST
} else {
wgpu::TextureUsages::empty()
},
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, inner.stencil_buffer));
}
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
| wgpu::TextureUsages::COPY_SRC
| if depth.copyable {
wgpu::TextureUsages::COPY_DST
} else {
wgpu::TextureUsages::empty()
},
view_formats: &[],
}));
}
}
}
}
fn mip_rect(rect: Vector4, level: u32) -> Vector4 {
if level == 0 {
return rect;
}
Vector4::new(
rect.x,
rect.y,
((rect.z as i64) >> level) as f64,
((rect.w as i64) >> level) as f64,
)
}
fn decode_rgba16f(bytes: &[u8]) -> Vec<f32> {
bytes
.as_chunks::<2>()
.0
.iter()
.map(|half| crate::extras::from_half_float(u16::from_le_bytes(*half)))
.collect()
}
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;
fn depth_buffer_format(stencil: bool) -> wgpu::TextureFormat {
if stencil {
wgpu::TextureFormat::Depth24PlusStencil8
} else {
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(not(target_arch = "wasm32"))]
fn shared_adapter() -> Result<wgpu::Adapter, Error> {
static ADAPTER: std::sync::OnceLock<Result<wgpu::Adapter, Option<String>>> =
std::sync::OnceLock::new();
ADAPTER
.get_or_init(|| {
let instance = wgpu::Instance::new(wgpu::InstanceDescriptor {
backends: BACKENDS,
..wgpu::InstanceDescriptor::new_without_display_handle()
});
pollster::block_on(pick_adapter(&instance)).map_err(|error| match error {
Error::NoAdapter { wanted } => wanted,
other => unreachable!("pick_adapter fails only with NoAdapter, not {other}"),
})
})
.clone()
.map_err(|wanted| Error::NoAdapter { wanted })
}
#[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 })
}
#[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 gather_light_state(
object: &mut crate::core::Object3D,
camera_view: &Matrix4,
shadow_map_enabled: bool,
) -> LightState {
let world_position = LightObject::world_position(&object.matrix_world);
let shadow_rendered = object.cast_shadow && shadow_map_enabled;
let light = object
.light_mut()
.expect("three-rs: the light list only holds lights");
if !shadow_rendered {
let (kind, angle, distance) = (light.kind, light.angle, light.distance);
let target_position = light.target_world_position();
if let Some(shadow) = light.shadow.as_deref_mut() {
if kind == LightKind::Spot {
shadow.update_spot_projection(angle, distance);
}
shadow.update_matrices(world_position, target_position);
}
}
let mut view_position = world_position;
view_position.apply_matrix4(camera_view);
let shadow = light.shadow.as_deref();
LightState {
color: light.color_intensity(),
view_position,
distance: light.distance,
decay: light.decay,
world_position,
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),
sh: light.sh_intensity(),
}
}
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,
) {
node_frame.velocity.rotate_bones(skeleton);
skeleton.borrow_mut().update();
node_frame.settle(claim, true);
}
}
fn scene_env_rotation(scene: &Scene) -> Matrix4 {
let mut m = Matrix4::identity();
if scene.environment.is_some() || scene.environment_node.is_some() {
m.make_rotation_from_euler(&scene.environment_rotation)
.transpose();
}
m
}
#[cfg(test)]
mod tests {
use super::*;
use crate::lights::SpotLight;
use crate::math::Vector3;
use crate::nodes::{UniformMember, UniformSource};
fn shadow_matrix_uniform(light: LightState) -> Vec<u8> {
let lights = [light];
let context = UniformContext {
lights: &lights,
..Default::default()
};
let member = UniformMember {
name: "shadowMatrix".into(),
source: UniformSource::ShadowMatrix(0),
ty: Type::Mat4,
offset: 0,
};
context.bytes(&[member], 64)
}
fn expected_spot_matrix(position: Vector3, angle: f64, distance: f64) -> Vec<u8> {
let mut shadow = LightShadow::spot();
shadow.update_spot_projection(angle, distance);
shadow.update_matrices(position, Vector3::new(0.0, 0.0, 0.0));
bytemuck::cast_slice(&shadow.matrix.to_f32_array()).to_vec()
}
#[test]
fn shadow_matrix_follows_a_light_that_casts_no_shadow() {
let node = SpotLight::new(Color::new(1.0, 1.0, 1.0), 1.0);
node.borrow_mut().position.set(3.0, 4.0, 5.0);
node.update_matrix_world(true);
assert!(!node.borrow().cast_shadow);
let angle = node.borrow().light().unwrap().angle;
let first = gather_light_state(&mut node.borrow_mut(), &Matrix4::identity(), true);
let first = shadow_matrix_uniform(first);
assert_eq!(
first,
expected_spot_matrix(Vector3::new(3.0, 4.0, 5.0), angle, 0.0)
);
let identity: Vec<u8> = bytemuck::cast_slice(&Matrix4::identity().to_f32_array()).to_vec();
assert_ne!(first, identity);
node.borrow_mut().position.set(-2.0, 6.0, 1.0);
node.update_matrix_world(true);
let moved = gather_light_state(&mut node.borrow_mut(), &Matrix4::identity(), true);
assert_eq!(
shadow_matrix_uniform(moved),
expected_spot_matrix(Vector3::new(-2.0, 6.0, 1.0), angle, 0.0)
);
}
#[test]
fn shadow_matrix_refresh_depends_on_the_shadow_being_rendered() {
let node = SpotLight::new(Color::new(1.0, 1.0, 1.0), 1.0);
node.borrow_mut().position.set(3.0, 4.0, 5.0);
node.borrow_mut().cast_shadow = true;
node.update_matrix_world(true);
let angle = node.borrow().light().unwrap().angle;
let rendered = gather_light_state(&mut node.borrow_mut(), &Matrix4::identity(), true);
let identity: Vec<u8> = bytemuck::cast_slice(&Matrix4::identity().to_f32_array()).to_vec();
assert_eq!(shadow_matrix_uniform(rendered), identity);
let disabled = gather_light_state(&mut node.borrow_mut(), &Matrix4::identity(), false);
assert_eq!(
shadow_matrix_uniform(disabled),
expected_spot_matrix(Vector3::new(3.0, 4.0, 5.0), angle, 0.0)
);
}
}