423 lines
11 KiB
C#
423 lines
11 KiB
C#
using Cryville.Common.Buffers;
|
|
using Cryville.Common.Pdt;
|
|
using System;
|
|
using System.Collections.Generic;
|
|
using System.Globalization;
|
|
using UnityEngine;
|
|
|
|
namespace Cryville.Crtr {
|
|
public readonly struct MotionRegistry {
|
|
readonly Type m_Type;
|
|
public readonly Type Type {
|
|
get { return m_Type; }
|
|
}
|
|
|
|
readonly Vector m_InitValue;
|
|
public readonly Vector InitValue {
|
|
get { return m_InitValue.Clone(); }
|
|
}
|
|
|
|
readonly Vector m_GlobalInitValue;
|
|
public readonly Vector GlobalInitValue {
|
|
get { return m_GlobalInitValue.Clone(); }
|
|
}
|
|
|
|
public MotionRegistry(Type type) : this((Vector)Activator.CreateInstance(type)) { }
|
|
|
|
public MotionRegistry(Vector init) : this(init, init) { }
|
|
|
|
public MotionRegistry(Vector init, Vector globalInit) {
|
|
if (!init.GetType().Equals(globalInit.GetType())) throw new ArgumentException();
|
|
m_Type = init.GetType();
|
|
m_InitValue = init;
|
|
m_GlobalInitValue = globalInit;
|
|
}
|
|
}
|
|
|
|
public class MotionNode {
|
|
public short Id = -1;
|
|
public bool Reset;
|
|
public Vec1 Time;
|
|
public Vec1 EndTime;
|
|
public PdtExpression Transition;
|
|
public Vector Value;
|
|
|
|
public void Init(Type type) {
|
|
Time ??= new Vec1(float.NegativeInfinity);
|
|
EndTime ??= new Vec1(float.NegativeInfinity);
|
|
Value ??= (Vector)Activator.CreateInstance(type);
|
|
}
|
|
|
|
public void CopyTo(MotionNode dest) {
|
|
dest.Id = Id;
|
|
Time.CopyTo(dest.Time);
|
|
EndTime.CopyTo(dest.EndTime);
|
|
dest.Transition = Transition;
|
|
Value.CopyTo(dest.Value);
|
|
}
|
|
|
|
public void LerpWith(MotionNode start, Vector4 trans, ref MotionNode result) {
|
|
result.Id = Id;
|
|
if (Time == null) start.Time.CopyTo(result.Time);
|
|
else {
|
|
var t = (Vector)result.Time;
|
|
Time.LerpWith(start.Time, trans, ref t);
|
|
}
|
|
if (EndTime == null) start.EndTime.CopyTo(result.EndTime);
|
|
else {
|
|
var t = (Vector)result.EndTime;
|
|
EndTime.LerpWith(start.EndTime, trans, ref t);
|
|
}
|
|
if (Value == null) start.Value.CopyTo(result.Value);
|
|
else Value.LerpWith(start.Value, trans, ref result.Value);
|
|
}
|
|
}
|
|
|
|
internal class MotionNodePool : CategorizedPool<Type, MotionNode> {
|
|
public static MotionNodePool Shared;
|
|
private class Bucket : ObjectPool<MotionNode> {
|
|
readonly Type _type;
|
|
public Bucket(Type type, int capacity) : base(capacity) {
|
|
_type = type;
|
|
}
|
|
protected override MotionNode Construct() {
|
|
var result = new MotionNode();
|
|
result.Init(_type);
|
|
return result;
|
|
}
|
|
}
|
|
readonly Dictionary<Type, ObjectPool<MotionNode>> m_buckets;
|
|
protected override IDictionary<Type, ObjectPool<MotionNode>> Buckets { get { return m_buckets; } }
|
|
public MotionNodePool() {
|
|
m_buckets = new Dictionary<Type, ObjectPool<MotionNode>>();
|
|
foreach (var reg in ChartPlayer.motionRegistry) {
|
|
var type = reg.Value.Type;
|
|
if (!m_buckets.ContainsKey(type))
|
|
m_buckets.Add(type, new Bucket(type, 4096));
|
|
}
|
|
m_buckets.TrimExcess();
|
|
}
|
|
}
|
|
|
|
public abstract class Vector {
|
|
public Vector() { }
|
|
|
|
public abstract byte Dimension { get; }
|
|
|
|
public abstract void ApplyFrom(Vector parent);
|
|
public abstract void LerpWith(Vector start, float lerpedTime, ref Vector result);
|
|
public abstract void LerpWith(Vector start, Vector4 trans, ref Vector result);
|
|
public abstract override string ToString();
|
|
public abstract unsafe void ToArray(float* arr);
|
|
|
|
public Vector Clone() {
|
|
return (Vector)MemberwiseClone();
|
|
}
|
|
public abstract void CopyTo(Vector dest);
|
|
|
|
static readonly Type[] floatArrayTypeArray = new Type[] { typeof(float[]) };
|
|
public static Vector Construct(Type type, float[] values) {
|
|
if (!typeof(Vector).IsAssignableFrom(type)) throw new ArgumentException("Type is not vector");
|
|
return (Vector)type.GetConstructor(floatArrayTypeArray).Invoke(new object[] { values });
|
|
}
|
|
}
|
|
|
|
public class Vec1 : Vector {
|
|
public float Value;
|
|
|
|
public Vec1() { Value = 0; }
|
|
public Vec1(float[] v) { Value = v[0]; }
|
|
public Vec1(float i) { Value = i; }
|
|
|
|
public override byte Dimension { get { return 1; } }
|
|
|
|
public override void ApplyFrom(Vector parent) {
|
|
var p = (Vec1)parent;
|
|
Value += p.Value;
|
|
}
|
|
|
|
public override void LerpWith(Vector start, float lerpedTime, ref Vector result) {
|
|
var r = (Vec1)result;
|
|
if (start == null) {
|
|
r.Value = Value;
|
|
return;
|
|
}
|
|
var s = (Vec1)start;
|
|
r.Value = s.Value * (1 - lerpedTime) + Value * lerpedTime;
|
|
}
|
|
public override void LerpWith(Vector start, Vector4 trans, ref Vector result) {
|
|
var r = (Vec1)result;
|
|
if (start == null) {
|
|
r.Value = Value;
|
|
return;
|
|
}
|
|
var s = (Vec1)start;
|
|
r.Value = s.Value * (1 - trans.x) + Value * trans.x;
|
|
}
|
|
|
|
public override void CopyTo(Vector dest) {
|
|
var d = (Vec1)dest;
|
|
d.Value = Value;
|
|
}
|
|
|
|
public override string ToString() {
|
|
return Value.ToString(CultureInfo.InvariantCulture);
|
|
}
|
|
|
|
public override unsafe void ToArray(float* arr) {
|
|
arr[0] = Value;
|
|
}
|
|
}
|
|
|
|
public class VecI1 : Vector {
|
|
public int Value;
|
|
|
|
public VecI1() { Value = 0; }
|
|
public VecI1(float[] v) { Value = (int)v[0]; }
|
|
public VecI1(int i) { Value = i; }
|
|
|
|
public override byte Dimension { get { return 1; } }
|
|
|
|
public override void ApplyFrom(Vector parent) {
|
|
var p = (VecI1)parent;
|
|
Value += p.Value;
|
|
}
|
|
|
|
public override void LerpWith(Vector start, float lerpedTime, ref Vector result) {
|
|
var r = (VecI1)result;
|
|
if (start == null) {
|
|
r.Value = Value;
|
|
return;
|
|
}
|
|
var s = (VecI1)start;
|
|
r.Value = (int)(s.Value * (1 - lerpedTime) + Value * lerpedTime);
|
|
}
|
|
public override void LerpWith(Vector start, Vector4 trans, ref Vector result) {
|
|
var r = (VecI1)result;
|
|
if (start == null) {
|
|
r.Value = Value;
|
|
return;
|
|
}
|
|
var s = (VecI1)start;
|
|
r.Value = (int)(s.Value * (1 - trans.x) + Value * trans.x);
|
|
}
|
|
|
|
public override void CopyTo(Vector dest) {
|
|
var d = (VecI1)dest;
|
|
d.Value = Value;
|
|
}
|
|
|
|
public override string ToString() {
|
|
return Value.ToString(CultureInfo.InvariantCulture);
|
|
}
|
|
|
|
public override unsafe void ToArray(float* arr) {
|
|
arr[0] = Value;
|
|
}
|
|
}
|
|
|
|
public class Vec1m : Vector {
|
|
public float Value;
|
|
|
|
public Vec1m() { Value = 1; }
|
|
public Vec1m(float[] v) { Value = v[0]; }
|
|
public Vec1m(float i) : base() { Value = i; }
|
|
|
|
public override byte Dimension { get { return 1; } }
|
|
|
|
public override void ApplyFrom(Vector parent) {
|
|
var p = (Vec1m)parent;
|
|
Value *= p.Value;
|
|
}
|
|
|
|
public override void LerpWith(Vector start, float lerpedTime, ref Vector result) {
|
|
var r = (Vec1m)result;
|
|
if (start == null) {
|
|
r.Value = Value;
|
|
return;
|
|
}
|
|
var s = (Vec1m)start;
|
|
r.Value = s.Value * (1 - lerpedTime) + Value * lerpedTime;
|
|
}
|
|
public override void LerpWith(Vector start, Vector4 trans, ref Vector result) {
|
|
var r = (Vec1m)result;
|
|
if (start == null) {
|
|
r.Value = Value;
|
|
return;
|
|
}
|
|
var s = (Vec1m)start;
|
|
r.Value = s.Value * (1 - trans.x) + Value * trans.x;
|
|
}
|
|
|
|
public override void CopyTo(Vector dest) {
|
|
var d = (Vec1m)dest;
|
|
d.Value = Value;
|
|
}
|
|
|
|
public override string ToString() {
|
|
return Value.ToString(CultureInfo.InvariantCulture);
|
|
}
|
|
|
|
public override unsafe void ToArray(float* arr) {
|
|
arr[0] = Value;
|
|
}
|
|
}
|
|
|
|
public class Vec2 : Vector {
|
|
float x, y;
|
|
|
|
public Vec2() { x = y = 0; }
|
|
public Vec2(float[] v) { x = v[0]; y = v[1]; }
|
|
public Vec2(float x, float y) { this.x = x; this.y = y; }
|
|
|
|
public override byte Dimension { get { return 2; } }
|
|
|
|
public override void ApplyFrom(Vector parent) {
|
|
var p = (Vec2)parent;
|
|
x += p.x; y += p.y;
|
|
}
|
|
|
|
public override void LerpWith(Vector start, float lerpedTime, ref Vector result) {
|
|
var r = (Vec2)result;
|
|
if (start == null) {
|
|
r.x = x;
|
|
r.y = y;
|
|
return;
|
|
}
|
|
var s = (Vec2)start;
|
|
r.x = s.x * (1 - lerpedTime) + x * lerpedTime;
|
|
r.y = s.y * (1 - lerpedTime) + y * lerpedTime;
|
|
}
|
|
public override void LerpWith(Vector start, Vector4 trans, ref Vector result) {
|
|
var r = (Vec2)result;
|
|
if (start == null) {
|
|
r.x = x;
|
|
r.y = y;
|
|
return;
|
|
}
|
|
var s = (Vec2)start;
|
|
r.x = s.x * (1 - trans.x) + x * trans.x;
|
|
r.y = s.y * (1 - trans.y) + y * trans.y;
|
|
}
|
|
|
|
public Vector3 ToVector2() {
|
|
return new Vector3(x, y);
|
|
}
|
|
|
|
public override void CopyTo(Vector dest) {
|
|
var d = (Vec2)dest;
|
|
d.x = x; d.y = y;
|
|
}
|
|
|
|
public override string ToString() {
|
|
return string.Format(CultureInfo.InvariantCulture, "{0},{1}", x, y);
|
|
}
|
|
|
|
public override unsafe void ToArray(float* arr) {
|
|
arr[0] = x;
|
|
arr[1] = y;
|
|
}
|
|
}
|
|
|
|
public class Vec3 : Vector {
|
|
float x, y, z;
|
|
|
|
public Vec3() { x = y = z = 0; }
|
|
public Vec3(float[] v) { x = v[0]; y = v[1]; z = v[2]; }
|
|
public Vec3(float x, float y, float z) { this.x = x; this.y = y; this.z = z; }
|
|
|
|
public override byte Dimension { get { return 3; } }
|
|
|
|
public override void ApplyFrom(Vector parent) {
|
|
var p = (Vec3)parent;
|
|
x += p.x; y += p.y; z += p.z;
|
|
}
|
|
|
|
public override void LerpWith(Vector start, float lerpedTime, ref Vector result) {
|
|
var r = (Vec3)result;
|
|
if (start == null) {
|
|
r.x = x;
|
|
r.y = y;
|
|
r.z = z;
|
|
return;
|
|
}
|
|
var s = (Vec3)start;
|
|
r.x = s.x * (1 - lerpedTime) + x * lerpedTime;
|
|
r.y = s.y * (1 - lerpedTime) + y * lerpedTime;
|
|
r.z = s.z * (1 - lerpedTime) + z * lerpedTime;
|
|
}
|
|
public override void LerpWith(Vector start, Vector4 trans, ref Vector result) {
|
|
var r = (Vec3)result;
|
|
if (start == null) {
|
|
r.x = x;
|
|
r.y = y;
|
|
r.z = z;
|
|
return;
|
|
}
|
|
var s = (Vec3)start;
|
|
r.x = s.x * (1 - trans.x) + x * trans.x;
|
|
r.y = s.y * (1 - trans.y) + y * trans.y;
|
|
r.z = s.z * (1 - trans.z) + z * trans.z;
|
|
}
|
|
|
|
public Vector3 ToVector3() {
|
|
return new Vector3(x, y, z);
|
|
}
|
|
|
|
public override void CopyTo(Vector dest) {
|
|
var d = (Vec3)dest;
|
|
d.x = x; d.y = y; d.z = z;
|
|
}
|
|
|
|
public override string ToString() {
|
|
return string.Format(CultureInfo.InvariantCulture, "{0},{1},{2}", x, y, z);
|
|
}
|
|
|
|
public override unsafe void ToArray(float* arr) {
|
|
arr[0] = x;
|
|
arr[1] = y;
|
|
arr[2] = z;
|
|
}
|
|
}
|
|
|
|
public unsafe class VectorSrc : PropSrc.FixedBuffer<Vector> {
|
|
const int MAX_DIMENSION = 4;
|
|
public VectorSrc(Func<Vector> cb) : base(PdtInternalType.Vector, MAX_DIMENSION * sizeof(float) + sizeof(int), cb) {
|
|
fixed (byte* rptr = buf) {
|
|
var ptr = (float*)rptr;
|
|
*(int*)(ptr + MAX_DIMENSION) = PdtInternalType.Number;
|
|
}
|
|
}
|
|
protected override void InternalGet() {
|
|
var v = _cb();
|
|
if (v.Dimension > MAX_DIMENSION) throw new NotSupportedException("Vector dimension too large");
|
|
fixed (byte* rptr = buf) {
|
|
var ptr = (float*)rptr;
|
|
v.ToArray(ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public class VectorOp : PropOp.Fixed<float[]> {
|
|
public VectorOp(Action<float[]> cb) : base(cb) { }
|
|
protected override unsafe void Execute() {
|
|
var op = GetOperand(0);
|
|
float[] values;
|
|
if (op.Type == PdtInternalType.Number) {
|
|
values = new float[] { op.AsNumber() };
|
|
}
|
|
else if (op.Type == PdtInternalType.Vector) {
|
|
op.GetArraySuffix(out int type, out _);
|
|
if (type != PdtInternalType.Number)
|
|
throw new InvalidOperationException("Not a vector of numbers");
|
|
values = new float[(op.Length - sizeof(int)) / sizeof(float)];
|
|
fixed (float* ptr = values) {
|
|
op.CopyTo((byte*)ptr, 0, op.Length - sizeof(int));
|
|
}
|
|
}
|
|
else throw new InvalidOperationException("Invalid operand");
|
|
_cb(values);
|
|
}
|
|
}
|
|
}
|