use crate::model::mdl::{Parser, Span, TokenKind, WriteFields as _, Writer};
use crate::model::Encoder;
use crate::model::FixedText;
use crate::model::IoError;
use crate::model::KnownChunk;
use crate::model::Model;
use crate::model::ModelVersion;
use crate::model::ValueError;
use crate::model::{mdl, mdx};
use crate::model::{BonesChunk, Cursor, HelpersChunk};
use crate::model::{Quaternion, Track, Vec3};
use bitfield::bitfield;
use std::io::Write as IoWrite;
const NAME_SIZE: usize = 80;
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,
),
allow_bits = 0x7f00
)]
pub struct NodeFlags(u32);
pub bits, _: 31, 0;
pub bone, set_bone: 8;
pub light, set_light: 9;
pub event_object, set_event_object: 10;
pub attachment, set_attachment: 11;
pub particle_emitter, set_particle_emitter: 12;
pub collision_shape, set_collision_shape: 13;
pub ribbon_emitter, set_ribbon_emitter: 14;
pub emitter_uses_mdl_or_unshaded, set_emitter_uses_mdl_or_unshaded: 15;
pub emitter_uses_tga_or_sort_far_z, set_emitter_uses_tga_or_sort_far_z: 16;
pub line_emitter, set_line_emitter: 17;
pub unfogged, set_unfogged: 18;
pub model_space, set_model_space: 19;
pub xy_quad, set_xy_quad: 20;
}
#[derive(Clone, Debug, PartialEq, mdx::Read, mdx::Write, mdl::Read, mdl::Write)]
#[mdx(sized(tag = HelpersChunk::TAG))]
#[mdl(fields)]
pub struct Node<F = NodeFlags> {
#[mdl(header)]
pub name: FixedText<NAME_SIZE>,
#[mdl(property = "ObjectId")]
pub object_id: u32,
#[mdl(
property = "Parent",
default = "no_reference",
skip_if = "is_no_reference"
)]
pub parent_id: u32,
#[mdl(flatten)]
pub flags: F,
#[mdx(tag = *b"KGTR")]
#[mdl(property = "Translation")]
pub translation: Option<Track<Vec3>>,
#[mdx(tag = *b"KGRT")]
#[mdl(property = "Rotation")]
pub rotation: Option<Track<Quaternion>>,
#[mdx(tag = *b"KGSC")]
#[mdl(property = "Scaling")]
pub scaling: Option<Track<Vec3>>,
}
#[derive(Clone, Debug, PartialEq, mdl::Read, mdl::Write)]
#[mdl(
block = "Bone",
after_read = "finish_bone",
validate_write = "validate_bone"
)]
pub struct Bone {
#[mdl(flatten)]
pub node: Node,
#[mdl(
property = "GeosetId",
default = "no_reference",
read_with = "read_geoset",
write_with = "write_geoset"
)]
pub geoset_id: u32,
#[mdl(
property = "GeosetAnimId",
default = "no_reference",
read_with = "read_geoset_animation",
write_with = "write_geoset_animation"
)]
pub geoset_animation_id: u32,
}
pub trait NodeFlagInterpretation: Copy + Default {
fn bits(self) -> u32;
fn from_bits(bits: u32) -> Self;
}
impl<F: NodeFlagInterpretation> Node<F> {
pub fn cast_flags<G: NodeFlagInterpretation>(self) -> Node<G> {
Node {
name: self.name,
object_id: self.object_id,
parent_id: self.parent_id,
flags: G::from_bits(self.flags.bits()),
translation: self.translation,
rotation: self.rotation,
scaling: self.scaling,
}
}
}
impl Node {
pub fn new(name: &str, object_id: u32) -> Result<Self, ValueError> {
let mut node = Self {
name: FixedText::default(),
object_id,
parent_id: u32::MAX,
flags: NodeFlags::default(),
translation: None,
rotation: None,
scaling: None,
};
node.name.set_text(name)?;
Ok(node)
}
}
impl Bone {
pub fn new(node: Node, geoset_id: u32, geoset_animation_id: u32) -> Self {
Self {
node,
geoset_id,
geoset_animation_id,
}
}
}
impl<V: ModelVersion> Model<V> {
pub fn bones(&self) -> Vec<Bone> {
self.collect_chunk_records::<BonesChunk>()
}
pub fn set_bones(&mut self, bones: &[Bone]) {
self.replace_chunk(BonesChunk::new(bones.to_vec()));
}
pub fn helpers(&self) -> Vec<Node> {
self.collect_chunk_records::<HelpersChunk>()
}
pub fn set_helpers(&mut self, helpers: &[Node]) {
self.replace_chunk(HelpersChunk::new(helpers.to_vec()));
}
}
impl mdx::Read for Bone {
fn read_mdx(cursor: &mut Cursor<'_>) -> Result<Self, mdx::ReadError> {
let node = cursor.read()?;
let geoset_id = cursor.read()?;
let geoset_animation_id = cursor.read()?;
Ok(Self {
node,
geoset_id,
geoset_animation_id,
})
}
}
impl mdx::Write for Bone {
fn write_mdx(&self, bytes: &mut Encoder<'_>) -> Result<(), mdx::WriteError> {
bytes.write(&self.node)?;
bytes.write(&self.geoset_id)?;
bytes.write(&self.geoset_animation_id)?;
Ok(())
}
}
fn no_reference() -> u32 {
u32::MAX
}
fn is_no_reference(value: &u32) -> bool {
*value == u32::MAX
}
fn finish_bone(value: &mut Bone, _: Span) -> Result<(), mdl::ReadError> {
value.node.flags.0 |= 0x100;
Ok(())
}
fn validate_bone(value: &Bone) -> Result<(), mdl::WriteError> {
validate_node_kind(&value.node, 0x100)
}
pub(crate) fn validate_node_kind<F: NodeFlagInterpretation>(
node: &Node<F>,
kind: u32,
) -> Result<(), mdl::WriteError> {
if node.flags.bits() & !0xff != kind {
return Err(mdl::WriteError::Unrepresentable {
field: "node object-kind bits",
});
}
Ok(())
}
pub(crate) fn set_node_kind<F: NodeFlagInterpretation>(node: &mut Node<F>, kind: u32) {
node.flags = F::from_bits(node.flags.bits() | kind);
}
fn read_reference(parser: &mut Parser<'_>, keyword: &str) -> Result<u32, mdl::ReadError> {
if parser
.peek()?
.is_some_and(|token| token.kind == TokenKind::Ident(keyword))
{
parser.next_token()?;
Ok(u32::MAX)
} else {
parser.read()
}
}
fn read_geoset(parser: &mut Parser<'_>) -> Result<u32, mdl::ReadError> {
read_reference(parser, "Multiple")
}
fn read_geoset_animation(parser: &mut Parser<'_>) -> Result<u32, mdl::ReadError> {
read_reference(parser, "None")
}
fn write_reference<W: IoWrite>(
value: &u32,
writer: &mut Writer<W>,
keyword: &str,
) -> Result<(), IoError<mdl::WriteError>> {
if *value == u32::MAX {
writer.identifier(keyword)
} else {
writer.write(value)
}
}
fn write_geoset<W: IoWrite>(
value: &u32,
writer: &mut Writer<W>,
) -> Result<(), IoError<mdl::WriteError>> {
write_reference(value, writer, "Multiple")
}
fn write_geoset_animation<W: IoWrite>(
value: &u32,
writer: &mut Writer<W>,
) -> Result<(), IoError<mdl::WriteError>> {
write_reference(value, writer, "None")
}
impl mdl::Read for Node {
fn read_mdl(parser: &mut Parser<'_>) -> Result<Self, mdl::ReadError> {
let start = parser.peek()?.map_or(0, |token| token.span.start);
parser.expect_ident("Helper")?;
mdl::read_mdl_body(parser, start)
}
}
impl mdl::Write for Node {
fn write_mdl<W: IoWrite>(
&self,
writer: &mut Writer<W>,
) -> Result<(), IoError<mdl::WriteError>> {
validate_node_kind(self, 0)?;
let state = self.prepare_mdl_fields(writer.dialect())?;
writer.indent()?;
writer.identifier("Helper")?;
self.write_mdl_headers(writer)?;
writer.open_body()?;
self.write_mdl_fields(state, writer)?;
writer.end_block()
}
}
macro_rules! impl_node_flags {
($flags:ident) => {
impl_node_flags!(@fields $flags,
(dont_inherit_translation, set_dont_inherit_translation, 0),
(dont_inherit_rotation, set_dont_inherit_rotation, 1),
(dont_inherit_scaling, set_dont_inherit_scaling, 2),
(billboarded, set_billboarded, 3),
(billboard_lock_x, set_billboard_lock_x, 4),
(billboard_lock_y, set_billboard_lock_y, 5),
(billboard_lock_z, set_billboard_lock_z, 6),
(camera_anchored, set_camera_anchored, 7)
);
impl NodeFlagInterpretation for $flags {
fn bits(self) -> u32 { self.0 }
fn from_bits(bits: u32) -> Self { Self(bits) }
}
};
(@fields $flags:ident, $(($get:ident, $set:ident, $bit:literal)),+) => {
impl $flags {
$(
#[doc = concat!("Returns the common `", stringify!($get), "` bit.")]
pub fn $get(&self) -> bool { self.0 & (1 << $bit) != 0 }
#[doc = concat!("Changes the common `", stringify!($get), "` bit, preserving all other bits.")]
pub fn $set(&mut self, value: bool) {
self.0 = (self.0 & !(1 << $bit)) | (u32::from(value) << $bit);
}
)+
}
};
}
pub(crate) use impl_node_flags;
impl_node_flags!(NodeFlags);