@bis-toolkit/p3d 1.0.0

package/dist/mlod/index.d.ts

@@ -0,0 +1,15 @@
+/**
+ * MLOD (Bohemia Interactive model format) reader library
+ */
+export { Mlod } from './Mlod';
+export { MlodLod } from './MlodLod';
+export { Face } from './Face';
+export { Vertex } from './Vertex';
+export { Point } from './Point';
+export { Vector3 } from './Vector3';
+export { FaceFlags } from './FaceFlags';
+export { PointFlags } from './PointFlags';
+export { TaggReader } from './TaggReader';
+export { type Tagg, type AnimationTagg, type LockTagg, type MassTagg, type PropertyTagg, type SelectedTagg, type SharpEdgesTagg, type UVSetTagg, type NamedSelectionTagg, type EndOfFileTagg } from './Tagg';
+export { getLodName } from '../shared/Resolution';
+export { BinaryReader } from '@bis-toolkit/utils';

package/dist/odol/Animation.d.ts

@@ -0,0 +1,48 @@
+import { Vector3 } from './math';
+import { OdolReader } from './OdolReader';
+export declare enum AnimType {
+    Rotation = 0,
+    RotationX = 1,
+    RotationY = 2,
+    RotationZ = 3,
+    Translation = 4,
+    TranslationX = 5,
+    TranslationY = 6,
+    TranslationZ = 7,
+    Direct = 8,
+    Hide = 9
+}
+export declare class Animation {
+    kind: AnimType;
+    animName: string;
+    source: string;
+    minValue: number;
+    maxValue: number;
+    minPhase: number;
+    maxPhase: number;
+    sourceAddress: number;
+    protected read(reader: OdolReader, kind: AnimType): void;
+}
+export declare class AnimationRotation extends Animation {
+    angle0: number;
+    angle1: number;
+    static fromReader(reader: OdolReader, kind: AnimType): AnimationRotation;
+}
+export declare class AnimationTranslation extends Animation {
+    offset0: number;
+    offset1: number;
+    static fromReader(reader: OdolReader, kind: AnimType): AnimationTranslation;
+}
+export declare class AnimationDirect extends Animation {
+    axisPos: Vector3;
+    axisDir: Vector3;
+    angle: number;
+    axisOffset: number;
+    static fromReader(reader: OdolReader, kind: AnimType): AnimationDirect;
+}
+export declare class AnimationHide extends Animation {
+    hideValue: number;
+    static fromReader(reader: OdolReader, kind: AnimType): AnimationHide;
+}
+export declare function isAnimationDirect(anim: Animation): anim is AnimationDirect;
+export declare function isAnimationHide(anim: Animation): anim is AnimationHide;

package/dist/odol/Animations.d.ts

@@ -0,0 +1,12 @@
+import { Animation } from './Animation';
+import { Vector3 } from './math';
+import { OdolReader } from './OdolReader';
+export declare class Animations {
+    animations: Animation[];
+    bonesToAnims: number[][][];
+    animsToBones: {
+        boneIdx: number;
+        axisData?: [Vector3, Vector3];
+    }[][];
+    static fromReader(reader: OdolReader): Animations;
+}

package/dist/odol/Materials.d.ts

@@ -0,0 +1,51 @@
+import { Matrix4 } from './math';
+import { OdolReader } from './OdolReader';
+/**
+ * Color with RGBA float components
+ */
+export declare class Color {
+    r: number;
+    g: number;
+    b: number;
+    a: number;
+    static fromReader(reader: OdolReader): Color;
+}
+export declare class StageTexture {
+    textureFilter: number;
+    texture: string;
+    stageId: number;
+    useWorldEnvMap: boolean;
+    static fromReader(reader: OdolReader): StageTexture;
+}
+export declare class StageTransform {
+    uvSource: number;
+    transformation: Matrix4;
+    static fromReader(reader: OdolReader): StageTransform;
+}
+export declare class EmbeddedMaterial {
+    materialName: string;
+    version: number;
+    emissive: Color;
+    ambient: Color;
+    diffuse: Color;
+    forcedDiffuse: Color;
+    specular: Color;
+    emissive2: Color;
+    specular2: Color;
+    unkCol1: Color;
+    unkCol2: Color;
+    specularPower: number;
+    pixelShaderId: number;
+    vertexShaderId: number;
+    mainLight: number;
+    fogMode: number;
+    surfaceFile: string;
+    nRenderFlags: number;
+    renderFlags: number;
+    stageTextures: StageTexture[];
+    stageTransforms: StageTransform[];
+    stageTI: StageTexture | null;
+    unk2: number;
+    unk3: number;
+    static fromReader(reader: OdolReader): EmbeddedMaterial;
+}

