not even the nix packages have clients with the server afaik

M

Malek•6/24/23, 5:16 AM

well then i don't want it

i want a de

I don't wanna assemble a desktop myself

N

NovaOP•6/24/23, 5:16 AM

stardust isn't ready for a DE :P

N

NovaOP•6/24/23, 5:16 AM

because we need help making it

NNova not even the nix packages have clients with the server afaik

M

matthewcroughan•6/24/23, 5:17 AM

what do you mean?

M

matthewcroughan•6/24/23, 5:17 AM

In Nix, you just have a file like this

M

matthewcroughan•6/24/23, 5:18 AM

{ pkgs ? import (builtins.getFlake "github:nixos/nixpkgs/nixos-unstable") {} }:
let
  monado = pkgs.monado.overrideAttrs (_:{
    src = pkgs.fetchgit {
      rev = "354e70f72e83d2dc39e65c696f5e5efe4122c648";
      url = "https://gitlab.freedesktop.org/TheJackiMonster/monado.git";
      sha256 = "sha256-Uzk9srRdSZmVS0VSl3wd4j1bpOs6FEKA4RgrXDz8bM0=";
    };
  });
  flatland = (builtins.getFlake "github:StardustXR/flatland").packages.x86_64-linux.default.overrideAttrs (_: {
    prePatch = ''
      substituteInPlace src/surface.rs --replace 'pub const PPM: f32 = 1000.0;' 'pub const PPM: f32 = 3500.0;'
    '';
  });
in
pkgs.mkShell {
  buildInputs = [
#    monado
    (monado.override { stdenv = pkgs.withCFlags [ "-O3" ] pkgs.stdenv; })
#    (builtins.getFlake "github:matthewcroughan/manifold/mc/nix-flake").packages.x86_64-linux.default
    (builtins.getFlake "github:stardustxr/server/develop").packages.x86_64-linux.default
    (builtins.getFlake "github:stardustxr/azimuth/mc/nixify").packages.x86_64-linux.default
    (builtins.getFlake "github:stardustxr/eclipse/mc/nixify").packages.x86_64-linux.default
    flatland
  ];
}

{ pkgs ? import (builtins.getFlake "github:nixos/nixpkgs/nixos-unstable") {} }:
let
  monado = pkgs.monado.overrideAttrs (_:{
    src = pkgs.fetchgit {
      rev = "354e70f72e83d2dc39e65c696f5e5efe4122c648";
      url = "https://gitlab.freedesktop.org/TheJackiMonster/monado.git";
      sha256 = "sha256-Uzk9srRdSZmVS0VSl3wd4j1bpOs6FEKA4RgrXDz8bM0=";
    };
  });
  flatland = (builtins.getFlake "github:StardustXR/flatland").packages.x86_64-linux.default.overrideAttrs (_: {
    prePatch = ''
      substituteInPlace src/surface.rs --replace 'pub const PPM: f32 = 1000.0;' 'pub const PPM: f32 = 3500.0;'
    '';
  });
in
pkgs.mkShell {
  buildInputs = [
#    monado
    (monado.override { stdenv = pkgs.withCFlags [ "-O3" ] pkgs.stdenv; })
#    (builtins.getFlake "github:matthewcroughan/manifold/mc/nix-flake").packages.x86_64-linux.default
    (builtins.getFlake "github:stardustxr/server/develop").packages.x86_64-linux.default
    (builtins.getFlake "github:stardustxr/azimuth/mc/nixify").packages.x86_64-linux.default
    (builtins.getFlake "github:stardustxr/eclipse/mc/nixify").packages.x86_64-linux.default
    flatland
  ];
}

{ pkgs ? import (builtins.getFlake "github:nixos/nixpkgs/nixos-unstable") {} }:
let
  monado = pkgs.monado.overrideAttrs (_:{
    src = pkgs.fetchgit {
      rev = "354e70f72e83d2dc39e65c696f5e5efe4122c648";
      url = "https://gitlab.freedesktop.org/TheJackiMonster/monado.git";
      sha256 = "sha256-Uzk9srRdSZmVS0VSl3wd4j1bpOs6FEKA4RgrXDz8bM0=";
    };
  });
  flatland = (builtins.getFlake "github:StardustXR/flatland").packages.x86_64-linux.default.overrideAttrs (_: {
    prePatch = ''
      substituteInPlace src/surface.rs --replace 'pub const PPM: f32 = 1000.0;' 'pub const PPM: f32 = 3500.0;'
    '';
  });
