records.hpp

Go to the documentation of this file.

#pragma once

 
#include <array>
#include <cstdint>
#include <vector>
 
#include <welder/vocabulary.hpp>
 
#include <wowlib/core/client_version.hpp>
#include <wowlib/formats/m2/offset_block.hpp>
#include <wowlib/formats/m2/root/record/track.hpp>
 
namespace wowlib::formats::m2::chunked::record {
  struct [[
      =welder::weld,
      =welder::doc("An AFID entry: the .anim FileDataID for one (animation, "
        "variation) pair; 0 means none.")
    ]] AnimFileEntry {
    [[=welder::doc("AnimationData.dbc id of the sequence.")]]
    std::uint16_t animId = 0;
    [[=welder::doc("The sequence variation index.")]]
    std::uint16_t subAnimId = 0;
    [[=welder::doc("FileDataID of the .anim file; 0 means none.")]]
    std::uint32_t fileId = 0;
 
    bool operator==(const AnimFileEntry&) const = default;
  };
 
  static_assert(sizeof(AnimFileEntry) == 8);

  /** One EXPT record: the pre-EXP2 extended particle parameters (the client
      reconstructs EXP2 from these when EXP2 is absent). */
  struct [[
      =welder::weld,
      =welder::doc("An EXPT record: z-source, color and alpha multipliers for "
        "one particle emitter.")
    ]] M2ExtendedParticleSimple {
    [[=welder::doc("If > 0, initial velocity points from (0, 0, z_source) to "
      "the spawn point.")]]
    float zSource = 0;
    [[=welder::doc("Multiplied into the particle's diffuse color.")]]
    float colorMult = 1;
    [[=welder::doc("Multiplied into the particle's opacity.")]]
    float alphaMult = 1;
 
    bool operator==(const M2ExtendedParticleSimple&) const = default;
  };
 
  static_assert(sizeof(M2ExtendedParticleSimple) == 12);
 
  struct [[
      =welder::weld,
      =welder::doc("An EXP2 record: the EXPT parameters plus the per-lifetime "
        "alpha-cutoff ramp.")
    ]] M2ExtendedParticle {
    [[=welder::doc("If > 0, initial velocity points from (0, 0, z_source) to "
      "the spawn point.")]]
    float zSource = 0;
    [[=welder::doc("Multiplied into the particle's diffuse color.")]]
    float colorMult = 1;
    [[=welder::doc("Multiplied into the particle's opacity.")]]
    float alphaMult = 1;
    [[=welder::doc("Alpha-test threshold sampled by the particle's lifetime.")]]
    root::record::M2PartTrack<fixed16> alphaCutoff{};
 
    bool operator==(const M2ExtendedParticle&) const = default;
  };

  struct [[
      =welder::weld,
      =welder::doc("A DETL record (9.0+): per-light flags, shadow-RT scale and "
        "diffuse multiplier (raw half-floats).")
    ]] M2LightDetail {
    [[=welder::doc("Unknown per-light flags.")]]
    std::uint16_t flags = 0;
    [[=welder::doc("Scale for the shadow RT matrix (raw half-float).")]]
    std::uint16_t scaleHalf = 0;
    [[=welder::doc("Multiplier for the light's diffuse color (raw "
      "half-float).")]]
    std::uint16_t diffuseColorMultHalf = 0;
    [[=welder::doc("Unknown.")]]
    std::uint16_t unknown0 = 0;
    [[=welder::doc("Unknown.")]]
    std::uint32_t unknown1 = 0;
 
    bool operator==(const M2LightDetail&) const = default;
  };
 
  static_assert(sizeof(M2LightDetail) == 12);
 
  // The chunk payloads are NON-templated: their content is version-independent
  // (M2ExtendedParticle's alphaCutoff is the unversioned M2PartTrack, PSBC
  // holds unversioned M2Bounds, the rest are plain int arrays) and the chunks
  // only exist Legion+, so any embedded offset structure is fixed at its WotLK+
  // layout. Rather than propagate the shell's V through a type that never uses
  // it, they fix `version` at versions::legion — one welded class per payload,
  // no per-shell-version instantiation.
 
  struct [[
      =welder::weld,
      =welder::doc("The EXP2 chunk payload: extended particle records, one per "
        "particle emitter.")
    ]] Exp2Data : M2OffsetBlock<Exp2Data> {
    static constexpr ClientVersion Version = versions::Legion;
 
    [[=welder::mark::no_reassign,
      =welder::doc("Extended particle parameters, one per particle emitter.")]]
    std::vector<M2ExtendedParticle> content;


    [[=welder::mark::exclude]]
    bool empty() const { return content.empty(); }
 
    bool operator==(const Exp2Data&) const = default;
  };
 
  struct [[
      =welder::weld,
      =welder::doc("The PABC chunk payload: the parent-model sequence-id "
        "blacklist ('BlacklistAnimData').")
    ]] PabcData : M2OffsetBlock<PabcData> {
    static constexpr ClientVersion Version = versions::Legion;
 
    [[=welder::mark::no_reassign,
      =welder::doc("Replacement parent-sequence lookups: a plain list of "
        "present AnimationData ids.")]]
    std::vector<std::uint16_t> replacementParentSequenceLookups;

    [[=welder::mark::exclude]]
    bool empty() const { return replacementParentSequenceLookups.empty(); }
 
    bool operator==(const PabcData&) const = default;
  };
 
  struct [[
      =welder::weld,
      =welder::doc("The PSBC chunk payload: parent sequence bounds.")
    ]] PsbcData : M2OffsetBlock<PsbcData> {
    static constexpr ClientVersion Version = versions::Legion;
 
    [[=welder::mark::no_reassign,
      =welder::doc("Parent sequence bounds, one per parent sequence.")]]
    std::vector<root::record::M2Bounds> parentSequenceBounds;

    [[=welder::mark::exclude]]
    bool empty() const { return parentSequenceBounds.empty(); }
 
    bool operator==(const PsbcData&) const = default;
  };
 
  struct [[
      =welder::weld,
      =welder::doc("The PGD1 chunk payload: per-particle-emitter geoset "
        "assignments.")
    ]] Pgd1Data : M2OffsetBlock<Pgd1Data> {
    static constexpr ClientVersion Version = versions::Legion;
 
    [[=welder::mark::no_reassign,
      =welder::doc("The geoset each particle emitter obeys (M2SkinSection "
        "geoset rules).")]]
    std::vector<std::uint16_t> geosets;

    [[=welder::mark::exclude]]
    bool empty() const { return geosets.empty(); }
 
    bool operator==(const Pgd1Data&) const = default;
  };
}