package/dist/odol/ModelInfo.d.ts

@@ -0,0 +1,71 @@
+import { OdolReader } from './OdolReader';
+import { Vector3, Matrix3 } from './math';
+import { PackedColor } from './PackedColor';
+import { ClipFlags, ShadowBufferSource, MapType } from './enums';
+import { Skeleton } from './auxiliaryStructures';
+/**
+ * Model information (metadata and properties)
+ */
+export declare class ModelInfo {
+    special: number;
+    boundingSphere: number;
+    geometrySphere: number;
+    remarks: number;
+    andHints: ClipFlags;
+    orHints: ClipFlags;
+    aimingCenter: Vector3;
+    color: PackedColor;
+    colorType: PackedColor;
+    viewDensity: number;
+    bboxMin: Vector3;
+    bboxMax: Vector3;
+    bboxMinVisual: Vector3;
+    bboxMaxVisual: Vector3;
+    boundingCenter: Vector3;
+    geometryCenter: Vector3;
+    centerOfMass: Vector3;
+    invInertia: Matrix3;
+    autoCenter: boolean;
+    lockAutoCenter: boolean;
+    canOcclude: boolean;
+    canBeOccluded: boolean;
+    unknownBool: boolean;
+    unknownFloat: number;
+    forceNotAlphaModel: boolean;
+    sbSource: ShadowBufferSource;
+    preferShadowVolume: boolean;
+    shadowOffset: number;
+    animated: boolean;
+    skeleton: Skeleton;
+    mapType: MapType;
+    massArray: number[];
+    mass: number;
+    invMass: number;
+    armor: number;
+    invArmor: number;
+    htMin: number;
+    htMax: number;
+    afMax: number;
+    mfMax: number;
+    mFact: number;
+    tBody: number;
+    minShadow: number;
+    canBlend: boolean;
+    propertyClass: string;
+    propertyDamage: string;
+    propertyFrequent: boolean;
+    memoryIndex: number;
+    geometryIndex: number;
+    unkLodType1Index: number;
+    geometryFireIndex: number;
+    geometryViewIndex: number;
+    geometryViewPilotIndex: number;
+    geometryViewGunnerIndex: number;
+    unkLodType2Index: number;
+    geometryViewCargoIndex: number;
+    landContactIndex: number;
+    roadwayIndex: number;
+    pathsIndex: number;
+    hitpointsIndex: number;
+    static fromReader(reader: OdolReader): ModelInfo;
+}

package/dist/odol/Odol.d.ts

@@ -0,0 +1,47 @@
+import { OdolReader } from './OdolReader';
+import { OdolLod } from './OdolLod';
+import { ModelInfo } from './ModelInfo';
+import { Animations } from './Animations';
+import { Skeleton } from './auxiliaryStructures';
+import { P3D, P3dStats } from '../shared/P3d';
+/**
+ * Main ODOL file reader
+ * ODOL is the compiled/binary format for Bohemia Interactive 3D models
+ */
+export declare class Odol implements P3D {
+    version: number;
+    modelInfo: ModelInfo | null;
+    lods: OdolLod[];
+    animations: Animations | null;
+    static readonly MIN_SUPPORTED_VERSION = 53;
+    static readonly MAX_SUPPORTED_VERSION = 54;
+    /**
+     * Read ODOL from a buffer
+     */
+    static fromBuffer(buffer: Buffer | Uint8Array): Odol;
+    /**
+     * Read ODOL from an OdolReader
+     */
+    static fromReader(reader: OdolReader): Odol;
+    /**
+     * Get skeleton from model info
+     */
+    get skeleton(): Skeleton | null;
+    /**
+     * Get mass from model info
+     */
+    get mass(): number;
+    /**
+     * Check if model has animations
+     */
+    get hasAnims(): boolean;
+    /**
+     * Get all unique textures across all LODs
+     */
+    get allTextures(): string[];
+    get allMaterials(): string[];
+    /**
+     * Get statistics about the model
+     */
+    getStats(): Partial<P3dStats>;
+}