in
pkgs.mkShell {
  buildInputs = [
#    monado
    (monado.override { stdenv = pkgs.withCFlags [ "-O3" ] pkgs.stdenv; })
#    (builtins.getFlake "github:matthewcroughan/manifold/mc/nix-flake").packages.x86_64-linux.default
    (builtins.getFlake "github:stardustxr/server/develop").packages.x86_64-linux.default
    (builtins.getFlake "github:stardustxr/azimuth/mc/nixify").packages.x86_64-linux.default
    (builtins.getFlake "github:stardustxr/eclipse/mc/nixify").packages.x86_64-linux.default
    flatland
  ];
}

{ pkgs ? import (builtins.getFlake "github:nixos/nixpkgs/nixos-unstable") {} }:
let
  monado = pkgs.monado.overrideAttrs (_:{
    src = pkgs.fetchgit {
      rev = "354e70f72e83d2dc39e65c696f5e5efe4122c648";
      url = "https://gitlab.freedesktop.org/TheJackiMonster/monado.git";
      sha256 = "sha256-Uzk9srRdSZmVS0VSl3wd4j1bpOs6FEKA4RgrXDz8bM0=";
    };
  });
  flatland = (builtins.getFlake "github:StardustXR/flatland").packages.x86_64-linux.default.overrideAttrs (_: {
    prePatch = ''
      substituteInPlace src/surface.rs --replace 'pub const PPM: f32 = 1000.0;' 'pub const PPM: f32 = 3500.0;'
    '';
  });
in
pkgs.mkShell {
  buildInputs = [
#    monado
    (monado.override { stdenv = pkgs.withCFlags [ "-O3" ] pkgs.stdenv; })
#    (builtins.getFlake "github:matthewcroughan/manifold/mc/nix-flake").packages.x86_64-linux.default
    (builtins.getFlake "github:stardustxr/server/develop").packages.x86_64-linux.default
    (builtins.getFlake "github:stardustxr/azimuth/mc/nixify").packages.x86_64-linux.default
    (builtins.getFlake "github:stardustxr/eclipse/mc/nixify").packages.x86_64-linux.default
    flatland
  ];
}

M

matthewcroughan•6/24/23, 5:18 AM

As you can see, I'm grabbing all the clients I want, and the server

M

matthewcroughan•6/24/23, 5:18 AM

Now I need to write a NixOS module, in order to set all of these up with systemd

M

matthewcroughan•6/24/23, 5:18 AM

but then, only NixOS users can use that service management.

M

matthewcroughan•6/24/23, 5:18 AM

But that's what it takes to build correct software management.

N

NovaOP•6/24/23, 5:18 AM

i know you can bundle it up to install multiple packages

N

NovaOP•6/24/23, 5:19 AM

but launching it is where i was confused

M

matthewcroughan•6/24/23, 5:19 AM

Well, if you don't use NixOS, that just has to be a systemd service that you cannot guarantee the correctness of

M

matthewcroughan•6/24/23, 5:19 AM

in the case of every single other software project, they just put a random systemd.service file inside of their repo and tell people to

cp

cp

that into

/etc

/etc

/etc

/etc and hope it goes well

M

matthewcroughan•6/24/23, 5:20 AM

they are powerless to test that, and hope that the user manages to copy it to the right place

M

matthewcroughan•6/24/23, 5:20 AM

in the case of NixOS we are able to test that, and the user doesn't have to install it themselves into the correct location

T

The_Last_Raposa ∞•6/24/23, 10:42 AM

hey matthew i think i have a project idea id want to use nix for

T

The_Last_Raposa ∞•6/24/23, 10:42 AM

you think you could help me learn the basics of using nixos for arm?

B

BOI•6/24/23, 6:38 PM

lmao why is nixos so popular recently

B

BOI•6/24/23, 6:38 PM

i still dont know whats so good about it

B

BOI•6/24/23, 6:38 PM

hear me ^ lmfao

T

The_Last_Raposa ∞•6/24/23, 6:45 PM

idk i think its just caught steam

TThe_Last_Raposa ∞idk i think its just caught steam

B

BOI•6/24/23, 6:54 PM

same lmfa

T

The_Last_Raposa ∞•6/24/23, 7:20 PM

i was looking at possibly using it for a minimal and relatively set and forget system

T

The_Last_Raposa ∞•6/24/23, 7:22 PM

tho i might wind up using something else given there isnt official support for the raspberry pi from nixOS

V

VoHeLi | ボヘリ•6/25/23, 1:39 PM

Hey, is Stardust compatible with Unity Apps? I mean I'm currently developing a XR game for the Lynx (I'm on quest 2 for now), so on Android. Is there a way to release it for the Stardust UI? Thanks

N

NovaOP•6/25/23, 1:41 PM

well... stardust itself doesn't really support unity because that's not how it works

N

NovaOP•6/25/23, 1:41 PM

however, it is planned for stardust to support openxr!

N

