| @@ -0,0 +1,37 @@ | ||
| //ViewDebugger.cs | ||
| //Created by Aaron C Gaudette on 13.07.16 | ||
|
|
||
| using UnityEngine; | ||
|
|
||
| namespace Holojam.Tools{ | ||
| public class ViewDebugger : Controller{ | ||
| public string label, scope, source; | ||
| public bool tracked, ignoreTracking; | ||
|
|
||
| protected override ProcessDelegate Process{get{return UpdateData;}} | ||
|
|
||
| protected override string labelField{get{return label;}} | ||
| protected override string scopeField{get{return scope;}} | ||
| protected override bool isSending{get{return false;}} | ||
|
|
||
| public Vector3[] triples; | ||
| public Quaternion[] quads; | ||
| public float[] floats; | ||
| public int[] ints; | ||
| public byte[] chars; | ||
| public string text; | ||
|
|
||
| void UpdateData(){ | ||
| source = view.source; | ||
| tracked = view.tracked; | ||
| ignoreTracking = view.ignoreTracking; | ||
|
|
||
| triples = view.triples; | ||
| quads = view.quads; | ||
| floats = view.floats; | ||
| ints = view.ints; | ||
| chars = view.chars; | ||
| text = view.text; | ||
| } | ||
| } | ||
| } |
| @@ -1,114 +1,112 @@ | ||
| //Viewer.cs | ||
| //Created by Aaron C Gaudette on 07.07.16 | ||
|
|
||
| using UnityEngine; | ||
|
|
||
| namespace Holojam.Tools{ | ||
| [ExecuteInEditMode] | ||
| public class Viewer : MonoBehaviour{ | ||
| public enum TrackingType{DIRECT,ACTOR}; | ||
| public TrackingType trackingType = TrackingType.ACTOR; | ||
|
|
||
| public Converter converter; | ||
|
|
||
| //Get tracking data from actor (recommended coupling), or from the view? | ||
| public Actor actor = null; | ||
| [HideInInspector] public Network.View view = null; | ||
| public int index = 0; | ||
| public bool localSpace = false; | ||
|
|
||
| //Update late to catch local space updates | ||
| void LateUpdate(){ | ||
| if(converter==null){ | ||
| Debug.LogWarning("Viewer: Converter is null!"); | ||
| return; | ||
| } | ||
|
|
||
| if(converter.device==Converter.Device.VIVE) | ||
| return; | ||
|
|
||
| //Flush extra components if necessary | ||
| Network.View[] views = GetComponents<Network.View>(); | ||
| if((view==null && views.Length>0) || (view!=null && (views.Length>1 || views.Length==0))){ | ||
| foreach(Network.View v in views)DestroyImmediate(v); | ||
| view=null; //In case the view has been set to a prefab value | ||
| } | ||
|
|
||
| //Automatically add a View component if not using a reference actor | ||
| if(actor==view){ | ||
| view = gameObject.AddComponent<Network.View>() as Network.View; | ||
| view.triples = new Vector3[1]; | ||
| view.quads = new Quaternion[1]; | ||
| } | ||
| else if(actor!=null && view!=null)DestroyImmediate(view); | ||
|
|
||
| if(view!=null){ | ||
| view.label = Network.Canon.IndexToLabel(index); | ||
| view.scope = Network.Client.SEND_SCOPE; | ||
| } | ||
| if(!Application.isPlaying)return; | ||
|
|
||
| Vector3 sourcePosition = GetPosition(); | ||
| Quaternion sourceRotation = GetRotation(); | ||
| bool sourceTracked = GetTracked(); | ||
|
|
||
| if(sourceTracked){ | ||
| //TrackingType.DIRECT: | ||
| //Direct raw conversion from Converter (no additional transformation) | ||
|
|
||
| //TrackingType.ACTOR: | ||
| //Loops once through the network (Converter -> Server -> Actor -> Viewer) | ||
|
|
||
| transform.position = sourcePosition; | ||
| if(BuildManager.IsMasterPC()) | ||
| transform.rotation = sourceRotation; | ||
| else{ | ||
| //Negate IMU | ||
| Quaternion raw = Quaternion.identity; | ||
| switch(converter.device){ | ||
| case Converter.Device.CARDBOARD: | ||
| raw = transform.GetChild(0).localRotation; | ||
| break; | ||
| case Converter.Device.DAYDREAM: | ||
| raw = UnityEngine.VR.InputTracking.GetLocalRotation( | ||
| UnityEngine.VR.VRNode.CenterEye | ||
| ); | ||
| break; | ||
| } | ||
| sourceRotation*=Quaternion.Inverse(raw); | ||
| transform.rotation = sourceRotation; | ||
| } | ||
| }else if(BuildManager.IsMasterPC()) //Fall back to IMU | ||
| transform.rotation = sourceRotation; | ||
|
|
||
| //Apply local rotation if necessary | ||
| if(actor!=null && actor.localSpace && actor.transform.parent!=null) | ||
| transform.rotation=actor.transform.parent.rotation*transform.rotation; | ||
| else if(actor==null && localSpace && transform.parent!=null) | ||
| transform.rotation=transform.parent.rotation*transform.rotation; | ||
| } | ||
|
|
||
| //Get tracking data from desired source | ||
| Vector3 GetPosition(){ | ||
| if(trackingType==TrackingType.DIRECT && !BuildManager.IsMasterPC()) | ||
| return converter.outputPosition; | ||
| else{ | ||
| return actor!=null? actor.center: | ||
| localSpace && transform.parent!=null? | ||
| transform.parent.TransformPoint(view.triples[0]) : view.triples[0]; | ||
| } | ||
| } | ||
| Quaternion GetRotation(){ | ||
| if(trackingType==TrackingType.DIRECT && !BuildManager.IsMasterPC()) | ||
| return converter.outputRotation; | ||
| else return actor!=null?actor.rawOrientation:view.quads[0]; | ||
| } | ||
| bool GetTracked(){ | ||
| if(trackingType==TrackingType.DIRECT && !BuildManager.IsMasterPC()) | ||
| return converter.hasInput; | ||
| else return actor!=null?actor.view.tracked:view.tracked; | ||
| } | ||
| } | ||
| } |
| @@ -0,0 +1,34 @@ | ||
| //Global.cs | ||
| //Created by Aaron C Gaudette on 11.11.16 | ||
| // | ||
|
|
||
| using UnityEngine; | ||
|
|
||
| namespace Holojam.Utility{ | ||
| public abstract class Global<T> : MonoBehaviour where T : MonoBehaviour{ | ||
| static T t; | ||
| static UnityEngine.Object lockObject = new UnityEngine.Object(); | ||
|
|
||
| protected static T global{ | ||
| get{lock(lockObject){ | ||
| if(t==null){ | ||
| T[] objects = FindObjectsOfType(typeof(T)) as T[]; | ||
| if(objects.Length==0){ | ||
| Debug.LogError("Global: "+ | ||
| "No instances of "+typeof(T)+" in scene! (static access failure)" | ||
| ); | ||
| return null; | ||
| } | ||
| t = objects[0]; | ||
| if(objects.Length>1){ | ||
| Debug.LogWarning("Global: "+ | ||
| "More than one instance ("+objects.Length+") of "+typeof(T)+" in scene! "+ | ||
| "(expect undefined behavior)",t | ||
| ); | ||
| } | ||
| } | ||
| return t; | ||
| }} | ||
| } | ||
| } | ||
| } |
| @@ -0,0 +1,28 @@ | ||
| //Palette.cs | ||
| //Created by Aaron C Gaudette on 11.11.16 | ||
|
|
||
| using UnityEngine; | ||
|
|
||
| namespace Holojam.Utility{ | ||
| public class Palette{ | ||
| public enum Colors{ | ||
| BLUE,GREEN,RED,YELLOW,SEA_FOAM | ||
| }; | ||
| public static Color Select(Colors color){ | ||
| switch(color){ | ||
| case Colors.BLUE: | ||
| return new Color(0,.5f,1); | ||
| case Colors.GREEN: | ||
| return new Color(.45f,1,.45f); | ||
| case Colors.RED: | ||
| return new Color(1,0,.38f); | ||
| case Colors.YELLOW: | ||
| return new Color(1,.84f,0); | ||
| case Colors.SEA_FOAM: | ||
| return new Color(.26f,.86f,.6f); | ||
| default: | ||
| return Color.white; | ||
| } | ||
| } | ||
| } | ||
| } |
| @@ -0,0 +1,24 @@ | ||
| //ViveRelay.cs | ||
| //Created by Aaron C Gaudette on 26.01.17 | ||
|
|
||
| using UnityEngine; | ||
|
|
||
| namespace Holojam.Vive{ | ||
| public class ViveRelay : Tools.Controller{ | ||
| protected override ProcessDelegate Process{get{return Relay;}} | ||
|
|
||
| protected override string labelField{ | ||
| get{return Network.Canon.IndexToLabel(Tools.BuildManager.BUILD_INDEX);} | ||
| } | ||
| protected override string scopeField{get{return "HolojamVive";}} | ||
| protected override bool isSending{get{return true;}} | ||
|
|
||
| protected override int triplesCount{get{return 1;}} | ||
| protected override int quadsCount{get{return 1;}} | ||
|
|
||
| void Relay(){ | ||
| UpdateTriple(0,transform.position); | ||
| UpdateQuad(0,transform.rotation); | ||
| } | ||
| } | ||
| } |
| @@ -0,0 +1,79 @@ | ||
| // automatically generated by the FlatBuffers compiler, do not modify | ||
|
|
||
| namespace Holojam.Protocol | ||
| { | ||
|
|
||
| using System; | ||
| using FlatBuffers; | ||
|
|
||
| public struct Flake : IFlatbufferObject | ||
| { | ||
| private Table __p; | ||
| public ByteBuffer ByteBuffer { get { return __p.bb; } } | ||
| public static Flake GetRootAsFlake(ByteBuffer _bb) { return GetRootAsFlake(_bb, new Flake()); } | ||
| public static Flake GetRootAsFlake(ByteBuffer _bb, Flake obj) { return (obj.__assign(_bb.GetInt(_bb.Position) + _bb.Position, _bb)); } | ||
| public void __init(int _i, ByteBuffer _bb) { __p.bb_pos = _i; __p.bb = _bb; } | ||
| public Flake __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; } | ||
|
|
||
| public string Label { get { int o = __p.__offset(4); return o != 0 ? __p.__string(o + __p.bb_pos) : null; } } | ||
| public ArraySegment<byte>? GetLabelBytes() { return __p.__vector_as_arraysegment(4); } | ||
| public Vector3? Triples(int j) { int o = __p.__offset(6); return o != 0 ? (Vector3?)(new Vector3()).__assign(__p.__vector(o) + j * 12, __p.bb) : null; } | ||
| public int TriplesLength { get { int o = __p.__offset(6); return o != 0 ? __p.__vector_len(o) : 0; } } | ||
| public Vector4? Quads(int j) { int o = __p.__offset(8); return o != 0 ? (Vector4?)(new Vector4()).__assign(__p.__vector(o) + j * 16, __p.bb) : null; } | ||
| public int QuadsLength { get { int o = __p.__offset(8); return o != 0 ? __p.__vector_len(o) : 0; } } | ||
| public float Floats(int j) { int o = __p.__offset(10); return o != 0 ? __p.bb.GetFloat(__p.__vector(o) + j * 4) : (float)0; } | ||
| public int FloatsLength { get { int o = __p.__offset(10); return o != 0 ? __p.__vector_len(o) : 0; } } | ||
| public ArraySegment<byte>? GetFloatsBytes() { return __p.__vector_as_arraysegment(10); } | ||
| public int Ints(int j) { int o = __p.__offset(12); return o != 0 ? __p.bb.GetInt(__p.__vector(o) + j * 4) : (int)0; } | ||
| public int IntsLength { get { int o = __p.__offset(12); return o != 0 ? __p.__vector_len(o) : 0; } } | ||
| public ArraySegment<byte>? GetIntsBytes() { return __p.__vector_as_arraysegment(12); } | ||
| public sbyte Chars(int j) { int o = __p.__offset(14); return o != 0 ? __p.bb.GetSbyte(__p.__vector(o) + j * 1) : (sbyte)0; } | ||
| public int CharsLength { get { int o = __p.__offset(14); return o != 0 ? __p.__vector_len(o) : 0; } } | ||
| public ArraySegment<byte>? GetCharsBytes() { return __p.__vector_as_arraysegment(14); } | ||
| public string Text { get { int o = __p.__offset(16); return o != 0 ? __p.__string(o + __p.bb_pos) : null; } } | ||
| public ArraySegment<byte>? GetTextBytes() { return __p.__vector_as_arraysegment(16); } | ||
|
|
||
| public static Offset<Flake> CreateFlake(FlatBufferBuilder builder, | ||
| StringOffset labelOffset = default(StringOffset), | ||
| VectorOffset triplesOffset = default(VectorOffset), | ||
| VectorOffset quadsOffset = default(VectorOffset), | ||
| VectorOffset floatsOffset = default(VectorOffset), | ||
| VectorOffset intsOffset = default(VectorOffset), | ||
| VectorOffset charsOffset = default(VectorOffset), | ||
| StringOffset textOffset = default(StringOffset)) { | ||
| builder.StartObject(7); | ||
| Flake.AddText(builder, textOffset); | ||
| Flake.AddChars(builder, charsOffset); | ||
| Flake.AddInts(builder, intsOffset); | ||
| Flake.AddFloats(builder, floatsOffset); | ||
| Flake.AddQuads(builder, quadsOffset); | ||
| Flake.AddTriples(builder, triplesOffset); | ||
| Flake.AddLabel(builder, labelOffset); | ||
| return Flake.EndFlake(builder); | ||
| } | ||
|
|
||
| public static void StartFlake(FlatBufferBuilder builder) { builder.StartObject(7); } | ||
| public static void AddLabel(FlatBufferBuilder builder, StringOffset labelOffset) { builder.AddOffset(0, labelOffset.Value, 0); } | ||
| public static void AddTriples(FlatBufferBuilder builder, VectorOffset triplesOffset) { builder.AddOffset(1, triplesOffset.Value, 0); } | ||
| public static void StartTriplesVector(FlatBufferBuilder builder, int numElems) { builder.StartVector(12, numElems, 4); } | ||
| public static void AddQuads(FlatBufferBuilder builder, VectorOffset quadsOffset) { builder.AddOffset(2, quadsOffset.Value, 0); } | ||
| public static void StartQuadsVector(FlatBufferBuilder builder, int numElems) { builder.StartVector(16, numElems, 4); } | ||
| public static void AddFloats(FlatBufferBuilder builder, VectorOffset floatsOffset) { builder.AddOffset(3, floatsOffset.Value, 0); } | ||
| public static VectorOffset CreateFloatsVector(FlatBufferBuilder builder, float[] data) { builder.StartVector(4, data.Length, 4); for (int i = data.Length - 1; i >= 0; i--) builder.AddFloat(data[i]); return builder.EndVector(); } | ||
| public static void StartFloatsVector(FlatBufferBuilder builder, int numElems) { builder.StartVector(4, numElems, 4); } | ||
| public static void AddInts(FlatBufferBuilder builder, VectorOffset intsOffset) { builder.AddOffset(4, intsOffset.Value, 0); } | ||
| public static VectorOffset CreateIntsVector(FlatBufferBuilder builder, int[] data) { builder.StartVector(4, data.Length, 4); for (int i = data.Length - 1; i >= 0; i--) builder.AddInt(data[i]); return builder.EndVector(); } | ||
| public static void StartIntsVector(FlatBufferBuilder builder, int numElems) { builder.StartVector(4, numElems, 4); } | ||
| public static void AddChars(FlatBufferBuilder builder, VectorOffset charsOffset) { builder.AddOffset(5, charsOffset.Value, 0); } | ||
| public static VectorOffset CreateCharsVector(FlatBufferBuilder builder, sbyte[] data) { builder.StartVector(1, data.Length, 1); for (int i = data.Length - 1; i >= 0; i--) builder.AddSbyte(data[i]); return builder.EndVector(); } | ||
| public static void StartCharsVector(FlatBufferBuilder builder, int numElems) { builder.StartVector(1, numElems, 1); } | ||
| public static void AddText(FlatBufferBuilder builder, StringOffset textOffset) { builder.AddOffset(6, textOffset.Value, 0); } | ||
| public static Offset<Flake> EndFlake(FlatBufferBuilder builder) { | ||
| int o = builder.EndObject(); | ||
| builder.Required(o, 4); // label | ||
| return new Offset<Flake>(o); | ||
| } | ||
| }; | ||
|
|
||
|
|
||
| } |
| @@ -0,0 +1,55 @@ | ||
| // automatically generated by the FlatBuffers compiler, do not modify | ||
|
|
||
| namespace Holojam.Protocol | ||
| { | ||
|
|
||
| using System; | ||
| using FlatBuffers; | ||
|
|
||
| public struct Packet : IFlatbufferObject | ||
| { | ||
| private Table __p; | ||
| public ByteBuffer ByteBuffer { get { return __p.bb; } } | ||
| public static Packet GetRootAsPacket(ByteBuffer _bb) { return GetRootAsPacket(_bb, new Packet()); } | ||
| public static Packet GetRootAsPacket(ByteBuffer _bb, Packet obj) { return (obj.__assign(_bb.GetInt(_bb.Position) + _bb.Position, _bb)); } | ||
| public void __init(int _i, ByteBuffer _bb) { __p.bb_pos = _i; __p.bb = _bb; } | ||
| public Packet __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; } | ||
|
|
||
| public string Scope { get { int o = __p.__offset(4); return o != 0 ? __p.__string(o + __p.bb_pos) : null; } } | ||
| public ArraySegment<byte>? GetScopeBytes() { return __p.__vector_as_arraysegment(4); } | ||
| public string Origin { get { int o = __p.__offset(6); return o != 0 ? __p.__string(o + __p.bb_pos) : null; } } | ||
| public ArraySegment<byte>? GetOriginBytes() { return __p.__vector_as_arraysegment(6); } | ||
| public PacketType Type { get { int o = __p.__offset(8); return o != 0 ? (PacketType)__p.bb.GetSbyte(o + __p.bb_pos) : PacketType.Update; } } | ||
| public Flake? Flakes(int j) { int o = __p.__offset(10); return o != 0 ? (Flake?)(new Flake()).__assign(__p.__indirect(__p.__vector(o) + j * 4), __p.bb) : null; } | ||
| public int FlakesLength { get { int o = __p.__offset(10); return o != 0 ? __p.__vector_len(o) : 0; } } | ||
|
|
||
| public static Offset<Packet> CreatePacket(FlatBufferBuilder builder, | ||
| StringOffset scopeOffset = default(StringOffset), | ||
| StringOffset originOffset = default(StringOffset), | ||
| PacketType type = PacketType.Update, | ||
| VectorOffset flakesOffset = default(VectorOffset)) { | ||
| builder.StartObject(4); | ||
| Packet.AddFlakes(builder, flakesOffset); | ||
| Packet.AddOrigin(builder, originOffset); | ||
| Packet.AddScope(builder, scopeOffset); | ||
| Packet.AddType(builder, type); | ||
| return Packet.EndPacket(builder); | ||
| } | ||
|
|
||
| public static void StartPacket(FlatBufferBuilder builder) { builder.StartObject(4); } | ||
| public static void AddScope(FlatBufferBuilder builder, StringOffset scopeOffset) { builder.AddOffset(0, scopeOffset.Value, 0); } | ||
| public static void AddOrigin(FlatBufferBuilder builder, StringOffset originOffset) { builder.AddOffset(1, originOffset.Value, 0); } | ||
| public static void AddType(FlatBufferBuilder builder, PacketType type) { builder.AddSbyte(2, (sbyte)type, 0); } | ||
| public static void AddFlakes(FlatBufferBuilder builder, VectorOffset flakesOffset) { builder.AddOffset(3, flakesOffset.Value, 0); } | ||
| public static VectorOffset CreateFlakesVector(FlatBufferBuilder builder, Offset<Flake>[] data) { builder.StartVector(4, data.Length, 4); for (int i = data.Length - 1; i >= 0; i--) builder.AddOffset(data[i].Value); return builder.EndVector(); } | ||
| public static void StartFlakesVector(FlatBufferBuilder builder, int numElems) { builder.StartVector(4, numElems, 4); } | ||
| public static Offset<Packet> EndPacket(FlatBufferBuilder builder) { | ||
| int o = builder.EndObject(); | ||
| builder.Required(o, 10); // flakes | ||
| return new Offset<Packet>(o); | ||
| } | ||
| public static void FinishPacketBuffer(FlatBufferBuilder builder, Offset<Packet> offset) { builder.Finish(offset.Value); } | ||
| }; | ||
|
|
||
|
|
||
| } |
| @@ -0,0 +1,13 @@ | ||
| // automatically generated by the FlatBuffers compiler, do not modify | ||
|
|
||
| namespace Holojam.Protocol | ||
| { | ||
|
|
||
| public enum PacketType : sbyte | ||
| { | ||
| Update = 0, | ||
| Event = 1, | ||
| }; | ||
|
|
||
|
|
||
| } |
| @@ -0,0 +1,30 @@ | ||
| // automatically generated by the FlatBuffers compiler, do not modify | ||
|
|
||
| namespace Holojam.Protocol | ||
| { | ||
|
|
||
| using System; | ||
| using FlatBuffers; | ||
|
|
||
| public struct Vector3 : IFlatbufferObject | ||
| { | ||
| private Struct __p; | ||
| public ByteBuffer ByteBuffer { get { return __p.bb; } } | ||
| public void __init(int _i, ByteBuffer _bb) { __p.bb_pos = _i; __p.bb = _bb; } | ||
| public Vector3 __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; } | ||
|
|
||
| public float X { get { return __p.bb.GetFloat(__p.bb_pos + 0); } } | ||
| public float Y { get { return __p.bb.GetFloat(__p.bb_pos + 4); } } | ||
| public float Z { get { return __p.bb.GetFloat(__p.bb_pos + 8); } } | ||
|
|
||
| public static Offset<Vector3> CreateVector3(FlatBufferBuilder builder, float X, float Y, float Z) { | ||
| builder.Prep(4, 12); | ||
| builder.PutFloat(Z); | ||
| builder.PutFloat(Y); | ||
| builder.PutFloat(X); | ||
| return new Offset<Vector3>(builder.Offset); | ||
| } | ||
| }; | ||
|
|
||
|
|
||
| } |
| @@ -0,0 +1,32 @@ | ||
| // automatically generated by the FlatBuffers compiler, do not modify | ||
|
|
||
| namespace Holojam.Protocol | ||
| { | ||
|
|
||
| using System; | ||
| using FlatBuffers; | ||
|
|
||
| public struct Vector4 : IFlatbufferObject | ||
| { | ||
| private Struct __p; | ||
| public ByteBuffer ByteBuffer { get { return __p.bb; } } | ||
| public void __init(int _i, ByteBuffer _bb) { __p.bb_pos = _i; __p.bb = _bb; } | ||
| public Vector4 __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; } | ||
|
|
||
| public float X { get { return __p.bb.GetFloat(__p.bb_pos + 0); } } | ||
| public float Y { get { return __p.bb.GetFloat(__p.bb_pos + 4); } } | ||
| public float Z { get { return __p.bb.GetFloat(__p.bb_pos + 8); } } | ||
| public float W { get { return __p.bb.GetFloat(__p.bb_pos + 12); } } | ||
|
|
||
| public static Offset<Vector4> CreateVector4(FlatBufferBuilder builder, float X, float Y, float Z, float W) { | ||
| builder.Prep(4, 16); | ||
| builder.PutFloat(W); | ||
| builder.PutFloat(Z); | ||
| builder.PutFloat(Y); | ||
| builder.PutFloat(X); | ||
| return new Offset<Vector4>(builder.Offset); | ||
| } | ||
| }; | ||
|
|
||
|
|
||
| } |