use super::deformation::InstanceDeformation;
use super::models::Model;
use super::objects::Objects;
use super::origin::translated;
use super::rays::instances::RayInstances;
use super::shadow_clusters::PosedClusters;
use super::slots::Slots;
use super::static_edits::posed_bounds;
use super::{Scene, SceneError};
use crate::content::identity::{Identity, InstanceId, ModelId};
use crate::content::instance::{InstanceState, Mobility};
use crate::shading::uniforms::{
OBJECT_CAPTURE_VISIBLE, OBJECT_DEFORMING, OBJECT_STATIC, OBJECT_VISIBLE, ObjectUniform,
};
use crate::static_lighting::AmbientCube;
use glam::{Mat4, Vec3};
pub(crate) struct Instance {
pub state: InstanceState,
pub mobility: Mobility,
pub baked_irradiance: AmbientCube,
pub casters: Vec<PosedClusters>,
submitted: Option<(Mat4, ModelId)>,
stale: bool,
pub deformation: Option<InstanceDeformation>,
}
impl Instance {
fn new(
state: InstanceState,
mobility: Mobility,
model: &Model,
deformation: Option<InstanceDeformation>,
) -> Self {
let mut instance = Self {
state,
mobility,
baked_irradiance: AmbientCube::default(),
casters: Vec::new(),
submitted: None,
stale: false,
deformation,
};
instance.pose_casters(model);
instance
}
fn pose_casters(&mut self, model: &Model) {
if self.mobility == Mobility::Static {
self.casters = model.caster_bounds(self.state.pose);
}
}
pub fn flags(&self) -> u32 {
let bit = |on: bool, bit: u32| if on { bit } else { 0 };
bit(self.mobility == Mobility::Static, OBJECT_STATIC)
| bit(self.state.visible, OBJECT_VISIBLE)
| bit(self.state.capture_visible, OBJECT_CAPTURE_VISIBLE)
| bit(self.deformation.is_some(), OBJECT_DEFORMING)
}
fn previous_pose(&self) -> Mat4 {
match (self.mobility, self.submitted) {
(Mobility::Moving, Some((pose, model))) if model == self.state.model => pose,
_ => self.state.pose,
}
}
fn record(&self) -> ObjectUniform {
let [deformed_positions, previous_positions, deformed_normals] = self
.deformation
.as_ref()
.map_or([0; 3], |deformation| deformation.record);
ObjectUniform {
model: self.state.pose.to_cols_array_2d(),
previous_model: self.previous_pose().to_cols_array_2d(),
baked_irradiance: self.baked_irradiance.packed(),
flags: self.flags(),
deformed_positions,
previous_positions,
deformed_normals,
}
}
pub fn bounds(&self, model: &Model) -> [Vec3; 2] {
self.deformation
.as_ref()
.map_or(model.bounds, |deformation| deformation.bounds)
}
pub fn mesh_bounds(&self, model: &Model, mesh: usize) -> Option<[Vec3; 2]> {
match &self.deformation {
Some(deformation) => Some(deformation.mesh_bounds[mesh]),
None => model.meshes[mesh].ranges.bounds(),
}
}
}
fn validate_pose(pose: Mat4) -> Result<(), SceneError> {
if !pose.is_finite() || !pose.inverse().is_finite() {
return Err(SceneError::InvalidPose);
}
Ok(())
}
pub(crate) struct Instances {
pub slots: Slots<InstanceId, Instance>,
pub objects: Objects,
counts: [usize; 2],
}
fn kind(mobility: Mobility) -> usize {
match mobility {
Mobility::Static => 0,
Mobility::Moving => 1,
}
}
impl Instances {
pub fn new(device: &wgpu::Device) -> Self {
Self {
slots: Slots::default(),
objects: Objects::new(device),
counts: [0; 2],
}
}
pub fn get(&self, id: InstanceId) -> Result<&Instance, SceneError> {
self.slots.get(id).ok_or(SceneError::UnknownInstance)
}
fn write(&self, queue: &wgpu::Queue, id: InstanceId) {
let instance = self.slots.get(id).expect("a live instance");
self.objects.write(queue, id.index(), &instance.record());
}
pub fn write_of_model(&self, queue: &wgpu::Queue, model: ModelId) {
for (id, instance) in self.slots.iter() {
if instance.state.model == model {
self.objects.write(queue, id.index(), &instance.record());
}
}
}
fn reserve(
&mut self,
device: &wgpu::Device,
queue: &wgpu::Queue,
count: usize,
) -> Result<(), SceneError> {
if self.objects.reserve(device, count)? {
for (id, instance) in self.slots.iter() {
self.objects.write(queue, id.index(), &instance.record());
}
}
Ok(())
}
pub fn pose_casters(&mut self, model: &Model, id: ModelId) {
for (_, instance) in self.slots.iter_mut() {
if instance.state.model == id {
instance.pose_casters(model);
}
}
}
pub fn static_poses(&self, model: ModelId) -> impl Iterator<Item = Mat4> + '_ {
self.slots
.iter()
.filter(move |(_, instance)| {
instance.mobility == Mobility::Static && instance.state.model == model
})
.map(|(_, instance)| instance.state.pose)
}
pub fn move_origin(
&mut self,
queue: &wgpu::Queue,
by: Vec3,
models: &super::models::Models,
rays: &mut RayInstances,
) {
let mut records = Vec::new();
for (id, instance) in self.slots.iter_mut() {
instance.state.pose = translated(instance.state.pose, by);
if let Some((pose, _)) = &mut instance.submitted {
*pose = translated(*pose, by);
}
let model = models
.slots
.get(instance.state.model)
.expect("an instance's model lives");
instance.pose_casters(model);
rays.set(id.index(), model.ray, instance.state.pose);
if records.len() <= id.index() {
records.resize(id.index() + 1, bytemuck::Zeroable::zeroed());
}
records[id.index()] = instance.record();
}
self.objects.write_all(queue, &records);
}
pub fn finish_frame(&mut self) {
for (_, instance) in self.slots.iter_mut() {
if let Some(deformation) = &mut instance.deformation {
deformation.finish(instance.state.visible);
}
if instance.mobility == Mobility::Moving {
let moved = instance.previous_pose() != instance.state.pose;
instance.submitted = instance
.state
.visible
.then_some((instance.state.pose, instance.state.model));
instance.stale |= moved;
}
}
}
pub fn prepare_frame(
&mut self,
queue: &wgpu::Queue,
models: &super::models::Models,
work: &mut Vec<crate::shading::deformation::DeformDispatch>,
) {
work.clear();
for (id, instance) in self.slots.iter_mut() {
let deforms = if let Some(deformation) = &mut instance.deformation {
let model = models.slots.get(instance.state.model);
let model = model.and_then(|model| model.deformation.as_ref());
deformation.prepare(model.expect("a deforming instance's model deforms"), work);
true
} else {
false
};
if instance.stale || deforms {
instance.stale = false;
self.objects.write(queue, id.index(), &instance.record());
}
}
}
}
impl Scene {
pub fn add_instance(
&mut self,
device: &wgpu::Device,
queue: &wgpu::Queue,
state: InstanceState,
mobility: Mobility,
) -> Result<InstanceId, SceneError> {
self.edited();
let deforms = self.models.get(state.model)?.deformation.is_some();
validate_pose(state.pose)?;
if deforms && mobility == Mobility::Static {
return Err(SceneError::DeformingModel);
}
let count = self.instances.slots.next_index() + 1;
let kind_count = self.instances.counts[kind(mobility)] + 1;
let reserved = self
.ray_instances
.reserve(device, queue, &mut self.rays, count, mobility, kind_count)
.and_then(|_| self.instances.reserve(device, queue, count))
.and_then(|_| {
let model = self.models.get(state.model)?;
model
.deformation
.as_ref()
.map(|model| InstanceDeformation::add(device, queue, &mut self.rays, model))
.transpose()
});
self.refresh_scene_group(device);
let deformation = reserved?;
let index = self.instances.slots.next_index();
let meshes = self.candidate_meshes(state.model, self.models.get(state.model)?);
let deformed = deformation
.as_ref()
.map(|deformation| deformation.mesh_bounds.as_slice());
let mirrored = state.pose.determinant() < 0.;
if let Err(error) = self
.candidates
.place(index, (state.model, &meshes), mirrored, deformed)
{
if let Some(deformation) = deformation {
deformation.free(&mut self.rays);
}
return Err(error);
}
let model = self.models.get_mut(state.model)?;
model.instances += 1;
if mobility == Mobility::Static {
self.static_edits
.record(posed_bounds(model.bounds, state.pose));
}
let id = self
.instances
.slots
.insert(Instance::new(state, mobility, model, deformation));
self.instances.counts[kind(mobility)] += 1;
self.write_instance(queue, id);
Ok(id)
}
fn write_instance(&mut self, queue: &wgpu::Queue, id: InstanceId) {
self.instances.write(queue, id);
let instance = self.instances.slots.get(id).expect("a live instance");
let (ray, pose) = (
self.drawn_model(instance.state.model).ray,
instance.state.pose,
);
self.ray_instances.set(id.index(), ray, pose);
}
pub fn instance(&self, id: InstanceId) -> Result<&InstanceState, SceneError> {
Ok(&self.instances.get(id)?.state)
}
pub fn set_instance(
&mut self,
queue: &wgpu::Queue,
id: InstanceId,
state: InstanceState,
) -> Result<(), SceneError> {
let previous = self.instances.get(id)?.state.model;
let deforms = self.models.get(state.model)?.deformation.is_some();
let old = self.instances.get(id)?.state;
if old != state && (old.capture_visible || state.capture_visible) {
if deforms {
self.deformation_edited();
} else {
self.edited();
}
}
validate_pose(state.pose)?;
if previous != state.model && (deforms || self.instances.get(id)?.deformation.is_some()) {
return Err(SceneError::DeformingModel);
}
let mirrored = |pose: glam::Mat4| pose.determinant() < 0.;
if previous != state.model || mirrored(old.pose) != mirrored(state.pose) {
let meshes = self.candidate_meshes(state.model, self.models.get(state.model)?);
let deformed = self
.instances
.get(id)?
.deformation
.as_ref()
.map(|deformation| deformation.mesh_bounds.as_slice());
self.candidates.place(
id.index(),
(state.model, &meshes),
mirrored(state.pose),
deformed,
)?;
}
if previous != state.model {
self.models.get_mut(previous)?.instances -= 1;
self.models.get_mut(state.model)?.instances += 1;
}
let instance = self.instances.slots.get_mut(id).unwrap();
if previous != state.model {
instance.baked_irradiance = AmbientCube::default();
}
if instance.mobility == Mobility::Static && instance.state != state {
let before = self.models.get(previous)?.bounds;
let after = self.models.get(state.model)?.bounds;
self.static_edits
.record(posed_bounds(before, instance.state.pose));
self.static_edits.record(posed_bounds(after, state.pose));
}
let placed = instance.state.pose != state.pose || previous != state.model;
instance.state = state;
instance.stale = false;
if placed {
instance.pose_casters(self.models.get(state.model)?);
}
self.write_instance(queue, id);
Ok(())
}
pub fn remove_instance(&mut self, id: InstanceId) -> Result<(), SceneError> {
self.edited();
let mut instance = self
.instances
.slots
.remove(id)
.ok_or(SceneError::UnknownInstance)?;
self.candidates.remove(id.index());
if let Some(deformation) = instance.deformation.take() {
deformation.free(&mut self.rays);
}
let model = self
.models
.get_mut(instance.state.model)
.expect("an instance's model lives");
model.instances -= 1;
self.instances.counts[kind(instance.mobility)] -= 1;
if instance.mobility == Mobility::Static {
self.static_edits
.record(posed_bounds(model.bounds, instance.state.pose));
}
Ok(())
}
pub fn set_instance_baked_irradiance(
&mut self,
queue: &wgpu::Queue,
id: InstanceId,
cube: AmbientCube,
) -> Result<(), SceneError> {
self.edited();
let instance = self
.instances
.slots
.get_mut(id)
.ok_or(SceneError::UnknownInstance)?;
if instance.mobility == Mobility::Static {
return Err(SceneError::StaticInstance);
}
instance.baked_irradiance = cube;
self.instances
.objects
.write_baked_irradiance(queue, id.index(), cube);
Ok(())
}
}