use crate::assets::{ShaderId, TextureId};
use rayengine_core::glam::{Mat4, Vec2, Vec3, Vec4};
use raylib::prelude::Color;
#[derive(Clone, Copy, Debug, Default, PartialEq)]
pub enum AlphaMode {
#[default]
Opaque,
Cutout(f32),
Blend,
}
impl AlphaMode {
pub(crate) fn validate(self) -> Result<(), crate::Error> {
if let Self::Cutout(cutoff) = self
&& (!cutoff.is_finite() || !(0.0..=1.0).contains(&cutoff))
{
return Err(crate::Error::Asset(
"alpha cutoff must be finite and in 0..=1".into(),
));
}
Ok(())
}
}
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
pub struct UniformId {
pub(crate) shader: ShaderId,
pub(crate) index: usize,
}
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum UniformValue {
Float(f32),
Int(i32),
Bool(bool),
Vec2(Vec2),
Vec3(Vec3),
Vec4(Vec4),
Mat4(Mat4),
}
impl UniformValue {
pub(crate) fn gl_type(self) -> u32 {
match self {
Self::Float(_) => 0x1406,
Self::Int(_) => 0x1404,
Self::Bool(_) => 0x8B56,
Self::Vec2(_) => 0x8B50,
Self::Vec3(_) => 0x8B51,
Self::Vec4(_) => 0x8B52,
Self::Mat4(_) => 0x8B5C,
}
}
pub(crate) fn validate(self) -> Result<(), crate::Error> {
let finite = match self {
Self::Float(v) => v.is_finite(),
Self::Int(_) | Self::Bool(_) => true,
Self::Vec2(v) => v.is_finite(),
Self::Vec3(v) => v.is_finite(),
Self::Vec4(v) => v.is_finite(),
Self::Mat4(v) => v.is_finite(),
};
if finite {
Ok(())
} else {
Err(crate::Error::Asset("shader values must be finite".into()))
}
}
}
#[derive(Clone, Copy, Debug)]
pub struct MaterialParam {
pub uniform: UniformId,
pub value: UniformValue,
}
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
pub enum Shading {
#[default]
Unlit,
Lit,
}
#[derive(Clone, Debug)]
pub struct MaterialDesc {
pub texture: Option<TextureId>,
pub render_target: Option<crate::targets::RenderTargetId>,
pub shader: Option<ShaderId>,
pub shading: Shading,
pub tint: Color,
pub alpha: AlphaMode,
pub parameters: Vec<MaterialParam>,
}
impl Default for MaterialDesc {
fn default() -> Self {
Self {
texture: None,
render_target: None,
shader: None,
shading: Shading::Unlit,
tint: Color::WHITE,
alpha: AlphaMode::Opaque,
parameters: Vec::new(),
}
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn rejects_invalid_cutoffs_and_nonfinite_parameters() {
for cutoff in [f32::NAN, f32::INFINITY, -0.01, 1.01] {
assert!(AlphaMode::Cutout(cutoff).validate().is_err());
}
for cutoff in [0.0, 0.5, 1.0] {
assert!(AlphaMode::Cutout(cutoff).validate().is_ok());
}
for value in [
UniformValue::Float(f32::NAN),
UniformValue::Vec2(Vec2::splat(f32::INFINITY)),
UniformValue::Vec3(Vec3::splat(f32::NAN)),
UniformValue::Vec4(Vec4::splat(f32::NEG_INFINITY)),
UniformValue::Mat4(Mat4::from_cols_array(&[f32::NAN; 16])),
] {
assert!(value.validate().is_err());
}
for value in [
UniformValue::Float(1.0),
UniformValue::Int(-3),
UniformValue::Bool(true),
UniformValue::Mat4(Mat4::IDENTITY),
] {
assert!(value.validate().is_ok());
}
}
}