Implementation
@override
void load() {
super.load();
_preAllocate();
_preAllocateReusables();
TypedDataList$ = .new(this);
String$ = .new(this, 'String\$',
allocatorFunc: ([count = 1]) => calloc<Char>(count),
slotCount: options.stringCount,
);
Bool$ = .new(this, r'Bool$',
byteSize: sizeOf<Bool>(),
allocatorFunc: ([count = 1]) => calloc<Bool>(count),
indexSetterFunc: (ptr, i, value) => ptr[i] = value,
literalSetterFunc: (ptr, value) => ptr.value = value,
printerFunc: (ptr) => ptr.value.toString(),
);
Ptr$Bool$ = .new(this, r'Ptr$Bool$',
allocatorFunc: ([count = 1]) => calloc<Pointer<Bool>>(count),
rawArrayFunc: Bool$.RawArray,
);
Int8$ = .new(this, r'Int8$',
byteSize: sizeOf<Int8>(),
allocatorFunc: ([count = 1]) => calloc<Int8>(count),
indexSetterFunc: (ptr, i, value) => ptr[i] = value.toInt(),
literalSetterFunc: (ptr, value) => ptr.value = value.toInt(),
printerFunc: (ptr) => ptr.value.toString(),
fromList: (list) => .fromList(list.cast<int>().toList()),
asView: (ptr, length) => ptr.asTypedList(length),
fromBuffer: (buf, offset, len) => buf.asInt8List(offset, len),
);
Ptr$Int8$ = .new(this, r'Ptr$Int8$',
allocatorFunc: ([count = 1]) => calloc<Pointer<Int8>>(count),
rawArrayFunc: Int8$.RawArray,
);
Uint8$ = .new(this, r'Uint8$',
byteSize: sizeOf<Uint8>(),
allocatorFunc: ([count = 1]) => calloc<Uint8>(count),
indexSetterFunc: (ptr, i, value) => ptr[i] = value.toInt(),
literalSetterFunc: (ptr, value) => ptr.value = value.toInt(),
printerFunc: (ptr) => ptr.value.toString(),
fromList: (list) => .fromList(list.cast<int>().toList()),
asView: (ptr, length) => ptr.asTypedList(length),
fromBuffer: (buf, offset, len) => buf.asUint8List(offset, len),
);
Ptr$Uint8$ = .new(this, r'Ptr$Uint8$',
allocatorFunc: ([count = 1]) => calloc<Pointer<Uint8>>(count),
rawArrayFunc: Uint8$.RawArray,
);
Int16$ = .new(this, r'Int16$',
byteSize: sizeOf<Int16>(),
allocatorFunc: ([count = 1]) => calloc<Int16>(count),
indexSetterFunc: (ptr, i, value) => ptr[i] = value.toInt(),
literalSetterFunc: (ptr, value) => ptr.value = value.toInt(),
printerFunc: (ptr) => ptr.value.toString(),
fromList: (list) => .fromList(list.cast<int>().toList()),
asView: (ptr, length) => ptr.asTypedList(length),
fromBuffer: (buf, offset, len) => buf.asInt16List(offset, len),
);
Ptr$Int16$ = .new(this, r'Ptr$Int16$',
allocatorFunc: ([count = 1]) => calloc<Pointer<Int16>>(count),
rawArrayFunc: Int16$.RawArray,
);
Uint16$ = .new(this, r'Uint16$',
byteSize: sizeOf<Uint16>(),
allocatorFunc: ([count = 1]) => calloc<Uint16>(count),
indexSetterFunc: (ptr, i, value) => ptr[i] = value.toInt(),
literalSetterFunc: (ptr, value) => ptr.value = value.toInt(),
printerFunc: (ptr) => ptr.value.toString(),
fromList: (list) => .fromList(list.cast<int>().toList()),
asView: (ptr, length) => ptr.asTypedList(length),
fromBuffer: (buf, offset, len) => buf.asUint16List(offset, len),
);
Ptr$Uint16$ = .new(this, r'Ptr$Uint16$',
allocatorFunc: ([count = 1]) => calloc<Pointer<Uint16>>(count),
rawArrayFunc: Uint16$.RawArray,
);
Int32$ = .new(this, r'Int32$',
byteSize: sizeOf<Int32>(),
allocatorFunc: ([count = 1]) => calloc<Int32>(count),
indexSetterFunc: (ptr, i, value) => ptr[i] = value.toInt(),
literalSetterFunc: (ptr, value) => ptr.value = value.toInt(),
printerFunc: (ptr) => ptr.value.toString(),
fromList: (list) => .fromList(list.cast<int>().toList()),
asView: (ptr, length) => ptr.asTypedList(length),
fromBuffer: (buf, offset, len) => buf.asInt32List(offset, len),
);
Ptr$Int32$ = .new(this, r'Ptr$Int32$',
allocatorFunc: ([count = 1]) => calloc<Pointer<Int32>>(count),
rawArrayFunc: Int32$.RawArray,
);
Uint32$ = .new(this, r'Uint32$',
byteSize: sizeOf<Uint32>(),
allocatorFunc: ([count = 1]) => calloc<Uint32>(count),
indexSetterFunc: (ptr, i, value) => ptr[i] = value.toInt(),
literalSetterFunc: (ptr, value) => ptr.value = value.toInt(),
printerFunc: (ptr) => ptr.value.toString(),
fromList: (list) => .fromList(list.cast<int>().toList()),
asView: (ptr, length) => ptr.asTypedList(length),
fromBuffer: (buf, offset, len) => buf.asUint32List(offset, len),
);
Ptr$Uint32$ = .new(this, r'Ptr$Uint32$',
allocatorFunc: ([count = 1]) => calloc<Pointer<Uint32>>(count),
rawArrayFunc: Uint32$.RawArray,
);
Int64$ = .new(this, r'Int64$',
byteSize: sizeOf<Int64>(),
allocatorFunc: ([count = 1]) => calloc<Int64>(count),
indexSetterFunc: (ptr, i, value) => ptr[i] = value.toInt(),
literalSetterFunc: (ptr, value) => ptr.value = value.toInt(),
printerFunc: (ptr) => ptr.value.toString(),
fromList: (list) => .fromList(list.cast<int>().toList()),
asView: (ptr, length) => ptr.asTypedList(length),
fromBuffer: (buf, offset, len) => buf.asInt64List(offset, len),
);
Ptr$Int64$ = .new(this, r'Ptr$Int64$',
allocatorFunc: ([count = 1]) => calloc<Pointer<Int64>>(count),
rawArrayFunc: Int64$.RawArray,
);
Uint64$ = .new(this, r'Uint64$',
byteSize: sizeOf<Uint64>(),
allocatorFunc: ([count = 1]) => calloc<Uint64>(count),
indexSetterFunc: (ptr, i, value) => ptr[i] = value.toInt(),
literalSetterFunc: (ptr, value) => ptr.value = value.toInt(),
printerFunc: (ptr) => ptr.value.toString(),
fromList: (list) => .fromList(list.cast<int>().toList()),
asView: (ptr, length) => ptr.asTypedList(length),
fromBuffer: (buf, offset, len) => buf.asUint64List(offset, len),
);
Ptr$Uint64$ = .new(this, r'Ptr$Uint64$',
allocatorFunc: ([count = 1]) => calloc<Pointer<Uint64>>(count),
rawArrayFunc: Uint64$.RawArray,
);
Float32$ = .new(this, r'Float32$',
byteSize: sizeOf<Float>(),
allocatorFunc: ([count = 1]) => calloc<Float>(count),
indexSetterFunc: (ptr, i, value) => ptr[i] = value.toDouble(),
literalSetterFunc: (ptr, value) => ptr.value = value.toDouble(),
printerFunc: (ptr) => ptr.value.toString(),
fromList: (list) => .fromList(list.cast<double>().toList()),
asView: (ptr, length) => ptr.asTypedList(length),
fromBuffer: (buf, offset, len) => buf.asFloat32List(offset, len),
);
Ptr$Float32$ = .new(this, r'Ptr$Float32$',
allocatorFunc: ([count = 1]) => calloc<Pointer<Float>>(count),
rawArrayFunc: Float32$.RawArray,
);
Float64$ = .new(this, r'Float64$',
byteSize: sizeOf<Double>(),
allocatorFunc: ([count = 1]) => calloc<Double>(count),
indexSetterFunc: (ptr, i, value) => ptr[i] = value.toDouble(),
literalSetterFunc: (ptr, value) => ptr.value = value.toDouble(),
printerFunc: (ptr) => ptr.value.toString(),
fromList: (list) => .fromList(list.cast<double>().toList()),
asView: (ptr, length) => ptr.asTypedList(length),
fromBuffer: (buf, offset, len) => buf.asFloat64List(offset, len),
);
Ptr$Float64$ = .new(this, r'Ptr$Float64$',
allocatorFunc: ([count = 1]) => calloc<Pointer<Double>>(count),
rawArrayFunc: Float64$.RawArray,
);
Int$ = .new(this, r'Int$',
byteSize: sizeOf<Int>(),
allocatorFunc: ([count = 1]) => calloc<Int>(count),
indexSetterFunc: (ptr, i, value) => ptr[i] = value.toInt(),
literalSetterFunc: (ptr, value) => ptr.value = value.toInt(),
printerFunc: (ptr) => ptr.value.toString(),
fromList: (list) => .fromList(list.cast<int>().toList()),
asView: (ptr, length) => ptr.cast<Int32>().asTypedList(length),
fromBuffer: (buf, offset, len) => buf.asInt32List(offset, len),
);
Ptr$Int$ = .new(this, r'Ptr$Int$',
allocatorFunc: ([count = 1]) => calloc<Pointer<Int>>(count),
rawArrayFunc: Int$.RawArray,
);
UnsignedInt$ = .new(this, r'UnsignedInt$',
byteSize: sizeOf<UnsignedInt>(),
allocatorFunc: ([count = 1]) => calloc<UnsignedInt>(count),
indexSetterFunc: (ptr, i, value) => ptr[i] = value.toInt(),
literalSetterFunc: (ptr, value) => ptr.value = value.toInt(),
printerFunc: (ptr) => ptr.value.toString(),
fromList: (list) => .fromList(list.cast<int>().toList()),
asView: (ptr, length) => ptr.cast<Uint32>().asTypedList(length),
fromBuffer: (buf, offset, len) => buf.asUint32List(offset, len),
);
Ptr$UnsignedInt$ = .new(this, r'Ptr$UnsignedInt$',
allocatorFunc: ([count = 1]) => calloc<Pointer<UnsignedInt>>(count),
rawArrayFunc: UnsignedInt$.RawArray,
);
Char$ = .new(this, r'Char$',
byteSize: sizeOf<Char>(),
allocatorFunc: ([count = 1]) => calloc<Char>(count),
indexSetterFunc: (ptr, i, value) => ptr[i] = value.toInt(),
literalSetterFunc: (ptr, value) => ptr.value = value.toInt(),
printerFunc: (ptr) => ptr.value.toString(),
fromList: (list) => .fromList(list.cast<int>().toList()),
asView: (ptr, length) => ptr.cast<Int8>().asTypedList(length),
fromBuffer: (buf, offset, len) => buf.asInt8List(offset, len),
);
Ptr$Char$ = .new(this, r'Ptr$Char$',
allocatorFunc: ([count = 1]) => calloc<Pointer<Char>>(count),
rawArrayFunc: Char$.RawArray,
);
UnsignedChar$ = .new(this, r'UnsignedChar$',
byteSize: sizeOf<UnsignedChar>(),
allocatorFunc: ([count = 1]) => calloc<UnsignedChar>(count),
indexSetterFunc: (ptr, i, value) => ptr[i] = value.toInt(),
literalSetterFunc: (ptr, value) => ptr.value = value.toInt(),
printerFunc: (ptr) => ptr.value.toString(),
fromList: (list) => .fromList(list.cast<int>().toList()),
asView: (ptr, length) => ptr.cast<Uint8>().asTypedList(length),
fromBuffer: (buf, offset, len) => buf.asUint8List(offset, len),
);
Ptr$UnsignedChar$ = .new(this, r'Ptr$UnsignedChar$',
allocatorFunc: ([count = 1]) => calloc<Pointer<UnsignedChar>>(count),
rawArrayFunc: UnsignedChar$.RawArray,
);
Short$ = .new(this, r'Short$',
byteSize: sizeOf<Short>(),
allocatorFunc: ([count = 1]) => calloc<Short>(count),
indexSetterFunc: (ptr, i, value) => ptr[i] = value.toInt(),
literalSetterFunc: (ptr, value) => ptr.value = value.toInt(),
printerFunc: (ptr) => ptr.value.toString(),
fromList: (list) => .fromList(list.cast<int>().toList()),
asView: (ptr, length) => ptr.cast<Int16>().asTypedList(length),
fromBuffer: (buf, offset, len) => buf.asInt16List(offset, len),
);
Ptr$Short$ = .new(this, r'Ptr$Short$',
allocatorFunc: ([count = 1]) => calloc<Pointer<Short>>(count),
rawArrayFunc: Short$.RawArray,
);
UnsignedShort$ = .new(this, r'UnsignedShort$',
byteSize: sizeOf<UnsignedShort>(),
allocatorFunc: ([count = 1]) => calloc<UnsignedShort>(count),
indexSetterFunc: (ptr, i, value) => ptr[i] = value.toInt(),
literalSetterFunc: (ptr, value) => ptr.value = value.toInt(),
printerFunc: (ptr) => ptr.value.toString(),
fromList: (list) => .fromList(list.cast<int>().toList()),
asView: (ptr, length) => ptr.cast<Uint16>().asTypedList(length),
fromBuffer: (buf, offset, len) => buf.asUint16List(offset, len),
);
Ptr$UnsignedShort$ = .new(this, r'Ptr$UnsignedShort$',
allocatorFunc: ([count = 1]) => calloc<Pointer<UnsignedShort>>(count),
rawArrayFunc: UnsignedShort$.RawArray,
);
AutomationEventList$ = .new(this, r'AutomationEventList$',
byteSize: sizeOf<AutomationEventListC>(),
allocatorFunc: ([count = 1]) => calloc<AutomationEventListC>(count),
refFunc: (ptr) => ptr.ref,
setRefFunc: (ptr, v) => ptr..ref = v,
pointerToStruct: (ptr) => ptr.toD(),
printerFunc: (ptr) => ptr.toD().signature(),
setCFunc: (ptr, i, v) => ptr[i].setC(v),
indexerFunc: (ptr, i) => ptr[i],
indexSetterFunc: (ptr, i, v) => ptr[i] = v,
updateFunc: (ptr, source) => source.nativeReadFrom(ptr.ref),
);
Ptr$AutomationEventList$ = .new(this, r'Ptr$AutomationEventList$',
allocatorFunc: ([count = 1]) => calloc<Pointer<AutomationEventListC>>(count),
valueFunc: AutomationEventList$.Value,
rawArrayFunc: AutomationEventList$.RawArray,
);
AutomationEvent$ = .new(this, r'AutomationEvent$',
byteSize: sizeOf<AutomationEventC>(),
allocatorFunc: ([count = 1]) => calloc<AutomationEventC>(count),
refFunc: (ptr) => ptr.ref,
setRefFunc: (ptr, v) => ptr..ref = v,
pointerToStruct: (ptr) => ptr.toD(),
printerFunc: (ptr) => ptr.toD().signature(),
setCFunc: (ptr, i, v) => ptr[i].setC(v),
indexerFunc: (ptr, i) => ptr[i],
indexSetterFunc: (ptr, i, v) => ptr[i] = v,
updateFunc: (ptr, source) => source.nativeReadFrom(ptr.ref),
);
Ptr$AutomationEvent$ = .new(this, r'Ptr$AutomationEvent$',
allocatorFunc: ([count = 1]) => calloc<Pointer<AutomationEventC>>(count),
valueFunc: AutomationEvent$.Value,
rawArrayFunc: AutomationEvent$.RawArray,
);
AudioStream$ = .new(this, r'AudioStream$',
byteSize: sizeOf<AudioStreamC>(),
allocatorFunc: ([count = 1]) => calloc<AudioStreamC>(count),
refFunc: (ptr) => ptr.ref,
setRefFunc: (ptr, v) => ptr..ref = v,
pointerToStruct: (ptr) => ptr.toD(),
printerFunc: (ptr) => ptr.toD().signature(),
setCFunc: (ptr, i, v) => ptr[i].setC(v),
indexerFunc: (ptr, i) => ptr[i],
indexSetterFunc: (ptr, i, v) => ptr[i] = v,
updateFunc: (ptr, source) => source.nativeReadFrom(ptr.ref),
);
Ptr$AudioStream$ = .new(this, r'Ptr$AudioStream$',
allocatorFunc: ([count = 1]) => calloc<Pointer<AudioStreamC>>(count),
valueFunc: AudioStream$.Value,
rawArrayFunc: AudioStream$.RawArray,
);
BoneInfo$ = .new(this, r'BoneInfo$',
byteSize: sizeOf<BoneInfoC>(),
allocatorFunc: ([count = 1]) => calloc<BoneInfoC>(count),
refFunc: (ptr) => ptr.ref,
setRefFunc: (ptr, v) => ptr..ref = v,
pointerToStruct: (ptr) => ptr.toD(),
printerFunc: (ptr) => ptr.toD().signature(),
setCFunc: (ptr, i, v) => ptr[i].setC(v),
indexerFunc: (ptr, i) => ptr[i],
indexSetterFunc: (ptr, i, v) => ptr[i] = v,
updateFunc: (ptr, source) => source.nativeReadFrom(ptr.ref),
);
Ptr$BoneInfo$ = .new(this, r'Ptr$BoneInfo$',
allocatorFunc: ([count = 1]) => calloc<Pointer<BoneInfoC>>(count),
valueFunc: BoneInfo$.Value,
rawArrayFunc: BoneInfo$.RawArray,
);
BoundingBox$ = .new(this, r'BoundingBox$',
byteSize: sizeOf<BoundingBoxC>(),
allocatorFunc: ([count = 1]) => calloc<BoundingBoxC>(count),
refFunc: (ptr) => ptr.ref,
setRefFunc: (ptr, v) => ptr..ref = v,
pointerToStruct: (ptr) => ptr.toD(),
printerFunc: (ptr) => ptr.toD().signature(),
setCFunc: (ptr, i, v) => ptr[i].setC(v),
indexerFunc: (ptr, i) => ptr[i],
indexSetterFunc: (ptr, i, v) => ptr[i] = v,
updateFunc: (ptr, source) => source.nativeReadFrom(ptr.ref),
);
Ptr$BoundingBox$ = .new(this, r'Ptr$BoundingBox$',
allocatorFunc: ([count = 1]) => calloc<Pointer<BoundingBoxC>>(count),
valueFunc: BoundingBox$.Value,
rawArrayFunc: BoundingBox$.RawArray,
);
Camera2D$ = .new(this, r'Camera2D$',
byteSize: sizeOf<Camera2DC>(),
allocatorFunc: ([count = 1]) => calloc<Camera2DC>(count),
refFunc: (ptr) => ptr.ref,
setRefFunc: (ptr, v) => ptr..ref = v,
pointerToStruct: (ptr) => ptr.toD(),
printerFunc: (ptr) => ptr.toD().signature(),
setCFunc: (ptr, i, v) => ptr[i].setC(v),
indexerFunc: (ptr, i) => ptr[i],
indexSetterFunc: (ptr, i, v) => ptr[i] = v,
updateFunc: (ptr, source) => source.nativeReadFrom(ptr.ref),
);
Ptr$Camera2D$ = .new(this, r'Ptr$Camera2D$',
allocatorFunc: ([count = 1]) => calloc<Pointer<Camera2DC>>(count),
valueFunc: Camera2D$.Value,
rawArrayFunc: Camera2D$.RawArray,
);
Camera3D$ = .new(this, r'Camera3D$',
byteSize: sizeOf<Camera3DC>(),
allocatorFunc: ([count = 1]) => calloc<Camera3DC>(count),
refFunc: (ptr) => ptr.ref,
setRefFunc: (ptr, v) => ptr..ref = v,
pointerToStruct: (ptr) => ptr.toD(),
printerFunc: (ptr) => ptr.toD().signature(),
setCFunc: (ptr, i, v) => ptr[i].setC(v),
indexerFunc: (ptr, i) => ptr[i],
indexSetterFunc: (ptr, i, v) => ptr[i] = v,
updateFunc: (ptr, source) => source.nativeReadFrom(ptr.ref),
);
Ptr$Camera3D$ = .new(this, r'Ptr$Camera3D$',
allocatorFunc: ([count = 1]) => calloc<Pointer<Camera3DC>>(count),
valueFunc: Camera3D$.Value,
rawArrayFunc: Camera3D$.RawArray,
);
Color$ = .new(this, r'Color$',
byteSize: sizeOf<ColorC>(),
allocatorFunc: ([count = 1]) => calloc<ColorC>(count),
refFunc: (ptr) => ptr.ref,
setRefFunc: (ptr, v) => ptr..ref = v,
pointerToStruct: (ptr) => ptr.toD(),
printerFunc: (ptr) => ptr.toD().signature(),
setCFunc: (ptr, i, v) => ptr[i].setC(v),
indexerFunc: (ptr, i) => ptr[i],
indexSetterFunc: (ptr, i, v) => ptr[i] = v,
updateFunc: (ptr, source) => source.nativeReadFrom(ptr.ref),
);
Ptr$Color$ = .new(this, r'Ptr$Color$',
allocatorFunc: ([count = 1]) => calloc<Pointer<ColorC>>(count),
valueFunc: Color$.Value,
rawArrayFunc: Color$.RawArray,
);
FilePathList$ = .new(this, r'FilePathList$',
byteSize: sizeOf<FilePathListC>(),
allocatorFunc: ([count = 1]) => calloc<FilePathListC>(count),
refFunc: (ptr) => ptr.ref,
setRefFunc: (ptr, v) => ptr..ref = v,
pointerToStruct: (ptr) => ptr.toD(),
printerFunc: (ptr) => ptr.toD().signature(),
setCFunc: (ptr, i, v) => ptr[i].setC(v),
indexerFunc: (ptr, i) => ptr[i],
indexSetterFunc: (ptr, i, v) => ptr[i] = v,
updateFunc: (ptr, source) => source.nativeReadFrom(ptr.ref),
);
Ptr$FilePathList$ = .new(this, r'Ptr$FilePathList$',
allocatorFunc: ([count = 1]) => calloc<Pointer<FilePathListC>>(count),
valueFunc: FilePathList$.Value,
rawArrayFunc: FilePathList$.RawArray,
);
Font$ = .new(this, r'Font$',
byteSize: sizeOf<FontC>(),
allocatorFunc: ([count = 1]) => calloc<FontC>(count),
refFunc: (ptr) => ptr.ref,
setRefFunc: (ptr, v) => ptr..ref = v,
pointerToStruct: (ptr) => ptr.toD(),
printerFunc: (ptr) => ptr.toD().signature(),
setCFunc: (ptr, i, v) => ptr[i].setC(v),
indexerFunc: (ptr, i) => ptr[i],
indexSetterFunc: (ptr, i, v) => ptr[i] = v,
updateFunc: (ptr, source) => source.nativeReadFrom(ptr.ref),
);
Ptr$Font$ = .new(this, r'Ptr$Font$',
allocatorFunc: ([count = 1]) => calloc<Pointer<FontC>>(count),
valueFunc: Font$.Value,
rawArrayFunc: Font$.RawArray,
);
GlyphInfo$ = .new(this, r'GlyphInfo$',
byteSize: sizeOf<GlyphInfoC>(),
allocatorFunc: ([count = 1]) => calloc<GlyphInfoC>(count),
refFunc: (ptr) => ptr.ref,
setRefFunc: (ptr, v) => ptr..ref = v,
pointerToStruct: (ptr) => ptr.toD(),
printerFunc: (ptr) => ptr.toD().signature(),
setCFunc: (ptr, i, v) => ptr[i].setC(v),
indexerFunc: (ptr, i) => ptr[i],
indexSetterFunc: (ptr, i, v) => ptr[i] = v,
updateFunc: (ptr, source) => source.nativeReadFrom(ptr.ref),
);
Ptr$GlyphInfo$ = .new(this, r'Ptr$GlyphInfo$',
allocatorFunc: ([count = 1]) => calloc<Pointer<GlyphInfoC>>(count),
valueFunc: GlyphInfo$.Value,
rawArrayFunc: GlyphInfo$.RawArray,
);
Image$ = .new(this, r'Image$',
byteSize: sizeOf<ImageC>(),
allocatorFunc: ([count = 1]) => calloc<ImageC>(count),
refFunc: (ptr) => ptr.ref,
setRefFunc: (ptr, v) => ptr..ref = v,
pointerToStruct: (ptr) => ptr.toD(),
printerFunc: (ptr) => ptr.toD().signature(),
setCFunc: (ptr, i, v) => ptr[i].setC(v),
indexerFunc: (ptr, i) => ptr[i],
indexSetterFunc: (ptr, i, v) => ptr[i] = v,
updateFunc: (ptr, source) => source.nativeReadFrom(ptr.ref),
);
Ptr$Image$ = .new(this, r'Ptr$Image$',
allocatorFunc: ([count = 1]) => calloc<Pointer<ImageC>>(count),
valueFunc: Image$.Value,
rawArrayFunc: Image$.RawArray,
);
Light$ = .new(this, r'Light$',
byteSize: sizeOf<LightC>(),
allocatorFunc: ([count = 1]) => calloc<LightC>(count),
refFunc: (ptr) => ptr.ref,
setRefFunc: (ptr, v) => ptr..ref = v,
pointerToStruct: (ptr) => ptr.toD(),
printerFunc: (ptr) => ptr.toD().signature(),
setCFunc: (ptr, i, v) => ptr[i].setC(v),
indexerFunc: (ptr, i) => ptr[i],
indexSetterFunc: (ptr, i, v) => ptr[i] = v,
updateFunc: (ptr, source) => source.nativeReadFrom(ptr.ref),
);
Ptr$Light$ = .new(this, r'Ptr$Light$',
allocatorFunc: ([count = 1]) => calloc<Pointer<LightC>>(count),
valueFunc: Light$.Value,
rawArrayFunc: Light$.RawArray,
);
Material$ = .new(this, r'Material$',
byteSize: sizeOf<MaterialC>(),
allocatorFunc: ([count = 1]) => calloc<MaterialC>(count),
refFunc: (ptr) => ptr.ref,
setRefFunc: (ptr, v) => ptr..ref = v,
pointerToStruct: (ptr) => ptr.toD(),
printerFunc: (ptr) => ptr.toD().signature(),
setCFunc: (ptr, i, v) => ptr[i].setC(v),
indexerFunc: (ptr, i) => ptr[i],
indexSetterFunc: (ptr, i, v) => ptr[i] = v,
updateFunc: (ptr, source) => source.nativeReadFrom(ptr.ref),
);
Ptr$Material$ = .new(this, r'Ptr$Material$',
allocatorFunc: ([count = 1]) => calloc<Pointer<MaterialC>>(count),
valueFunc: Material$.Value,
rawArrayFunc: Material$.RawArray,
);
MaterialMap$ = .new(this, r'MaterialMap$',
byteSize: sizeOf<MaterialMapC>(),
allocatorFunc: ([count = 1]) => calloc<MaterialMapC>(count),
refFunc: (ptr) => ptr.ref,
setRefFunc: (ptr, v) => ptr..ref = v,
pointerToStruct: (ptr) => ptr.toD(),
printerFunc: (ptr) => ptr.toD().signature(),
setCFunc: (ptr, i, v) => ptr[i].setC(v),
indexerFunc: (ptr, i) => ptr[i],
indexSetterFunc: (ptr, i, v) => ptr[i] = v,
updateFunc: (ptr, source) => source.nativeReadFrom(ptr.ref),
);
Ptr$MaterialMap$ = .new(this, r'Ptr$MaterialMap$',
allocatorFunc: ([count = 1]) => calloc<Pointer<MaterialMapC>>(count),
valueFunc: MaterialMap$.Value,
rawArrayFunc: MaterialMap$.RawArray,
);
Matrix$ = .new(this, r'Matrix$',
byteSize: sizeOf<MatrixC>(),
allocatorFunc: ([count = 1]) => calloc<MatrixC>(count),
refFunc: (ptr) => ptr.ref,
setRefFunc: (ptr, v) => ptr..ref = v,
pointerToStruct: (ptr) => ptr.toD(),
printerFunc: (ptr) => ptr.toD().signature(),
setCFunc: (ptr, i, v) => ptr[i].setC(v),
indexerFunc: (ptr, i) => ptr[i],
indexSetterFunc: (ptr, i, v) => ptr[i] = v,
updateFunc: (ptr, source) => source.nativeReadFrom(ptr.ref),
);
Ptr$Matrix$ = .new(this, r'Ptr$Matrix$',
allocatorFunc: ([count = 1]) => calloc<Pointer<MatrixC>>(count),
valueFunc: Matrix$.Value,
rawArrayFunc: Matrix$.RawArray,
);
Mesh$ = .new(this, r'Mesh$',
byteSize: sizeOf<MeshC>(),
allocatorFunc: ([count = 1]) => calloc<MeshC>(count),
refFunc: (ptr) => ptr.ref,
setRefFunc: (ptr, v) => ptr..ref = v,
pointerToStruct: (ptr) => ptr.toD(),
printerFunc: (ptr) => ptr.toD().signature(),
setCFunc: (ptr, i, v) => ptr[i].setC(v),
indexerFunc: (ptr, i) => ptr[i],
indexSetterFunc: (ptr, i, v) => ptr[i] = v,
updateFunc: (ptr, source) => source.nativeReadFrom(ptr.ref),
);
Ptr$Mesh$ = .new(this, r'Ptr$Mesh$',
allocatorFunc: ([count = 1]) => calloc<Pointer<MeshC>>(count),
valueFunc: Mesh$.Value,
rawArrayFunc: Mesh$.RawArray,
);
Model$ = .new(this, r'Model$',
byteSize: sizeOf<ModelC>(),
allocatorFunc: ([count = 1]) => calloc<ModelC>(count),
refFunc: (ptr) => ptr.ref,
setRefFunc: (ptr, v) => ptr..ref = v,
pointerToStruct: (ptr) => ptr.toD(),
printerFunc: (ptr) => ptr.toD().signature(),
setCFunc: (ptr, i, v) => ptr[i].setC(v),
indexerFunc: (ptr, i) => ptr[i],
indexSetterFunc: (ptr, i, v) => ptr[i] = v,
updateFunc: (ptr, source) => source.nativeReadFrom(ptr.ref),
);
Ptr$Model$ = .new(this, r'Ptr$Model$',
allocatorFunc: ([count = 1]) => calloc<Pointer<ModelC>>(count),
valueFunc: Model$.Value,
rawArrayFunc: Model$.RawArray,
);
ModelAnimation$ = .new(this, r'ModelAnimation$',
byteSize: sizeOf<ModelAnimationC>(),
allocatorFunc: ([count = 1]) => calloc<ModelAnimationC>(count),
refFunc: (ptr) => ptr.ref,
setRefFunc: (ptr, v) => ptr..ref = v,
pointerToStruct: (ptr) => ptr.toD(),
printerFunc: (ptr) => ptr.toD().signature(),
setCFunc: (ptr, i, v) => ptr[i].setC(v),
indexerFunc: (ptr, i) => ptr[i],
indexSetterFunc: (ptr, i, v) => ptr[i] = v,
updateFunc: (ptr, source) => source.nativeReadFrom(ptr.ref),
);
Ptr$ModelAnimation$ = .new(this, r'Ptr$ModelAnimation$',
allocatorFunc: ([count = 1]) => calloc<Pointer<ModelAnimationC>>(count),
valueFunc: ModelAnimation$.Value,
rawArrayFunc: ModelAnimation$.RawArray,
);
Music$ = .new(this, r'Music$',
byteSize: sizeOf<MusicC>(),
allocatorFunc: ([count = 1]) => calloc<MusicC>(count),
refFunc: (ptr) => ptr.ref,
setRefFunc: (ptr, v) => ptr..ref = v,
pointerToStruct: (ptr) => ptr.toD(),
printerFunc: (ptr) => ptr.toD().signature(),
setCFunc: (ptr, i, v) => ptr[i].setC(v),
indexerFunc: (ptr, i) => ptr[i],
indexSetterFunc: (ptr, i, v) => ptr[i] = v,
updateFunc: (ptr, source) => source.nativeReadFrom(ptr.ref),
);
Ptr$Music$ = .new(this, r'Ptr$Music$',
allocatorFunc: ([count = 1]) => calloc<Pointer<MusicC>>(count),
valueFunc: Music$.Value,
rawArrayFunc: Music$.RawArray,
);
NPatchInfo$ = .new(this, r'NPatchInfo$',
byteSize: sizeOf<NPatchInfoC>(),
allocatorFunc: ([count = 1]) => calloc<NPatchInfoC>(count),
refFunc: (ptr) => ptr.ref,
setRefFunc: (ptr, v) => ptr..ref = v,
pointerToStruct: (ptr) => ptr.toD(),
printerFunc: (ptr) => ptr.toD().signature(),
setCFunc: (ptr, i, v) => ptr[i].setC(v),
indexerFunc: (ptr, i) => ptr[i],
indexSetterFunc: (ptr, i, v) => ptr[i] = v,
updateFunc: (ptr, source) => source.nativeReadFrom(ptr.ref),
);
Ptr$NPatchInfo$ = .new(this, r'Ptr$NPatchInfo$',
allocatorFunc: ([count = 1]) => calloc<Pointer<NPatchInfoC>>(count),
valueFunc: NPatchInfo$.Value,
rawArrayFunc: NPatchInfo$.RawArray,
);
Quaternion$ = .new(this, r'Quaternion$',
byteSize: sizeOf<QuaternionC>(),
allocatorFunc: ([count = 1]) => calloc<QuaternionC>(count),
refFunc: (ptr) => ptr.ref,
setRefFunc: (ptr, v) => ptr..ref = v,
pointerToStruct: (ptr) => ptr.toD(),
printerFunc: (ptr) => ptr.toD().signature(),
setCFunc: (ptr, i, v) => ptr[i].setC(v),
indexerFunc: (ptr, i) => ptr[i],
indexSetterFunc: (ptr, i, v) => ptr[i] = v,
updateFunc: (ptr, source) => source.nativeReadFrom(ptr.ref),
);
Ptr$Quaternion$ = .new(this, r'Ptr$Quaternion$',
allocatorFunc: ([count = 1]) => calloc<Pointer<QuaternionC>>(count),
valueFunc: Quaternion$.Value,
rawArrayFunc: Quaternion$.RawArray,
);
Rectangle$ = .new(this, r'Rectangle$',
byteSize: sizeOf<RectangleC>(),
allocatorFunc: ([count = 1]) => calloc<RectangleC>(count),
refFunc: (ptr) => ptr.ref,
setRefFunc: (ptr, v) => ptr..ref = v,
pointerToStruct: (ptr) => ptr.toD(),
printerFunc: (ptr) => ptr.toD().signature(),
setCFunc: (ptr, i, v) => ptr[i].setC(v),
indexerFunc: (ptr, i) => ptr[i],
indexSetterFunc: (ptr, i, v) => ptr[i] = v,
updateFunc: (ptr, source) => source.nativeReadFrom(ptr.ref),
);
Ptr$Rectangle$ = .new(this, r'Ptr$Rectangle$',
allocatorFunc: ([count = 1]) => calloc<Pointer<RectangleC>>(count),
valueFunc: Rectangle$.Value,
rawArrayFunc: Rectangle$.RawArray,
);
RlDrawCall$ = .new(this, r'RlDrawCall$',
byteSize: sizeOf<RlDrawCallC>(),
allocatorFunc: ([count = 1]) => calloc<RlDrawCallC>(count),
refFunc: (ptr) => ptr.ref,
setRefFunc: (ptr, v) => ptr..ref = v,
pointerToStruct: (ptr) => ptr.toD(),
printerFunc: (ptr) => ptr.toD().signature(),
setCFunc: (ptr, i, v) => ptr[i].setC(v),
indexerFunc: (ptr, i) => ptr[i],
indexSetterFunc: (ptr, i, v) => ptr[i] = v,
updateFunc: (ptr, source) => source.nativeReadFrom(ptr.ref),
);
Ptr$RlDrawCall$ = .new(this, r'Ptr$RlDrawCall$',
allocatorFunc: ([count = 1]) => calloc<Pointer<RlDrawCallC>>(count),
valueFunc: RlDrawCall$.Value,
rawArrayFunc: RlDrawCall$.RawArray,
);
RlRenderBatch$ = .new(this, r'RlRenderBatch$',
byteSize: sizeOf<RlRenderBatchC>(),
allocatorFunc: ([count = 1]) => calloc<RlRenderBatchC>(count),
refFunc: (ptr) => ptr.ref,
setRefFunc: (ptr, v) => ptr..ref = v,
pointerToStruct: (ptr) => ptr.toD(),
printerFunc: (ptr) => ptr.toD().signature(),
setCFunc: (ptr, i, v) => ptr[i].setC(v),
indexerFunc: (ptr, i) => ptr[i],
indexSetterFunc: (ptr, i, v) => ptr[i] = v,
updateFunc: (ptr, source) => source.nativeReadFrom(ptr.ref),
);
Ptr$RlRenderBatch$ = .new(this, r'Ptr$RlRenderBatch$',
allocatorFunc: ([count = 1]) => calloc<Pointer<RlRenderBatchC>>(count),
valueFunc: RlRenderBatch$.Value,
rawArrayFunc: RlRenderBatch$.RawArray,
);
RlVertexBuffer$ = .new(this, r'RlVertexBuffer$',
byteSize: sizeOf<RlVertexBufferC>(),
allocatorFunc: ([count = 1]) => calloc<RlVertexBufferC>(count),
refFunc: (ptr) => ptr.ref,
setRefFunc: (ptr, v) => ptr..ref = v,
pointerToStruct: (ptr) => ptr.toD(),
printerFunc: (ptr) => ptr.toD().signature(),
setCFunc: (ptr, i, v) => ptr[i].setC(v),
indexerFunc: (ptr, i) => ptr[i],
indexSetterFunc: (ptr, i, v) => ptr[i] = v,
updateFunc: (ptr, source) => source.nativeReadFrom(ptr.ref),
);
Ptr$RlVertexBuffer$ = .new(this, r'Ptr$RlVertexBuffer$',
allocatorFunc: ([count = 1]) => calloc<Pointer<RlVertexBufferC>>(count),
valueFunc: RlVertexBuffer$.Value,
rawArrayFunc: RlVertexBuffer$.RawArray,
);
Ray$ = .new(this, r'Ray$',
byteSize: sizeOf<RayC>(),
allocatorFunc: ([count = 1]) => calloc<RayC>(count),
refFunc: (ptr) => ptr.ref,
setRefFunc: (ptr, v) => ptr..ref = v,
pointerToStruct: (ptr) => ptr.toD(),
printerFunc: (ptr) => ptr.toD().signature(),
setCFunc: (ptr, i, v) => ptr[i].setC(v),
indexerFunc: (ptr, i) => ptr[i],
indexSetterFunc: (ptr, i, v) => ptr[i] = v,
updateFunc: (ptr, source) => source.nativeReadFrom(ptr.ref),
);
Ptr$Ray$ = .new(this, r'Ptr$Ray$',
allocatorFunc: ([count = 1]) => calloc<Pointer<RayC>>(count),
valueFunc: Ray$.Value,
rawArrayFunc: Ray$.RawArray,
);
RayCollision$ = .new(this, r'RayCollision$',
byteSize: sizeOf<RayCollisionC>(),
allocatorFunc: ([count = 1]) => calloc<RayCollisionC>(count),
refFunc: (ptr) => ptr.ref,
setRefFunc: (ptr, v) => ptr..ref = v,
pointerToStruct: (ptr) => ptr.toD(),
printerFunc: (ptr) => ptr.toD().signature(),
setCFunc: (ptr, i, v) => ptr[i].setC(v),
indexerFunc: (ptr, i) => ptr[i],
indexSetterFunc: (ptr, i, v) => ptr[i] = v,
updateFunc: (ptr, source) => source.nativeReadFrom(ptr.ref),
);
Ptr$RayCollision$ = .new(this, r'Ptr$RayCollision$',
allocatorFunc: ([count = 1]) => calloc<Pointer<RayCollisionC>>(count),
valueFunc: RayCollision$.Value,
rawArrayFunc: RayCollision$.RawArray,
);
RenderTexture$ = .new(this, r'RenderTexture$',
byteSize: sizeOf<RenderTextureC>(),
allocatorFunc: ([count = 1]) => calloc<RenderTextureC>(count),
refFunc: (ptr) => ptr.ref,
setRefFunc: (ptr, v) => ptr..ref = v,
pointerToStruct: (ptr) => ptr.toD(),
printerFunc: (ptr) => ptr.toD().signature(),
setCFunc: (ptr, i, v) => ptr[i].setC(v),
indexerFunc: (ptr, i) => ptr[i],
indexSetterFunc: (ptr, i, v) => ptr[i] = v,
updateFunc: (ptr, source) => source.nativeReadFrom(ptr.ref),
);
Ptr$RenderTexture$ = .new(this, r'Ptr$RenderTexture$',
allocatorFunc: ([count = 1]) => calloc<Pointer<RenderTextureC>>(count),
valueFunc: RenderTexture$.Value,
rawArrayFunc: RenderTexture$.RawArray,
);
Shader$ = .new(this, r'Shader$',
byteSize: sizeOf<ShaderC>(),
allocatorFunc: ([count = 1]) => calloc<ShaderC>(count),
refFunc: (ptr) => ptr.ref,
setRefFunc: (ptr, v) => ptr..ref = v,
pointerToStruct: (ptr) => ptr.toD(),
printerFunc: (ptr) => ptr.toD().signature(),
setCFunc: (ptr, i, v) => ptr[i].setC(v),
indexerFunc: (ptr, i) => ptr[i],
indexSetterFunc: (ptr, i, v) => ptr[i] = v,
updateFunc: (ptr, source) => source.nativeReadFrom(ptr.ref),
);
Ptr$Shader$ = .new(this, r'Ptr$Shader$',
allocatorFunc: ([count = 1]) => calloc<Pointer<ShaderC>>(count),
valueFunc: Shader$.Value,
rawArrayFunc: Shader$.RawArray,
);
Sound$ = .new(this, r'Sound$',
byteSize: sizeOf<SoundC>(),
allocatorFunc: ([count = 1]) => calloc<SoundC>(count),
refFunc: (ptr) => ptr.ref,
setRefFunc: (ptr, v) => ptr..ref = v,
pointerToStruct: (ptr) => ptr.toD(),
printerFunc: (ptr) => ptr.toD().signature(),
setCFunc: (ptr, i, v) => ptr[i].setC(v),
indexerFunc: (ptr, i) => ptr[i],
indexSetterFunc: (ptr, i, v) => ptr[i] = v,
updateFunc: (ptr, source) => source.nativeReadFrom(ptr.ref),
);
Ptr$Sound$ = .new(this, r'Ptr$Sound$',
allocatorFunc: ([count = 1]) => calloc<Pointer<SoundC>>(count),
valueFunc: Sound$.Value,
rawArrayFunc: Sound$.RawArray,
);
Texture$ = .new(this, r'Texture$',
byteSize: sizeOf<TextureC>(),
allocatorFunc: ([count = 1]) => calloc<TextureC>(count),
refFunc: (ptr) => ptr.ref,
setRefFunc: (ptr, v) => ptr..ref = v,
pointerToStruct: (ptr) => ptr.toD(),
printerFunc: (ptr) => ptr.toD().signature(),
setCFunc: (ptr, i, v) => ptr[i].setC(v),
indexerFunc: (ptr, i) => ptr[i],
indexSetterFunc: (ptr, i, v) => ptr[i] = v,
updateFunc: (ptr, source) => source.nativeReadFrom(ptr.ref),
);
Ptr$Texture$ = .new(this, r'Ptr$Texture$',
allocatorFunc: ([count = 1]) => calloc<Pointer<TextureC>>(count),
valueFunc: Texture$.Value,
rawArrayFunc: Texture$.RawArray,
);
Transform$ = .new(this, r'Transform$',
byteSize: sizeOf<TransformC>(),
allocatorFunc: ([count = 1]) => calloc<TransformC>(count),
refFunc: (ptr) => ptr.ref,
setRefFunc: (ptr, v) => ptr..ref = v,
pointerToStruct: (ptr) => ptr.toD(),
printerFunc: (ptr) => ptr.toD().signature(),
setCFunc: (ptr, i, v) => ptr[i].setC(v),
indexerFunc: (ptr, i) => ptr[i],
indexSetterFunc: (ptr, i, v) => ptr[i] = v,
updateFunc: (ptr, source) => source.nativeReadFrom(ptr.ref),
);
Ptr$Transform$ = .new(this, r'Ptr$Transform$',
allocatorFunc: ([count = 1]) => calloc<Pointer<TransformC>>(count),
valueFunc: Transform$.Value,
rawArrayFunc: Transform$.RawArray,
);
Vector2$ = .new(this, r'Vector2$',
byteSize: sizeOf<Vector2C>(),
allocatorFunc: ([count = 1]) => calloc<Vector2C>(count),
refFunc: (ptr) => ptr.ref,
setRefFunc: (ptr, v) => ptr..ref = v,
pointerToStruct: (ptr) => ptr.toD(),
printerFunc: (ptr) => ptr.toD().signature(),
setCFunc: (ptr, i, v) => ptr[i].setC(v),
indexerFunc: (ptr, i) => ptr[i],
indexSetterFunc: (ptr, i, v) => ptr[i] = v,
updateFunc: (ptr, source) => source.nativeReadFrom(ptr.ref),
);
Ptr$Vector2$ = .new(this, r'Ptr$Vector2$',
allocatorFunc: ([count = 1]) => calloc<Pointer<Vector2C>>(count),
valueFunc: Vector2$.Value,
rawArrayFunc: Vector2$.RawArray,
);
Vector3$ = .new(this, r'Vector3$',
byteSize: sizeOf<Vector3C>(),
allocatorFunc: ([count = 1]) => calloc<Vector3C>(count),
refFunc: (ptr) => ptr.ref,
setRefFunc: (ptr, v) => ptr..ref = v,
pointerToStruct: (ptr) => ptr.toD(),
printerFunc: (ptr) => ptr.toD().signature(),
setCFunc: (ptr, i, v) => ptr[i].setC(v),
indexerFunc: (ptr, i) => ptr[i],
indexSetterFunc: (ptr, i, v) => ptr[i] = v,
updateFunc: (ptr, source) => source.nativeReadFrom(ptr.ref),
);
Ptr$Vector3$ = .new(this, r'Ptr$Vector3$',
allocatorFunc: ([count = 1]) => calloc<Pointer<Vector3C>>(count),
valueFunc: Vector3$.Value,
rawArrayFunc: Vector3$.RawArray,
);
Vector4$ = .new(this, r'Vector4$',
byteSize: sizeOf<Vector4C>(),
allocatorFunc: ([count = 1]) => calloc<Vector4C>(count),
refFunc: (ptr) => ptr.ref,
setRefFunc: (ptr, v) => ptr..ref = v,
pointerToStruct: (ptr) => ptr.toD(),
printerFunc: (ptr) => ptr.toD().signature(),
setCFunc: (ptr, i, v) => ptr[i].setC(v),
indexerFunc: (ptr, i) => ptr[i],
indexSetterFunc: (ptr, i, v) => ptr[i] = v,
updateFunc: (ptr, source) => source.nativeReadFrom(ptr.ref),
);
Ptr$Vector4$ = .new(this, r'Ptr$Vector4$',
allocatorFunc: ([count = 1]) => calloc<Pointer<Vector4C>>(count),
valueFunc: Vector4$.Value,
rawArrayFunc: Vector4$.RawArray,
);
VrDeviceInfo$ = .new(this, r'VrDeviceInfo$',
byteSize: sizeOf<VrDeviceInfoC>(),
allocatorFunc: ([count = 1]) => calloc<VrDeviceInfoC>(count),
refFunc: (ptr) => ptr.ref,
setRefFunc: (ptr, v) => ptr..ref = v,
pointerToStruct: (ptr) => ptr.toD(),
printerFunc: (ptr) => ptr.toD().signature(),
setCFunc: (ptr, i, v) => ptr[i].setC(v),
indexerFunc: (ptr, i) => ptr[i],
indexSetterFunc: (ptr, i, v) => ptr[i] = v,
updateFunc: (ptr, source) => source.nativeReadFrom(ptr.ref),
);
Ptr$VrDeviceInfo$ = .new(this, r'Ptr$VrDeviceInfo$',
allocatorFunc: ([count = 1]) => calloc<Pointer<VrDeviceInfoC>>(count),
valueFunc: VrDeviceInfo$.Value,
rawArrayFunc: VrDeviceInfo$.RawArray,
);
VrStereoConfig$ = .new(this, r'VrStereoConfig$',
byteSize: sizeOf<VrStereoConfigC>(),
allocatorFunc: ([count = 1]) => calloc<VrStereoConfigC>(count),
refFunc: (ptr) => ptr.ref,
setRefFunc: (ptr, v) => ptr..ref = v,
pointerToStruct: (ptr) => ptr.toD(),
printerFunc: (ptr) => ptr.toD().signature(),
setCFunc: (ptr, i, v) => ptr[i].setC(v),
indexerFunc: (ptr, i) => ptr[i],
indexSetterFunc: (ptr, i, v) => ptr[i] = v,
updateFunc: (ptr, source) => source.nativeReadFrom(ptr.ref),
);
Ptr$VrStereoConfig$ = .new(this, r'Ptr$VrStereoConfig$',
allocatorFunc: ([count = 1]) => calloc<Pointer<VrStereoConfigC>>(count),
valueFunc: VrStereoConfig$.Value,
rawArrayFunc: VrStereoConfig$.RawArray,
);
Wave$ = .new(this, r'Wave$',
byteSize: sizeOf<WaveC>(),
allocatorFunc: ([count = 1]) => calloc<WaveC>(count),
refFunc: (ptr) => ptr.ref,
setRefFunc: (ptr, v) => ptr..ref = v,
pointerToStruct: (ptr) => ptr.toD(),
printerFunc: (ptr) => ptr.toD().signature(),
setCFunc: (ptr, i, v) => ptr[i].setC(v),
indexerFunc: (ptr, i) => ptr[i],
indexSetterFunc: (ptr, i, v) => ptr[i] = v,
updateFunc: (ptr, source) => source.nativeReadFrom(ptr.ref),
);
Ptr$Wave$ = .new(this, r'Ptr$Wave$',
allocatorFunc: ([count = 1]) => calloc<Pointer<WaveC>>(count),
valueFunc: Wave$.Value,
rawArrayFunc: Wave$.RawArray,
);
}
