StardustXR/server
1
0
Fork 0
Code Issues 11 Pull Requests 3 Actions Packages Projects Releases 5 Wiki Activity

feat: upgrade stereokit

Browse Source
This commit is contained in:
Nova
2024-05-28 09:13:15 -04:00
parent 01c5ad3b04
commit eda50b7d51
27 changed files with 1498 additions and 592 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1048
Cargo.lock generated
View File

File diff suppressed because it is too large Load Diff

9
Cargo.toml
View File

@@ -44,7 +44,7 @@ lto = true
[dependencies]
color-eyre = { version = "0.6.2", default-features = false }
clap = { version = "4.2.4", features = ["derive"] }
glam = { version = "0.23.0", features = ["mint"] }
glam = { version = "0.27.0", features = ["mint", "serde"] }
lazy_static = "1.4.0"
mint = "0.5.9"
nanoid = "0.4.0"
@@ -84,13 +84,10 @@ features = [
"renderer_gl",
"wayland_frontend",
]
version = "*"
optional = true
[dependencies.stereokit]
default-features = false
features = ["linux-egl"]
version = "0.16.9"
[dependencies.stereokit-rust]
git = "https://github.com/mvvvv/StereoKit-rust.git"
[dependencies.console-subscriber]
version = "0.2.0"

142
src/main.rs
View File

