load method

@override void load()

Override to perform one-time module initialization. Called by doLoad.

Implementation

@override
void load() {
  super.load();

  TypedDataList$ = .new(this);

  String$ = .new(this, 'String\$',
    slotCount: options.stringCount,
  );

  Bool$ = .new(this, 'Bool\$',
    byteSize: WasmSize.Int32,
    pointerFactory: WasmBoolPointer.new,
    printerFunc: (ptr) => ptr.value.toString(),
  );

  Ptr$Bool$ = .new(this, 'Ptr\$Bool\$',
    pointerFactory: (ptr) => .new(ptr, Bool$.pointerFactory),
    rawArrayFunc: Bool$.RawArray,
  );

  Int8$ = WasmLitIntAlloc(this, 'Int8\$',
    byteSize: WasmSize.Int8,
    pointerFactory: WasmInt8Pointer.new,
    fromList: (list) => .fromList(list.cast<int>().toList()),
    asView: (ptr, len) => WasmMemory.heapI8.buffer.asInt8List(ptr, len),
    fromBuffer: (buf, offset, len) => buf.asInt8List(offset, len),
  );

  Ptr$Int8$ = .new(this, 'Ptr\$Int8\$',
    pointerFactory: (ptr) => .new(ptr, Int8$.pointerFactory),
    rawArrayFunc: Int8$.RawArray,
  );

  Uint8$ = WasmLitIntAlloc(this, 'Uint8\$',
    byteSize: WasmSize.Uint8,
    pointerFactory: WasmUint8Pointer.new,
    fromList: (list) => .fromList(list.cast<int>().toList()),
    asView: (ptr, len) => WasmMemory.heapU8.buffer.asUint8List(ptr, len),
    fromBuffer: (buf, offset, len) => buf.asUint8List(offset, len),
  );

  Ptr$Uint8$ = .new(this, 'Ptr\$Uint8\$',
    pointerFactory: (ptr) => .new(ptr, Uint8$.pointerFactory),
    rawArrayFunc: Uint8$.RawArray,
  );

  Int16$ = WasmLitIntAlloc(this, 'Int16\$',
    byteSize: WasmSize.Int16,
    pointerFactory: WasmInt16Pointer.new,
    fromList: (list) => .fromList(list.cast<int>().toList()),
    asView: (ptr, len) => WasmMemory.heapI16.buffer.asInt16List(ptr, len),
    fromBuffer: (buf, offset, len) => buf.asInt16List(offset, len),
  );

  Ptr$Int16$ = .new(this, 'Ptr\$Int16\$',
    pointerFactory: (ptr) => .new(ptr, Int16$.pointerFactory),
    rawArrayFunc: Int16$.RawArray,
  );

  Uint16$ = WasmLitIntAlloc(this, 'Uint16\$',
    byteSize: WasmSize.Uint16,
    pointerFactory: WasmUint16Pointer.new,
    fromList: (list) => .fromList(list.cast<int>().toList()),
    asView: (ptr, len) => WasmMemory.heapU16.buffer.asUint16List(ptr, len),
    fromBuffer: (buf, offset, len) => buf.asUint16List(offset, len),
  );

  Ptr$Uint16$ = .new(this, 'Ptr\$Uint16\$',
    pointerFactory: (ptr) => .new(ptr, Uint16$.pointerFactory),
    rawArrayFunc: Uint16$.RawArray,
  );

  Int32$ = WasmLitIntAlloc(this, 'Int32\$',
    byteSize: WasmSize.Int32,
    pointerFactory: WasmInt32Pointer.new,
    fromList: (list) => .fromList(list.cast<int>().toList()),
    asView: (ptr, len) => WasmMemory.heapI32.buffer.asInt32List(ptr, len),
    fromBuffer: (buf, offset, len) => buf.asInt32List(offset, len),
  );

  Ptr$Int32$ = .new(this, 'Ptr\$Int32\$',
    pointerFactory: (ptr) => .new(ptr, Int32$.pointerFactory),
    rawArrayFunc: Int32$.RawArray,
  );

  Uint32$ = WasmLitIntAlloc(this, 'Uint32\$',
    byteSize: WasmSize.Uint32,
    pointerFactory: WasmUint32Pointer.new,
    fromList: (list) => .fromList(list.cast<int>().toList()),
    asView: (ptr, len) => WasmMemory.heapU32.buffer.asUint32List(ptr, len),
    fromBuffer: (buf, offset, len) => buf.asUint32List(offset, len),
  );

  Ptr$Uint32$ = .new(this, 'Ptr\$Uint32\$',
    pointerFactory: (ptr) => .new(ptr, Uint32$.pointerFactory),
    rawArrayFunc: Uint32$.RawArray,
  );

  Int64$ = WasmLitIntAlloc(this, 'Int64\$',
    byteSize: WasmSize.Int64,
    pointerFactory: WasmInt64Pointer.new,
    fromList: (list) => .fromList(list.cast<int>().toList()),
    asView: (ptr, len) => WasmMemory.heapI64.buffer.asInt64List(ptr, len),
    fromBuffer: (buf, offset, len) => buf.asInt64List(offset, len),
  );

  Ptr$Int64$ = .new(this, 'Ptr\$Int64\$',
    pointerFactory: (ptr) => .new(ptr, Int64$.pointerFactory),
    rawArrayFunc: Int64$.RawArray,
  );

  Uint64$ = WasmLitIntAlloc(this, 'Uint64\$',
    byteSize: WasmSize.Uint64,
    pointerFactory: WasmUint64Pointer.new,
    fromList: (list) => .fromList(list.cast<int>().toList()),
    asView: (ptr, len) => WasmMemory.heapU64.buffer.asUint64List(ptr, len),
    fromBuffer: (buf, offset, len) => buf.asUint64List(offset, len),
  );

  Ptr$Uint64$ = .new(this, 'Ptr\$Uint64\$',
    pointerFactory: (ptr) => .new(ptr, Uint64$.pointerFactory),
    rawArrayFunc: Uint64$.RawArray,
  );

  Float32$ = WasmLitFloatAlloc(this, 'Float32\$',
    byteSize: WasmSize.Float32,
    pointerFactory: WasmFloat32Pointer.new,
    fromList: (list) => .fromList(list.cast<double>().toList()),
    asView: (ptr, len) => WasmMemory.heapF32.buffer.asFloat32List(ptr, len),
    fromBuffer: (buf, offset, len) => buf.asFloat32List(offset, len),
  );

  Ptr$Float32$ = .new(this, 'Ptr\$Float32\$',
    pointerFactory: (ptr) => .new(ptr, Float32$.pointerFactory),
    rawArrayFunc: Float32$.RawArray,
  );

  Float64$ = WasmLitFloatAlloc(this, 'Float64\$',
    byteSize: WasmSize.Float64,
    pointerFactory: WasmFloat64Pointer.new,
    fromList: (list) => .fromList(list.cast<double>().toList()),
    asView: (ptr, len) => WasmMemory.heapF64.buffer.asFloat64List(ptr, len),
    fromBuffer: (buf, offset, len) => buf.asFloat64List(offset, len),
  );

  Ptr$Float64$ = .new(this, 'Ptr\$Float64\$',
    pointerFactory: (ptr) => .new(ptr, Float64$.pointerFactory),
    rawArrayFunc: Float64$.RawArray,
  );

  AudioStream$ = .new(this, 'AudioStream\$',
    byteSize: AudioStreamD.byteSize,
    factory: AudioStreamD.new
  );

  Ptr$AudioStream$ = .new(this, 'Ptr\$AudioStream\$',
    pointerFactory: (ptr) => .new(ptr, AudioStream$.pointerFactory),
    valueFunc: AudioStream$.Value,
    rawArrayFunc: AudioStream$.RawArray,
  );

  AutomationEventList$ = .new(this, 'AutomationEventList\$',
    byteSize: AutomationEventListD.byteSize,
    factory: AutomationEventListD.new
  );

  Ptr$AutomationEventList$ = .new(this, 'Ptr\$AutomationEventList\$',
    pointerFactory: (ptr) => .new(ptr, AutomationEventList$.pointerFactory),
    valueFunc: AutomationEventList$.Value,
    rawArrayFunc: AutomationEventList$.RawArray,
  );

  AutomationEvent$ = .new(this, 'AutomationEvent\$',
    byteSize: AutomationEventD.byteSize,
    factory: AutomationEventD.new
  );

  Ptr$AutomationEvent$ = .new(this, 'Ptr\$AutomationEvent\$',
    pointerFactory: (ptr) => .new(ptr, AutomationEvent$.pointerFactory),
    valueFunc: AutomationEvent$.Value,
    rawArrayFunc: AutomationEvent$.RawArray,
  );

  BoneInfo$ = .new(this, 'BoneInfo\$',
    byteSize: BoneInfoD.byteSize,
    factory: BoneInfoD.new
  );

  Ptr$BoneInfo$ = .new(this, 'Ptr\$BoneInfo\$',
    pointerFactory: (ptr) => .new(ptr, BoneInfo$.pointerFactory),
    valueFunc: BoneInfo$.Value,
    rawArrayFunc: BoneInfo$.RawArray,
  );

  BoundingBox$ = .new(this, 'BoundingBox\$',
    byteSize: BoundingBoxD.byteSize,
    factory: BoundingBoxD.new
  );

  Ptr$BoundingBox$ = .new(this, 'Ptr\$BoundingBox\$',
    pointerFactory: (ptr) => .new(ptr, BoundingBox$.pointerFactory),
    valueFunc: BoundingBox$.Value,
    rawArrayFunc: BoundingBox$.RawArray,
  );

  Camera2D$ = .new(this, 'Camera2D\$',
    byteSize: Camera2DD.byteSize,
    factory: Camera2DD.new
  );

  Ptr$Camera2D$ = .new(this, 'Ptr\$Camera2D\$',
    pointerFactory: (ptr) => .new(ptr, Camera2D$.pointerFactory),
    valueFunc: Camera2D$.Value,
    rawArrayFunc: Camera2D$.RawArray,
  );

  Camera3D$ = .new(this, 'Camera3D\$',
    byteSize: Camera3DD.byteSize,
    factory: Camera3DD.new
  );

  Ptr$Camera3D$ = .new(this, 'Ptr\$Camera3D\$',
    pointerFactory: (ptr) => .new(ptr, Camera3D$.pointerFactory),
    valueFunc: Camera3D$.Value,
    rawArrayFunc: Camera3D$.RawArray,
  );

  Color$ = .new(this, 'Color\$',
    byteSize: ColorD.byteSize,
    factory: ColorD.new
  );

  Ptr$Color$ = .new(this, 'Ptr\$Color\$',
    pointerFactory: (ptr) => .new(ptr, Color$.pointerFactory),
    valueFunc: Color$.Value,
    rawArrayFunc: Color$.RawArray,
  );

  FilePathList$ = .new(this, 'FilePathList\$',
    byteSize: FilePathListD.byteSize,
    factory: FilePathListD.new
  );

  Ptr$FilePathList$ = .new(this, 'Ptr\$FilePathList\$',
    pointerFactory: (ptr) => .new(ptr, FilePathList$.pointerFactory),
    valueFunc: FilePathList$.Value,
    rawArrayFunc: FilePathList$.RawArray,
  );

  Font$ = .new(this, 'Font\$',
    byteSize: FontD.byteSize,
    factory: FontD.new
  );

  Ptr$Font$ = .new(this, 'Ptr\$Font\$',
    pointerFactory: (ptr) => .new(ptr, Font$.pointerFactory),
    valueFunc: Font$.Value,
    rawArrayFunc: Font$.RawArray,
  );

  GlyphInfo$ = .new(this, 'GlyphInfo\$',
    byteSize: GlyphInfoD.byteSize,
    factory: GlyphInfoD.new
  );

  Ptr$GlyphInfo$ = .new(this, 'Ptr\$GlyphInfo\$',
    pointerFactory: (ptr) => .new(ptr, GlyphInfo$.pointerFactory),
    valueFunc: GlyphInfo$.Value,
    rawArrayFunc: GlyphInfo$.RawArray,
  );

  Image$ = .new(this, 'Image\$',
    byteSize: ImageD.byteSize,
    factory: ImageD.new
  );

  Ptr$Image$ = .new(this, 'Ptr\$Image\$',
    pointerFactory: (ptr) => .new(ptr, Image$.pointerFactory),
    valueFunc: Image$.Value,
    rawArrayFunc: Image$.RawArray,
  );

  Light$ = .new(this, 'Light\$',
    byteSize: LightD.byteSize,
    factory: LightD.new
  );

  Ptr$Light$ = .new(this, 'Ptr\$Light\$',
    pointerFactory: (ptr) => .new(ptr, Light$.pointerFactory),
    valueFunc: Light$.Value,
    rawArrayFunc: Light$.RawArray,
  );

  MaterialMap$ = .new(this, 'MaterialMap\$',
    byteSize: MaterialMapD.byteSize,
    factory: MaterialMapD.new
  );

  Ptr$MaterialMap$ = .new(this, 'Ptr\$MaterialMap\$',
    pointerFactory: (ptr) => .new(ptr, MaterialMap$.pointerFactory),
    valueFunc: MaterialMap$.Value,
    rawArrayFunc: MaterialMap$.RawArray,
  );

  Material$ = .new(this, 'Material\$',
    byteSize: MaterialD.byteSize,
    factory: MaterialD.new
  );

  Ptr$Material$ = .new(this, 'Ptr\$Material\$',
    pointerFactory: (ptr) => .new(ptr, Material$.pointerFactory),
    valueFunc: Material$.Value,
    rawArrayFunc: Material$.RawArray,
  );

  Matrix$ = .new(this, 'Matrix\$',
    byteSize: MatrixD.byteSize,
    factory: MatrixD.new
  );

  Ptr$Matrix$ = .new(this, 'Ptr\$Matrix\$',
    pointerFactory: (ptr) => .new(ptr, Matrix$.pointerFactory),
    valueFunc: Matrix$.Value,
    rawArrayFunc: Matrix$.RawArray,
  );

  Mesh$ = .new(this, 'Mesh\$',
    byteSize: MeshD.byteSize,
    factory: MeshD.new
  );

  Ptr$Mesh$ = .new(this, 'Ptr\$Mesh\$',
    pointerFactory: (ptr) => .new(ptr, Mesh$.pointerFactory),
    valueFunc: Mesh$.Value,
    rawArrayFunc: Mesh$.RawArray,
  );

  ModelAnimation$ = .new(this, 'ModelAnimation\$',
    byteSize: ModelAnimationD.byteSize,
    factory: ModelAnimationD.new
  );

  Ptr$ModelAnimation$ = .new(this, 'Ptr\$ModelAnimation\$',
    pointerFactory: (ptr) => .new(ptr, ModelAnimation$.pointerFactory),
    valueFunc: ModelAnimation$.Value,
    rawArrayFunc: ModelAnimation$.RawArray,
  );

  Model$ = .new(this, 'Model\$',
    byteSize: ModelD.byteSize,
    factory: ModelD.new
  );

  Ptr$Model$ = .new(this, 'Ptr\$Model\$',
    pointerFactory: (ptr) => .new(ptr, Model$.pointerFactory),
    valueFunc: Model$.Value,
    rawArrayFunc: Model$.RawArray,
  );

  Music$ = .new(this, 'Music\$',
    byteSize: MusicD.byteSize,
    factory: MusicD.new
  );

  Ptr$Music$ = .new(this, 'Ptr\$Music\$',
    pointerFactory: (ptr) => .new(ptr, Music$.pointerFactory),
    valueFunc: Music$.Value,
    rawArrayFunc: Music$.RawArray,
  );

  NPatchInfo$ = .new(this, 'NPatchInfo\$',
    byteSize: NPatchInfoD.byteSize,
    factory: NPatchInfoD.new
  );

  Ptr$NPatchInfo$ = .new(this, 'Ptr\$NPatchInfo\$',
    pointerFactory: (ptr) => .new(ptr, NPatchInfo$.pointerFactory),
    valueFunc: NPatchInfo$.Value,
    rawArrayFunc: NPatchInfo$.RawArray,
  );

  Quaternion$ = .new(this, 'Quaternion\$',
    byteSize: QuaternionD.byteSize,
    factory: QuaternionD.new
  );

  Ptr$Quaternion$ = .new(this, 'Ptr\$Quaternion\$',
    pointerFactory: (ptr) => .new(ptr, Quaternion$.pointerFactory),
    valueFunc: Quaternion$.Value,
    rawArrayFunc: Quaternion$.RawArray,
  );

  RayCollision$ = .new(this, 'RayCollision\$',
    byteSize: RayCollisionD.byteSize,
    factory: RayCollisionD.new
  );

  Ptr$RayCollision$ = .new(this, 'Ptr\$RayCollision\$',
    pointerFactory: (ptr) => .new(ptr, RayCollision$.pointerFactory),
    valueFunc: RayCollision$.Value,
    rawArrayFunc: RayCollision$.RawArray,
  );

  Ray$ = .new(this, 'Ray\$',
    byteSize: RayD.byteSize,
    factory: RayD.new
  );

  Ptr$Ray$ = .new(this, 'Ptr\$Ray\$',
    pointerFactory: (ptr) => .new(ptr, Ray$.pointerFactory),
    valueFunc: Ray$.Value,
    rawArrayFunc: Ray$.RawArray,
  );

  Rectangle$ = .new(this, 'Rectangle\$',
    byteSize: RectangleD.byteSize,
    factory: RectangleD.new
  );

  Ptr$Rectangle$ = .new(this, 'Ptr\$Rectangle\$',
    pointerFactory: (ptr) => .new(ptr, Rectangle$.pointerFactory),
    valueFunc: Rectangle$.Value,
    rawArrayFunc: Rectangle$.RawArray,
  );

  RlDrawCall$ = .new(this, 'RlDrawCall\$',
    byteSize: RlDrawCallD.byteSize,
    factory: RlDrawCallD.new
  );

  Ptr$RlDrawCall$ = .new(this, 'Ptr\$RlDrawCall\$',
    pointerFactory: (ptr) => .new(ptr, RlDrawCall$.pointerFactory),
    valueFunc: RlDrawCall$.Value,
    rawArrayFunc: RlDrawCall$.RawArray,
  );

  RlRenderBatch$ = .new(this, 'RlRenderBatch\$',
    byteSize: RlRenderBatchD.byteSize,
    factory: RlRenderBatchD.new
  );

  Ptr$RlRenderBatch$ = .new(this, 'Ptr\$RlRenderBatch\$',
    pointerFactory: (ptr) => .new(ptr, RlRenderBatch$.pointerFactory),
    valueFunc: RlRenderBatch$.Value,
    rawArrayFunc: RlRenderBatch$.RawArray,
  );

  RlVertexBuffer$ = .new(this, 'RlVertexBuffer\$',
    byteSize: RlVertexBufferD.byteSize,
    factory: RlVertexBufferD.new
  );

  Ptr$RlVertexBuffer$ = .new(this, 'Ptr\$RlVertexBuffer\$',
    pointerFactory: (ptr) => .new(ptr, RlVertexBuffer$.pointerFactory),
    valueFunc: RlVertexBuffer$.Value,
    rawArrayFunc: RlVertexBuffer$.RawArray,
  );

  RenderTexture$ = .new(this, 'RenderTexture\$',
    byteSize: RenderTextureD.byteSize,
    factory: RenderTextureD.new
  );

  Ptr$RenderTexture$ = .new(this, 'Ptr\$RenderTexture\$',
    pointerFactory: (ptr) => .new(ptr, RenderTexture$.pointerFactory),
    valueFunc: RenderTexture$.Value,
    rawArrayFunc: RenderTexture$.RawArray,
  );

  Shader$ = .new(this, 'Shader\$',
    byteSize: ShaderD.byteSize,
    factory: ShaderD.new
  );

  Ptr$Shader$ = .new(this, 'Ptr\$Shader\$',
    pointerFactory: (ptr) => .new(ptr, Shader$.pointerFactory),
    valueFunc: Shader$.Value,
    rawArrayFunc: Shader$.RawArray,
  );

  Sound$ = .new(this, 'Sound\$',
    byteSize: SoundD.byteSize,
    factory: SoundD.new
  );

  Ptr$Sound$ = .new(this, 'Ptr\$Sound\$',
    pointerFactory: (ptr) => .new(ptr, Sound$.pointerFactory),
    valueFunc: Sound$.Value,
    rawArrayFunc: Sound$.RawArray,
  );

  Texture$ = .new(this, 'Texture\$',
    byteSize: TextureD.byteSize,
    factory: TextureD.new
  );

  Ptr$Texture$ = .new(this, 'Ptr\$Texture\$',
    pointerFactory: (ptr) => .new(ptr, Texture$.pointerFactory),
    valueFunc: Texture$.Value,
    rawArrayFunc: Texture$.RawArray,
  );

  Transform$ = .new(this, 'Transform\$',
    byteSize: TransformD.byteSize,
    factory: TransformD.new
  );

  Ptr$Transform$ = .new(this, 'Ptr\$Transform\$',
    pointerFactory: (ptr) => .new(ptr, Transform$.pointerFactory),
    valueFunc: Transform$.Value,
    rawArrayFunc: Transform$.RawArray,
  );

  Vector2$ = .new(this, 'Vector2\$',
    byteSize: Vector2D.byteSize,
    factory: Vector2D.new
  );

  Ptr$Vector2$ = .new(this, 'Ptr\$Vector2\$',
    pointerFactory: (ptr) => .new(ptr, Vector2$.pointerFactory),
    valueFunc: Vector2$.Value,
    rawArrayFunc: Vector2$.RawArray,
  );

  Vector3$ = .new(this, 'Vector3\$',
    byteSize: Vector3D.byteSize,
    factory: Vector3D.new
  );

  Ptr$Vector3$ = .new(this, 'Ptr\$Vector3\$',
    pointerFactory: (ptr) => .new(ptr, Vector3$.pointerFactory),
    valueFunc: Vector3$.Value,
    rawArrayFunc: Vector3$.RawArray,
  );

  Vector4$ = .new(this, 'Vector4\$',
    byteSize: Vector4D.byteSize,
    factory: Vector4D.new
  );

  Ptr$Vector4$ = .new(this, 'Ptr\$Vector4\$',
    pointerFactory: (ptr) => .new(ptr, Vector4$.pointerFactory),
    valueFunc: Vector4$.Value,
    rawArrayFunc: Vector4$.RawArray,
  );

  VrDeviceInfo$ = .new(this, 'VrDeviceInfo\$',
    byteSize: VrDeviceInfoD.byteSize,
    factory: VrDeviceInfoD.new
  );

  Ptr$VrDeviceInfo$ = .new(this, 'Ptr\$VrDeviceInfo\$',
    pointerFactory: (ptr) => .new(ptr, VrDeviceInfo$.pointerFactory),
    valueFunc: VrDeviceInfo$.Value,
    rawArrayFunc: VrDeviceInfo$.RawArray,
  );

  VrStereoConfig$ = .new(this, 'VrStereoConfig\$',
    byteSize: VrStereoConfigD.byteSize,
    factory: VrStereoConfigD.new
  );

  Ptr$VrStereoConfig$ = .new(this, 'Ptr\$VrStereoConfig\$',
    pointerFactory: (ptr) => .new(ptr, VrStereoConfig$.pointerFactory),
    valueFunc: VrStereoConfig$.Value,
    rawArrayFunc: VrStereoConfig$.RawArray,
  );

  Wave$ = .new(this, 'Wave\$',
    byteSize: WaveD.byteSize,
    factory: WaveD.new
  );

  Ptr$Wave$ = .new(this, 'Ptr\$Wave\$',
    pointerFactory: (ptr) => .new(ptr, Wave$.pointerFactory),
    valueFunc: Wave$.Value,
    rawArrayFunc: Wave$.RawArray,
  );
}