use super::{
MAX_PORTABLE_SHADER_VALUE, Mesh3d, Mesh3dObjectError, Mesh3dRenderError, Object3dId, Vec3,
interval_products_f64, is_portable_shader_source, shader_clip_point_ranges,
validate_clip_classification,
};
mod bounds;
#[cfg(test)]
mod tests;
pub(super) fn native_mesh_is_outside(
mesh: &Mesh3d,
model_rows: [[f32; 4]; 3],
camera_rows: [[f32; 4]; 4],
) -> bool {
bounds::native_mesh_is_outside(mesh, model_rows, camera_rows)
}
pub(super) fn fog_transform_is_proven(
mesh: &Mesh3d,
model_rows: [[f32; 4]; 3],
depth_row: [f32; 4],
) -> bool {
bounds::fog_transform_is_proven(mesh, model_rows, depth_row)
}
#[derive(Debug, Clone, Copy, Default, PartialEq, Eq)]
#[non_exhaustive]
pub enum SurfaceRasterization3d {
#[default]
StrictPortable,
Native,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[non_exhaustive]
pub enum Mesh3dSurfaceError {
NormalTransform,
FogArithmetic,
TransformArithmetic,
ClipPlaneClassification,
ClipIntersection,
ClippedVertexIdentity,
ClippedPolygonCapacity,
ClippedPolygonDegenerate,
PerspectiveDivide,
ClippedVertexOutside,
ProjectedOrientation,
}
impl Mesh3dSurfaceError {
#[cfg(test)]
pub(super) fn legacy(self) -> Mesh3dRenderError {
match self {
Self::TransformArithmetic => Mesh3dRenderError::InvalidGeometryTransform,
_ => Mesh3dRenderError::UnportableSurfaceTopology,
}
}
pub(super) fn for_triangle(
self,
object_id: Object3dId,
triangle_index: usize,
) -> Mesh3dRenderError {
Mesh3dRenderError::ObjectFailure {
object_id,
reason: Mesh3dObjectError::SurfaceTriangle {
triangle_index,
reason: self,
},
}
}
}
pub(super) fn validate_points_for_policy(
mesh: &Mesh3d,
model_rows: [[f32; 4]; 3],
camera_rows: [[f32; 4]; 4],
policy: SurfaceRasterization3d,
object_id: Object3dId,
) -> Result<(), Mesh3dRenderError> {
if policy == SurfaceRasterization3d::Native
&& bounds::native_transform_is_proven(mesh, model_rows, camera_rows)
{
return Ok(());
}
for (vertex_index, vertex) in mesh.vertices().iter().enumerate() {
let result = validate_point_for_policy(*vertex, model_rows, camera_rows, policy);
if let Err(reason) = result {
return Err(Mesh3dRenderError::ObjectFailure {
object_id,
reason: source_point_error(mesh, vertex_index, reason),
});
}
}
Ok(())
}
fn source_point_error(
mesh: &Mesh3d,
vertex_index: usize,
reason: Mesh3dSurfaceError,
) -> Mesh3dObjectError {
match mesh
.triangle_indices()
.iter()
.position(|index| *index as usize == vertex_index)
{
Some(index) => Mesh3dObjectError::SurfaceTriangle {
triangle_index: index / 3,
reason,
},
None => Mesh3dObjectError::Vertex {
vertex_index,
reason,
},
}
}
pub(super) fn validate_point_for_policy(
vertex: Vec3,
model_rows: [[f32; 4]; 3],
camera_rows: [[f32; 4]; 4],
policy: SurfaceRasterization3d,
) -> Result<(), Mesh3dSurfaceError> {
let clip = shader_clip_point_ranges(vertex, model_rows, camera_rows)
.map_err(|_| Mesh3dSurfaceError::TransformArithmetic)?;
if policy == SurfaceRasterization3d::StrictPortable {
validate_clip_classification(clip)
.map_err(|_| Mesh3dSurfaceError::ClipPlaneClassification)?;
}
Ok(())
}