Maraiah/src/marathon/shp.rs

//! Marathon Shapes format handling.

use crate::durandal::{bin::*, err::*, fx32::*, image::*, text::*};
use bitflags::bitflags;

fn color(b: &[u8]) -> ResultS<(usize, ColorShp)>
{
   let l = c_byte(b, 0)?;
   let i = c_byte(b, 1)? as usize;
   let r = c_u16b(b, 2)?;
   let g = c_u16b(b, 4)?;
   let b = c_u16b(b, 6)?;
   let l = match l {
      128 => Ok(true),
      0 => Ok(false),
      _ => Err(err_msg("invalid flag in color")),
   }?;

   Ok((i, ColorShp::Opaque{r, g, b, l}))
}

fn clut_collection(b: &[u8],
                   clr_num: usize,
                   clu_num: usize)
                   -> ResultS<Vec<Vec<ColorShp>>>
{
   let mut tables = vec![vec![ColorShp::Translucent; clr_num]; clu_num];
   let mut p = 0;

   for i in 0..clu_num {
      let clut = &mut tables[i];

      for j in 0..clr_num {
         let (i, cr) = color(c_data(b, p..)?)?;

         if i >= clr_num {
            bail!("invalid index");
         }

         clut[i] = cr;
         p += 8;
      }
   }

   Ok(tables)
}

/*
fn frame(b: &[u8]) -> ResultS<()>
{
   let flags    = c_u16b(b, 0)?;
   let minlight = c_u32b(b, 2)?;
   let bmp_ind  = c_u16b(b, 6)?;
   //  orig_x   = c_i16b(b, 8)?;
   //  orig_y   = c_i16b(b, 10)?;
   //  key_x    = c_i16b(b, 12)?;
   //  key_y    = c_i16b(b, 14)?;
   let wrl_l    = c_i16b(b, 16)?;
   let wrl_r    = c_i16b(b, 18)?;
   let wrl_t    = c_i16b(b, 20)?;
   let wrl_b    = c_i16b(b, 22)?;
   let wrl_x    = c_i16b(b, 24)?;
   let wrl_y    = c_i16b(b, 26)?;
   let flags    = ok!(FrameFlags::from_bits(flags), "bad flag")?;
   let minlight = Fx32::from_bits(minlight);

   dbg!(flags);
   dbg!(minlight);
   dbg!(bmp_ind);
   dbg!(wrl_l);
   dbg!(wrl_r);
   dbg!(wrl_t);
   dbg!(wrl_b);
   dbg!(wrl_x);
   dbg!(wrl_y);

   Ok(())
}

fn sequence(b: &[u8]) -> ResultS<()>
{
   //  sq_type = c_u16b(b, 0)?;
   //  flags   = c_u16b(b, 2)?;
   let name    = c_data(b, 4..38)?;
   let v_type  = c_u16b(b, 38)?;
   let frames  = c_u16b(b, 40)?;
   let ticks   = c_u16b(b, 42)?;
   let key     = c_u16b(b, 44)?;
   let xfer    = c_u16b(b, 46)?;
   let xfer_pd = c_u16b(b, 48)?;
   let snd_beg = c_u16b(b, 50)?;
   let snd_key = c_u16b(b, 52)?;
   let snd_end = c_u16b(b, 54)?;
   //  xform   = c_u16b(b, 56)?;
   let loop_f  = c_u16b(b, 58)?;
   let name    = mac_roman_conv(ok!(pascal_str(name), "bad string")?);
   let snd_beg = ObjID::from_repr(snd_beg);
   let snd_key = ObjID::from_repr(snd_key);
   let snd_end = ObjID::from_repr(snd_end);

   dbg!(name);
   dbg!(v_type);
   dbg!(frames);
   dbg!(ticks);
   dbg!(key);
   dbg!(xfer);
   dbg!(xfer_pd);
   dbg!(snd_beg);
   dbg!(snd_key);
   dbg!(snd_end);
   dbg!(loop_f);

   Ok(())
}
*/

