diff --git a/exporter/SynthesisFusionAddin/src/Proto/assembly_pb2.pyi b/exporter/SynthesisFusionAddin/src/Proto/assembly_pb2.pyi new file mode 100644 index 000000000..84548670b --- /dev/null +++ b/exporter/SynthesisFusionAddin/src/Proto/assembly_pb2.pyi @@ -0,0 +1,449 @@ +""" +@generated by mypy-protobuf. Do not edit manually! +isort:skip_file +""" + +import builtins +import collections.abc +import google.protobuf.descriptor +import google.protobuf.internal.containers +import google.protobuf.message +import joint_pb2 +import material_pb2 +import signal_pb2 +import types_pb2 +import typing + +DESCRIPTOR: google.protobuf.descriptor.FileDescriptor + +@typing.final +class Assembly(google.protobuf.message.Message): + """* + Assembly + Base Design to be interacted with + THIS IS THE CURRENT FILE EXPORTED + """ + + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + INFO_FIELD_NUMBER: builtins.int + DATA_FIELD_NUMBER: builtins.int + DYNAMIC_FIELD_NUMBER: builtins.int + PHYSICAL_DATA_FIELD_NUMBER: builtins.int + DESIGN_HIERARCHY_FIELD_NUMBER: builtins.int + JOINT_HIERARCHY_FIELD_NUMBER: builtins.int + TRANSFORM_FIELD_NUMBER: builtins.int + THUMBNAIL_FIELD_NUMBER: builtins.int + dynamic: builtins.bool + """/ Can it be effected by the simulation dynamically""" + @property + def info(self) -> types_pb2.Info: + """/ Basic information (name, Author, etc)""" + + @property + def data(self) -> global___AssemblyData: + """/ All of the data in the assembly""" + + @property + def physical_data(self) -> types_pb2.PhysicalProperties: + """/ Overall physical data of the assembly""" + + @property + def design_hierarchy(self) -> types_pb2.GraphContainer: + """/ The Design hierarchy represented by Part Refs - The first object is a root container for all top level items""" + + @property + def joint_hierarchy(self) -> types_pb2.GraphContainer: + """/ The Joint hierarchy for compound shapes""" + + @property + def transform(self) -> types_pb2.Transform: + """/ The Transform in space currently""" + + @property + def thumbnail(self) -> types_pb2.Thumbnail: + """/ Optional thumbnail saved from Fusion 360 or scraped from previous configuration""" + + def __init__( + self, + *, + info: types_pb2.Info | None = ..., + data: global___AssemblyData | None = ..., + dynamic: builtins.bool = ..., + physical_data: types_pb2.PhysicalProperties | None = ..., + design_hierarchy: types_pb2.GraphContainer | None = ..., + joint_hierarchy: types_pb2.GraphContainer | None = ..., + transform: types_pb2.Transform | None = ..., + thumbnail: types_pb2.Thumbnail | None = ..., + ) -> None: ... + def HasField(self, field_name: typing.Literal["data", b"data", "design_hierarchy", b"design_hierarchy", "info", b"info", "joint_hierarchy", b"joint_hierarchy", "physical_data", b"physical_data", "thumbnail", b"thumbnail", "transform", b"transform"]) -> builtins.bool: ... + def ClearField(self, field_name: typing.Literal["data", b"data", "design_hierarchy", b"design_hierarchy", "dynamic", b"dynamic", "info", b"info", "joint_hierarchy", b"joint_hierarchy", "physical_data", b"physical_data", "thumbnail", b"thumbnail", "transform", b"transform"]) -> None: ... + +global___Assembly = Assembly + +@typing.final +class AssemblyData(google.protobuf.message.Message): + """* + Data used to construct the assembly + """ + + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + PARTS_FIELD_NUMBER: builtins.int + JOINTS_FIELD_NUMBER: builtins.int + MATERIALS_FIELD_NUMBER: builtins.int + SIGNALS_FIELD_NUMBER: builtins.int + @property + def parts(self) -> global___Parts: + """/ Meshes and Design Objects""" + + @property + def joints(self) -> joint_pb2.Joints: + """/ Joint Definition Set""" + + @property + def materials(self) -> material_pb2.Materials: + """/ Appearance and Physical Material Set""" + + @property + def signals(self) -> signal_pb2.Signals: + """Contains table of all signals with ID reference""" + + def __init__( + self, + *, + parts: global___Parts | None = ..., + joints: joint_pb2.Joints | None = ..., + materials: material_pb2.Materials | None = ..., + signals: signal_pb2.Signals | None = ..., + ) -> None: ... + def HasField(self, field_name: typing.Literal["joints", b"joints", "materials", b"materials", "parts", b"parts", "signals", b"signals"]) -> builtins.bool: ... + def ClearField(self, field_name: typing.Literal["joints", b"joints", "materials", b"materials", "parts", b"parts", "signals", b"signals"]) -> None: ... + +global___AssemblyData = AssemblyData + +@typing.final +class Parts(google.protobuf.message.Message): + """Part file can be exported seperately in the future""" + + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + @typing.final + class PartDefinitionsEntry(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + KEY_FIELD_NUMBER: builtins.int + VALUE_FIELD_NUMBER: builtins.int + key: builtins.str + @property + def value(self) -> global___PartDefinition: ... + def __init__( + self, + *, + key: builtins.str = ..., + value: global___PartDefinition | None = ..., + ) -> None: ... + def HasField(self, field_name: typing.Literal["value", b"value"]) -> builtins.bool: ... + def ClearField(self, field_name: typing.Literal["key", b"key", "value", b"value"]) -> None: ... + + @typing.final + class PartInstancesEntry(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + KEY_FIELD_NUMBER: builtins.int + VALUE_FIELD_NUMBER: builtins.int + key: builtins.str + @property + def value(self) -> global___PartInstance: ... + def __init__( + self, + *, + key: builtins.str = ..., + value: global___PartInstance | None = ..., + ) -> None: ... + def HasField(self, field_name: typing.Literal["value", b"value"]) -> builtins.bool: ... + def ClearField(self, field_name: typing.Literal["key", b"key", "value", b"value"]) -> None: ... + + INFO_FIELD_NUMBER: builtins.int + PART_DEFINITIONS_FIELD_NUMBER: builtins.int + PART_INSTANCES_FIELD_NUMBER: builtins.int + USER_DATA_FIELD_NUMBER: builtins.int + @property + def info(self) -> types_pb2.Info: + """/ Part name, version, GUID""" + + @property + def part_definitions(self) -> google.protobuf.internal.containers.MessageMap[builtins.str, global___PartDefinition]: + """/ Map of the Exported Part Definitions""" + + @property + def part_instances(self) -> google.protobuf.internal.containers.MessageMap[builtins.str, global___PartInstance]: + """/ Map of the Exported Parts that make up the object""" + + @property + def user_data(self) -> types_pb2.UserData: + """/ other associated data that can be used + end effector, wheel, etc + """ + + def __init__( + self, + *, + info: types_pb2.Info | None = ..., + part_definitions: collections.abc.Mapping[builtins.str, global___PartDefinition] | None = ..., + part_instances: collections.abc.Mapping[builtins.str, global___PartInstance] | None = ..., + user_data: types_pb2.UserData | None = ..., + ) -> None: ... + def HasField(self, field_name: typing.Literal["info", b"info", "user_data", b"user_data"]) -> builtins.bool: ... + def ClearField(self, field_name: typing.Literal["info", b"info", "part_definitions", b"part_definitions", "part_instances", b"part_instances", "user_data", b"user_data"]) -> None: ... + +global___Parts = Parts + +@typing.final +class PartDefinition(google.protobuf.message.Message): + """* + Part Definition + Unique Definition of a part that can be replicated. + Useful for keeping the object counter down in the scene. + """ + + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + INFO_FIELD_NUMBER: builtins.int + PHYSICAL_DATA_FIELD_NUMBER: builtins.int + BASE_TRANSFORM_FIELD_NUMBER: builtins.int + BODIES_FIELD_NUMBER: builtins.int + DYNAMIC_FIELD_NUMBER: builtins.int + FRICTION_OVERRIDE_FIELD_NUMBER: builtins.int + MASS_OVERRIDE_FIELD_NUMBER: builtins.int + dynamic: builtins.bool + """/ Optional value to state whether an object is a dynamic object in a static assembly - all children are also considered overriden""" + friction_override: builtins.float + """/ Optional value for overriding the friction value 0-1""" + mass_override: builtins.float + """/ Optional value for overriding an indiviaul object's mass""" + @property + def info(self) -> types_pb2.Info: + """/ Information about version - id - name""" + + @property + def physical_data(self) -> types_pb2.PhysicalProperties: + """/ Physical data associated with Part""" + + @property + def base_transform(self) -> types_pb2.Transform: + """/ Base Transform applied - Most Likely Identity Matrix""" + + @property + def bodies(self) -> google.protobuf.internal.containers.RepeatedCompositeFieldContainer[global___Body]: + """/ Mesh Bodies to populate part""" + + def __init__( + self, + *, + info: types_pb2.Info | None = ..., + physical_data: types_pb2.PhysicalProperties | None = ..., + base_transform: types_pb2.Transform | None = ..., + bodies: collections.abc.Iterable[global___Body] | None = ..., + dynamic: builtins.bool = ..., + friction_override: builtins.float = ..., + mass_override: builtins.float = ..., + ) -> None: ... + def HasField(self, field_name: typing.Literal["base_transform", b"base_transform", "info", b"info", "physical_data", b"physical_data"]) -> builtins.bool: ... + def ClearField(self, field_name: typing.Literal["base_transform", b"base_transform", "bodies", b"bodies", "dynamic", b"dynamic", "friction_override", b"friction_override", "info", b"info", "mass_override", b"mass_override", "physical_data", b"physical_data"]) -> None: ... + +global___PartDefinition = PartDefinition + +@typing.final +class PartInstance(google.protobuf.message.Message): + """ + Part + Represents a object that does not have to be unique + Can be an override for an existing definition + """ + + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + INFO_FIELD_NUMBER: builtins.int + PART_DEFINITION_REFERENCE_FIELD_NUMBER: builtins.int + TRANSFORM_FIELD_NUMBER: builtins.int + GLOBAL_TRANSFORM_FIELD_NUMBER: builtins.int + JOINTS_FIELD_NUMBER: builtins.int + APPEARANCE_FIELD_NUMBER: builtins.int + PHYSICAL_MATERIAL_FIELD_NUMBER: builtins.int + SKIP_COLLIDER_FIELD_NUMBER: builtins.int + part_definition_reference: builtins.str + """/ Reference to the Part Definition defined in Assembly Data""" + appearance: builtins.str + """Appearance Reference to link to `Materials->Appearance->Info->id`""" + physical_material: builtins.str + """/ Physical Material Reference to link to `Materials->PhysicalMaterial->Info->id`""" + skip_collider: builtins.bool + """/ Flag that if enabled indicates we should skip generating a collider, defaults to FALSE or undefined""" + @property + def info(self) -> types_pb2.Info: ... + @property + def transform(self) -> types_pb2.Transform: + """/ Overriding the object transform (moves the part from the def) - in design hierarchy context""" + + @property + def global_transform(self) -> types_pb2.Transform: + """/ Position transform from a global scope""" + + @property + def joints(self) -> google.protobuf.internal.containers.RepeatedScalarFieldContainer[builtins.str]: + """/ Joints that interact with this element""" + + def __init__( + self, + *, + info: types_pb2.Info | None = ..., + part_definition_reference: builtins.str = ..., + transform: types_pb2.Transform | None = ..., + global_transform: types_pb2.Transform | None = ..., + joints: collections.abc.Iterable[builtins.str] | None = ..., + appearance: builtins.str = ..., + physical_material: builtins.str = ..., + skip_collider: builtins.bool = ..., + ) -> None: ... + def HasField(self, field_name: typing.Literal["global_transform", b"global_transform", "info", b"info", "transform", b"transform"]) -> builtins.bool: ... + def ClearField(self, field_name: typing.Literal["appearance", b"appearance", "global_transform", b"global_transform", "info", b"info", "joints", b"joints", "part_definition_reference", b"part_definition_reference", "physical_material", b"physical_material", "skip_collider", b"skip_collider", "transform", b"transform"]) -> None: ... + +global___PartInstance = PartInstance + +@typing.final +class Body(google.protobuf.message.Message): + """ + Body object + Can contain a TriangleMesh or Collection of Faces. + Must be unique in the context of the Assembly. + """ + + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + INFO_FIELD_NUMBER: builtins.int + PART_FIELD_NUMBER: builtins.int + TRIANGLE_MESH_FIELD_NUMBER: builtins.int + APPEARANCE_OVERRIDE_FIELD_NUMBER: builtins.int + part: builtins.str + """/ Reference to Part Definition""" + appearance_override: builtins.str + """/ Override Visual Appearance for the body""" + @property + def info(self) -> types_pb2.Info: ... + @property + def triangle_mesh(self) -> global___TriangleMesh: + """/ Triangle Mesh for rendering""" + + def __init__( + self, + *, + info: types_pb2.Info | None = ..., + part: builtins.str = ..., + triangle_mesh: global___TriangleMesh | None = ..., + appearance_override: builtins.str = ..., + ) -> None: ... + def HasField(self, field_name: typing.Literal["info", b"info", "triangle_mesh", b"triangle_mesh"]) -> builtins.bool: ... + def ClearField(self, field_name: typing.Literal["appearance_override", b"appearance_override", "info", b"info", "part", b"part", "triangle_mesh", b"triangle_mesh"]) -> None: ... + +global___Body = Body + +@typing.final +class TriangleMesh(google.protobuf.message.Message): + """* + Traingle Mesh for Storing Display Mesh data + """ + + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + INFO_FIELD_NUMBER: builtins.int + HAS_VOLUME_FIELD_NUMBER: builtins.int + MATERIAL_REFERENCE_FIELD_NUMBER: builtins.int + MESH_FIELD_NUMBER: builtins.int + BMESH_FIELD_NUMBER: builtins.int + has_volume: builtins.bool + """/ Is this object a Plane ? (Does it have volume)""" + material_reference: builtins.str + """/ Rendered Appearance properties referenced from Assembly Data""" + @property + def info(self) -> types_pb2.Info: ... + @property + def mesh(self) -> global___Mesh: + """/ Stored as true types, inidicies, verts, uv""" + + @property + def bmesh(self) -> global___BinaryMesh: + """/ Stored as binary data in bytes""" + + def __init__( + self, + *, + info: types_pb2.Info | None = ..., + has_volume: builtins.bool = ..., + material_reference: builtins.str = ..., + mesh: global___Mesh | None = ..., + bmesh: global___BinaryMesh | None = ..., + ) -> None: ... + def HasField(self, field_name: typing.Literal["bmesh", b"bmesh", "info", b"info", "mesh", b"mesh", "mesh_type", b"mesh_type"]) -> builtins.bool: ... + def ClearField(self, field_name: typing.Literal["bmesh", b"bmesh", "has_volume", b"has_volume", "info", b"info", "material_reference", b"material_reference", "mesh", b"mesh", "mesh_type", b"mesh_type"]) -> None: ... + def WhichOneof(self, oneof_group: typing.Literal["mesh_type", b"mesh_type"]) -> typing.Literal["mesh", "bmesh"] | None: ... + +global___TriangleMesh = TriangleMesh + +@typing.final +class Mesh(google.protobuf.message.Message): + """* + Mesh Data stored as generic Data Structure + """ + + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + VERTS_FIELD_NUMBER: builtins.int + NORMALS_FIELD_NUMBER: builtins.int + UV_FIELD_NUMBER: builtins.int + INDICES_FIELD_NUMBER: builtins.int + @property + def verts(self) -> google.protobuf.internal.containers.RepeatedScalarFieldContainer[builtins.float]: + """/ Tri Mesh Verts vec3""" + + @property + def normals(self) -> google.protobuf.internal.containers.RepeatedScalarFieldContainer[builtins.float]: + """/ Tri Mesh Normals vec3""" + + @property + def uv(self) -> google.protobuf.internal.containers.RepeatedScalarFieldContainer[builtins.float]: + """/ Tri Mesh uv Mapping vec2""" + + @property + def indices(self) -> google.protobuf.internal.containers.RepeatedScalarFieldContainer[builtins.int]: + """/ Tri Mesh indicies (Vert Map)""" + + def __init__( + self, + *, + verts: collections.abc.Iterable[builtins.float] | None = ..., + normals: collections.abc.Iterable[builtins.float] | None = ..., + uv: collections.abc.Iterable[builtins.float] | None = ..., + indices: collections.abc.Iterable[builtins.int] | None = ..., + ) -> None: ... + def ClearField(self, field_name: typing.Literal["indices", b"indices", "normals", b"normals", "uv", b"uv", "verts", b"verts"]) -> None: ... + +global___Mesh = Mesh + +@typing.final +class BinaryMesh(google.protobuf.message.Message): + """/ Mesh used for more effective file transfers""" + + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + DATA_FIELD_NUMBER: builtins.int + data: builtins.bytes + """/ BEWARE of ENDIANESS""" + def __init__( + self, + *, + data: builtins.bytes = ..., + ) -> None: ... + def ClearField(self, field_name: typing.Literal["data", b"data"]) -> None: ... + +global___BinaryMesh = BinaryMesh diff --git a/exporter/SynthesisFusionAddin/src/Proto/joint_pb2.pyi b/exporter/SynthesisFusionAddin/src/Proto/joint_pb2.pyi new file mode 100644 index 000000000..f716bc270 --- /dev/null +++ b/exporter/SynthesisFusionAddin/src/Proto/joint_pb2.pyi @@ -0,0 +1,570 @@ +""" +@generated by mypy-protobuf. Do not edit manually! +isort:skip_file +""" + +import builtins +import collections.abc +import google.protobuf.descriptor +import google.protobuf.internal.containers +import google.protobuf.internal.enum_type_wrapper +import google.protobuf.message +import motor_pb2 +import sys +import types_pb2 +import typing + +if sys.version_info >= (3, 10): + import typing as typing_extensions +else: + import typing_extensions + +DESCRIPTOR: google.protobuf.descriptor.FileDescriptor + +class _JointMotion: + ValueType = typing.NewType("ValueType", builtins.int) + V: typing_extensions.TypeAlias = ValueType + +class _JointMotionEnumTypeWrapper(google.protobuf.internal.enum_type_wrapper._EnumTypeWrapper[_JointMotion.ValueType], builtins.type): + DESCRIPTOR: google.protobuf.descriptor.EnumDescriptor + RIGID: _JointMotion.ValueType # 0 + REVOLUTE: _JointMotion.ValueType # 1 + SLIDER: _JointMotion.ValueType # 2 + CYLINDRICAL: _JointMotion.ValueType # 3 + PINSLOT: _JointMotion.ValueType # 4 + PLANAR: _JointMotion.ValueType # 5 + BALL: _JointMotion.ValueType # 6 + CUSTOM: _JointMotion.ValueType # 7 + +class JointMotion(_JointMotion, metaclass=_JointMotionEnumTypeWrapper): + """Describes the joint - Not really sure what to do with this for now - TBD""" + +RIGID: JointMotion.ValueType # 0 +REVOLUTE: JointMotion.ValueType # 1 +SLIDER: JointMotion.ValueType # 2 +CYLINDRICAL: JointMotion.ValueType # 3 +PINSLOT: JointMotion.ValueType # 4 +PLANAR: JointMotion.ValueType # 5 +BALL: JointMotion.ValueType # 6 +CUSTOM: JointMotion.ValueType # 7 +global___JointMotion = JointMotion + +@typing.final +class Joints(google.protobuf.message.Message): + """You can have an Open-Chain robot meaning a single path + You can have a closed chain mechanism or Four-bar (closed loop) + Or multiple paths with closed loop like a stewart platform + + * + Joints + A way to define the motion between various group connections + """ + + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + @typing.final + class JointDefinitionsEntry(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + KEY_FIELD_NUMBER: builtins.int + VALUE_FIELD_NUMBER: builtins.int + key: builtins.str + @property + def value(self) -> global___Joint: ... + def __init__( + self, + *, + key: builtins.str = ..., + value: global___Joint | None = ..., + ) -> None: ... + def HasField(self, field_name: typing.Literal["value", b"value"]) -> builtins.bool: ... + def ClearField(self, field_name: typing.Literal["key", b"key", "value", b"value"]) -> None: ... + + @typing.final + class JointInstancesEntry(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + KEY_FIELD_NUMBER: builtins.int + VALUE_FIELD_NUMBER: builtins.int + key: builtins.str + @property + def value(self) -> global___JointInstance: ... + def __init__( + self, + *, + key: builtins.str = ..., + value: global___JointInstance | None = ..., + ) -> None: ... + def HasField(self, field_name: typing.Literal["value", b"value"]) -> builtins.bool: ... + def ClearField(self, field_name: typing.Literal["key", b"key", "value", b"value"]) -> None: ... + + @typing.final + class MotorDefinitionsEntry(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + KEY_FIELD_NUMBER: builtins.int + VALUE_FIELD_NUMBER: builtins.int + key: builtins.str + @property + def value(self) -> motor_pb2.Motor: ... + def __init__( + self, + *, + key: builtins.str = ..., + value: motor_pb2.Motor | None = ..., + ) -> None: ... + def HasField(self, field_name: typing.Literal["value", b"value"]) -> builtins.bool: ... + def ClearField(self, field_name: typing.Literal["key", b"key", "value", b"value"]) -> None: ... + + INFO_FIELD_NUMBER: builtins.int + JOINT_DEFINITIONS_FIELD_NUMBER: builtins.int + JOINT_INSTANCES_FIELD_NUMBER: builtins.int + RIGID_GROUPS_FIELD_NUMBER: builtins.int + MOTOR_DEFINITIONS_FIELD_NUMBER: builtins.int + @property + def info(self) -> types_pb2.Info: + """/ name, version, uid""" + + @property + def joint_definitions(self) -> google.protobuf.internal.containers.MessageMap[builtins.str, global___Joint]: + """/ Unique Joint Implementations""" + + @property + def joint_instances(self) -> google.protobuf.internal.containers.MessageMap[builtins.str, global___JointInstance]: + """/ Instances of the Joint Implementations""" + + @property + def rigid_groups(self) -> google.protobuf.internal.containers.RepeatedCompositeFieldContainer[global___RigidGroup]: + """/ Rigidgroups ?""" + + @property + def motor_definitions(self) -> google.protobuf.internal.containers.MessageMap[builtins.str, motor_pb2.Motor]: + """/ Collection of all Motors exported""" + + def __init__( + self, + *, + info: types_pb2.Info | None = ..., + joint_definitions: collections.abc.Mapping[builtins.str, global___Joint] | None = ..., + joint_instances: collections.abc.Mapping[builtins.str, global___JointInstance] | None = ..., + rigid_groups: collections.abc.Iterable[global___RigidGroup] | None = ..., + motor_definitions: collections.abc.Mapping[builtins.str, motor_pb2.Motor] | None = ..., + ) -> None: ... + def HasField(self, field_name: typing.Literal["info", b"info"]) -> builtins.bool: ... + def ClearField(self, field_name: typing.Literal["info", b"info", "joint_definitions", b"joint_definitions", "joint_instances", b"joint_instances", "motor_definitions", b"motor_definitions", "rigid_groups", b"rigid_groups"]) -> None: ... + +global___Joints = Joints + +@typing.final +class JointInstance(google.protobuf.message.Message): + """* + Instance of a Joint that has a defined motion and limits. + Instancing helps with identifiy closed loop systems. + """ + + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + INFO_FIELD_NUMBER: builtins.int + ISENDEFFECTOR_FIELD_NUMBER: builtins.int + PARENT_PART_FIELD_NUMBER: builtins.int + CHILD_PART_FIELD_NUMBER: builtins.int + JOINT_REFERENCE_FIELD_NUMBER: builtins.int + OFFSET_FIELD_NUMBER: builtins.int + PARTS_FIELD_NUMBER: builtins.int + SIGNAL_REFERENCE_FIELD_NUMBER: builtins.int + MOTION_LINK_FIELD_NUMBER: builtins.int + isEndEffector: builtins.bool + """Is this joint the end effector in the tree ? - might remove this""" + parent_part: builtins.str + """Object that contains the joint - the ID - Part usually""" + child_part: builtins.str + """Object that is affected by the joint - the ID - Part usually""" + joint_reference: builtins.str + """Reference to the Joint Definition""" + signal_reference: builtins.str + """Reference to the Signals as Drivers - use for signal_map in Assembly Data""" + @property + def info(self) -> types_pb2.Info: + """Joint name, ID, version, etc""" + + @property + def offset(self) -> types_pb2.Vector3: + """Offset from Joint Definition Origin""" + + @property + def parts(self) -> types_pb2.GraphContainer: + """Part Instances all contained and affected by this joint directly - tree""" + + @property + def motion_link(self) -> google.protobuf.internal.containers.RepeatedCompositeFieldContainer[global___MotionLink]: + """Motion Links to other joints - ways to preserve motion between dynamic objects""" + + def __init__( + self, + *, + info: types_pb2.Info | None = ..., + isEndEffector: builtins.bool = ..., + parent_part: builtins.str = ..., + child_part: builtins.str = ..., + joint_reference: builtins.str = ..., + offset: types_pb2.Vector3 | None = ..., + parts: types_pb2.GraphContainer | None = ..., + signal_reference: builtins.str = ..., + motion_link: collections.abc.Iterable[global___MotionLink] | None = ..., + ) -> None: ... + def HasField(self, field_name: typing.Literal["info", b"info", "offset", b"offset", "parts", b"parts"]) -> builtins.bool: ... + def ClearField(self, field_name: typing.Literal["child_part", b"child_part", "info", b"info", "isEndEffector", b"isEndEffector", "joint_reference", b"joint_reference", "motion_link", b"motion_link", "offset", b"offset", "parent_part", b"parent_part", "parts", b"parts", "signal_reference", b"signal_reference"]) -> None: ... + +global___JointInstance = JointInstance + +@typing.final +class MotionLink(google.protobuf.message.Message): + """* + Motion Link Feature + Enables the restriction on a joint to a certain range of motion as it is relative to another joint + This is useful for moving parts restricted by belts and gears + """ + + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + JOINT_INSTANCE_FIELD_NUMBER: builtins.int + RATIO_FIELD_NUMBER: builtins.int + REVERSED_FIELD_NUMBER: builtins.int + joint_instance: builtins.str + """The Joint that this is linked to""" + ratio: builtins.float + """Ratio of motion between joint 1 and joint 2, we assume this is in mm for linear and deg for rotational""" + reversed: builtins.bool + """Reverse the relationship - turn in the same or opposite directions - useful when moving axis arent both the same way.""" + def __init__( + self, + *, + joint_instance: builtins.str = ..., + ratio: builtins.float = ..., + reversed: builtins.bool = ..., + ) -> None: ... + def ClearField(self, field_name: typing.Literal["joint_instance", b"joint_instance", "ratio", b"ratio", "reversed", b"reversed"]) -> None: ... + +global___MotionLink = MotionLink + +@typing.final +class Joint(google.protobuf.message.Message): + """* + A unqiue implementation of a joint motion + Contains information about motion but not assembly relation + NOTE: A spring motion is a joint with no driver + """ + + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + INFO_FIELD_NUMBER: builtins.int + ORIGIN_FIELD_NUMBER: builtins.int + JOINT_MOTION_TYPE_FIELD_NUMBER: builtins.int + BREAK_MAGNITUDE_FIELD_NUMBER: builtins.int + ROTATIONAL_FIELD_NUMBER: builtins.int + PRISMATIC_FIELD_NUMBER: builtins.int + CUSTOM_FIELD_NUMBER: builtins.int + USER_DATA_FIELD_NUMBER: builtins.int + MOTOR_REFERENCE_FIELD_NUMBER: builtins.int + joint_motion_type: global___JointMotion.ValueType + """type of motion described by the joint""" + break_magnitude: builtins.float + """At what effort does it come apart at. - leave blank if it doesn't""" + motor_reference: builtins.str + """/ Motor definition reference to lookup in joints collection""" + @property + def info(self) -> types_pb2.Info: + """/ Joint name, ID, version, etc""" + + @property + def origin(self) -> types_pb2.Vector3: + """Transform relative to the parent""" + + @property + def rotational(self) -> global___RotationalJoint: + """/ ONEOF rotational joint""" + + @property + def prismatic(self) -> global___PrismaticJoint: + """/ ONEOF prismatic joint""" + + @property + def custom(self) -> global___CustomJoint: + """/ ONEOF custom joint""" + + @property + def user_data(self) -> types_pb2.UserData: + """/ Additional information someone can query or store relative to your joint.""" + + def __init__( + self, + *, + info: types_pb2.Info | None = ..., + origin: types_pb2.Vector3 | None = ..., + joint_motion_type: global___JointMotion.ValueType = ..., + break_magnitude: builtins.float = ..., + rotational: global___RotationalJoint | None = ..., + prismatic: global___PrismaticJoint | None = ..., + custom: global___CustomJoint | None = ..., + user_data: types_pb2.UserData | None = ..., + motor_reference: builtins.str = ..., + ) -> None: ... + def HasField(self, field_name: typing.Literal["JointMotion", b"JointMotion", "custom", b"custom", "info", b"info", "origin", b"origin", "prismatic", b"prismatic", "rotational", b"rotational", "user_data", b"user_data"]) -> builtins.bool: ... + def ClearField(self, field_name: typing.Literal["JointMotion", b"JointMotion", "break_magnitude", b"break_magnitude", "custom", b"custom", "info", b"info", "joint_motion_type", b"joint_motion_type", "motor_reference", b"motor_reference", "origin", b"origin", "prismatic", b"prismatic", "rotational", b"rotational", "user_data", b"user_data"]) -> None: ... + def WhichOneof(self, oneof_group: typing.Literal["JointMotion", b"JointMotion"]) -> typing.Literal["rotational", "prismatic", "custom"] | None: ... + +global___Joint = Joint + +@typing.final +class Dynamics(google.protobuf.message.Message): + """* + Dynamics specify the mechanical effects on the motion. + """ + + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + DAMPING_FIELD_NUMBER: builtins.int + FRICTION_FIELD_NUMBER: builtins.int + damping: builtins.float + """/ Damping effect on a given joint motion""" + friction: builtins.float + """/ Friction effect on a given joint motion""" + def __init__( + self, + *, + damping: builtins.float = ..., + friction: builtins.float = ..., + ) -> None: ... + def ClearField(self, field_name: typing.Literal["damping", b"damping", "friction", b"friction"]) -> None: ... + +global___Dynamics = Dynamics + +@typing.final +class Limits(google.protobuf.message.Message): + """* + Limits specify the mechanical range of a given joint. + + TODO: Add units + """ + + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + LOWER_FIELD_NUMBER: builtins.int + UPPER_FIELD_NUMBER: builtins.int + VELOCITY_FIELD_NUMBER: builtins.int + EFFORT_FIELD_NUMBER: builtins.int + lower: builtins.float + """/ Lower Limit corresponds to default displacement""" + upper: builtins.float + """/ Upper Limit is the joint extent""" + velocity: builtins.float + """/ Velocity Max in m/s^2 (angular for rotational)""" + effort: builtins.float + """/ Effort is the absolute force a joint can apply for a given instant - ROS has a great article on it http://wiki.ros.org/pr2_controller_manager/safety_limits""" + def __init__( + self, + *, + lower: builtins.float = ..., + upper: builtins.float = ..., + velocity: builtins.float = ..., + effort: builtins.float = ..., + ) -> None: ... + def ClearField(self, field_name: typing.Literal["effort", b"effort", "lower", b"lower", "upper", b"upper", "velocity", b"velocity"]) -> None: ... + +global___Limits = Limits + +@typing.final +class Safety(google.protobuf.message.Message): + """* + Safety switch configuration for a given joint. + Can usefully indicate a bounds issue. + Inspired by the URDF implementation. + + This should really just be created by the controller. + http://wiki.ros.org/pr2_controller_manager/safety_limits + """ + + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + LOWER_LIMIT_FIELD_NUMBER: builtins.int + UPPER_LIMIT_FIELD_NUMBER: builtins.int + K_POSITION_FIELD_NUMBER: builtins.int + K_VELOCITY_FIELD_NUMBER: builtins.int + lower_limit: builtins.float + """/ Lower software limit""" + upper_limit: builtins.float + """/ Upper Software limit""" + k_position: builtins.float + """/ Relation between position and velocity limit""" + k_velocity: builtins.float + """/ Relation between effort and velocity limit""" + def __init__( + self, + *, + lower_limit: builtins.float = ..., + upper_limit: builtins.float = ..., + k_position: builtins.float = ..., + k_velocity: builtins.float = ..., + ) -> None: ... + def ClearField(self, field_name: typing.Literal["k_position", b"k_position", "k_velocity", b"k_velocity", "lower_limit", b"lower_limit", "upper_limit", b"upper_limit"]) -> None: ... + +global___Safety = Safety + +@typing.final +class DOF(google.protobuf.message.Message): + """* + DOF - representing the construction of a joint motion + """ + + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + NAME_FIELD_NUMBER: builtins.int + AXIS_FIELD_NUMBER: builtins.int + PIVOTDIRECTION_FIELD_NUMBER: builtins.int + DYNAMICS_FIELD_NUMBER: builtins.int + LIMITS_FIELD_NUMBER: builtins.int + VALUE_FIELD_NUMBER: builtins.int + name: builtins.str + """/ In case you want to name this degree of freedom""" + pivotDirection: types_pb2.Axis.ValueType + """/ Direction the axis vector is offset from - this has an incorrect naming scheme""" + value: builtins.float + """/ Current value of the DOF""" + @property + def axis(self) -> types_pb2.Vector3: + """/ Axis the degree of freedom is pivoting by""" + + @property + def dynamics(self) -> global___Dynamics: + """/ Dynamic properties of this joint pivot""" + + @property + def limits(self) -> global___Limits: + """/ Limits of this freedom""" + + def __init__( + self, + *, + name: builtins.str = ..., + axis: types_pb2.Vector3 | None = ..., + pivotDirection: types_pb2.Axis.ValueType = ..., + dynamics: global___Dynamics | None = ..., + limits: global___Limits | None = ..., + value: builtins.float = ..., + ) -> None: ... + def HasField(self, field_name: typing.Literal["axis", b"axis", "dynamics", b"dynamics", "limits", b"limits"]) -> builtins.bool: ... + def ClearField(self, field_name: typing.Literal["axis", b"axis", "dynamics", b"dynamics", "limits", b"limits", "name", b"name", "pivotDirection", b"pivotDirection", "value", b"value"]) -> None: ... + +global___DOF = DOF + +@typing.final +class CustomJoint(google.protobuf.message.Message): + """* + CustomJoint is a joint with N degrees of freedom specified. + There should be input validation to handle max freedom case. + """ + + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + DOFS_FIELD_NUMBER: builtins.int + @property + def dofs(self) -> google.protobuf.internal.containers.RepeatedCompositeFieldContainer[global___DOF]: + """/ A list of degrees of freedom that the joint can contain""" + + def __init__( + self, + *, + dofs: collections.abc.Iterable[global___DOF] | None = ..., + ) -> None: ... + def ClearField(self, field_name: typing.Literal["dofs", b"dofs"]) -> None: ... + +global___CustomJoint = CustomJoint + +@typing.final +class RotationalJoint(google.protobuf.message.Message): + """* + RotationalJoint describes a joint with rotational translation. + This is the exact same as prismatic for now. + """ + + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + ROTATIONAL_FREEDOM_FIELD_NUMBER: builtins.int + @property + def rotational_freedom(self) -> global___DOF: ... + def __init__( + self, + *, + rotational_freedom: global___DOF | None = ..., + ) -> None: ... + def HasField(self, field_name: typing.Literal["rotational_freedom", b"rotational_freedom"]) -> builtins.bool: ... + def ClearField(self, field_name: typing.Literal["rotational_freedom", b"rotational_freedom"]) -> None: ... + +global___RotationalJoint = RotationalJoint + +@typing.final +class BallJoint(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + YAW_FIELD_NUMBER: builtins.int + PITCH_FIELD_NUMBER: builtins.int + ROTATION_FIELD_NUMBER: builtins.int + @property + def yaw(self) -> global___DOF: ... + @property + def pitch(self) -> global___DOF: ... + @property + def rotation(self) -> global___DOF: ... + def __init__( + self, + *, + yaw: global___DOF | None = ..., + pitch: global___DOF | None = ..., + rotation: global___DOF | None = ..., + ) -> None: ... + def HasField(self, field_name: typing.Literal["pitch", b"pitch", "rotation", b"rotation", "yaw", b"yaw"]) -> builtins.bool: ... + def ClearField(self, field_name: typing.Literal["pitch", b"pitch", "rotation", b"rotation", "yaw", b"yaw"]) -> None: ... + +global___BallJoint = BallJoint + +@typing.final +class PrismaticJoint(google.protobuf.message.Message): + """* + Prismatic Joint describes a motion that translates the position in a single axis + """ + + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + PRISMATIC_FREEDOM_FIELD_NUMBER: builtins.int + @property + def prismatic_freedom(self) -> global___DOF: ... + def __init__( + self, + *, + prismatic_freedom: global___DOF | None = ..., + ) -> None: ... + def HasField(self, field_name: typing.Literal["prismatic_freedom", b"prismatic_freedom"]) -> builtins.bool: ... + def ClearField(self, field_name: typing.Literal["prismatic_freedom", b"prismatic_freedom"]) -> None: ... + +global___PrismaticJoint = PrismaticJoint + +@typing.final +class RigidGroup(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + NAME_FIELD_NUMBER: builtins.int + OCCURRENCES_FIELD_NUMBER: builtins.int + name: builtins.str + @property + def occurrences(self) -> google.protobuf.internal.containers.RepeatedScalarFieldContainer[builtins.str]: + """this could be the full path of the occurrence in order to make it easier to assembly them possibly - just parse on the unity side""" + + def __init__( + self, + *, + name: builtins.str = ..., + occurrences: collections.abc.Iterable[builtins.str] | None = ..., + ) -> None: ... + def ClearField(self, field_name: typing.Literal["name", b"name", "occurrences", b"occurrences"]) -> None: ... + +global___RigidGroup = RigidGroup diff --git a/exporter/SynthesisFusionAddin/src/Proto/material_pb2.pyi b/exporter/SynthesisFusionAddin/src/Proto/material_pb2.pyi new file mode 100644 index 000000000..8d8126237 --- /dev/null +++ b/exporter/SynthesisFusionAddin/src/Proto/material_pb2.pyi @@ -0,0 +1,302 @@ +""" +@generated by mypy-protobuf. Do not edit manually! +isort:skip_file +""" + +import builtins +import collections.abc +import google.protobuf.descriptor +import google.protobuf.internal.containers +import google.protobuf.internal.enum_type_wrapper +import google.protobuf.message +import sys +import types_pb2 +import typing + +if sys.version_info >= (3, 10): + import typing as typing_extensions +else: + import typing_extensions + +DESCRIPTOR: google.protobuf.descriptor.FileDescriptor + +@typing.final +class Materials(google.protobuf.message.Message): + """* + Represents a File or Set of Materials with Appearances and Physical Data + + Can be Stored in AssemblyData + """ + + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + @typing.final + class PhysicalMaterialsEntry(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + KEY_FIELD_NUMBER: builtins.int + VALUE_FIELD_NUMBER: builtins.int + key: builtins.str + @property + def value(self) -> global___PhysicalMaterial: ... + def __init__( + self, + *, + key: builtins.str = ..., + value: global___PhysicalMaterial | None = ..., + ) -> None: ... + def HasField(self, field_name: typing.Literal["value", b"value"]) -> builtins.bool: ... + def ClearField(self, field_name: typing.Literal["key", b"key", "value", b"value"]) -> None: ... + + @typing.final + class AppearancesEntry(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + KEY_FIELD_NUMBER: builtins.int + VALUE_FIELD_NUMBER: builtins.int + key: builtins.str + @property + def value(self) -> global___Appearance: ... + def __init__( + self, + *, + key: builtins.str = ..., + value: global___Appearance | None = ..., + ) -> None: ... + def HasField(self, field_name: typing.Literal["value", b"value"]) -> builtins.bool: ... + def ClearField(self, field_name: typing.Literal["key", b"key", "value", b"value"]) -> None: ... + + INFO_FIELD_NUMBER: builtins.int + PHYSICALMATERIALS_FIELD_NUMBER: builtins.int + APPEARANCES_FIELD_NUMBER: builtins.int + @property + def info(self) -> types_pb2.Info: + """/ Identifiable information (id, name, version)""" + + @property + def physicalMaterials(self) -> google.protobuf.internal.containers.MessageMap[builtins.str, global___PhysicalMaterial]: + """/ Map of Physical Materials""" + + @property + def appearances(self) -> google.protobuf.internal.containers.MessageMap[builtins.str, global___Appearance]: + """/ Map of Appearances that are purely visual""" + + def __init__( + self, + *, + info: types_pb2.Info | None = ..., + physicalMaterials: collections.abc.Mapping[builtins.str, global___PhysicalMaterial] | None = ..., + appearances: collections.abc.Mapping[builtins.str, global___Appearance] | None = ..., + ) -> None: ... + def HasField(self, field_name: typing.Literal["info", b"info"]) -> builtins.bool: ... + def ClearField(self, field_name: typing.Literal["appearances", b"appearances", "info", b"info", "physicalMaterials", b"physicalMaterials"]) -> None: ... + +global___Materials = Materials + +@typing.final +class Appearance(google.protobuf.message.Message): + """* + Contains information on how a object looks + Limited to just color for now + """ + + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + INFO_FIELD_NUMBER: builtins.int + ALBEDO_FIELD_NUMBER: builtins.int + ROUGHNESS_FIELD_NUMBER: builtins.int + METALLIC_FIELD_NUMBER: builtins.int + SPECULAR_FIELD_NUMBER: builtins.int + roughness: builtins.float + """/ roughness value 0-1""" + metallic: builtins.float + """/ metallic value 0-1""" + specular: builtins.float + """/ specular value 0-1""" + @property + def info(self) -> types_pb2.Info: + """/ Identfiable information (id, name, version)""" + + @property + def albedo(self) -> types_pb2.Color: + """/ albedo map RGBA 0-255""" + + def __init__( + self, + *, + info: types_pb2.Info | None = ..., + albedo: types_pb2.Color | None = ..., + roughness: builtins.float = ..., + metallic: builtins.float = ..., + specular: builtins.float = ..., + ) -> None: ... + def HasField(self, field_name: typing.Literal["albedo", b"albedo", "info", b"info"]) -> builtins.bool: ... + def ClearField(self, field_name: typing.Literal["albedo", b"albedo", "info", b"info", "metallic", b"metallic", "roughness", b"roughness", "specular", b"specular"]) -> None: ... + +global___Appearance = Appearance + +@typing.final +class PhysicalMaterial(google.protobuf.message.Message): + """* + Data to represent any given Physical Material + """ + + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + class _MaterialType: + ValueType = typing.NewType("ValueType", builtins.int) + V: typing_extensions.TypeAlias = ValueType + + class _MaterialTypeEnumTypeWrapper(google.protobuf.internal.enum_type_wrapper._EnumTypeWrapper[PhysicalMaterial._MaterialType.ValueType], builtins.type): + DESCRIPTOR: google.protobuf.descriptor.EnumDescriptor + METAL: PhysicalMaterial._MaterialType.ValueType # 0 + PLASTIC: PhysicalMaterial._MaterialType.ValueType # 1 + + class MaterialType(_MaterialType, metaclass=_MaterialTypeEnumTypeWrapper): ... + METAL: PhysicalMaterial.MaterialType.ValueType # 0 + PLASTIC: PhysicalMaterial.MaterialType.ValueType # 1 + + @typing.final + class Thermal(google.protobuf.message.Message): + """* + Thermal Properties Set Definition for Simulation. + """ + + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + THERMAL_CONDUCTIVITY_FIELD_NUMBER: builtins.int + SPECIFIC_HEAT_FIELD_NUMBER: builtins.int + THERMAL_EXPANSION_COEFFICIENT_FIELD_NUMBER: builtins.int + thermal_conductivity: builtins.float + """/ W/(m*K)""" + specific_heat: builtins.float + """/ J/(g*C)""" + thermal_expansion_coefficient: builtins.float + """/ um/(m*C)""" + def __init__( + self, + *, + thermal_conductivity: builtins.float = ..., + specific_heat: builtins.float = ..., + thermal_expansion_coefficient: builtins.float = ..., + ) -> None: ... + def ClearField(self, field_name: typing.Literal["specific_heat", b"specific_heat", "thermal_conductivity", b"thermal_conductivity", "thermal_expansion_coefficient", b"thermal_expansion_coefficient"]) -> None: ... + + @typing.final + class Mechanical(google.protobuf.message.Message): + """* + Mechanical Properties Set Definition for Simulation. + """ + + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + YOUNG_MOD_FIELD_NUMBER: builtins.int + POISSON_RATIO_FIELD_NUMBER: builtins.int + SHEAR_MOD_FIELD_NUMBER: builtins.int + DENSITY_FIELD_NUMBER: builtins.int + DAMPING_COEFFICIENT_FIELD_NUMBER: builtins.int + young_mod: builtins.float + """naming scheme changes here + / GPa + """ + poisson_ratio: builtins.float + """/ ?""" + shear_mod: builtins.float + """/ MPa""" + density: builtins.float + """/ g/cm^3""" + damping_coefficient: builtins.float + """/ ?""" + def __init__( + self, + *, + young_mod: builtins.float = ..., + poisson_ratio: builtins.float = ..., + shear_mod: builtins.float = ..., + density: builtins.float = ..., + damping_coefficient: builtins.float = ..., + ) -> None: ... + def ClearField(self, field_name: typing.Literal["damping_coefficient", b"damping_coefficient", "density", b"density", "poisson_ratio", b"poisson_ratio", "shear_mod", b"shear_mod", "young_mod", b"young_mod"]) -> None: ... + + @typing.final + class Strength(google.protobuf.message.Message): + """* + Strength Properties Set Definition for Simulation. + """ + + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + YIELD_STRENGTH_FIELD_NUMBER: builtins.int + TENSILE_STRENGTH_FIELD_NUMBER: builtins.int + THERMAL_TREATMENT_FIELD_NUMBER: builtins.int + yield_strength: builtins.float + """/ MPa""" + tensile_strength: builtins.float + """/ MPa""" + thermal_treatment: builtins.bool + """/ yes / no""" + def __init__( + self, + *, + yield_strength: builtins.float = ..., + tensile_strength: builtins.float = ..., + thermal_treatment: builtins.bool = ..., + ) -> None: ... + def ClearField(self, field_name: typing.Literal["tensile_strength", b"tensile_strength", "thermal_treatment", b"thermal_treatment", "yield_strength", b"yield_strength"]) -> None: ... + + INFO_FIELD_NUMBER: builtins.int + DESCRIPTION_FIELD_NUMBER: builtins.int + THERMAL_FIELD_NUMBER: builtins.int + MECHANICAL_FIELD_NUMBER: builtins.int + STRENGTH_FIELD_NUMBER: builtins.int + DYNAMIC_FRICTION_FIELD_NUMBER: builtins.int + STATIC_FRICTION_FIELD_NUMBER: builtins.int + RESTITUTION_FIELD_NUMBER: builtins.int + DEFORMABLE_FIELD_NUMBER: builtins.int + MATTYPE_FIELD_NUMBER: builtins.int + description: builtins.str + """/ short description of physical material""" + dynamic_friction: builtins.float + """/ Frictional force for dampening - Interpolate (0-1)""" + static_friction: builtins.float + """/ Frictional force override at stop - Interpolate (0-1)""" + restitution: builtins.float + """/ Restitution of the object - Interpolate (0-1)""" + deformable: builtins.bool + """/ should this object deform when encountering large forces - TODO: This needs a proper message and equation field""" + matType: global___PhysicalMaterial.MaterialType.ValueType + """/ generic type to assign some default params""" + @property + def info(self) -> types_pb2.Info: + """/ Identifiable information (id, name, version, etc)""" + + @property + def thermal(self) -> global___PhysicalMaterial.Thermal: + """/ Thermal Physical properties of the model OPTIONAL""" + + @property + def mechanical(self) -> global___PhysicalMaterial.Mechanical: + """/ Mechanical properties of the model OPTIONAL""" + + @property + def strength(self) -> global___PhysicalMaterial.Strength: + """/ Physical Strength properties of the model OPTIONAL""" + + def __init__( + self, + *, + info: types_pb2.Info | None = ..., + description: builtins.str = ..., + thermal: global___PhysicalMaterial.Thermal | None = ..., + mechanical: global___PhysicalMaterial.Mechanical | None = ..., + strength: global___PhysicalMaterial.Strength | None = ..., + dynamic_friction: builtins.float = ..., + static_friction: builtins.float = ..., + restitution: builtins.float = ..., + deformable: builtins.bool = ..., + matType: global___PhysicalMaterial.MaterialType.ValueType = ..., + ) -> None: ... + def HasField(self, field_name: typing.Literal["info", b"info", "mechanical", b"mechanical", "strength", b"strength", "thermal", b"thermal"]) -> builtins.bool: ... + def ClearField(self, field_name: typing.Literal["deformable", b"deformable", "description", b"description", "dynamic_friction", b"dynamic_friction", "info", b"info", "matType", b"matType", "mechanical", b"mechanical", "restitution", b"restitution", "static_friction", b"static_friction", "strength", b"strength", "thermal", b"thermal"]) -> None: ... + +global___PhysicalMaterial = PhysicalMaterial diff --git a/exporter/SynthesisFusionAddin/src/Proto/motor_pb2.pyi b/exporter/SynthesisFusionAddin/src/Proto/motor_pb2.pyi new file mode 100644 index 000000000..6131aeb69 --- /dev/null +++ b/exporter/SynthesisFusionAddin/src/Proto/motor_pb2.pyi @@ -0,0 +1,203 @@ +""" +@generated by mypy-protobuf. Do not edit manually! +isort:skip_file +""" + +import builtins +import google.protobuf.descriptor +import google.protobuf.internal.enum_type_wrapper +import google.protobuf.message +import sys +import types_pb2 +import typing + +if sys.version_info >= (3, 10): + import typing as typing_extensions +else: + import typing_extensions + +DESCRIPTOR: google.protobuf.descriptor.FileDescriptor + +class _DutyCycles: + ValueType = typing.NewType("ValueType", builtins.int) + V: typing_extensions.TypeAlias = ValueType + +class _DutyCyclesEnumTypeWrapper(google.protobuf.internal.enum_type_wrapper._EnumTypeWrapper[_DutyCycles.ValueType], builtins.type): + DESCRIPTOR: google.protobuf.descriptor.EnumDescriptor + CONTINUOUS_RUNNING: _DutyCycles.ValueType # 0 + """/ S1""" + SHORT_TIME: _DutyCycles.ValueType # 1 + """/ S2""" + INTERMITTENT_PERIODIC: _DutyCycles.ValueType # 2 + """/ S3""" + CONTINUOUS_PERIODIC: _DutyCycles.ValueType # 3 + """/ S6 Continuous Operation with Periodic Duty""" + +class DutyCycles(_DutyCycles, metaclass=_DutyCyclesEnumTypeWrapper): + """* + Duty Cycles for electric motors + Affects the dynamic output of the motor + https://www.news.benevelli-group.com/index.php/en/88-what-motor-duty-cycle.html + These each have associated data we are not going to use right now + """ + +CONTINUOUS_RUNNING: DutyCycles.ValueType # 0 +"""/ S1""" +SHORT_TIME: DutyCycles.ValueType # 1 +"""/ S2""" +INTERMITTENT_PERIODIC: DutyCycles.ValueType # 2 +"""/ S3""" +CONTINUOUS_PERIODIC: DutyCycles.ValueType # 3 +"""/ S6 Continuous Operation with Periodic Duty""" +global___DutyCycles = DutyCycles + +@typing.final +class Motor(google.protobuf.message.Message): + """* + A Motor should determine the relationship between an input and joint motion + Could represent something like a DC Motor relationship + """ + + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + INFO_FIELD_NUMBER: builtins.int + DC_MOTOR_FIELD_NUMBER: builtins.int + SIMPLE_MOTOR_FIELD_NUMBER: builtins.int + @property + def info(self) -> types_pb2.Info: ... + @property + def dc_motor(self) -> global___DCMotor: ... + @property + def simple_motor(self) -> global___SimpleMotor: ... + def __init__( + self, + *, + info: types_pb2.Info | None = ..., + dc_motor: global___DCMotor | None = ..., + simple_motor: global___SimpleMotor | None = ..., + ) -> None: ... + def HasField(self, field_name: typing.Literal["dc_motor", b"dc_motor", "info", b"info", "motor_type", b"motor_type", "simple_motor", b"simple_motor"]) -> builtins.bool: ... + def ClearField(self, field_name: typing.Literal["dc_motor", b"dc_motor", "info", b"info", "motor_type", b"motor_type", "simple_motor", b"simple_motor"]) -> None: ... + def WhichOneof(self, oneof_group: typing.Literal["motor_type", b"motor_type"]) -> typing.Literal["dc_motor", "simple_motor"] | None: ... + +global___Motor = Motor + +@typing.final +class SimpleMotor(google.protobuf.message.Message): + """* + SimpleMotor Configuration + Very easy motor used to simulate joints without specifying a real motor + Can set braking_constant - stall_torque - and max_velocity + Assumes you are solving using a velocity constraint for a joint and not a acceleration constraint + """ + + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + STALL_TORQUE_FIELD_NUMBER: builtins.int + MAX_VELOCITY_FIELD_NUMBER: builtins.int + BRAKING_CONSTANT_FIELD_NUMBER: builtins.int + stall_torque: builtins.float + """/ Torque at 0 rpm with a inverse linear relationship to max_velocity""" + max_velocity: builtins.float + """/ The target velocity in RPM, will use stall_torque relationship to reach each step""" + braking_constant: builtins.float + """/ (Optional) 0 - 1, the relationship of stall_torque used to perserve the position of this motor""" + def __init__( + self, + *, + stall_torque: builtins.float = ..., + max_velocity: builtins.float = ..., + braking_constant: builtins.float = ..., + ) -> None: ... + def ClearField(self, field_name: typing.Literal["braking_constant", b"braking_constant", "max_velocity", b"max_velocity", "stall_torque", b"stall_torque"]) -> None: ... + +global___SimpleMotor = SimpleMotor + +@typing.final +class DCMotor(google.protobuf.message.Message): + """* + DCMotor Configuration + Parameters to simulate a DC Electric Motor + Still needs some more but overall they are most of the parameters we can use + """ + + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + @typing.final + class Advanced(google.protobuf.message.Message): + """/ Information usually found on datasheet""" + + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + FREE_CURRENT_FIELD_NUMBER: builtins.int + FREE_SPEED_FIELD_NUMBER: builtins.int + STALL_CURRENT_FIELD_NUMBER: builtins.int + STALL_TORQUE_FIELD_NUMBER: builtins.int + INPUT_VOLTAGE_FIELD_NUMBER: builtins.int + RESISTANCE_VARIATION_FIELD_NUMBER: builtins.int + free_current: builtins.float + """/ measured in AMPs""" + free_speed: builtins.int + """/ measured in RPM""" + stall_current: builtins.float + """/ measure in AMPs""" + stall_torque: builtins.float + """/ measured in Nm""" + input_voltage: builtins.int + """/ measured in Volts DC""" + resistance_variation: builtins.float + """/ between (K * (N / 4)) and (K * ((N-2) / 4)) where N is number of poles - leave at 0 if unknown""" + def __init__( + self, + *, + free_current: builtins.float = ..., + free_speed: builtins.int = ..., + stall_current: builtins.float = ..., + stall_torque: builtins.float = ..., + input_voltage: builtins.int = ..., + resistance_variation: builtins.float = ..., + ) -> None: ... + def ClearField(self, field_name: typing.Literal["free_current", b"free_current", "free_speed", b"free_speed", "input_voltage", b"input_voltage", "resistance_variation", b"resistance_variation", "stall_current", b"stall_current", "stall_torque", b"stall_torque"]) -> None: ... + + REFERENCE_URL_FIELD_NUMBER: builtins.int + TORQUE_CONSTANT_FIELD_NUMBER: builtins.int + EMF_CONSTANT_FIELD_NUMBER: builtins.int + RESISTANCE_FIELD_NUMBER: builtins.int + MAXIMUM_EFFECIENCY_FIELD_NUMBER: builtins.int + MAXIMUM_POWER_FIELD_NUMBER: builtins.int + DUTY_CYCLE_FIELD_NUMBER: builtins.int + ADVANCED_FIELD_NUMBER: builtins.int + reference_url: builtins.str + """/ Reference for purchase page or spec sheet""" + torque_constant: builtins.float + """/ m-Nm/Amp""" + emf_constant: builtins.float + """/ mV/rad/sec""" + resistance: builtins.float + """/ Resistance of Motor - Optional if other values are known""" + maximum_effeciency: builtins.int + """/ measure in percentage of 100 - generally around 60 - measured under optimal load""" + maximum_power: builtins.int + """/ measured in Watts""" + duty_cycle: global___DutyCycles.ValueType + """/ Stated Duty Cycle of motor""" + @property + def advanced(self) -> global___DCMotor.Advanced: + """/ Optional data that can give a better relationship to the simulation""" + + def __init__( + self, + *, + reference_url: builtins.str = ..., + torque_constant: builtins.float = ..., + emf_constant: builtins.float = ..., + resistance: builtins.float = ..., + maximum_effeciency: builtins.int = ..., + maximum_power: builtins.int = ..., + duty_cycle: global___DutyCycles.ValueType = ..., + advanced: global___DCMotor.Advanced | None = ..., + ) -> None: ... + def HasField(self, field_name: typing.Literal["advanced", b"advanced"]) -> builtins.bool: ... + def ClearField(self, field_name: typing.Literal["advanced", b"advanced", "duty_cycle", b"duty_cycle", "emf_constant", b"emf_constant", "maximum_effeciency", b"maximum_effeciency", "maximum_power", b"maximum_power", "reference_url", b"reference_url", "resistance", b"resistance", "torque_constant", b"torque_constant"]) -> None: ... + +global___DCMotor = DCMotor diff --git a/exporter/SynthesisFusionAddin/src/Proto/signal_pb2.pyi b/exporter/SynthesisFusionAddin/src/Proto/signal_pb2.pyi new file mode 100644 index 000000000..0befac803 --- /dev/null +++ b/exporter/SynthesisFusionAddin/src/Proto/signal_pb2.pyi @@ -0,0 +1,159 @@ +""" +@generated by mypy-protobuf. Do not edit manually! +isort:skip_file +""" + +import builtins +import collections.abc +import google.protobuf.descriptor +import google.protobuf.internal.containers +import google.protobuf.internal.enum_type_wrapper +import google.protobuf.message +import sys +import types_pb2 +import typing + +if sys.version_info >= (3, 10): + import typing as typing_extensions +else: + import typing_extensions + +DESCRIPTOR: google.protobuf.descriptor.FileDescriptor + +class _IOType: + ValueType = typing.NewType("ValueType", builtins.int) + V: typing_extensions.TypeAlias = ValueType + +class _IOTypeEnumTypeWrapper(google.protobuf.internal.enum_type_wrapper._EnumTypeWrapper[_IOType.ValueType], builtins.type): + DESCRIPTOR: google.protobuf.descriptor.EnumDescriptor + INPUT: _IOType.ValueType # 0 + """/ Input Signal""" + OUTPUT: _IOType.ValueType # 1 + """/ Output Signal""" + +class IOType(_IOType, metaclass=_IOTypeEnumTypeWrapper): + """* + IOType is a way to specify Input or Output. + """ + +INPUT: IOType.ValueType # 0 +"""/ Input Signal""" +OUTPUT: IOType.ValueType # 1 +"""/ Output Signal""" +global___IOType = IOType + +class _DeviceType: + ValueType = typing.NewType("ValueType", builtins.int) + V: typing_extensions.TypeAlias = ValueType + +class _DeviceTypeEnumTypeWrapper(google.protobuf.internal.enum_type_wrapper._EnumTypeWrapper[_DeviceType.ValueType], builtins.type): + DESCRIPTOR: google.protobuf.descriptor.EnumDescriptor + PWM: _DeviceType.ValueType # 0 + Digital: _DeviceType.ValueType # 1 + Analog: _DeviceType.ValueType # 2 + I2C: _DeviceType.ValueType # 3 + CANBUS: _DeviceType.ValueType # 4 + CUSTOM: _DeviceType.ValueType # 5 + +class DeviceType(_DeviceType, metaclass=_DeviceTypeEnumTypeWrapper): + """* + DeviceType needs to be a type of device that has a supported connection + As well as a signal frmae but that can come later + """ + +PWM: DeviceType.ValueType # 0 +Digital: DeviceType.ValueType # 1 +Analog: DeviceType.ValueType # 2 +I2C: DeviceType.ValueType # 3 +CANBUS: DeviceType.ValueType # 4 +CUSTOM: DeviceType.ValueType # 5 +global___DeviceType = DeviceType + +@typing.final +class Signals(google.protobuf.message.Message): + """* + Signals is a container for all of the potential signals. + """ + + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + @typing.final + class SignalMapEntry(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + KEY_FIELD_NUMBER: builtins.int + VALUE_FIELD_NUMBER: builtins.int + key: builtins.str + @property + def value(self) -> global___Signal: ... + def __init__( + self, + *, + key: builtins.str = ..., + value: global___Signal | None = ..., + ) -> None: ... + def HasField(self, field_name: typing.Literal["value", b"value"]) -> builtins.bool: ... + def ClearField(self, field_name: typing.Literal["key", b"key", "value", b"value"]) -> None: ... + + INFO_FIELD_NUMBER: builtins.int + SIGNAL_MAP_FIELD_NUMBER: builtins.int + @property + def info(self) -> types_pb2.Info: + """/ Has identifiable data (id, name, version)""" + + @property + def signal_map(self) -> google.protobuf.internal.containers.MessageMap[builtins.str, global___Signal]: + """/ Contains a full collection of symbols""" + + def __init__( + self, + *, + info: types_pb2.Info | None = ..., + signal_map: collections.abc.Mapping[builtins.str, global___Signal] | None = ..., + ) -> None: ... + def HasField(self, field_name: typing.Literal["info", b"info"]) -> builtins.bool: ... + def ClearField(self, field_name: typing.Literal["info", b"info", "signal_map", b"signal_map"]) -> None: ... + +global___Signals = Signals + +@typing.final +class Signal(google.protobuf.message.Message): + """* + Signal is a way to define a controlling signal. + + TODO: Add Origin + TODO: Decide how this is linked to a exported object + """ + + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + INFO_FIELD_NUMBER: builtins.int + IO_FIELD_NUMBER: builtins.int + CUSTOM_TYPE_FIELD_NUMBER: builtins.int + SIGNAL_ID_FIELD_NUMBER: builtins.int + DEVICE_TYPE_FIELD_NUMBER: builtins.int + io: global___IOType.ValueType + """/ Is this a Input or Output""" + custom_type: builtins.str + """/ The name of a custom input type that is not listed as a device type""" + signal_id: builtins.int + """/ ID for a given signal that exists... PWM 2, CANBUS 4""" + device_type: global___DeviceType.ValueType + """/ Enum for device type that should always be set""" + @property + def info(self) -> types_pb2.Info: + """/ Has identifiable data (id, name, version)""" + + def __init__( + self, + *, + info: types_pb2.Info | None = ..., + io: global___IOType.ValueType = ..., + custom_type: builtins.str = ..., + signal_id: builtins.int = ..., + device_type: global___DeviceType.ValueType = ..., + ) -> None: ... + def HasField(self, field_name: typing.Literal["info", b"info"]) -> builtins.bool: ... + def ClearField(self, field_name: typing.Literal["custom_type", b"custom_type", "device_type", b"device_type", "info", b"info", "io", b"io", "signal_id", b"signal_id"]) -> None: ... + +global___Signal = Signal diff --git a/exporter/SynthesisFusionAddin/src/Proto/types_pb2.pyi b/exporter/SynthesisFusionAddin/src/Proto/types_pb2.pyi new file mode 100644 index 000000000..446356734 --- /dev/null +++ b/exporter/SynthesisFusionAddin/src/Proto/types_pb2.pyi @@ -0,0 +1,315 @@ +""" +@generated by mypy-protobuf. Do not edit manually! +isort:skip_file +Common data type implementations +Intended to be re-used +""" + +import builtins +import collections.abc +import google.protobuf.descriptor +import google.protobuf.internal.containers +import google.protobuf.internal.enum_type_wrapper +import google.protobuf.message +import sys +import typing + +if sys.version_info >= (3, 10): + import typing as typing_extensions +else: + import typing_extensions + +DESCRIPTOR: google.protobuf.descriptor.FileDescriptor + +class _Axis: + ValueType = typing.NewType("ValueType", builtins.int) + V: typing_extensions.TypeAlias = ValueType + +class _AxisEnumTypeWrapper(google.protobuf.internal.enum_type_wrapper._EnumTypeWrapper[_Axis.ValueType], builtins.type): + DESCRIPTOR: google.protobuf.descriptor.EnumDescriptor + X: _Axis.ValueType # 0 + Y: _Axis.ValueType # 1 + Z: _Axis.ValueType # 2 + +class Axis(_Axis, metaclass=_AxisEnumTypeWrapper): + """Axis Enum""" + +X: Axis.ValueType # 0 +Y: Axis.ValueType # 1 +Z: Axis.ValueType # 2 +global___Axis = Axis + +@typing.final +class Node(google.protobuf.message.Message): + """Each proper object within the Graph - First one is Root""" + + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + VALUE_FIELD_NUMBER: builtins.int + CHILDREN_FIELD_NUMBER: builtins.int + USER_DATA_FIELD_NUMBER: builtins.int + value: builtins.str + """/ the reference ID for whatever kind of graph this is""" + @property + def children(self) -> google.protobuf.internal.containers.RepeatedCompositeFieldContainer[global___Node]: + """/ the children for the given leaf""" + + @property + def user_data(self) -> global___UserData: + """/ other associated data that can be used""" + + def __init__( + self, + *, + value: builtins.str = ..., + children: collections.abc.Iterable[global___Node] | None = ..., + user_data: global___UserData | None = ..., + ) -> None: ... + def HasField(self, field_name: typing.Literal["user_data", b"user_data"]) -> builtins.bool: ... + def ClearField(self, field_name: typing.Literal["children", b"children", "user_data", b"user_data", "value", b"value"]) -> None: ... + +global___Node = Node + +@typing.final +class GraphContainer(google.protobuf.message.Message): + """Top level GraphContainer + Contains all Graph element roots within + """ + + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + NODES_FIELD_NUMBER: builtins.int + @property + def nodes(self) -> google.protobuf.internal.containers.RepeatedCompositeFieldContainer[global___Node]: + """represents the root of each seperate assembly - most of the time 1 node""" + + def __init__( + self, + *, + nodes: collections.abc.Iterable[global___Node] | None = ..., + ) -> None: ... + def ClearField(self, field_name: typing.Literal["nodes", b"nodes"]) -> None: ... + +global___GraphContainer = GraphContainer + +@typing.final +class UserData(google.protobuf.message.Message): + """* + UserData + + Arbitrary data to append to a given message in map form + """ + + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + @typing.final + class DataEntry(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + KEY_FIELD_NUMBER: builtins.int + VALUE_FIELD_NUMBER: builtins.int + key: builtins.str + value: builtins.str + def __init__( + self, + *, + key: builtins.str = ..., + value: builtins.str = ..., + ) -> None: ... + def ClearField(self, field_name: typing.Literal["key", b"key", "value", b"value"]) -> None: ... + + DATA_FIELD_NUMBER: builtins.int + @property + def data(self) -> google.protobuf.internal.containers.ScalarMap[builtins.str, builtins.str]: + """/ e.g. data["wheel"] = "yes" """ + + def __init__( + self, + *, + data: collections.abc.Mapping[builtins.str, builtins.str] | None = ..., + ) -> None: ... + def ClearField(self, field_name: typing.Literal["data", b"data"]) -> None: ... + +global___UserData = UserData + +@typing.final +class Vector3(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + X_FIELD_NUMBER: builtins.int + Y_FIELD_NUMBER: builtins.int + Z_FIELD_NUMBER: builtins.int + x: builtins.float + y: builtins.float + z: builtins.float + def __init__( + self, + *, + x: builtins.float = ..., + y: builtins.float = ..., + z: builtins.float = ..., + ) -> None: ... + def ClearField(self, field_name: typing.Literal["x", b"x", "y", b"y", "z", b"z"]) -> None: ... + +global___Vector3 = Vector3 + +@typing.final +class PhysicalProperties(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + DENSITY_FIELD_NUMBER: builtins.int + MASS_FIELD_NUMBER: builtins.int + VOLUME_FIELD_NUMBER: builtins.int + AREA_FIELD_NUMBER: builtins.int + COM_FIELD_NUMBER: builtins.int + density: builtins.float + """/ kg per cubic cm kg/(cm^3)""" + mass: builtins.float + """/ kg""" + volume: builtins.float + """/ cm^3""" + area: builtins.float + """/ cm^2""" + @property + def com(self) -> global___Vector3: + """/ non-negative? Vec3""" + + def __init__( + self, + *, + density: builtins.float = ..., + mass: builtins.float = ..., + volume: builtins.float = ..., + area: builtins.float = ..., + com: global___Vector3 | None = ..., + ) -> None: ... + def HasField(self, field_name: typing.Literal["com", b"com"]) -> builtins.bool: ... + def ClearField(self, field_name: typing.Literal["area", b"area", "com", b"com", "density", b"density", "mass", b"mass", "volume", b"volume"]) -> None: ... + +global___PhysicalProperties = PhysicalProperties + +@typing.final +class Transform(google.protobuf.message.Message): + """* + Transform + + Data needed to apply scale, position, and rotational changes + """ + + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + SPATIAL_MATRIX_FIELD_NUMBER: builtins.int + @property + def spatial_matrix(self) -> google.protobuf.internal.containers.RepeatedScalarFieldContainer[builtins.float]: + """ + flat map of 4x4 transform matrix + [00][01][02][03][10][11][12][13][20][21][22][23] + """ + + def __init__( + self, + *, + spatial_matrix: collections.abc.Iterable[builtins.float] | None = ..., + ) -> None: ... + def ClearField(self, field_name: typing.Literal["spatial_matrix", b"spatial_matrix"]) -> None: ... + +global___Transform = Transform + +@typing.final +class Color(google.protobuf.message.Message): + """RGBA in expanded form 0-255""" + + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + R_FIELD_NUMBER: builtins.int + G_FIELD_NUMBER: builtins.int + B_FIELD_NUMBER: builtins.int + A_FIELD_NUMBER: builtins.int + R: builtins.int + """red""" + G: builtins.int + """green""" + B: builtins.int + """blue""" + A: builtins.int + """alpha""" + def __init__( + self, + *, + R: builtins.int = ..., + G: builtins.int = ..., + B: builtins.int = ..., + A: builtins.int = ..., + ) -> None: ... + def ClearField(self, field_name: typing.Literal["A", b"A", "B", b"B", "G", b"G", "R", b"R"]) -> None: ... + +global___Color = Color + +@typing.final +class Info(google.protobuf.message.Message): + """* + Defines basic fields for almost all objects + The location where you can access the GUID for a reference + """ + + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + GUID_FIELD_NUMBER: builtins.int + NAME_FIELD_NUMBER: builtins.int + VERSION_FIELD_NUMBER: builtins.int + GUID: builtins.str + """GUID unique value - must always be defined + since guid's have exactly 128bits could be represented with bytes[] + however endian becomes an issue + """ + name: builtins.str + """Generic readable name""" + version: builtins.int + """Version of object iteration""" + def __init__( + self, + *, + GUID: builtins.str = ..., + name: builtins.str = ..., + version: builtins.int = ..., + ) -> None: ... + def ClearField(self, field_name: typing.Literal["GUID", b"GUID", "name", b"name", "version", b"version"]) -> None: ... + +global___Info = Info + +@typing.final +class Thumbnail(google.protobuf.message.Message): + """* + A basic Thumbnail to be encoded in the file + Most of the Time Fusion can encode the file with transparency as PNG not bitmap + """ + + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + WIDTH_FIELD_NUMBER: builtins.int + HEIGHT_FIELD_NUMBER: builtins.int + EXTENSION_FIELD_NUMBER: builtins.int + TRANSPARENT_FIELD_NUMBER: builtins.int + DATA_FIELD_NUMBER: builtins.int + width: builtins.int + """/ Image Width""" + height: builtins.int + """/ Image Height""" + extension: builtins.str + """/ Image Extension - ex. (.png, .bitmap, .jpeg)""" + transparent: builtins.bool + """/ Transparency - true from fusion when correctly configured""" + data: builtins.bytes + """/ Data as read from the file in bytes[] form""" + def __init__( + self, + *, + width: builtins.int = ..., + height: builtins.int = ..., + extension: builtins.str = ..., + transparent: builtins.bool = ..., + data: builtins.bytes = ..., + ) -> None: ... + def ClearField(self, field_name: typing.Literal["data", b"data", "extension", b"extension", "height", b"height", "transparent", b"transparent", "width", b"width"]) -> None: ... + +global___Thumbnail = Thumbnail