internal object GetValue(object item)
{
var propertyValue = RuntimeProperty?.GetValue(item);
var transformedValue = TransformValue?.Invoke(propertyValue) ?? propertyValue;
return(transformedValue);
}
public InstructionData(ExtensionEnum sentExtension = ExtensionEnum.None, string sentName = null, int[] sentIdentifer = null, TransformValue sentTransformValue = default(TransformValue))
{
extension = sentExtension;
name = sentName;
identifier = sentIdentifer;
transformValue = sentTransformValue;
}
public void SetSpawnTransform(Transform sentTrans)
{
if (sentTrans == null)
{
spawnTransformValue = default(TransformValue);
return;
}
spawnTransformValue = new TransformValue(sentTrans);
}
public ImageDisplayInformation([NotNull] string name, [NotNull] ImageValue image, [CanBeNull] TransformValue transform)
{
Name = name;
Content = image;
Transform = transform;
layer = 0;
displayMatrix = Matrix4x4.identity;
status = ImageStatus.Unavailable;
}
//Create instance from TransformValue
public TransformValue(TransformValue sentTransValue)
{
xPosition = sentTransValue.Position.x;
yPosition = sentTransValue.Position.y;
zPosition = sentTransValue.Position.z;
xRotation = sentTransValue.Rotation.x;
yRotation = sentTransValue.Rotation.y;
zRotation = sentTransValue.Rotation.z;
wRotation = sentTransValue.Rotation.w;
}
public void SetPosition(TransformValue sentTransValue)
{
Show();
if (sentTransValue.Position == new Vector3(0, 0, 0))
{
Debug.Log("Player found null transform");
return;
}
transform.SetPositionAndRotation(sentTransValue.Position, sentTransValue.Rotation);
fpsController.ResetRotation();
Hide();
}
//Compare hashcodes to determine if equal
public override bool Equals(object obj)
{
if (obj == null)
{
return(false);
}
if (obj.GetType() != this.GetType())
{
return(false);
}
TransformValue sentTrans = (TransformValue)obj;
return(GetHashCode() == sentTrans.GetHashCode());
}
void ChangeTransformValue(string raw, TransformValue value)
{
NumberFormatInfo info = new NumberFormatInfo {
NumberDecimalSeparator = "."
};
if (!float.TryParse(raw, NumberStyles.AllowLeadingSign | NumberStyles.AllowDecimalPoint, info, out float result))
{
result = 0;
}
switch (value)
{
case TransformValue.PositionX:
editedGameObject.Transform.localPosition.X = result;
break;
case TransformValue.PositionY:
editedGameObject.Transform.localPosition.Y = result;
break;
case TransformValue.PositionZ:
editedGameObject.Transform.localPosition.Z = result;
break;
case TransformValue.RotationX:
editedGameObject.Transform.localRotation.X = result;
break;
case TransformValue.RotationY:
editedGameObject.Transform.localRotation.Y = result;
break;
case TransformValue.RotationZ:
editedGameObject.Transform.localRotation.Z = result;
break;
case TransformValue.ScaleX:
editedGameObject.Transform.localScale.X = result;
break;
case TransformValue.ScaleY:
editedGameObject.Transform.localScale.Y = result;
break;
case TransformValue.ScaleZ:
editedGameObject.Transform.localScale.Z = result;
break;
}
}
private void AddImage(ref ImageValue currentImage, ref string currentName, ref TransformValue currentTransform, List <ImageDisplayInformation> images, PluginExecuteContext context)
{
if (string.IsNullOrEmpty(currentName))
{
throw new MissingMemberException($"Unable to create show command: missing image name for {currentImage.ConvertToString(context.Language)}");
}
// ReSharper disable once AccessToModifiedClosure
var name = currentName;
var image = currentImage;
images.RemoveAll(e => e.Name == name || e.Content.EqualsWith(image, context.Language));
images.Add(new ImageDisplayInformation(currentName, currentImage, currentTransform == null ? null : (TransformValue)_defaultTransform.AddWith(currentTransform)));
currentName = null;
currentImage = null;
currentTransform = null;
}
// .. COROUTINES
IEnumerator UpdateAnimation(Camera camera_to_animate)
{
float elapsed = 0f;
float total_time = KeyFrames.Sum(e => e.TimeBetweenFrames);
Transform camera_transform = camera_to_animate.GetComponent <Transform>();
while (elapsed < total_time)
{
float elapsed_frame = 0;
CameraAnimationKeyframe from, to;
GetCameraKeyFramesAtTime(elapsed, out from, out to);
TransformValue from_transform = new TransformValue(from.CameraPreview == null ? camera_transform : from.CameraPreview.GetComponent <Transform>());
TransformValue to_transform = new TransformValue(to.CameraPreview.GetComponent <Transform>());
float from_fov = from.CameraPreview == null ? camera_to_animate.fieldOfView : from.CameraPreview.fieldOfView;
float to_fov = to.CameraPreview.fieldOfView;
while (elapsed_frame < to.TimeBetweenFrames)
{
float normalized_time = elapsed_frame / to.TimeBetweenFrames;
//Transform
EasingFunctions.Ease(to.TransformEaseType, normalized_time, from_transform, to_transform, ref camera_transform);
//Field of View
camera_to_animate.fieldOfView = EasingFunctions.Ease(to.FieldOfViewEaseType, normalized_time, from_fov, to_fov);
elapsed += Time.deltaTime;
elapsed_frame += Time.deltaTime;
yield return(null);
}
camera_transform.localPosition = to_transform.LocalPosition;
camera_transform.localRotation = to_transform.LocalRotation;
camera_transform.localScale = to_transform.LocalScale;
camera_to_animate.fieldOfView = to_fov;
}
if (OnAnimationCompleted != null)
{
OnAnimationCompleted.Invoke(this);
}
}
public static void Lerp(this Transform transform, TransformValue start, TransformValue end, float t)
{
transform.localPosition = Vector3.Lerp(start.LocalPosition, end.LocalPosition, t);
transform.localRotation = Quaternion.Lerp(start.LocalRotation, end.LocalRotation, t);
transform.localScale = Vector3.Lerp(start.LocalScale, end.LocalScale, t);
}
public PlayerInstruction(Transform sentTrans)
{
spawnPoint = new TransformValue(sentTrans);
}
public void SetPosition(TransformValue sentTrans)
{
transform.position = sentTrans.Position;
transform.rotation = sentTrans.Rotation;
}
public static void Ease(TYPE type, float normalized_time, TransformValue start_value, TransformValue end_value, ref Transform value)
{
float factor = Ease(type, normalized_time, 0.0f, 1.0f);
value.Lerp(start_value, end_value, factor);
}
public static void Lerp(this Transform transform, TransformValue start, TransformValue end, float t)
{
transform.localPosition = Vector3.Lerp(start.LocalPosition, end.LocalPosition, t);
transform.localRotation = Quaternion.Lerp(start.LocalRotation, end.LocalRotation, t);
transform.localScale = Vector3.Lerp(start.LocalScale, end.LocalScale, t);
}
private (ImageBindMode Mode, int Layer, EffectValue Effect, ImageDisplayInformation[] Images) AnalyseParameters(PluginExecuteContext context)
{
EffectValue effect = null;
var bind = ImageBindMode.None;
int? layer = null;
var images = new List <ImageDisplayInformation>();
ImageValue currentImage = null;
string currentName = null;
TransformValue currentTransform = null;
foreach (var(key, value) in context.Parameters)
{
switch (key)
{
case EffectValue effectValue:
effect = effectValue;
break;
case ImageValue imageValue:
if (currentImage != null)
{
AddImage(ref currentImage, ref currentName, ref currentTransform, images, context);
}
currentImage = imageValue;
currentTransform = new TransformValue();
break;
case IStringConverter stringConverter:
var name = stringConverter.ConvertToString(context.Language);
switch (name)
{
case "Layer":
layer = IntegerValue.TryParse(value);
break;
case "Name":
currentName = StringValue.TryParse(value);
break;
case "Effect":
effect = value is EffectValue effectValue ? effectValue : throw new ArgumentException($"Unable to create show command: effect {value} is not EffectValue");
break;
case "Transform":
currentTransform = (TransformValue)currentTransform.AddWith(value);
break;
case "Bind":
if (value is NullValue)
{
bind = ImageBindMode.Canvas;
}
else
{
switch (StringValue.TryParse(value))
{
case "Canvas":
case "Maximal":
case "Max":
bind = ImageBindMode.Canvas;
break;
case "Minimal":
case "Min":
bind = ImageBindMode.Minimal;
break;
}
}
break;
case "DefaultTransform":
_defaultTransform = value is TransformValue transformValue ? transformValue : throw new ArgumentException($"Unable to set show command default transform: target {value} is not TransformValue");
break;
case "DefaultLayer":
_defaultLayer = IntegerValue.TryParse(value);
break;
default:
TransformPlugin.AnalyzePropertyTo(name, value, currentTransform, context.Language);
break;
}
break;
}
}
if (currentImage != null)
{
AddImage(ref currentImage, ref currentName, ref currentTransform, images, context);
}
layer = layer ?? _defaultLayer;
var list = images.ToArray();
for (var i = -1; ++i < list.Length;)
{
list[i].layer = layer.Value;
list[i].status = ImageStatus.PrepareToShow;
}
return(bind, layer.Value, effect, list);
}
public PlayerInstruction(TransformValue sentTransValue)
{
spawnPoint = sentTransValue;
}
public async Task <SerializableValue> Execute(PluginExecuteContext context)
{
var(mode, layer, effect, images) = AnalyseParameters(context);
if (!images.Any())
{
return(new NullValue());
}
if (_placeholder != null)
{
await _placeholder;
}
CreatePlaceholder();
InitializeImage(images, layer);
if (effect == null)
{
await PlaceNewImages(images);
UpdateImageList(images);
CompletePlaceholder();
return(new NullValue());
}
var names = images.Select(e => e.Name).ToArray();
if (mode == ImageBindMode.None)
{
var existedImages = await UpdateImageInfo(_images.Where(e => names.Contains(e.Key)).Select(e => e.Value).ToArray());
images = await UpdateImageInfo(images);
await Dispatcher.WaitAll(images.Select(e => e.Content.Texture.ReadTexture()));
var targets = existedImages.Length == 0
? images.Select(e => (Previous: (ImageDisplayInformation?)null, Target: e)).ToArray()
: (from image in images
join e in existedImages.AsNullable() on image.Name equals e?.Name into tempImages
from r in tempImages.DefaultIfEmpty()
select(Previous: r, Target: image)).ToArray();
var finalImages = new List <ImageDisplayInformation>();
for (var i = -1; ++i < targets.Length;)
{
var(previous, target) = targets[i];
if (previous.HasValue && previous.Value.Content.Texture.texture != null && target.Content.Texture.texture != null)
{
var texture = previous.Value.Content.Texture.texture;
var previousRect = previous.Value.displayMatrix.MultiplyRect(new Rect(0, 0, texture.width, texture.height));
texture = target.Content.Texture.texture;
var targetRect = target.displayMatrix.MultiplyRect(new Rect(0, 0, texture.width, texture.height));
var canvasSize = previousRect.MergeWith(targetRect).MaximizeToRectInt();
var shader = await GetCombinerShader();
var combiner = new Texture2DCombiner(canvasSize.width, canvasSize.height, shader);
var drawingMatrix = previous.Value.displayMatrix;
drawingMatrix.SetTranslation(previousRect.position - canvasSize.position);
combiner.DrawTexture(previous.Value.Content.Texture.texture, drawingMatrix);
var canvasTransform = new TransformValue()
.Set(TransformValue.PropertyName.PositionX, canvasSize.xMin)
.Set(TransformValue.PropertyName.PositionY, canvasSize.yMin);
await PlaceOverlayCanvas(previous.Value.Name, combiner.Combine(), canvasTransform, previous.Value.layer);
combiner = new Texture2DCombiner(canvasSize.width, canvasSize.height, shader);
drawingMatrix = target.displayMatrix;
drawingMatrix.SetTranslation(targetRect.position - canvasSize.position);
combiner.DrawTexture(target.Content.Texture.texture, drawingMatrix);
finalImages.Add(new ImageDisplayInformation(target.Name, new ImageValue {
Uv = target.Content.Uv,
Color = target.Content.Color,
Texture = new Texture2DValue {
texture = combiner.Combine()
}
}, canvasTransform)
{
layer = target.layer,
status = ImageStatus.PrepareToShow
});
}
else
{
finalImages.Add(target);
}
}
await PlaceNewImages(finalImages.ToArray(), effect.Effect as SingleGraphicEffect);
await PlaceNewImages(images);
UpdateImageList(images);
CompletePlaceholder();
return(new NullValue());
}
var overlayCanvas = await BindImages(FindPreBindImages(names));
var targetCanvas = await BindImages(images);
RectInt displayArea;
(overlayCanvas, targetCanvas, displayArea) = CutDisplayArea(new RectInt(0, 0, targetCanvas.width, targetCanvas.height), overlayCanvas, targetCanvas, mode);
var overlayName = $"OVERLAY{{{Guid.NewGuid().ToString().ToUpper()}}}";
var overlayTransform = CreateOverlayTransform(displayArea.position);
await PlaceOverlayCanvas(overlayName, overlayCanvas, overlayTransform, layer);
await RemoveHiddenSeparateImages(names);
await PlayOverlayEffect(overlayName, targetCanvas, effect.Effect as SingleGraphicEffect, overlayTransform, layer);
await PlaceNewImages(images);
await RemoveOverlayImage(overlayName);
UpdateImageList(images);
CompletePlaceholder();
return(new NullValue());
}
public static void Ease(TYPE type, float normalized_time, TransformValue start_value, TransformValue end_value, ref Transform value)
{
float factor = Ease(type, normalized_time, 0.0f, 1.0f);
value.Lerp(start_value, end_value, factor);
}
