material.hpp

Go to the documentation of this file.

#pragma once

 
#include <array>
#include <cstdint>
#include <string>
 
#include <welder/vocabulary.hpp>
 
#include <wowlib/core/lang.hpp>
#include <wowlib/core/client_version.hpp>
#include <wowlib/formats/m2/boundaries.hpp>
#include <wowlib/formats/m2/root/record/track.hpp>
 
namespace wowlib::formats::m2::root::record {
  struct [[
      =welder::weld,
      =welder::weld_as("M2Color"),
  WOWLIB_CS_FAMILY_SURFACE
      =welder::doc(R"(
        One color + alpha animation pair. Abstract over the client version; construct a concrete
        version with M2Color.ForVersion / for_version.)")
    ]] M2ColorBase {
    // The concretes default operator== — the base must be comparable too.
    bool operator==(const M2ColorBase&) const = default;
  };

  /** The version-agnostic base of every M2TextureWeight<V> (welded as "M2TextureWeight").
      Bindings-only, like every *Base: it gives the per-version classes a
      common welded supertype, so the family surface hoists their shared
      members and containers of them carry a base-typed live view. */
  struct [[
      =welder::weld,
      =welder::weld_as("M2TextureWeight"),
  WOWLIB_CS_FAMILY_SURFACE
      =welder::doc(R"(
        One texture weight (transparency) track. Abstract over the client version; construct a concrete
        version with M2TextureWeight.ForVersion / for_version.)")
    ]] M2TextureWeightBase {
    // The concretes default operator== — the base must be comparable too.
    bool operator==(const M2TextureWeightBase&) const = default;
  };


  struct [[
      =welder::weld,
      =welder::weld_as("M2TextureFlipbook"),
  WOWLIB_CS_FAMILY_SURFACE
      =welder::doc(R"(
        One texture flipbook animation. Abstract over the client version; construct a concrete
        version with M2TextureFlipbook.ForVersion / for_version.)")
    ]] M2TextureFlipbookBase {
    // The concretes default operator== — the base must be comparable too.
    bool operator==(const M2TextureFlipbookBase&) const = default;
  };

      Bindings-only, like every *Base: it gives the per-version classes a
      common welded supertype, so the family surface hoists their shared
      members and containers of them carry a base-typed live view. */
  struct [[
      =welder::weld,
      =welder::weld_as("M2TextureTransform"),
  WOWLIB_CS_FAMILY_SURFACE
      =welder::doc(R"(
        One texture UV transform animation. Abstract over the client version; construct a concrete
        version with M2TextureTransform.ForVersion / for_version.)")
    ]] M2TextureTransformBase {
    // The concretes default operator== — the base must be comparable too.
    bool operator==(const M2TextureTransformBase&) const = default;
  };
 
  struct [[
      =welder::weld,
      =welder::doc("An M2 vertex: position, 4-bone weights/indices, normal and "
        "two texture coordinate sets.")
    ]] M2Vertex {
    [[=welder::doc("Position in model space.")]]
    C3Vector pos{};
    [[=welder::doc("Influence weights of the four bones; they sum to 255.")]]
    std::array<std::uint8_t, 4> boneWeights{};
    [[=welder::doc("The four influencing bone indices.")]]
    std::array<std::uint8_t, 4> boneIndices{};
    [[=welder::doc("Normal in model space.")]]
    C3Vector normal{};
    [[=welder::doc("Two UV sets; the shader picks which are used.")]]
    std::array<C2Vector, 2> texCoords{};
 
    bool operator==(const M2Vertex&) const = default;
  };
 
  static_assert(sizeof(M2Vertex) == 48);
 
  enum class [[
      =welder::weld,
      =welder::flags,
      =welder::doc("M2Material render flags.")
    ]] MaterialFlags : std::uint16_t {
    Unlit [[=welder::doc("No lighting.")]] = 0x1,
    Unfogged [[=welder::doc("No fog.")]] = 0x2,
    TwoSided [[=welder::doc("No backface culling.")]] = 0x4,
    DepthTest [[=welder::doc("Depth test enabled.")]] = 0x8,
    DepthWrite [[=welder::doc("Depth write enabled.")]] = 0x10,
    NoCustomAlpha [[=welder::doc("MoP+: force fully opaque/transparent for "
      "custom elements.")]] = 0x800
  };
 