package/dist/odol/OdolLod.d.ts

@@ -0,0 +1,75 @@
+import { OdolReader } from './OdolReader';
+import { Vector3 } from './math';
+import { ClipFlags, SpecialFlags } from './enums';
+import { ProxyObject, SubSkeletonIndexSet, Keyframe, LodMetadata } from './auxiliaryStructures';
+import { EmbeddedMaterial } from './Materials';
+import { Polygons, Section, NamedSelection, Face } from './structures';
+import { VertexData } from './VertexData';
+import { ILod } from '../shared/Lod';
+/**
+ * ODOL LOD (Level of Detail)
+ */
+export declare class OdolLod implements ILod {
+    resolution: number;
+    proxyObjects: ProxyObject[];
+    subSkeletonsToSkeleton: number[];
+    skeletonToSubSkeleton: SubSkeletonIndexSet[];
+    vertexCount: number;
+    faceArea: number;
+    orHints: ClipFlags;
+    andHints: ClipFlags;
+    bMin: Vector3;
+    bMax: Vector3;
+    bCenter: Vector3;
+    bRadius: number;
+    textures: string[];
+    materials: EmbeddedMaterial[];
+    pointToVertex: number[];
+    vertexToPoint: number[];
+    polygons: Polygons;
+    sections: Section[];
+    namedSelections: NamedSelection[];
+    namedProperties: [string, string][];
+    frames: Keyframe[];
+    iconColor: number;
+    selectedColor: number;
+    special: SpecialFlags;
+    vertexData: VertexData;
+    lodMetadata: LodMetadata | null;
+    static fromReader(reader: OdolReader): OdolLod;
+    /**
+     * Get resolution name
+     */
+    get resolutionName(): string;
+    /**
+     * Get all unique texture paths
+     */
+    get allTextures(): string[];
+    /**
+     * Get all material names
+     */
+    get materialNames(): string[];
+    /**
+     * Get vertices
+     */
+    get vertices(): Vector3[];
+    get verticesCount(): number;
+    get facesCount(): number;
+    /**
+     * Get face count
+     */
+    get faces(): Face[];
+    /**
+     * Get statistics about this LOD
+     */
+    getStats(): {
+        resolution: number;
+        vertexCount: number;
+        faceCount: number;
+        textureCount: number;
+        materialCount: number;
+        sectionCount: number;
+        namedSelectionCount: number;
+        proxyCount: number;
+    };
+}

package/dist/odol/OdolReader.d.ts

@@ -0,0 +1,30 @@
+import { BinaryReader } from '@bis-toolkit/utils';
+import { Vector3 } from './math';
+/**
+ * Extended BinaryReader with ODOL-specific functionality
+ * Handles compression and compressed arrays
+ */
+export declare class OdolReader extends BinaryReader {
+    version: number;
+    /**
+     * Read an array of elements
+     */
+    readArray<T>(readElement: (reader: OdolReader) => T, size?: number): T[];
+    /**
+     * Read a compressed array of elements
+     */
+    readCompressedArray<T>(readElement: (reader: OdolReader) => T, elemSize: number): T[];
+    /**
+     * Read a compressed fill array (optimized for arrays with many repeated values)
+     */
+    readCompressedFillArray<T>(readElement: (reader: OdolReader) => T, sizeOfT: number): T[];
+    /**
+     * Read compressed data
+     */
+    readCompressed(expectedSize: number): Uint8Array;
+    /**
+     * Read compressed vertex index array
+     */
+    readCompressedVertexIndexArray(): number[];
+    readCompressedVector3(): Vector3;
+}

package/dist/odol/PackedColor.d.ts

@@ -0,0 +1,14 @@
+import { BinaryReader } from '@bis-toolkit/utils';
+/**
+ * Packed color (RGBA as a single 32-bit integer)
+ */
+export declare class PackedColor {
+    value: number;
+    constructor(value?: number);
+    static fromReader(reader: BinaryReader): PackedColor;
+    get r(): number;
+    get g(): number;
+    get b(): number;
+    get a(): number;
+    toArray(): [number, number, number, number];
+}

package/dist/odol/VertexData.d.ts

