private void ResubmitCompletedHapticPatterns()
{
if (!VRConfig.configUseBhaptics.Value)
{
return;
}
var m_nextHapticPatternTimesClone = new Dictionary <string, float>(m_nextHapticPatternTimes); // to avoid modifying original dictionary while looping on it
foreach (KeyValuePair <string, float> pair in m_nextHapticPatternTimesClone)
{
string patternKey = pair.Key;
float nextHapticPatternTime = pair.Value;
if (Time.time >= nextHapticPatternTime && nextHapticPatternTime > 0)
{
FeedbackDetails feedback = GetElevatorStateFeedback(m_elevatorState, patternKey);
if (feedback != null)
{
var scaleOption = new ScaleOption(feedback.FeedbackIntensity, feedback.FeedbackDurationScale);
m_hapticPlayer.SubmitRegistered(feedback.PatternKey, feedback.PatternKey, scaleOption);
m_nextHapticPatternTimes[patternKey] += feedback.FeedbackDuration * feedback.FeedbackDurationScale;
}
else
{
m_nextHapticPatternTimes[patternKey] = 0;
}
}
}
}
public void Play(ScaleOption option = null)
{
if (option == null)
{
option = new ScaleOption(Intensity, Duration);
}
switch (FeedbackType)
{
case FeedbackType.DotMode:
if (DotPoints == null)
{
Debug.LogError("DotPoints not defined");
return;
}
player.Submit(_key, ToPositionType(Position), DotPoints, TimeMillis);
break;
case FeedbackType.PathMode:
if (Points == null)
{
Debug.LogError("Points not defined");
return;
}
player.Submit(_key, ToPositionType(Position), new List <PathPoint>(Convert(Points)), TimeMillis);
break;
case FeedbackType.TactFile:
if (!isOriginFileRegistered)
{
isOriginFileRegistered = true;
var feedbackFile = CommonUtils.ConvertJsonStringToTactosyFile(FeedbackFile.Value);
//Debug.Log("Register tact file " + FeedbackFile.Id + ", " + FeedbackFile.Key);
player.Register(FeedbackFile.Id, feedbackFile.Project);
}
if (FeedbackFile.Type == BhapticsUtils.TypeVest)
{
player.SubmitRegisteredVestRotation(FeedbackFile.Id, _key,
new RotationOption(VestRotationAngleX + TactFileOffsetX, VestRotationOffsetY + TactFileOffsetY),
option);
}
else if (FeedbackFile.Type == BhapticsUtils.TypeTactosy && IsReflectTactosy)
{
if (!isRegistered)
{
isRegistered = true;
var project = BhapticsUtils.ReflectLeftRight(FeedbackFile.Value);
player.Register(FeedbackFile.Id + "Reflect", project);
}
player.SubmitRegistered(FeedbackFile.Id + "Reflect", _key, option);
}
else
{
player.SubmitRegistered(FeedbackFile.Id, _key, option);
}
break;
}
}
public void Play(ScaleOption option = null)
{
if (option == null)
{
option = new ScaleOption(Intensity, Duration);
}
switch (FeedbackType)
{
case FeedbackType.DotMode:
if (DotPoints == null)
{
Debug.LogError("DotPoints not defined");
return;
}
player.Submit(_key, ToPositionType(Position), DotPoints, TimeMillis);
break;
case FeedbackType.PathMode:
if (Points == null)
{
Debug.LogError("Points not defined");
return;
}
player.Submit(_key, ToPositionType(Position), new List <PathPoint>(Convert(Points)), TimeMillis);
break;
case FeedbackType.TactFile:
if (currentFeedbackFileKey != FeedbackFile.Id)
{
currentFeedbackFileKey = FeedbackFile.Id;
player.RegisterTactFileStr(currentFeedbackFileKey, FeedbackFile.Value);
}
if (FeedbackFile.Type == BhapticsUtils.TypeVest || FeedbackFile.Type == BhapticsUtils.TypeTactot)
{
player.SubmitRegisteredVestRotation(currentFeedbackFileKey, _key,
new RotationOption(VestRotationAngleX + TactFileOffsetX, VestRotationOffsetY + TactFileOffsetY),
option);
}
else if (IsReflectTactosy && (FeedbackFile.Type == BhapticsUtils.TypeTactosy ||
FeedbackFile.Type == BhapticsUtils.TypeTactosy2))
{
var reflectKey = FeedbackFile.Id + "Reflect";
if (currentFeedbackFileKeyReflect != reflectKey)
{
player.RegisterTactFileStrReflected(reflectKey,
FeedbackFile.Value);
currentFeedbackFileKeyReflect = reflectKey;
}
player.SubmitRegistered(reflectKey, _key, option);
}
else
{
player.SubmitRegistered(currentFeedbackFileKey, _key, option);
}
break;
}
}
SetScaleInputsActive
(ScaleOption currentActiveOption,
ScaleOption desiredActiveOption)
{
SetScaleInputsActive(currentActiveOption, false);
SetScaleInputsActive(desiredActiveOption, true);
CurrentScaleType = desiredActiveOption;
}
public void SetScale(Int32 input)
{
Debug.Log("Setting scale choice to " + input);
MyContract.RequireArgument(
input == 0 || input == 1,
"is either 0 or 1",
"input"
);
ScaleOption ScaleChoice = (ScaleOption)input;
Debug.Log("Setting scale choice to " + ScaleChoice.ToString());
SetScaleInputsActive(CurrentScaleType, ScaleChoice);
}
public void SubmitRegistered(string key, ScaleOption option)
{
var request = new SubmitRequest()
{
Key = key,
Type = "key",
Parameters = new Dictionary <string, object>
{
{ "scaleOption", option }
}
};
SubmitRequest(request);
}
void ProvideHapticFeedbackThread(float locationAngle, float locationHeight, FeedbackType effect, float intensityMultiplier, bool waitToPlay)
{
if (intensityMultiplier < 0.001)
{
return;
}
if (!systemInitialized || hapticPlayer == null)
{
CreateSystem();
}
if (hapticPlayer != null)
{
if (feedbackMap.ContainsKey(effect))
{
if (feedbackMap[effect].feedbackFileCount > 0)
{
if (waitToPlay)
{
if (IsPlayingKeyAll(feedbackMap[effect].prefix, feedbackMap[effect].feedbackFileCount))
{
return;
}
}
string key = feedbackMap[effect].prefix + (RandomNumber.Between(1, feedbackMap[effect].feedbackFileCount)).ToString();
if (locationHeight < -0.5f)
{
locationHeight = -0.5f;
}
else if (locationHeight > 0.5f)
{
locationHeight = 0.5f;
}
Bhaptics.Tact.RotationOption RotOption = new RotationOption(locationAngle, locationHeight);
Bhaptics.Tact.ScaleOption scaleOption = new ScaleOption(intensityMultiplier, 1.0f);
//hapticPlayer.SubmitRegistered(key, scaleOption);
hapticPlayer.SubmitRegisteredVestRotation(key, RotOption, scaleOption);
}
}
}
}
private void PlayReceiveDamageHaptics(float dmg, Vector3 direction)
{
if (!VRConfig.configUseBhaptics.Value)
{
return;
}
var rotationOption = GetRotationOptionFromDirection(direction);
float intensity = dmg * 0.3f + 0.3f;
float duration = 1f;
var scaleOption = new ScaleOption(intensity, duration);
m_hapticPlayer.SubmitRegisteredVestRotation(VEST_DAMAGE_KEY, "", rotationOption, scaleOption);
m_lastDamageRotationOption = rotationOption;
}
/// <summary>
/// 以某种比例缩放图片
/// </summary>
/// <param name="newSize">新的尺寸</param>
/// <param name="scaleMode">缩放模式</param>
/// <param name="scaleOpiton">缩放选项</param>
public void SacleTo(Size newSize, ScaleMode scaleMode, ScaleOption scaleOpiton = ScaleOption.NoSacleWhenSmall)
{
Size size = this.bitmap.Size;
if (scaleOpiton == ScaleOption.NoSacleWhenSmall)
{
if (newSize.Height >= size.Height && newSize.Width >= size.Width)
{
return;
}
}
newSize = this.GetImageNewSize(size, newSize, scaleMode);
var img = new Bitmap(this.bitmap, newSize);
this.bitmap.Dispose();
this.bitmap = img;
}
public static void Alert(string title, string message, string[] categories, ScaleOption urgency, ScaleOption importance, IDictionary <string, object> properties, params string[] targets)
{
//EventWriter.Alert(title, message, categories, urgency, importance, properties, targets);
var props = Writer.EnsureProperties(properties);
props.Add(XFConstants.EventWriter.EventType, EventTypeOption.Alert);
props.Add(XFConstants.Alert.Title, title);
props.Add(XFConstants.Alert.Message, message);
props.Add(XFConstants.Alert.Categories, categories.ToDelimited('|'));
props.Add(XFConstants.Alert.Urgency, urgency.ToString());
props.Add(XFConstants.Alert.Importance, importance.ToString());
props.Add(XFConstants.Alert.Targets, targets.ToDelimited('|'));
props.Add(XFConstants.Alert.CreatedAt, DateTime.Now.ToString(XFConstants.DateTimeFormat));
List <TypedItem> list = Writer.Convert(props);
EventWriter.Write(EventTypeOption.Alert, list);
}
/// <summary>
/// Resim Boyutlandirir eger genislik ve yükseklik verilmezse hata verir.
/// Resmin baz olarak secilen tarafini istenilen rakama boyutlandirir.
/// Buradan cikan boyutlanma oranini diger tarafa uygular.
/// Resmin Genislik veya yuksekligini baz alarak onu istenilen olcuye getirirken
/// baz alinmayan tarafi baz alinanin resize oranina gore boyutlandirir.
/// </summary>
/// <param name="bitmap">Boyutlandirilacak bitmap resmini ifade eder.</param>
/// <param name="scaleOption">Resmi yeniden boyutlandırırken neresi baz alinacek. Eger genislik baz alinacaksa.
/// size parametresine istenilen genislik, yukseklik baz alinacaksa istenilen yukseklik verilmeli</param>
/// <param name="size">İstenilen yükseklik veya genişlik değerini ifade eder.</param>
/// <returns>Bitmap</returns>
public static Bitmap ResizeImage(Bitmap bitmap, ScaleOption scaleOption, int size)
{
if (size == 0)
{
throw new NullReferenceException("Maksimum boyut belirtilmedi.");
}
if (bitmap == null)
{
throw new NullReferenceException("Ölçeklendirilecek resim belirtilmedi.");
}
switch (scaleOption)
{
case ScaleOption.Width:
_oldSize = bitmap.Width;
break;
case ScaleOption.Height:
_oldSize = bitmap.Height;
break;
default:
throw new ArgumentOutOfRangeException(nameof(scaleOption), scaleOption, null);
}
var oran = size / (float)_oldSize;
_newHeight = (int)(bitmap.Height * oran);
_newWidth = (int)(bitmap.Width * oran);
var newBitmap = new Bitmap(_newWidth, _newHeight, PixelFormat.Format64bppArgb);
var graphicsFromImage = Graphics.FromImage(newBitmap);
graphicsFromImage.InterpolationMode = InterpolationMode.High;
//1. parametre bitmap:boyutlanacak resim
//2. parametre new Rectangle(0, 0, newWidth, newHeight): grafik nesnemizin hangi noktasından itibaren hangi size da resim ekleneceğini gösteren dikdörtgen yani yeni boyutu ne olacak resmin
//3. ve 4. parametre 0,0: eklenecek resmin hangi noktasından itibaren çizileceği (yani 1. parametrede alınan fotoğrafı hangi noktasından itibaren ekleyeceğiz)
//5. ve 6. parametre bitmap.Width, bitmap.Height: resim eklenen dikdörtgenin içine hangi boyutlarda eklecek tabiki bize verilen olması gereken genişliğe göre ayarlanan boyutlarda
//7. parametre GraphicsUnit.Pixel: ölçü birimi olrak ne kullanılcak
graphicsFromImage.DrawImage(bitmap, new Rectangle(0, 0, _newWidth, _newHeight), 0, 0, bitmap.Width, bitmap.Height, GraphicsUnit.Pixel);
return(newBitmap);
}
private void HammerChargingHaptics(float pressure)
{
if (!VRConfig.configUseBhaptics.Value)
{
return;
}
var scaleOption = new ScaleOption(pressure, 1f); // pressure goes from 0 to 1
if (Controllers.mainControllerType == HandType.Left)
{
m_hapticPlayer.SubmitRegistered(VEST_HAMMER_CHARGING_L_KEY, scaleOption);
m_hapticPlayer.SubmitRegistered(ARMS_HAMMER_CHARGING_L_KEY, scaleOption);
}
else
{
m_hapticPlayer.SubmitRegistered(VEST_HAMMER_CHARGING_R_KEY, scaleOption);
m_hapticPlayer.SubmitRegistered(ARMS_HAMMER_CHARGING_R_KEY, scaleOption);
}
}
SetScaleInputsActive
(ScaleOption targetObjects, bool active)
{
switch (targetObjects)
{
case ScaleOption.Linear:
SetObjectsActive(LinearScaleOptions, active);
break;
case ScaleOption.Logarithmic:
SetObjectsActive(LogarithmicScaleOptions, active);
break;
default:
throw new UnexpectedEnumValueException
<ScaleOption>(targetObjects);
}
CurrentScaleType = targetObjects;
}
private void PlayWeaponFireHaptics(Weapon weapon)
{
if (!VRConfig.configUseBhaptics.Value)
{
return;
}
float intensity = Haptics.GetFireHapticStrength(weapon);
var scaleOption = new ScaleOption(intensity, 1.0f);
if (Controllers.mainControllerType == HandType.Left || Controllers.aimingTwoHanded)
{
m_hapticPlayer.SubmitRegistered(VEST_FIRE_L_KEY, scaleOption);
m_hapticPlayer.SubmitRegistered(ARMS_FIRE_L_KEY, scaleOption);
}
if (Controllers.mainControllerType == HandType.Right || Controllers.aimingTwoHanded)
{
m_hapticPlayer.SubmitRegistered(VEST_FIRE_R_KEY, scaleOption);
m_hapticPlayer.SubmitRegistered(ARMS_FIRE_R_KEY, scaleOption);
}
}
private void MineExplosionHaptics(Vector3 explosionPosition)
{
if (!VRConfig.configUseBhaptics.Value)
{
return;
}
const float MAX_DISTANCE = 30f;
Vector3 playerPosition = m_player.transform.position;
playerPosition.y = 1f; // for directional haptic (a mine height of 1 will hit horizontally)
Vector3 direction = playerPosition - explosionPosition;
float distance = direction.magnitude;
if (distance < MAX_DISTANCE)
{
var rotationOption = GetRotationOptionFromDirection(direction);
float intensity = 1 - (Math.Max(0, distance - 5) / MAX_DISTANCE);
var scaleOption = new ScaleOption(intensity, 1f);
m_hapticPlayer.SubmitRegisteredVestRotation(VEST_EXPLOSION_KEY, "", rotationOption, scaleOption);
m_hapticPlayer.SubmitRegistered(ARMS_EXPLOSION_KEY, scaleOption);
}
}
public void SubmitRegisteredVestRotation(string key, string altKey, RotationOption option, ScaleOption sOption)
{
// nothing to do
}
public void SubmitRegistered(string key, ScaleOption option)
{
// nothing to do
}
private static void DrawScaledImage(SImage image, Graphics graphics, int width, int height, double scale, ScaleOption scaleOption, Color borderColor)
{
SolidBrush brush = new SolidBrush(borderColor);
graphics.FillRectangle(brush, 0, 0, width, height);
if (scaleOption == ScaleOption.Width)
{
int h = (int)(image.Height * scale);
int y = (height - h) / 2;
graphics.DrawImage(image, 0, y, width, h);
}
else if (scaleOption == ScaleOption.Height)
{
int w = (int)(image.Width * scale);
int x = (width - w) / 2;
graphics.DrawImage(image, x, 0, w, height);
}
}
public static List <Disposition> Default(this List <Disposition> list, DateTime target, ScaleOption option)
{
list.Add(new Disposition()
{
Key = "importance",
Token = option.ToString().ToLower(),
Display = option.ToString(),
StartedAt = target
});
list.Add(new Disposition()
{
Key = "urgency",
Token = option.ToString().ToLower(),
Display = option.ToString(),
StartedAt = target
});
list.Add(new Disposition()
{
Key = "status",
Token = StatusOption.None.ToString().ToLower(),
Display = StatusOption.None.ToString(),
StartedAt = target
});
return(list);
}
public void SubmitRegistered(string key, ScaleOption option)
{
SubmitRegistered(key, key, option);
}
public static void Alert(string title, string message, ScaleOption urgency, ScaleOption importance, IDictionary <string, object> properties)
{
Alert(title, message, new string[] { "general" }, urgency, importance, properties, "common");
}
public static void Alert(string title, string message, string[] categories, ScaleOption urgency, ScaleOption importance, params string[] targets)
{
Alert(title, message, categories, urgency, importance, null, targets);
}
public static void Alert(string title, string message, ScaleOption urgency, ScaleOption importance)
{
Alert(title, message, urgency, importance, null);
}
public void SubmitRegistered(string key, string altKey, RotationOption rOption, ScaleOption sOption)
{
HapticApi.SubmitRegisteredWithOption(key, altKey, sOption.Intensity, sOption.Duration, rOption.OffsetAngleX, rOption.OffsetY);
}
public void SubmitRegistered(string key, string altKey, ScaleOption option)
{
HapticApi.SubmitRegisteredWithOption(key, altKey, option.Intensity, option.Duration, 0f, 0f);
}
public void SubmitRegisteredVestRotation(string key, string altKey, RotationOption rOption, ScaleOption sOption)
{
var request = new SubmitRequest()
{
Key = key,
Type = "key",
Parameters = new Dictionary <string, object>
{
{ "rotationOption", rOption },
{ "scaleOption", sOption },
{ "altKey", altKey }
}
};
SubmitRequest(request);
}
/// <summary>
/// Bitmap dosyasını istenen yerinden, istenen boyutta yeniden ölçeklendirmek için kullanılır.
/// </summary>
/// <param name="bitmap">Bitmap olarak gönderilecek resmi ifade eder.</param>
/// <param name="imageResizeOption">Biçimlendirme şeklini ifade eder.</param>
/// <param name="directionOption">Kesilecek bitmapın yerini ifade eder.</param>
/// <param name="newWidth">Ölçeklendirilmiş bitmapın yeni genişliğini ifade eder.</param>
/// <param name="newHeight">Ölçeklendirilmiş bitmapın yeni yüksekliğini ifade eder.</param>
/// <param name="scaleOption">Yüksekliğinmi yoksa genişliğinmi esas alınacağını ifade eder.</param>
/// <returns>Bitmap</returns>
public static Bitmap ResizeImage(Bitmap bitmap, ImageResizeOption imageResizeOption, DirectionOption directionOption, int newWidth, int newHeight, ScaleOption scaleOption)
{
switch (imageResizeOption)
{
case ImageResizeOption.Fit:
if (bitmap.Height - newHeight > bitmap.Width - newWidth)
{
_rate = newHeight / (float)bitmap.Height;
var myNewWidth = (int)(bitmap.Width * _rate);
var newerBitmap = new Bitmap(myNewWidth, newHeight, PixelFormat.Format64bppArgb);
var graphicsFromImge = Graphics.FromImage(newerBitmap);
graphicsFromImge.DrawImage(bitmap, new Rectangle(0, 0, myNewWidth, newHeight), new Rectangle(0, 0, bitmap.Width, bitmap.Height), GraphicsUnit.Pixel);
return(newerBitmap);
}
else
{
_rate = newWidth / (float)bitmap.Width;
var myNewHeight = (int)(bitmap.Height * _rate);
var newerBitmap = new Bitmap(newWidth, myNewHeight, PixelFormat.Format64bppArgb);
using (_graphics = Graphics.FromImage(newerBitmap))
{
_graphics.DrawImage(bitmap, new Rectangle(0, 0, newWidth, myNewHeight), new Rectangle(0, 0, bitmap.Width, bitmap.Height), GraphicsUnit.Pixel);
return(newerBitmap);
}
}
case ImageResizeOption.Stretch:
var newlyBitmap = new Bitmap(newWidth, newHeight, PixelFormat.Format64bppArgb);
using (_graphics = Graphics.FromImage(newlyBitmap))
{
_graphics.DrawImage(bitmap, 0, 0, newWidth, newHeight);
}
return(newlyBitmap);
case ImageResizeOption.Cut:
_newBitmap = new Bitmap(newWidth, newHeight, PixelFormat.Format64bppArgb);
using (_graphics = Graphics.FromImage(_newBitmap))
{
DirectionSet(directionOption, bitmap, newWidth, newHeight);
_graphics.DrawImage(bitmap, new Rectangle(0, 0, newWidth, newHeight), _leftCoordinate, _topCoordinate, newWidth, newHeight, GraphicsUnit.Pixel);
}
return(_newBitmap);
case ImageResizeOption.Scale:
if ((newWidth / (float)bitmap.Width > newHeight / (float)bitmap.Height && newWidth / (float)bitmap.Width > 1) || (newWidth / (float)bitmap.Width > newHeight / (float)bitmap.Height && (float)newWidth / bitmap.Width < 1 && (float)newHeight / bitmap.Height < 1))
{
var myImage = ResizeImage(bitmap, ScaleOption.Width, newWidth);
return(ResizeImage(myImage, ImageResizeOption.Cut, directionOption, newWidth, newHeight, scaleOption));
}
else if (bitmap.Width == bitmap.Height)
{
var myImage = ResizeImage(bitmap, scaleOption, newWidth);
return(myImage);
}
else
{
//yukseklige gore resim boyutlandirilip sonra fazlalik kesilecek
var myImage2 = ResizeImage(bitmap, ScaleOption.Height, newHeight);
return(ResizeImage(myImage2, ImageResizeOption.Cut, directionOption, newWidth, newHeight, scaleOption));
}
default:
throw new ArgumentOutOfRangeException(nameof(imageResizeOption), imageResizeOption, null);
}
// return new Bitmap(600, 600);
}
public void Play(ScaleOption option = null)
{
if (option == null)
{
option = new ScaleOption(Intensity, Duration);
}
switch (FeedbackType)
{
case FeedbackType.DotMode:
if (DotPoints == null)
{
Debug.LogError("DotPoints not defined");
return;
}
player.Submit(_key, ToPositionType(Position), DotPoints, TimeMillis);
break;
case FeedbackType.PathMode:
if (Points == null)
{
Debug.LogError("Points not defined");
return;
}
player.Submit(_key, ToPositionType(Position), new List <PathPoint>(Convert(Points)), TimeMillis);
break;
case FeedbackType.TactFile:
if (!isOriginFileRegistered)
{
isOriginFileRegistered = true;
player.RegisterTactFileStr(FeedbackFile.Id, FeedbackFile.Value);
}
//#if UNITY_EDITOR_WIN
// // WHEN CHANGED // TODO
player.RegisterTactFileStr(FeedbackFile.Id, FeedbackFile.Value);
//#endif
if (FeedbackFile.Type == BhapticsUtils.TypeVest || FeedbackFile.Type == BhapticsUtils.TypeTactot)
{
player.SubmitRegisteredVestRotation(FeedbackFile.Id, _key,
new RotationOption(VestRotationAngleX + TactFileOffsetX, VestRotationOffsetY + TactFileOffsetY),
option);
}
else if (IsReflectTactosy && (FeedbackFile.Type == BhapticsUtils.TypeTactosy ||
FeedbackFile.Type == BhapticsUtils.TypeTactosy2))
{
var reflectKey = FeedbackFile.Id + "Reflect";
if (!isRegistered)
{
isRegistered = true;
player.RegisterTactFileStrReflected(reflectKey,
FeedbackFile.Value);
}
player.SubmitRegistered(reflectKey, _key, option);
}
else
{
player.SubmitRegistered(FeedbackFile.Id, _key, option);
}
break;
}
}
public void SubmitRegistered(string key, string altKey, ScaleOption option)
{
SubmitRegistered(key, altKey, DefaultRotationOption, option);
}
public void SubmitRegistered(string key, string altKey, RotationOption rOption, ScaleOption sOption)
{
SubmitRequest(key, altKey, sOption.Intensity, sOption.Duration, rOption.OffsetAngleX, rOption.OffsetY);
}