fn collection(b: &[u8]) -> ResultS<Collection>
{
   let version = c_u16b(b, 0)?;
   let cl_type = c_u16b(b, 2)?;
   //  flags   = c_u16b(b, 4)?;
   let clr_num = c_u16b(b, 6)? as usize;
   let clu_num = c_u16b(b, 8)? as usize;
   let clu_ofs = c_u32b(b, 10)? as usize;
   let seq_num = c_u16b(b, 14)? as usize;
   let seq_ofs = c_u32b(b, 16)? as usize;
   let frm_num = c_u16b(b, 20)? as usize;
   let frm_ofs = c_u32b(b, 22)? as usize;
   let bmp_num = c_u16b(b, 26)? as usize;
   let bmp_ofs = c_u32b(b, 28)? as usize;
   //  xform   = c_i16b(b, 30)?;
   let size    = c_u32b(b, 32)? as usize;
   let cl_type = CollectionType::from_repr(cl_type)?;

   if version != 3 {
      bail!("invalid collection version number");
   }

   /*
   for i in 0..frm_num {
      let p = c_u32b(b, frm_ofs + 4 * i)? as usize;
      frame(c_data(b, p..)?)?;
   }

   for i in 0..seq_num {
      let p = c_u32b(b, seq_ofs + 4 * i)? as usize;
      sequence(c_data(b, p..)?)?;
   }
   */

   let tables = clut_collection(&b[clu_ofs..], clr_num, clu_num)?;

   Ok(Collection{clr_num, tables, bitmaps: Vec::new()})
}

pub fn testfn_replaceme(b: &[u8]) -> ResultS<()>
{
   for i in 0..32 {
      let p         = 32 * i;
      //  status    = c_u16b(b, p + 0)?;
      //  flags     = c_u16b(b, p + 2)?;
      let offset_lo = c_u32b(b, p + 4)?  as usize;
      let length_lo = c_u32b(b, p + 8)?  as usize;
      let offset_hi = c_u32b(b, p + 12)? as usize;
      let length_hi = c_u32b(b, p + 16)? as usize;

      let collections =
         (if offset_lo != u32::max_value() as usize {
             Some(collection(c_data(b, offset_lo..offset_lo + length_lo)?)?)
          } else {
             None
          },
          if offset_hi != u32::max_value() as usize {
             Some(collection(c_data(b, offset_hi..offset_hi + length_hi)?)?)
          } else {
             None
          });

      dbg!(collections);
   }

   Ok(())
}

impl Image for ImageShp<'_>
{
   type Output = ColorShp;

   fn w(&self) -> usize {self.w}
   fn h(&self) -> usize {self.h}

   fn cr_at(&self, x: usize, y: usize) -> Option<&ColorShp>
   {
      self.clut.get(*self.cr.get(x + y * self.w)? as usize)
   }
}

impl Color for ColorShp
{
   type Comp = u16;
   const MAX: u32 = u16::max_value() as u32;

   fn r(&self) -> u16
   {
      match self {
         &ColorShp::Translucent => 0,
         &ColorShp::Opaque{r, ..} => r,
      }
   }

   fn g(&self) -> u16
   {
      match self {
         &ColorShp::Translucent => 0,
         &ColorShp::Opaque{g, ..} => g,
      }
   }

   fn b(&self) -> u16
   {
      match self {
         &ColorShp::Translucent => 0,
         &ColorShp::Opaque{b, ..} => b,
      }
   }

   fn a(&self) -> u16
   {
      match self {
         &ColorShp::Translucent => 0,
         &ColorShp::Opaque{..} => 255,
      }
   }
}

#[derive(Clone, Debug)]
enum ColorShp
{
   Translucent,
   Opaque
   {
      r: u16,
      g: u16,
      b: u16,
      l: bool,
   },
}

#[derive(Debug)]
struct ImageShp<'a>
{
   w:    usize,
   h:    usize,
   cr:   Vec<u8>,
   clut: &'a [ColorShp],
}

#[derive(Debug)]
struct Collection<'a>
{
   clr_num: usize,
   tables:  Vec<Vec<ColorShp>>,
   bitmaps: Vec<ImageShp<'a>>,
}

bitflags! {
   pub struct FrameFlags: u16
   {
      const Obscure = 0x20_00;
      const FlipY   = 0x40_00;
      const FlipX   = 0x80_00;
   }
}

c_enum! {
   #[derive(Debug)]
   pub enum CollectionType: u16
   {
      0 => Unused,
      1 => Wall,
      2 => Object,
      3 => Interface,
      4 => Scenery,
   }
}

// EOF