@@ -0,0 +1,52 @@
+import { OdolReader } from './OdolReader';
+import { Vector3 } from './math';
+import { ClipFlags } from './enums';
+import { UVSet } from './structures';
+/**
+ * Animation RT pair
+ */
+export declare class AnimationRTPair {
+    selectionIndex: number;
+    weight: number;
+    constructor(selectionIndex: number, weight: number);
+}
+/**
+ * Animation RT weight
+ */
+export declare class AnimationRTWeight {
+    private nSmall;
+    private smallSpace;
+    static fromReader(reader: OdolReader): AnimationRTWeight;
+    getAnimationRTPairs(): AnimationRTPair[];
+}
+/**
+ * Vertex neighbor info
+ */
+export declare class VertexNeighborInfo {
+    posA: number;
+    private unk1;
+    weightA: AnimationRTWeight | null;
+    posB: number;
+    private unk2;
+    weightB: AnimationRTWeight | null;
+    static fromReader(reader: OdolReader): VertexNeighborInfo;
+}
+/**
+ * ST coordinate pair (tangent/bitangent)
+ */
+export declare class STPair {
+    s: Vector3;
+    t: Vector3;
+    static fromReader(reader: OdolReader): STPair;
+}
+export declare class VertexData {
+    vertexBoneRefIsSimple: boolean;
+    clipFlags: ClipFlags[];
+    uvSets: UVSet[];
+    vertices: Vector3[];
+    normals: Vector3[];
+    stCoords: STPair[];
+    vertexBoneRef: AnimationRTWeight[];
+    neighborBoneRef: VertexNeighborInfo[];
+    static fromReader(reader: OdolReader): VertexData;
+}

package/dist/odol/auxiliaryStructures.d.ts

@@ -0,0 +1,49 @@
+import { OdolReader } from './OdolReader';
+import { PackedColor } from './PackedColor';
+import { ClipFlags, SpecialFlags } from './enums';
+import { Vector3, Matrix4 } from './math';
+/**
+ * Skeleton bone structure
+ */
+export declare class Skeleton {
+    name: string;
+    isDiscrete: boolean;
+    bones: string[];
+    pivotsName: string;
+    static fromReader(reader: OdolReader): Skeleton;
+    getBonePairs(): [string, string][];
+}
+/**
+ * Proxy object (reference to another model)
+ */
+export declare class ProxyObject {
+    proxyModel: string;
+    transformation: Matrix4;
+    sequenceId: number;
+    namedSelectionIndex: number;
+    boneIndex: number;
+    sectionIndex: number;
+    static fromReader(reader: OdolReader): ProxyObject;
+}
+/**
+ * Keyframe for animations
+ */
+export declare class Keyframe {
+    time: number;
+    points: Vector3[];
+    static fromReader(reader: OdolReader): Keyframe;
+}
+export declare class SubSkeletonIndexSet {
+    subSkeletons: number[];
+    static fromReader(reader: OdolReader): SubSkeletonIndexSet;
+}
+export declare class LodMetadata {
+    facesCount: number;
+    color: PackedColor;
+    special: SpecialFlags;
+    orHints: ClipFlags;
+    hasSkeleton: boolean;
+    verticesCount: number;
+    faceArea: number;
+    static fromReader(reader: OdolReader): LodMetadata;
+}

package/dist/odol/enums.d.ts

