From 44dbd7fd7fca140f98bfdc33f73782a841de3105 Mon Sep 17 00:00:00 2001 From: Ruben van de Ven Date: Fri, 31 Oct 2025 15:41:25 +0100 Subject: [PATCH] build with prost --- build.rs | 5 + src/trap/renderable.proto | 49 ++ src/trap/renderable.rs | 1366 +++++++++++++++++++++++++++++++++++++ 3 files changed, 1420 insertions(+) create mode 100644 build.rs create mode 100644 src/trap/renderable.proto create mode 100644 src/trap/renderable.rs diff --git a/build.rs b/build.rs new file mode 100644 index 0000000..22ef880 --- /dev/null +++ b/build.rs @@ -0,0 +1,5 @@ +use std::io::Result; +fn main() -> Result<()> { + prost_build::compile_protos(&["src/trap/renderable.proto"], &["src/"])?; + Ok(()) +} diff --git a/src/trap/renderable.proto b/src/trap/renderable.proto new file mode 100644 index 0000000..07c3a96 --- /dev/null +++ b/src/trap/renderable.proto @@ -0,0 +1,49 @@ +syntax = "proto3"; + +package renderable; + +// Enum for coordinate spaces +enum CoordinateSpace { + UNDEFINED=0; + CAMERA = 1; + UNDISTORTED_CAMERA = 2; + WORLD = 3; + LASER = 4; +} + +// Message for RenderablePosition (Tuple[float, float]) +message RenderablePosition { + float x = 1; + float y = 2; +} + +// Message for SrgbaColor +message SrgbaColor { + float red = 1; + float green = 2; + float blue = 3; + float alpha = 4; +} + +// Message for RenderablePoint +message RenderablePoint { + RenderablePosition position = 1; + SrgbaColor color = 2; +} + +// Message for RenderableLine +message RenderableLine { + repeated RenderablePoint points = 1; +} + +// Message for RenderableLines +message RenderableLines { + repeated RenderableLine lines = 1; + CoordinateSpace space = 2; +} + +// Message to represent RenderableLayers (Dict[int, RenderableLines]) +message RenderableLayers { + map layers = 1; +} + diff --git a/src/trap/renderable.rs b/src/trap/renderable.rs new file mode 100644 index 0000000..b0486de --- /dev/null +++ b/src/trap/renderable.rs @@ -0,0 +1,1366 @@ +// This file is generated by rust-protobuf 2.27.1. Do not edit +// @generated + +// https://github.com/rust-lang/rust-clippy/issues/702 +#![allow(unknown_lints)] +#![allow(clippy::all)] + +#![allow(unused_attributes)] +#![cfg_attr(rustfmt, rustfmt::skip)] + +#![allow(box_pointers)] +#![allow(dead_code)] +#![allow(missing_docs)] +#![allow(non_camel_case_types)] +#![allow(non_snake_case)] +#![allow(non_upper_case_globals)] +#![allow(trivial_casts)] +#![allow(unused_imports)] +#![allow(unused_results)] +//! Generated file from `renderable.proto` + +/// Generated files are compatible only with the same version +/// of protobuf runtime. +// const _PROTOBUF_VERSION_CHECK: () = ::protobuf::VERSION_2_27_1; + +#[derive(PartialEq,Clone,Default)] +pub struct RenderablePosition { + // message fields + pub x: f32, + pub y: f32, + // special fields + pub unknown_fields: ::protobuf::UnknownFields, + pub cached_size: ::protobuf::CachedSize, +} + +impl<'a> ::std::default::Default for &'a RenderablePosition { + fn default() -> &'a RenderablePosition { + ::default_instance() + } +} + +impl RenderablePosition { + pub fn new() -> RenderablePosition { + ::std::default::Default::default() + } + + // float x = 1; + + + pub fn get_x(&self) -> f32 { + self.x + } + pub fn clear_x(&mut self) { + self.x = 0.; + } + + // Param is passed by value, moved + pub fn set_x(&mut self, v: f32) { + self.x = v; + } + + // float y = 2; + + + pub fn get_y(&self) -> f32 { + self.y + } + pub fn clear_y(&mut self) { + self.y = 0.; + } + + // Param is passed by value, moved + pub fn set_y(&mut self, v: f32) { + self.y = v; + } +} + +impl ::protobuf::Message for RenderablePosition { + fn is_initialized(&self) -> bool { + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> { + while !is.eof()? { + let (field_number, wire_type) = is.read_tag_unpack()?; + match field_number { + 1 => { + if wire_type != ::protobuf::wire_format::WireTypeFixed32 { + return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); + } + let tmp = is.read_float()?; + self.x = tmp; + }, + 2 => { + if wire_type != ::protobuf::wire_format::WireTypeFixed32 { + return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); + } + let tmp = is.read_float()?; + self.y = tmp; + }, + _ => { + ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + if self.x != 0. { + my_size += 5; + } + if self.y != 0. { + my_size += 5; + } + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> { + if self.x != 0. { + os.write_float(1, self.x)?; + } + if self.y != 0. { + os.write_float(2, self.y)?; + } + os.write_unknown_fields(self.get_unknown_fields())?; + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn as_any(&self) -> &dyn (::std::any::Any) { + self as &dyn (::std::any::Any) + } + fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) { + self as &mut dyn (::std::any::Any) + } + fn into_any(self: ::std::boxed::Box) -> ::std::boxed::Box { + self + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + + fn new() -> RenderablePosition { + RenderablePosition::new() + } + + fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor { + static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT; + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeFloat>( + "x", + |m: &RenderablePosition| { &m.x }, + |m: &mut RenderablePosition| { &mut m.x }, + )); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeFloat>( + "y", + |m: &RenderablePosition| { &m.y }, + |m: &mut RenderablePosition| { &mut m.y }, + )); + ::protobuf::reflect::MessageDescriptor::new_pb_name::( + "RenderablePosition", + fields, + file_descriptor_proto() + ) + }) + } + + fn default_instance() -> &'static RenderablePosition { + static instance: ::protobuf::rt::LazyV2 = ::protobuf::rt::LazyV2::INIT; + instance.get(RenderablePosition::new) + } +} + +impl ::protobuf::Clear for RenderablePosition { + fn clear(&mut self) { + self.x = 0.; + self.y = 0.; + self.unknown_fields.clear(); + } +} + +impl ::std::fmt::Debug for RenderablePosition { + fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +impl ::protobuf::reflect::ProtobufValue for RenderablePosition { + fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef { + ::protobuf::reflect::ReflectValueRef::Message(self) + } +} + +#[derive(PartialEq,Clone,Default)] +pub struct SrgbaColor { + // message fields + pub red: f32, + pub green: f32, + pub blue: f32, + pub alpha: f32, + // special fields + pub unknown_fields: ::protobuf::UnknownFields, + pub cached_size: ::protobuf::CachedSize, +} + +impl<'a> ::std::default::Default for &'a SrgbaColor { + fn default() -> &'a SrgbaColor { + ::default_instance() + } +} + +impl SrgbaColor { + pub fn new() -> SrgbaColor { + ::std::default::Default::default() + } + + // float red = 1; + + + pub fn get_red(&self) -> f32 { + self.red + } + pub fn clear_red(&mut self) { + self.red = 0.; + } + + // Param is passed by value, moved + pub fn set_red(&mut self, v: f32) { + self.red = v; + } + + // float green = 2; + + + pub fn get_green(&self) -> f32 { + self.green + } + pub fn clear_green(&mut self) { + self.green = 0.; + } + + // Param is passed by value, moved + pub fn set_green(&mut self, v: f32) { + self.green = v; + } + + // float blue = 3; + + + pub fn get_blue(&self) -> f32 { + self.blue + } + pub fn clear_blue(&mut self) { + self.blue = 0.; + } + + // Param is passed by value, moved + pub fn set_blue(&mut self, v: f32) { + self.blue = v; + } + + // float alpha = 4; + + + pub fn get_alpha(&self) -> f32 { + self.alpha + } + pub fn clear_alpha(&mut self) { + self.alpha = 0.; + } + + // Param is passed by value, moved + pub fn set_alpha(&mut self, v: f32) { + self.alpha = v; + } +} + +impl ::protobuf::Message for SrgbaColor { + fn is_initialized(&self) -> bool { + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> { + while !is.eof()? { + let (field_number, wire_type) = is.read_tag_unpack()?; + match field_number { + 1 => { + if wire_type != ::protobuf::wire_format::WireTypeFixed32 { + return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); + } + let tmp = is.read_float()?; + self.red = tmp; + }, + 2 => { + if wire_type != ::protobuf::wire_format::WireTypeFixed32 { + return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); + } + let tmp = is.read_float()?; + self.green = tmp; + }, + 3 => { + if wire_type != ::protobuf::wire_format::WireTypeFixed32 { + return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); + } + let tmp = is.read_float()?; + self.blue = tmp; + }, + 4 => { + if wire_type != ::protobuf::wire_format::WireTypeFixed32 { + return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); + } + let tmp = is.read_float()?; + self.alpha = tmp; + }, + _ => { + ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + if self.red != 0. { + my_size += 5; + } + if self.green != 0. { + my_size += 5; + } + if self.blue != 0. { + my_size += 5; + } + if self.alpha != 0. { + my_size += 5; + } + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> { + if self.red != 0. { + os.write_float(1, self.red)?; + } + if self.green != 0. { + os.write_float(2, self.green)?; + } + if self.blue != 0. { + os.write_float(3, self.blue)?; + } + if self.alpha != 0. { + os.write_float(4, self.alpha)?; + } + os.write_unknown_fields(self.get_unknown_fields())?; + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn as_any(&self) -> &dyn (::std::any::Any) { + self as &dyn (::std::any::Any) + } + fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) { + self as &mut dyn (::std::any::Any) + } + fn into_any(self: ::std::boxed::Box) -> ::std::boxed::Box { + self + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + + fn new() -> SrgbaColor { + SrgbaColor::new() + } + + fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor { + static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT; + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeFloat>( + "red", + |m: &SrgbaColor| { &m.red }, + |m: &mut SrgbaColor| { &mut m.red }, + )); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeFloat>( + "green", + |m: &SrgbaColor| { &m.green }, + |m: &mut SrgbaColor| { &mut m.green }, + )); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeFloat>( + "blue", + |m: &SrgbaColor| { &m.blue }, + |m: &mut SrgbaColor| { &mut m.blue }, + )); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeFloat>( + "alpha", + |m: &SrgbaColor| { &m.alpha }, + |m: &mut SrgbaColor| { &mut m.alpha }, + )); + ::protobuf::reflect::MessageDescriptor::new_pb_name::( + "SrgbaColor", + fields, + file_descriptor_proto() + ) + }) + } + + fn default_instance() -> &'static SrgbaColor { + static instance: ::protobuf::rt::LazyV2 = ::protobuf::rt::LazyV2::INIT; + instance.get(SrgbaColor::new) + } +} + +impl ::protobuf::Clear for SrgbaColor { + fn clear(&mut self) { + self.red = 0.; + self.green = 0.; + self.blue = 0.; + self.alpha = 0.; + self.unknown_fields.clear(); + } +} + +impl ::std::fmt::Debug for SrgbaColor { + fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +impl ::protobuf::reflect::ProtobufValue for SrgbaColor { + fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef { + ::protobuf::reflect::ReflectValueRef::Message(self) + } +} + +#[derive(PartialEq,Clone,Default)] +pub struct RenderablePoint { + // message fields + pub position: ::protobuf::SingularPtrField, + pub color: ::protobuf::SingularPtrField, + // special fields + pub unknown_fields: ::protobuf::UnknownFields, + pub cached_size: ::protobuf::CachedSize, +} + +impl<'a> ::std::default::Default for &'a RenderablePoint { + fn default() -> &'a RenderablePoint { + ::default_instance() + } +} + +impl RenderablePoint { + pub fn new() -> RenderablePoint { + ::std::default::Default::default() + } + + // .renderable.RenderablePosition position = 1; + + + pub fn get_position(&self) -> &RenderablePosition { + self.position.as_ref().unwrap_or_else(|| ::default_instance()) + } + pub fn clear_position(&mut self) { + self.position.clear(); + } + + pub fn has_position(&self) -> bool { + self.position.is_some() + } + + // Param is passed by value, moved + pub fn set_position(&mut self, v: RenderablePosition) { + self.position = ::protobuf::SingularPtrField::some(v); + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_position(&mut self) -> &mut RenderablePosition { + if self.position.is_none() { + self.position.set_default(); + } + self.position.as_mut().unwrap() + } + + // Take field + pub fn take_position(&mut self) -> RenderablePosition { + self.position.take().unwrap_or_else(|| RenderablePosition::new()) + } + + // .renderable.SrgbaColor color = 2; + + + pub fn get_color(&self) -> &SrgbaColor { + self.color.as_ref().unwrap_or_else(|| ::default_instance()) + } + pub fn clear_color(&mut self) { + self.color.clear(); + } + + pub fn has_color(&self) -> bool { + self.color.is_some() + } + + // Param is passed by value, moved + pub fn set_color(&mut self, v: SrgbaColor) { + self.color = ::protobuf::SingularPtrField::some(v); + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_color(&mut self) -> &mut SrgbaColor { + if self.color.is_none() { + self.color.set_default(); + } + self.color.as_mut().unwrap() + } + + // Take field + pub fn take_color(&mut self) -> SrgbaColor { + self.color.take().unwrap_or_else(|| SrgbaColor::new()) + } +} + +impl ::protobuf::Message for RenderablePoint { + fn is_initialized(&self) -> bool { + for v in &self.position { + if !v.is_initialized() { + return false; + } + }; + for v in &self.color { + if !v.is_initialized() { + return false; + } + }; + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> { + while !is.eof()? { + let (field_number, wire_type) = is.read_tag_unpack()?; + match field_number { + 1 => { + ::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.position)?; + }, + 2 => { + ::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.color)?; + }, + _ => { + ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + if let Some(ref v) = self.position.as_ref() { + let len = v.compute_size(); + my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + } + if let Some(ref v) = self.color.as_ref() { + let len = v.compute_size(); + my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + } + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> { + if let Some(ref v) = self.position.as_ref() { + os.write_tag(1, ::protobuf::wire_format::WireTypeLengthDelimited)?; + os.write_raw_varint32(v.get_cached_size())?; + v.write_to_with_cached_sizes(os)?; + } + if let Some(ref v) = self.color.as_ref() { + os.write_tag(2, ::protobuf::wire_format::WireTypeLengthDelimited)?; + os.write_raw_varint32(v.get_cached_size())?; + v.write_to_with_cached_sizes(os)?; + } + os.write_unknown_fields(self.get_unknown_fields())?; + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn as_any(&self) -> &dyn (::std::any::Any) { + self as &dyn (::std::any::Any) + } + fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) { + self as &mut dyn (::std::any::Any) + } + fn into_any(self: ::std::boxed::Box) -> ::std::boxed::Box { + self + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + + fn new() -> RenderablePoint { + RenderablePoint::new() + } + + fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor { + static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT; + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage>( + "position", + |m: &RenderablePoint| { &m.position }, + |m: &mut RenderablePoint| { &mut m.position }, + )); + fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage>( + "color", + |m: &RenderablePoint| { &m.color }, + |m: &mut RenderablePoint| { &mut m.color }, + )); + ::protobuf::reflect::MessageDescriptor::new_pb_name::( + "RenderablePoint", + fields, + file_descriptor_proto() + ) + }) + } + + fn default_instance() -> &'static RenderablePoint { + static instance: ::protobuf::rt::LazyV2 = ::protobuf::rt::LazyV2::INIT; + instance.get(RenderablePoint::new) + } +} + +impl ::protobuf::Clear for RenderablePoint { + fn clear(&mut self) { + self.position.clear(); + self.color.clear(); + self.unknown_fields.clear(); + } +} + +impl ::std::fmt::Debug for RenderablePoint { + fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +impl ::protobuf::reflect::ProtobufValue for RenderablePoint { + fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef { + ::protobuf::reflect::ReflectValueRef::Message(self) + } +} + +#[derive(PartialEq,Clone,Default)] +pub struct RenderableLine { + // message fields + pub points: ::protobuf::RepeatedField, + // special fields + pub unknown_fields: ::protobuf::UnknownFields, + pub cached_size: ::protobuf::CachedSize, +} + +impl<'a> ::std::default::Default for &'a RenderableLine { + fn default() -> &'a RenderableLine { + ::default_instance() + } +} + +impl RenderableLine { + pub fn new() -> RenderableLine { + ::std::default::Default::default() + } + + // repeated .renderable.RenderablePoint points = 1; + + + pub fn get_points(&self) -> &[RenderablePoint] { + &self.points + } + pub fn clear_points(&mut self) { + self.points.clear(); + } + + // Param is passed by value, moved + pub fn set_points(&mut self, v: ::protobuf::RepeatedField) { + self.points = v; + } + + // Mutable pointer to the field. + pub fn mut_points(&mut self) -> &mut ::protobuf::RepeatedField { + &mut self.points + } + + // Take field + pub fn take_points(&mut self) -> ::protobuf::RepeatedField { + ::std::mem::replace(&mut self.points, ::protobuf::RepeatedField::new()) + } +} + +impl ::protobuf::Message for RenderableLine { + fn is_initialized(&self) -> bool { + for v in &self.points { + if !v.is_initialized() { + return false; + } + }; + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> { + while !is.eof()? { + let (field_number, wire_type) = is.read_tag_unpack()?; + match field_number { + 1 => { + ::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.points)?; + }, + _ => { + ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + for value in &self.points { + let len = value.compute_size(); + my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + }; + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> { + for v in &self.points { + os.write_tag(1, ::protobuf::wire_format::WireTypeLengthDelimited)?; + os.write_raw_varint32(v.get_cached_size())?; + v.write_to_with_cached_sizes(os)?; + }; + os.write_unknown_fields(self.get_unknown_fields())?; + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn as_any(&self) -> &dyn (::std::any::Any) { + self as &dyn (::std::any::Any) + } + fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) { + self as &mut dyn (::std::any::Any) + } + fn into_any(self: ::std::boxed::Box) -> ::std::boxed::Box { + self + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + + fn new() -> RenderableLine { + RenderableLine::new() + } + + fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor { + static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT; + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage>( + "points", + |m: &RenderableLine| { &m.points }, + |m: &mut RenderableLine| { &mut m.points }, + )); + ::protobuf::reflect::MessageDescriptor::new_pb_name::( + "RenderableLine", + fields, + file_descriptor_proto() + ) + }) + } + + fn default_instance() -> &'static RenderableLine { + static instance: ::protobuf::rt::LazyV2 = ::protobuf::rt::LazyV2::INIT; + instance.get(RenderableLine::new) + } +} + +impl ::protobuf::Clear for RenderableLine { + fn clear(&mut self) { + self.points.clear(); + self.unknown_fields.clear(); + } +} + +impl ::std::fmt::Debug for RenderableLine { + fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +impl ::protobuf::reflect::ProtobufValue for RenderableLine { + fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef { + ::protobuf::reflect::ReflectValueRef::Message(self) + } +} + +#[derive(PartialEq,Clone,Default)] +pub struct RenderableLines { + // message fields + pub lines: ::protobuf::RepeatedField, + pub space: CoordinateSpace, + // special fields + pub unknown_fields: ::protobuf::UnknownFields, + pub cached_size: ::protobuf::CachedSize, +} + +impl<'a> ::std::default::Default for &'a RenderableLines { + fn default() -> &'a RenderableLines { + ::default_instance() + } +} + +impl RenderableLines { + pub fn new() -> RenderableLines { + ::std::default::Default::default() + } + + // repeated .renderable.RenderableLine lines = 1; + + + pub fn get_lines(&self) -> &[RenderableLine] { + &self.lines + } + pub fn clear_lines(&mut self) { + self.lines.clear(); + } + + // Param is passed by value, moved + pub fn set_lines(&mut self, v: ::protobuf::RepeatedField) { + self.lines = v; + } + + // Mutable pointer to the field. + pub fn mut_lines(&mut self) -> &mut ::protobuf::RepeatedField { + &mut self.lines + } + + // Take field + pub fn take_lines(&mut self) -> ::protobuf::RepeatedField { + ::std::mem::replace(&mut self.lines, ::protobuf::RepeatedField::new()) + } + + // .renderable.CoordinateSpace space = 2; + + + pub fn get_space(&self) -> CoordinateSpace { + self.space + } + pub fn clear_space(&mut self) { + self.space = CoordinateSpace::UNDEFINED; + } + + // Param is passed by value, moved + pub fn set_space(&mut self, v: CoordinateSpace) { + self.space = v; + } +} + +impl ::protobuf::Message for RenderableLines { + fn is_initialized(&self) -> bool { + for v in &self.lines { + if !v.is_initialized() { + return false; + } + }; + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> { + while !is.eof()? { + let (field_number, wire_type) = is.read_tag_unpack()?; + match field_number { + 1 => { + ::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.lines)?; + }, + 2 => { + ::protobuf::rt::read_proto3_enum_with_unknown_fields_into(wire_type, is, &mut self.space, 2, &mut self.unknown_fields)? + }, + _ => { + ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + for value in &self.lines { + let len = value.compute_size(); + my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + }; + if self.space != CoordinateSpace::UNDEFINED { + my_size += ::protobuf::rt::enum_size(2, self.space); + } + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> { + for v in &self.lines { + os.write_tag(1, ::protobuf::wire_format::WireTypeLengthDelimited)?; + os.write_raw_varint32(v.get_cached_size())?; + v.write_to_with_cached_sizes(os)?; + }; + if self.space != CoordinateSpace::UNDEFINED { + os.write_enum(2, ::protobuf::ProtobufEnum::value(&self.space))?; + } + os.write_unknown_fields(self.get_unknown_fields())?; + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn as_any(&self) -> &dyn (::std::any::Any) { + self as &dyn (::std::any::Any) + } + fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) { + self as &mut dyn (::std::any::Any) + } + fn into_any(self: ::std::boxed::Box) -> ::std::boxed::Box { + self + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + + fn new() -> RenderableLines { + RenderableLines::new() + } + + fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor { + static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT; + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage>( + "lines", + |m: &RenderableLines| { &m.lines }, + |m: &mut RenderableLines| { &mut m.lines }, + )); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeEnum>( + "space", + |m: &RenderableLines| { &m.space }, + |m: &mut RenderableLines| { &mut m.space }, + )); + ::protobuf::reflect::MessageDescriptor::new_pb_name::( + "RenderableLines", + fields, + file_descriptor_proto() + ) + }) + } + + fn default_instance() -> &'static RenderableLines { + static instance: ::protobuf::rt::LazyV2 = ::protobuf::rt::LazyV2::INIT; + instance.get(RenderableLines::new) + } +} + +impl ::protobuf::Clear for RenderableLines { + fn clear(&mut self) { + self.lines.clear(); + self.space = CoordinateSpace::UNDEFINED; + self.unknown_fields.clear(); + } +} + +impl ::std::fmt::Debug for RenderableLines { + fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +impl ::protobuf::reflect::ProtobufValue for RenderableLines { + fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef { + ::protobuf::reflect::ReflectValueRef::Message(self) + } +} + +#[derive(PartialEq,Clone,Default)] +pub struct RenderableLayers { + // message fields + pub layers: ::std::collections::HashMap, + // special fields + pub unknown_fields: ::protobuf::UnknownFields, + pub cached_size: ::protobuf::CachedSize, +} + +impl<'a> ::std::default::Default for &'a RenderableLayers { + fn default() -> &'a RenderableLayers { + ::default_instance() + } +} + +impl RenderableLayers { + pub fn new() -> RenderableLayers { + ::std::default::Default::default() + } + + // repeated .renderable.RenderableLayers.LayersEntry layers = 1; + + + pub fn get_layers(&self) -> &::std::collections::HashMap { + &self.layers + } + pub fn clear_layers(&mut self) { + self.layers.clear(); + } + + // Param is passed by value, moved + pub fn set_layers(&mut self, v: ::std::collections::HashMap) { + self.layers = v; + } + + // Mutable pointer to the field. + pub fn mut_layers(&mut self) -> &mut ::std::collections::HashMap { + &mut self.layers + } + + // Take field + pub fn take_layers(&mut self) -> ::std::collections::HashMap { + ::std::mem::replace(&mut self.layers, ::std::collections::HashMap::new()) + } +} + +impl ::protobuf::Message for RenderableLayers { + fn is_initialized(&self) -> bool { + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> { + while !is.eof()? { + let (field_number, wire_type) = is.read_tag_unpack()?; + match field_number { + 1 => { + ::protobuf::rt::read_map_into::<::protobuf::types::ProtobufTypeInt32, ::protobuf::types::ProtobufTypeMessage>(wire_type, is, &mut self.layers)?; + }, + _ => { + ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + my_size += ::protobuf::rt::compute_map_size::<::protobuf::types::ProtobufTypeInt32, ::protobuf::types::ProtobufTypeMessage>(1, &self.layers); + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> { + ::protobuf::rt::write_map_with_cached_sizes::<::protobuf::types::ProtobufTypeInt32, ::protobuf::types::ProtobufTypeMessage>(1, &self.layers, os)?; + os.write_unknown_fields(self.get_unknown_fields())?; + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn as_any(&self) -> &dyn (::std::any::Any) { + self as &dyn (::std::any::Any) + } + fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) { + self as &mut dyn (::std::any::Any) + } + fn into_any(self: ::std::boxed::Box) -> ::std::boxed::Box { + self + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + + fn new() -> RenderableLayers { + RenderableLayers::new() + } + + fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor { + static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT; + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_map_accessor::<_, ::protobuf::types::ProtobufTypeInt32, ::protobuf::types::ProtobufTypeMessage>( + "layers", + |m: &RenderableLayers| { &m.layers }, + |m: &mut RenderableLayers| { &mut m.layers }, + )); + ::protobuf::reflect::MessageDescriptor::new_pb_name::( + "RenderableLayers", + fields, + file_descriptor_proto() + ) + }) + } + + fn default_instance() -> &'static RenderableLayers { + static instance: ::protobuf::rt::LazyV2 = ::protobuf::rt::LazyV2::INIT; + instance.get(RenderableLayers::new) + } +} + +impl ::protobuf::Clear for RenderableLayers { + fn clear(&mut self) { + self.layers.clear(); + self.unknown_fields.clear(); + } +} + +impl ::std::fmt::Debug for RenderableLayers { + fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +impl ::protobuf::reflect::ProtobufValue for RenderableLayers { + fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef { + ::protobuf::reflect::ReflectValueRef::Message(self) + } +} + +#[derive(Clone,PartialEq,Eq,Debug,Hash)] +pub enum CoordinateSpace { + UNDEFINED = 0, + CAMERA = 1, + UNDISTORTED_CAMERA = 2, + WORLD = 3, + LASER = 4, +} + +impl ::protobuf::ProtobufEnum for CoordinateSpace { + fn value(&self) -> i32 { + *self as i32 + } + + fn from_i32(value: i32) -> ::std::option::Option { + match value { + 0 => ::std::option::Option::Some(CoordinateSpace::UNDEFINED), + 1 => ::std::option::Option::Some(CoordinateSpace::CAMERA), + 2 => ::std::option::Option::Some(CoordinateSpace::UNDISTORTED_CAMERA), + 3 => ::std::option::Option::Some(CoordinateSpace::WORLD), + 4 => ::std::option::Option::Some(CoordinateSpace::LASER), + _ => ::std::option::Option::None + } + } + + fn values() -> &'static [Self] { + static values: &'static [CoordinateSpace] = &[ + CoordinateSpace::UNDEFINED, + CoordinateSpace::CAMERA, + CoordinateSpace::UNDISTORTED_CAMERA, + CoordinateSpace::WORLD, + CoordinateSpace::LASER, + ]; + values + } + + fn enum_descriptor_static() -> &'static ::protobuf::reflect::EnumDescriptor { + static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::EnumDescriptor> = ::protobuf::rt::LazyV2::INIT; + descriptor.get(|| { + ::protobuf::reflect::EnumDescriptor::new_pb_name::("CoordinateSpace", file_descriptor_proto()) + }) + } +} + +impl ::std::marker::Copy for CoordinateSpace { +} + +impl ::std::default::Default for CoordinateSpace { + fn default() -> Self { + CoordinateSpace::UNDEFINED + } +} + +impl ::protobuf::reflect::ProtobufValue for CoordinateSpace { + fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef { + ::protobuf::reflect::ReflectValueRef::Enum(::protobuf::ProtobufEnum::descriptor(self)) + } +} + +static file_descriptor_proto_data: &'static [u8] = b"\ + \n\x10renderable.proto\x12\nrenderable\"0\n\x12RenderablePosition\x12\ + \x0c\n\x01x\x18\x01\x20\x01(\x02R\x01x\x12\x0c\n\x01y\x18\x02\x20\x01(\ + \x02R\x01y\"^\n\nSrgbaColor\x12\x10\n\x03red\x18\x01\x20\x01(\x02R\x03re\ + d\x12\x14\n\x05green\x18\x02\x20\x01(\x02R\x05green\x12\x12\n\x04blue\ + \x18\x03\x20\x01(\x02R\x04blue\x12\x14\n\x05alpha\x18\x04\x20\x01(\x02R\ + \x05alpha\"{\n\x0fRenderablePoint\x12:\n\x08position\x18\x01\x20\x01(\ + \x0b2\x1e.renderable.RenderablePositionR\x08position\x12,\n\x05color\x18\ + \x02\x20\x01(\x0b2\x16.renderable.SrgbaColorR\x05color\"E\n\x0eRenderabl\ + eLine\x123\n\x06points\x18\x01\x20\x03(\x0b2\x1b.renderable.RenderablePo\ + intR\x06points\"v\n\x0fRenderableLines\x120\n\x05lines\x18\x01\x20\x03(\ + \x0b2\x1a.renderable.RenderableLineR\x05lines\x121\n\x05space\x18\x02\ + \x20\x01(\x0e2\x1b.renderable.CoordinateSpaceR\x05space\"\xac\x01\n\x10R\ + enderableLayers\x12@\n\x06layers\x18\x01\x20\x03(\x0b2(.renderable.Rende\ + rableLayers.LayersEntryR\x06layers\x1aV\n\x0bLayersEntry\x12\x10\n\x03ke\ + y\x18\x01\x20\x01(\x05R\x03key\x121\n\x05value\x18\x02\x20\x01(\x0b2\x1b\ + .renderable.RenderableLinesR\x05value:\x028\x01*Z\n\x0fCoordinateSpace\ + \x12\r\n\tUNDEFINED\x10\0\x12\n\n\x06CAMERA\x10\x01\x12\x16\n\x12UNDISTO\ + RTED_CAMERA\x10\x02\x12\t\n\x05WORLD\x10\x03\x12\t\n\x05LASER\x10\x04J\ + \xd3\n\n\x06\x12\x04\0\0/\x01\n\x08\n\x01\x0c\x12\x03\0\0\x12\n\x08\n\ + \x01\x02\x12\x03\x02\0\x13\n(\n\x02\x05\0\x12\x04\x05\0\x0b\x01\x1a\x1c\ + \x20Enum\x20for\x20coordinate\x20spaces\n\n\n\n\x03\x05\0\x01\x12\x03\ + \x05\x05\x14\n\x0b\n\x04\x05\0\x02\0\x12\x03\x06\x02\x0e\n\x0c\n\x05\x05\ + \0\x02\0\x01\x12\x03\x06\x02\x0b\n\x0c\n\x05\x05\0\x02\0\x02\x12\x03\x06\ + \x0c\r\n\x0b\n\x04\x05\0\x02\x01\x12\x03\x07\x02\r\n\x0c\n\x05\x05\0\x02\ + \x01\x01\x12\x03\x07\x02\x08\n\x0c\n\x05\x05\0\x02\x01\x02\x12\x03\x07\ + \x0b\x0c\n\x0b\n\x04\x05\0\x02\x02\x12\x03\x08\x02\x19\n\x0c\n\x05\x05\0\ + \x02\x02\x01\x12\x03\x08\x02\x14\n\x0c\n\x05\x05\0\x02\x02\x02\x12\x03\ + \x08\x17\x18\n\x0b\n\x04\x05\0\x02\x03\x12\x03\t\x02\x0c\n\x0c\n\x05\x05\ + \0\x02\x03\x01\x12\x03\t\x02\x07\n\x0c\n\x05\x05\0\x02\x03\x02\x12\x03\t\ + \n\x0b\n\x0b\n\x04\x05\0\x02\x04\x12\x03\n\x02\x0c\n\x0c\n\x05\x05\0\x02\ + \x04\x01\x12\x03\n\x02\x07\n\x0c\n\x05\x05\0\x02\x04\x02\x12\x03\n\n\x0b\ + \nB\n\x02\x04\0\x12\x04\x0e\0\x11\x01\x1a6\x20Message\x20for\x20Renderab\ + lePosition\x20(Tuple[float,\x20float])\n\n\n\n\x03\x04\0\x01\x12\x03\x0e\ + \x08\x1a\n\x0b\n\x04\x04\0\x02\0\x12\x03\x0f\x02\x0e\n\x0c\n\x05\x04\0\ + \x02\0\x05\x12\x03\x0f\x02\x07\n\x0c\n\x05\x04\0\x02\0\x01\x12\x03\x0f\ + \x08\t\n\x0c\n\x05\x04\0\x02\0\x03\x12\x03\x0f\x0c\r\n\x0b\n\x04\x04\0\ + \x02\x01\x12\x03\x10\x02\x0e\n\x0c\n\x05\x04\0\x02\x01\x05\x12\x03\x10\ + \x02\x07\n\x0c\n\x05\x04\0\x02\x01\x01\x12\x03\x10\x08\t\n\x0c\n\x05\x04\ + \0\x02\x01\x03\x12\x03\x10\x0c\r\n$\n\x02\x04\x01\x12\x04\x14\0\x19\x01\ + \x1a\x18\x20Message\x20for\x20SrgbaColor\n\n\n\n\x03\x04\x01\x01\x12\x03\ + \x14\x08\x12\n\x0b\n\x04\x04\x01\x02\0\x12\x03\x15\x02\x10\n\x0c\n\x05\ + \x04\x01\x02\0\x05\x12\x03\x15\x02\x07\n\x0c\n\x05\x04\x01\x02\0\x01\x12\ + \x03\x15\x08\x0b\n\x0c\n\x05\x04\x01\x02\0\x03\x12\x03\x15\x0e\x0f\n\x0b\ + \n\x04\x04\x01\x02\x01\x12\x03\x16\x02\x12\n\x0c\n\x05\x04\x01\x02\x01\ + \x05\x12\x03\x16\x02\x07\n\x0c\n\x05\x04\x01\x02\x01\x01\x12\x03\x16\x08\ + \r\n\x0c\n\x05\x04\x01\x02\x01\x03\x12\x03\x16\x10\x11\n\x0b\n\x04\x04\ + \x01\x02\x02\x12\x03\x17\x02\x11\n\x0c\n\x05\x04\x01\x02\x02\x05\x12\x03\ + \x17\x02\x07\n\x0c\n\x05\x04\x01\x02\x02\x01\x12\x03\x17\x08\x0c\n\x0c\n\ + \x05\x04\x01\x02\x02\x03\x12\x03\x17\x0f\x10\n\x0b\n\x04\x04\x01\x02\x03\ + \x12\x03\x18\x02\x12\n\x0c\n\x05\x04\x01\x02\x03\x05\x12\x03\x18\x02\x07\ + \n\x0c\n\x05\x04\x01\x02\x03\x01\x12\x03\x18\x08\r\n\x0c\n\x05\x04\x01\ + \x02\x03\x03\x12\x03\x18\x10\x11\n)\n\x02\x04\x02\x12\x04\x1c\0\x1f\x01\ + \x1a\x1d\x20Message\x20for\x20RenderablePoint\n\n\n\n\x03\x04\x02\x01\ + \x12\x03\x1c\x08\x17\n\x0b\n\x04\x04\x02\x02\0\x12\x03\x1d\x02\"\n\x0c\n\ + \x05\x04\x02\x02\0\x06\x12\x03\x1d\x02\x14\n\x0c\n\x05\x04\x02\x02\0\x01\ + \x12\x03\x1d\x15\x1d\n\x0c\n\x05\x04\x02\x02\0\x03\x12\x03\x1d\x20!\n\ + \x0b\n\x04\x04\x02\x02\x01\x12\x03\x1e\x02\x17\n\x0c\n\x05\x04\x02\x02\ + \x01\x06\x12\x03\x1e\x02\x0c\n\x0c\n\x05\x04\x02\x02\x01\x01\x12\x03\x1e\ + \r\x12\n\x0c\n\x05\x04\x02\x02\x01\x03\x12\x03\x1e\x15\x16\n(\n\x02\x04\ + \x03\x12\x04\"\0$\x01\x1a\x1c\x20Message\x20for\x20RenderableLine\n\n\n\ + \n\x03\x04\x03\x01\x12\x03\"\x08\x16\n\x0b\n\x04\x04\x03\x02\0\x12\x03#\ + \x02&\n\x0c\n\x05\x04\x03\x02\0\x04\x12\x03#\x02\n\n\x0c\n\x05\x04\x03\ + \x02\0\x06\x12\x03#\x0b\x1a\n\x0c\n\x05\x04\x03\x02\0\x01\x12\x03#\x1b!\ + \n\x0c\n\x05\x04\x03\x02\0\x03\x12\x03#$%\n)\n\x02\x04\x04\x12\x04'\0*\ + \x01\x1a\x1d\x20Message\x20for\x20RenderableLines\n\n\n\n\x03\x04\x04\ + \x01\x12\x03'\x08\x17\n\x0b\n\x04\x04\x04\x02\0\x12\x03(\x02$\n\x0c\n\ + \x05\x04\x04\x02\0\x04\x12\x03(\x02\n\n\x0c\n\x05\x04\x04\x02\0\x06\x12\ + \x03(\x0b\x19\n\x0c\n\x05\x04\x04\x02\0\x01\x12\x03(\x1a\x1f\n\x0c\n\x05\ + \x04\x04\x02\0\x03\x12\x03(\"#\n\x0b\n\x04\x04\x04\x02\x01\x12\x03)\x02\ + \x1c\n\x0c\n\x05\x04\x04\x02\x01\x06\x12\x03)\x02\x11\n\x0c\n\x05\x04\ + \x04\x02\x01\x01\x12\x03)\x12\x17\n\x0c\n\x05\x04\x04\x02\x01\x03\x12\ + \x03)\x1a\x1b\nP\n\x02\x04\x05\x12\x04-\0/\x01\x1aD\x20Message\x20to\x20\ + represent\x20RenderableLayers\x20(Dict[int,\x20RenderableLines])\n\n\n\n\ + \x03\x04\x05\x01\x12\x03-\x08\x18\n\x0b\n\x04\x04\x05\x02\0\x12\x03.\x02\ + )\n\x0c\n\x05\x04\x05\x02\0\x06\x12\x03.\x02\x1d\n\x0c\n\x05\x04\x05\x02\ + \0\x01\x12\x03.\x1e$\n\x0c\n\x05\x04\x05\x02\0\x03\x12\x03.'(b\x06proto3\ +"; + +static file_descriptor_proto_lazy: ::protobuf::rt::LazyV2<::protobuf::descriptor::FileDescriptorProto> = ::protobuf::rt::LazyV2::INIT; + +fn parse_descriptor_proto() -> ::protobuf::descriptor::FileDescriptorProto { + ::protobuf::Message::parse_from_bytes(file_descriptor_proto_data).unwrap() +} + +pub fn file_descriptor_proto() -> &'static ::protobuf::descriptor::FileDescriptorProto { + file_descriptor_proto_lazy.get(|| { + parse_descriptor_proto() + }) +}