use crate::ecs::generational_registry::*;
use crate::ecs::skin::systems::GpuSkinData;
use std::collections::HashMap;
use super::super::super::projection::*;
use super::super::pass::SkinnedMeshPass;
use super::super::types::*;
fn skinned_material_layer_for(
layer_map: &HashMap<
crate::ecs::asset_id::TextureId,
crate::render::wgpu::material_texture_arrays::MaterialTextureLayer,
>,
id: Option<crate::ecs::asset_id::TextureId>,
) -> u32 {
id.and_then(|i| layer_map.get(&i))
.map(|l| l.packed())
.unwrap_or(NO_TEXTURE_LAYER)
}
fn skinned_default_material_data() -> MaterialData {
MaterialData {
base_color: [1.0, 1.0, 1.0, 1.0],
emissive_factor: [0.0, 0.0, 0.0],
alpha_mode: 0,
alpha_cutoff: 0.5,
base_layer: NO_TEXTURE_LAYER,
emissive_layer: NO_TEXTURE_LAYER,
normal_layer: NO_TEXTURE_LAYER,
metallic_roughness_layer: NO_TEXTURE_LAYER,
occlusion_layer: NO_TEXTURE_LAYER,
normal_scale: 1.0,
occlusion_strength: 1.0,
roughness: 0.5,
metallic: 0.0,
unlit: 0,
normal_map_flags: 0,
transmission_factor: 0.0,
transmission_layer: NO_TEXTURE_LAYER,
thickness: 0.0,
thickness_layer: NO_TEXTURE_LAYER,
attenuation_color: [1.0, 1.0, 1.0],
attenuation_distance: f32::INFINITY,
ior: 1.5,
specular_factor: 1.0,
_align_specular: [0, 0],
specular_color_factor: [1.0, 1.0, 1.0],
specular_layer: NO_TEXTURE_LAYER,
specular_color_layer: NO_TEXTURE_LAYER,
emissive_strength: 1.0,
_pad_before_transforms: [0, 0],
base_transform: GpuTextureTransform::IDENTITY,
emissive_transform: GpuTextureTransform::IDENTITY,
normal_transform: GpuTextureTransform::IDENTITY,
metallic_roughness_transform: GpuTextureTransform::IDENTITY,
occlusion_transform: GpuTextureTransform::IDENTITY,
transmission_transform: GpuTextureTransform::IDENTITY,
thickness_transform: GpuTextureTransform::IDENTITY,
specular_transform: GpuTextureTransform::IDENTITY,
specular_color_transform: GpuTextureTransform::IDENTITY,
clearcoat_factor: 0.0,
clearcoat_roughness_factor: 0.0,
clearcoat_normal_scale: 1.0,
clearcoat_layer: NO_TEXTURE_LAYER,
clearcoat_roughness_layer: NO_TEXTURE_LAYER,
clearcoat_normal_layer: NO_TEXTURE_LAYER,
_pad_clearcoat: [0, 0],
clearcoat_transform: GpuTextureTransform::IDENTITY,
clearcoat_roughness_transform: GpuTextureTransform::IDENTITY,
clearcoat_normal_transform: GpuTextureTransform::IDENTITY,
sheen_color_factor: [0.0, 0.0, 0.0],
sheen_roughness_factor: 0.0,
sheen_color_layer: NO_TEXTURE_LAYER,
_pad_sheen0: 0,
_pad_sheen: [0, 0],
sheen_color_transform: GpuTextureTransform::IDENTITY,
sheen_roughness_transform: GpuTextureTransform::IDENTITY,
iridescence_factor: 0.0,
iridescence_ior: 1.3,
iridescence_thickness_minimum: 100.0,
iridescence_thickness_maximum: 400.0,
iridescence_layer: NO_TEXTURE_LAYER,
_pad_iridescence0: 0,
_pad_iridescence: [0, 0],
iridescence_transform: GpuTextureTransform::IDENTITY,
iridescence_thickness_transform: GpuTextureTransform::IDENTITY,
anisotropy_strength: 0.0,
anisotropy_rotation_cos: 1.0,
anisotropy_rotation_sin: 0.0,
anisotropy_layer: NO_TEXTURE_LAYER,
anisotropy_transform: GpuTextureTransform::IDENTITY,
dispersion: 0.0,
diffuse_transmission_factor: 0.0,
_pad_diffuse_transmission0: 0,
diffuse_transmission_color_layer: NO_TEXTURE_LAYER,
diffuse_transmission_color_factor: [1.0, 1.0, 1.0],
blend_opaque_alpha_threshold: 0.99,
diffuse_transmission_transform: GpuTextureTransform::IDENTITY,
diffuse_transmission_color_transform: GpuTextureTransform::IDENTITY,
}
}
impl SkinnedMeshPass {
pub(in super::super) fn prepare_pass_node(
&mut self,
device: &wgpu::Device,
queue: &wgpu::Queue,
world: &crate::ecs::world::World,
) {
self.set_current_world(world.resources.world_id);
self.ensure_world_gpu_buffers(device);
self.frame_counter += 1;
self.state_mut().last_used_frame = self.frame_counter;
self.sync_skinned_meshes(device, queue, &world.resources.assets.mesh_cache);
self.state_mut().skinned_entities.clear();
self.state_mut().opaque_skinned_entities.clear();
self.state_mut().transparent_skinned_entities.clear();
let mut objects = Vec::new();
let mut materials = Vec::new();
let mut custom_data = Vec::new();
let mut entity_is_transparent: Vec<bool> = Vec::new();
let mut buffers_resized = false;
let max_buffer_size = device.limits().max_buffer_size as usize;
let matrix_size = std::mem::size_of::<[[f32; 4]; 4]>();
if self.skinning_cache.needs_rebuild(world) {
self.skinning_cache.rebuild_static_data(world);
if !self.skinning_cache.inverse_bind_matrices.is_empty() {
let required_size = self.skinning_cache.inverse_bind_matrices.len();
if required_size > self.inverse_bind_matrices_buffer_size {
let new_size = (required_size as f32 * 2.0).ceil() as usize;
let buffer_bytes = matrix_size * new_size;
if buffer_bytes > max_buffer_size {
tracing::error!(
"Inverse bind matrices buffer would exceed GPU limit: {} > {} bytes",
buffer_bytes,
max_buffer_size
);
} else {
self.inverse_bind_matrices_buffer =
device.create_buffer(&wgpu::BufferDescriptor {
label: Some("Inverse Bind Matrices Buffer (Resized)"),
size: buffer_bytes as u64,
usage: wgpu::BufferUsages::STORAGE | wgpu::BufferUsages::COPY_DST,
mapped_at_creation: false,
});
self.inverse_bind_matrices_buffer_size = new_size;
buffers_resized = true;
}
}
if self.skinning_cache.inverse_bind_matrices.len()
<= self.inverse_bind_matrices_buffer_size
{
queue.write_buffer(
&self.inverse_bind_matrices_buffer,
0,
bytemuck::cast_slice(&self.skinning_cache.inverse_bind_matrices),
);
}
}
if !self.skinning_cache.skin_data.is_empty() {
let required_size = self.skinning_cache.skin_data.len();
if required_size > self.skin_data_buffer_size {
let new_size = (required_size as f32 * 2.0).ceil() as usize;
let buffer_bytes = std::mem::size_of::<GpuSkinData>() * new_size;
if buffer_bytes > max_buffer_size {
tracing::error!(
"Skin data buffer would exceed GPU limit: {} > {} bytes",
buffer_bytes,
max_buffer_size
);
} else {
self.skin_data_buffer = device.create_buffer(&wgpu::BufferDescriptor {
label: Some("Skin Data Buffer (Resized)"),
size: buffer_bytes as u64,
usage: wgpu::BufferUsages::STORAGE | wgpu::BufferUsages::COPY_DST,
mapped_at_creation: false,
});
self.skin_data_buffer_size = new_size;
buffers_resized = true;
}
}
if self.skinning_cache.skin_data.len() <= self.skin_data_buffer_size {
queue.write_buffer(
&self.skin_data_buffer,
0,
bytemuck::cast_slice(&self.skinning_cache.skin_data),
);
}
}
}
let bone_transforms = self.skinning_cache.collect_bone_transforms(world);
if !bone_transforms.is_empty() {
let required_size = bone_transforms.len();
if required_size > self.bone_transforms_buffer_size {
let new_size = (required_size as f32 * 2.0).ceil() as usize;
let buffer_bytes = matrix_size * new_size;
if buffer_bytes > max_buffer_size {
tracing::error!(
"Bone transforms buffer would exceed GPU limit: {} > {} bytes",
buffer_bytes,
max_buffer_size
);
} else {
self.bone_transforms_buffer = device.create_buffer(&wgpu::BufferDescriptor {
label: Some("Bone Transforms Buffer (Resized)"),
size: buffer_bytes as u64,
usage: wgpu::BufferUsages::STORAGE | wgpu::BufferUsages::COPY_DST,
mapped_at_creation: false,
});
self.bone_transforms_buffer_size = new_size;
buffers_resized = true;
}
}
if bone_transforms.len() <= self.bone_transforms_buffer_size {
queue.write_buffer(
&self.bone_transforms_buffer,
0,
bytemuck::cast_slice(&bone_transforms),
);
}
}
let required_joints = self.skinning_cache.total_joints as usize;
if required_joints > self.joint_matrices_buffer_size {
let new_size = (required_joints as f32 * 2.0).ceil() as usize;
let buffer_bytes = matrix_size * new_size;
if buffer_bytes > max_buffer_size {
tracing::error!(
"Joint matrices buffer would exceed GPU limit: {} > {} bytes",
buffer_bytes,
max_buffer_size
);
} else {
self.joint_matrices_buffer = device.create_buffer(&wgpu::BufferDescriptor {
label: Some("Joint Matrices Buffer (Resized)"),
size: buffer_bytes as u64,
usage: wgpu::BufferUsages::STORAGE | wgpu::BufferUsages::COPY_DST,
mapped_at_creation: false,
});
self.joint_matrices_buffer_size = new_size;
buffers_resized = true;
self.rebuild_instance_bind_group(device);
}
}
if buffers_resized {
self.rebuild_skinning_compute_bind_group(device);
}
self.total_joints_to_dispatch = self.skinning_cache.total_joints;
for entity in world.core.query_entities(
crate::ecs::world::SKIN
| crate::ecs::world::RENDER_MESH
| crate::ecs::world::GLOBAL_TRANSFORM,
) {
if let Some(visibility) = world.core.get_visibility(entity)
&& !visibility.visible
{
continue;
}
let render_mesh = match world.core.get_render_mesh(entity) {
Some(rm) => rm,
None => continue,
};
let mesh_id = match self.skinned_meshes.get(&render_mesh.name) {
Some(&id) => id,
None => continue,
};
let skin_index = self
.skinning_cache
.entity_skin_indices
.get(&entity)
.copied()
.unwrap_or(0);
let joint_offset = self.skinning_cache.get_joint_offset(skin_index);
let material_id = materials.len() as u32;
let material_data = if let Some(material_ref) = world.core.get_material_ref(entity) {
let material_registry = &world.resources.assets.material_registry;
let resolved = if let Some(id) = material_ref.id {
registry_entry(&material_registry.registry, id.index, id.generation)
.map(|material| (material, id.index as usize))
} else {
registry_lookup_index(&material_registry.registry, &material_ref.name).and_then(
|(index, _generation)| {
material_registry.registry.entries[index as usize]
.as_ref()
.map(|material| (material, index as usize))
},
)
};
if let Some((material, registry_index)) = resolved {
let texture_ids = material_registry
.texture_ids
.get(registry_index)
.copied()
.unwrap_or_default();
let alpha_mode = match material.alpha_mode {
crate::ecs::material::components::AlphaMode::Opaque => 0,
crate::ecs::material::components::AlphaMode::Mask => 1,
crate::ecs::material::components::AlphaMode::Blend => 2,
};
let mut flags = 0u32;
if material.normal_map_flip_y {
flags |= NORMAL_MAP_FLIP_Y;
}
if material.normal_map_two_component {
flags |= NORMAL_MAP_TWO_COMPONENT;
}
MaterialData {
base_color: material.base_color,
emissive_factor: material.emissive_factor,
alpha_mode,
alpha_cutoff: material.alpha_cutoff,
base_layer: skinned_material_layer_for(
&self.material_layer_map,
texture_ids.base,
),
emissive_layer: skinned_material_layer_for(
&self.material_layer_map,
texture_ids.emissive,
),
normal_layer: skinned_material_layer_for(
&self.material_layer_map,
texture_ids.normal,
),
metallic_roughness_layer: skinned_material_layer_for(
&self.material_layer_map,
texture_ids.metallic_roughness,
),
occlusion_layer: skinned_material_layer_for(
&self.material_layer_map,
texture_ids.occlusion,
),
normal_scale: material.normal_scale,
occlusion_strength: material.occlusion_strength,
roughness: material.roughness,
metallic: material.metallic,
unlit: material.unlit as u32,
normal_map_flags: flags,
transmission_factor: material.transmission_factor,
transmission_layer: skinned_material_layer_for(
&self.material_layer_map,
texture_ids.transmission,
),
thickness: material.thickness,
thickness_layer: skinned_material_layer_for(
&self.material_layer_map,
texture_ids.thickness,
),
attenuation_color: material.attenuation_color,
attenuation_distance: material.attenuation_distance,
ior: material.ior,
specular_factor: material.specular_factor,
_align_specular: [0, 0],
specular_color_factor: material.specular_color_factor,
specular_layer: skinned_material_layer_for(
&self.material_layer_map,
texture_ids.specular,
),
specular_color_layer: skinned_material_layer_for(
&self.material_layer_map,
texture_ids.specular_color,
),
emissive_strength: material.emissive_strength,
_pad_before_transforms: [0, 0],
base_transform: GpuTextureTransform::from_material(
&material.base_texture_transform,
),
emissive_transform: GpuTextureTransform::from_material(
&material.emissive_texture_transform,
),
normal_transform: GpuTextureTransform::from_material(
&material.normal_texture_transform,
),
metallic_roughness_transform: GpuTextureTransform::from_material(
&material.metallic_roughness_texture_transform,
),
occlusion_transform: GpuTextureTransform::from_material(
&material.occlusion_texture_transform,
),
transmission_transform: GpuTextureTransform::from_material(
&material.transmission_texture_transform,
),
thickness_transform: GpuTextureTransform::from_material(
&material.thickness_texture_transform,
),
specular_transform: GpuTextureTransform::from_material(
&material.specular_texture_transform,
),
specular_color_transform: GpuTextureTransform::from_material(
&material.specular_color_texture_transform,
),
clearcoat_factor: material.clearcoat_factor,
clearcoat_roughness_factor: material.clearcoat_roughness_factor,
clearcoat_normal_scale: material.clearcoat_normal_scale,
clearcoat_layer: skinned_material_layer_for(
&self.material_layer_map,
texture_ids.clearcoat,
),
clearcoat_roughness_layer: skinned_material_layer_for(
&self.material_layer_map,
texture_ids.clearcoat_roughness,
),
clearcoat_normal_layer: skinned_material_layer_for(
&self.material_layer_map,
texture_ids.clearcoat_normal,
),
_pad_clearcoat: [0, 0],
clearcoat_transform: GpuTextureTransform::from_material(
&material.clearcoat_texture_transform,
),
clearcoat_roughness_transform: GpuTextureTransform::from_material(
&material.clearcoat_roughness_texture_transform,
),
clearcoat_normal_transform: GpuTextureTransform::from_material(
&material.clearcoat_normal_texture_transform,
),
sheen_color_factor: material.sheen_color_factor,
sheen_roughness_factor: material.sheen_roughness_factor,
sheen_color_layer: skinned_material_layer_for(
&self.material_layer_map,
texture_ids.sheen_color,
),
_pad_sheen0: 0,
_pad_sheen: [0, 0],
sheen_color_transform: GpuTextureTransform::from_material(
&material.sheen_color_texture_transform,
),
sheen_roughness_transform: GpuTextureTransform::from_material(
&material.sheen_roughness_texture_transform,
),
iridescence_factor: material.iridescence_factor,
iridescence_ior: material.iridescence_ior,
iridescence_thickness_minimum: material.iridescence_thickness_minimum,
iridescence_thickness_maximum: material.iridescence_thickness_maximum,
iridescence_layer: skinned_material_layer_for(
&self.material_layer_map,
texture_ids.iridescence,
),
_pad_iridescence0: 0,
_pad_iridescence: [0, 0],
iridescence_transform: GpuTextureTransform::from_material(
&material.iridescence_texture_transform,
),
iridescence_thickness_transform: GpuTextureTransform::from_material(
&material.iridescence_thickness_texture_transform,
),
anisotropy_strength: material.anisotropy_strength,
anisotropy_rotation_cos: material.anisotropy_rotation.cos(),
anisotropy_rotation_sin: material.anisotropy_rotation.sin(),
anisotropy_layer: skinned_material_layer_for(
&self.material_layer_map,
texture_ids.anisotropy,
),
anisotropy_transform: GpuTextureTransform::from_material(
&material.anisotropy_texture_transform,
),
dispersion: material.dispersion,
diffuse_transmission_factor: material.diffuse_transmission_factor,
_pad_diffuse_transmission0: 0,
diffuse_transmission_color_layer: skinned_material_layer_for(
&self.material_layer_map,
texture_ids.diffuse_transmission_color,
),
diffuse_transmission_color_factor: material
.diffuse_transmission_color_factor,
blend_opaque_alpha_threshold: material.blend_opaque_alpha_threshold,
diffuse_transmission_transform: GpuTextureTransform::from_material(
&material.diffuse_transmission_texture_transform,
),
diffuse_transmission_color_transform: GpuTextureTransform::from_material(
&material.diffuse_transmission_color_texture_transform,
),
}
} else {
skinned_default_material_data()
}
} else {
skinned_default_material_data()
};
let is_transparent = material_data.alpha_mode == 2;
entity_is_transparent.push(is_transparent);
materials.push(material_data);
custom_data.push([1.0f32, 1.0, 1.0, 1.0]);
let mesh_data = &self.skinned_mesh_data[mesh_id as usize];
let mut morph_weights = [0.0f32; 8];
if let Some(morph_component) = world.core.get_morph_weights(entity) {
for (index, weight) in morph_component.weights.iter().take(8).enumerate() {
morph_weights[index] = *weight;
}
}
let flip_winding = world
.core
.get_global_transform(entity)
.map(|transform| {
u32::from(
nalgebra_glm::determinant(&nalgebra_glm::mat4_to_mat3(&transform.0)) < 0.0,
)
})
.unwrap_or(0);
objects.push(SkinnedObjectData {
transform_index: 0,
mesh_id,
material_id,
joint_offset,
morph_weights,
morph_target_count: mesh_data.morph_target_count,
morph_displacement_offset: mesh_data.morph_displacement_offset,
mesh_vertex_offset: mesh_data.vertex_offset,
mesh_vertex_count: mesh_data.vertex_count,
flip_winding,
entity_id: entity.id,
_padding: [0; 2],
});
self.state_mut().skinned_entities.push(entity);
}
{
let skinned_entities: Vec<_> = self.state().skinned_entities.clone();
for (index, &entity) in skinned_entities.iter().enumerate() {
if entity_is_transparent[index] {
self.state_mut().transparent_skinned_entities.push(entity);
} else {
self.state_mut().opaque_skinned_entities.push(entity);
}
}
}
if objects.is_empty() {
return;
}
{
let gpu_object_buffer_size = self.gpu().object_buffer_size;
if objects.len() > gpu_object_buffer_size {
let new_size = (objects.len() as f32 * 2.0).ceil() as usize;
let world_state = self.world_states[self.current_world_id as usize]
.as_mut()
.unwrap();
let gpu = world_state.gpu_buffers.as_mut().unwrap();
gpu.object_buffer = device.create_buffer(&wgpu::BufferDescriptor {
label: Some("Skinned Mesh Object Buffer (Per-World, Resized)"),
size: (std::mem::size_of::<SkinnedObjectData>() * new_size) as u64,
usage: wgpu::BufferUsages::STORAGE | wgpu::BufferUsages::COPY_DST,
mapped_at_creation: false,
});
gpu.object_buffer_size = new_size;
}
self.rebuild_instance_bind_group(device);
}
{
let world_state = self.world_states[self.current_world_id as usize]
.as_mut()
.unwrap();
let gpu = world_state.gpu_buffers.as_mut().unwrap();
if materials.len() > gpu.materials_buffer_size {
let new_size = (materials.len() as f32 * 2.0).ceil() as usize;
gpu.materials_buffer = device.create_buffer(&wgpu::BufferDescriptor {
label: Some("Skinned Mesh Materials Buffer (Per-World, Resized)"),
size: (std::mem::size_of::<MaterialData>() * new_size) as u64,
usage: wgpu::BufferUsages::STORAGE | wgpu::BufferUsages::COPY_DST,
mapped_at_creation: false,
});
gpu.materials_buffer_size = new_size;
}
}
{
let gpu_custom_data_buffer_size = self.gpu().custom_data_buffer_size;
if custom_data.len() > gpu_custom_data_buffer_size {
let new_size = (custom_data.len() as f32 * 2.0).ceil() as usize;
let world_state = self.world_states[self.current_world_id as usize]
.as_mut()
.unwrap();
let gpu = world_state.gpu_buffers.as_mut().unwrap();
gpu.custom_data_buffer = device.create_buffer(&wgpu::BufferDescriptor {
label: Some("Skinned Mesh Custom Data Buffer (Per-World, Resized)"),
size: (std::mem::size_of::<[f32; 4]>() * new_size) as u64,
usage: wgpu::BufferUsages::STORAGE | wgpu::BufferUsages::COPY_DST,
mapped_at_creation: false,
});
gpu.custom_data_buffer_size = new_size;
}
self.rebuild_instance_bind_group(device);
}
queue.write_buffer(&self.gpu().object_buffer, 0, bytemuck::cast_slice(&objects));
queue.write_buffer(
&self.gpu().materials_buffer,
0,
bytemuck::cast_slice(&materials),
);
queue.write_buffer(
&self.gpu().custom_data_buffer,
0,
bytemuck::cast_slice(&custom_data),
);
self.sync_textures(&world.resources.texture_cache);
let light_result = collect_lights(world, MAX_LIGHTS);
let mut lights_data = light_result.lights_data;
let directional_light = light_result.directional_light;
let entity_to_lights_index = light_result.entity_to_index;
crate::render::wgpu::passes::geometry::projection::resolve_cookie_layers(
world,
&mut lights_data,
&entity_to_lights_index,
&self.material_layer_map,
&world.resources.texture_cache.registry,
);
let directional_light_direction = directional_light
.as_ref()
.map(|(_light, transform)| {
let dir = transform.forward_vector();
[dir.x, dir.y, dir.z, 0.0]
})
.unwrap_or([0.0, -1.0, 0.0, 0.0]);
let camera_position = world
.resources
.active_camera
.and_then(|cam| world.core.get_global_transform(cam))
.map(|t| nalgebra_glm::vec3(t.0[(0, 3)], t.0[(1, 3)], t.0[(2, 3)]))
.unwrap_or_else(|| nalgebra_glm::vec3(0.0, 0.0, 0.0));
let spotlight_result = collect_spotlight_shadows(world, camera_position);
apply_spotlight_shadow_indices(
&mut lights_data,
&spotlight_result.entity_to_shadow_index,
&entity_to_lights_index,
);
if !spotlight_result.shadow_data.is_empty() {
queue.write_buffer(
&self.spotlight_shadow_buffer,
0,
bytemuck::cast_slice(&spotlight_result.shadow_data),
);
}
{
let gpu_lights_buffer_size = self.gpu().lights_buffer_size;
if lights_data.len() > gpu_lights_buffer_size {
let new_size = (lights_data.len() as f32 * 2.0).ceil() as usize;
let world_state = self.world_states[self.current_world_id as usize]
.as_mut()
.unwrap();
let gpu = world_state.gpu_buffers.as_mut().unwrap();
gpu.lights_buffer = device.create_buffer(&wgpu::BufferDescriptor {
label: Some("Skinned Mesh Lights Buffer (Per-World, Resized)"),
size: (std::mem::size_of::<LightData>() * new_size) as u64,
usage: wgpu::BufferUsages::STORAGE | wgpu::BufferUsages::COPY_DST,
mapped_at_creation: false,
});
gpu.lights_buffer_size = new_size;
}
self.rebuild_instance_bind_group(device);
}
if !lights_data.is_empty() {
queue.write_buffer(
&self.gpu().lights_buffer,
0,
bytemuck::cast_slice(&lights_data),
);
}
let cascade_result = calculate_cascade_shadows(world, directional_light.as_ref());
let cascade_view_projections = cascade_result.cascade_view_projections;
let cascade_diameters = cascade_result.cascade_diameters;
let cascade_split_distances = cascade_result.cascade_split_distances;
let light_view_projection = cascade_result.light_view_projection;
let shadow_bias = cascade_result.shadow_bias;
let shadows_enabled = cascade_result.shadows_enabled;
let cascade_texture_resolution = if cfg!(target_arch = "wasm32") {
2048.0
} else {
4096.0
};
let cascade_atlas_offsets: [[f32; 4]; crate::render::wgpu::passes::NUM_SHADOW_CASCADES] = [
[
0.0,
0.0,
cascade_diameters[0] / cascade_texture_resolution,
0.0,
],
[
0.5,
0.0,
cascade_diameters[1] / cascade_texture_resolution,
0.0,
],
[
0.0,
0.5,
cascade_diameters[2] / cascade_texture_resolution,
0.0,
],
[
0.5,
0.5,
cascade_diameters[3] / cascade_texture_resolution,
0.0,
],
];
if let Some(camera_matrices) =
crate::ecs::camera::queries::query_active_camera_matrices(world)
{
let global_unlit = if world.resources.graphics.active_view.unlit_mode {
1.0
} else {
0.0
};
let (snap_resolution, snap_enabled) =
if let Some(ref vertex_snap) = world.resources.graphics.vertex_snap {
(vertex_snap.resolution, 1)
} else {
([320.0, 240.0], 0)
};
let affine_enabled = if world.resources.graphics.affine_texture_mapping {
1
} else {
0
};
let (fog_color, fog_enabled, fog_start, fog_end) =
if let Some(ref fog) = world.resources.graphics.active_view.fog {
(fog.color, 1, fog.start, fog.end)
} else {
([0.5, 0.5, 0.6], 0, 5.0, 30.0)
};
let time = world.resources.window.timing.uptime_milliseconds as f32 / 1000.0;
let camera_z_far = world
.resources
.active_camera
.and_then(|entity| world.core.get_camera(entity))
.map(|camera| match &camera.projection {
crate::ecs::camera::components::Projection::Perspective(persp) => {
persp.z_far.unwrap_or(1000.0)
}
crate::ecs::camera::components::Projection::Orthographic(ortho) => ortho.z_far,
})
.unwrap_or(1000.0);
let oit_z_scale = (camera_z_far * 0.2).max(1.0);
let uniforms = SkinnedMeshUniforms {
view: camera_matrices.view.into(),
projection: camera_matrices.projection.into(),
camera_position: [
camera_matrices.camera_position.x,
camera_matrices.camera_position.y,
camera_matrices.camera_position.z,
1.0,
],
num_lights: [lights_data.len() as u32, 0, 0, 0],
ambient_light: world.resources.graphics.active_view.ambient_light,
light_view_projection,
shadow_bias,
shadows_enabled,
global_unlit,
shadow_normal_bias: 1.8,
snap_resolution,
snap_enabled,
affine_enabled,
fog_color,
fog_enabled,
fog_start,
fog_end,
cascade_count: crate::render::wgpu::passes::NUM_SHADOW_CASCADES as u32,
_padding2: 0.0,
cascade_view_projections,
cascade_split_distances,
cascade_atlas_offsets,
cascade_atlas_scale: [0.5, 0.5, 0.0, 0.0],
time,
pbr_debug_mode: world.resources.graphics.pbr_debug_mode.as_u32(),
texture_debug_stripes: world.resources.graphics.texture_debug_stripes as u32,
texture_debug_stripes_speed: world.resources.graphics.texture_debug_stripes_speed,
directional_light_direction,
ibl_blend_factor: world.resources.graphics.ibl_blend_factor,
oit_z_scale,
_pad_pre_flat: [0.0; 2],
flat_color: world
.resources
.graphics
.active_view
.flat_shading_color
.map(|c| [c.x, c.y, c.z, c.w])
.unwrap_or([0.0; 4]),
_padding3: [0.0; 12],
};
queue.write_buffer(&self.uniform_buffer, 0, bytemuck::cast_slice(&[uniforms]));
let (screen_width, screen_height) =
if let Some((width, height)) = world.resources.window.cached_viewport_size {
(width, height)
} else {
(1920, 1080)
};
let (z_near, z_far) = world
.resources
.active_camera
.and_then(|cam| world.core.get_camera(cam))
.map(|cam| match &cam.projection {
crate::ecs::camera::components::Projection::Perspective(persp) => {
(persp.z_near, persp.z_far.unwrap_or(1000.0))
}
crate::ecs::camera::components::Projection::Orthographic(ortho) => {
(ortho.z_near, ortho.z_far)
}
})
.unwrap_or((0.1, 1000.0));
let tile_size_x = (screen_width as f32) / (CLUSTER_GRID_X as f32);
let tile_size_y = (screen_height as f32) / (CLUSTER_GRID_Y as f32);
let inverse_projection: [[f32; 4]; 4] =
nalgebra_glm::inverse(&camera_matrices.projection).into();
let cluster_uniforms = ClusterUniforms {
inverse_projection,
screen_size: [screen_width as f32, screen_height as f32],
z_near,
z_far,
cluster_count: [CLUSTER_GRID_X, CLUSTER_GRID_Y, CLUSTER_GRID_Z, 0],
tile_size: [tile_size_x, tile_size_y],
num_lights: lights_data.len() as u32,
num_directional_lights: light_result.num_directional_lights,
};
queue.write_buffer(
&self.gpu().cluster_uniforms_buffer,
0,
bytemuck::cast_slice(&[cluster_uniforms]),
);
}
}
}