mirror of
https://github.com/blitzkit/blitzkit.git
synced 2026-10-21 10:47:04 +02:00
2258 lines
60 KiB
TypeScript
2258 lines
60 KiB
TypeScript
// Code generated by protoc-gen-ts_proto. DO NOT EDIT.
|
|
// versions:
|
|
// protoc-gen-ts_proto v2.11.2
|
|
// protoc v5.28.2
|
|
// source: model_definitions.proto
|
|
|
|
/* eslint-disable */
|
|
import { BinaryReader, BinaryWriter } from "@bufbuild/protobuf/wire";
|
|
|
|
export const protobufPackage = "blitzkit";
|
|
|
|
export interface ModelDefinitions {
|
|
models: { [key: number]: ModelDefinition };
|
|
}
|
|
|
|
export interface ModelDefinitions_ModelsEntry {
|
|
key: number;
|
|
value: ModelDefinition | undefined;
|
|
}
|
|
|
|
export interface ModelDefinition {
|
|
armor: Armor | undefined;
|
|
turret_origin: Vector3 | undefined;
|
|
initial_turret_rotation?: InitialTurretRotation | undefined;
|
|
turrets: { [key: number]: TurretModelDefinition };
|
|
tracks: { [key: number]: TrackModelDefinition };
|
|
bounding_box: BoundingBox | undefined;
|
|
}
|
|
|
|
export interface ModelDefinition_TurretsEntry {
|
|
key: number;
|
|
value: TurretModelDefinition | undefined;
|
|
}
|
|
|
|
export interface ModelDefinition_TracksEntry {
|
|
key: number;
|
|
value: TrackModelDefinition | undefined;
|
|
}
|
|
|
|
export interface Armor {
|
|
thickness: { [key: number]: number };
|
|
spaced: number[];
|
|
}
|
|
|
|
export interface Armor_ThicknessEntry {
|
|
key: number;
|
|
value: number;
|
|
}
|
|
|
|
export interface Vector3 {
|
|
x: number;
|
|
y: number;
|
|
z: number;
|
|
}
|
|
|
|
export interface InitialTurretRotation {
|
|
yaw: number;
|
|
pitch: number;
|
|
roll: number;
|
|
}
|
|
|
|
export interface TurretModelDefinition {
|
|
bounding_box: BoundingBox | undefined;
|
|
armor: Armor | undefined;
|
|
model_id: number;
|
|
gun_origin: Vector3 | undefined;
|
|
guns: { [key: number]: GunModelDefinition };
|
|
yaw?: YawLimits | undefined;
|
|
}
|
|
|
|
export interface TurretModelDefinition_GunsEntry {
|
|
key: number;
|
|
value: GunModelDefinition | undefined;
|
|
}
|
|
|
|
export interface YawLimits {
|
|
min: number;
|
|
max: number;
|
|
}
|
|
|
|
export interface BoundingBox {
|
|
min: Vector3 | undefined;
|
|
max: Vector3 | undefined;
|
|
}
|
|
|
|
export interface TrackModelDefinition {
|
|
thickness: number;
|
|
origin: Vector3 | undefined;
|
|
}
|
|
|
|
export interface GunModelDefinition {
|
|
armor: Armor | undefined;
|
|
thickness: number;
|
|
model_id: number;
|
|
pitch: PitchLimits | undefined;
|
|
mask?: number | undefined;
|
|
}
|
|
|
|
export interface PitchLimits {
|
|
min: number;
|
|
max: number;
|
|
front?: PitchLimitsExtrema | undefined;
|
|
back?: PitchLimitsExtrema | undefined;
|
|
transition?: number | undefined;
|
|
}
|
|
|
|
export interface PitchLimitsExtrema {
|
|
min: number;
|
|
max: number;
|
|
range: number;
|
|
}
|
|
|
|
function createBaseModelDefinitions(): ModelDefinitions {
|
|
return { models: {} };
|
|
}
|
|
|
|
export const ModelDefinitions: MessageFns<ModelDefinitions> = {
|
|
encode(
|
|
message: ModelDefinitions,
|
|
writer: BinaryWriter = new BinaryWriter(),
|
|
): BinaryWriter {
|
|
globalThis.Object.entries(message.models).forEach(
|
|
([key, value]: [string, ModelDefinition]) => {
|
|
ModelDefinitions_ModelsEntry.encode(
|
|
{ key: key as any, value },
|
|
writer.uint32(10).fork(),
|
|
).join();
|
|
},
|
|
);
|
|
return writer;
|
|
},
|
|
|
|
decode(input: BinaryReader | Uint8Array, length?: number): ModelDefinitions {
|
|
const reader =
|
|
input instanceof BinaryReader ? input : new BinaryReader(input);
|
|
const end = length === undefined ? reader.len : reader.pos + length;
|
|
const message = createBaseModelDefinitions();
|
|
while (reader.pos < end) {
|
|
const tag = reader.uint32();
|
|
switch (tag >>> 3) {
|
|
case 1: {
|
|
if (tag !== 10) {
|
|
break;
|
|
}
|
|
|
|
const entry1 = ModelDefinitions_ModelsEntry.decode(
|
|
reader,
|
|
reader.uint32(),
|
|
);
|
|
if (entry1.value !== undefined) {
|
|
message.models[entry1.key] = entry1.value;
|
|
}
|
|
continue;
|
|
}
|
|
}
|
|
if ((tag & 7) === 4 || tag === 0) {
|
|
break;
|
|
}
|
|
reader.skip(tag & 7);
|
|
}
|
|
return message;
|
|
},
|
|
|
|
fromJSON(object: any): ModelDefinitions {
|
|
return {
|
|
models: isObject(object.models)
|
|
? (globalThis.Object.entries(object.models) as [string, any][]).reduce(
|
|
(
|
|
acc: { [key: number]: ModelDefinition },
|
|
[key, value]: [string, any],
|
|
) => {
|
|
acc[globalThis.Number(key)] = ModelDefinition.fromJSON(value);
|
|
return acc;
|
|
},
|
|
{},
|
|
)
|
|
: {},
|
|
};
|
|
},
|
|
|
|
toJSON(message: ModelDefinitions): unknown {
|
|
const obj: any = {};
|
|
if (message.models) {
|
|
const entries = globalThis.Object.entries(message.models) as [
|
|
string,
|
|
ModelDefinition,
|
|
][];
|
|
if (entries.length > 0) {
|
|
obj.models = {};
|
|
entries.forEach(([k, v]) => {
|
|
obj.models[k] = ModelDefinition.toJSON(v);
|
|
});
|
|
}
|
|
}
|
|
return obj;
|
|
},
|
|
|
|
create<I extends Exact<DeepPartial<ModelDefinitions>, I>>(
|
|
base?: I,
|
|
): ModelDefinitions {
|
|
return ModelDefinitions.fromPartial(base ?? ({} as any));
|
|
},
|
|
fromPartial<I extends Exact<DeepPartial<ModelDefinitions>, I>>(
|
|
object: I,
|
|
): ModelDefinitions {
|
|
const message = createBaseModelDefinitions();
|
|
message.models = (
|
|
globalThis.Object.entries(object.models ?? {}) as [
|
|
string,
|
|
ModelDefinition,
|
|
][]
|
|
).reduce(
|
|
(
|
|
acc: { [key: number]: ModelDefinition },
|
|
[key, value]: [string, ModelDefinition],
|
|
) => {
|
|
if (value !== undefined) {
|
|
acc[globalThis.Number(key)] = ModelDefinition.fromPartial(value);
|
|
}
|
|
return acc;
|
|
},
|
|
{},
|
|
);
|
|
return message;
|
|
},
|
|
};
|
|
|
|
function createBaseModelDefinitions_ModelsEntry(): ModelDefinitions_ModelsEntry {
|
|
return { key: 0, value: undefined };
|
|
}
|
|
|
|
export const ModelDefinitions_ModelsEntry: MessageFns<ModelDefinitions_ModelsEntry> =
|
|
{
|
|
encode(
|
|
message: ModelDefinitions_ModelsEntry,
|
|
writer: BinaryWriter = new BinaryWriter(),
|
|
): BinaryWriter {
|
|
if (message.key !== 0) {
|
|
writer.uint32(8).uint32(message.key);
|
|
}
|
|
if (message.value !== undefined) {
|
|
ModelDefinition.encode(message.value, writer.uint32(18).fork()).join();
|
|
}
|
|
return writer;
|
|
},
|
|
|
|
decode(
|
|
input: BinaryReader | Uint8Array,
|
|
length?: number,
|
|
): ModelDefinitions_ModelsEntry {
|
|
const reader =
|
|
input instanceof BinaryReader ? input : new BinaryReader(input);
|
|
const end = length === undefined ? reader.len : reader.pos + length;
|
|
const message = createBaseModelDefinitions_ModelsEntry();
|
|
while (reader.pos < end) {
|
|
const tag = reader.uint32();
|
|
switch (tag >>> 3) {
|
|
case 1: {
|
|
if (tag !== 8) {
|
|
break;
|
|
}
|
|
|
|
message.key = reader.uint32();
|
|
continue;
|
|
}
|
|
case 2: {
|
|
if (tag !== 18) {
|
|
break;
|
|
}
|
|
|
|
message.value = ModelDefinition.decode(reader, reader.uint32());
|
|
continue;
|
|
}
|
|
}
|
|
if ((tag & 7) === 4 || tag === 0) {
|
|
break;
|
|
}
|
|
reader.skip(tag & 7);
|
|
}
|
|
return message;
|
|
},
|
|
|
|
fromJSON(object: any): ModelDefinitions_ModelsEntry {
|
|
return {
|
|
key: isSet(object.key) ? globalThis.Number(object.key) : 0,
|
|
value: isSet(object.value)
|
|
? ModelDefinition.fromJSON(object.value)
|
|
: undefined,
|
|
};
|
|
},
|
|
|
|
toJSON(message: ModelDefinitions_ModelsEntry): unknown {
|
|
const obj: any = {};
|
|
if (message.key !== 0) {
|
|
obj.key = Math.round(message.key);
|
|
}
|
|
if (message.value !== undefined) {
|
|
obj.value = ModelDefinition.toJSON(message.value);
|
|
}
|
|
return obj;
|
|
},
|
|
|
|
create<I extends Exact<DeepPartial<ModelDefinitions_ModelsEntry>, I>>(
|
|
base?: I,
|
|
): ModelDefinitions_ModelsEntry {
|
|
return ModelDefinitions_ModelsEntry.fromPartial(base ?? ({} as any));
|
|
},
|
|
fromPartial<I extends Exact<DeepPartial<ModelDefinitions_ModelsEntry>, I>>(
|
|
object: I,
|
|
): ModelDefinitions_ModelsEntry {
|
|
const message = createBaseModelDefinitions_ModelsEntry();
|
|
message.key = object.key ?? 0;
|
|
message.value =
|
|
object.value !== undefined && object.value !== null
|
|
? ModelDefinition.fromPartial(object.value)
|
|
: undefined;
|
|
return message;
|
|
},
|
|
};
|
|
|
|
function createBaseModelDefinition(): ModelDefinition {
|
|
return {
|
|
armor: undefined,
|
|
turret_origin: undefined,
|
|
initial_turret_rotation: undefined,
|
|
turrets: {},
|
|
tracks: {},
|
|
bounding_box: undefined,
|
|
};
|
|
}
|
|
|
|
export const ModelDefinition: MessageFns<ModelDefinition> = {
|
|
encode(
|
|
message: ModelDefinition,
|
|
writer: BinaryWriter = new BinaryWriter(),
|
|
): BinaryWriter {
|
|
if (message.armor !== undefined) {
|
|
Armor.encode(message.armor, writer.uint32(10).fork()).join();
|
|
}
|
|
if (message.turret_origin !== undefined) {
|
|
Vector3.encode(message.turret_origin, writer.uint32(18).fork()).join();
|
|
}
|
|
if (message.initial_turret_rotation !== undefined) {
|
|
InitialTurretRotation.encode(
|
|
message.initial_turret_rotation,
|
|
writer.uint32(26).fork(),
|
|
).join();
|
|
}
|
|
globalThis.Object.entries(message.turrets).forEach(
|
|
([key, value]: [string, TurretModelDefinition]) => {
|
|
ModelDefinition_TurretsEntry.encode(
|
|
{ key: key as any, value },
|
|
writer.uint32(34).fork(),
|
|
).join();
|
|
},
|
|
);
|
|
globalThis.Object.entries(message.tracks).forEach(
|
|
([key, value]: [string, TrackModelDefinition]) => {
|
|
ModelDefinition_TracksEntry.encode(
|
|
{ key: key as any, value },
|
|
writer.uint32(42).fork(),
|
|
).join();
|
|
},
|
|
);
|
|
if (message.bounding_box !== undefined) {
|
|
BoundingBox.encode(
|
|
message.bounding_box!,
|
|
writer.uint32(50).fork(),
|
|
).join();
|
|
}
|
|
return writer;
|
|
},
|
|
|
|
decode(input: BinaryReader | Uint8Array, length?: number): ModelDefinition {
|
|
const reader =
|
|
input instanceof BinaryReader ? input : new BinaryReader(input);
|
|
const end = length === undefined ? reader.len : reader.pos + length;
|
|
const message = createBaseModelDefinition();
|
|
while (reader.pos < end) {
|
|
const tag = reader.uint32();
|
|
switch (tag >>> 3) {
|
|
case 1: {
|
|
if (tag !== 10) {
|
|
break;
|
|
}
|
|
|
|
message.armor = Armor.decode(reader, reader.uint32());
|
|
continue;
|
|
}
|
|
case 2: {
|
|
if (tag !== 18) {
|
|
break;
|
|
}
|
|
|
|
message.turret_origin = Vector3.decode(reader, reader.uint32());
|
|
continue;
|
|
}
|
|
case 3: {
|
|
if (tag !== 26) {
|
|
break;
|
|
}
|
|
|
|
message.initial_turret_rotation = InitialTurretRotation.decode(
|
|
reader,
|
|
reader.uint32(),
|
|
);
|
|
continue;
|
|
}
|
|
case 4: {
|
|
if (tag !== 34) {
|
|
break;
|
|
}
|
|
|
|
const entry4 = ModelDefinition_TurretsEntry.decode(
|
|
reader,
|
|
reader.uint32(),
|
|
);
|
|
if (entry4.value !== undefined) {
|
|
message.turrets[entry4.key] = entry4.value;
|
|
}
|
|
continue;
|
|
}
|
|
case 5: {
|
|
if (tag !== 42) {
|
|
break;
|
|
}
|
|
|
|
const entry5 = ModelDefinition_TracksEntry.decode(
|
|
reader,
|
|
reader.uint32(),
|
|
);
|
|
if (entry5.value !== undefined) {
|
|
message.tracks[entry5.key] = entry5.value;
|
|
}
|
|
continue;
|
|
}
|
|
case 6: {
|
|
if (tag !== 50) {
|
|
break;
|
|
}
|
|
|
|
message.bounding_box = BoundingBox.decode(reader, reader.uint32());
|
|
continue;
|
|
}
|
|
}
|
|
if ((tag & 7) === 4 || tag === 0) {
|
|
break;
|
|
}
|
|
reader.skip(tag & 7);
|
|
}
|
|
return message;
|
|
},
|
|
|
|
fromJSON(object: any): ModelDefinition {
|
|
return {
|
|
armor: isSet(object.armor) ? Armor.fromJSON(object.armor) : undefined,
|
|
turret_origin: isSet(object.turretOrigin)
|
|
? Vector3.fromJSON(object.turretOrigin)
|
|
: isSet(object.turret_origin)
|
|
? Vector3.fromJSON(object.turret_origin)
|
|
: undefined,
|
|
initial_turret_rotation: isSet(object.initialTurretRotation)
|
|
? InitialTurretRotation.fromJSON(object.initialTurretRotation)
|
|
: isSet(object.initial_turret_rotation)
|
|
? InitialTurretRotation.fromJSON(object.initial_turret_rotation)
|
|
: undefined,
|
|
turrets: isObject(object.turrets)
|
|
? (globalThis.Object.entries(object.turrets) as [string, any][]).reduce(
|
|
(
|
|
acc: { [key: number]: TurretModelDefinition },
|
|
[key, value]: [string, any],
|
|
) => {
|
|
acc[globalThis.Number(key)] =
|
|
TurretModelDefinition.fromJSON(value);
|
|
return acc;
|
|
},
|
|
{},
|
|
)
|
|
: {},
|
|
tracks: isObject(object.tracks)
|
|
? (globalThis.Object.entries(object.tracks) as [string, any][]).reduce(
|
|
(
|
|
acc: { [key: number]: TrackModelDefinition },
|
|
[key, value]: [string, any],
|
|
) => {
|
|
acc[globalThis.Number(key)] =
|
|
TrackModelDefinition.fromJSON(value);
|
|
return acc;
|
|
},
|
|
{},
|
|
)
|
|
: {},
|
|
bounding_box: isSet(object.boundingBox)
|
|
? BoundingBox.fromJSON(object.boundingBox)
|
|
: isSet(object.bounding_box)
|
|
? BoundingBox.fromJSON(object.bounding_box)
|
|
: undefined,
|
|
};
|
|
},
|
|
|
|
toJSON(message: ModelDefinition): unknown {
|
|
const obj: any = {};
|
|
if (message.armor !== undefined) {
|
|
obj.armor = Armor.toJSON(message.armor);
|
|
}
|
|
if (message.turret_origin !== undefined) {
|
|
obj.turretOrigin = Vector3.toJSON(message.turret_origin);
|
|
}
|
|
if (message.initial_turret_rotation !== undefined) {
|
|
obj.initialTurretRotation = InitialTurretRotation.toJSON(
|
|
message.initial_turret_rotation,
|
|
);
|
|
}
|
|
if (message.turrets) {
|
|
const entries = globalThis.Object.entries(message.turrets) as [
|
|
string,
|
|
TurretModelDefinition,
|
|
][];
|
|
if (entries.length > 0) {
|
|
obj.turrets = {};
|
|
entries.forEach(([k, v]) => {
|
|
obj.turrets[k] = TurretModelDefinition.toJSON(v);
|
|
});
|
|
}
|
|
}
|
|
if (message.tracks) {
|
|
const entries = globalThis.Object.entries(message.tracks) as [
|
|
string,
|
|
TrackModelDefinition,
|
|
][];
|
|
if (entries.length > 0) {
|
|
obj.tracks = {};
|
|
entries.forEach(([k, v]) => {
|
|
obj.tracks[k] = TrackModelDefinition.toJSON(v);
|
|
});
|
|
}
|
|
}
|
|
if (message.bounding_box !== undefined) {
|
|
obj.boundingBox = BoundingBox.toJSON(message.bounding_box);
|
|
}
|
|
return obj;
|
|
},
|
|
|
|
create<I extends Exact<DeepPartial<ModelDefinition>, I>>(
|
|
base?: I,
|
|
): ModelDefinition {
|
|
return ModelDefinition.fromPartial(base ?? ({} as any));
|
|
},
|
|
fromPartial<I extends Exact<DeepPartial<ModelDefinition>, I>>(
|
|
object: I,
|
|
): ModelDefinition {
|
|
const message = createBaseModelDefinition();
|
|
message.armor =
|
|
object.armor !== undefined && object.armor !== null
|
|
? Armor.fromPartial(object.armor)
|
|
: undefined;
|
|
message.turret_origin =
|
|
object.turret_origin !== undefined && object.turret_origin !== null
|
|
? Vector3.fromPartial(object.turret_origin)
|
|
: undefined;
|
|
message.initial_turret_rotation =
|
|
object.initial_turret_rotation !== undefined &&
|
|
object.initial_turret_rotation !== null
|
|
? InitialTurretRotation.fromPartial(object.initial_turret_rotation)
|
|
: undefined;
|
|
message.turrets = (
|
|
globalThis.Object.entries(object.turrets ?? {}) as [
|
|
string,
|
|
TurretModelDefinition,
|
|
][]
|
|
).reduce(
|
|
(
|
|
acc: { [key: number]: TurretModelDefinition },
|
|
[key, value]: [string, TurretModelDefinition],
|
|
) => {
|
|
if (value !== undefined) {
|
|
acc[globalThis.Number(key)] =
|
|
TurretModelDefinition.fromPartial(value);
|
|
}
|
|
return acc;
|
|
},
|
|
{},
|
|
);
|
|
message.tracks = (
|
|
globalThis.Object.entries(object.tracks ?? {}) as [
|
|
string,
|
|
TrackModelDefinition,
|
|
][]
|
|
).reduce(
|
|
(
|
|
acc: { [key: number]: TrackModelDefinition },
|
|
[key, value]: [string, TrackModelDefinition],
|
|
) => {
|
|
if (value !== undefined) {
|
|
acc[globalThis.Number(key)] = TrackModelDefinition.fromPartial(value);
|
|
}
|
|
return acc;
|
|
},
|
|
{},
|
|
);
|
|
message.bounding_box =
|
|
object.bounding_box !== undefined && object.bounding_box !== null
|
|
? BoundingBox.fromPartial(object.bounding_box)
|
|
: undefined;
|
|
return message;
|
|
},
|
|
};
|
|
|
|
function createBaseModelDefinition_TurretsEntry(): ModelDefinition_TurretsEntry {
|
|
return { key: 0, value: undefined };
|
|
}
|
|
|
|
export const ModelDefinition_TurretsEntry: MessageFns<ModelDefinition_TurretsEntry> =
|
|
{
|
|
encode(
|
|
message: ModelDefinition_TurretsEntry,
|
|
writer: BinaryWriter = new BinaryWriter(),
|
|
): BinaryWriter {
|
|
if (message.key !== 0) {
|
|
writer.uint32(8).uint32(message.key);
|
|
}
|
|
if (message.value !== undefined) {
|
|
TurretModelDefinition.encode(
|
|
message.value,
|
|
writer.uint32(18).fork(),
|
|
).join();
|
|
}
|
|
return writer;
|
|
},
|
|
|
|
decode(
|
|
input: BinaryReader | Uint8Array,
|
|
length?: number,
|
|
): ModelDefinition_TurretsEntry {
|
|
const reader =
|
|
input instanceof BinaryReader ? input : new BinaryReader(input);
|
|
const end = length === undefined ? reader.len : reader.pos + length;
|
|
const message = createBaseModelDefinition_TurretsEntry();
|
|
while (reader.pos < end) {
|
|
const tag = reader.uint32();
|
|
switch (tag >>> 3) {
|
|
case 1: {
|
|
if (tag !== 8) {
|
|
break;
|
|
}
|
|
|
|
message.key = reader.uint32();
|
|
continue;
|
|
}
|
|
case 2: {
|
|
if (tag !== 18) {
|
|
break;
|
|
}
|
|
|
|
message.value = TurretModelDefinition.decode(
|
|
reader,
|
|
reader.uint32(),
|
|
);
|
|
continue;
|
|
}
|
|
}
|
|
if ((tag & 7) === 4 || tag === 0) {
|
|
break;
|
|
}
|
|
reader.skip(tag & 7);
|
|
}
|
|
return message;
|
|
},
|
|
|
|
fromJSON(object: any): ModelDefinition_TurretsEntry {
|
|
return {
|
|
key: isSet(object.key) ? globalThis.Number(object.key) : 0,
|
|
value: isSet(object.value)
|
|
? TurretModelDefinition.fromJSON(object.value)
|
|
: undefined,
|
|
};
|
|
},
|
|
|
|
toJSON(message: ModelDefinition_TurretsEntry): unknown {
|
|
const obj: any = {};
|
|
if (message.key !== 0) {
|
|
obj.key = Math.round(message.key);
|
|
}
|
|
if (message.value !== undefined) {
|
|
obj.value = TurretModelDefinition.toJSON(message.value);
|
|
}
|
|
return obj;
|
|
},
|
|
|
|
create<I extends Exact<DeepPartial<ModelDefinition_TurretsEntry>, I>>(
|
|
base?: I,
|
|
): ModelDefinition_TurretsEntry {
|
|
return ModelDefinition_TurretsEntry.fromPartial(base ?? ({} as any));
|
|
},
|
|
fromPartial<I extends Exact<DeepPartial<ModelDefinition_TurretsEntry>, I>>(
|
|
object: I,
|
|
): ModelDefinition_TurretsEntry {
|
|
const message = createBaseModelDefinition_TurretsEntry();
|
|
message.key = object.key ?? 0;
|
|
message.value =
|
|
object.value !== undefined && object.value !== null
|
|
? TurretModelDefinition.fromPartial(object.value)
|
|
: undefined;
|
|
return message;
|
|
},
|
|
};
|
|
|
|
function createBaseModelDefinition_TracksEntry(): ModelDefinition_TracksEntry {
|
|
return { key: 0, value: undefined };
|
|
}
|
|
|
|
export const ModelDefinition_TracksEntry: MessageFns<ModelDefinition_TracksEntry> =
|
|
{
|
|
encode(
|
|
message: ModelDefinition_TracksEntry,
|
|
writer: BinaryWriter = new BinaryWriter(),
|
|
): BinaryWriter {
|
|
if (message.key !== 0) {
|
|
writer.uint32(8).uint32(message.key);
|
|
}
|
|
if (message.value !== undefined) {
|
|
TrackModelDefinition.encode(
|
|
message.value,
|
|
writer.uint32(18).fork(),
|
|
).join();
|
|
}
|
|
return writer;
|
|
},
|
|
|
|
decode(
|
|
input: BinaryReader | Uint8Array,
|
|
length?: number,
|
|
): ModelDefinition_TracksEntry {
|
|
const reader =
|
|
input instanceof BinaryReader ? input : new BinaryReader(input);
|
|
const end = length === undefined ? reader.len : reader.pos + length;
|
|
const message = createBaseModelDefinition_TracksEntry();
|
|
while (reader.pos < end) {
|
|
const tag = reader.uint32();
|
|
switch (tag >>> 3) {
|
|
case 1: {
|
|
if (tag !== 8) {
|
|
break;
|
|
}
|
|
|
|
message.key = reader.uint32();
|
|
continue;
|
|
}
|
|
case 2: {
|
|
if (tag !== 18) {
|
|
break;
|
|
}
|
|
|
|
message.value = TrackModelDefinition.decode(
|
|
reader,
|
|
reader.uint32(),
|
|
);
|
|
continue;
|
|
}
|
|
}
|
|
if ((tag & 7) === 4 || tag === 0) {
|
|
break;
|
|
}
|
|
reader.skip(tag & 7);
|
|
}
|
|
return message;
|
|
},
|
|
|
|
fromJSON(object: any): ModelDefinition_TracksEntry {
|
|
return {
|
|
key: isSet(object.key) ? globalThis.Number(object.key) : 0,
|
|
value: isSet(object.value)
|
|
? TrackModelDefinition.fromJSON(object.value)
|
|
: undefined,
|
|
};
|
|
},
|
|
|
|
toJSON(message: ModelDefinition_TracksEntry): unknown {
|
|
const obj: any = {};
|
|
if (message.key !== 0) {
|
|
obj.key = Math.round(message.key);
|
|
}
|
|
if (message.value !== undefined) {
|
|
obj.value = TrackModelDefinition.toJSON(message.value);
|
|
}
|
|
return obj;
|
|
},
|
|
|
|
create<I extends Exact<DeepPartial<ModelDefinition_TracksEntry>, I>>(
|
|
base?: I,
|
|
): ModelDefinition_TracksEntry {
|
|
return ModelDefinition_TracksEntry.fromPartial(base ?? ({} as any));
|
|
},
|
|
fromPartial<I extends Exact<DeepPartial<ModelDefinition_TracksEntry>, I>>(
|
|
object: I,
|
|
): ModelDefinition_TracksEntry {
|
|
const message = createBaseModelDefinition_TracksEntry();
|
|
message.key = object.key ?? 0;
|
|
message.value =
|
|
object.value !== undefined && object.value !== null
|
|
? TrackModelDefinition.fromPartial(object.value)
|
|
: undefined;
|
|
return message;
|
|
},
|
|
};
|
|
|
|
function createBaseArmor(): Armor {
|
|
return { thickness: {}, spaced: [] };
|
|
}
|
|
|
|
export const Armor: MessageFns<Armor> = {
|
|
encode(
|
|
message: Armor,
|
|
writer: BinaryWriter = new BinaryWriter(),
|
|
): BinaryWriter {
|
|
globalThis.Object.entries(message.thickness).forEach(
|
|
([key, value]: [string, number]) => {
|
|
Armor_ThicknessEntry.encode(
|
|
{ key: key as any, value },
|
|
writer.uint32(10).fork(),
|
|
).join();
|
|
},
|
|
);
|
|
for (const v of message.spaced) {
|
|
writer.uint32(16).uint32(v!);
|
|
}
|
|
return writer;
|
|
},
|
|
|
|
decode(input: BinaryReader | Uint8Array, length?: number): Armor {
|
|
const reader =
|
|
input instanceof BinaryReader ? input : new BinaryReader(input);
|
|
const end = length === undefined ? reader.len : reader.pos + length;
|
|
const message = createBaseArmor();
|
|
while (reader.pos < end) {
|
|
const tag = reader.uint32();
|
|
switch (tag >>> 3) {
|
|
case 1: {
|
|
if (tag !== 10) {
|
|
break;
|
|
}
|
|
|
|
const entry1 = Armor_ThicknessEntry.decode(reader, reader.uint32());
|
|
if (entry1.value !== undefined) {
|
|
message.thickness[entry1.key] = entry1.value;
|
|
}
|
|
continue;
|
|
}
|
|
case 2: {
|
|
if (tag === 16) {
|
|
message.spaced.push(reader.uint32());
|
|
|
|
continue;
|
|
}
|
|
|
|
if (tag === 18) {
|
|
const end2 = reader.uint32() + reader.pos;
|
|
while (reader.pos < end2) {
|
|
message.spaced.push(reader.uint32());
|
|
}
|
|
|
|
continue;
|
|
}
|
|
|
|
break;
|
|
}
|
|
}
|
|
if ((tag & 7) === 4 || tag === 0) {
|
|
break;
|
|
}
|
|
reader.skip(tag & 7);
|
|
}
|
|
return message;
|
|
},
|
|
|
|
fromJSON(object: any): Armor {
|
|
return {
|
|
thickness: isObject(object.thickness)
|
|
? (
|
|
globalThis.Object.entries(object.thickness) as [string, any][]
|
|
).reduce(
|
|
(acc: { [key: number]: number }, [key, value]: [string, any]) => {
|
|
acc[globalThis.Number(key)] = globalThis.Number(value);
|
|
return acc;
|
|
},
|
|
{},
|
|
)
|
|
: {},
|
|
spaced: globalThis.Array.isArray(object?.spaced)
|
|
? object.spaced.map((e: any) => globalThis.Number(e))
|
|
: [],
|
|
};
|
|
},
|
|
|
|
toJSON(message: Armor): unknown {
|
|
const obj: any = {};
|
|
if (message.thickness) {
|
|
const entries = globalThis.Object.entries(message.thickness) as [
|
|
string,
|
|
number,
|
|
][];
|
|
if (entries.length > 0) {
|
|
obj.thickness = {};
|
|
entries.forEach(([k, v]) => {
|
|
obj.thickness[k] = v;
|
|
});
|
|
}
|
|
}
|
|
if (message.spaced?.length) {
|
|
obj.spaced = message.spaced.map((e) => Math.round(e));
|
|
}
|
|
return obj;
|
|
},
|
|
|
|
create<I extends Exact<DeepPartial<Armor>, I>>(base?: I): Armor {
|
|
return Armor.fromPartial(base ?? ({} as any));
|
|
},
|
|
fromPartial<I extends Exact<DeepPartial<Armor>, I>>(object: I): Armor {
|
|
const message = createBaseArmor();
|
|
message.thickness = (
|
|
globalThis.Object.entries(object.thickness ?? {}) as [string, number][]
|
|
).reduce(
|
|
(acc: { [key: number]: number }, [key, value]: [string, number]) => {
|
|
if (value !== undefined) {
|
|
acc[globalThis.Number(key)] = globalThis.Number(value);
|
|
}
|
|
return acc;
|
|
},
|
|
{},
|
|
);
|
|
message.spaced = object.spaced?.map((e) => e) || [];
|
|
return message;
|
|
},
|
|
};
|
|
|
|
function createBaseArmor_ThicknessEntry(): Armor_ThicknessEntry {
|
|
return { key: 0, value: 0 };
|
|
}
|
|
|
|
export const Armor_ThicknessEntry: MessageFns<Armor_ThicknessEntry> = {
|
|
encode(
|
|
message: Armor_ThicknessEntry,
|
|
writer: BinaryWriter = new BinaryWriter(),
|
|
): BinaryWriter {
|
|
if (message.key !== 0) {
|
|
writer.uint32(8).uint32(message.key);
|
|
}
|
|
if (message.value !== 0) {
|
|
writer.uint32(21).float(message.value);
|
|
}
|
|
return writer;
|
|
},
|
|
|
|
decode(
|
|
input: BinaryReader | Uint8Array,
|
|
length?: number,
|
|
): Armor_ThicknessEntry {
|
|
const reader =
|
|
input instanceof BinaryReader ? input : new BinaryReader(input);
|
|
const end = length === undefined ? reader.len : reader.pos + length;
|
|
const message = createBaseArmor_ThicknessEntry();
|
|
while (reader.pos < end) {
|
|
const tag = reader.uint32();
|
|
switch (tag >>> 3) {
|
|
case 1: {
|
|
if (tag !== 8) {
|
|
break;
|
|
}
|
|
|
|
message.key = reader.uint32();
|
|
continue;
|
|
}
|
|
case 2: {
|
|
if (tag !== 21) {
|
|
break;
|
|
}
|
|
|
|
message.value = reader.float();
|
|
continue;
|
|
}
|
|
}
|
|
if ((tag & 7) === 4 || tag === 0) {
|
|
break;
|
|
}
|
|
reader.skip(tag & 7);
|
|
}
|
|
return message;
|
|
},
|
|
|
|
fromJSON(object: any): Armor_ThicknessEntry {
|
|
return {
|
|
key: isSet(object.key) ? globalThis.Number(object.key) : 0,
|
|
value: isSet(object.value) ? globalThis.Number(object.value) : 0,
|
|
};
|
|
},
|
|
|
|
toJSON(message: Armor_ThicknessEntry): unknown {
|
|
const obj: any = {};
|
|
if (message.key !== 0) {
|
|
obj.key = Math.round(message.key);
|
|
}
|
|
if (message.value !== 0) {
|
|
obj.value = message.value;
|
|
}
|
|
return obj;
|
|
},
|
|
|
|
create<I extends Exact<DeepPartial<Armor_ThicknessEntry>, I>>(
|
|
base?: I,
|
|
): Armor_ThicknessEntry {
|
|
return Armor_ThicknessEntry.fromPartial(base ?? ({} as any));
|
|
},
|
|
fromPartial<I extends Exact<DeepPartial<Armor_ThicknessEntry>, I>>(
|
|
object: I,
|
|
): Armor_ThicknessEntry {
|
|
const message = createBaseArmor_ThicknessEntry();
|
|
message.key = object.key ?? 0;
|
|
message.value = object.value ?? 0;
|
|
return message;
|
|
},
|
|
};
|
|
|
|
function createBaseVector3(): Vector3 {
|
|
return { x: 0, y: 0, z: 0 };
|
|
}
|
|
|
|
export const Vector3: MessageFns<Vector3> = {
|
|
encode(
|
|
message: Vector3,
|
|
writer: BinaryWriter = new BinaryWriter(),
|
|
): BinaryWriter {
|
|
if (message.x !== 0) {
|
|
writer.uint32(13).float(message.x);
|
|
}
|
|
if (message.y !== 0) {
|
|
writer.uint32(21).float(message.y);
|
|
}
|
|
if (message.z !== 0) {
|
|
writer.uint32(29).float(message.z);
|
|
}
|
|
return writer;
|
|
},
|
|
|
|
decode(input: BinaryReader | Uint8Array, length?: number): Vector3 {
|
|
const reader =
|
|
input instanceof BinaryReader ? input : new BinaryReader(input);
|
|
const end = length === undefined ? reader.len : reader.pos + length;
|
|
const message = createBaseVector3();
|
|
while (reader.pos < end) {
|
|
const tag = reader.uint32();
|
|
switch (tag >>> 3) {
|
|
case 1: {
|
|
if (tag !== 13) {
|
|
break;
|
|
}
|
|
|
|
message.x = reader.float();
|
|
continue;
|
|
}
|
|
case 2: {
|
|
if (tag !== 21) {
|
|
break;
|
|
}
|
|
|
|
message.y = reader.float();
|
|
continue;
|
|
}
|
|
case 3: {
|
|
if (tag !== 29) {
|
|
break;
|
|
}
|
|
|
|
message.z = reader.float();
|
|
continue;
|
|
}
|
|
}
|
|
if ((tag & 7) === 4 || tag === 0) {
|
|
break;
|
|
}
|
|
reader.skip(tag & 7);
|
|
}
|
|
return message;
|
|
},
|
|
|
|
fromJSON(object: any): Vector3 {
|
|
return {
|
|
x: isSet(object.x) ? globalThis.Number(object.x) : 0,
|
|
y: isSet(object.y) ? globalThis.Number(object.y) : 0,
|
|
z: isSet(object.z) ? globalThis.Number(object.z) : 0,
|
|
};
|
|
},
|
|
|
|
toJSON(message: Vector3): unknown {
|
|
const obj: any = {};
|
|
if (message.x !== 0) {
|
|
obj.x = message.x;
|
|
}
|
|
if (message.y !== 0) {
|
|
obj.y = message.y;
|
|
}
|
|
if (message.z !== 0) {
|
|
obj.z = message.z;
|
|
}
|
|
return obj;
|
|
},
|
|
|
|
create<I extends Exact<DeepPartial<Vector3>, I>>(base?: I): Vector3 {
|
|
return Vector3.fromPartial(base ?? ({} as any));
|
|
},
|
|
fromPartial<I extends Exact<DeepPartial<Vector3>, I>>(object: I): Vector3 {
|
|
const message = createBaseVector3();
|
|
message.x = object.x ?? 0;
|
|
message.y = object.y ?? 0;
|
|
message.z = object.z ?? 0;
|
|
return message;
|
|
},
|
|
};
|
|
|
|
function createBaseInitialTurretRotation(): InitialTurretRotation {
|
|
return { yaw: 0, pitch: 0, roll: 0 };
|
|
}
|
|
|
|
export const InitialTurretRotation: MessageFns<InitialTurretRotation> = {
|
|
encode(
|
|
message: InitialTurretRotation,
|
|
writer: BinaryWriter = new BinaryWriter(),
|
|
): BinaryWriter {
|
|
if (message.yaw !== 0) {
|
|
writer.uint32(13).float(message.yaw);
|
|
}
|
|
if (message.pitch !== 0) {
|
|
writer.uint32(21).float(message.pitch);
|
|
}
|
|
if (message.roll !== 0) {
|
|
writer.uint32(29).float(message.roll);
|
|
}
|
|
return writer;
|
|
},
|
|
|
|
decode(
|
|
input: BinaryReader | Uint8Array,
|
|
length?: number,
|
|
): InitialTurretRotation {
|
|
const reader =
|
|
input instanceof BinaryReader ? input : new BinaryReader(input);
|
|
const end = length === undefined ? reader.len : reader.pos + length;
|
|
const message = createBaseInitialTurretRotation();
|
|
while (reader.pos < end) {
|
|
const tag = reader.uint32();
|
|
switch (tag >>> 3) {
|
|
case 1: {
|
|
if (tag !== 13) {
|
|
break;
|
|
}
|
|
|
|
message.yaw = reader.float();
|
|
continue;
|
|
}
|
|
case 2: {
|
|
if (tag !== 21) {
|
|
break;
|
|
}
|
|
|
|
message.pitch = reader.float();
|
|
continue;
|
|
}
|
|
case 3: {
|
|
if (tag !== 29) {
|
|
break;
|
|
}
|
|
|
|
message.roll = reader.float();
|
|
continue;
|
|
}
|
|
}
|
|
if ((tag & 7) === 4 || tag === 0) {
|
|
break;
|
|
}
|
|
reader.skip(tag & 7);
|
|
}
|
|
return message;
|
|
},
|
|
|
|
fromJSON(object: any): InitialTurretRotation {
|
|
return {
|
|
yaw: isSet(object.yaw) ? globalThis.Number(object.yaw) : 0,
|
|
pitch: isSet(object.pitch) ? globalThis.Number(object.pitch) : 0,
|
|
roll: isSet(object.roll) ? globalThis.Number(object.roll) : 0,
|
|
};
|
|
},
|
|
|
|
toJSON(message: InitialTurretRotation): unknown {
|
|
const obj: any = {};
|
|
if (message.yaw !== 0) {
|
|
obj.yaw = message.yaw;
|
|
}
|
|
if (message.pitch !== 0) {
|
|
obj.pitch = message.pitch;
|
|
}
|
|
if (message.roll !== 0) {
|
|
obj.roll = message.roll;
|
|
}
|
|
return obj;
|
|
},
|
|
|
|
create<I extends Exact<DeepPartial<InitialTurretRotation>, I>>(
|
|
base?: I,
|
|
): InitialTurretRotation {
|
|
return InitialTurretRotation.fromPartial(base ?? ({} as any));
|
|
},
|
|
fromPartial<I extends Exact<DeepPartial<InitialTurretRotation>, I>>(
|
|
object: I,
|
|
): InitialTurretRotation {
|
|
const message = createBaseInitialTurretRotation();
|
|
message.yaw = object.yaw ?? 0;
|
|
message.pitch = object.pitch ?? 0;
|
|
message.roll = object.roll ?? 0;
|
|
return message;
|
|
},
|
|
};
|
|
|
|
function createBaseTurretModelDefinition(): TurretModelDefinition {
|
|
return {
|
|
bounding_box: undefined,
|
|
armor: undefined,
|
|
model_id: 0,
|
|
gun_origin: undefined,
|
|
guns: {},
|
|
yaw: undefined,
|
|
};
|
|
}
|
|
|
|
export const TurretModelDefinition: MessageFns<TurretModelDefinition> = {
|
|
encode(
|
|
message: TurretModelDefinition,
|
|
writer: BinaryWriter = new BinaryWriter(),
|
|
): BinaryWriter {
|
|
if (message.bounding_box !== undefined) {
|
|
BoundingBox.encode(
|
|
message.bounding_box!,
|
|
writer.uint32(10).fork(),
|
|
).join();
|
|
}
|
|
if (message.armor !== undefined) {
|
|
Armor.encode(message.armor, writer.uint32(18).fork()).join();
|
|
}
|
|
if (message.model_id !== 0) {
|
|
writer.uint32(24).uint32(message.model_id);
|
|
}
|
|
if (message.gun_origin !== undefined) {
|
|
Vector3.encode(message.gun_origin, writer.uint32(34).fork()).join();
|
|
}
|
|
globalThis.Object.entries(message.guns).forEach(
|
|
([key, value]: [string, GunModelDefinition]) => {
|
|
TurretModelDefinition_GunsEntry.encode(
|
|
{ key: key as any, value },
|
|
writer.uint32(42).fork(),
|
|
).join();
|
|
},
|
|
);
|
|
if (message.yaw !== undefined) {
|
|
YawLimits.encode(message.yaw, writer.uint32(50).fork()).join();
|
|
}
|
|
return writer;
|
|
},
|
|
|
|
decode(
|
|
input: BinaryReader | Uint8Array,
|
|
length?: number,
|
|
): TurretModelDefinition {
|
|
const reader =
|
|
input instanceof BinaryReader ? input : new BinaryReader(input);
|
|
const end = length === undefined ? reader.len : reader.pos + length;
|
|
const message = createBaseTurretModelDefinition();
|
|
while (reader.pos < end) {
|
|
const tag = reader.uint32();
|
|
switch (tag >>> 3) {
|
|
case 1: {
|
|
if (tag !== 10) {
|
|
break;
|
|
}
|
|
|
|
message.bounding_box = BoundingBox.decode(reader, reader.uint32());
|
|
continue;
|
|
}
|
|
case 2: {
|
|
if (tag !== 18) {
|
|
break;
|
|
}
|
|
|
|
message.armor = Armor.decode(reader, reader.uint32());
|
|
continue;
|
|
}
|
|
case 3: {
|
|
if (tag !== 24) {
|
|
break;
|
|
}
|
|
|
|
message.model_id = reader.uint32();
|
|
continue;
|
|
}
|
|
case 4: {
|
|
if (tag !== 34) {
|
|
break;
|
|
}
|
|
|
|
message.gun_origin = Vector3.decode(reader, reader.uint32());
|
|
continue;
|
|
}
|
|
case 5: {
|
|
if (tag !== 42) {
|
|
break;
|
|
}
|
|
|
|
const entry5 = TurretModelDefinition_GunsEntry.decode(
|
|
reader,
|
|
reader.uint32(),
|
|
);
|
|
if (entry5.value !== undefined) {
|
|
message.guns[entry5.key] = entry5.value;
|
|
}
|
|
continue;
|
|
}
|
|
case 6: {
|
|
if (tag !== 50) {
|
|
break;
|
|
}
|
|
|
|
message.yaw = YawLimits.decode(reader, reader.uint32());
|
|
continue;
|
|
}
|
|
}
|
|
if ((tag & 7) === 4 || tag === 0) {
|
|
break;
|
|
}
|
|
reader.skip(tag & 7);
|
|
}
|
|
return message;
|
|
},
|
|
|
|
fromJSON(object: any): TurretModelDefinition {
|
|
return {
|
|
bounding_box: isSet(object.boundingBox)
|
|
? BoundingBox.fromJSON(object.boundingBox)
|
|
: isSet(object.bounding_box)
|
|
? BoundingBox.fromJSON(object.bounding_box)
|
|
: undefined,
|
|
armor: isSet(object.armor) ? Armor.fromJSON(object.armor) : undefined,
|
|
model_id: isSet(object.modelId)
|
|
? globalThis.Number(object.modelId)
|
|
: isSet(object.model_id)
|
|
? globalThis.Number(object.model_id)
|
|
: 0,
|
|
gun_origin: isSet(object.gunOrigin)
|
|
? Vector3.fromJSON(object.gunOrigin)
|
|
: isSet(object.gun_origin)
|
|
? Vector3.fromJSON(object.gun_origin)
|
|
: undefined,
|
|
guns: isObject(object.guns)
|
|
? (globalThis.Object.entries(object.guns) as [string, any][]).reduce(
|
|
(
|
|
acc: { [key: number]: GunModelDefinition },
|
|
[key, value]: [string, any],
|
|
) => {
|
|
acc[globalThis.Number(key)] = GunModelDefinition.fromJSON(value);
|
|
return acc;
|
|
},
|
|
{},
|
|
)
|
|
: {},
|
|
yaw: isSet(object.yaw) ? YawLimits.fromJSON(object.yaw) : undefined,
|
|
};
|
|
},
|
|
|
|
toJSON(message: TurretModelDefinition): unknown {
|
|
const obj: any = {};
|
|
if (message.bounding_box !== undefined) {
|
|
obj.boundingBox = BoundingBox.toJSON(message.bounding_box);
|
|
}
|
|
if (message.armor !== undefined) {
|
|
obj.armor = Armor.toJSON(message.armor);
|
|
}
|
|
if (message.model_id !== 0) {
|
|
obj.modelId = Math.round(message.model_id);
|
|
}
|
|
if (message.gun_origin !== undefined) {
|
|
obj.gunOrigin = Vector3.toJSON(message.gun_origin);
|
|
}
|
|
if (message.guns) {
|
|
const entries = globalThis.Object.entries(message.guns) as [
|
|
string,
|
|
GunModelDefinition,
|
|
][];
|
|
if (entries.length > 0) {
|
|
obj.guns = {};
|
|
entries.forEach(([k, v]) => {
|
|
obj.guns[k] = GunModelDefinition.toJSON(v);
|
|
});
|
|
}
|
|
}
|
|
if (message.yaw !== undefined) {
|
|
obj.yaw = YawLimits.toJSON(message.yaw);
|
|
}
|
|
return obj;
|
|
},
|
|
|
|
create<I extends Exact<DeepPartial<TurretModelDefinition>, I>>(
|
|
base?: I,
|
|
): TurretModelDefinition {
|
|
return TurretModelDefinition.fromPartial(base ?? ({} as any));
|
|
},
|
|
fromPartial<I extends Exact<DeepPartial<TurretModelDefinition>, I>>(
|
|
object: I,
|
|
): TurretModelDefinition {
|
|
const message = createBaseTurretModelDefinition();
|
|
message.bounding_box =
|
|
object.bounding_box !== undefined && object.bounding_box !== null
|
|
? BoundingBox.fromPartial(object.bounding_box)
|
|
: undefined;
|
|
message.armor =
|
|
object.armor !== undefined && object.armor !== null
|
|
? Armor.fromPartial(object.armor)
|
|
: undefined;
|
|
message.model_id = object.model_id ?? 0;
|
|
message.gun_origin =
|
|
object.gun_origin !== undefined && object.gun_origin !== null
|
|
? Vector3.fromPartial(object.gun_origin)
|
|
: undefined;
|
|
message.guns = (
|
|
globalThis.Object.entries(object.guns ?? {}) as [
|
|
string,
|
|
GunModelDefinition,
|
|
][]
|
|
).reduce(
|
|
(
|
|
acc: { [key: number]: GunModelDefinition },
|
|
[key, value]: [string, GunModelDefinition],
|
|
) => {
|
|
if (value !== undefined) {
|
|
acc[globalThis.Number(key)] = GunModelDefinition.fromPartial(value);
|
|
}
|
|
return acc;
|
|
},
|
|
{},
|
|
);
|
|
message.yaw =
|
|
object.yaw !== undefined && object.yaw !== null
|
|
? YawLimits.fromPartial(object.yaw)
|
|
: undefined;
|
|
return message;
|
|
},
|
|
};
|
|
|
|
function createBaseTurretModelDefinition_GunsEntry(): TurretModelDefinition_GunsEntry {
|
|
return { key: 0, value: undefined };
|
|
}
|
|
|
|
export const TurretModelDefinition_GunsEntry: MessageFns<TurretModelDefinition_GunsEntry> =
|
|
{
|
|
encode(
|
|
message: TurretModelDefinition_GunsEntry,
|
|
writer: BinaryWriter = new BinaryWriter(),
|
|
): BinaryWriter {
|
|
if (message.key !== 0) {
|
|
writer.uint32(8).uint32(message.key);
|
|
}
|
|
if (message.value !== undefined) {
|
|
GunModelDefinition.encode(
|
|
message.value,
|
|
writer.uint32(18).fork(),
|
|
).join();
|
|
}
|
|
return writer;
|
|
},
|
|
|
|
decode(
|
|
input: BinaryReader | Uint8Array,
|
|
length?: number,
|
|
): TurretModelDefinition_GunsEntry {
|
|
const reader =
|
|
input instanceof BinaryReader ? input : new BinaryReader(input);
|
|
const end = length === undefined ? reader.len : reader.pos + length;
|
|
const message = createBaseTurretModelDefinition_GunsEntry();
|
|
while (reader.pos < end) {
|
|
const tag = reader.uint32();
|
|
switch (tag >>> 3) {
|
|
case 1: {
|
|
if (tag !== 8) {
|
|
break;
|
|
}
|
|
|
|
message.key = reader.uint32();
|
|
continue;
|
|
}
|
|
case 2: {
|
|
if (tag !== 18) {
|
|
break;
|
|
}
|
|
|
|
message.value = GunModelDefinition.decode(reader, reader.uint32());
|
|
continue;
|
|
}
|
|
}
|
|
if ((tag & 7) === 4 || tag === 0) {
|
|
break;
|
|
}
|
|
reader.skip(tag & 7);
|
|
}
|
|
return message;
|
|
},
|
|
|
|
fromJSON(object: any): TurretModelDefinition_GunsEntry {
|
|
return {
|
|
key: isSet(object.key) ? globalThis.Number(object.key) : 0,
|
|
value: isSet(object.value)
|
|
? GunModelDefinition.fromJSON(object.value)
|
|
: undefined,
|
|
};
|
|
},
|
|
|
|
toJSON(message: TurretModelDefinition_GunsEntry): unknown {
|
|
const obj: any = {};
|
|
if (message.key !== 0) {
|
|
obj.key = Math.round(message.key);
|
|
}
|
|
if (message.value !== undefined) {
|
|
obj.value = GunModelDefinition.toJSON(message.value);
|
|
}
|
|
return obj;
|
|
},
|
|
|
|
create<I extends Exact<DeepPartial<TurretModelDefinition_GunsEntry>, I>>(
|
|
base?: I,
|
|
): TurretModelDefinition_GunsEntry {
|
|
return TurretModelDefinition_GunsEntry.fromPartial(base ?? ({} as any));
|
|
},
|
|
fromPartial<
|
|
I extends Exact<DeepPartial<TurretModelDefinition_GunsEntry>, I>,
|
|
>(object: I): TurretModelDefinition_GunsEntry {
|
|
const message = createBaseTurretModelDefinition_GunsEntry();
|
|
message.key = object.key ?? 0;
|
|
message.value =
|
|
object.value !== undefined && object.value !== null
|
|
? GunModelDefinition.fromPartial(object.value)
|
|
: undefined;
|
|
return message;
|
|
},
|
|
};
|
|
|
|
function createBaseYawLimits(): YawLimits {
|
|
return { min: 0, max: 0 };
|
|
}
|
|
|
|
export const YawLimits: MessageFns<YawLimits> = {
|
|
encode(
|
|
message: YawLimits,
|
|
writer: BinaryWriter = new BinaryWriter(),
|
|
): BinaryWriter {
|
|
if (message.min !== 0) {
|
|
writer.uint32(13).float(message.min);
|
|
}
|
|
if (message.max !== 0) {
|
|
writer.uint32(21).float(message.max);
|
|
}
|
|
return writer;
|
|
},
|
|
|
|
decode(input: BinaryReader | Uint8Array, length?: number): YawLimits {
|
|
const reader =
|
|
input instanceof BinaryReader ? input : new BinaryReader(input);
|
|
const end = length === undefined ? reader.len : reader.pos + length;
|
|
const message = createBaseYawLimits();
|
|
while (reader.pos < end) {
|
|
const tag = reader.uint32();
|
|
switch (tag >>> 3) {
|
|
case 1: {
|
|
if (tag !== 13) {
|
|
break;
|
|
}
|
|
|
|
message.min = reader.float();
|
|
continue;
|
|
}
|
|
case 2: {
|
|
if (tag !== 21) {
|
|
break;
|
|
}
|
|
|
|
message.max = reader.float();
|
|
continue;
|
|
}
|
|
}
|
|
if ((tag & 7) === 4 || tag === 0) {
|
|
break;
|
|
}
|
|
reader.skip(tag & 7);
|
|
}
|
|
return message;
|
|
},
|
|
|
|
fromJSON(object: any): YawLimits {
|
|
return {
|
|
min: isSet(object.min) ? globalThis.Number(object.min) : 0,
|
|
max: isSet(object.max) ? globalThis.Number(object.max) : 0,
|
|
};
|
|
},
|
|
|
|
toJSON(message: YawLimits): unknown {
|
|
const obj: any = {};
|
|
if (message.min !== 0) {
|
|
obj.min = message.min;
|
|
}
|
|
if (message.max !== 0) {
|
|
obj.max = message.max;
|
|
}
|
|
return obj;
|
|
},
|
|
|
|
create<I extends Exact<DeepPartial<YawLimits>, I>>(base?: I): YawLimits {
|
|
return YawLimits.fromPartial(base ?? ({} as any));
|
|
},
|
|
fromPartial<I extends Exact<DeepPartial<YawLimits>, I>>(
|
|
object: I,
|
|
): YawLimits {
|
|
const message = createBaseYawLimits();
|
|
message.min = object.min ?? 0;
|
|
message.max = object.max ?? 0;
|
|
return message;
|
|
},
|
|
};
|
|
|
|
function createBaseBoundingBox(): BoundingBox {
|
|
return { min: undefined, max: undefined };
|
|
}
|
|
|
|
export const BoundingBox: MessageFns<BoundingBox> = {
|
|
encode(
|
|
message: BoundingBox,
|
|
writer: BinaryWriter = new BinaryWriter(),
|
|
): BinaryWriter {
|
|
if (message.min !== undefined) {
|
|
Vector3.encode(message.min, writer.uint32(10).fork()).join();
|
|
}
|
|
if (message.max !== undefined) {
|
|
Vector3.encode(message.max, writer.uint32(18).fork()).join();
|
|
}
|
|
return writer;
|
|
},
|
|
|
|
decode(input: BinaryReader | Uint8Array, length?: number): BoundingBox {
|
|
const reader =
|
|
input instanceof BinaryReader ? input : new BinaryReader(input);
|
|
const end = length === undefined ? reader.len : reader.pos + length;
|
|
const message = createBaseBoundingBox();
|
|
while (reader.pos < end) {
|
|
const tag = reader.uint32();
|
|
switch (tag >>> 3) {
|
|
case 1: {
|
|
if (tag !== 10) {
|
|
break;
|
|
}
|
|
|
|
message.min = Vector3.decode(reader, reader.uint32());
|
|
continue;
|
|
}
|
|
case 2: {
|
|
if (tag !== 18) {
|
|
break;
|
|
}
|
|
|
|
message.max = Vector3.decode(reader, reader.uint32());
|
|
continue;
|
|
}
|
|
}
|
|
if ((tag & 7) === 4 || tag === 0) {
|
|
break;
|
|
}
|
|
reader.skip(tag & 7);
|
|
}
|
|
return message;
|
|
},
|
|
|
|
fromJSON(object: any): BoundingBox {
|
|
return {
|
|
min: isSet(object.min) ? Vector3.fromJSON(object.min) : undefined,
|
|
max: isSet(object.max) ? Vector3.fromJSON(object.max) : undefined,
|
|
};
|
|
},
|
|
|
|
toJSON(message: BoundingBox): unknown {
|
|
const obj: any = {};
|
|
if (message.min !== undefined) {
|
|
obj.min = Vector3.toJSON(message.min);
|
|
}
|
|
if (message.max !== undefined) {
|
|
obj.max = Vector3.toJSON(message.max);
|
|
}
|
|
return obj;
|
|
},
|
|
|
|
create<I extends Exact<DeepPartial<BoundingBox>, I>>(base?: I): BoundingBox {
|
|
return BoundingBox.fromPartial(base ?? ({} as any));
|
|
},
|
|
fromPartial<I extends Exact<DeepPartial<BoundingBox>, I>>(
|
|
object: I,
|
|
): BoundingBox {
|
|
const message = createBaseBoundingBox();
|
|
message.min =
|
|
object.min !== undefined && object.min !== null
|
|
? Vector3.fromPartial(object.min)
|
|
: undefined;
|
|
message.max =
|
|
object.max !== undefined && object.max !== null
|
|
? Vector3.fromPartial(object.max)
|
|
: undefined;
|
|
return message;
|
|
},
|
|
};
|
|
|
|
function createBaseTrackModelDefinition(): TrackModelDefinition {
|
|
return { thickness: 0, origin: undefined };
|
|
}
|
|
|
|
export const TrackModelDefinition: MessageFns<TrackModelDefinition> = {
|
|
encode(
|
|
message: TrackModelDefinition,
|
|
writer: BinaryWriter = new BinaryWriter(),
|
|
): BinaryWriter {
|
|
if (message.thickness !== 0) {
|
|
writer.uint32(13).float(message.thickness);
|
|
}
|
|
if (message.origin !== undefined) {
|
|
Vector3.encode(message.origin, writer.uint32(18).fork()).join();
|
|
}
|
|
return writer;
|
|
},
|
|
|
|
decode(
|
|
input: BinaryReader | Uint8Array,
|
|
length?: number,
|
|
): TrackModelDefinition {
|
|
const reader =
|
|
input instanceof BinaryReader ? input : new BinaryReader(input);
|
|
const end = length === undefined ? reader.len : reader.pos + length;
|
|
const message = createBaseTrackModelDefinition();
|
|
while (reader.pos < end) {
|
|
const tag = reader.uint32();
|
|
switch (tag >>> 3) {
|
|
case 1: {
|
|
if (tag !== 13) {
|
|
break;
|
|
}
|
|
|
|
message.thickness = reader.float();
|
|
continue;
|
|
}
|
|
case 2: {
|
|
if (tag !== 18) {
|
|
break;
|
|
}
|
|
|
|
message.origin = Vector3.decode(reader, reader.uint32());
|
|
continue;
|
|
}
|
|
}
|
|
if ((tag & 7) === 4 || tag === 0) {
|
|
break;
|
|
}
|
|
reader.skip(tag & 7);
|
|
}
|
|
return message;
|
|
},
|
|
|
|
fromJSON(object: any): TrackModelDefinition {
|
|
return {
|
|
thickness: isSet(object.thickness)
|
|
? globalThis.Number(object.thickness)
|
|
: 0,
|
|
origin: isSet(object.origin)
|
|
? Vector3.fromJSON(object.origin)
|
|
: undefined,
|
|
};
|
|
},
|
|
|
|
toJSON(message: TrackModelDefinition): unknown {
|
|
const obj: any = {};
|
|
if (message.thickness !== 0) {
|
|
obj.thickness = message.thickness;
|
|
}
|
|
if (message.origin !== undefined) {
|
|
obj.origin = Vector3.toJSON(message.origin);
|
|
}
|
|
return obj;
|
|
},
|
|
|
|
create<I extends Exact<DeepPartial<TrackModelDefinition>, I>>(
|
|
base?: I,
|
|
): TrackModelDefinition {
|
|
return TrackModelDefinition.fromPartial(base ?? ({} as any));
|
|
},
|
|
fromPartial<I extends Exact<DeepPartial<TrackModelDefinition>, I>>(
|
|
object: I,
|
|
): TrackModelDefinition {
|
|
const message = createBaseTrackModelDefinition();
|
|
message.thickness = object.thickness ?? 0;
|
|
message.origin =
|
|
object.origin !== undefined && object.origin !== null
|
|
? Vector3.fromPartial(object.origin)
|
|
: undefined;
|
|
return message;
|
|
},
|
|
};
|
|
|
|
function createBaseGunModelDefinition(): GunModelDefinition {
|
|
return {
|
|
armor: undefined,
|
|
thickness: 0,
|
|
model_id: 0,
|
|
pitch: undefined,
|
|
mask: 0,
|
|
};
|
|
}
|
|
|
|
export const GunModelDefinition: MessageFns<GunModelDefinition> = {
|
|
encode(
|
|
message: GunModelDefinition,
|
|
writer: BinaryWriter = new BinaryWriter(),
|
|
): BinaryWriter {
|
|
if (message.armor !== undefined) {
|
|
Armor.encode(message.armor, writer.uint32(10).fork()).join();
|
|
}
|
|
if (message.thickness !== 0) {
|
|
writer.uint32(21).float(message.thickness);
|
|
}
|
|
if (message.model_id !== 0) {
|
|
writer.uint32(24).uint32(message.model_id);
|
|
}
|
|
if (message.pitch !== undefined) {
|
|
PitchLimits.encode(message.pitch, writer.uint32(34).fork()).join();
|
|
}
|
|
if (message.mask !== undefined && message.mask !== 0) {
|
|
writer.uint32(45).float(message.mask);
|
|
}
|
|
return writer;
|
|
},
|
|
|
|
decode(
|
|
input: BinaryReader | Uint8Array,
|
|
length?: number,
|
|
): GunModelDefinition {
|
|
const reader =
|
|
input instanceof BinaryReader ? input : new BinaryReader(input);
|
|
const end = length === undefined ? reader.len : reader.pos + length;
|
|
const message = createBaseGunModelDefinition();
|
|
while (reader.pos < end) {
|
|
const tag = reader.uint32();
|
|
switch (tag >>> 3) {
|
|
case 1: {
|
|
if (tag !== 10) {
|
|
break;
|
|
}
|
|
|
|
message.armor = Armor.decode(reader, reader.uint32());
|
|
continue;
|
|
}
|
|
case 2: {
|
|
if (tag !== 21) {
|
|
break;
|
|
}
|
|
|
|
message.thickness = reader.float();
|
|
continue;
|
|
}
|
|
case 3: {
|
|
if (tag !== 24) {
|
|
break;
|
|
}
|
|
|
|
message.model_id = reader.uint32();
|
|
continue;
|
|
}
|
|
case 4: {
|
|
if (tag !== 34) {
|
|
break;
|
|
}
|
|
|
|
message.pitch = PitchLimits.decode(reader, reader.uint32());
|
|
continue;
|
|
}
|
|
case 5: {
|
|
if (tag !== 45) {
|
|
break;
|
|
}
|
|
|
|
message.mask = reader.float();
|
|
continue;
|
|
}
|
|
}
|
|
if ((tag & 7) === 4 || tag === 0) {
|
|
break;
|
|
}
|
|
reader.skip(tag & 7);
|
|
}
|
|
return message;
|
|
},
|
|
|
|
fromJSON(object: any): GunModelDefinition {
|
|
return {
|
|
armor: isSet(object.armor) ? Armor.fromJSON(object.armor) : undefined,
|
|
thickness: isSet(object.thickness)
|
|
? globalThis.Number(object.thickness)
|
|
: 0,
|
|
model_id: isSet(object.modelId)
|
|
? globalThis.Number(object.modelId)
|
|
: isSet(object.model_id)
|
|
? globalThis.Number(object.model_id)
|
|
: 0,
|
|
pitch: isSet(object.pitch)
|
|
? PitchLimits.fromJSON(object.pitch)
|
|
: undefined,
|
|
mask: isSet(object.mask) ? globalThis.Number(object.mask) : 0,
|
|
};
|
|
},
|
|
|
|
toJSON(message: GunModelDefinition): unknown {
|
|
const obj: any = {};
|
|
if (message.armor !== undefined) {
|
|
obj.armor = Armor.toJSON(message.armor);
|
|
}
|
|
if (message.thickness !== 0) {
|
|
obj.thickness = message.thickness;
|
|
}
|
|
if (message.model_id !== 0) {
|
|
obj.modelId = Math.round(message.model_id);
|
|
}
|
|
if (message.pitch !== undefined) {
|
|
obj.pitch = PitchLimits.toJSON(message.pitch);
|
|
}
|
|
if (message.mask !== undefined && message.mask !== 0) {
|
|
obj.mask = message.mask;
|
|
}
|
|
return obj;
|
|
},
|
|
|
|
create<I extends Exact<DeepPartial<GunModelDefinition>, I>>(
|
|
base?: I,
|
|
): GunModelDefinition {
|
|
return GunModelDefinition.fromPartial(base ?? ({} as any));
|
|
},
|
|
fromPartial<I extends Exact<DeepPartial<GunModelDefinition>, I>>(
|
|
object: I,
|
|
): GunModelDefinition {
|
|
const message = createBaseGunModelDefinition();
|
|
message.armor =
|
|
object.armor !== undefined && object.armor !== null
|
|
? Armor.fromPartial(object.armor)
|
|
: undefined;
|
|
message.thickness = object.thickness ?? 0;
|
|
message.model_id = object.model_id ?? 0;
|
|
message.pitch =
|
|
object.pitch !== undefined && object.pitch !== null
|
|
? PitchLimits.fromPartial(object.pitch)
|
|
: undefined;
|
|
message.mask = object.mask ?? 0;
|
|
return message;
|
|
},
|
|
};
|
|
|
|
function createBasePitchLimits(): PitchLimits {
|
|
return { min: 0, max: 0, front: undefined, back: undefined, transition: 0 };
|
|
}
|
|
|
|
export const PitchLimits: MessageFns<PitchLimits> = {
|
|
encode(
|
|
message: PitchLimits,
|
|
writer: BinaryWriter = new BinaryWriter(),
|
|
): BinaryWriter {
|
|
if (message.min !== 0) {
|
|
writer.uint32(13).float(message.min);
|
|
}
|
|
if (message.max !== 0) {
|
|
writer.uint32(21).float(message.max);
|
|
}
|
|
if (message.front !== undefined) {
|
|
PitchLimitsExtrema.encode(message.front, writer.uint32(26).fork()).join();
|
|
}
|
|
if (message.back !== undefined) {
|
|
PitchLimitsExtrema.encode(message.back, writer.uint32(34).fork()).join();
|
|
}
|
|
if (message.transition !== undefined && message.transition !== 0) {
|
|
writer.uint32(45).float(message.transition);
|
|
}
|
|
return writer;
|
|
},
|
|
|
|
decode(input: BinaryReader | Uint8Array, length?: number): PitchLimits {
|
|
const reader =
|
|
input instanceof BinaryReader ? input : new BinaryReader(input);
|
|
const end = length === undefined ? reader.len : reader.pos + length;
|
|
const message = createBasePitchLimits();
|
|
while (reader.pos < end) {
|
|
const tag = reader.uint32();
|
|
switch (tag >>> 3) {
|
|
case 1: {
|
|
if (tag !== 13) {
|
|
break;
|
|
}
|
|
|
|
message.min = reader.float();
|
|
continue;
|
|
}
|
|
case 2: {
|
|
if (tag !== 21) {
|
|
break;
|
|
}
|
|
|
|
message.max = reader.float();
|
|
continue;
|
|
}
|
|
case 3: {
|
|
if (tag !== 26) {
|
|
break;
|
|
}
|
|
|
|
message.front = PitchLimitsExtrema.decode(reader, reader.uint32());
|
|
continue;
|
|
}
|
|
case 4: {
|
|
if (tag !== 34) {
|
|
break;
|
|
}
|
|
|
|
message.back = PitchLimitsExtrema.decode(reader, reader.uint32());
|
|
continue;
|
|
}
|
|
case 5: {
|
|
if (tag !== 45) {
|
|
break;
|
|
}
|
|
|
|
message.transition = reader.float();
|
|
continue;
|
|
}
|
|
}
|
|
if ((tag & 7) === 4 || tag === 0) {
|
|
break;
|
|
}
|
|
reader.skip(tag & 7);
|
|
}
|
|
return message;
|
|
},
|
|
|
|
fromJSON(object: any): PitchLimits {
|
|
return {
|
|
min: isSet(object.min) ? globalThis.Number(object.min) : 0,
|
|
max: isSet(object.max) ? globalThis.Number(object.max) : 0,
|
|
front: isSet(object.front)
|
|
? PitchLimitsExtrema.fromJSON(object.front)
|
|
: undefined,
|
|
back: isSet(object.back)
|
|
? PitchLimitsExtrema.fromJSON(object.back)
|
|
: undefined,
|
|
transition: isSet(object.transition)
|
|
? globalThis.Number(object.transition)
|
|
: 0,
|
|
};
|
|
},
|
|
|
|
toJSON(message: PitchLimits): unknown {
|
|
const obj: any = {};
|
|
if (message.min !== 0) {
|
|
obj.min = message.min;
|
|
}
|
|
if (message.max !== 0) {
|
|
obj.max = message.max;
|
|
}
|
|
if (message.front !== undefined) {
|
|
obj.front = PitchLimitsExtrema.toJSON(message.front);
|
|
}
|
|
if (message.back !== undefined) {
|
|
obj.back = PitchLimitsExtrema.toJSON(message.back);
|
|
}
|
|
if (message.transition !== undefined && message.transition !== 0) {
|
|
obj.transition = message.transition;
|
|
}
|
|
return obj;
|
|
},
|
|
|
|
create<I extends Exact<DeepPartial<PitchLimits>, I>>(base?: I): PitchLimits {
|
|
return PitchLimits.fromPartial(base ?? ({} as any));
|
|
},
|
|
fromPartial<I extends Exact<DeepPartial<PitchLimits>, I>>(
|
|
object: I,
|
|
): PitchLimits {
|
|
const message = createBasePitchLimits();
|
|
message.min = object.min ?? 0;
|
|
message.max = object.max ?? 0;
|
|
message.front =
|
|
object.front !== undefined && object.front !== null
|
|
? PitchLimitsExtrema.fromPartial(object.front)
|
|
: undefined;
|
|
message.back =
|
|
object.back !== undefined && object.back !== null
|
|
? PitchLimitsExtrema.fromPartial(object.back)
|
|
: undefined;
|
|
message.transition = object.transition ?? 0;
|
|
return message;
|
|
},
|
|
};
|
|
|
|
function createBasePitchLimitsExtrema(): PitchLimitsExtrema {
|
|
return { min: 0, max: 0, range: 0 };
|
|
}
|
|
|
|
export const PitchLimitsExtrema: MessageFns<PitchLimitsExtrema> = {
|
|
encode(
|
|
message: PitchLimitsExtrema,
|
|
writer: BinaryWriter = new BinaryWriter(),
|
|
): BinaryWriter {
|
|
if (message.min !== 0) {
|
|
writer.uint32(13).float(message.min);
|
|
}
|
|
if (message.max !== 0) {
|
|
writer.uint32(21).float(message.max);
|
|
}
|
|
if (message.range !== 0) {
|
|
writer.uint32(29).float(message.range);
|
|
}
|
|
return writer;
|
|
},
|
|
|
|
decode(
|
|
input: BinaryReader | Uint8Array,
|
|
length?: number,
|
|
): PitchLimitsExtrema {
|
|
const reader =
|
|
input instanceof BinaryReader ? input : new BinaryReader(input);
|
|
const end = length === undefined ? reader.len : reader.pos + length;
|
|
const message = createBasePitchLimitsExtrema();
|
|
while (reader.pos < end) {
|
|
const tag = reader.uint32();
|
|
switch (tag >>> 3) {
|
|
case 1: {
|
|
if (tag !== 13) {
|
|
break;
|
|
}
|
|
|
|
message.min = reader.float();
|
|
continue;
|
|
}
|
|
case 2: {
|
|
if (tag !== 21) {
|
|
break;
|
|
}
|
|
|
|
message.max = reader.float();
|
|
continue;
|
|
}
|
|
case 3: {
|
|
if (tag !== 29) {
|
|
break;
|
|
}
|
|
|
|
message.range = reader.float();
|
|
continue;
|
|
}
|
|
}
|
|
if ((tag & 7) === 4 || tag === 0) {
|
|
break;
|
|
}
|
|
reader.skip(tag & 7);
|
|
}
|
|
return message;
|
|
},
|
|
|
|
fromJSON(object: any): PitchLimitsExtrema {
|
|
return {
|
|
min: isSet(object.min) ? globalThis.Number(object.min) : 0,
|
|
max: isSet(object.max) ? globalThis.Number(object.max) : 0,
|
|
range: isSet(object.range) ? globalThis.Number(object.range) : 0,
|
|
};
|
|
},
|
|
|
|
toJSON(message: PitchLimitsExtrema): unknown {
|
|
const obj: any = {};
|
|
if (message.min !== 0) {
|
|
obj.min = message.min;
|
|
}
|
|
if (message.max !== 0) {
|
|
obj.max = message.max;
|
|
}
|
|
if (message.range !== 0) {
|
|
obj.range = message.range;
|
|
}
|
|
return obj;
|
|
},
|
|
|
|
create<I extends Exact<DeepPartial<PitchLimitsExtrema>, I>>(
|
|
base?: I,
|
|
): PitchLimitsExtrema {
|
|
return PitchLimitsExtrema.fromPartial(base ?? ({} as any));
|
|
},
|
|
fromPartial<I extends Exact<DeepPartial<PitchLimitsExtrema>, I>>(
|
|
object: I,
|
|
): PitchLimitsExtrema {
|
|
const message = createBasePitchLimitsExtrema();
|
|
message.min = object.min ?? 0;
|
|
message.max = object.max ?? 0;
|
|
message.range = object.range ?? 0;
|
|
return message;
|
|
},
|
|
};
|
|
|
|
type Builtin =
|
|
| Date
|
|
| Function
|
|
| Uint8Array
|
|
| string
|
|
| number
|
|
| boolean
|
|
| undefined;
|
|
|
|
export type DeepPartial<T> = T extends Builtin
|
|
? T
|
|
: T extends globalThis.Array<infer U>
|
|
? globalThis.Array<DeepPartial<U>>
|
|
: T extends ReadonlyArray<infer U>
|
|
? ReadonlyArray<DeepPartial<U>>
|
|
: T extends { $case: string; value: unknown }
|
|
? { $case: T["$case"]; value?: DeepPartial<T["value"]> }
|
|
: T extends {}
|
|
? { [K in keyof T]?: DeepPartial<T[K]> }
|
|
: Partial<T>;
|
|
|
|
type KeysOfUnion<T> = T extends T ? keyof T : never;
|
|
export type Exact<P, I extends P> = P extends Builtin
|
|
? P
|
|
: P & { [K in keyof P]: Exact<P[K], I[K]> } & {
|
|
[K in Exclude<keyof I, KeysOfUnion<P>>]: never;
|
|
};
|
|
|
|
function isObject(value: any): boolean {
|
|
return typeof value === "object" && value !== null;
|
|
}
|
|
|
|
function isSet(value: any): boolean {
|
|
return value !== null && value !== undefined;
|
|
}
|
|
|
|
export interface MessageFns<T> {
|
|
encode(message: T, writer?: BinaryWriter): BinaryWriter;
|
|
decode(input: BinaryReader | Uint8Array, length?: number): T;
|
|
fromJSON(object: any): T;
|
|
toJSON(message: T): unknown;
|
|
create<I extends Exact<DeepPartial<T>, I>>(base?: I): T;
|
|
fromPartial<I extends Exact<DeepPartial<T>, I>>(object: I): T;
|
|
}
|