First pass at editor GUI

.gitignore

@@ -21,3 +21,6 @@ sponza*
 
 # Ignore compiled shaders
 *.spv
+
+# Checking in a socket is probably a terrible idea
+*.socket

.vscode/settings.json

@@ -6,5 +6,9 @@
     "files.insertFinalNewline": true,
     "files.trimFinalNewlines": true,
     "files.trimTrailingWhitespace": true,
-    "webgl-glsl-editor.format.placeSpaceAfterKeywords": true
+    "webgl-glsl-editor.format.placeSpaceAfterKeywords": true,
+    "rust-analyzer.check.extraArgs": [
+        "--target-dir",
+        "C:/windows/temp/rust-analyzer-check"
+    ],
 }

.vscode/tasks.json

@@ -98,8 +98,17 @@
 			"label": "Run Hotham simple scene on the simulator",
 			"group": {
 				"kind": "test",
-				"isDefault": true,
+				"isDefault": false,
 			}
 		},
+		{
+			"label": "Test OpenXR Client",
+			"type": "shell",
+			"command": "./hotham-openxr-client/test.ps1",
+			"group": {
+				"kind": "test",
+				"isDefault": true,
+			}
+		}
 	]
 }

Cargo.toml

@@ -9,6 +9,9 @@ members = [
   "hotham-asset-client",
   "hotham-asset-server",
   "hotham-simulator",
+  "hotham-editor",
+  "hotham-editor-protocol",
+  "hotham-openxr-client",
   "hotham",
 ]
 

examples/simple-scene/Cargo.toml

@@ -12,7 +12,9 @@ name = "hotham_simple_scene_example"
 path = "src/main.rs"
 
 [dependencies]
+env_logger = "0.10.0"
 hotham = {path = "../../hotham"}
+log = "0.4.17"
 
 [target.'cfg(target_os = "android")'.dependencies]
 ndk-glue = "0.6"

examples/simple-scene/src/lib.rs

@@ -9,6 +9,7 @@ use hotham::{
     },
     xr, Engine, HothamResult, TickData,
 };
+use log::info;
 
 #[derive(Clone, Debug, Default)]
 /// Most Hotham applications will want to keep track of some sort of state.
@@ -24,9 +25,20 @@ pub fn main() {
 }
 
 pub fn real_main() -> HothamResult<()> {
+    let _ = env_logger::builder()
+        .filter_module("hotham-openxr-client", log::LevelFilter::Trace)
+        .filter_module("simple_scene_example", log::LevelFilter::Trace)
+        .init();
+
+    println!("Hello!");
+    info!("Building engine..");
     let mut engine = Engine::new();
+    info!("..done!");
+
+    info!("Initialising app..");
     let mut state = Default::default();
     init(&mut engine)?;
+    info!("Done! Entering main loop..");
 
     while let Ok(tick_data) = engine.update() {
         tick(tick_data, &mut engine, &mut state);

hotham-editor-protocol/Cargo.toml

@@ -0,0 +1,10 @@
+[package]
+name = "hotham-editor-protocol"
+version = "0.1.0"
+edition = "2021"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]
+ash = "0.37.2"
+openxr-sys = "0.9.3"

hotham-editor-protocol/README.md

@@ -0,0 +1,39 @@
+# Hotham Editor Protocol
+## Why?
+Whenever two programs want to talk to eachother, the most complicated question is *where is the protocol defined?*. Sometimes the protocol is inferred from the way the programs serialise and deserialise their messages, but this leads to all sorts of problems.
+
+In essence, this is a *contract* problem. What is the contract, where is it, and how is it enforced?
+
+For more on this topic, we can, as always, defer to [Joe Armstrong (RIP)](https://www.youtube.com/watch?v=ed7A7r6DBsM).
+
+## How?
+Simple. We define:
+
+- What the messages of the protocol are
+- A means to **encode** them to bytes
+- A means to **decode** them to bytes
+
+We can even take that a step further and define FSMs (as Joe would suggest), but that is future work.
+
+
+## Examples
+Let's say we're using Unix sockets:
+
+```rust
+let socket = UnixStream::connect("hotham_editor.socket").unwrap();
+let client = EditorClient::new(socket); // woah, generics
+
+let view_configuration = client.request(&requests::GetViewConfiguration {}).unwrap(); // view_configuration is the correct type!!
+```
+
+This magic is made possible through the `Request` trait:
+
+```rust
+pub trait Request {
+    /// What should the response to this request be?
+    type Response: Clone;
+
+    /// Get a `RequestType` tag that we can use to identify requests
+    fn request_type(&self) -> RequestType;
+}
+```