Struct lu_formats::files::luz::Luz

pub struct Luz<'a> {

    pub file_version: u32,
    pub file_revision: Option<u32>,
    pub zone_id: u32,
    pub player_start: Option<Transform3>,
    pub num_scene_files: u32,
    pub scenes: Vec<Scene<'a>>,
    pub num_zone_boundary_lines: u8,
    pub boundary_lines: Vec<BoundaryInfo>,
    pub raw_filename: U1Str<'a>,
    pub zone_name: Option<U1Str<'a>>,
    pub zone_description: Option<U1Str<'a>>,
    pub zone_transition_data: Option<TransitionData<'a>>,
    pub paths: Option<PathData<'a>>,
}

Struct luz

LU Zone File Format

Parser: parse_luz

Depends on

• BoundaryInfo
• common::Transform3
• common::U1Str
• PathData
• Scene
• TransitionData

Fields

file_version: u32

file_revision: Option<u32>

If: file_version >= 36

zone_id: u32

player_start: Option<Transform3>

If: file_version >= 38

num_scene_files: u32

scenes: Vec<Scene<'a>>

Repeat-Expr: num_scene_files

num_zone_boundary_lines: u8

boundary_lines: Vec<BoundaryInfo>

Repeat-Expr: num_zone_boundary_lines

raw_filename: U1Str<'a>

zone_name: Option<U1Str<'a>>

If: file_version >= 31

zone_description: Option<U1Str<'a>>

If: file_version >= 31

zone_transition_data: Option<TransitionData<'a>>

If: file_version >= 32

paths: Option<PathData<'a>>

If: file_version >= 35

Trait Implementations

impl<'a> Clone for Luz<'a>

fn clone(&self) -> Luz<'a>

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<'a> Debug for Luz<'a>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'de, 'a> Deserialize<'de> for Luz<'a>

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<'a> PartialEq<Luz<'a>> for Luz<'a>

fn eq(&self, other: &Luz<'a>) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<'a> Serialize for Luz<'a>

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>where __S: Serializer,

Serialize this value into the given Serde serializer.

impl<'a> StructuralPartialEq for Luz<'a>