public override bool SetRumble(TBInput.Controller controller, float strength)
{
switch (controller)
{
case TBInput.Controller.LHandController:
_leftRumble = new OVRHapticsClip(_numHapticSamples);
for (int i = 0; i < _numHapticSamples; i++)
{
_leftRumble.WriteSample((byte)(255 * strength));
}
OVRHaptics.LeftChannel.Preempt(_leftRumble);
return(true);
case TBInput.Controller.RHandController:
_rightRumble = new OVRHapticsClip(_numHapticSamples);
for (int i = 0; i < _numHapticSamples; i++)
{
_rightRumble.WriteSample((byte)(255 * strength));
}
OVRHaptics.RightChannel.Preempt(_rightRumble);
return(true);
default:
return(false);
}
}
private void WriteHapticSamples(OVRHapticsClip clip, float freq, float amplitude, int duration)
{
for (int i = 0; i < duration; i++)
{
clip.WriteSample((byte)(Mathf.RoundToInt(amplitude * 0.5f * (Mathf.Sin(i * freq * 2 * Mathf.PI) + 1))));
}
}
public void Vibrate(float duration)
{
OVRHapticsClip clip = new OVRHapticsClip();
for (int i = 0; i < duration * 320; i++)
{
clip.WriteSample((byte)Mathf.Clamp((int)(0.4 * 255), 0, 255));
}
OVRHaptics.RightChannel.Preempt(clip);
OVRHaptics.LeftChannel.Preempt(clip);
}
public void triggerVibration(int iteration, int frequency, int strength)
{
OVRHapticsClip clip = new OVRHapticsClip();
for (int i = 0; i < iteration; i++)
{
clip.WriteSample(i % frequency == 0 ?(byte)strength : (byte)0);
}
OVRHaptics.RightChannel.Preempt(clip);
}
public static void Trigger(int iterations, int frequency, int strength, OVRInput.Controller controller)
{
OVRHapticsClip clip = new OVRHapticsClip();
for (int i = 0; i < iterations; i++)
{
clip.WriteSample(i % frequency == 0 ? (byte)strength : (byte)0);
}
VibeOnCorrespondingController(clip, controller);
}
private OVRHapticsClip GenerateClipFromCurve()
{
var clip = new OVRHapticsClip(160);
for (int i = 0; i < clip.Capacity; i++)
{
float val = 0.5f + 0.5f * Mathf.Sin((i / 160f) * 5f * Mathf.PI * 2f);
val *= hapticCurve.Evaluate(i / 160f);
clip.WriteSample((byte)(val * 255f));
}
return(clip);
}
//Creates and Plays a Procedural Tone
// Left: Which Controller | intensity: How Powerful | length: how long in ms
public void ProceduralTone(bool Left, int intensity, int length = 25)
{
//Stop intensity going out side of byte range
intensity = Mathf.Clamp(intensity, 0, 255);
byte holder = Convert.ToByte(intensity);
proceduralClip.Reset();
for (int i = 0; i < length; i++)
{
proceduralClip.WriteSample(holder);
}
ClipPlayerNow(Left, proceduralClip);
}
/// <summary>
/// The HapticPulseOnIndex method is used to initiate a simple haptic pulse on the tracked object of the given index.
/// </summary>
/// <param name="index">The index of the tracked object to initiate the haptic pulse on.</param>
/// <param name="strength">The intensity of the rumble of the controller motor. `0` to `1`.</param>
public override void HapticPulseOnIndex(uint index, float strength = 0.5f)
{
if (index < uint.MaxValue)
{
var controller = GetControllerByIndex(index);
hapticsProceduralClip.WriteSample((byte)(strength * byte.MaxValue));
if (IsControllerLeftHand(controller))
{
OVRHaptics.LeftChannel.Preempt(hapticsProceduralClip);
}
else if (IsControllerRightHand(controller))
{
OVRHaptics.RightChannel.Preempt(hapticsProceduralClip);
}
}
}
protected override void StartHaptics(HumanBodyBones bodyPart, BodyCoordinateHit hitLocation, float intensity)
{
#if VRTK_DEFINE_SDK_OCULUS
if (isLeftController)
{
hapticsClipLeft.Reset();
hapticsClipLeft.WriteSample((byte)(intensity * byte.MaxValue));
OVRHaptics.LeftChannel.Preempt(hapticsClipLeft);
}
else
{
hapticsClipRight.Reset();
hapticsClipRight.WriteSample((byte)(intensity * byte.MaxValue));
OVRHaptics.RightChannel.Preempt(hapticsClipRight);
}
#endif
}
public void TriggerVibration(int iteration, int frequency, int strength, OVRInput.Controller controller)
{
OVRHapticsClip clip = new OVRHapticsClip();
for (int i = 0; i < iteration; i++)
{
clip.WriteSample(i % frequency == 0 ? (byte)strength : (byte)0);
}
if (controller == OVRInput.Controller.RTouch)
{
OVRHaptics.RightChannel.Preempt(clip);
}
if (controller == OVRInput.Controller.LTouch)
{
OVRHaptics.LeftChannel.Preempt(clip);
}
}
private OVRHapticsClip createHapticsClip(string strPattern)
{
var pattern = strPattern.Split(new char[] { ',' }, StringSplitOptions.RemoveEmptyEntries).Select(s => byte.Parse(s)).ToArray();
if (pattern.Count() == 0)
{
pattern = new byte[] { 255, 255, 0, 0, 0, 0 }
}
;
var clip = new OVRHapticsClip(pattern.Count());
for (int i = 0; i < clip.Capacity; i++)
{
clip.WriteSample(pattern[i]);
}
return(clip);
}
public void TriggerVibration(int iteration, int frequency, int strength, OVRInput.Controller controller)
{
OVRHapticsClip clip = new OVRHapticsClip();
// loop iteration times, base on frequency, change vibration up to strenght down to 0
for (int i = 0; i < iteration; i++)
{
clip.WriteSample(i % frequency == 0 ? (byte)strength : (byte)0);
}
if (controller == OVRInput.Controller.LTouch)
{
OVRHaptics.LeftChannel.Preempt(clip);
// Preempt means stop previous clip and start this
}
else if (controller == OVRInput.Controller.RTouch)
{
OVRHaptics.RightChannel.Preempt(clip);
}
}
internal override void HapticPulse(Controller ctrl, int durationMicroSec)
{
/* mapping from durationMicroSec, which is a value up to ~500, down to bytes */
if (haptics_clip == null)
{
haptics_clip = new OVRHapticsClip(1);
}
int value = durationMicroSec / 2;
if (value > 255)
{
value = 255;
}
haptics_clip.Reset();
haptics_clip.WriteSample((byte)value);
OVRHaptics.OVRHapticsChannel channel = OVRHaptics.Channels[ctrl.index];
channel.Preempt(haptics_clip);
}
// -------------------------------------------
/*
* TriggerVibration
*/
public void TriggerVibration(int[] _map, OVRInput.Controller _controller)
{
OVRHapticsClip clip = new OVRHapticsClip();
for (int i = 0; i < _map.Length; i++)
{
clip.WriteSample((byte)_map[i]);
}
if (_controller == OVRInput.Controller.LTouch)
{
OVRHaptics.LeftChannel.Preempt(clip);
}
if (_controller == OVRInput.Controller.RTouch)
{
OVRHaptics.RightChannel.Preempt(clip);
}
if (_controller == OVRInput.Controller.All)
{
OVRHaptics.LeftChannel.Preempt(clip);
OVRHaptics.RightChannel.Preempt(clip);
}
}
protected override void StartHaptics(HumanBodyBones bodyPart, BodyCoordinateHit hitLocation, float intensity)
{
#if VRTK_DEFINE_SDK_OCULUS
if (hapticsClipLeft == null || hapticsClipRight == null)
{
OVRHaptics.Config.Load();
hapticsClipLeft = new OVRHapticsClip();
hapticsClipRight = new OVRHapticsClip();
}
int clipLengthBytes =
Mathf.Min(
Mathf.Max(OVRHaptics.Config.SampleRateHz * hapticDuration, OVRHaptics.Config.MinimumBufferSamplesCount),
OVRHaptics.Config.MaximumBufferSamplesCount
);
if (isLeftController)
{
hapticsClipLeft.Reset();
for (int i = 0; i < clipLengthBytes; i++)
{
hapticsClipLeft.WriteSample((byte)(intensity * byte.MaxValue));
}
OVRHaptics.LeftChannel.Preempt(hapticsClipLeft);
}
else
{
hapticsClipRight.Reset();
for (int i = 0; i < clipLengthBytes; i++)
{
hapticsClipRight.WriteSample((byte)(intensity * byte.MaxValue));
}
OVRHaptics.RightChannel.Preempt(hapticsClipRight);
}
#endif
}
/*private void InitializeOVRHaptics()
* {
* const int cnt = 10;
* clipLight = new OVRHapticsClip(cnt);
* clipMedium = new OVRHapticsClip(cnt);
* clipHard = new OVRHapticsClip(cnt);
* Debug.Log (clipLight.Samples.Length.ToString ());
* Debug.Log (clipMedium.Samples.Length.ToString ());
* Debug.Log (clipHard.Samples.Length.ToString ());
* for (int i = 0; i < cnt; i++)
* {
* clipLight.Samples[i] = i % 2 == 0 ? (byte)0 : (byte)75;
* clipMedium.Samples[i] = i % 2 == 0 ? (byte)0 : (byte)150;
* clipHard.Samples[i] = i % 2 == 0 ? (byte)0 : (byte)255;
* }
*
* clipLight = new OVRHapticsClip(clipLight.Samples, clipLight.Samples.Length);
* clipMedium = new OVRHapticsClip(clipMedium.Samples, clipMedium.Samples.Length);
* clipHard = new OVRHapticsClip(clipHard.Samples, clipHard.Samples.Length);
* }
*
* public void Vibrate(VibrationForce vibrationForce)
* {
* var channel = OVRHaptics.RightChannel;
* if (leftHand)
* channel = OVRHaptics.LeftChannel;
*
* switch (vibrationForce)
* {
* case VibrationForce.Light:
* channel.Preempt(clipLight);
* break;
* case VibrationForce.Medium:
* channel.Preempt(clipMedium);
* break;
* case VibrationForce.Hard:
* channel.Preempt(clipHard);
* break;
* }
* }*/
public void ApplyHapticFeedback(VibrationForce vibrationForce)
{
HapticsClip.Reset();
int cnt = 10;
for (int i = 0; i < cnt; i++)
{
switch (vibrationForce)
{
case VibrationForce.Light:
HapticsClip.WriteSample(i % 2 == 0 ? (byte)0 : (byte)75);
break;
case VibrationForce.Medium:
HapticsClip.WriteSample(i % 2 == 0 ? (byte)0 : (byte)150);
break;
case VibrationForce.Hard:
HapticsClip.WriteSample(i % 2 == 0 ? (byte)0 : (byte)255);
break;
}
}
HapticsClip.WriteSample(0);
HapticsClip.WriteSample(0);
HapticsClip.WriteSample(0);
HapticsClip.WriteSample(0);
if (leftHand)
{
OVRHaptics.LeftChannel.Preempt(HapticsClip);
}
else
{
OVRHaptics.RightChannel.Preempt(HapticsClip);
}
}
/// <summary>
/// Pulse haptic feedback
/// </summary>
/// <param name="node">Node on which to perform the pulse.</param>
/// <param name="hapticPulse">Haptic pulse</param>
/// <param name="durationMultiplier">(Optional) Multiplier value applied to the hapticPulse duration</param>
/// <param name="intensityMultiplier">(Optional) Multiplier value applied to the hapticPulse intensity</param>
public void Pulse(Node node, HapticPulse hapticPulse, float durationMultiplier = 1f, float intensityMultiplier = 1f)
{
// Clip buffer can hold up to 800 milliseconds of samples
// At 320Hz, each sample is 3.125f milliseconds
if (Mathf.Approximately(m_MasterIntensity, 0))
{
return;
}
#if ENABLE_OVR_INPUT
m_GeneratedHapticClip.Reset();
var duration = hapticPulse.duration * durationMultiplier;
var intensity = hapticPulse.intensity * intensityMultiplier;
var fadeIn = hapticPulse.fadeIn;
var fadeOut = hapticPulse.fadeOut;
if (duration > MaxDuration)
{
duration = Mathf.Clamp(duration, 0f, MaxDuration); // Clamp at maximum 800ms for sample buffer
if (!m_SampleLengthWarningShown)
{
Debug.LogWarning("Pulse durations greater than 0.8f are not currently supported");
}
m_SampleLengthWarningShown = true;
}
const int kSampleRateConversion = 490; // Samplerate conversion : 44100/90fps = 490
const int kIntensityIncreaseMultiplier = 255; // Maximum value of 255 for intensity
const float kFadeInProportion = 0.25f;
var fadeInSampleCount = duration * kSampleRateConversion * kFadeInProportion;
var fadeOutSampleCount = fadeInSampleCount * 2; // FadeOut is less apparent than FadeIn unless FadeOut duration is increased
duration *= kSampleRateConversion;
var durationFadeOutPosition = duration - fadeOutSampleCount;
intensity = Mathf.Clamp(Mathf.Clamp01(intensity) * kIntensityIncreaseMultiplier * m_MasterIntensity, 0, kIntensityIncreaseMultiplier);
var hapticClipSample = Convert.ToByte(intensity);
for (int i = 1; i < duration; ++i)
{
float sampleShaped = hapticClipSample;
if (fadeIn && i < fadeInSampleCount)
{
sampleShaped = Mathf.Lerp(0, intensity, i / fadeInSampleCount);
}
else if (fadeOut && i > durationFadeOutPosition)
{
sampleShaped = Mathf.Lerp(0, intensity, (duration - i) / fadeOutSampleCount);
}
m_GeneratedHapticClip.WriteSample(Convert.ToByte(sampleShaped));
}
const float kMaxSimultaneousClipDuration = 0.25f;
var channel = GetTargetChannel(node);
if (duration > kMaxSimultaneousClipDuration)
{
// Prevent multiple long clips from playing back simultaneously
// If the new clip has a long duration, stop playback of any existing clips in order to prevent haptic feedback noise
if (channel != null)
{
channel.Preempt(m_GeneratedHapticClip);
}
else
{
m_RHapticsChannel.Preempt(m_GeneratedHapticClip);
m_LHapticsChannel.Preempt(m_GeneratedHapticClip);
}
}
else
{
// Allow multiple short clips to play simultaneously
if (channel != null)
{
channel.Mix(m_GeneratedHapticClip);
}
else
{
m_RHapticsChannel.Mix(m_GeneratedHapticClip);
m_LHapticsChannel.Mix(m_GeneratedHapticClip);
}
}
#endif
}
/// <summary>
/// Adds the samples from the specified clip to the ones in the currently-playing clip(s).
/// </summary>
public void Mix(OVRHapticsClip clip)
{
int numClipsToMix = 0;
int numSamplesToMix = 0;
int numSamplesRemaining = clip.Count;
while (numSamplesRemaining > 0 && numClipsToMix < m_pendingClips.Count)
{
int numSamplesRemainingInClip = m_pendingClips[numClipsToMix].Clip.Count - m_pendingClips[numClipsToMix].ReadCount;
numSamplesRemaining -= numSamplesRemainingInClip;
numSamplesToMix += numSamplesRemainingInClip;
numClipsToMix++;
}
if (numSamplesRemaining > 0)
{
numSamplesToMix += numSamplesRemaining;
numSamplesRemaining = 0;
}
if (numClipsToMix > 0)
{
OVRHapticsClip mixClip = new OVRHapticsClip(numSamplesToMix);
OVRHapticsClip a = clip;
int aReadCount = 0;
for (int i = 0; i < numClipsToMix; i++)
{
OVRHapticsClip b = m_pendingClips[i].Clip;
for(int bReadCount = m_pendingClips[i].ReadCount; bReadCount < b.Count; bReadCount++)
{
if (OVRHaptics.Config.SampleSizeInBytes == 1)
{
byte sample = 0; // TODO support multi-byte samples
if ((aReadCount < a.Count) && (bReadCount < b.Count))
{
sample = (byte)(Mathf.Clamp(a.Samples[aReadCount] + b.Samples[bReadCount], 0, System.Byte.MaxValue)); // TODO support multi-byte samples
aReadCount++;
}
else if (bReadCount < b.Count)
{
sample = b.Samples[bReadCount]; // TODO support multi-byte samples
}
mixClip.WriteSample(sample); // TODO support multi-byte samples
}
}
}
while (aReadCount < a.Count)
{
if (OVRHaptics.Config.SampleSizeInBytes == 1)
{
mixClip.WriteSample(a.Samples[aReadCount]); // TODO support multi-byte samples
}
aReadCount++;
}
m_pendingClips[0] = new ClipPlaybackTracker(mixClip);
for (int i = 1; i < numClipsToMix; i++)
{
m_pendingClips.RemoveAt(1);
}
}
else
{
m_pendingClips.Add(new ClipPlaybackTracker(clip));
}
}
public void Mix(OVRHapticsClip clip)
{
int num = 0;
int num2 = 0;
int num3 = clip.Count;
while (num3 > 0 && num < this.m_pendingClips.Count)
{
int num4 = this.m_pendingClips[num].Clip.Count - this.m_pendingClips[num].ReadCount;
num3 -= num4;
num2 += num4;
num++;
}
if (num3 > 0)
{
num2 += num3;
}
if (num > 0)
{
OVRHapticsClip ovrhapticsClip = new OVRHapticsClip(num2);
int i = 0;
for (int j = 0; j < num; j++)
{
OVRHapticsClip clip2 = this.m_pendingClips[j].Clip;
for (int k = this.m_pendingClips[j].ReadCount; k < clip2.Count; k++)
{
if (OVRHaptics.Config.SampleSizeInBytes == 1)
{
byte sample = 0;
if (i < clip.Count && k < clip2.Count)
{
sample = (byte)Mathf.Clamp((int)(clip.Samples[i] + clip2.Samples[k]), 0, 255);
i++;
}
else if (k < clip2.Count)
{
sample = clip2.Samples[k];
}
ovrhapticsClip.WriteSample(sample);
}
}
}
while (i < clip.Count)
{
if (OVRHaptics.Config.SampleSizeInBytes == 1)
{
ovrhapticsClip.WriteSample(clip.Samples[i]);
}
i++;
}
this.m_pendingClips[0] = new OVRHaptics.OVRHapticsOutput.ClipPlaybackTracker(ovrhapticsClip);
for (int l = 1; l < num; l++)
{
this.m_pendingClips.RemoveAt(1);
}
}
else
{
this.m_pendingClips.Add(new OVRHaptics.OVRHapticsOutput.ClipPlaybackTracker(clip));
}
}
// Use this for initialization
void Start()
{
clip = new OVRHapticsClip(1);
clip.WriteSample(255);
}
/// <summary>
/// Adds the samples from the specified clip to the ones in the currently-playing clip(s).
/// </summary>
public void Mix(OVRHapticsClip clip)
{
int numClipsToMix = 0;
int numSamplesToMix = 0;
int numSamplesRemaining = clip.Count;
while (numSamplesRemaining > 0 && numClipsToMix < m_pendingClips.Count)
{
int numSamplesRemainingInClip = m_pendingClips[numClipsToMix].Clip.Count - m_pendingClips[numClipsToMix].ReadCount;
numSamplesRemaining -= numSamplesRemainingInClip;
numSamplesToMix += numSamplesRemainingInClip;
numClipsToMix++;
}
if (numSamplesRemaining > 0)
{
numSamplesToMix += numSamplesRemaining;
numSamplesRemaining = 0;
}
if (numClipsToMix > 0)
{
OVRHapticsClip mixClip = new OVRHapticsClip(numSamplesToMix);
OVRHapticsClip a = clip;
int aReadCount = 0;
for (int i = 0; i < numClipsToMix; i++)
{
OVRHapticsClip b = m_pendingClips[i].Clip;
for (int bReadCount = m_pendingClips[i].ReadCount; bReadCount < b.Count; bReadCount++)
{
if (OVRHaptics.Config.SampleSizeInBytes == 1)
{
byte sample = 0; // TODO support multi-byte samples
if ((aReadCount < a.Count) && (bReadCount < b.Count))
{
sample = (byte)(Mathf.Clamp(a.Samples[aReadCount] + b.Samples[bReadCount], 0, System.Byte.MaxValue)); // TODO support multi-byte samples
aReadCount++;
}
else if (bReadCount < b.Count)
{
sample = b.Samples[bReadCount]; // TODO support multi-byte samples
}
mixClip.WriteSample(sample); // TODO support multi-byte samples
}
}
}
while (aReadCount < a.Count)
{
if (OVRHaptics.Config.SampleSizeInBytes == 1)
{
mixClip.WriteSample(a.Samples[aReadCount]); // TODO support multi-byte samples
}
aReadCount++;
}
m_pendingClips[0] = new ClipPlaybackTracker(mixClip);
for (int i = 1; i < numClipsToMix; i++)
{
m_pendingClips.RemoveAt(1);
}
}
else
{
m_pendingClips.Add(new ClipPlaybackTracker(clip));
}
}
