Mentions légales du service

Skip to content
Snippets Groups Projects
Commit f12e85a6 authored by MONSEIGNE Thibaut's avatar MONSEIGNE Thibaut Committed by MONSEIGNE Thibaut
Browse files

:fire: Remove Original examples & demos

parent 39dca4a1
No related branches found
No related tags found
No related merge requests found
Expand all Hide whitespace changes
Inline Side-by-side
Showing
with 0 additions and 2775 deletions
Demos.meta deleted 100644 → 0
+ 0
− 9
View file @ 39dca4a1
fileFormatVersion: 2
guid: 2ca0d7588caddeb419150aa68a92a048
folderAsset: yes
timeCreated: 1470245112
licenseType: Free
DefaultImporter:
userData:
assetBundleName:
assetBundleVariant:
Demos/CubeRotation.cs deleted 100644 → 0
+ 0
− 25
View file @ 39dca4a1
using UnityEngine;
namespace LSL4Unity.Demos
{
public class CubeRotation : MonoBehaviour
{
private float yawSpeed = 1.0f;
private float pitchSpeed = 1.0f;
private float rollSpeed = 1.0f;
private void Update()
{
if (Input.GetKey("a")) { yawSpeed += 1; }
if (Input.GetKey("d") && yawSpeed > 0) { yawSpeed -= 1; }
if (Input.GetKey("w")) { pitchSpeed += 1; }
if (Input.GetKey("s") && pitchSpeed > 0) { pitchSpeed -= 1; }
if (Input.GetKey("e")) { rollSpeed += 1; }
if (Input.GetKey("q") && rollSpeed > 0) { rollSpeed -= 1; }
transform.rotation *= Quaternion.Euler(yawSpeed * Time.deltaTime, pitchSpeed * Time.deltaTime, rollSpeed * Time.deltaTime);
}
}
}
Demos/CubeRotation.cs.meta deleted 100644 → 0
+ 0
− 12
View file @ 39dca4a1
fileFormatVersion: 2
guid: 89ccfd963e304fe4c89df7f836670980
timeCreated: 1470245128
licenseType: Free
MonoImporter:
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant:
Demos/Demo_IncomingStreams.unity deleted 100644 → 0
+ 0
− 446
View file @ 39dca4a1
%YAML 1.1
%TAG !u! tag:unity3d.com,2011:
--- !u!29 &1
OcclusionCullingSettings:
m_ObjectHideFlags: 0
serializedVersion: 2
m_OcclusionBakeSettings:
smallestOccluder: 5
smallestHole: 0.25
backfaceThreshold: 100
m_SceneGUID: 00000000000000000000000000000000
m_OcclusionCullingData: {fileID: 0}
--- !u!104 &2
RenderSettings:
m_ObjectHideFlags: 0
serializedVersion: 7
m_Fog: 0
m_FogColor: {r: 0.5, g: 0.5, b: 0.5, a: 1}
m_FogMode: 3
m_FogDensity: 0.01
m_LinearFogStart: 0
m_LinearFogEnd: 300
m_AmbientSkyColor: {r: 0.212, g: 0.227, b: 0.259, a: 1}
m_AmbientEquatorColor: {r: 0.114, g: 0.125, b: 0.133, a: 1}
m_AmbientGroundColor: {r: 0.047, g: 0.043, b: 0.035, a: 1}
m_AmbientIntensity: 1
m_AmbientMode: 0
m_SkyboxMaterial: {fileID: 10304, guid: 0000000000000000f000000000000000, type: 0}
m_HaloStrength: 0.5
m_FlareStrength: 1
m_FlareFadeSpeed: 3
m_HaloTexture: {fileID: 0}
m_SpotCookie: {fileID: 10001, guid: 0000000000000000e000000000000000, type: 0}
m_DefaultReflectionMode: 0
m_DefaultReflectionResolution: 128
m_ReflectionBounces: 1
m_ReflectionIntensity: 1
m_CustomReflection: {fileID: 0}
m_Sun: {fileID: 0}
m_IndirectSpecularColor: {r: 0, g: 0, b: 0, a: 1}
--- !u!157 &3
LightmapSettings:
m_ObjectHideFlags: 0
serializedVersion: 7
m_GIWorkflowMode: 1
m_GISettings:
serializedVersion: 2
m_BounceScale: 1
m_IndirectOutputScale: 1
m_AlbedoBoost: 1
m_TemporalCoherenceThreshold: 1
m_EnvironmentLightingMode: 0
m_EnableBakedLightmaps: 1
m_EnableRealtimeLightmaps: 1
m_LightmapEditorSettings:
serializedVersion: 4
m_Resolution: 2
m_BakeResolution: 40
m_TextureWidth: 1024
m_TextureHeight: 1024
m_AO: 0
m_AOMaxDistance: 1
m_CompAOExponent: 1
m_CompAOExponentDirect: 0
m_Padding: 2
m_LightmapParameters: {fileID: 0}
m_LightmapsBakeMode: 1
m_TextureCompression: 1
m_DirectLightInLightProbes: 1
m_FinalGather: 0
m_FinalGatherFiltering: 1
m_FinalGatherRayCount: 256
m_ReflectionCompression: 2
m_LightingDataAsset: {fileID: 0}
m_RuntimeCPUUsage: 25
--- !u!196 &4
NavMeshSettings:
serializedVersion: 2
m_ObjectHideFlags: 0
m_BuildSettings:
serializedVersion: 2
agentTypeID: 0
agentRadius: 0.5
agentHeight: 2
agentSlope: 45
agentClimb: 0.4
ledgeDropHeight: 0
maxJumpAcrossDistance: 0
minRegionArea: 2
manualCellSize: 0
cellSize: 0.16666667
accuratePlacement: 0
m_NavMeshData: {fileID: 0}
--- !u!1 &68353125
GameObject:
m_ObjectHideFlags: 0
m_PrefabParentObject: {fileID: 0}
m_PrefabInternal: {fileID: 0}
serializedVersion: 5
m_Component:
- component: {fileID: 68353127}
- component: {fileID: 68353126}
m_Layer: 0
m_Name: Resolver
m_TagString: Untagged
m_Icon: {fileID: 0}
m_NavMeshLayer: 0
m_StaticEditorFlags: 0
m_IsActive: 1
--- !u!114 &68353126
MonoBehaviour:
m_ObjectHideFlags: 0
m_PrefabParentObject: {fileID: 0}
m_PrefabInternal: {fileID: 0}
m_GameObject: {fileID: 68353125}
m_Enabled: 1
m_EditorHideFlags: 0
m_Script: {fileID: 11500000, guid: 4bc033cd2cffec7459d6fa31ad6a961b, type: 3}
m_Name:
m_EditorClassIdentifier:
knownStreams: []
forgetStreamAfter: 1
onStreamFound:
m_PersistentCalls:
m_Calls:
- m_Target: {fileID: 193850119}
m_MethodName: AStreamIsFound
m_Mode: 0
m_Arguments:
m_ObjectArgument: {fileID: 0}
m_ObjectArgumentAssemblyTypeName: UnityEngine.Object, UnityEngine
m_IntArgument: 0
m_FloatArgument: 0
m_StringArgument:
m_BoolArgument: 0
m_CallState: 2
m_TypeName: Assets.LSL4Unity.Scripts.StreamEvent, Assembly-CSharp, Version=0.0.0.0,
Culture=neutral, PublicKeyToken=null
onStreamLost:
m_PersistentCalls:
m_Calls:
- m_Target: {fileID: 193850119}
m_MethodName: AStreamGotLost
m_Mode: 0
m_Arguments:
m_ObjectArgument: {fileID: 0}
m_ObjectArgumentAssemblyTypeName: UnityEngine.Object, UnityEngine
m_IntArgument: 0
m_FloatArgument: 0
m_StringArgument:
m_BoolArgument: 0
m_CallState: 2
m_TypeName: Assets.LSL4Unity.Scripts.StreamEvent, Assembly-CSharp, Version=0.0.0.0,
Culture=neutral, PublicKeyToken=null
--- !u!4 &68353127
Transform:
m_ObjectHideFlags: 0
m_PrefabParentObject: {fileID: 0}
m_PrefabInternal: {fileID: 0}
m_GameObject: {fileID: 68353125}
m_LocalRotation: {x: 0, y: 0, z: 0, w: 1}
m_LocalPosition: {x: -0.7427908, y: -2.570417, z: 15.226566}
m_LocalScale: {x: 1, y: 1, z: 1}
m_Children: []
m_Father: {fileID: 0}
m_RootOrder: 3
m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
--- !u!1 &193850114
GameObject:
m_ObjectHideFlags: 0
m_PrefabParentObject: {fileID: 0}
m_PrefabInternal: {fileID: 0}
serializedVersion: 5
m_Component:
- component: {fileID: 193850115}
- component: {fileID: 193850118}
- component: {fileID: 193850117}
- component: {fileID: 193850116}
- component: {fileID: 193850119}
m_Layer: 0
m_Name: AObjectListeningToAStream
m_TagString: Untagged
m_Icon: {fileID: 0}
m_NavMeshLayer: 0
m_StaticEditorFlags: 0
m_IsActive: 1
--- !u!4 &193850115
Transform:
m_ObjectHideFlags: 0
m_PrefabParentObject: {fileID: 0}
m_PrefabInternal: {fileID: 0}
m_GameObject: {fileID: 193850114}
m_LocalRotation: {x: 0, y: 0, z: 0, w: 1}
m_LocalPosition: {x: 0, y: 0, z: 0}
m_LocalScale: {x: 1, y: 1, z: 1}
m_Children: []
m_Father: {fileID: 753183517}
m_RootOrder: 0
m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
--- !u!23 &193850116
MeshRenderer:
m_ObjectHideFlags: 0
m_PrefabParentObject: {fileID: 0}
m_PrefabInternal: {fileID: 0}
m_GameObject: {fileID: 193850114}
m_Enabled: 1
m_CastShadows: 1
m_ReceiveShadows: 1
m_MotionVectors: 1
m_LightProbeUsage: 1
m_ReflectionProbeUsage: 1
m_Materials:
- {fileID: 10303, guid: 0000000000000000f000000000000000, type: 0}
m_StaticBatchInfo:
firstSubMesh: 0
subMeshCount: 0
m_StaticBatchRoot: {fileID: 0}
m_ProbeAnchor: {fileID: 0}
m_LightProbeVolumeOverride: {fileID: 0}
m_ScaleInLightmap: 1
m_PreserveUVs: 1
m_IgnoreNormalsForChartDetection: 0
m_ImportantGI: 0
m_SelectedEditorRenderState: 3
m_MinimumChartSize: 4
m_AutoUVMaxDistance: 0.5
m_AutoUVMaxAngle: 89
m_LightmapParameters: {fileID: 0}
m_SortingLayerID: 0
m_SortingOrder: 0
--- !u!136 &193850117
CapsuleCollider:
m_ObjectHideFlags: 0
m_PrefabParentObject: {fileID: 0}
m_PrefabInternal: {fileID: 0}
m_GameObject: {fileID: 193850114}
m_Material: {fileID: 0}
m_IsTrigger: 0
m_Enabled: 1
m_Radius: 0.5
m_Height: 2
m_Direction: 1
m_Center: {x: 0, y: 0, z: 0}
--- !u!33 &193850118
MeshFilter:
m_ObjectHideFlags: 0
m_PrefabParentObject: {fileID: 0}
m_PrefabInternal: {fileID: 0}
m_GameObject: {fileID: 193850114}
m_Mesh: {fileID: 10206, guid: 0000000000000000e000000000000000, type: 0}
--- !u!114 &193850119
MonoBehaviour:
m_ObjectHideFlags: 0
m_PrefabParentObject: {fileID: 0}
m_PrefabInternal: {fileID: 0}
m_GameObject: {fileID: 193850114}
m_Enabled: 1
m_EditorHideFlags: 0
m_Script: {fileID: 11500000, guid: 5ba4ed7276e95054fb35c620c2207e28, type: 3}
m_Name:
m_EditorClassIdentifier:
StreamName: RandomSpehricalData
StreamType: 3DCoord
targetTransform: {fileID: 193850115}
useX: 0
useY: 1
useZ: 0
--- !u!1 &576020205
GameObject:
m_ObjectHideFlags: 0
m_PrefabParentObject: {fileID: 0}
m_PrefabInternal: {fileID: 0}
serializedVersion: 5
m_Component:
- component: {fileID: 576020210}
- component: {fileID: 576020209}
- component: {fileID: 576020208}
- component: {fileID: 576020207}
- component: {fileID: 576020206}
m_Layer: 0
m_Name: Main Camera
m_TagString: MainCamera
m_Icon: {fileID: 0}
m_NavMeshLayer: 0
m_StaticEditorFlags: 0
m_IsActive: 1
--- !u!81 &576020206
AudioListener:
m_ObjectHideFlags: 0
m_PrefabParentObject: {fileID: 0}
m_PrefabInternal: {fileID: 0}
m_GameObject: {fileID: 576020205}
m_Enabled: 1
--- !u!124 &576020207
Behaviour:
m_ObjectHideFlags: 0
m_PrefabParentObject: {fileID: 0}
m_PrefabInternal: {fileID: 0}
m_GameObject: {fileID: 576020205}
m_Enabled: 1
--- !u!92 &576020208
Behaviour:
m_ObjectHideFlags: 0
m_PrefabParentObject: {fileID: 0}
m_PrefabInternal: {fileID: 0}
m_GameObject: {fileID: 576020205}
m_Enabled: 1
--- !u!20 &576020209
Camera:
m_ObjectHideFlags: 0
m_PrefabParentObject: {fileID: 0}
m_PrefabInternal: {fileID: 0}
m_GameObject: {fileID: 576020205}
m_Enabled: 1
serializedVersion: 2
m_ClearFlags: 1
m_BackGroundColor: {r: 0.19215687, g: 0.3019608, b: 0.4745098, a: 0}
m_NormalizedViewPortRect:
serializedVersion: 2
x: 0
y: 0
width: 1
height: 1
near clip plane: 0.3
far clip plane: 1000
field of view: 60
orthographic: 0
orthographic size: 5
m_Depth: -1
m_CullingMask:
serializedVersion: 2
m_Bits: 4294967295
m_RenderingPath: -1
m_TargetTexture: {fileID: 0}
m_TargetDisplay: 0
m_TargetEye: 3
m_HDR: 0
m_OcclusionCulling: 1
m_StereoConvergence: 10
m_StereoSeparation: 0.022
m_StereoMirrorMode: 0
--- !u!4 &576020210
Transform:
m_ObjectHideFlags: 0
m_PrefabParentObject: {fileID: 0}
m_PrefabInternal: {fileID: 0}
m_GameObject: {fileID: 576020205}
m_LocalRotation: {x: 0, y: 0, z: 0, w: 1}
m_LocalPosition: {x: 0, y: 1, z: -10}
m_LocalScale: {x: 1, y: 1, z: 1}
m_Children: []
m_Father: {fileID: 0}
m_RootOrder: 0
m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
--- !u!1 &753183515
GameObject:
m_ObjectHideFlags: 0
m_PrefabParentObject: {fileID: 0}
m_PrefabInternal: {fileID: 0}
serializedVersion: 5
m_Component:
- component: {fileID: 753183517}
m_Layer: 0
m_Name: IncomingStreams
m_TagString: Untagged
m_Icon: {fileID: 0}
m_NavMeshLayer: 0
m_StaticEditorFlags: 0
m_IsActive: 1
--- !u!4 &753183517
Transform:
m_ObjectHideFlags: 0
m_PrefabParentObject: {fileID: 0}
m_PrefabInternal: {fileID: 0}
m_GameObject: {fileID: 753183515}
m_LocalRotation: {x: 0, y: 0, z: 0, w: 1}
m_LocalPosition: {x: 0, y: 0, z: 0}
m_LocalScale: {x: 1, y: 1, z: 1}
m_Children:
- {fileID: 193850115}
m_Father: {fileID: 0}
m_RootOrder: 2
m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
--- !u!1 &1295183507
GameObject:
m_ObjectHideFlags: 0
m_PrefabParentObject: {fileID: 0}
m_PrefabInternal: {fileID: 0}
serializedVersion: 5
m_Component:
- component: {fileID: 1295183509}
- component: {fileID: 1295183508}
m_Layer: 0
m_Name: Directional Light
m_TagString: Untagged
m_Icon: {fileID: 0}
m_NavMeshLayer: 0
m_StaticEditorFlags: 0
m_IsActive: 1
--- !u!108 &1295183508
Light:
m_ObjectHideFlags: 0
m_PrefabParentObject: {fileID: 0}
m_PrefabInternal: {fileID: 0}
m_GameObject: {fileID: 1295183507}
m_Enabled: 1
serializedVersion: 7
m_Type: 1
m_Color: {r: 1, g: 0.95686275, b: 0.8392157, a: 1}
m_Intensity: 1
m_Range: 10
m_SpotAngle: 30
m_CookieSize: 10
m_Shadows:
m_Type: 2
m_Resolution: -1
m_CustomResolution: -1
m_Strength: 1
m_Bias: 0.05
m_NormalBias: 0.4
m_NearPlane: 0.2
m_Cookie: {fileID: 0}
m_DrawHalo: 0
m_Flare: {fileID: 0}
m_RenderMode: 0
m_CullingMask:
serializedVersion: 2
m_Bits: 4294967295
m_Lightmapping: 4
m_AreaSize: {x: 1, y: 1}
m_BounceIntensity: 1
m_ShadowRadius: 0
m_ShadowAngle: 0
--- !u!4 &1295183509
Transform:
m_ObjectHideFlags: 0
m_PrefabParentObject: {fileID: 0}
m_PrefabInternal: {fileID: 0}
m_GameObject: {fileID: 1295183507}
m_LocalRotation: {x: 0.40821788, y: -0.23456968, z: 0.10938163, w: 0.8754261}
m_LocalPosition: {x: 0, y: 3, z: 0}
m_LocalScale: {x: 1, y: 1, z: 1}
m_Children: []
m_Father: {fileID: 0}
m_RootOrder: 1
m_LocalEulerAnglesHint: {x: 50, y: -30, z: 0}
Demos/Demo_IncomingStreams.unity.meta deleted 100644 → 0
+ 0
− 8
View file @ 39dca4a1
fileFormatVersion: 2
guid: 3550c01a8d2673149a51d237ef66a00b
timeCreated: 1482333848
licenseType: Free
DefaultImporter:
userData:
assetBundleName:
assetBundleVariant:
Demos/Demo_RotatingCube.unity deleted 100644 → 0
+ 0
− 1068
View file @ 39dca4a1
This diff is collapsed.
Demos/Demo_RotatingCube.unity.meta deleted 100644 → 0
+ 0
− 8
View file @ 39dca4a1
fileFormatVersion: 2
guid: 2ffabf00099d5d949bff8fc861a8f09a
timeCreated: 1470244953
licenseType: Free
DefaultImporter:
userData:
assetBundleName:
assetBundleVariant:
Demos/LSLTransformDemoOutlet.cs deleted 100644 → 0
+ 0
− 68
View file @ 39dca4a1
using UnityEngine;
namespace LSL4Unity.Demos
{
/// <summary> An reusable example of an outlet which provides the orientation of an entity to LSL. </summary>
public class LSLTransformDemoOutlet : MonoBehaviour
{
private const string UNIQUE_SOURCE_ID = "D256CFBDBA3145978CFA641403219531";
private liblsl.StreamOutlet outlet;
private liblsl.StreamInfo info;
//public liblsl.StreamInfo GetStreamInfo() { return info; }
public string streamName = "BeMoBI.Unity.Orientation.<Add_a_entity_id_here>";
public string streamType = "Unity.Quaternion";
public int channelCount = 4;
public MomentForSampling sampling;
public Transform sampleSource;
/// <summary> Use a array to reduce allocation costs. </summary>
private float[] sample;
private double dataRate;
public double GetDataRate() { return dataRate; }
public bool HasConsumer() { return outlet != null && outlet.HaveConsumers(); }
private void Start()
{
// initialize the array once
sample = new float[channelCount];
dataRate = LSLUtils.GetSamplingRateFor(sampling);
info = new liblsl.StreamInfo(streamName, streamType, channelCount, dataRate, liblsl.channel_format_t.cf_float32, UNIQUE_SOURCE_ID);
outlet = new liblsl.StreamOutlet(info);
}
private void PushSample()
{
if (outlet == null) { return; }
var rotation = sampleSource.rotation;
// reuse the array for each sample to reduce allocation costs
sample[0] = rotation.x;
sample[1] = rotation.y;
sample[2] = rotation.z;
sample[3] = rotation.w;
outlet.PushSample(sample, liblsl.LocalClock());
}
private void FixedUpdate()
{
if (sampling == MomentForSampling.FixedUpdate) { PushSample(); }
}
private void Update()
{
if (sampling == MomentForSampling.Update) { PushSample(); }
}
private void LateUpdate()
{
if (sampling == MomentForSampling.LateUpdate) { PushSample(); }
}
}
}
Demos/LSLTransformDemoOutlet.cs.meta deleted 100644 → 0
+ 0
− 12
View file @ 39dca4a1
fileFormatVersion: 2
guid: 357857a4b3c756d4aa4c765f4b02f577
timeCreated: 1470250104
licenseType: Free
MonoImporter:
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant:
Demos/RandomMarker.cs deleted 100644 → 0
+ 0
− 31
View file @ 39dca4a1
using System.Collections;
using UnityEngine;
using UnityEngine.Assertions;
namespace LSL4Unity.Demos
{
public class RandomMarker : MonoBehaviour
{
public LSLMarkerStream stream;
private void Start()
{
Assert.IsNotNull(stream, "You forgot to assign the reference to a marker stream implementation!");
if (stream != null) { StartCoroutine(WriteContinouslyMarkerEachSecond()); }
}
private IEnumerator WriteContinouslyMarkerEachSecond()
{
while (true)
{
// an example for demonstrating the usage of marker stream
string currentMarker = GetARandomMarker();
stream.Write(currentMarker);
yield return new WaitForSecondsRealtime(1f);
}
}
private static string GetARandomMarker() { return Random.value > 0.5 ? "A" : "B"; }
}
}
Demos/RandomMarker.cs.meta deleted 100644 → 0
+ 0
− 12
View file @ 39dca4a1
fileFormatVersion: 2
guid: 04edb71db3ae93943b11404c7012e4e8
timeCreated: 1471591971
licenseType: Free
MonoImporter:
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant:
Demos/StreamInfo.cs deleted 100644 → 0
+ 0
− 39
View file @ 39dca4a1
using UnityEngine;
using UnityEngine.UI;
namespace LSL4Unity.Demos
{
public class StreamInfo : MonoBehaviour
{
public LSLTransformDemoOutlet outlet;
public Text streamNameLabel;
public Text streamTypeLabel;
public Text dataRate;
public Text hasConsumerLabel;
// Use this for initialization
private void Start()
{
streamNameLabel.text = outlet.streamName;
streamTypeLabel.text = outlet.streamType;
dataRate.text = $"Data Rate: {outlet.GetDataRate()}";
hasConsumerLabel.text = "Has no consumers";
}
// Update is called once per frame
private void Update()
{
if (outlet.HasConsumer())
{
hasConsumerLabel.text = "Has consumers";
hasConsumerLabel.color = Color.green;
}
else
{
hasConsumerLabel.text = "No Consumers";
hasConsumerLabel.color = Color.black;
}
}
}
}
Demos/StreamInfo.cs.meta deleted 100644 → 0
+ 0
− 12
View file @ 39dca4a1
fileFormatVersion: 2
guid: 1a5f5978f3c997a4e83f46f049b25b66
timeCreated: 1470246118
licenseType: Free
MonoImporter:
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant:
Scripts/AInlet.cs deleted 100644 → 0
+ 0
− 622
View file @ 39dca4a1
using System;
using System.Collections;
using System.Collections.Generic;
using System.Linq;
using LSL4Unity.OV;
using UnityEngine;
namespace LSL4Unity
{
/// <summary> Float Inlet. </summary>
/// <seealso cref="UnityEngine.MonoBehaviour" />
public abstract class AFloatInlet : MonoBehaviour
{
public enum UpdateMoment { FixedUpdate, Update }
public UpdateMoment moment;
public string streamName;
public string streamType;
private liblsl.StreamInlet inlet;
private liblsl.ContinuousResolver resolver;
private int expectedChannels = 0;
private float[] sample;
private void Start()
{
bool hasAName = streamName.Length != 0;
bool hasAType = streamType.Length != 0;
if (!hasAName && !hasAType)
{
Debug.LogError("Inlet has to specify a name or a type before it is able to lookup a stream.");
enabled = false;
return;
}
if (hasAName)
{
Debug.Log("Creating LSL resolver for stream " + streamName);
resolver = new liblsl.ContinuousResolver("name", streamName);
}
else // if (hasAType) // Useless with the first if
{
Debug.Log("Creating LSL resolver for stream with type " + streamType);
resolver = new liblsl.ContinuousResolver("type ", streamType);
}
StartCoroutine(ResolveExpectedStream());
AdditionalStart();
}
/// <summary> Override this method in the subclass to specify what should happen during Start(). </summary>
protected void AdditionalStart() { } //By default, do nothing.
private IEnumerator ResolveExpectedStream()
{
var results = resolver.Results();
yield return new WaitUntil(() => results.Length > 0);
Debug.Log($"Resolving Stream: {streamName}");
inlet = new liblsl.StreamInlet(results[0]);
expectedChannels = inlet.Info().ChannelCount();
yield return null;
}
protected void PullSamples()
{
sample = new float[expectedChannels];
try
{
double lastTimeStamp = inlet.PullSample(sample, 0.0f);
if (Math.Abs(lastTimeStamp) > Constants.TOLERANCE)
{
// do not miss the first one found
Process(sample, lastTimeStamp);
// pull as long samples are available
while (Math.Abs(lastTimeStamp = inlet.PullSample(sample, 0.0f)) > Constants.TOLERANCE) { Process(sample, lastTimeStamp); }
}
}
catch (ArgumentException e)
{
Debug.LogError("An Error on pulling samples deactivating LSL inlet on...", this);
enabled = false;
Debug.LogException(e, this);
}
}
/// <summary> Override this method in the subclass to specify what should happen when samples are available. </summary>
/// <param name="sample"> The Incomming Sample. </param>
/// <param name="time"> The current Time. </param>
protected abstract void Process(float[] sample, double time);
private void FixedUpdate()
{
if (moment == UpdateMoment.FixedUpdate && inlet != null) { PullSamples(); }
}
private void Update()
{
if (moment == UpdateMoment.Update && inlet != null) { PullSamples(); }
}
}
/// <summary> Double Inlet. </summary>
/// <seealso cref="UnityEngine.MonoBehaviour" />
public abstract class ADoubleInlet : MonoBehaviour
{
public enum UpdateMoment { FixedUpdate, Update }
public UpdateMoment moment;
public string streamName;
public string streamType;
private liblsl.StreamInlet inlet;
private liblsl.ContinuousResolver resolver;
private int expectedChannels = 0;
private double[] sample;
private void Start()
{
bool hasAName = streamName.Length != 0;
bool hasAType = streamType.Length != 0;
if (!hasAName && !hasAType)
{
Debug.LogError("Inlet has to specify a name or a type before it is able to lookup a stream.");
enabled = false;
return;
}
if (hasAName)
{
Debug.Log("Creating LSL resolver for stream " + streamName);
resolver = new liblsl.ContinuousResolver("name", streamName);
}
else // if (hasAType) // Useless with the first if
{
Debug.Log("Creating LSL resolver for stream with type " + streamType);
resolver = new liblsl.ContinuousResolver("type", streamType);
}
StartCoroutine(ResolveExpectedStream());
AdditionalStart();
}
/// <summary> Override this method in the subclass to specify what should happen during Start(). </summary>
protected virtual void AdditionalStart() { } //By default, do nothing.
private IEnumerator ResolveExpectedStream()
{
var results = resolver.Results();
while (inlet == null)
{
yield return new WaitUntil(() => results.Length > 0);
inlet = new liblsl.StreamInlet(GetStreamInfoFrom(results));
expectedChannels = inlet.Info().ChannelCount();
}
yield return null;
}
private liblsl.StreamInfo GetStreamInfoFrom(IEnumerable<liblsl.StreamInfo> results)
{
var targetInfo = results.First(r => r.Name().Equals(streamName));
return targetInfo;
}
protected void PullSamples()
{
sample = new double[expectedChannels];
try
{
double lastTimeStamp = inlet.PullSample(sample, 0.0f);
if (Math.Abs(lastTimeStamp) > Constants.TOLERANCE)
{
// do not miss the first one found
Process(sample, lastTimeStamp);
// pull as long samples are available
while (Math.Abs(lastTimeStamp = inlet.PullSample(sample, 0.0f)) > Constants.TOLERANCE) { Process(sample, lastTimeStamp); }
}
}
catch (ArgumentException e)
{
Debug.LogError("An Error on pulling samples deactivating LSL inlet on...", this);
enabled = false;
Debug.LogException(e, this);
}
}
/// <inheritdoc cref="AFloatInlet.Process"/>
protected abstract void Process(double[] sample, double time);
private void FixedUpdate()
{
if (moment == UpdateMoment.FixedUpdate && inlet != null) { PullSamples(); }
}
private void Update()
{
if (moment == UpdateMoment.Update && inlet != null) { PullSamples(); }
}
}
/// <summary> Char Inlet. </summary>
/// <seealso cref="UnityEngine.MonoBehaviour" />
public abstract class ACharInlet : MonoBehaviour
{
public enum UpdateMoment { FixedUpdate, Update }
public UpdateMoment moment;
public string streamName;
public string streamType;
private liblsl.StreamInlet inlet;
private liblsl.ContinuousResolver resolver;
private int expectedChannels = 0;
private char[] sample;
private void Start()
{
bool hasAName = streamName.Length != 0;
bool hasAType = streamType.Length != 0;
if (!hasAName && !hasAType)
{
Debug.LogError("Inlet has to specify a name or a type before it is able to lookup a stream.");
enabled = false;
return;
}
if (hasAName)
{
Debug.Log("Creating LSL resolver for stream " + streamName);
resolver = new liblsl.ContinuousResolver("name", streamName);
}
else // if (hasAType) // Useless with the first if
{
Debug.Log("Creating LSL resolver for stream with type " + streamType);
resolver = new liblsl.ContinuousResolver("type", streamType);
}
StartCoroutine(ResolveExpectedStream());
AdditionalStart();
}
/// <summary> Override this method in the subclass to specify what should happen during Start(). </summary>
protected virtual void AdditionalStart() { } //By default, do nothing.
private IEnumerator ResolveExpectedStream()
{
var results = resolver.Results();
yield return new WaitUntil(() => results.Length > 0);
inlet = new liblsl.StreamInlet(results[0]);
expectedChannels = inlet.Info().ChannelCount();
yield return null;
}
protected void PullSamples()
{
sample = new char[expectedChannels];
try
{
double lastTimeStamp = inlet.PullSample(sample, 0.0f);
if (Math.Abs(lastTimeStamp) > Constants.TOLERANCE)
{
// do not miss the first one found
Process(sample, lastTimeStamp);
// pull as long samples are available
while (Math.Abs(lastTimeStamp = inlet.PullSample(sample, 0.0f)) > Constants.TOLERANCE) { Process(sample, lastTimeStamp); }
}
}
catch (ArgumentException e)
{
Debug.LogError("An Error on pulling samples deactivating LSL inlet on...", this);
enabled = false;
Debug.LogException(e, this);
}
}
/// <inheritdoc cref="AFloatInlet.Process"/>
protected abstract void Process(char[] sample, double time);
private void FixedUpdate()
{
if (moment == UpdateMoment.FixedUpdate && inlet != null) { PullSamples(); }
}
private void Update()
{
if (moment == UpdateMoment.Update && inlet != null) { PullSamples(); }
}
}
/// <summary> Float Inlet. </summary>
/// <seealso cref="UnityEngine.MonoBehaviour" />
public abstract class AShortInlet : MonoBehaviour
{
public enum UpdateMoment { FixedUpdate, Update }
public UpdateMoment moment;
public string streamName;
public string streamType;
private liblsl.StreamInlet inlet;
private liblsl.ContinuousResolver resolver;
private int expectedChannels = 0;
private short[] sample;
private void Start()
{
bool hasAName = streamName.Length != 0;
bool hasAType = streamType.Length != 0;
if (!hasAName && !hasAType)
{
Debug.LogError("Inlet has to specify a name or a type before it is able to lookup a stream.");
enabled = false;
return;
}
if (hasAName)
{
Debug.Log("Creating LSL resolver for stream " + streamName);
resolver = new liblsl.ContinuousResolver("name", streamName);
}
else // if (hasAType) // Useless with the first if
{
Debug.Log("Creating LSL resolver for stream with type " + streamType);
resolver = new liblsl.ContinuousResolver("type", streamType);
}
StartCoroutine(ResolveExpectedStream());
AdditionalStart();
}
/// <summary> Override this method in the subclass to specify what should happen during Start(). </summary>
protected virtual void AdditionalStart() { } //By default, do nothing.
private IEnumerator ResolveExpectedStream()
{
var results = resolver.Results();
yield return new WaitUntil(() => results.Length > 0);
inlet = new liblsl.StreamInlet(results[0]);
expectedChannels = inlet.Info().ChannelCount();
yield return null;
}
protected void PullSamples()
{
sample = new short[expectedChannels];
try
{
double lastTimeStamp = inlet.PullSample(sample, 0.0f);
if (Math.Abs(lastTimeStamp) > Constants.TOLERANCE)
{
// do not miss the first one found
Process(sample, lastTimeStamp);
// pull as long samples are available
while (Math.Abs(lastTimeStamp = inlet.PullSample(sample, 0.0f)) > Constants.TOLERANCE) { Process(sample, lastTimeStamp); }
}
}
catch (ArgumentException e)
{
Debug.LogError("An Error on pulling samples deactivating LSL inlet on...", this);
enabled = false;
Debug.LogException(e, this);
}
}
/// <inheritdoc cref="AFloatInlet.Process"/>
protected abstract void Process(short[] sample, double time);
private void FixedUpdate()
{
if (moment == UpdateMoment.FixedUpdate && inlet != null) { PullSamples(); }
}
private void Update()
{
if (moment == UpdateMoment.Update && inlet != null) { PullSamples(); }
}
}
/// <summary> Int Inlet. </summary>
/// <seealso cref="UnityEngine.MonoBehaviour" />
public abstract class AIntInlet : MonoBehaviour
{
public enum UpdateMoment { FixedUpdate, Update }
public UpdateMoment moment;
public string streamName;
public string streamType;
private liblsl.StreamInlet inlet;
private liblsl.ContinuousResolver resolver;
private int expectedChannels = 0;
private int[] sample;
private void Start()
{
bool hasAName = streamName.Length != 0;
bool hasAType = streamType.Length != 0;
if (!hasAName && !hasAType)
{
Debug.LogError("Inlet has to specify a name or a type before it is able to lookup a stream.");
enabled = false;
return;
}
if (hasAName)
{
Debug.Log("Creating LSL resolver for stream " + streamName);
resolver = new liblsl.ContinuousResolver("name", streamName);
}
else // if (hasAType) // Useless with the first if
{
Debug.Log("Creating LSL resolver for stream with type " + streamType);
resolver = new liblsl.ContinuousResolver("type", streamType);
}
StartCoroutine(ResolveExpectedStream());
AdditionalStart();
}
/// <summary> Override this method in the subclass to specify what should happen during Start(). </summary>
protected virtual void AdditionalStart() { } //By default, do nothing.
private IEnumerator ResolveExpectedStream()
{
var results = resolver.Results();
yield return new WaitUntil(() => results.Length > 0);
inlet = new liblsl.StreamInlet(results[0]);
expectedChannels = inlet.Info().ChannelCount();
yield return null;
}
protected void PullSamples()
{
sample = new int[expectedChannels];
try
{
double lastTimeStamp = inlet.PullSample(sample, 0.0f);
if (Math.Abs(lastTimeStamp) > Constants.TOLERANCE)
{
// do not miss the first one found
Process(sample, lastTimeStamp);
// pull as long samples are available
while (Math.Abs(lastTimeStamp = inlet.PullSample(sample, 0.0f)) > Constants.TOLERANCE) { Process(sample, lastTimeStamp); }
}
}
catch (ArgumentException e)
{
Debug.LogError("An Error on pulling samples deactivating LSL inlet on...", this);
enabled = false;
Debug.LogException(e, this);
}
}
/// <inheritdoc cref="AFloatInlet.Process"/>
protected abstract void Process(int[] sample, double time);
private void FixedUpdate()
{
if (moment == UpdateMoment.FixedUpdate && inlet != null) { PullSamples(); }
}
private void Update()
{
if (moment == UpdateMoment.Update && inlet != null) { PullSamples(); }
}
}
/// <summary> String Inlet. </summary>
/// <seealso cref="UnityEngine.MonoBehaviour" />
public abstract class AStringInlet : MonoBehaviour
{
public enum UpdateMoment { FixedUpdate, Update }
public UpdateMoment moment;
public string streamName;
public string streamType;
private liblsl.StreamInlet inlet;
private liblsl.ContinuousResolver resolver;
private int expectedChannels = 0;
private string[] sample;
private void Start()
{
bool hasAName = streamName.Length != 0;
bool hasAType = streamType.Length != 0;
if (!hasAName && !hasAType)
{
Debug.LogError("Inlet has to specify a name or a type before it is able to lookup a stream.");
enabled = false;
return;
}
if (hasAName)
{
Debug.Log("Creating LSL resolver for stream " + streamName);
resolver = new liblsl.ContinuousResolver("name", streamName);
}
else // if (hasAType) // Useless with the first if
{
Debug.Log("Creating LSL resolver for stream with type " + streamType);
resolver = new liblsl.ContinuousResolver("type", streamType);
}
StartCoroutine(ResolveExpectedStream());
AdditionalStart();
}
/// <summary> Override this method in the subclass to specify what should happen during Start(). </summary>
protected virtual void AdditionalStart() { } //By default, do nothing.
private IEnumerator ResolveExpectedStream()
{
var results = resolver.Results();
yield return new WaitUntil(() => results.Length > 0);
inlet = new liblsl.StreamInlet(results[0]);
expectedChannels = inlet.Info().ChannelCount();
yield return null;
}
protected void PullSamples()
{
sample = new string[expectedChannels];
try
{
double lastTimeStamp = inlet.PullSample(sample, 0.0f);
if (Math.Abs(lastTimeStamp) > Constants.TOLERANCE)
{
// do not miss the first one found
Process(sample, lastTimeStamp);
// pull as long samples are available
while (Math.Abs(lastTimeStamp = inlet.PullSample(sample, 0.0f)) > Constants.TOLERANCE) { Process(sample, lastTimeStamp); }
}
}
catch (ArgumentException e)
{
Debug.LogError("An Error on pulling samples deactivating LSL inlet on...", this);
enabled = false;
Debug.LogException(e, this);
}
}
/// <inheritdoc cref="AFloatInlet.Process"/>
protected abstract void Process(string[] sample, double time);
private void FixedUpdate()
{
if (moment == UpdateMoment.FixedUpdate && inlet != null) { PullSamples(); }
}
private void Update()
{
if (moment == UpdateMoment.Update && inlet != null) { PullSamples(); }
}
}
}
Scripts/AInlet.cs.meta deleted 100644 → 0
+ 0
− 12
View file @ 39dca4a1
fileFormatVersion: 2
guid: e4dbfc4bac1d43d4c85a008a0e3f3aad
timeCreated: 1469171488
licenseType: Free
MonoImporter:
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant:
Scripts/BaseInlet.cs deleted 100644 → 0
+ 0
− 291
View file @ 39dca4a1
using System;
using System.Linq;
using LSL4Unity.OV;
using UnityEngine;
namespace LSL4Unity
{
public abstract class ABaseInlet : MonoBehaviour
{
public string streamName;
public string streamType;
protected liblsl.StreamInlet inlet;
protected int expectedChannels;
protected Resolver resolver;
/// <summary> Call this method when your inlet implementation got created at runtime. </summary>
protected virtual void RegisterAndLookUpStream()
{
resolver = FindObjectOfType<Resolver>();
//Resolver.OnStreamFound.AddListener(new UnityAction<LSLStreamInfoWrapper>(AStreamIsFound)); // Redundant to explicit delegate creation
//Resolver.OnStreamLost.AddListener(new UnityAction<LSLStreamInfoWrapper>(AStreamGotLost)); // Redundant to explicit delegate creation
resolver.onStreamFound.AddListener(AStreamIsFound);
resolver.onStreamLost.AddListener(AStreamGotLost);
if (resolver.streams.Any(IsTheExpected))
{
var stream = resolver.streams.First(IsTheExpected);
AStreamIsFound(stream);
}
}
/// <summary> Callback method for the Resolver gets called each time the resolver found a stream. </summary>
/// <param name="stream"> The stream. </param>
public virtual void AStreamIsFound(LSLStreamInfoWrapper stream)
{
if (!IsTheExpected(stream)) { return; }
Debug.Log($"LSL Stream {stream.name} found for {name}");
inlet = new liblsl.StreamInlet(stream.Item);
expectedChannels = stream.ChannelCount;
OnStreamAvailable();
}
/// <summary> Callback method for the Resolver gets called each time the resolver misses a stream within its cache. </summary>
/// <param name="stream"> The stream. </param>
public virtual void AStreamGotLost(LSLStreamInfoWrapper stream)
{
if (!IsTheExpected(stream)) { return; }
Debug.Log($"LSL Stream {stream.name} Lost for {name}");
OnStreamLost();
}
/// <summary> Determines if the specified stream is the expected stream. </summary>
/// <param name="stream"> The stream. </param>
/// <returns> <c>true</c> if if the specified stream is the expected stream; otherwise, <c>false</c>. </returns>
protected virtual bool IsTheExpected(LSLStreamInfoWrapper stream)
{
bool predicate = streamName.Equals(stream.name);
predicate &= streamType.Equals(stream.type);
return predicate;
}
/// <summary> Pull the samples. </summary>
protected abstract void PullSamples();
/// <summary> Called when a stream is available. </summary>
/// <exception cref="NotImplementedException">Please override this method in a derived class!</exception>
protected virtual void OnStreamAvailable()
{
// base implementation may not decide what happens when the stream gets available
throw new NotImplementedException("Please override this method in a derived class!");
}
/// <summary> Called when a stream is lost. </summary>
/// <exception cref="NotImplementedException">Please override this method in a derived class!</exception>
protected virtual void OnStreamLost()
{
// base implementation may not decide what happens when the stream gets lost
throw new NotImplementedException("Please override this method in a derived class!");
}
}
/// <inheritdoc/>
public abstract class InletFloatSamples : ABaseInlet
{
/// <summary> Override this method in the subclass to specify what should happen when samples are available. </summary>
/// <param name="data"> The Incomming Sample. </param>
/// <param name="time"> The current Time. </param>
protected abstract void Process(float[] data, double time);
protected float[] sample;
protected override void PullSamples()
{
sample = new float[expectedChannels];
try
{
double time = inlet.PullSample(sample, 0.0f);
if (Math.Abs(time) > Constants.TOLERANCE)
{
// do not miss the first one found
Process(sample, time);
// pull as long samples are available
while (Math.Abs(time = inlet.PullSample(sample, 0.0f)) > Constants.TOLERANCE) { Process(sample, time); }
}
}
catch (ArgumentException e)
{
Debug.LogError("An Error on pulling samples deactivating LSL inlet on...", this);
enabled = false;
Debug.LogException(e, this);
}
}
}
/// <inheritdoc/>
public abstract class InletDoubleSamples : ABaseInlet
{
/// <inheritdoc cref="InletFloatSamples.Process"/>
protected abstract void Process(double[] sample, double time);
protected double[] sample;
protected override void PullSamples()
{
sample = new double[expectedChannels];
try
{
double lastTimeStamp = inlet.PullSample(sample, 0.0f);
if (Math.Abs(lastTimeStamp) > Constants.TOLERANCE)
{
// do not miss the first one found
Process(sample, lastTimeStamp);
// pull as long samples are available
while (Math.Abs(lastTimeStamp = inlet.PullSample(sample, 0.0f)) > Constants.TOLERANCE) { Process(sample, lastTimeStamp); }
}
}
catch (ArgumentException e)
{
Debug.LogError("An Error on pulling samples deactivating LSL inlet on...", this);
enabled = false;
Debug.LogException(e, this);
}
}
}
/// <inheritdoc/>
public abstract class InletIntSamples : ABaseInlet
{
/// <inheritdoc cref="InletFloatSamples.Process"/>
protected abstract void Process(int[] sample, double time);
protected int[] sample;
protected override void PullSamples()
{
sample = new int[expectedChannels];
try
{
double lastTimeStamp = inlet.PullSample(sample, 0.0f);
if (Math.Abs(lastTimeStamp) > Constants.TOLERANCE)
{
// do not miss the first one found
Process(sample, lastTimeStamp);
// pull as long samples are available
while (Math.Abs(lastTimeStamp = inlet.PullSample(sample, 0.0f)) > Constants.TOLERANCE) { Process(sample, lastTimeStamp); }
}
}
catch (ArgumentException e)
{
Debug.LogError("An Error on pulling samples deactivating LSL inlet on...", this);
enabled = false;
Debug.LogException(e, this);
}
}
}
/// <inheritdoc/>
public abstract class InletCharSamples : ABaseInlet
{
/// <inheritdoc cref="InletFloatSamples.Process"/>
protected abstract void Process(char[] sample, double time);
protected char[] sample;
protected override void PullSamples()
{
sample = new char[expectedChannels];
try
{
double lastTimeStamp = inlet.PullSample(sample, 0.0f);
if (Math.Abs(lastTimeStamp) > Constants.TOLERANCE)
{
// do not miss the first one found
Process(sample, lastTimeStamp);
// pull as long samples are available
while (Math.Abs(lastTimeStamp = inlet.PullSample(sample, 0.0f)) > Constants.TOLERANCE) { Process(sample, lastTimeStamp); }
}
}
catch (ArgumentException e)
{
Debug.LogError("An Error on pulling samples deactivating LSL inlet on...", this);
enabled = false;
Debug.LogException(e, this);
}
}
}
/// <inheritdoc/>
public abstract class InletStringSamples : ABaseInlet
{
/// <inheritdoc cref="InletFloatSamples.Process"/>
protected abstract void Process(string[] sample, double time);
protected string[] sample;
protected override void PullSamples()
{
sample = new string[expectedChannels];
try
{
double lastTimeStamp = inlet.PullSample(sample, 0.0f);
if (Math.Abs(lastTimeStamp) > Constants.TOLERANCE)
{
// do not miss the first one found
Process(sample, lastTimeStamp);
// pull as long samples are available
while (Math.Abs(lastTimeStamp = inlet.PullSample(sample, 0.0f)) > Constants.TOLERANCE) { Process(sample, lastTimeStamp); }
}
}
catch (ArgumentException e)
{
Debug.LogError("An Error on pulling samples deactivating LSL inlet on...", this);
enabled = false;
Debug.LogException(e, this);
}
}
}
/// <inheritdoc/>
public abstract class InletShortSamples : ABaseInlet
{
/// <inheritdoc cref="InletFloatSamples.Process"/>
protected abstract void Process(short[] sample, double time);
protected short[] sample;
protected override void PullSamples()
{
sample = new short[expectedChannels];
try
{
double lastTimeStamp = inlet.PullSample(sample, 0.0f);
if (Math.Abs(lastTimeStamp) > Constants.TOLERANCE)
{
// do not miss the first one found
Process(sample, lastTimeStamp);
// pull as long samples are available
while (Math.Abs(lastTimeStamp = inlet.PullSample(sample, 0.0f)) > Constants.TOLERANCE) { Process(sample, lastTimeStamp); }
}
}
catch (ArgumentException e)
{
Debug.LogError("An Error on pulling samples deactivating LSL inlet on...", this);
enabled = false;
Debug.LogException(e, this);
}
}
}
}
Scripts/BaseInlet.cs.meta deleted 100644 → 0
+ 0
− 12
View file @ 39dca4a1
fileFormatVersion: 2
guid: cc40f3ccd629bdf4a850cf96960539a4
timeCreated: 1482355052
licenseType: Free
MonoImporter:
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant:
Scripts/Examples.meta deleted 100644 → 0
+ 0
− 9
View file @ 39dca4a1
fileFormatVersion: 2
guid: 6659c9ee82049744b8389fb20566159f
folderAsset: yes
timeCreated: 1469175164
licenseType: Free
DefaultImporter:
userData:
assetBundleName:
assetBundleVariant:
Scripts/Examples/DemoInletForFloatSamples.cs deleted 100644 → 0
+ 0
− 67
View file @ 39dca4a1
using UnityEngine;
namespace LSL4Unity.Examples
{
/// <summary>
/// Example that works with the Resolver component.
/// This script waits for the resolver to resolve a Stream which matches the Name and Type.
/// See the base class for more details.
///
/// The specific implementation should only deal with the moment when the samples need to be pulled
/// and how they should processed in your game logic
///
/// </summary>
public class DemoInletForFloatSamples : InletFloatSamples
{
public Transform targetTransform;
public bool useX, useY, useZ;
private bool pullContinuously = false;
//void Start()
//{
// [optional] call this only, if your gameobject hosting this component
// got instantiated during runtime
// registerAndLookUpStream();
//}
protected override bool IsTheExpected(LSLStreamInfoWrapper stream)
{
// the base implementation just checks for stream name and type
bool predicate = base.IsTheExpected(stream);
// add a more specific description for your stream here specifying hostname etc.
//predicate &= stream.HostName.Equals("Expected Hostname");
return predicate;
}
/// <summary>
/// Override this method to implement whatever should happen with the samples...
/// IMPORTANT: Avoid heavy processing logic within this method, update a state and use
/// coroutines for more complexe processing tasks to distribute processing time over
/// several frames
/// </summary>
/// <param name="data"> The Incomming Sample. </param>
/// <param name="time"> The current Time. </param>
protected override void Process(float[] data, double time)
{
//Assuming that a samples contains at least 3 values for x,y,z
float x = useX ? data[0] : 1;
float y = useY ? data[1] : 1;
float z = useZ ? data[2] : 1;
// we map the data to the scale factors
Vector3 targetScale = new Vector3(x, y, z);
// apply the rotation to the target transform
targetTransform.localScale = targetScale;
}
protected override void OnStreamAvailable() { pullContinuously = true; }
protected override void OnStreamLost() { pullContinuously = false; }
private void Update()
{
if (pullContinuously) { PullSamples(); }
}
}
}
Scripts/Examples/DemoInletForFloatSamples.cs.meta deleted 100644 → 0
+ 0
− 12
View file @ 39dca4a1
fileFormatVersion: 2
guid: 5ba4ed7276e95054fb35c620c2207e28
timeCreated: 1482351815
licenseType: Free
MonoImporter:
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant:
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Please register or to comment