@@ -26,11 +26,15 @@ use std::path::{Path, PathBuf};
use std::process::{Child, Command, Stdio};
use std::sync::Arc;
use std::time::Duration;
use stereokit::{
named_colors::BLACK, DepthMode, DisplayMode, Handed, LogLevel, StereoKitMultiThread,
TextureFormat, TextureType,
use stereokit_rust::material::Material;
use stereokit_rust::shader::Shader;
use stereokit_rust::sk::{
sk_quit, AppMode, DepthMode, DisplayBlend, DisplayMode, QuitReason, SkClosures, SkSettings,
};
use stereokit::{DisplayBlend, Sk};
use stereokit_rust::system::{Handed, LogLevel, Renderer, World};
use stereokit_rust::tex::{SHCubemap, Tex, TexFormat, TexType};
use stereokit_rust::ui::Ui;
use stereokit_rust::util::{Color128, Device, Time};
use tokio::sync::Notify;
use tokio::task::LocalSet;
use tokio::{runtime::Handle, sync::oneshot};
@@ -63,7 +67,6 @@ struct CliArgs {
}
static STARDUST_INSTANCE: OnceCell<String> = OnceCell::new();
static SK_MULTITHREAD: OnceCell<Sk> = OnceCell::new();
static STOP_NOTIFIER: Notify = Notify::const_new();
struct EventLoopInfo {
@@ -102,16 +105,16 @@ fn main() {
}
let cli_args = Arc::new(CliArgs::parse());
let sk = stereokit::Settings {
app_name: "Stardust XR".to_string(),
display_preference: if cli_args.flatscreen {
DisplayMode::Flatscreen
let (sk, sk_event_loop) = SkSettings::default()
.app_name("Stardust XR")
.mode(if cli_args.flatscreen {
AppMode::Simulator
} else {
DisplayMode::MixedReality
},
blend_preference: DisplayBlend::AnyTransparent,
depth_mode: DepthMode::D32,
log_filter: match EnvFilter::from_default_env().max_level_hint() {
AppMode::XR
})
.blend_preference(DisplayBlend::AnyTransparent)
.depth_mode(DepthMode::D32)
.log_filter(match EnvFilter::from_default_env().max_level_hint() {
Some(LevelFilter::ERROR) => LogLevel::Error,
Some(LevelFilter::WARN) => LogLevel::Warning,
Some(LevelFilter::INFO) => LogLevel::Inform,
@@ -119,46 +122,35 @@ fn main() {
Some(LevelFilter::TRACE) => LogLevel::Diagnostic,
Some(LevelFilter::OFF) => LogLevel::None,
None => LogLevel::Warning,
},
overlay_app: cli_args.overlay_priority.is_some(),
overlay_priority: cli_args.overlay_priority.unwrap_or(u32::MAX),
disable_desktop_input_window: true,
render_scaling: 2.0,
..Default::default()
}
.init()
.expect("StereoKit failed to initialize");
let _ = SK_MULTITHREAD.set(sk.multithreaded());
})
.overlay_app(cli_args.overlay_priority.is_some())
.overlay_priority(cli_args.overlay_priority.unwrap_or(u32::MAX))
.disable_desktop_input_window(true)
.render_scaling(2.0)
.init()
.expect("StereoKit failed to initialize");
info!("Init StereoKit");
sk.render_set_multisample(0);
sk.material_set_shader(
sk.material_find("default/material_pbr").unwrap(),
sk.shader_find("default/shader_pbr_clip").unwrap(),
);
Renderer::multisample(0);
Material::default().shader(Shader::pbr_clip());
Ui::enable_far_interact(false);
// Skytex/light stuff
{
if let Some((light, tex)) = project_dirs
if let Some(sky) = project_dirs
.as_ref()
.and_then(|dirs| {
let skytex_path = dirs.config_dir().join("skytex.hdr");
skytex_path
.exists()
.then(|| sk.tex_create_cubemap_file(&skytex_path, true, 100).ok())
})
.flatten()
.map(|dirs| dirs.config_dir().join("skytex.hdr"))
.filter(|f| f.exists())
.and_then(|p| SHCubemap::from_cubemap_equirectangular(p, true, 100).ok())
{
sk.render_set_skytex(&tex);
sk.render_set_skylight(light);
sky.render_as_sky();
} else {
sk.render_set_skytex(sk.tex_gen_color(
BLACK,
Renderer::skytex(Tex::gen_color(
Color128::BLACK,
1,
1,
TextureType::CUBEMAP,
TextureFormat::RGBA32,
TexType::Cubemap,
TexFormat::RGBA32,
));
}
}
@@ -170,33 +162,25 @@ fn main() {
.unwrap();
let mut hands = (!cli_args.flatscreen)
.then(|| {
let left = SkHand::new(Handed::Left, &sk).ok();
let right = SkHand::new(Handed::Right, &sk).ok();
let left = SkHand::new(Handed::Left).ok();
let right = SkHand::new(Handed::Right).ok();
left.zip(right)
})
.flatten();
let mut controllers = (!cli_args.flatscreen && !cli_args.disable_controller)
.then(|| {
let left = SkController::new(&sk, Handed::Left).ok();
let right = SkController::new(&sk, Handed::Right).ok();
let left = SkController::new(Handed::Left).ok();
let right = SkController::new(Handed::Right).ok();
left.zip(right)
})
.flatten();
let eye_pointer = (sk.active_display_mode() == DisplayMode::MixedReality
&& sk.device_has_eye_gaze())
let eye_pointer = (sk.get_active_display_mode() == DisplayMode::MixedReality
&& Device::has_eye_gaze())
.then(EyePointer::new)
.transpose()
.unwrap();
if hands.is_none() {
sk.input_hand_visible(Handed::Left, false);
sk.input_hand_visible(Handed::Right, false);
}
let play_space = sk
.world_has_bounds()
.then(|| PlaySpace::new().ok())
.flatten();
let play_space = World::has_bounds().then(|| PlaySpace::new().ok()).flatten();
let (info_sender, info_receiver) = oneshot::channel::<EventLoopInfo>();
let event_thread = std::thread::Builder::new()
@@ -229,47 +213,48 @@ fn main() {
let mut last_frame_delta = Duration::ZERO;
let mut sleep_duration = Duration::ZERO;
debug_span!("StereoKit").in_scope(|| {
sk.run(
|sk| {
SkClosures::run_app(
sk,
sk_event_loop,
|_sk, token| {
let _span = debug_span!("StereoKit step");
let _span = _span.enter();
hmd::frame(sk);
camera::update(sk);
hmd::frame();
camera::update(token);
#[cfg(feature = "wayland")]
wayland.frame_event(sk);
wayland.frame_event();
destroy_queue::clear();
if let Some(mouse_pointer) = &mut mouse_pointer {
mouse_pointer.update(sk);
mouse_pointer.update();
}
if let Some((left_hand, right_hand)) = &mut hands {
left_hand.update(!cli_args.disable_controller, sk);
right_hand.update(!cli_args.disable_controller, sk);
left_hand.update(!cli_args.disable_controller, token);
right_hand.update(!cli_args.disable_controller, token);
}
if let Some((left_controller, right_controller)) = &mut controllers {
left_controller.update(sk);
right_controller.update(sk);
left_controller.update(token);
right_controller.update(token);
}
if let Some(eye_pointer) = &eye_pointer {
eye_pointer.update(sk);
eye_pointer.update();
}
if let Some(play_space) = &play_space {
play_space.update(sk);
play_space.update();
}
input::process_input();
nodes::root::Root::send_frame_events(sk.time_elapsed_unscaled());
nodes::root::Root::send_frame_events(Time::get_step_unscaled());
adaptive_sleep(
sk,
&mut last_frame_delta,
&mut sleep_duration,
Duration::from_micros(250),
);
#[cfg(feature = "wayland")]
wayland.update(sk);
drawable::draw(sk);
audio::update(sk);
wayland.update();
drawable::draw(token);
audio::update();
#[cfg(feature = "wayland")]
wayland.make_context_current();
},
@@ -295,12 +280,11 @@ fn main() {
}
fn adaptive_sleep(
sk: &impl StereoKitMultiThread,
last_frame_delta: &mut Duration,
sleep_duration: &mut Duration,
sleep_duration_increase: Duration,
) {
let frame_delta = Duration::from_secs_f64(sk.time_elapsed_unscaled());
let frame_delta = Duration::from_secs_f64(Time::get_step_unscaled());
if *last_frame_delta < frame_delta {
if let Some(frame_delta_delta) = frame_delta.checked_sub(*last_frame_delta) {
if let Some(new_sleep_duration) = sleep_duration.checked_sub(frame_delta_delta) {
@@ -346,7 +330,7 @@ async fn event_loop(
info!("Cleanly shut down event loop");
unsafe {
stereokit::sys::sk_quit();
sk_quit(QuitReason::SystemClose);
}
Ok(())

23
src/nodes/audio.rs
View File

@@ -15,7 +15,7 @@ use stardust_xr::values::ResourceID;
use std::ops::DerefMut;
use std::sync::Arc;
use std::{ffi::OsStr, path::PathBuf};
use stereokit::{Sound as SkSound, SoundInstance, StereoKitDraw};
use stereokit_rust::sound::{Sound as SkSound, SoundInst};
static SOUND_REGISTRY: Registry<Sound> = Registry::new();
@@ -26,7 +26,7 @@ pub struct Sound {
volume: f32,
pending_audio_path: PathBuf,
sk_sound: OnceCell<SendWrapper<SkSound>>,
instance: Mutex<Option<SoundInstance>>,
instance: Mutex<Option<SoundInst>>,
stop: Mutex<Option<()>>,
play: Mutex<Option<()>>,
}
@@ -53,24 +53,21 @@ impl Sound {
Ok(sound_arc)
}
fn update(&self, sk: &impl StereoKitDraw) {
fn update(&self) {
let sound = self.sk_sound.get_or_init(|| {
SendWrapper::new(sk.sound_create(self.pending_audio_path.clone()).unwrap())
SendWrapper::new(SkSound::from_file(self.pending_audio_path.clone()).unwrap())
});
if self.stop.lock().take().is_some() {
if let Some(instance) = self.instance.lock().take() {
sk.sound_inst_stop(instance);
instance.stop();
}
}
if self.instance.lock().is_none() && self.play.lock().take().is_some() {
self.instance.lock().replace(sk.sound_play(
sound.as_ref(),
vec3(0.0, 0.0, 0.0),
self.volume,
));
let instance = sound.play(vec3(0.0, 0.0, 0.0), Some(self.volume));
self.instance.lock().replace(instance);
}
if let Some(instance) = self.instance.lock().deref_mut() {
sk.sound_inst_set_pos(*instance, self.space.global_transform().w_axis.xyz());
instance.position(self.space.global_transform().w_axis.xyz());
}
}
}
@@ -98,9 +95,9 @@ impl Drop for Sound {
}
}
pub fn update(sk: &impl StereoKitDraw) {
pub fn update() {
for sound in SOUND_REGISTRY.get_valid_contents() {
sound.update(sk)
sound.update()
}
}

BIN
src/nodes/drawable/assets/shaders/shader_unlit_gamma.hlsl.sks Normal file
View File

Binary file not shown.

BIN
src/nodes/drawable/assets/shaders/shader_unlit_simula.hlsl.sks Normal file
View File

Binary file not shown.

30
src/nodes/drawable/lines.rs
View File

@@ -4,12 +4,14 @@ use crate::{
nodes::{spatial::Spatial, Aspect, Node},
};
use color_eyre::eyre::Result;
use glam::Vec3A;
use glam::Vec3;
use parking_lot::Mutex;
use portable_atomic::{AtomicBool, Ordering};
use prisma::Lerp;
use std::{collections::VecDeque, sync::Arc};
use stereokit::{bounds_grow_to_fit_pt, Bounds, Color128, LinePoint as SkLinePoint, StereoKitDraw};
use stereokit_rust::{
maths::Bounds, sk::MainThreadToken, system::LinePoint as SkLinePoint, util::Color128,
};
static LINES_REGISTRY: Registry<Lines> = Registry::new();
@@ -29,7 +31,7 @@ impl Lines {
if let Ok(lines) = node.get_aspect::<Lines>() {
for line in &*lines.data.lock() {
for point in &line.points {
bounds = bounds_grow_to_fit_pt(bounds, point.point);
bounds.grown_point(Vec3::from(point.point));
}
}
}
@@ -47,7 +49,7 @@ impl Lines {
Ok(lines)
}
fn draw(&self, draw_ctx: &impl StereoKitDraw) {
fn draw(&self, token: &MainThreadToken) {
let transform_mat = self.space.global_transform();
let data = self.data.lock().clone();
for line in &data {
@@ -55,15 +57,9 @@ impl Lines {
.points
.iter()
.map(|p| SkLinePoint {
pt: transform_mat.transform_point3a(Vec3A::from(p.point)).into(),
pt: transform_mat.transform_point3(Vec3::from(p.point)).into(),
thickness: p.thickness,
color: stereokit::sys::color128::from([
p.color.c.r,
p.color.c.g,
p.color.c.b,
p.color.a,
])
.into(),
color: Color128::new(p.color.c.r, p.color.c.g, p.color.c.b, p.color.a).into(),
})
.collect();
if line.cyclic && !points.is_empty() {
@@ -78,9 +74,7 @@ impl Lines {
};
let connect_point = SkLinePoint {
pt: transform_mat
.transform_point3a(
Vec3A::from(first.point).lerp(Vec3A::from(last.point), 0.5),
)
.transform_point3(Vec3::from(first.point).lerp(Vec3::from(last.point), 0.5))
.into(),
thickness: (first.thickness + last.thickness) * 0.5,
color: color.into(),
@@ -88,7 +82,7 @@ impl Lines {
points.push_front(connect_point.clone());
points.push_back(connect_point);
}
draw_ctx.line_add_listv(points.make_contiguous());
stereokit_rust::system::Lines::add_list(token, points.make_contiguous());
}
}
}
@@ -108,10 +102,10 @@ impl Drop for Lines {
}
}
pub fn draw_all(draw_ctx: &impl StereoKitDraw) {
pub fn draw_all(token: &MainThreadToken) {
for lines in LINES_REGISTRY.get_valid_contents() {
if lines.enabled.load(Ordering::Relaxed) {
lines.draw(draw_ctx);
lines.draw(token);
}
}
}

18
src/nodes/drawable/mod.rs
View File

@@ -16,22 +16,22 @@ use color_eyre::eyre::{self, Result};
use parking_lot::Mutex;
use stardust_xr::values::ResourceID;
use std::{ffi::OsStr, path::PathBuf, sync::Arc};
use stereokit::StereoKitDraw;
use stereokit_rust::{sk::MainThreadToken, system::Renderer, tex::SHCubemap};
// #[instrument(level = "debug", skip(sk))]
pub fn draw(sk: &impl StereoKitDraw) {
lines::draw_all(sk);
model::draw_all(sk);
text::draw_all(sk);
pub fn draw(token: &MainThreadToken) {
lines::draw_all(token);
model::draw_all(token);
text::draw_all(token);
if let Some(skytex) = QUEUED_SKYTEX.lock().take() {
if let Ok((_skylight, skytex)) = sk.tex_create_cubemap_file(&skytex, true, i32::MAX) {
sk.render_set_skytex(&skytex);
if let Ok(skytex) = SHCubemap::from_cubemap_equirectangular(&skytex, true, 100) {
Renderer::skytex(skytex.tex);
}
}
if let Some(skylight) = QUEUED_SKYLIGHT.lock().take() {
if let Ok((skylight, _)) = sk.tex_create_cubemap_file(&skylight, true, i32::MAX) {
sk.render_set_skylight(skylight);
if let Ok(skylight) = SHCubemap::from_cubemap_equirectangular(&skylight, true, 100) {
Renderer::skylight(skylight.sh);
}
}
}

223
src/nodes/drawable/model.rs
View File

@@ -1,61 +1,54 @@
use super::{MaterialParameter, ModelAspect, ModelPartAspect, Node};
use crate::core::client::Client;
use crate::core::destroy_queue;
use crate::core::node_collections::LifeLinkedNodeMap;
use crate::core::registry::Registry;
use crate::core::resource::get_resource_file;
use crate::nodes::spatial::Spatial;
use crate::nodes::Aspect;
use crate::SK_MULTITHREAD;
use color_eyre::eyre::{eyre, Result};
use glam::{Mat4, Vec2, Vec3};
use once_cell::sync::OnceCell;
use parking_lot::Mutex;
use portable_atomic::{AtomicBool, Ordering};
use rustc_hash::FxHashMap;
use send_wrapper::SendWrapper;
use stardust_xr::values::ResourceID;
use stereokit_rust::material::Transparency;
use stereokit_rust::maths::Bounds;
use stereokit_rust::sk::MainThreadToken;
use stereokit_rust::{material::Material, model::Model as SKModel, tex::Tex, util::Color128};
use std::ffi::OsStr;
use std::path::PathBuf;
use std::sync::{Arc, Weak};
use stereokit::named_colors::WHITE;
use stereokit::{
Bounds, Color128, Material, Model as SKModel, RenderLayer, Shader, StereoKitDraw,
StereoKitMultiThread, Transparency,
};
static MODEL_REGISTRY: Registry<Model> = Registry::new();
static HOLDOUT_MATERIAL: OnceCell<Arc<Material>> = OnceCell::new();
static HOLDOUT_MATERIAL: OnceCell<Arc<SendWrapper<Material>>> = OnceCell::new();
impl MaterialParameter {
fn apply_to_material(
&self,
client: &Client,
sk: &impl StereoKitMultiThread,
material: &Material,
parameter_name: &str,
) {
fn apply_to_material(&self, client: &Client, material: &Material, parameter_name: &str) {
let mut params = material.get_all_param_info();
match self {
MaterialParameter::Bool(val) => {
sk.material_set_bool(material, parameter_name, *val);
params.set_bool(parameter_name, *val);
}
MaterialParameter::Int(val) => {
sk.material_set_int(material, parameter_name, *val);
params.set_int(parameter_name, &[*val]);
}
MaterialParameter::UInt(val) => {
sk.material_set_uint(material, parameter_name, *val);
params.set_uint(parameter_name, &[*val]);
}
MaterialParameter::Float(val) => {
sk.material_set_float(material, parameter_name, *val);
params.set_float(parameter_name, *val);
}
MaterialParameter::Vec2(val) => {
sk.material_set_vector2(material, parameter_name, *val);
params.set_vec2(parameter_name, Vec2::from(*val));
}
MaterialParameter::Vec3(val) => {
sk.material_set_vector3(material, parameter_name, *val);
params.set_vec3(parameter_name, Vec3::from(*val));
}
MaterialParameter::Color(val) => {
sk.material_set_color(
material,
params.set_color(
parameter_name,
Color128::new(val.c.r, val.c.g, val.c.b, val.a),
);
@@ -66,8 +59,8 @@ impl MaterialParameter {
else {
return;
};
if let Ok(tex) = sk.tex_create_file(texture_path, true, 0) {
sk.material_set_texture(material, parameter_name, &tex);
if let Ok(tex) = Tex::from_file(texture_path, true, None) {
params.set_texture(parameter_name, &tex);
}
}
}
@@ -80,57 +73,27 @@ pub struct ModelPart {
space: Arc<Spatial>,
model: Weak<Model>,
pending_material_parameters: Mutex<FxHashMap<String, MaterialParameter>>,
pending_material_replacement: Mutex<Option<Arc<Material>>>,
pending_material_replacement: Mutex<Option<Arc<SendWrapper<Material>>>>,
}
impl ModelPart {
fn create_for_model(sk: &impl StereoKitMultiThread, model: &Arc<Model>, sk_model: &SKModel) {
fn create_for_model(model: &Arc<Model>, sk_model: &SKModel) {
HOLDOUT_MATERIAL.get_or_init(|| {
let mat = sk.material_copy(Material::UNLIT);
sk.material_set_transparency(&mat, Transparency::None);
sk.material_set_color(
&mat,
"color",
stereokit::sys::color128 {
r: 0.0,
g: 0.0,
b: 0.0,
a: 0.0,
},
);
Arc::new(mat)
let mut mat = Material::copy(Material::unlit());
mat.transparency(Transparency::None);
mat.color_tint(Color128::BLACK_TRANSPARENT);
Arc::new(SendWrapper::new(mat))
});
let first_root_part = sk.model_node_get_root(sk_model);
let mut current_option_part = Some(first_root_part);
while let Some(current_part) = &mut current_option_part {
ModelPart::create(sk, model, sk_model, *current_part);
if let Some(child) = sk.model_node_child(sk_model, *current_part) {
*current_part = child;
} else if let Some(sibling) = sk.model_node_sibling(sk_model, *current_part) {
*current_part = sibling;
} else {
while let Some(current_part) = &mut current_option_part {
if let Some(sibling) = sk.model_node_sibling(sk_model, *current_part) {
*current_part = sibling;
break;
}
current_option_part = sk.model_node_parent(sk_model, *current_part);
}
}
let nodes = sk_model.get_nodes();
for part in nodes.all() {
ModelPart::create(model, &part);
}
}
fn create(
sk: &impl StereoKitMultiThread,
model: &Arc<Model>,
sk_model: &SKModel,
id: i32,
) -> Option<Arc<Self>> {
let parent_node = sk
.model_node_parent(sk_model, id)
.and_then(|id| model.parts.get(&id));
fn create(model: &Arc<Model>, part: &stereokit_rust::model::ModelNode) -> Option<Arc<Self>> {
let parent_node = part
.get_parent()
.and_then(|part| model.parts.get(part.get_id()));
let parent_part = parent_node
.as_ref()
.and_then(|node| node.get_aspect::<ModelPart>().ok());
@@ -138,7 +101,8 @@ impl ModelPart {
let stardust_model_part = model.space.node()?;
let client = stardust_model_part.get_client()?;
let mut part_path = parent_part.map(|n| n.path.clone()).unwrap_or_default();
part_path.push(sk.model_node_get_name(sk_model, id)?);
part_path.push(part.get_name().unwrap());
let node = client.scenegraph.add_node(Node::create_parent_name(
&client,
stardust_model_part.get_path(),
@@ -148,10 +112,12 @@ impl ModelPart {
let spatial_parent = parent_node
.and_then(|n| n.get_aspect::<Spatial>().ok())
.unwrap_or_else(|| model.space.clone());
let local_transform = unsafe { part.get_local_transform().m };
let space = Spatial::add_to(
&node,
Some(spatial_parent),
sk.model_node_get_transform_local(sk_model, id),
Mat4::from_cols_array(&local_transform),
false,
);
@@ -163,23 +129,24 @@ impl ModelPart {
let Ok(model_part) = node.get_aspect::<ModelPart>() else {
return Bounds::default();
};
let Some(sk) = SK_MULTITHREAD.get() else {
return Bounds::default();
};
let Some(model) = model_part.model.upgrade() else {
return Bounds::default();
};
let Some(sk_model) = model.sk_model.get() else {
return Bounds::default();
};
let Some(sk_mesh) = sk.model_node_get_mesh(sk_model, model_part.id) else {
let nodes = sk_model.get_nodes();
let Some(model_node) = nodes.get_index(model_part.id) else {
return Bounds::default();
};
sk.mesh_get_bounds(sk_mesh)
let Some(sk_mesh) = model_node.get_mesh() else {
return Bounds::default();
};
sk_mesh.get_bounds()
});
let model_part = Arc::new(ModelPart {
id,
id: *part.get_id(),
path: part_path,
space,
model: Arc::downgrade(model),
@@ -188,17 +155,31 @@ impl ModelPart {
});
<ModelPart as ModelPartAspect>::add_node_members(&node);
node.add_aspect_raw(model_part.clone());
model.parts.add(id, &node);
model.parts.add(*part.get_id(), &node);
Some(model_part)
}
pub fn replace_material(&self, replacement: Arc<Material>) {
pub fn replace_material(&self, replacement: Arc<SendWrapper<Material>>) {
self.pending_material_replacement
.lock()
.replace(replacement);
}
/// only to be run on the main thread
pub fn replace_material_now(&self, replacement: &Material) {
let Some(model) = self.model.upgrade() else {
return;
};
let Some(sk_model) = model.sk_model.get() else {
return;
};
let nodes = sk_model.get_nodes();
let Some(mut part) = nodes.get_index(self.id) else {
return;
};
part.material(replacement);
}
fn update(&self, sk: &impl StereoKitDraw) {
fn update(&self) {
let Some(model) = self.model.upgrade() else {
return;
};
@@ -208,28 +189,37 @@ impl ModelPart {
let Some(node) = model.space.node() else {
return;
};
let nodes = sk_model.get_nodes();
let Some(mut part) = nodes.get_index(self.id) else {
return;
};
part.model_transform(Spatial::space_to_space_matrix(
Some(&self.space),
Some(&model.space),
));
let Some(client) = node.get_client() else {
return;
};
if let Some(material_replacement) = self.pending_material_replacement.lock().take() {
sk.model_node_set_material(sk_model, self.id, material_replacement.as_ref().as_ref());
part.material(&**material_replacement);
}
let mut material_parameters = self.pending_material_parameters.lock();
for (parameter_name, parameter_value) in material_parameters.drain() {
let Some(material) = sk.model_node_get_material(sk_model, self.id) else {
continue;
};
let new_material = sk.material_copy(material);
parameter_value.apply_to_material(&client, sk, &new_material, parameter_name.as_str());
sk.model_node_set_material(sk_model, self.id, &new_material);
// todo: find all materials with identical parameters and batch them into 1 material again
'mat_params: {
let mut material_parameters = self.pending_material_parameters.lock();
if !material_parameters.is_empty() {
let Some(material) = part.get_material() else {
break 'mat_params;
};
let new_material = Material::copy(&material);
part.material(&new_material);
for (parameter_name, parameter_value) in material_parameters.drain() {
parameter_value.apply_to_material(&client, &new_material, &parameter_name);
}
}
}
sk.model_node_set_transform_model(
sk_model,
self.id,
Spatial::space_to_space_matrix(Some(&self.space), Some(&model.space)),
);
}
}
impl Aspect for ModelPart {
@@ -261,15 +251,12 @@ impl ModelPartAspect for ModelPart {
}
pub struct Model {
self_ref: Weak<Model>,
enabled: Arc<AtomicBool>,
space: Arc<Spatial>,
_resource_id: ResourceID,
sk_model: OnceCell<SKModel>,
parts: LifeLinkedNodeMap<i32>,
}
unsafe impl Send for Model {}
unsafe impl Sync for Model {}
impl Model {
pub fn add_to(node: &Arc<Node>, resource_id: ResourceID) -> Result<Arc<Model>> {
@@ -280,8 +267,7 @@ impl Model {
)
.ok_or_else(|| eyre!("Resource not found"))?;
let model = Arc::new_cyclic(|self_ref| Model {
self_ref: self_ref.clone(),
let model = Arc::new(Model {
enabled: node.enabled.clone(),
space: node.get_aspect::<Spatial>().unwrap().clone(),
_resource_id: resource_id,
@@ -290,51 +276,50 @@ impl Model {
});
MODEL_REGISTRY.add_raw(&model);
let sk = SK_MULTITHREAD.get().unwrap();
let sk_model = sk.model_copy(
sk.model_create_file(pending_model_path.to_str().unwrap(), None::<Shader>)?,
);
ModelPart::create_for_model(sk, &model.self_ref.upgrade().unwrap(), &sk_model);
// technically doing this in anything but the main thread isn't a good idea but dangit we need those model nodes ASAP
let sk_model = SKModel::copy(SKModel::from_file(
pending_model_path.to_str().unwrap(),
None,
)?);
ModelPart::create_for_model(&model, &sk_model);
let _ = model.sk_model.set(sk_model);
node.add_aspect_raw(model.clone());
Ok(model)
}
fn draw(&self, sk: &impl StereoKitDraw) {
fn draw(&self, token: &MainThreadToken) {
let Some(sk_model) = self.sk_model.get() else {
return;
};
for model_node_node in self.parts.nodes() {
if let Ok(model_node) = model_node_node.get_aspect::<ModelPart>() {
model_node.update(sk);
model_node.update();
};
}
sk.model_draw(
sk_model,
self.space.global_transform(),
WHITE,
RenderLayer::LAYER0,
);
if self.enabled.load(Ordering::Relaxed) {
sk_model.draw(token, self.space.global_transform(), None, None);
}
}
}
// TODO: proper hread safety in stereokit_rust (probably just bind stereokit directly)
unsafe impl Send for Model {}
unsafe impl Sync for Model {}
impl Aspect for Model {
const NAME: &'static str = "Model";
}
impl ModelAspect for Model {}
impl Drop for Model {
fn drop(&mut self) {
if let Some(sk_model) = self.sk_model.take() {
destroy_queue::add(sk_model);
}
// if let Some(sk_model) = self.sk_model.take() {
// destroy_queue::add(sk_model);
// }
MODEL_REGISTRY.remove(self);
}
}
pub fn draw_all(sk: &impl StereoKitDraw) {
pub fn draw_all(token: &MainThreadToken) {
for model in MODEL_REGISTRY.get_valid_contents() {
if model.enabled.load(Ordering::Relaxed) {
model.draw(sk);
}
model.draw(token);
}
}

6
src/nodes/drawable/shaders/mod.rs → src/nodes/drawable/shaders.rs
View File

@@ -4,14 +4,14 @@ use smithay::backend::renderer::gles::{
GlesError,
};
use std::mem::transmute;
use stereokit::Shader;
use stereokit_rust::shader::Shader;
use tracing::error;
// Simula shader with fancy lanzcos sampling
pub const UNLIT_SHADER_BYTES: &[u8] = include_bytes!("shader_unlit_gamma.sks");
pub const UNLIT_SHADER_BYTES: &[u8] = include_bytes!("assets/shaders/shader_unlit_gamma.hlsl.sks");
// Simula shader with fancy lanzcos sampling
pub const PANEL_SHADER_BYTES: &[u8] = include_bytes!("shader_unlit_simula.sks");
pub const PANEL_SHADER_BYTES: &[u8] = include_bytes!("assets/shaders/shader_unlit_simula.hlsl.sks");
struct FfiAssetHeader {
asset_type: i32,

BIN
src/nodes/drawable/shaders/shader_unlit_gamma.sks
View File

Binary file not shown.

BIN
src/nodes/drawable/shaders/shader_unlit_simula.sks
View File

Binary file not shown.

0
src/nodes/drawable/shaders/shader_unlit_gamma.hlsl → src/nodes/drawable/shaders_src/shader_unlit_gamma.hlsl
View File

0
src/nodes/drawable/shaders/shader_unlit_simula.hlsl → src/nodes/drawable/shaders_src/shader_unlit_simula.hlsl
View File

67
src/nodes/drawable/text.rs
View File

@@ -8,8 +8,11 @@ use once_cell::sync::OnceCell;
use parking_lot::Mutex;
use portable_atomic::{AtomicBool, Ordering};
use std::{ffi::OsStr, path::PathBuf, sync::Arc};
use stereokit::{
named_colors::WHITE, Color128, StereoKitDraw, TextAlign, TextFit, TextStyle as SkTextStyle,
use stereokit_rust::{
font::Font,
sk::MainThreadToken,
system::{TextAlign, TextFit, TextStyle as SkTextStyle},
util::{Color128, Color32},
};
use super::{TextAspect, TextStyle};
@@ -18,13 +21,13 @@ static TEXT_REGISTRY: Registry<Text> = Registry::new();
fn convert_align(x_align: super::XAlign, y_align: super::YAlign) -> TextAlign {
match (x_align, y_align) {
(super::XAlign::Left, super::YAlign::Top) => TextAlign::Left,
(super::XAlign::Left, super::YAlign::Top) => TextAlign::TopLeft,
(super::XAlign::Left, super::YAlign::Center) => TextAlign::CenterLeft,
(super::XAlign::Left, super::YAlign::Bottom) => TextAlign::BottomLeft,
(super::XAlign::Center, super::YAlign::Top) => TextAlign::Center,
(super::XAlign::Center, super::YAlign::Center) => TextAlign::Center,
(super::XAlign::Center, super::YAlign::Bottom) => TextAlign::BottomCenter,
(super::XAlign::Right, super::YAlign::Top) => TextAlign::Right,
(super::XAlign::Right, super::YAlign::Top) => TextAlign::TopRight,
(super::XAlign::Right, super::YAlign::Center) => TextAlign::CenterRight,
(super::XAlign::Right, super::YAlign::Bottom) => TextAlign::BottomRight,
}
@@ -59,16 +62,16 @@ impl Text {
Ok(text)
}
fn draw(&self, sk: &impl StereoKitDraw) {
fn draw(&self, token: &MainThreadToken) {
let style =
self.style
.get_or_try_init(|| -> Result<SkTextStyle, color_eyre::eyre::Error> {
let font = self
.font_path
.as_deref()
.and_then(|path| sk.font_create(path).ok())
.unwrap_or_else(|| sk.font_find("default/font").unwrap());
Ok(unsafe { sk.text_make_style(font, 1.0, WHITE) })
.and_then(|path| Font::from_file(path).ok())
.unwrap_or_default();
Ok(SkTextStyle::from_font(font, 1.0, Color32::WHITE))
});
if let Ok(style) = style {
@@ -81,7 +84,8 @@ impl Text {
data.character_height,
));
if let Some(bounds) = &data.bounds {
sk.text_add_in(
stereokit_rust::system::Text::add_in(
token,
&*text,
transform,
Vec2::from(bounds.bounds) / data.character_height,
@@ -92,21 +96,40 @@ impl Text {
super::TextFit::Exact => TextFit::Exact,
super::TextFit::Overflow => TextFit::Overflow,
},
*style,
convert_align(bounds.anchor_align_x, bounds.anchor_align_y),
convert_align(data.text_align_x, data.text_align_y),
vec3(0.0, 0.0, 0.0),
Color128::from([data.color.c.r, data.color.c.g, data.color.c.b, data.color.a]),
Some(style.clone()),
Some(Color128::new(
data.color.c.r,
data.color.c.g,
data.color.c.b,
data.color.a,
)),
data.bounds
.as_ref()
.map(|b| convert_align(b.anchor_align_x, b.anchor_align_y)),
Some(convert_align(data.text_align_x, data.text_align_y)),
None,
None,
None,
);
} else {
sk.text_add_at(
stereokit_rust::system::Text::add_at(
token,
&*text,
transform,
*style,
TextAlign::Center,
convert_align(data.text_align_x, data.text_align_y),
vec3(0.0, 0.0, 0.0),
Color128::from([data.color.c.r, data.color.c.g, data.color.c.b, data.color.a]),
Some(*style),
Some(Color128::new(
data.color.c.r,
data.color.c.g,
data.color.c.b,
data.color.a,
)),
data.bounds
.as_ref()
.map(|b| convert_align(b.anchor_align_x, b.anchor_align_y)),
Some(convert_align(data.text_align_x, data.text_align_y)),
None,
None,
None,
);
}
}
@@ -141,10 +164,10 @@ impl Drop for Text {
}
}
pub fn draw_all(sk: &impl StereoKitDraw) {
pub fn draw_all(token: &MainThreadToken) {
for text in TEXT_REGISTRY.get_valid_contents() {
if text.enabled.load(Ordering::Relaxed) {
text.draw(sk);
text.draw(token);
}
}
}

6
src/nodes/hmd.rs
View File

@@ -6,7 +6,7 @@ use crate::{
use color_eyre::eyre::Result;
use glam::{vec3, Mat4};
use std::sync::Arc;
use stereokit::StereoKitMultiThread;
use stereokit_rust::system::Input;
lazy_static::lazy_static! {
static ref HMD: Arc<Node> = create();
@@ -19,9 +19,9 @@ fn create() -> Arc<Node> {
node
}
pub fn frame(sk: &impl StereoKitMultiThread) {
pub fn frame() {
let spatial = HMD.get_aspect::<Spatial>().unwrap();
let hmd_pose = sk.input_head();
let hmd_pose = Input::get_head();
*spatial.transform.lock() = Mat4::from_scale_rotation_translation(
vec3(1.0, 1.0, 1.0),
hmd_pose.orientation.into(),

6
src/nodes/input/method.rs
View File

@@ -25,6 +25,7 @@ pub struct InputMethod {
pub data: Mutex<InputDataType>,
pub datamap: Mutex<Datamap>,
pub capture_requests: Registry<InputHandler>,
pub captures: Registry<InputHandler>,
pub(super) handler_aliases: LifeLinkedNodeMap<String>,
pub(super) handler_order: Mutex<Vec<Weak<InputHandler>>>,
@@ -41,6 +42,7 @@ impl InputMethod {
enabled: Mutex::new(true),
spatial: node.get_aspect::<Spatial>().unwrap().clone(),
data: Mutex::new(data),
capture_requests: Registry::new(),
captures: Registry::new(),
datamap: Mutex::new(datamap),
handler_aliases: LifeLinkedNodeMap::default(),
@@ -166,9 +168,7 @@ impl InputMethodRefAspect for InputMethod {
let input_method = node.get_aspect::<InputMethod>()?;
let input_handler = handler.get_aspect::<InputHandler>()?;
input_method.captures.add_raw(&input_handler);
// input_method_client::
// node.send_remote_signal("capture", message)
input_method.capture_requests.add_raw(&input_handler);
Ok(())
}
}

8
src/nodes/input/mod.rs
View File

@@ -154,7 +154,6 @@ pub fn process_input() {
.collect()
});
method.captures.clear();
// Iterate over the distance links and send input to them
for (i, input_link) in input_links.into_iter().enumerate() {
if let Some(method_alias) = input_link
@@ -165,8 +164,13 @@ pub fn process_input() {
{
method_alias.enabled.store(true, Ordering::Release);
}
input_link.send_input(i as u32, true, method.datamap.lock().clone());
input_link.send_input(
i as u32,
method.captures.contains(&input_link.handler),
method.datamap.lock().clone(),
);
}
method.capture_requests.clear();
});
}
}

69
src/nodes/items/camera.rs
View File

@@ -19,12 +19,19 @@ use mint::{RowMatrix4, Vector2};
use nanoid::nanoid;
use once_cell::sync::OnceCell;
use parking_lot::Mutex;
use send_wrapper::SendWrapper;
use serde::Deserialize;
use stardust_xr::schemas::flex::{deserialize, serialize};
use std::sync::Arc;
use stereokit::{
Color128, Material, Rect, RenderLayer, StereoKitDraw, Tex, TextureType, Transparency,
use stereokit_rust::{
material::{Material, Transparency},
shader::Shader,
sk::MainThreadToken,
system::Renderer,
tex::{Tex, TexFormat, TexType},
util::Color128,
};
use tracing::error;
lazy_static! {
pub(super) static ref ITEM_TYPE_INFO_CAMERA: TypeInfo = TypeInfo {
@@ -46,8 +53,8 @@ struct FrameInfo {
pub struct CameraItem {
space: Arc<Spatial>,
frame_info: Mutex<FrameInfo>,
sk_tex: OnceCell<Tex>,
sk_mat: OnceCell<Arc<Material>>,
sk_tex: OnceCell<SendWrapper<Tex>>,
sk_mat: OnceCell<Arc<SendWrapper<Material>>>,
applied_to: Registry<ModelPart>,
apply_to: Registry<ModelPart>,
}
@@ -111,52 +118,54 @@ impl CameraItem {
Ok(serialize(id)?.into())
}
pub fn update(&self, sk: &impl StereoKitDraw) {
pub fn update(&self, token: &MainThreadToken) {
let frame_info = self.frame_info.lock();
let sk_tex = self.sk_tex.get_or_init(|| {
sk.tex_gen_color(
SendWrapper::new(Tex::gen_color(
Color128::default(),
frame_info.px_size.x as i32,
frame_info.px_size.y as i32,
TextureType::RENDER_TARGET,
stereokit::TextureFormat::RGBA32Linear,
)
});
let sk_mat = self.sk_mat.get_or_init(|| {
let shader = sk.shader_create_mem(&UNLIT_SHADER_BYTES).unwrap();
let mat = sk.material_create(&shader);
sk.material_set_texture(&mat, "diffuse", sk_tex.as_ref());
sk.material_set_transparency(&mat, Transparency::Blend);
Arc::new(mat)
TexType::Rendertarget,
TexFormat::RGBA32Linear,
))
});
let sk_mat = self
.sk_mat
.get_or_try_init(|| -> Result<Arc<SendWrapper<Material>>> {
let shader = Shader::from_memory(&UNLIT_SHADER_BYTES)?;
let mut mat = Material::new(&shader, None);
mat.get_all_param_info().set_texture("diffuse", &**sk_tex);
mat.transparency(Transparency::Blend);
Ok(Arc::new(SendWrapper::new(mat)))
});
let Ok(sk_mat) = sk_mat else {
error!("unable to make camera item stereokit texture");
return;
};
for model_part in self.apply_to.take_valid_contents() {
model_part.replace_material(sk_mat.clone())
}
if !self.applied_to.is_empty() {
sk.render_to(
sk_tex,
frame_info.proj_matrix,
Renderer::render_to(
token,
&**sk_tex,
self.space.global_transform(),
RenderLayer::all(),
stereokit::RenderClear::All,
Rect {
x: 0.0,
y: 0.0,
w: 0.0,
h: 0.0,
},
);
frame_info.proj_matrix,
None,
None,
None,
)
}
}
}
pub fn update(sk: &impl StereoKitDraw) {
pub fn update(token: &MainThreadToken) {
for camera in ITEM_TYPE_INFO_CAMERA.items.get_valid_contents() {
let ItemType::Camera(camera) = &camera.specialization else {
continue;
};
camera.update(sk);
camera.update(token);
}
}

33
src/nodes/spatial/mod.rs
View File

@@ -7,7 +7,7 @@ use crate::core::client::Client;
use crate::core::registry::Registry;
use crate::create_interface;
use color_eyre::eyre::{eyre, Result};
use glam::{vec3a, Mat4, Quat};
use glam::{vec3a, Mat4, Quat, Vec3};
use mint::Vector3;
use nanoid::nanoid;
use once_cell::sync::OnceCell;
@@ -15,7 +15,7 @@ use parking_lot::Mutex;
use std::fmt::Debug;
use std::ptr;
use std::sync::{Arc, Weak};
use stereokit::{bounds_grow_to_fit_box, Bounds};
use stereokit_rust::maths::Bounds;
stardust_xr_server_codegen::codegen_spatial_protocol!();
impl Transform {
@@ -104,11 +104,7 @@ impl Spatial {
.map(|b| (b)(&node))
.unwrap_or_default();
for child in self.children.get_valid_contents() {
bounds = bounds_grow_to_fit_box(
bounds,
child.get_bounding_box(),
Some(child.local_transform()),
);
bounds.grown_box(child.get_bounding_box(), child.local_transform());
}
bounds
}
@@ -253,8 +249,8 @@ impl SpatialRefAspect for Spatial {
let bounds = this_spatial.get_bounding_box();
Ok(BoundingBox {
center: mint::Vector3::from(bounds.center),
size: mint::Vector3::from(bounds.dimensions),
center: Vec3::from(bounds.center).into(),
size: Vec3::from(bounds.dimensions).into(),
})
}
@@ -267,21 +263,18 @@ impl SpatialRefAspect for Spatial {
let relative_spatial = relative_to.get_aspect::<Spatial>()?;
let center = Spatial::space_to_space_matrix(Some(&this_spatial), Some(&relative_spatial))
.transform_point3([0.0; 3].into());
let bounds = bounds_grow_to_fit_box(
Bounds {
center,
dimensions: [0.0; 3].into(),
},
let mut bounds = Bounds {
center: center.into(),
dimensions: [0.0; 3].into(),
};
bounds.grown_box(
this_spatial.get_bounding_box(),
Some(Spatial::space_to_space_matrix(
Some(&this_spatial),
Some(&relative_spatial),
)),
Spatial::space_to_space_matrix(Some(&this_spatial), Some(&relative_spatial)),
);
Ok(BoundingBox {
center: mint::Vector3::from(bounds.center),
size: mint::Vector3::from(bounds.dimensions),
center: Vec3::from(bounds.center).into(),
size: Vec3::from(bounds.dimensions).into(),
})
}

14
src/objects/input/eye_pointer.rs
View File

@@ -13,7 +13,7 @@ use nanoid::nanoid;
use serde::{Deserialize, Serialize};
use stardust_xr::values::Datamap;
use std::sync::Arc;
use stereokit::StereoKitMultiThread;
use stereokit_rust::system::Input;
#[derive(Default, Deserialize, Serialize)]
pub struct EyeDatamap {
@@ -46,13 +46,11 @@ impl EyePointer {
Ok(EyePointer { spatial, pointer })
}
pub fn update(&self, sk: &impl StereoKitMultiThread) {
let ray = sk.input_eyes();
self.spatial
.set_local_transform(Mat4::from_rotation_translation(
ray.orientation,
ray.position,
));
pub fn update(&self) {
let ray = Input::get_eyes();
self.spatial.set_local_transform(
Mat4::from_rotation_translation(ray.orientation.into(), ray.position.into()).into(),
);
{
// Set pointer input datamap
*self.pointer.datamap.lock() = Datamap::from_typed(EyeDatamap { eye: 2 }).unwrap();

97
src/objects/input/mouse_pointer.rs
View File

@@ -11,24 +11,38 @@ use crate::{
},
};
use color_eyre::eyre::Result;
use glam::{vec2, vec3, Mat4, Vec2, Vec3};
use glam::{vec3, Mat4, Vec3};
use mint::Vector2;
use nanoid::nanoid;
use serde::{Deserialize, Serialize};
use stardust_xr::values::Datamap;
use std::{convert::TryFrom, sync::Arc};
use stereokit::{ray_from_mouse, ButtonState, Key, StereoKitMultiThread};
use std::sync::Arc;
use stereokit_rust::system::{Input, Key};
use xkbcommon::xkb::{Context, Keymap, FORMAT_TEXT_V1};
#[derive(Default, Deserialize, Serialize)]
#[derive(Deserialize, Serialize)]
struct MouseEvent {
select: f32,
middle: f32,
context: f32,
grab: f32,
scroll_continuous: Vec2,
scroll_discrete: Vec2,
scroll_continuous: Vector2<f32>,
scroll_discrete: Vector2<f32>,
raw_input_events: Vec<u32>,
}
impl Default for MouseEvent {
fn default() -> Self {
MouseEvent {
select: 0.0,
middle: 0.0,
context: 0.0,
grab: 0.0,
scroll_continuous: [0.0; 2].into(),
scroll_discrete: [0.0; 2].into(),
raw_input_events: vec![],
}
}
}
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct KeyboardEvent {
@@ -91,53 +105,48 @@ impl MousePointer {
keyboard_sender,
})
}
pub fn update(&mut self, sk: &impl StereoKitMultiThread) {
let mouse = sk.input_mouse();
pub fn update(&mut self) {
let mouse = Input::get_mouse();
let ray = ray_from_mouse(mouse.pos).unwrap();
let ray = mouse.get_ray();
self.spatial.set_local_transform(
Mat4::look_to_rh(
Vec3::from(ray.pos),
Vec3::from(ray.dir),
Vec3::from(ray.position),
Vec3::from(ray.direction),
vec3(0.0, 1.0, 0.0),
)
.inverse(),
);
{
// Set pointer input datamap
self.mouse_datamap.select =
if sk.input_key(Key::MouseLeft).contains(ButtonState::ACTIVE) {
1.0f32
} else {
0.0f32
};
self.mouse_datamap.middle =
if sk.input_key(Key::MouseCenter).contains(ButtonState::ACTIVE) {
1.0f32
} else {
0.0f32
};
self.mouse_datamap.context =
if sk.input_key(Key::MouseRight).contains(ButtonState::ACTIVE) {
1.0f32
} else {
0.0f32
};
self.mouse_datamap.grab = if sk.input_key(Key::MouseBack).contains(ButtonState::ACTIVE)
|| sk
.input_key(Key::MouseForward)
.contains(ButtonState::ACTIVE)
self.mouse_datamap.select = if Input::key(Key::MouseLeft).is_active() {
1.0f32
} else {
0.0f32
};
self.mouse_datamap.middle = if Input::key(Key::MouseCenter).is_active() {
1.0f32
} else {
0.0f32
};
self.mouse_datamap.context = if Input::key(Key::MouseRight).is_active() {
1.0f32
} else {
0.0f32
};
self.mouse_datamap.grab = if Input::key(Key::MouseBack).is_active()
|| Input::key(Key::MouseForward).is_active()
{
1.0f32
} else {
0.0f32
};
self.mouse_datamap.scroll_continuous = vec2(0.0, mouse.scroll_change / 120.0);
self.mouse_datamap.scroll_discrete = vec2(0.0, mouse.scroll_change / 120.0);
self.mouse_datamap.scroll_continuous = [0.0, mouse.scroll_change / 120.0].into();
self.mouse_datamap.scroll_discrete = [0.0, mouse.scroll_change / 120.0].into();
*self.pointer.datamap.lock() = Datamap::from_typed(&self.mouse_datamap).unwrap();
}
self.target_pointer_input();
self.send_keyboard_input(sk);
self.send_keyboard_input();
}
fn target_pointer_input(&mut self) {
@@ -145,7 +154,7 @@ impl MousePointer {
if let Some(capture) = &self.capture {
if !self
.pointer
.captures
.capture_requests
.get_valid_contents()
.contains(&capture)
{
@@ -156,7 +165,7 @@ impl MousePointer {
if self.capture.is_none() {
if let Some(new_capture) = self
.pointer
.captures
.capture_requests
.get_valid_contents()
.into_iter()
.map(|h| {
@@ -183,8 +192,10 @@ impl MousePointer {
}
// make sure that if something is captured only send input to it
self.pointer.captures.clear();
if let Some(capture) = &self.capture {
self.pointer.set_handler_order([capture].into_iter());
self.pointer.captures.add_raw(capture);
return;
}
@@ -236,7 +247,7 @@ impl MousePointer {
);
}
fn send_keyboard_input(&mut self, sk: &impl StereoKitMultiThread) {
fn send_keyboard_input(&mut self) {
let rx = PULSE_RECEIVER_REGISTRY
.get_valid_contents()
.into_iter()
@@ -263,12 +274,12 @@ impl MousePointer {
if let Some(rx) = rx {
let keys = (8_u32..254)
.filter_map(|i| Key::try_from(i).ok())
.filter_map(|k| Some((map_key(k)?, sk.input_key(k))))
.map(|i| unsafe { std::mem::transmute(i) })
.filter_map(|k| Some((map_key(k)?, Input::key(k))))
.filter_map(|(i, k)| {
if k.contains(ButtonState::JUST_ACTIVE) {
if k.is_just_active() {
Some(i as i32)
} else if k.contains(ButtonState::JUST_INACTIVE) {
} else if k.is_just_inactive() {
Some(-(i as i32))
} else {
None

42
src/objects/input/sk_controller.rs
View File

@@ -11,9 +11,10 @@ use glam::{Mat4, Vec2, Vec3};
use serde::{Deserialize, Serialize};
use stardust_xr::values::Datamap;
use std::sync::Arc;
use stereokit::{
named_colors::WHITE, ButtonState, Handed, Model, RenderLayer, StereoKitDraw,
StereoKitMultiThread,
use stereokit_rust::{
model::Model,
sk::MainThreadToken,
system::{Handed, Input},
};
#[derive(Default, Deserialize, Serialize)]
@@ -32,7 +33,7 @@ pub struct SkController {
datamap: ControllerDatamap,
}
impl SkController {
pub fn new(sk: &impl StereoKitMultiThread, handed: Handed) -> Result<Self> {
pub fn new(handed: Handed) -> Result<Self> {
let _node = Node::create_parent_name(
&INTERNAL_CLIENT,
"",
@@ -45,7 +46,7 @@ impl SkController {
)
.add_to_scenegraph()?;
Spatial::add_to(&_node, None, Mat4::IDENTITY, false);
let model = sk.model_create_mem("cursor.glb", include_bytes!("cursor.glb"), None)?;
let model = Model::from_memory("cursor.glb", include_bytes!("cursor.glb"), None)?;
let tip = InputDataType::Tip(Tip::default());
let input = InputMethod::add_to(
&_node,
@@ -61,30 +62,35 @@ impl SkController {
datamap: Default::default(),
})
}
pub fn update(&mut self, sk: &impl StereoKitDraw) {
let controller = sk.input_controller(self.handed);
*self.input.enabled.lock() = controller.tracked.contains(ButtonState::ACTIVE);
pub fn update(&mut self, token: &MainThreadToken) {
let controller = Input::controller(self.handed);
*self.input.enabled.lock() = controller.tracked.is_active();
if *self.input.enabled.lock() {
let world_transform = Mat4::from_rotation_translation(
controller.aim.orientation,
controller.aim.position,
controller.aim.orientation.into(),
controller.aim.position.into(),
);
sk.model_draw(
&self.model,
self.model.draw(
token,
world_transform * Mat4::from_scale(Vec3::ONE * 0.02),
WHITE,
RenderLayer::LAYER0,
None,
None,
);
self.input.spatial.set_local_transform(world_transform);
}
self.datamap.select = controller.trigger;
self.datamap.grab = controller.grip;
self.datamap.scroll = controller.stick;
self.datamap.scroll = controller.stick.into();
*self.input.datamap.lock() = Datamap::from_typed(&self.datamap).unwrap();
// remove the capture when it's removed from captures list
if let Some(capture) = &self.capture {
if !self.input.captures.get_valid_contents().contains(&capture) {
if !self
.input
.capture_requests
.get_valid_contents()
.contains(&capture)
{
self.capture.take();
}
}
@@ -92,7 +98,7 @@ impl SkController {
if self.capture.is_none() {
self.capture = self
.input
.captures
.capture_requests
.get_valid_contents()
.into_iter()
.map(|handler| {
@@ -115,8 +121,10 @@ impl SkController {
}
// make sure that if something is captured only send input to it
self.input.captures.clear();
if let Some(capture) = &self.capture {
self.input.set_handler_order([capture].into_iter());
self.input.captures.add_raw(capture);
return;
}

145
src/objects/input/sk_hand.rs
View File

@@ -7,18 +7,20 @@ use crate::nodes::{
Node,
};
use color_eyre::eyre::Result;
use glam::Mat4;
use glam::{Mat4, Quat, Vec3};
use nanoid::nanoid;
use serde::{Deserialize, Serialize};
use stardust_xr::values::Datamap;
use std::f32::INFINITY;
use std::sync::Arc;
use stereokit::{ButtonState, Color128, HandJoint, Handed, Material, StereoKitMultiThread};
use stereokit_rust::sk::MainThreadToken;
use stereokit_rust::system::{HandJoint, Handed, Input, LinePoint, Lines};
use stereokit_rust::util::Color128;
fn convert_joint(joint: HandJoint) -> Joint {
Joint {
position: joint.position.into(),
rotation: joint.orientation.into(),
position: Vec3::from(joint.position).into(),
rotation: Quat::from(joint.orientation).into(),
radius: joint.radius,
distance: 0.0,
}
@@ -33,13 +35,12 @@ struct HandDatamap {
pub struct SkHand {
_node: Arc<Node>,
handed: Handed,
material: Material,
input: Arc<InputMethod>,
capture: Option<Arc<InputHandler>>,
datamap: HandDatamap,
}
impl SkHand {
pub fn new(handed: Handed, sk: &impl StereoKitMultiThread) -> Result<Self> {
pub fn new(handed: Handed) -> Result<Self> {
let _node = Node::create_parent_name(&INTERNAL_CLIENT, "", &nanoid!(), false)
.add_to_scenegraph()?;
Spatial::add_to(&_node, None, Mat4::IDENTITY, false);
@@ -50,29 +51,21 @@ impl SkHand {
let datamap = Datamap::from_typed(HandDatamap::default())?;
let input = InputMethod::add_to(&_node, hand, datamap)?;
let material = sk.material_copy(Material::HAND);
unsafe { sk.material_addref(&material); }
sk.input_hand_material(handed, Material(material.0));
Input::hand_visible(handed, false);
Ok(SkHand {
_node,
handed,
material,
input,
capture: None,
datamap: Default::default(),
})
}
pub fn update(&mut self, controller_enabled: bool, sk: &impl StereoKitMultiThread) {
let sk_hand = sk.input_hand(self.handed);
pub fn update(&mut self, controller_enabled: bool, token: &MainThreadToken) {
let sk_hand = Input::hand(self.handed);
if let InputDataType::Hand(hand) = &mut *self.input.data.lock() {
let controller_active = controller_enabled
&& sk
.input_controller(self.handed)
.tracked
.contains(ButtonState::ACTIVE);
*self.input.enabled.lock() =
!controller_active && sk_hand.tracked_state.contains(ButtonState::ACTIVE);
sk.input_hand_visible(self.handed, *self.input.enabled.lock());
let controller_active =
controller_enabled && Input::controller(self.handed).is_tracked();
*self.input.enabled.lock() = !controller_active && sk_hand.tracked.is_active();
if *self.input.enabled.lock() {
hand.thumb.tip = convert_joint(sk_hand.fingers[0][4]);
hand.thumb.distal = convert_joint(sk_hand.fingers[0][3]);
@@ -92,17 +85,27 @@ impl SkHand {
finger.metacarpal = convert_joint(sk_finger[0]);
}
hand.palm.position = sk_hand.palm.position.into();
hand.palm.rotation = sk_hand.palm.orientation.into();
hand.palm.position = Vec3::from(sk_hand.palm.position).into();
hand.palm.rotation = Quat::from(sk_hand.palm.orientation).into();
hand.palm.radius =
(sk_hand.fingers[2][0].radius + sk_hand.fingers[2][1].radius) * 0.5;
hand.wrist.position = sk_hand.wrist.position.into();
hand.wrist.rotation = sk_hand.wrist.orientation.into();
hand.wrist.position = Vec3::from(sk_hand.wrist.position).into();
hand.wrist.rotation = Quat::from(sk_hand.wrist.orientation).into();
hand.wrist.radius =
(sk_hand.fingers[0][0].radius + sk_hand.fingers[4][0].radius) * 0.5;
hand.elbow = None;
self.draw(
token,
if self.capture.is_none() {
Color128::new_rgb(1.0, 1.0, 1.0)
} else {
Color128::new_rgb(0.0, 1.0, 0.75)
},
hand,
);
}
}
self.datamap.pinch_strength = sk_hand.pinch_activation;
@@ -111,16 +114,20 @@ impl SkHand {
// remove the capture when it's removed from captures list
if let Some(capture) = &self.capture {
if !self.input.captures.get_valid_contents().contains(&capture) {
if !self
.input
.capture_requests
.get_valid_contents()
.contains(&capture)
{
self.capture.take();
sk.material_set_color(&self.material, "color", Color128::new_rgb(1.0, 1.0, 1.0));
}
}
// add the capture that's the closest if we don't have one
if self.capture.is_none() {
self.capture = self
.input
.captures
.capture_requests
.get_valid_contents()
.into_iter()
.map(|handler| (handler.clone(), self.compare_distance(&handler.field).abs()))
@@ -132,14 +139,13 @@ impl SkHand {
}
})
.map(|(rx, _)| rx);
if self.capture.is_some() {
sk.material_set_color(&self.material, "color", Color128::new_rgb(0.0, 1.0, 0.75));
}
}
// make sure that if something is captured only send input to it
self.input.captures.clear();
if let Some(capture) = &self.capture {
self.input.set_handler_order([capture].into_iter());
self.input.captures.add_raw(capture);
return;
}
@@ -183,6 +189,77 @@ impl SkHand {
);
}
fn draw(&self, token: &MainThreadToken, color: Color128, hand: &Hand) {
// thumb
Lines::add_list(
token,
&[
joint_to_line_point(&hand.thumb.tip, color),
joint_to_line_point(&hand.thumb.distal, color),
joint_to_line_point(&hand.thumb.proximal, color),
joint_to_line_point(&hand.thumb.metacarpal, color),
],
);
// index
Lines::add_list(
token,
&[
joint_to_line_point(&hand.index.tip, color),
joint_to_line_point(&hand.index.distal, color),
joint_to_line_point(&hand.index.intermediate, color),
joint_to_line_point(&hand.index.proximal, color),
joint_to_line_point(&hand.index.metacarpal, color),
],
);
// middle
Lines::add_list(
token,
&[
joint_to_line_point(&hand.middle.tip, color),
joint_to_line_point(&hand.middle.distal, color),
joint_to_line_point(&hand.middle.intermediate, color),
joint_to_line_point(&hand.middle.proximal, color),
joint_to_line_point(&hand.middle.metacarpal, color),
],
);
// ring
Lines::add_list(
token,
&[
joint_to_line_point(&hand.ring.tip, color),
joint_to_line_point(&hand.ring.distal, color),
joint_to_line_point(&hand.ring.intermediate, color),
joint_to_line_point(&hand.ring.proximal, color),
joint_to_line_point(&hand.ring.metacarpal, color),
],
);
// little
Lines::add_list(
token,
&[
joint_to_line_point(&hand.little.tip, color),
joint_to_line_point(&hand.little.distal, color),
joint_to_line_point(&hand.little.intermediate, color),
joint_to_line_point(&hand.little.proximal, color),
joint_to_line_point(&hand.little.metacarpal, color),
],
);
// palm
Lines::add_list(
token,
&[
joint_to_line_point(&hand.wrist, color),
joint_to_line_point(&hand.thumb.metacarpal, color),
joint_to_line_point(&hand.index.metacarpal, color),
joint_to_line_point(&hand.middle.metacarpal, color),
joint_to_line_point(&hand.ring.metacarpal, color),
joint_to_line_point(&hand.little.metacarpal, color),
joint_to_line_point(&hand.wrist, color),
],
);
}
fn compare_distance(&self, field: &Field) -> f32 {
let InputDataType::Hand(hand) = &*self.input.data.lock() else {
return INFINITY;
@@ -199,3 +276,11 @@ impl SkHand {
+ (ring_tip_distance * 0.15)
}
}
fn joint_to_line_point(joint: &Joint, color: Color128) -> LinePoint {
LinePoint {
pt: Vec3::from(joint.position).into(),
thickness: joint.radius * 2.0,
color: color.into(),
}
}

23
src/objects/play_space.rs
View File

@@ -6,7 +6,7 @@ use mint::Vector2;
use nanoid::nanoid;
use serde::{Deserialize, Serialize};
use stardust_xr::values::Datamap;
use stereokit::StereoKitMultiThread;
use stereokit_rust::system::World;
use crate::{
core::client::INTERNAL_CLIENT,
@@ -59,23 +59,14 @@ impl PlaySpace {
_pulse_rx: pulse_rx,
})
}
pub fn update(&self, sk: &impl StereoKitMultiThread) {
let pose = sk.world_get_bounds_pose();
self.spatial
.set_local_transform(Mat4::from_rotation_translation(
pose.orientation,
pose.position,
));
pub fn update(&self) {
let pose = World::get_bounds_pose();
self.spatial.set_local_transform(
Mat4::from_rotation_translation(pose.orientation.into(), pose.position.into()).into(),
);
let Field::Box(box_field) = self.field.as_ref() else {
return;
};
box_field.set_size(
[
sk.world_get_bounds_size().x,
0.0,
sk.world_get_bounds_size().y,
]
.into(),
);
box_field.set_size([World::get_bounds_size().x, 0.0, World::get_bounds_size().y].into());
}
}

22
src/wayland/mod.rs
View File

@@ -24,7 +24,6 @@ use crate::{core::task, wayland::state::ClientState};
use color_eyre::eyre::{ensure, Result};
use once_cell::sync::OnceCell;
use parking_lot::Mutex;
use sk::StereoKitDraw;
use smithay::backend::allocator::dmabuf::Dmabuf;
use smithay::backend::egl::EGLContext;
use smithay::backend::renderer::gles::GlesRenderer;
@@ -42,7 +41,7 @@ use std::{
os::unix::{net::UnixListener, prelude::FromRawFd},
sync::Arc,
};
use stereokit as sk;
use stereokit_rust::system::{Backend, BackendGraphics};
use tokio::sync::mpsc::UnboundedReceiver;
use tokio::{
io::unix::AsyncFd, net::UnixListener as AsyncUnixListener, sync::mpsc, task::JoinHandle,
@@ -59,16 +58,15 @@ struct EGLRawHandles {
}
fn get_sk_egl() -> Result<EGLRawHandles> {
ensure!(
unsafe { sk::sys::backend_graphics_get() }
== sk::sys::backend_graphics__backend_graphics_opengles_egl,
Backend::graphics() == BackendGraphics::OpenGLESEGL,
"StereoKit is not running using EGL!"
);
Ok(unsafe {
EGLRawHandles {
display: sk::sys::backend_opengl_egl_get_display() as *const c_void,
config: sk::sys::backend_opengl_egl_get_config() as *const c_void,
context: sk::sys::backend_opengl_egl_get_context() as *const c_void,
display: stereokit_rust::system::backend_opengl_egl_get_display() as *const c_void,
config: stereokit_rust::system::backend_opengl_egl_get_config() as *const c_void,
context: stereokit_rust::system::backend_opengl_egl_get_context() as *const c_void,
}
})
}
@@ -196,8 +194,8 @@ impl Wayland {
})?)
}
#[instrument(level = "debug", name = "Wayland frame", skip(self, sk))]
pub fn update(&mut self, sk: &impl StereoKitDraw) {
#[instrument(level = "debug", name = "Wayland frame", skip(self))]
pub fn update(&mut self) {
while let Ok((dmabuf, notifier)) = self.dmabuf_rx.try_recv() {
if self.renderer.import_dmabuf(&dmabuf, None).is_err() {
if let Some(notifier) = notifier {
@@ -206,15 +204,15 @@ impl Wayland {
}
}
for core_surface in CORE_SURFACES.get_valid_contents() {
core_surface.process(sk, &mut self.renderer);
core_surface.process(&mut self.renderer);
}
self.display.flush_clients(None);
}
pub fn frame_event(&self, sk: &impl StereoKitDraw) {
pub fn frame_event(&self) {
for core_surface in CORE_SURFACES.get_valid_contents() {
core_surface.frame(sk, self.output.clone());
core_surface.frame(self.output.clone());
}
}

59
src/wayland/surface.rs
View File

@@ -19,9 +19,11 @@ use smithay::{
wayland::compositor::{self, SurfaceData},
};
use std::{cell::RefCell, ffi::c_void, sync::Arc, time::Duration};
use stereokit::{
Material, Shader, StereoKitDraw, Tex, TextureAddress, TextureFormat, TextureSample,
TextureType, Transparency,
use stereokit_rust::{
material::{Material, Transparency},
shader::Shader,
tex::{Tex, TexAddress, TexFormat, TexSample, TexType},
util::Time,
};
pub static CORE_SURFACES: Registry<CoreSurface> = Registry::new();
@@ -40,8 +42,8 @@ pub struct CoreSurface {
pub dh: DisplayHandle,
pub weak_surface: wayland_server::Weak<WlSurface>,
mapped_data: Mutex<Option<CoreSurfaceData>>,
sk_tex: OnceCell<Tex>,
sk_mat: OnceCell<Arc<Material>>,
sk_tex: OnceCell<SendWrapper<Mutex<Tex>>>,
sk_mat: OnceCell<SendWrapper<Mutex<Material>>>,
material_offset: Mutex<Delta<u32>>,
on_mapped: Mutex<Box<dyn Fn() + Send + Sync>>,
on_commit: Mutex<Box<dyn Fn(u32) + Send + Sync>>,
@@ -85,24 +87,28 @@ impl CoreSurface {
*self.on_commit.lock() = Box::new(|_| {});
}
pub fn process(&self, sk: &impl StereoKitDraw, renderer: &mut GlesRenderer) {
pub fn process(&self, renderer: &mut GlesRenderer) {
let Some(wl_surface) = self.wl_surface() else {
return;
};
let sk_tex = self
.sk_tex
.get_or_init(|| sk.tex_create(TextureType::IMAGE_NO_MIPS, TextureFormat::RGBA32));
let sk_tex = self.sk_tex.get_or_init(|| {
SendWrapper::new(Mutex::new(Tex::new(
TexType::ImageNomips,
TexFormat::RGBA32Linear,
nanoid::nanoid!(),
)))
});
self.sk_mat.get_or_init(|| {
let shader = sk.shader_create_mem(&PANEL_SHADER_BYTES);
let shader = Shader::from_memory(&PANEL_SHADER_BYTES).unwrap();
// let _ = renderer.with_context(|c| unsafe {
// shader_inject(c, &mut shader, SIMULA_VERT_STR, SIMULA_FRAG_STR)
// });
let mat = sk.material_create(shader.as_ref().unwrap_or(Shader::UI.as_ref()));
sk.material_set_texture(&mat, "diffuse", sk_tex.as_ref());
sk.material_set_transparency(&mat, Transparency::Blend);
Arc::new(mat)
let mut mat = Material::new(shader, None);
mat.diffuse_tex(sk_tex.lock().as_ref());
mat.transparency(Transparency::Blend);
SendWrapper::new(Mutex::new(mat))
});
// Let smithay handle buffer management (has to be done here as RendererSurfaceStates is not thread safe)
@@ -146,22 +152,22 @@ impl CoreSurface {
let Some(sk_mat) = self.sk_mat.get() else {
return;
};
unsafe {
sk.tex_set_surface(
sk_tex.as_ref(),
sk_tex
.lock()
.set_native_surface(
smithay_tex.tex_id() as usize as *mut c_void,
TextureType::IMAGE_NO_MIPS,
TexType::ImageNomips,
smithay::backend::renderer::gles::ffi::RGBA8.into(),
smithay_tex.width() as i32,
smithay_tex.height() as i32,
1,
false,
);
sk.tex_set_sample(sk_tex.as_ref(), TextureSample::Point);
sk.tex_set_address(sk_tex.as_ref(), TextureAddress::Clamp);
}
)
.sample_mode(TexSample::Point)
.address_mode(TexAddress::Clamp);
if let Some(material_offset) = self.material_offset.lock().delta() {
sk.material_set_queue_offset(sk_mat.as_ref().as_ref(), *material_offset as i32);
sk_mat.lock().queue_offset(*material_offset as i32);
}
let Some(surface_size) = renderer_surface_state.surface_size() else {
@@ -180,7 +186,7 @@ impl CoreSurface {
self.apply_surface_materials();
}
pub fn frame(&self, sk: &impl StereoKitDraw, output: Output) {
pub fn frame(&self, output: Output) {
let Some(wl_surface) = self.wl_surface() else {
return;
};
@@ -188,7 +194,7 @@ impl CoreSurface {
send_frames_surface_tree(
&wl_surface,
&output,
Duration::from_secs_f64(sk.time_get()),
Duration::from_secs_f64(Time::get_total_unscaled()),
None,
|_, _| Some(output.clone()),
);
@@ -204,8 +210,9 @@ impl CoreSurface {
fn apply_surface_materials(&self) {
if let Some(sk_mat) = self.sk_mat.get() {
let sk_mat = sk_mat.lock();
for model_node in self.pending_material_applications.get_valid_contents() {
model_node.replace_material(sk_mat.clone());
model_node.replace_material_now(sk_mat.as_ref());
}
self.pending_material_applications.clear();
}