NovaOP•6/25/23, 1:41 PM

however, unity does not support openxr on linux

N

NovaOP•6/25/23, 1:42 PM

but unity does support openxr on android and we have waydroid letting you run android apps on linux, works great with stardust too!

N

NovaOP•6/25/23, 1:42 PM

but making a bridge from waydroid to linux for openxr will take a while...

N

NovaOP•6/25/23, 1:43 PM

@VoHeLi you might be thinking of polyspatial... similar things don't exist for stardust and aren't planned or intended, but non-immersive 3D apps is

N

NovaOP•6/25/23, 1:43 PM

point is, make your game in unity and eventually it will work with stardust somehow

N

NovaOP•6/25/23, 1:43 PM

idk how long that will take

N

NovaOP•6/25/23, 1:43 PM

but if you want to give it a huge boost, export it to webxr

N

NovaOP•6/25/23, 1:43 PM

sound good? :D

V

VoHeLi | ボヘリ•6/25/23, 1:50 PM

Thank for your answer, I'm working indeed on an app that would take the whole space. I just wanted to know if Stardust could launch Unity apps too in a fully immersive way.

V

VoHeLi | ボヘリ•6/25/23, 1:50 PM

Because your UI System seems very advanced

V

VoHeLi | ボヘリ•6/25/23, 1:50 PM

Specially to compete with Apple Vision Pro Swift UI

E

ethernet•6/25/23, 1:50 PM

ok pog I got all my kimera vio stuff compiling

E

ethernet•6/25/23, 1:51 PM

I have a single, beautiful dynamic library file

E

ethernet•6/25/23, 1:51 PM

now I have to write rust bindings against it lol

E

ethernet•6/25/23, 1:51 PM

Oh no. not rust, I have to connect it to monado

E

ethernet•6/25/23, 1:51 PM

and then I can see how terrible the tracking quality is

E

ethernet•6/25/23, 1:51 PM

and then I can cry and start from scratch

E

ethernet•6/25/23, 1:51 PM

let's goOooo progress!

Eethernet and then I can cry and start from scratch

N

NovaOP•6/25/23, 2:01 PM

haha yayyy

VVoHeLi | ボヘリ Because your UI System seems very advanced

N

NovaOP•6/25/23, 2:01 PM

thanks! it can absolutely do everything apple's can given some work :3

N

NovaOP•6/25/23, 2:01 PM

and it can do more

N

NovaOP•6/25/23, 3:17 PM

pub struct SimplePulseReceiver<T: Serialize + DeserializeOwned + Default + 'static>(
    HandlerWrapper<PulseReceiver, InlineHandler<T>>,
);
impl<T: Serialize + DeserializeOwned + Default + 'static> SimplePulseReceiver<T> {
    pub fn create<Fi: Field, F: FnMut(&str, &T) + Send + Sync + 'static>(
        spatial_parent: &Spatial,
        transform: Transform,
        field: &Fi,
        on_data: F,
    ) -> Result<Self, NodeError> {
        let mut mask_serializer = FlexbufferSerializer::new();
        T::default()
            .serialize(&mut mask_serializer)
            .map_err(|_| NodeError::Serialization)?;
        Ok(SimplePulseReceiver(
            PulseReceiver::create(spatial_parent, transform, field, mask_serializer.view())?
                .wrap(InlineHandler(Box::new(on_data)))?,
        ))
    }
}
impl<T: Serialize + DeserializeOwned + Default + 'static> std::ops::Deref
    for SimplePulseReceiver<T>
{
    type Target = PulseReceiver;

    fn deref(&self) -> &Self::Target {
        self.0.node()
    }
}

struct InlineHandler<T: Serialize + DeserializeOwned + Default + 'static>(
    Box<dyn FnMut(&str, &T) + Send + Sync + 'static>,
);
impl<T: Serialize + DeserializeOwned + Default + 'static> PulseReceiverHandler
    for InlineHandler<T>
{
    fn data(&mut self, uid: &str, data: &[u8], _data_reader: MapReader<&[u8]>) {
        let Ok(root) = Reader::get_root(data) else {return};
        let Ok(data) = T::deserialize(root) else {return};
        (self.0)(uid, &data)
    }
}