  struct [[
      =welder::weld,
      =welder::doc("An M2 material: render flags (see MaterialFlags) and the "
        "blending mode (see M2/Rendering M2BLEND).")
    ]] M2Material {
    [[=welder::doc("See MaterialFlags.")]]
    MaterialFlags flags{};
    [[=welder::doc("M2BLEND blending mode (see M2/Rendering).")]]
    std::uint16_t blendingMode = 0;
 
    bool operator==(const M2Material&) const = default;
  };
 
  static_assert(sizeof(M2Material) == 4);
 
  struct [[
      =welder::weld,
      =welder::doc("A texture definition: type 0 references the filename (TXID "
        "FileDataIDs replace it in 8.0+); non-zero types are runtime component "
        "slots (skin, hair, monster skins, ...).")
    ]] M2Texture {
    [[=welder::doc("0 = filename-referenced, else a component slot.")]]
    std::uint32_t type = 0;
    [[=welder::doc("0x1 wrap X, 0x2 wrap Y.")]]
    std::uint32_t flags = 0;
    [[=welder::doc(
      "For type 0; the serializer writes the NUL inside the count.")]]
    std::string filename;
 
    bool operator==(const M2Texture&) const = default;
  };
 
  namespace detail {
    // The annotated era layouts; instantiate through the canonicalizing
    // aliases below, never directly.
    template <ClientVersion V>
    struct [[
        =welder::weld,
        =welder::doc(
          "A vertex color + alpha animation pair, referenced from skin batches "
          "by color index.")
      ]] M2Color : M2ColorBase {
      [[=welder::doc("RGB vertex color.")]]
      record::M2Track<C3Vector, V> color{};
      [[=welder::doc("0 transparent .. 0x7FFF opaque.")]]
      record::M2Track<fixed16, V> alpha{};
 
      bool operator==(const M2Color&) const = default;
    };
 
    template <ClientVersion V>
    struct [[
        =welder::weld,
        =welder::doc("A global texture weight (transparency) track.")
      ]] M2TextureWeight : M2TextureWeightBase {
      [[=welder::doc("0 transparent .. 0x7FFF opaque; multiplies the color "
        "block's alpha.")]]
      record::M2Track<fixed16, V> weight{};
 
      bool operator==(const M2TextureWeight&) const = default;
    };
 
    template <ClientVersion V>
    struct [[
        =welder::weld,
        =welder::doc(
          "A pre-WotLK texture flipbook slot; never observed engaged in files.")
      ]] M2TextureFlipbook : M2TextureFlipbookBase {
      [[=welder::doc("Frame index keyframes.")]]
      record::M2Track<std::uint16_t, V> frames{};
 
      bool operator==(const M2TextureFlipbook&) const = default;
    };
 
    template <ClientVersion V>
    struct [[
        =welder::weld,
        =welder::doc(
          "A UV animation: translation/rotation/scaling keyframes for the "
          "texture matrix (rotation pivots at texture center 0.5, 0.5).")
      ]] M2TextureTransform : M2TextureTransformBase {
      [[=welder::doc("UV translation keyframes.")]]
      record::M2Track<C3Vector, V> translation{};
      [[=welder::doc("UV rotation keyframes, pivoting at the texture center.")]]
      record::M2Track<C4Quaternion, V> rotation{};
      [[=welder::doc("UV scaling keyframes.")]]
      record::M2Track<C3Vector, V> scaling{};
 
      bool operator==(const M2TextureTransform&) const = default;
    };
  }
 
  // The canonicalizing faces: these records' only version axis is the track
  // era of the animations they embed (M2TrackPivots).
  template <ClientVersion V>
  using M2Color = detail::M2Color<canonicalVersion(V, M2TrackPivots, M2Versions)>;
  template <ClientVersion V>
  using M2TextureWeight = detail::M2TextureWeight<canonicalVersion(V, M2TrackPivots, M2Versions)>;
  template <ClientVersion V>
  using M2TextureFlipbook = detail::M2TextureFlipbook<canonicalVersion(V, M2TrackPivots, M2Versions)>;
  template <ClientVersion V>
  using M2TextureTransform = detail::M2TextureTransform<canonicalVersion(V, M2TrackPivots, M2Versions)>;
}