feat: sc2 typings

src/core/blitz/SCPGStream.ts

@@ -1,4 +1,5 @@
 import { times } from 'lodash';
+import { SC2 } from '../../types/sc2';
 import { readDVPL } from './readDVPL';
 import { readDVPLFile } from './readDVPLFile';
 
@@ -70,6 +71,12 @@ interface PolygonGroupRaw {
   vertexFormat: number;
   vertices: Buffer;
 }
+type BlitzkriegVertex = { type: VertexType; value: number[] }[];
+interface BlitzkriegPolygonGroup {
+  id: bigint;
+  vertices: BlitzkriegVertex[];
+  indices: number[];
+}
 
 const VECTOR_SIZES = [
   [VertexType.COLOR, VertexType.FLEXIBILITY, VertexType.HARD_JOINTINDEX],
@@ -216,7 +223,7 @@ export class SCPGStream {
       }
 
       const verticesStream = new SCPGStream(polygonGroupRaw.vertices);
-      const vertices: Partial<Record<VertexType, number[]>>[] = [];
+      const vertices: BlitzkriegVertex[] = [];
       const vertexFormatBuffer = Buffer.alloc(4);
       vertexFormatBuffer.writeUInt32LE(polygonGroupRaw.vertexFormat, 0);
       const vertexFormat = [...vertexFormatBuffer]
@@ -230,9 +237,11 @@ export class SCPGStream {
         vertexFormat.forEach((type) => {
           const resolved = VECTOR_SIZES.some((types, size) => {
             if (types.includes(type)) {
-              if (!(index in vertices)) vertices[index] = {};
-              vertices[index][type] = verticesStream.consumeVectorN(size + 1);
-
+              if (!(index in vertices)) vertices[index] = [];
+              vertices[index].push({
+                type,
+                value: verticesStream.consumeVectorN(size + 1),
+              });
               return true;
             }
           });
@@ -243,7 +252,11 @@ export class SCPGStream {
         });
       }
 
-      return { vertices, indices };
+      return {
+        id: polygonGroupRaw['#id'].readBigUInt64LE(),
+        vertices,
+        indices,
+      } satisfies BlitzkriegPolygonGroup;
     });
 
     return polygonGroups;
@@ -271,7 +284,7 @@ export class SCPGStream {
   }
   consumeSC2() {
     this.consumeSC2Header();
-    return this.consumeKA();
+    return this.consumeKA() as SC2;
   }
 
   consumeKAValue(

src/types/sc2.ts

@@ -0,0 +1,144 @@
+export interface SC2 {
+  '#dataNodes': DataNode[];
+  '#hierarchy': Hierarchy[];
+  '#sceneComponents': SceneComponents;
+}
+
+type DataNode = {
+  '##name': 'NMaterial';
+  '#id': Buffer;
+  materialName: string;
+  parentMaterialKey?: string;
+  configCount?: number;
+  qualityGroup?: string;
+  fxName?: string;
+} & Record<`configArchive_${number}`, ConfigArchive>;
+
+interface ConfigArchive {
+  configName: string;
+  fxName: string;
+  properties: Properties;
+  textureSampleStates: TextureSampleStates;
+  textures: Textures;
+  customCullMode?: number;
+  enabledPresets?: EnabledPresets;
+  flags?: Flags;
+}
+
+interface EnabledPresets {
+  AlphaTest: boolean;
+}
+
+interface Flags {
+  AMBIENT_ATTENUATION_BOX: number;
+}
+
+interface Properties {
+  alphatestThreshold: Buffer;
+  attenuationBoxHalfSize: Buffer;
+  attenuationBoxSmoothness: Buffer;
+  baseColorFactor?: Buffer;
+  decalTileCoordScale?: Buffer;
+  inGlossiness: Buffer;
+  inSpecularity: Buffer;
+  metalFresnelReflectance: Buffer;
+  metallicRoughnessFactor?: Buffer;
+}
+
+interface TextureSampleStates {
+  albedo: number;
+  baseColorMap: number;
+  baseNormalMap: number;
+  baseRMMap: number;
+  decalmask?: number;
+  maskMap: number;
+  miscMap: number;
+  normalmap: number;
+}
+
+interface Textures {
+  albedo: string;
+  baseColorMap: string;
+  baseNormalMap: string;
+  baseRMMap: string;
+  decalmask?: string;
+  maskMap: string;
+  miscMap: string;
+  normalmap: string;
+}
+
+interface Hierarchy {
+  '##name': 'Entity';
+  '#hierarchy'?: Hierarchy[];
+  components: Components;
+  flags: number;
+  id: number;
+  name: string;
+}
+
+// 0001, 0002, 0003...: Component
+type Components = {
+  count: number;
+} & Record<string, Component>;
+
+type LODDistance = Record<`distance${number}`, number>;
+
+// 0001, 0002, 0003...
+type RoBatches = Record<
+  string,
+  {
+    '##name': 'RenderBatch';
+    'rb.aabbox': RbAabbox;
+    'rb.classname': 'RenderBatch';
+    'rb.datasource': bigint;
+    'rb.nmatname': string;
+    'rb.sortingKey': number;
+  }
+>;
+
+interface RbAabbox {
+  minimum: number[];
+  maximum: number[];
+}
+
+type Component =
+  | {
+      'comp.typename': 'TransformComponent';
+      'tc.localRotation': number[];
+      'tc.localScale': number[];
+      'tc.localTranslation': number[];
+      'tc.worldRotation': number[];
+      'tc.worldScale': number[];
+      'tc.worldTranslation': number[];
+    }
+  | {
+      'comp.typename': 'RenderComponent';
+      'rc.renderObj': {
+        '##name': 'Mesh';
+        'ro.batchCount': number;
+        'ro.batches': RoBatches;
+        'ro.debugflags': number;
+        'ro.flags': number;
+        'ro.notShadowOnly': boolean;
+        'ro.sOclCull': boolean;
+        'ro.sOclIndex': number;
+      } & Record<`rb${number}.${'lodIndex' | 'switchIndex'}`, number>;
+    }
+  | {
+      'comp.typename': 'SlotComponent';
+      'sc.attachmentRotation': number[];
+      'sc.attachmentScale': number[];
+      'sc.attachmentTranslation': number[];
+      'sc.configFilePath': string;
+      'sc.slotName': string;
+      'sc.template': string;
+      'sc.typeFiltersCount': number;
+    }
+  | {
+      'comp.typename': 'LodComponent';
+      'lc.loddist': LODDistance;
+    };
+
+interface SceneComponents {
+  count: number;
+}