use super::*;
impl MetalRenderer {
pub(super) unsafe fn encode_shadow(
&mut self,
pass_u: &ShadowPassGpu,
items: &[DrawItem],
slot: usize,
map: Id,
slice: usize,
radial: bool,
frustum: &crate::math::Frustum,
) -> Result<(), MetalError> {
let _pool = AutoreleasePool::new();
let chosen = if radial {
self.point_shadow_pipeline.as_ref()
} else {
self.shadow_pipeline.as_ref()
};
let Some(pipeline) = chosen else {
return Ok(());
};
let pipeline = pipeline.id();
let cmd = self.device.command_buffer();
if cmd.is_null() {
return Err(MetalError::NoCommandQueue);
}
let desc: Id = unsafe { msg0(class!("MTLRenderPassDescriptor"), sel!("renderPassDescriptor")) };
unsafe {
let depth: Id = msg0(desc, sel!("depthAttachment"));
let _: () = msg1(depth, sel!("setTexture:"), map);
let _: () = msg1(depth, sel!("setLoadAction:"), load_action::CLEAR);
let _: () = msg1(depth, sel!("setStoreAction:"), store_action::STORE);
let _: () = msg1(depth, sel!("setClearDepth:"), 1.0f64);
let _: () = msg1(depth, sel!("setSlice:"), slice as NSUInteger);
}
let encoder: Id = unsafe { msg1(cmd, sel!("renderCommandEncoderWithDescriptor:"), desc) };
if encoder.is_null() {
return Err(MetalError::NoCommandQueue);
}
let cut_pipeline = self.cut_shadow_pipeline.as_ref().map(|p| p.id());
let mut current = pipeline;
let mut last_cull = NSUInteger::MAX;
unsafe {
let _: () = msg1(encoder, sel!("setRenderPipelineState:"), pipeline);
let _: () = msg1(encoder, sel!("setFrontFacingWinding:"), winding::COUNTER_CLOCKWISE);
let _: () = msg1(
encoder,
sel!("setDepthStencilState:"),
self.depth_states[&(compare::LESS, true)].id(),
);
set_bytes(encoder, true, pass_u, VB_FRAME);
if radial {
set_bytes(encoder, false, pass_u, VB_FRAME);
}
}
for item in items {
if !item.cast_shadow {
continue;
}
if item.primitive != primitive::TRIANGLE {
continue;
}
if self.item_sphere(item).is_some_and(|s| !frustum.intersects_sphere(&s)) {
continue;
}
let key = Arc::as_ptr(&item.geometry) as usize;
let Some(geom) = self.geometries.get(&key) else {
continue;
};
let (vertices, indices, index_count, vertex_count, skin) = (
geom.vertices.id(),
geom.indices.as_ref().map(|b| b.id()),
geom.index_count,
geom.vertex_count,
geom.skin.as_ref().map(|b| b.id()),
);
let instances = item
.instance_slot
.and_then(|i| self.transients[slot].get(i))
.map(|b| b.id())
.unwrap_or(self.identity_instance.id());
let bones = item
.bone_slot
.and_then(|i| self.transients[slot].get(i))
.map(|b| b.id())
.unwrap_or(self.identity_instance.id());
let morph_u = item_morph_uniforms(item, geom.morph.as_ref());
let morph_buffer = geom
.morph
.as_ref()
.filter(|_| morph_u.info[0] > 0)
.map(|m| m.buffer.id())
.unwrap_or(self.identity_instance.id());
let (start, end) = (item.range.0 as usize, item.range.1 as usize);
let (map_texture, map_sampler) = self.material_texture(&item.material);
let mut draw_u = draw_uniforms(
item,
map_texture != self.white.id(),
item.instance_slot.is_some(),
&item.geometry,
);
if item.bone_slot.is_some() && skin.is_some() {
draw_u.maps[3] = 2;
}
let alpha = self.slot_texture(item.material.texture_slots().alpha_map.as_ref(), true);
draw_u.extra[0] = alpha.is_some() as u32;
let cut = item.material.alpha_test() > 0.0 && (draw_u.flags[1] == 1 || alpha.is_some());
let want = match (radial, cut, cut_pipeline) {
(false, true, Some(p)) => p,
_ => pipeline,
};
let cull = shadow_cull(item.material.side(), radial);
unsafe {
if want != current {
let _: () = msg1(encoder, sel!("setRenderPipelineState:"), want);
current = want;
}
if cull != last_cull {
let _: () = msg1(encoder, sel!("setCullMode:"), cull);
last_cull = cull;
}
if cut || radial {
let _: () = msg2(encoder, sel!("setFragmentTexture:atIndex:"), map_texture, 0usize);
let _: () = msg2(encoder, sel!("setFragmentSamplerState:atIndex:"), map_sampler, 0usize);
let (alpha_tex, alpha_smp) = alpha.unwrap_or((self.white.id(), map_sampler));
let _: () = msg2(encoder, sel!("setFragmentTexture:atIndex:"), alpha_tex, 1usize);
let _: () = msg2(encoder, sel!("setFragmentSamplerState:atIndex:"), alpha_smp, 1usize);
set_bytes(encoder, false, &draw_u, VB_DRAW);
}
let disp = self.slot_texture(item.material.texture_slots().displacement_map.as_ref(), true);
let _: () = msg2(encoder, sel!("setVertexTexture:atIndex:"), disp.map_or(self.white.id(), |(t, _)| t), 0usize);
let _: () = msg2(encoder, sel!("setVertexSamplerState:atIndex:"), disp.map_or(map_sampler, |(_, s)| s), 0usize);
let _: () = msg3(encoder, sel!("setVertexBuffer:offset:atIndex:"), vertices, 0usize, 0usize);
let _: () = msg3(encoder, sel!("setVertexBuffer:offset:atIndex:"), instances, 0usize, VB_INSTANCES);
let _: () = msg3(encoder, sel!("setVertexBuffer:offset:atIndex:"), skin.unwrap_or(vertices), 0usize, VB_SKIN);
let _: () = msg3(encoder, sel!("setVertexBuffer:offset:atIndex:"), bones, 0usize, VB_BONES);
let _: () = msg3(encoder, sel!("setVertexBuffer:offset:atIndex:"), morph_buffer, 0usize, VB_MORPH_DATA);
set_bytes(encoder, true, &morph_u, VB_MORPH);
set_bytes(encoder, true, &draw_u, VB_DRAW);
let n = item.instance_count.max(1) as NSUInteger;
match indices {
Some(ibuf) if index_count > 0 => {
let count = end.min(index_count).saturating_sub(start);
if count > 0 {
let _: () = msg6(
encoder,
sel!(
"drawIndexedPrimitives:indexCount:indexType:indexBuffer:indexBufferOffset:instanceCount:"
),
primitive::TRIANGLE,
count as NSUInteger,
index_type::UINT32,
ibuf,
start * std::mem::size_of::<u32>(),
n,
);
}
}
_ => {
let count = end.min(vertex_count).saturating_sub(start);
if count > 0 {
let _: () = msg4(
encoder,
sel!("drawPrimitives:vertexStart:vertexCount:instanceCount:"),
primitive::TRIANGLE,
start,
count as NSUInteger,
n,
);
}
}
}
}
}
unsafe {
let _: () = msg0(encoder, sel!("endEncoding"));
let _: () = msg0(cmd, sel!("commit"));
}
Ok(())
}
pub(super) fn ensure_shadow_arrays(&mut self, casters: &Casters) -> Result<(), MetalError> {
use crate::lights::shadow::shadow_layer_size;
let count = |want: fn(&Caster) -> bool| casters.iter().filter(|c| want(c)).map(Caster::layers).sum::<usize>();
let nd = count(|c| matches!(c, Caster::Dir { .. }));
let ns = count(|c| matches!(c, Caster::Spot { .. }));
let np = count(|c| matches!(c, Caster::Point { .. })) / 6;
let max_size = |want: fn(&Caster) -> bool| {
casters.iter().filter(|c| want(c)).map(|c| c.settings().map_size).max().unwrap_or(0)
};
if nd + ns + np == 0 {
return Ok(());
}
let array = |device: &MetalDevice, size: u32, layers: usize| {
crate::metal::resources::new_texture_array_levels(
device,
size,
size,
pixel_format::DEPTH32_FLOAT,
texture_usage::RENDER_TARGET | texture_usage::SHADER_READ,
layers as u32,
1,
)
};
if nd > 0 {
let size = shadow_layer_size(max_size(|c| matches!(c, Caster::Dir { .. })), nd);
if self.shadow_map.is_none() || self.shadow_size != size || self.shadow_layers[0] < nd {
self.shadow_map = Some(array(&self.device, size, nd)?);
self.shadow_size = size;
self.shadow_layers[0] = nd;
}
}
if ns > 0 {
let size = shadow_layer_size(max_size(|c| matches!(c, Caster::Spot { .. })), ns);
if self.spot_shadow_map.is_none() || self.spot_shadow_size != size || self.shadow_layers[1] < ns {
self.spot_shadow_map = Some(array(&self.device, size, ns)?);
self.spot_shadow_size = size;
self.shadow_layers[1] = ns;
}
}
if np > 0 {
if self.point_shadow_map.is_none() || self.shadow_layers[2] < 6 * np {
self.point_shadow_map = Some(array(&self.device, POINT_SHADOW_SIZE, 6 * np)?);
self.shadow_layers[2] = 6 * np;
}
if self.point_shadow_pipeline.is_none() {
self.point_shadow_pipeline =
Some(crate::metal::resources::point_shadow_pipeline(&self.device)?);
}
}
self.ensure_shadow_support()
}
pub(super) fn ensure_shadow_support(&mut self) -> Result<(), MetalError> {
if self.shadow_sampler.is_none() {
self.shadow_sampler = Some(crate::metal::resources::shadow_sampler(&self.device)?);
}
if self.shadow_pipeline.is_none() {
self.shadow_pipeline = Some(crate::metal::resources::shadow_pipeline(&self.device)?);
}
if self.cut_shadow_pipeline.is_none() {
self.cut_shadow_pipeline =
Some(crate::metal::resources::cut_shadow_pipeline(&self.device)?);
}
Ok(())
}
}