pub struct SimplePulseReceiver<T: Serialize + DeserializeOwned + Default + 'static>(
    HandlerWrapper<PulseReceiver, InlineHandler<T>>,
);
impl<T: Serialize + DeserializeOwned + Default + 'static> SimplePulseReceiver<T> {
    pub fn create<Fi: Field, F: FnMut(&str, &T) + Send + Sync + 'static>(
        spatial_parent: &Spatial,
        transform: Transform,
        field: &Fi,
        on_data: F,
    ) -> Result<Self, NodeError> {
        let mut mask_serializer = FlexbufferSerializer::new();
        T::default()
            .serialize(&mut mask_serializer)
            .map_err(|_| NodeError::Serialization)?;
        Ok(SimplePulseReceiver(
            PulseReceiver::create(spatial_parent, transform, field, mask_serializer.view())?
                .wrap(InlineHandler(Box::new(on_data)))?,
        ))
    }
}
impl<T: Serialize + DeserializeOwned + Default + 'static> std::ops::Deref
    for SimplePulseReceiver<T>
{
    type Target = PulseReceiver;

    fn deref(&self) -> &Self::Target {
        self.0.node()
    }
}

struct InlineHandler<T: Serialize + DeserializeOwned + Default + 'static>(
    Box<dyn FnMut(&str, &T) + Send + Sync + 'static>,
);
impl<T: Serialize + DeserializeOwned + Default + 'static> PulseReceiverHandler
    for InlineHandler<T>
{
    fn data(&mut self, uid: &str, data: &[u8], _data_reader: MapReader<&[u8]>) {
        let Ok(root) = Reader::get_root(data) else {return};
        let Ok(data) = T::deserialize(root) else {return};
        (self.0)(uid, &data)
    }
}

pub struct SimplePulseReceiver<T: Serialize + DeserializeOwned + Default + 'static>(
    HandlerWrapper<PulseReceiver, InlineHandler<T>>,
);
impl<T: Serialize + DeserializeOwned + Default + 'static> SimplePulseReceiver<T> {
    pub fn create<Fi: Field, F: FnMut(&str, &T) + Send + Sync + 'static>(
        spatial_parent: &Spatial,
        transform: Transform,
        field: &Fi,
        on_data: F,
    ) -> Result<Self, NodeError> {
        let mut mask_serializer = FlexbufferSerializer::new();
        T::default()
            .serialize(&mut mask_serializer)
            .map_err(|_| NodeError::Serialization)?;
        Ok(SimplePulseReceiver(
            PulseReceiver::create(spatial_parent, transform, field, mask_serializer.view())?
                .wrap(InlineHandler(Box::new(on_data)))?,
        ))
    }
}
impl<T: Serialize + DeserializeOwned + Default + 'static> std::ops::Deref
    for SimplePulseReceiver<T>
{
    type Target = PulseReceiver;

    fn deref(&self) -> &Self::Target {
        self.0.node()
    }
}

struct InlineHandler<T: Serialize + DeserializeOwned + Default + 'static>(
    Box<dyn FnMut(&str, &T) + Send + Sync + 'static>,
);
impl<T: Serialize + DeserializeOwned + Default + 'static> PulseReceiverHandler
    for InlineHandler<T>
{
    fn data(&mut self, uid: &str, data: &[u8], _data_reader: MapReader<&[u8]>) {
        let Ok(root) = Reader::get_root(data) else {return};
        let Ok(data) = T::deserialize(root) else {return};
        (self.0)(uid, &data)
    }
}

pub struct SimplePulseReceiver<T: Serialize + DeserializeOwned + Default + 'static>(
    HandlerWrapper<PulseReceiver, InlineHandler<T>>,
);
impl<T: Serialize + DeserializeOwned + Default + 'static> SimplePulseReceiver<T> {
    pub fn create<Fi: Field, F: FnMut(&str, &T) + Send + Sync + 'static>(
        spatial_parent: &Spatial,
        transform: Transform,
        field: &Fi,
        on_data: F,
    ) -> Result<Self, NodeError> {
        let mut mask_serializer = FlexbufferSerializer::new();
        T::default()
            .serialize(&mut mask_serializer)
            .map_err(|_| NodeError::Serialization)?;
        Ok(SimplePulseReceiver(
            PulseReceiver::create(spatial_parent, transform, field, mask_serializer.view())?
                .wrap(InlineHandler(Box::new(on_data)))?,
        ))
    }
}
impl<T: Serialize + DeserializeOwned + Default + 'static> std::ops::Deref
    for SimplePulseReceiver<T>
{
    type Target = PulseReceiver;

    fn deref(&self) -> &Self::Target {
        self.0.node()
    }
}

struct InlineHandler<T: Serialize + DeserializeOwned + Default + 'static>(
    Box<dyn FnMut(&str, &T) + Send + Sync + 'static>,
);
impl<T: Serialize + DeserializeOwned + Default + 'static> PulseReceiverHandler
    for InlineHandler<T>
{
    fn data(&mut self, uid: &str, data: &[u8], _data_reader: MapReader<&[u8]>) {
        let Ok(root) = Reader::get_root(data) else {return};
        let Ok(data) = T::deserialize(root) else {return};
        (self.0)(uid, &data)
    }
}