@@ -0,0 +1,104 @@
+/**
+ * Clipping flags enum
+ */
+export declare enum ClipFlags {
+    DecalNone = 0,
+    FogNormal = 0,
+    LandNone = 0,
+    LightNormal = 0,
+    None = 0,
+    Front = 1,
+    Back = 2,
+    Left = 4,
+    Right = 8,
+    Bottom = 16,
+    Top = 32,
+    All = 63,
+    User0 = 64,
+    MaxUserValue = 255,
+    LandOn = 256,
+    LandAbove = 512,
+    LandUnder = 1024,
+    LandKeep = 2048,
+    LandMask = 3328,
+    DecalNormal = 4096,
+    DecalVertical = 8192,
+    DecalMask = 12288,
+    FogDisable = 16384,
+    FogSky = 32768,
+    FogMask = 49152,
+    UserStep = 1048576,
+    UserMask = 267386880,
+    Hints = 268435456,
+    Shining = 209715200,
+    AlwaysInShadow = 210763776,
+    HalfLight = 211812352,
+    FullLight = 212860928
+}
+export declare enum SpecialFlags {
+    None = 0,
+    Unk_2 = 2,
+    Unk_16 = 16,
+    NoShadows = 32,
+    Unk_256 = 256,
+    Unk_512 = 512,
+    Unk_4096 = 4096,
+    SectionSpecial = 8192,
+    Unk_16384 = 16384,
+    Unk_32768 = 32768,
+    Unk_131072 = 131072,
+    HiddenVertex = 4202496,
+    ZBiasLow = 67108864,
+    ZBiasMiddle = 134217728,
+    ZBiasHigh = 201326592
+}
+export declare enum ShadowBufferSource {
+    Visual = 0,
+    ShadowVolume = 1,
+    Explicit = 2,
+    None = 3,
+    VisualEx = 4
+}
+export declare enum MapType {
+    Tree = 0,
+    SmallTree = 1,
+    Bush = 2,
+    Building = 3,
+    House = 4,
+    ForestBorder = 5,
+    ForestTriangle = 6,
+    ForestSquare = 7,
+    Church = 8,
+    Chapel = 9,
+    Cross = 10,
+    Rock = 11,
+    Bunker = 12,
+    Fortress = 13,
+    Fountain = 14,
+    ViewTower = 15,
+    Lighthouse = 16,
+    Quay = 17,
+    Fuelstation = 18,
+    Hospital = 19,
+    Fence = 20,
+    Wall = 21,
+    Hide = 22,
+    BusStop = 23,
+    Road = 24,
+    Forest = 25,
+    Transmitter = 26,
+    Stack = 27,
+    Ruin = 28,
+    Tourism = 29,
+    Watertower = 30,
+    Track = 31,
+    MainRoad = 32,
+    Rocks = 33,
+    PowerLines = 34,
+    RailWay = 35
+}
+export declare enum AnimationType {
+    None = 0,
+    Software = 1,
+    Hardware = 2
+}

package/dist/odol/index.d.ts

@@ -0,0 +1,14 @@
+export { Animation } from './Animation';
+export { Animations } from './Animations';
+export { Odol } from './Odol';
+export { OdolLod } from './OdolLod';
+export { ModelInfo } from './ModelInfo';
+export { OdolReader } from './OdolReader';
+export { getLodName } from '../shared/Resolution';
+export { Vector3, Matrix3, Matrix4 } from './math';
+export { PackedColor } from './PackedColor';
+export { ClipFlags, SpecialFlags, ShadowBufferSource, MapType, AnimationType } from './enums';
+export { Face, Polygons, Section, NamedSelection, UVSet } from './structures';
+export { AnimationRTPair, AnimationRTWeight, VertexNeighborInfo, STPair, VertexData } from './VertexData';
+export { Skeleton, ProxyObject, Keyframe, SubSkeletonIndexSet, LodMetadata } from './auxiliaryStructures';
+export { Color, EmbeddedMaterial, StageTexture, StageTransform } from './Materials';

package/dist/odol/math.d.ts

@@ -0,0 +1,46 @@
+import { BinaryReader } from '@bis-toolkit/utils';
+export declare class Vector3 {
+    x: number;
+    y: number;
+    z: number;
+    constructor(x?: number, y?: number, z?: number);
+    get length(): number;
+    static fromReader(reader: BinaryReader): Vector3;
+    static readCompressed(reader: BinaryReader): Vector3;
+    static fromInt32(compressed: number): Vector3;
+    distance(v: Vector3): number;
+    normalize(): Vector3;
+    toArray(): [number, number, number];
+}
+export declare class Matrix3 {
+    m00: number;
+    m01: number;
+    m02: number;
+    m10: number;
+    m11: number;
+    m12: number;
+    m20: number;
+    m21: number;
+    m22: number;
+    constructor(m00?: number, m01?: number, m02?: number, m10?: number, m11?: number, m12?: number, m20?: number, m21?: number, m22?: number);
+    static fromReader(reader: BinaryReader): Matrix3;
+}
+/**
+ * Matrix4 (stored as 3x3 orientation + 3D position)
+ */
+export declare class Matrix4 {
+    m00: number;
+    m01: number;
+    m02: number;
+    m10: number;
+    m11: number;
+    m12: number;
+    m20: number;
+    m21: number;
+    m22: number;
+    px: number;
+    py: number;
+    pz: number;
+    constructor(m00?: number, m01?: number, m02?: number, m10?: number, m11?: number, m12?: number, m20?: number, m21?: number, m22?: number, px?: number, py?: number, pz?: number);
+    static fromReader(reader: BinaryReader): Matrix4;
+}