byte-engine 0.1.0

A composable Rust game engine focused on graphics, input, audio, physics, and retained UI.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104

//! Creates connected replication endpoints as a networking smoke test.

use std::time::Instant;

use byte_engine::{
	core::factory::Factory,
	network::{channel::ChannelServer as Server, Replicable},
	space::Positionable,
};
use math::Vector3;
use serde::{Deserialize, Serialize};

fn main() {
	// let mut server_app = byte_engine::application::graphics::GraphicsApplication::new(
	// 	"Server",
	// 	&[
	// 		Parameter::new("kill-after", "60"),
	// 		Parameter::new("render.ghi.features.mesh-shading", "false"), // Many devices don't support this feature and it is not necessary for this test.
	// 	],
	// );

	// let mut client_a_app = byte_engine::application::graphics::GraphicsApplication::new(
	// 	"Client A",
	// 	&[
	// 		Parameter::new("kill-after", "60"),
	// 		Parameter::new("render.ghi.features.mesh-shading", "false"), // Many devices don't support this feature and it is not necessary for this test.
	// 	],
	// );

	// let mut client_b_app = byte_engine::application::graphics::GraphicsApplication::new(
	// 	"Client B",
	// 	&[
	// 		Parameter::new("kill-after", "60"),
	// 		Parameter::new("render.ghi.features.mesh-shading", "false"), // Many devices don't support this feature and it is not necessary for this test.
	// 	],
	// );

	let mut server = Server::new();
	let mut client_a = server.client();
	let mut client_b = server.client();

	client_a.connect(Instant::now());
	client_b.connect(Instant::now());

	let mut update = || {
		client_a.update().unwrap();
		client_b.update().unwrap();
		server.update(Instant::now()).unwrap();
	};

	let mut replicable_factory = Factory::new();

	let a = Object {
		position: Vector3::new(0.5f32, 0.5f32, 0.5f32),
	};

	replicable_factory.create(a);

	update();
	update();
	update();

	let mut data = [0u8; 1024];
	data[0] = Commands::Spawn as u8;

	server.send(true, data);

	client_a.update().unwrap();
	client_b.update().unwrap();
	server.update(Instant::now()).unwrap();

	for packet in server.drain_received() {
		if packet.data[0] == Commands::Spawn as u8 {
			println!("Requested spawn");
		}
	}
}

#[repr(u8)]
#[derive(Debug, Clone, Serialize, Deserialize)]
enum Commands {
	Spawn,
}

#[derive(Clone)]
struct Object {
	position: Vector3,
}

impl Positionable for Object {
	fn position(&self) -> Vector3 {
		self.position
	}

	fn set_position(&mut self, position: Vector3) {
		self.position = position;
	}
}

impl Replicable for Object {
	fn payload(&self) -> &u8 {
		todo!()
	}
}