dofdev/oriels
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity

inside an oriel + cubic flow

Browse source
This commit is contained in:
spatialfree 2021-11-27 22:46:08 -05:00
parent 901e9112ce
commit 43c98bb95e
4 changed files with 337 additions and 125 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

152
MonoNet.cs
View file

@ -6,53 +6,50 @@ using System.Threading;
using System.Threading.Tasks;
public class MonoNet {
public MonoNet() {
public Mono mono;
public MonoNet(Mono mono) {
this.mono = mono;
Random rnd = new Random();
me = new Peer(rnd.Next(1, 256)); // temp, until unique usernames
}
public Socket socket;
byte[] data;
int head;
int bufferSize = 1024;
byte[] rData; int rHead;
byte[] wData; int wHead;
public Peer me;
public Peer[] peers;
public async void Start() {
string publicIP, localIP;
// GetIPs();
void GetIPs()
{
using (Socket socket = new Socket(AddressFamily.InterNetwork, SocketType.Dgram, 0))
{
socket.Connect("8.8.8.8", 65530);
IPEndPoint endPoint = socket.LocalEndPoint as IPEndPoint;
localIP = endPoint.Address.ToString();
}
// Console.WriteLine("Your local IP is: " + localIP);
publicIP = new WebClient().DownloadString("https://ipv4.icanhazip.com/").TrimEnd();
// Console.WriteLine("Your IP is: " + publicIP);
}
public void Start() {
socket = new Socket(AddressFamily.InterNetwork, SocketType.Dgram, ProtocolType.Udp);
string ip = "192.168.1.70";
// ip = "139.177.201.219";
EndPoint serverEndPoint = new IPEndPoint(IPAddress.Parse(ip), 1234);
socket.Connect(serverEndPoint);
data = new byte[1024];
rData = new byte[bufferSize];
wData = new byte[bufferSize];
peers = new Peer[64];
Thread.Sleep(1000); // useful?
Thread readThread = new Thread(Read);
readThread.Start();
Thread writeThread = new Thread(Write);
writeThread.Start();
// socket.Close();
}
void Read() {
bool running = true;
while (running) {
while (socket.Available > 0) {
try {socket.Receive(data, 0, data.Length, SocketFlags.None);}
catch (Exception e) {
try { socket.Receive(rData, 0, bufferSize, SocketFlags.None); } catch (Exception e) {
Console.WriteLine($"can't connect to the server: {e}");
return;
}
head = 0;
rHead = 0;
int id = ReadInt();
if (id != 0) {
int index = -1;
@ -72,66 +69,88 @@ public class MonoNet {
Console.WriteLine("too many peers");
return;
}
peers[index].cursor = ReadVec3();
peers[index].cursorA = ReadVec3();
peers[index].cursorB = ReadVec3();
peers[index].cursorC = ReadVec3();
peers[index].cursorD = ReadVec3();
peers[index].headset = ReadPose();
peers[index].offHand = ReadPose();
peers[index].mainHand = ReadPose();
}
}
}
}
data = new byte[1024];
head = 0;
void Write() {
bool running = true;
while (running) {
wHead = 0;
WriteInt(me.id);
WriteVec3(me.cursor);
WriteVec3(me.cursorA);
WriteVec3(me.cursorB);
WriteVec3(me.cursorC);
WriteVec3(me.cursorD);
WritePose(me.headset);
WritePose(me.offHand);
WritePose(me.mainHand);
socket.Send(data);
socket.Send(wData);
await Task.Delay(1);
Thread.Sleep(60);
}
socket.Close();
}
int ReadInt() {
int value = BitConverter.ToInt32(data, head);
head += 4;
int value = BitConverter.ToInt32(rData, rHead);
rHead += 4;
return value;
} void WriteInt(int value) {
BitConverter.GetBytes(value).CopyTo(data, head);
head += 4;
}
void WriteInt(int value) {
BitConverter.GetBytes(value).CopyTo(wData, wHead);
wHead += 4;
}
float ReadFloat() {
float value = BitConverter.ToSingle(rData, rHead);
rHead += 4;
return value;
}
void WriteFloat(float value) {
BitConverter.GetBytes(value).CopyTo(wData, wHead);
wHead += 4;
}
Vec3 ReadVec3() {
Vec3 value = new Vec3(
BitConverter.ToSingle(data, head),
BitConverter.ToSingle(data, head + 4),
BitConverter.ToSingle(data, head + 8)
BitConverter.ToSingle(rData, rHead),
BitConverter.ToSingle(rData, rHead + 4),
BitConverter.ToSingle(rData, rHead + 8)
);
head += 12;
rHead += 12;
return value;
} void WriteVec3(Vec3 vec) {
BitConverter.GetBytes(vec.x).CopyTo(data, head);
BitConverter.GetBytes(vec.y).CopyTo(data, head + 4);
BitConverter.GetBytes(vec.z).CopyTo(data, head + 8);
head += 12;
}
void WriteVec3(Vec3 vec) {
BitConverter.GetBytes(vec.x).CopyTo(wData, wHead);
BitConverter.GetBytes(vec.y).CopyTo(wData, wHead + 4);
BitConverter.GetBytes(vec.z).CopyTo(wData, wHead + 8);
wHead += 12;
}
Quat ReadQuat() {
Quat value = new Quat(
BitConverter.ToSingle(data, head),
BitConverter.ToSingle(data, head + 4),
BitConverter.ToSingle(data, head + 8),
BitConverter.ToSingle(data, head + 12)
BitConverter.ToSingle(rData, rHead),
BitConverter.ToSingle(rData, rHead + 4),
BitConverter.ToSingle(rData, rHead + 8),
BitConverter.ToSingle(rData, rHead + 12)
);
head += 16;
rHead += 16;
return value;
} void WriteQuat(Quat quat) {
BitConverter.GetBytes(quat.x).CopyTo(data, head);
BitConverter.GetBytes(quat.y).CopyTo(data, head + 4);
BitConverter.GetBytes(quat.z).CopyTo(data, head + 8);
BitConverter.GetBytes(quat.w).CopyTo(data, head + 12);
head += 16;
}
void WriteQuat(Quat quat) {
BitConverter.GetBytes(quat.x).CopyTo(wData, wHead);
BitConverter.GetBytes(quat.y).CopyTo(wData, wHead + 4);
BitConverter.GetBytes(quat.z).CopyTo(wData, wHead + 8);
BitConverter.GetBytes(quat.w).CopyTo(wData, wHead + 12);
wHead += 16;
}
Pose ReadPose() {
@ -139,27 +158,42 @@ public class MonoNet {
ReadVec3(),
ReadQuat()
);
} void WritePose(Pose pose) {
}
void WritePose(Pose pose) {
WriteVec3(pose.position);
WriteQuat(pose.orientation);
}
string localIP, publicIP;
void GetIPs() {
using (Socket socket = new Socket(AddressFamily.InterNetwork, SocketType.Dgram, 0)) {
socket.Connect("8.8.8.8", 65530);
IPEndPoint endPoint = socket.LocalEndPoint as IPEndPoint;
localIP = endPoint.Address.ToString();
}
publicIP = new WebClient().DownloadString("https://ipv4.icanhazip.com/").TrimEnd();
}
Mesh meshCube = Default.MeshCube;
Material matCube = Default.Material;
public void Cubee(Matrix m) {
meshCube.Draw(matCube, m);
}
public class Peer
{
public class Peer {
public int id;
public Vec3 cursor;
public Vec3 cursorA, cursorB, cursorC, cursorD;
public Pose headset;
public Pose offHand;
public Pose mainHand;
public Sound voice;
public SoundInst voiceInst; // update position
public Peer(int id) {
this.id = id;
// voice = Sound.CreateStream(0.5f);
// voiceInst = voice.Play(Vec3.Zero, 0.5f);
}
}
}

244
Program.cs
View file

@ -2,65 +2,74 @@ using StereoKit;
using System;
class Program {
static void Main(string[] args) {
static void Main(string[] args) {
SKSettings settings = new SKSettings {
appName = "oriels",
assetsFolder = "Assets",
};
if (!SK.Initialize(settings))
if (!SK.Initialize(settings))
Environment.Exit(1);
// TextStyle style = Text.MakeStyle(Font.FromFile("DMMono-Regular.ttf"), 0.1f, Color.White);
Mono.Run();
}
Mono mono = new Mono();
mono.Run();
}
}
public static class Mono {
public class Mono {
public Mic mic;
public Controller offHand, mainHand;
public static Controller offHand, mainHand;
public void Run() {
// mic = new Mic();
public static void Run() {
MonoNet net = new MonoNet();
MonoNet net = new MonoNet(this);
net.Start();
// StretchCursor stretchCursor = new StretchCursor();
CubicFlow cubicFlow = new CubicFlow();
// ReachCursor reachCursor = new ReachCursor();
// SupineCursor supineCursor = new SupineCursor();
// ClawCursor clawCursor = new ClawCursor();
Oriel oriel = new Oriel();
oriel.Start();
// ColorCube cube = new ColorCube();
// OrbitalView.strength = 4;
// OrbitalView.distance = 0.4f;
// cube.thickness = 0.01f;
StretchCursor stretchCursor = new StretchCursor();
// ReachCursor reachCursor = new ReachCursor();
// SupineCursor supineCursor = new SupineCursor();
// ClawCursor clawCursor = new ClawCursor();
// Oriel oriel = new Oriel();
// oriel.Start();
// Lerper lerper = new Lerper();
while (SK.Step(() => {
offHand = Input.Controller(Handed.Left);
mainHand = Input.Controller(Handed.Right);
// mainHand.aim = Input.Hand(Handed.Right).palm;
stretchCursor.Step(offHand.aim, mainHand.aim);
net.me.cursor = stretchCursor.pos;
// net.me.cursor = Vec3.Up * (float)Math.Sin(Time.Total);
cubicFlow.Step(offHand.aim, mainHand.aim);
cubicFlow.DrawSelf();
net.me.cursorA = cubicFlow.p0;
net.me.cursorB = cubicFlow.p1;
net.me.cursorC = cubicFlow.p2;
net.me.cursorD = cubicFlow.p3;
// net.me.cursorA = Vec3.Up * (float)Math.Sin(Time.Total);
net.me.headset = Input.Head;
net.me.offHand = offHand.aim;
net.me.mainHand = mainHand.aim;
for (int i = 0; i < net.peers.Length; i++) {
MonoNet.Peer peer = net.peers[i];
if (peer != null) {
net.Cubee(Matrix.TRS(peer.cursor, Quat.Identity, Vec3.One * 0.05f));
net.Cubee(Matrix.TRS(peer.cursorA, Quat.Identity, Vec3.One * 0.05f));
net.Cubee(peer.headset.ToMatrix(Vec3.One * 0.3f));
net.Cubee(peer.offHand.ToMatrix(Vec3.One * 0.1f));
net.Cubee(peer.mainHand.ToMatrix(Vec3.One * 0.1f));
cubicFlow.Draw(peer.cursorA, peer.cursorB, peer.cursorC, peer.cursorD);
}
}
oriel.Step();
// domHand subHand ?? :3
// if (offHand.trigger.) {
@ -86,48 +95,160 @@ public static class Mono {
// mainHand.IsStickClicked
// );
// oriel.Step();
// cursor.Draw(Matrix.S(0.1f));
}));
})) ;
SK.Shutdown();
}
}
public class DrawKey {
public int x, y;
public Key key;
public DrawKey(int x, int y, Key key) {
this.x = x;
this.y = y;
this.key = key;
public class Mic {
public float[] bufferRaw = new float[0];
public int bufferRawSize = 0;
public int comp = 8;
public float[] buffer = new float[0];
public int bufferSize = 0;
FilterButterworth filter;
public void Step() {
if (Microphone.IsRecording) {
// Ensure our buffer of samples is large enough to contain all the
// data the mic has ready for us this frame
if (Microphone.Sound.UnreadSamples > bufferRaw.Length) {
bufferRaw = new float[Microphone.Sound.UnreadSamples];
buffer = new float[Microphone.Sound.UnreadSamples / comp];
}
// Read data from the microphone stream into our buffer, and track
// how much was actually read. Since the mic data collection runs in
// a separate thread, this will often be a little inconsistent. Some
// frames will have nothing ready, and others may have a lot!
bufferRawSize = Microphone.Sound.ReadSamples(ref bufferRaw);
bufferSize = bufferRawSize / comp;
if (bufferSize > 0) {
// LowPassFilter lowpass = new LowPassFilter(48000 / comp / 2, 2, 48000);
for (int i = 0; i < bufferRawSize; i++) {
// bufferRaw[i] = (float)lowpass.compute(bufferRaw[i]);
filter.Update(bufferRaw[i]);
bufferRaw[i] = filter.Value;
}
// voice.WriteSamples(bufferRaw);
buffer[0] = bufferRaw[0];
for (int i = 1; i < bufferSize; i++) {
buffer[i] = bufferRaw[i * comp - 1];
}
// upsample
float[] upsampled = new float[bufferSize * comp];
for (int i = 0; i < bufferSize - 1; i++) {
upsampled[Math.Max(i * comp - 1, 0)] = buffer[i];
for (int j = 1; j < comp; j++) {
upsampled[i * comp - 1 + j] = SKMath.Lerp(buffer[i], buffer[i + 1], (float)j / (float)comp);
}
}
voice.WriteSamples(upsampled);
}
} else {
Microphone.Start();
voice = Sound.CreateStream(0.5f);
voiceInst = voice.Play(Vec3.Zero, 0.5f);
filter = new FilterButterworth(48000 / comp / 2, 48000, FilterButterworth.PassType.Lowpass, (float)Math.Sqrt(2));
}
}
public Sound voice;
public SoundInst voiceInst; // update position
public class FilterButterworth {
/// <summary>
/// rez amount, from sqrt(2) to ~ 0.1
/// </summary>
private readonly float resonance;
private readonly float frequency;
private readonly int sampleRate;
private readonly PassType passType;
private readonly float c, a1, a2, a3, b1, b2;
/// <summary>
/// Array of input values, latest are in front
/// </summary>
private float[] inputHistory = new float[2];
/// <summary>
/// Array of output values, latest are in front
/// </summary>
private float[] outputHistory = new float[3];
public FilterButterworth(float frequency, int sampleRate, PassType passType, float resonance) {
this.resonance = resonance;
this.frequency = frequency;
this.sampleRate = sampleRate;
this.passType = passType;
switch (passType) {
case PassType.Lowpass:
c = 1.0f / (float)Math.Tan(Math.PI * frequency / sampleRate);
a1 = 1.0f / (1.0f + resonance * c + c * c);
a2 = 2f * a1;
a3 = a1;
b1 = 2.0f * (1.0f - c * c) * a1;
b2 = (1.0f - resonance * c + c * c) * a1;
break;
case PassType.Highpass:
c = (float)Math.Tan(Math.PI * frequency / sampleRate);
a1 = 1.0f / (1.0f + resonance * c + c * c);
a2 = -2f * a1;
a3 = a1;
b1 = 2.0f * (c * c - 1.0f) * a1;
b2 = (1.0f - resonance * c + c * c) * a1;
break;
}
}
public enum PassType {
Highpass,
Lowpass,
}
public void Update(float newInput) {
float newOutput = a1 * newInput + a2 * this.inputHistory[0] + a3 * this.inputHistory[1] - b1 * this.outputHistory[0] - b2 * this.outputHistory[1];
this.inputHistory[1] = this.inputHistory[0];
this.inputHistory[0] = newInput;
this.outputHistory[2] = this.outputHistory[1];
this.outputHistory[1] = this.outputHistory[0];
this.outputHistory[0] = newOutput;
}
public float Value {
get { return this.outputHistory[0]; }
}
}
}
public class Lerper
{
public class Lerper {
public float t = 0;
public float spring = 1;
public float dampen = 1;
float vel;
public void Step(float to = 1, bool bounce = false)
{
public void Step(float to = 1, bool bounce = false) {
float dir = to - t;
vel += dir * spring * Time.Elapsedf;
if (Math.Sign(vel) != Math.Sign(dir))
{
if (Math.Sign(vel) != Math.Sign(dir)) {
vel *= 1 - (dampen * Time.Elapsedf);
}
else
{
} else {
vel *= 1 - (dampen * 0.33f * Time.Elapsedf);
}
float newt = t + vel * Time.Elapsedf;
if (bounce && (newt < 0 || newt > 1))
{
if (bounce && (newt < 0 || newt > 1)) {
vel *= -0.5f;
newt = Math.Clamp(newt, 0, 1);
}
@ -135,20 +256,16 @@ public class Lerper
t = newt;
}
public void Reset()
{
public void Reset() {
t = vel = 0;
}
}
public class Oriel {
public Bounds bounds;
// render
// Model model = Model.FromFile("oriel.glb", Shader.FromFile("oriel.hlsl"));
Material mat = new Material(Shader.FromFile("oriel.hlsl"));
Mesh mesh = Default.MeshCube;
Mesh quad = Default.MeshQuad;
Vec3 _dimensions;
public void Start() {
bounds = new Bounds(Vec3.Zero, new Vec3(1f, 0.5f, 0.5f));
@ -158,24 +275,35 @@ public class Oriel {
public void Step() {
// circle around center
// bounds.center = Quat.FromAngles(0, 0, Time.Totalf * 60) * Vec3.Up * 0.3f;
// bounds.dimensions = _dimensions * (1f + (MathF.Sin(Time.Totalf * 3) * 0.3f));
mat.Transparency = Transparency.Blend;
// mat.FaceCull = Cull.Front;
mat.SetFloat("_height", bounds.dimensions.y);
mat.SetFloat("_ypos", bounds.center.y);
// mat.FaceCull = Cull.None;
mesh.Draw(mat, Matrix.TRS(bounds.center, Quat.Identity, bounds.dimensions));
Pose head = Input.Head;
Vec3 quadPos = head.position + head.Forward * 0.04f;
if (bounds.Contains(head.position, quadPos)) {
quad.Draw(mat, Matrix.TRS(quadPos, Quat.LookAt(quadPos, head.position), Vec3.One * 0.5f));
}
}
}
public class Bitting {
public class DrawKey {
public int x, y;
public Key key;
public DrawKey(int x, int y, Key key) {
this.x = x;
this.y = y;
this.key = key;
}
}
Tex tex = new Tex(TexType.Image, TexFormat.Rgba32);
Material material = Default.Material;
Mesh quad = Default.MeshQuad;
int [,] bitchar = new int[,] {
int[,] bitchar = new int[,] {
{0, 0, 0, 0, 0, 0, 0},
{0, 0, 0, 0, 0, 0, 0},
{0, 0, 0, 0, 0, 0, 0},
@ -202,7 +330,7 @@ public class Bitting {
lastKey = null;
}
for (int i = 0; i < drawKeys.Length; i++){
for (int i = 0; i < drawKeys.Length; i++) {
DrawKey drawKey = drawKeys[i];
if (Input.Key(drawKey.key).IsJustActive()) {
bitchar[drawKey.x, drawKey.y] = 1;
@ -252,9 +380,9 @@ public static class PullRequest {
Vec3 ds = b.dimensions;
for (int i = 0; i < 4; i++) {
Quat q = Quat.FromAngles(i * 90, 0, 0);
Lines.Add(q * (new Vec3(0, 0, 0) - c) * ds, q * (new Vec3(0, 1, 0) - c) * ds, color, color, thickness);
Lines.Add(q * (new Vec3(0, 1, 0) - c) * ds, q * (new Vec3(1, 1, 0) - c) * ds, color, color, thickness);
Lines.Add(q * (new Vec3(1, 1, 0) - c) * ds, q * (new Vec3(1, 0, 0) - c) * ds, color, color, thickness);
Lines.Add(q * (new Vec3(0, 0, 0) - c) * ds, q * (new Vec3(0, 1, 0) - c) * ds, color, color, thickness);
Lines.Add(q * (new Vec3(0, 1, 0) - c) * ds, q * (new Vec3(1, 1, 0) - c) * ds, color, color, thickness);
Lines.Add(q * (new Vec3(1, 1, 0) - c) * ds, q * (new Vec3(1, 0, 0) - c) * ds, color, color, thickness);
// convert to linepoints
}

40
SpatialCursor.cs
View file

@ -37,12 +37,46 @@ public class ReachCursor : SpatialCursor {
}
public class TwistCursor : SpatialCursor {
public void Step(Vec3 mainPos, Quat mainQuat) {
public void Step(Vec3 mainPos, Quat mainQuat, float str = 1) {
Quat rel = Quat.LookAt(Vec3.Zero, mainQuat * Vec3.Forward);
float twist = (Vec3.Dot(rel * -Vec3.Right, mainQuat * Vec3.Up) + 1) / 2;
pos = mainPos + mainQuat * Vec3.Forward * twist;
pos = mainPos + mainQuat * Vec3.Forward * twist * str;
model.Draw(Matrix.TS(pos, 0.06f));
model.Draw(Matrix.TS(pos, 0.02f));
}
}
public class CubicFlow {
public Vec3 p0, p1, p2, p3;
public TwistCursor offTwist = new TwistCursor();
public TwistCursor mainTwist = new TwistCursor();
public void Step(Pose offPose, Pose mainPose) {
offTwist.Step(offPose.position, offPose.orientation, 3);
mainTwist.Step(mainPose.position, mainPose.orientation, 3);
p0 = offPose.position;
p1 = offTwist.pos;
p2 = mainTwist.pos;
p3 = mainPose.position;
// if toggle
}
public void DrawSelf() {
Draw(this.p0, this.p1, this.p2, this.p3);
}
LinePoint[] bezier = new LinePoint[64];
public void Draw(Vec3 p0, Vec3 p1, Vec3 p2, Vec3 p3) {
for (int i = 0; i < bezier.Length; i++) {
float t = i / ((float)bezier.Length - 1);
Vec3 a = Vec3.Lerp(p0, p1, t);
Vec3 b = Vec3.Lerp(p1, p2, t);
Vec3 c = Vec3.Lerp(p2, p3, t);
Vec3 pos = Vec3.Lerp(Vec3.Lerp(a, b, t), Vec3.Lerp(b, c, t), t);
bezier[i] = new LinePoint(pos, Color.White, 0.01f);
}
Lines.Add(bezier);
}
}

16
omnisharp.json Normal file
View file

@ -0,0 +1,16 @@
{
"FormattingOptions": {
"NewLinesForBracesInLambdaExpressionBody": false,
"NewLinesForBracesInAnonymousMethods": false,
"NewLinesForBracesInAnonymousTypes": false,
"NewLinesForBracesInControlBlocks": false,
"NewLinesForBracesInTypes": false,
"NewLinesForBracesInMethods": false,
"NewLinesForBracesInProperties": false,
"NewLinesForBracesInObjectCollectionArrayInitializers": false,
"NewLinesForBracesInAccessors": false,
"NewLineForElse": false,
"NewLineForCatch": false,
"NewLineForFinally": false
}
}