use crate::model::mdl::{is_zero, Span};
use crate::model::scene::{impl_node_flags, NodeFlagInterpretation};
use crate::model::scene::{set_node_kind, validate_node_kind};
use crate::model::Color;
use crate::model::FixedText;
use crate::model::KnownChunk;
use crate::model::PopcornEmittersChunk;
use crate::model::ValueError;
use crate::model::{mdl, mdx};
use crate::model::{Animatable, Track};
use crate::model::{Model, Node};
use crate::model::{ModelVersion, SupportsReforgedChunks};
use bitfield::bitfield;
const PATH_SIZE: usize = 260;
#[derive(Clone, Debug, PartialEq, mdx::Read, mdx::Write, mdl::Read, mdl::Write)]
#[mdx(sized(tag = PopcornEmittersChunk::TAG))]
#[mdl(
block = "ParticleEmitterPopcorn",
after_read = "finish_popcorn",
validate_write = "validate_popcorn"
)]
pub struct PopcornEmitter {
#[mdl(flatten)]
pub node: Node<PopcornFlags>,
#[mdx(tag = *b"KPPL")]
#[mdl(property = "LifeSpan", default = "one")]
pub life_span: Animatable<f32>,
#[mdx(tag = *b"KPPE")]
#[mdl(property = "EmissionRate", default = "one")]
pub emission_rate: Animatable<f32>,
#[mdx(tag = *b"KPPS")]
#[mdl(property = "Speed", default = "one")]
pub speed: Animatable<f32>,
#[mdx(tag = *b"KPPC")]
#[mdl(property = "Color", default = "white")]
pub color: Animatable<Color>,
#[mdx(tag = *b"KPPA")]
#[mdl(property = "Alpha", default = "one")]
pub alpha: Animatable<f32>,
#[mdl(property = "ReplaceableId", default, skip_if = "is_zero")]
pub replaceable_id: u32,
#[mdl(property = "Path", default)]
pub path: FixedText<PATH_SIZE>,
#[mdl(property = "AnimVisibilityGuide", default)]
pub visibility_guide: FixedText<PATH_SIZE>,
#[mdx(tag = *b"KPPV")]
#[mdl(property = "Visibility")]
pub visibility: Option<Track<f32>>,
}
impl PopcornEmitter {
pub fn new<F: NodeFlagInterpretation>(
node: Node<F>,
path: &str,
visibility_guide: &str,
) -> Result<Self, ValueError> {
let mut emitter = Self {
node: node.cast_flags(),
life_span: Animatable::Static(1.0),
emission_rate: Animatable::Static(1.0),
speed: Animatable::Static(1.0),
color: Animatable::Static([1.0; 3]),
alpha: Animatable::Static(1.0),
replaceable_id: 0,
path: FixedText::default(),
visibility_guide: FixedText::default(),
visibility: None,
};
emitter.path.set_text(path)?;
emitter.visibility_guide.set_text(visibility_guide)?;
Ok(emitter)
}
}
impl<V: ModelVersion> Model<V> {
pub fn try_popcorn_emitters(&self) -> Result<Vec<PopcornEmitter>, ValueError> {
self.check_chunk_version(*b"CORN")?;
Ok(self.collect_chunk_records::<PopcornEmittersChunk>())
}
pub fn try_set_popcorn_emitters(
&mut self,
emitters: &[PopcornEmitter],
) -> Result<(), ValueError> {
self.check_chunk_version(*b"CORN")?;
self.replace_chunk(PopcornEmittersChunk::new(emitters.to_vec()));
Ok(())
}
}
impl<V: SupportsReforgedChunks> Model<V> {
pub fn popcorn_emitters(&self) -> Vec<PopcornEmitter> {
self.collect_chunk_records::<PopcornEmittersChunk>()
}
pub fn set_popcorn_emitters(&mut self, emitters: &[PopcornEmitter]) {
self.replace_chunk(PopcornEmittersChunk::new(emitters.to_vec()));
}
}
fn one() -> Animatable<f32> {
Animatable::Static(1.0)
}
fn white() -> Animatable<Color> {
Animatable::Static([1.0; 3])
}
fn finish_popcorn(value: &mut PopcornEmitter, _: Span) -> Result<(), mdl::ReadError> {
set_node_kind(&mut value.node, 0x1000);
Ok(())
}
fn validate_popcorn(value: &PopcornEmitter) -> Result<(), mdl::WriteError> {
validate_node_kind(&value.node, 0x1000 | (value.node.flags.bits() & 0x78000))
}
bitfield! {
#[derive(Clone, Copy, Debug, Default, Eq, PartialEq, mdx::Read, mdx::Write, mdl::Read, mdl::Write)]
#[mdl(
flags(
DontInheritTranslation = 1,
DontInheritRotation = 2,
DontInheritScaling = 4,
Billboarded = 8,
BillboardedLockX = 16,
BillboardedLockY = 32,
BillboardedLockZ = 64,
CameraAnchored = 128,
SortPrimsFarZ = 65536,
Unshaded = 32768,
Unfogged = 131072,
PopcornScaling = 262144,
),
allow_bits = 0x1000
)]
pub struct PopcornFlags(u32);
pub bits, _: 31, 0;
pub unshaded, set_unshaded: 15;
pub sort_prims_far_z, set_sort_prims_far_z: 16;
pub unfogged, set_unfogged: 17;
pub popcorn_scaling, set_popcorn_scaling: 18;
}
impl PopcornFlags {
const MASK: u32 = 0x78000;
pub const fn from_bits(bits: u32) -> Self {
Self(bits)
}
}
impl PopcornEmitter {
pub fn flags(&self) -> PopcornFlags {
PopcornFlags::from_bits(self.node.flags.bits() & PopcornFlags::MASK)
}
pub fn set_flags(&mut self, flags: PopcornFlags) {
let bits =
(self.node.flags.bits() & !PopcornFlags::MASK) | (flags.bits() & PopcornFlags::MASK);
self.node.flags = PopcornFlags(bits);
}
}
impl_node_flags!(PopcornFlags);