508 lines
14 KiB
Rust
508 lines
14 KiB
Rust
// automatically generated by the FlatBuffers compiler, do not modify
|
|
|
|
|
|
pub mod my_game {
|
|
#![allow(dead_code)]
|
|
#![allow(unused_imports)]
|
|
|
|
use std::mem;
|
|
use std::marker::PhantomData;
|
|
use std::cmp::Ordering;
|
|
|
|
extern crate flatbuffers;
|
|
use self::flatbuffers::EndianScalar;
|
|
pub mod sample {
|
|
#![allow(dead_code)]
|
|
#![allow(unused_imports)]
|
|
|
|
use std::mem;
|
|
use std::marker::PhantomData;
|
|
use std::cmp::Ordering;
|
|
|
|
extern crate flatbuffers;
|
|
use self::flatbuffers::EndianScalar;
|
|
|
|
#[allow(non_camel_case_types)]
|
|
#[repr(i8)]
|
|
#[derive(Clone, Copy, PartialEq, Debug)]
|
|
pub enum Color {
|
|
Red = 0,
|
|
Green = 1,
|
|
Blue = 2
|
|
}
|
|
|
|
const ENUM_MIN_COLOR: i8 = 0;
|
|
const ENUM_MAX_COLOR: i8 = 2;
|
|
|
|
impl<'a> flatbuffers::Follow<'a> for Color {
|
|
type Inner = Self;
|
|
#[inline]
|
|
fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
|
|
flatbuffers::read_scalar_at::<Self>(buf, loc)
|
|
}
|
|
}
|
|
|
|
impl flatbuffers::EndianScalar for Color {
|
|
#[inline]
|
|
fn to_little_endian(self) -> Self {
|
|
let n = i8::to_le(self as i8);
|
|
let p = &n as *const i8 as *const Color;
|
|
unsafe { *p }
|
|
}
|
|
#[inline]
|
|
fn from_little_endian(self) -> Self {
|
|
let n = i8::from_le(self as i8);
|
|
let p = &n as *const i8 as *const Color;
|
|
unsafe { *p }
|
|
}
|
|
}
|
|
|
|
impl flatbuffers::Push for Color {
|
|
type Output = Color;
|
|
#[inline]
|
|
fn push(&self, dst: &mut [u8], _rest: &[u8]) {
|
|
flatbuffers::emplace_scalar::<Color>(dst, *self);
|
|
}
|
|
}
|
|
|
|
#[allow(non_camel_case_types)]
|
|
const ENUM_VALUES_COLOR:[Color; 3] = [
|
|
Color::Red,
|
|
Color::Green,
|
|
Color::Blue
|
|
];
|
|
|
|
#[allow(non_camel_case_types)]
|
|
const ENUM_NAMES_COLOR:[&'static str; 3] = [
|
|
"Red",
|
|
"Green",
|
|
"Blue"
|
|
];
|
|
|
|
pub fn enum_name_color(e: Color) -> &'static str {
|
|
let index: usize = e as usize;
|
|
ENUM_NAMES_COLOR[index]
|
|
}
|
|
|
|
#[allow(non_camel_case_types)]
|
|
#[repr(u8)]
|
|
#[derive(Clone, Copy, PartialEq, Debug)]
|
|
pub enum Equipment {
|
|
NONE = 0,
|
|
Weapon = 1
|
|
}
|
|
|
|
const ENUM_MIN_EQUIPMENT: u8 = 0;
|
|
const ENUM_MAX_EQUIPMENT: u8 = 1;
|
|
|
|
impl<'a> flatbuffers::Follow<'a> for Equipment {
|
|
type Inner = Self;
|
|
#[inline]
|
|
fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
|
|
flatbuffers::read_scalar_at::<Self>(buf, loc)
|
|
}
|
|
}
|
|
|
|
impl flatbuffers::EndianScalar for Equipment {
|
|
#[inline]
|
|
fn to_little_endian(self) -> Self {
|
|
let n = u8::to_le(self as u8);
|
|
let p = &n as *const u8 as *const Equipment;
|
|
unsafe { *p }
|
|
}
|
|
#[inline]
|
|
fn from_little_endian(self) -> Self {
|
|
let n = u8::from_le(self as u8);
|
|
let p = &n as *const u8 as *const Equipment;
|
|
unsafe { *p }
|
|
}
|
|
}
|
|
|
|
impl flatbuffers::Push for Equipment {
|
|
type Output = Equipment;
|
|
#[inline]
|
|
fn push(&self, dst: &mut [u8], _rest: &[u8]) {
|
|
flatbuffers::emplace_scalar::<Equipment>(dst, *self);
|
|
}
|
|
}
|
|
|
|
#[allow(non_camel_case_types)]
|
|
const ENUM_VALUES_EQUIPMENT:[Equipment; 2] = [
|
|
Equipment::NONE,
|
|
Equipment::Weapon
|
|
];
|
|
|
|
#[allow(non_camel_case_types)]
|
|
const ENUM_NAMES_EQUIPMENT:[&'static str; 2] = [
|
|
"NONE",
|
|
"Weapon"
|
|
];
|
|
|
|
pub fn enum_name_equipment(e: Equipment) -> &'static str {
|
|
let index: usize = e as usize;
|
|
ENUM_NAMES_EQUIPMENT[index]
|
|
}
|
|
|
|
pub struct EquipmentUnionTableOffset {}
|
|
// struct Vec3, aligned to 4
|
|
#[repr(C, align(4))]
|
|
#[derive(Clone, Copy, Debug, PartialEq)]
|
|
pub struct Vec3 {
|
|
x_: f32,
|
|
y_: f32,
|
|
z_: f32,
|
|
} // pub struct Vec3
|
|
impl flatbuffers::SafeSliceAccess for Vec3 {}
|
|
impl<'a> flatbuffers::Follow<'a> for Vec3 {
|
|
type Inner = &'a Vec3;
|
|
#[inline]
|
|
fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
|
|
<&'a Vec3>::follow(buf, loc)
|
|
//flatbuffers::follow_cast_ref::<Vec3>(buf, loc)
|
|
}
|
|
}
|
|
impl<'a> flatbuffers::Follow<'a> for &'a Vec3 {
|
|
type Inner = &'a Vec3;
|
|
#[inline]
|
|
fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
|
|
flatbuffers::follow_cast_ref::<Vec3>(buf, loc)
|
|
}
|
|
}
|
|
impl<'b> flatbuffers::Push for Vec3 {
|
|
type Output = Vec3;
|
|
#[inline]
|
|
fn push(&self, dst: &mut [u8], _rest: &[u8]) {
|
|
let src = unsafe {
|
|
::std::slice::from_raw_parts(self as *const Vec3 as *const u8, Self::size())
|
|
};
|
|
dst.copy_from_slice(src);
|
|
}
|
|
}
|
|
impl<'b> flatbuffers::Push for &'b Vec3 {
|
|
type Output = Vec3;
|
|
|
|
#[inline]
|
|
fn push(&self, dst: &mut [u8], _rest: &[u8]) {
|
|
let src = unsafe {
|
|
::std::slice::from_raw_parts(*self as *const Vec3 as *const u8, Self::size())
|
|
};
|
|
dst.copy_from_slice(src);
|
|
}
|
|
}
|
|
|
|
|
|
impl Vec3 {
|
|
pub fn new<'a>(_x: f32, _y: f32, _z: f32) -> Self {
|
|
Vec3 {
|
|
x_: _x.to_little_endian(),
|
|
y_: _y.to_little_endian(),
|
|
z_: _z.to_little_endian(),
|
|
|
|
}
|
|
}
|
|
pub fn x<'a>(&'a self) -> f32 {
|
|
self.x_.from_little_endian()
|
|
}
|
|
pub fn y<'a>(&'a self) -> f32 {
|
|
self.y_.from_little_endian()
|
|
}
|
|
pub fn z<'a>(&'a self) -> f32 {
|
|
self.z_.from_little_endian()
|
|
}
|
|
}
|
|
|
|
pub enum MonsterOffset {}
|
|
#[derive(Copy, Clone, Debug, PartialEq)]
|
|
|
|
pub struct Monster<'a> {
|
|
pub _tab: flatbuffers::Table<'a>,
|
|
}
|
|
|
|
impl<'a> flatbuffers::Follow<'a> for Monster<'a> {
|
|
type Inner = Monster<'a>;
|
|
#[inline]
|
|
fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
|
|
Self {
|
|
_tab: flatbuffers::Table { buf: buf, loc: loc },
|
|
}
|
|
}
|
|
}
|
|
|
|
impl<'a> Monster<'a> {
|
|
#[inline]
|
|
pub fn init_from_table(table: flatbuffers::Table<'a>) -> Self {
|
|
Monster {
|
|
_tab: table,
|
|
}
|
|
}
|
|
#[allow(unused_mut)]
|
|
pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr>(
|
|
_fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr>,
|
|
args: &'args MonsterArgs<'args>) -> flatbuffers::WIPOffset<Monster<'bldr>> {
|
|
let mut builder = MonsterBuilder::new(_fbb);
|
|
if let Some(x) = args.equipped { builder.add_equipped(x); }
|
|
if let Some(x) = args.weapons { builder.add_weapons(x); }
|
|
if let Some(x) = args.inventory { builder.add_inventory(x); }
|
|
if let Some(x) = args.name { builder.add_name(x); }
|
|
if let Some(x) = args.pos { builder.add_pos(x); }
|
|
builder.add_hp(args.hp);
|
|
builder.add_mana(args.mana);
|
|
builder.add_equipped_type(args.equipped_type);
|
|
builder.add_color(args.color);
|
|
builder.finish()
|
|
}
|
|
|
|
pub const VT_POS: flatbuffers::VOffsetT = 4;
|
|
pub const VT_MANA: flatbuffers::VOffsetT = 6;
|
|
pub const VT_HP: flatbuffers::VOffsetT = 8;
|
|
pub const VT_NAME: flatbuffers::VOffsetT = 10;
|
|
pub const VT_INVENTORY: flatbuffers::VOffsetT = 14;
|
|
pub const VT_COLOR: flatbuffers::VOffsetT = 16;
|
|
pub const VT_WEAPONS: flatbuffers::VOffsetT = 18;
|
|
pub const VT_EQUIPPED_TYPE: flatbuffers::VOffsetT = 20;
|
|
pub const VT_EQUIPPED: flatbuffers::VOffsetT = 22;
|
|
|
|
#[inline]
|
|
pub fn pos(&'a self) -> Option<&'a Vec3> {
|
|
self._tab.get::<Vec3>(Monster::VT_POS, None)
|
|
}
|
|
#[inline]
|
|
pub fn mana(&'a self) -> i16 {
|
|
self._tab.get::<i16>(Monster::VT_MANA, Some(150)).unwrap()
|
|
}
|
|
#[inline]
|
|
pub fn hp(&'a self) -> i16 {
|
|
self._tab.get::<i16>(Monster::VT_HP, Some(100)).unwrap()
|
|
}
|
|
#[inline]
|
|
pub fn name(&'a self) -> Option<&'a str> {
|
|
self._tab.get::<flatbuffers::ForwardsUOffset<&str>>(Monster::VT_NAME, None)
|
|
}
|
|
#[inline]
|
|
pub fn inventory(&'a self) -> Option<&'a [u8]> {
|
|
self._tab.get::<flatbuffers::ForwardsUOffset<flatbuffers::Vector<'a, u8>>>(Monster::VT_INVENTORY, None).map(|v| v.safe_slice())
|
|
}
|
|
#[inline]
|
|
pub fn color(&'a self) -> Color {
|
|
self._tab.get::<Color>(Monster::VT_COLOR, Some(Color::Blue)).unwrap()
|
|
}
|
|
#[inline]
|
|
pub fn weapons(&'a self) -> Option<flatbuffers::Vector<flatbuffers::ForwardsUOffset<Weapon<'a>>>> {
|
|
self._tab.get::<flatbuffers::ForwardsUOffset<flatbuffers::Vector<flatbuffers::ForwardsUOffset<Weapon<'a>>>>>(Monster::VT_WEAPONS, None)
|
|
}
|
|
#[inline]
|
|
pub fn equipped_type(&'a self) -> Equipment {
|
|
self._tab.get::<Equipment>(Monster::VT_EQUIPPED_TYPE, Some(Equipment::NONE)).unwrap()
|
|
}
|
|
#[inline]
|
|
pub fn equipped(&'a self) -> Option<flatbuffers::Table<'a>> {
|
|
self._tab.get::<flatbuffers::ForwardsUOffset<flatbuffers::Table<'a>>>(Monster::VT_EQUIPPED, None)
|
|
}
|
|
#[inline]
|
|
#[allow(non_snake_case)]
|
|
pub fn equipped_as_weapon(&'a self) -> Option<Weapon> {
|
|
if self.equipped_type() == Equipment::Weapon {
|
|
self.equipped().map(|u| Weapon::init_from_table(u))
|
|
} else {
|
|
None
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
pub struct MonsterArgs<'a> {
|
|
pub pos: Option<&'a Vec3>,
|
|
pub mana: i16,
|
|
pub hp: i16,
|
|
pub name: Option<flatbuffers::WIPOffset<&'a str>>,
|
|
pub inventory: Option<flatbuffers::WIPOffset<flatbuffers::Vector<'a , u8>>>,
|
|
pub color: Color,
|
|
pub weapons: Option<flatbuffers::WIPOffset<flatbuffers::Vector<'a , flatbuffers::ForwardsUOffset<Weapon<'a >>>>>,
|
|
pub equipped_type: Equipment,
|
|
pub equipped: Option<flatbuffers::WIPOffset<flatbuffers::UnionWIPOffset>>,
|
|
}
|
|
impl<'a> Default for MonsterArgs<'a> {
|
|
#[inline]
|
|
fn default() -> Self {
|
|
MonsterArgs {
|
|
pos: None,
|
|
mana: 150,
|
|
hp: 100,
|
|
name: None,
|
|
inventory: None,
|
|
color: Color::Blue,
|
|
weapons: None,
|
|
equipped_type: Equipment::NONE,
|
|
equipped: None,
|
|
}
|
|
}
|
|
}
|
|
pub struct MonsterBuilder<'a: 'b, 'b> {
|
|
fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>,
|
|
start_: flatbuffers::WIPOffset<flatbuffers::TableUnfinishedWIPOffset>,
|
|
}
|
|
impl<'a: 'b, 'b> MonsterBuilder<'a, 'b> {
|
|
#[inline]
|
|
pub fn add_pos(&mut self, pos: &'b Vec3) {
|
|
self.fbb_.push_slot_always::<&Vec3>(Monster::VT_POS, pos);
|
|
}
|
|
#[inline]
|
|
pub fn add_mana(&mut self, mana: i16) {
|
|
self.fbb_.push_slot::<i16>(Monster::VT_MANA, mana, 150);
|
|
}
|
|
#[inline]
|
|
pub fn add_hp(&mut self, hp: i16) {
|
|
self.fbb_.push_slot::<i16>(Monster::VT_HP, hp, 100);
|
|
}
|
|
#[inline]
|
|
pub fn add_name(&mut self, name: flatbuffers::WIPOffset<&'b str>) {
|
|
self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(Monster::VT_NAME, name);
|
|
}
|
|
#[inline]
|
|
pub fn add_inventory(&mut self, inventory: flatbuffers::WIPOffset<flatbuffers::Vector<'b , u8>>) {
|
|
self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(Monster::VT_INVENTORY, inventory);
|
|
}
|
|
#[inline]
|
|
pub fn add_color(&mut self, color: Color) {
|
|
self.fbb_.push_slot::<Color>(Monster::VT_COLOR, color, Color::Blue);
|
|
}
|
|
#[inline]
|
|
pub fn add_weapons(&mut self, weapons: flatbuffers::WIPOffset<flatbuffers::Vector<'b , flatbuffers::ForwardsUOffset<Weapon<'b >>>>) {
|
|
self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(Monster::VT_WEAPONS, weapons);
|
|
}
|
|
#[inline]
|
|
pub fn add_equipped_type(&mut self, equipped_type: Equipment) {
|
|
self.fbb_.push_slot::<Equipment>(Monster::VT_EQUIPPED_TYPE, equipped_type, Equipment::NONE);
|
|
}
|
|
#[inline]
|
|
pub fn add_equipped(&mut self, equipped: flatbuffers::WIPOffset<flatbuffers::UnionWIPOffset>) {
|
|
self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(Monster::VT_EQUIPPED, equipped);
|
|
}
|
|
#[inline]
|
|
pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>) -> MonsterBuilder<'a, 'b> {
|
|
let start = _fbb.start_table();
|
|
MonsterBuilder {
|
|
fbb_: _fbb,
|
|
start_: start,
|
|
}
|
|
}
|
|
#[inline]
|
|
pub fn finish(self) -> flatbuffers::WIPOffset<Monster<'a>> {
|
|
let o = self.fbb_.end_table(self.start_);
|
|
flatbuffers::WIPOffset::new(o.value())
|
|
}
|
|
}
|
|
|
|
pub enum WeaponOffset {}
|
|
#[derive(Copy, Clone, Debug, PartialEq)]
|
|
|
|
pub struct Weapon<'a> {
|
|
pub _tab: flatbuffers::Table<'a>,
|
|
}
|
|
|
|
impl<'a> flatbuffers::Follow<'a> for Weapon<'a> {
|
|
type Inner = Weapon<'a>;
|
|
#[inline]
|
|
fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
|
|
Self {
|
|
_tab: flatbuffers::Table { buf: buf, loc: loc },
|
|
}
|
|
}
|
|
}
|
|
|
|
impl<'a> Weapon<'a> {
|
|
#[inline]
|
|
pub fn init_from_table(table: flatbuffers::Table<'a>) -> Self {
|
|
Weapon {
|
|
_tab: table,
|
|
}
|
|
}
|
|
#[allow(unused_mut)]
|
|
pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr>(
|
|
_fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr>,
|
|
args: &'args WeaponArgs<'args>) -> flatbuffers::WIPOffset<Weapon<'bldr>> {
|
|
let mut builder = WeaponBuilder::new(_fbb);
|
|
if let Some(x) = args.name { builder.add_name(x); }
|
|
builder.add_damage(args.damage);
|
|
builder.finish()
|
|
}
|
|
|
|
pub const VT_NAME: flatbuffers::VOffsetT = 4;
|
|
pub const VT_DAMAGE: flatbuffers::VOffsetT = 6;
|
|
|
|
#[inline]
|
|
pub fn name(&'a self) -> Option<&'a str> {
|
|
self._tab.get::<flatbuffers::ForwardsUOffset<&str>>(Weapon::VT_NAME, None)
|
|
}
|
|
#[inline]
|
|
pub fn damage(&'a self) -> i16 {
|
|
self._tab.get::<i16>(Weapon::VT_DAMAGE, Some(0)).unwrap()
|
|
}
|
|
}
|
|
|
|
pub struct WeaponArgs<'a> {
|
|
pub name: Option<flatbuffers::WIPOffset<&'a str>>,
|
|
pub damage: i16,
|
|
}
|
|
impl<'a> Default for WeaponArgs<'a> {
|
|
#[inline]
|
|
fn default() -> Self {
|
|
WeaponArgs {
|
|
name: None,
|
|
damage: 0,
|
|
}
|
|
}
|
|
}
|
|
pub struct WeaponBuilder<'a: 'b, 'b> {
|
|
fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>,
|
|
start_: flatbuffers::WIPOffset<flatbuffers::TableUnfinishedWIPOffset>,
|
|
}
|
|
impl<'a: 'b, 'b> WeaponBuilder<'a, 'b> {
|
|
#[inline]
|
|
pub fn add_name(&mut self, name: flatbuffers::WIPOffset<&'b str>) {
|
|
self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(Weapon::VT_NAME, name);
|
|
}
|
|
#[inline]
|
|
pub fn add_damage(&mut self, damage: i16) {
|
|
self.fbb_.push_slot::<i16>(Weapon::VT_DAMAGE, damage, 0);
|
|
}
|
|
#[inline]
|
|
pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>) -> WeaponBuilder<'a, 'b> {
|
|
let start = _fbb.start_table();
|
|
WeaponBuilder {
|
|
fbb_: _fbb,
|
|
start_: start,
|
|
}
|
|
}
|
|
#[inline]
|
|
pub fn finish(self) -> flatbuffers::WIPOffset<Weapon<'a>> {
|
|
let o = self.fbb_.end_table(self.start_);
|
|
flatbuffers::WIPOffset::new(o.value())
|
|
}
|
|
}
|
|
|
|
#[inline]
|
|
pub fn get_root_as_monster<'a>(buf: &'a [u8]) -> Monster<'a> {
|
|
flatbuffers::get_root::<Monster<'a>>(buf)
|
|
}
|
|
|
|
#[inline]
|
|
pub fn get_size_prefixed_root_as_monster<'a>(buf: &'a [u8]) -> Monster<'a> {
|
|
flatbuffers::get_size_prefixed_root::<Monster<'a>>(buf)
|
|
}
|
|
|
|
#[inline]
|
|
pub fn finish_monster_buffer<'a, 'b>(
|
|
fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>,
|
|
root: flatbuffers::WIPOffset<Monster<'a>>) {
|
|
fbb.finish(root, None);
|
|
}
|
|
|
|
#[inline]
|
|
pub fn finish_size_prefixed_monster_buffer<'a, 'b>(fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>, root: flatbuffers::WIPOffset<Monster<'a>>) {
|
|
fbb.finish_size_prefixed(root, None);
|
|
}
|
|
} // pub mod Sample
|
|
} // pub mod MyGame
|
|
|