Code cleanup.

Assets/Animations/IConfig.anim.meta

@@ -1,8 +1,8 @@
 fileFormatVersion: 2
-guid: 66a6563760d5cfa47ac1057052043fa7
-timeCreated: 1610937108
-licenseType: Free
+guid: 2e0c61e29fd90f04b9e41265d93e2029
 NativeFormatImporter:
+  externalObjects: {}
+  mainObjectFileID: 7400000
   userData: 
   assetBundleName: 
   assetBundleVariant: 

Assets/Animations/TConfig_Main.anim.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: d815e4d844e6a1c4d849e96e199f8881
+NativeFormatImporter:
+  externalObjects: {}
+  mainObjectFileID: 7400000
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Animations/TMain_Config.anim.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 82867c59112ff5a419fbea2ebff2d3b9
+NativeFormatImporter:
+  externalObjects: {}
+  mainObjectFileID: 7400000
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Cryville/Common/Buffers/CategorizedPool.cs

@@ -0,0 +1,90 @@
+using System.Collections.Generic;
+
+namespace Cryville.Common.Buffers {
+	/// <summary>
+	/// A set of resource pools categorized by a category type.
+	/// </summary>
+	/// <typeparam name="TCategory">The category type.</typeparam>
+	/// <typeparam name="TObject">The type of the objects in the pool.</typeparam>
+	public abstract class CategorizedPool<TCategory, TObject> where TObject : class {
+		/// <summary>
+		/// The set of underlying pools.
+		/// </summary>
+		/// <remarks>
+		/// <para>The <see cref="Rent(TCategory)" /> and <see cref="Return(TCategory, TObject)" /> method select an underlying pool directly from this set with the category as the key. When overridden, this set must be available since construction.</para>
+		/// </remarks>
+		protected abstract IReadOnlyDictionary<TCategory, ObjectPool<TObject>> Buckets { get; }
+		/// <summary>
+		/// The count of objects rented from the set of pools.
+		/// </summary>
+		public int RentedCount { get; private set; }
+		/// <summary>
+		/// Rents an object from the pool.
+		/// </summary>
+		/// <param name="category">The category.</param>
+		/// <returns>The rented object.</returns>
+		public TObject Rent(TCategory category) {
+			var obj = Buckets[category].Rent();
+			RentedCount++;
+			return obj;
+		}
+		/// <summary>
+		/// Returns a rented object to the pool.
+		/// </summary>
+		/// <param name="category">The category.</param>
+		/// <param name="obj">The object to return.</param>
+		public void Return(TCategory category, TObject obj) {
+			Buckets[category].Return(obj);
+			--RentedCount;
+		}
+	}
+	/// <summary>
+	/// A utility to access a categorized pool, representing a single unit that uses a shared categorized pool.
+	/// </summary>
+	/// <typeparam name="TCategory">The category type.</typeparam>
+	/// <typeparam name="TObject">The type of the objects in the pool.</typeparam>
+	public class CategorizedPoolAccessor<TCategory, TObject> where TObject : class {
+		readonly CategorizedPool<TCategory, TObject> _pool;
+		static readonly SimpleObjectPool<Dictionary<TObject, TCategory>> _dictPool
+			= new SimpleObjectPool<Dictionary<TObject, TCategory>>(1024);
+		Dictionary<TObject, TCategory> _rented;
+		/// <summary>
+		/// Creates an instance of the <see cref="CategorizedPoolAccessor{TCategory, TObject}" /> class.
+		/// </summary>
+		/// <param name="pool">The categorized pool.</param>
+		public CategorizedPoolAccessor(CategorizedPool<TCategory, TObject> pool) {
+			_pool = pool;
+		}
+		/// <summary>
+		/// Rents an object from the pool.
+		/// </summary>
+		/// <param name="category">The category.</param>
+		/// <returns>The rented object.</returns>
+		public TObject Rent(TCategory category) {
+			var obj = _pool.Rent(category);
+			if (_rented == null) _rented = _dictPool.Rent();
+			_rented.Add(obj, category);
+			return obj;
+		}
+		/// <summary>
+		/// Returns a rented object to the pool.
+		/// </summary>
+		/// <param name="obj">The object to return.</param>
+		public void Return(TObject obj) {
+			_pool.Return(_rented[obj], obj);
+			_rented.Remove(obj);
+		}
+		/// <summary>
+		/// Returns all objects rented by this accessor to the pool.
+		/// </summary>
+		public void ReturnAll() {
+			if (_rented == null) return;
+			foreach (var obj in _rented) {
+				_pool.Return(obj.Value, obj.Key);
+			}
+			_rented.Clear();
+			_dictPool.Return(_rented);
+			_rented = null;
+		}
+	}
+}

Assets/Cryville/Common/Buffers/CategorizedPool.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: ec18f22479042d747b88c093aa90c5c0
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Cryville/Common/Buffers/ObjectPool.cs

@@ -14,6 +14,10 @@
 			_objs = new T[capacity];
 		}
 		/// <summary>
+		/// The count of objects rented from the pool.
+		/// </summary>
+		public int RentedCount { get { return _index; } }
+		/// <summary>
 		/// Rents a object from the pool.
 		/// </summary>
 		/// <returns>The rented object.</returns>
@@ -24,6 +28,7 @@
 				_objs[_index++] = null;
 			}
 			if (obj == null) obj = Construct();
+			else Reset(obj);
 			return obj;
 		}
 		/// <summary>
@@ -38,5 +43,10 @@
 		/// </summary>
 		/// <returns>The new instance.</returns>
 		protected abstract T Construct();
+		/// <summary>
+		/// Resets an object.
+		/// </summary>
+		/// <param name="obj">The object.</param>
+		protected virtual void Reset(T obj) { }
 	}
 }

Assets/Cryville/Common/Font/FontFile.cs

@@ -3,7 +3,6 @@ using System;
 using System.Collections;
 using System.Collections.Generic;
 using System.IO;
-using System.Text;
 
 namespace Cryville.Common.Font {
 	public abstract class FontFile : IEnumerable<Typeface> {

Assets/Cryville/Common/Identifier.cs

@@ -24,11 +24,11 @@ namespace Cryville.Common {
 			if (Key == 0) return "";
 			return Name.ToString();
 		}
-		public static implicit operator Identifier(string identifier) {
-			return new Identifier(identifier);
+		public static bool operator ==(Identifier lhs, Identifier rhs) {
+			return lhs.Equals(rhs);
 		}
-		public static implicit operator string(Identifier identifier) {
-			return identifier.ToString();
+		public static bool operator !=(Identifier lhs, Identifier rhs) {
+			return !lhs.Equals(rhs);
 		}
 	}
 }

Assets/Cryville/Common/Math/ColumnVector.cs

@@ -54,16 +54,13 @@ namespace Cryville.Common.Math {
 			return res;
 		}
 		/// <summary>
-		/// Creates a <see cref="System.Single" /> column vector and fills it with polynomial coefficients.
+		/// Fills a <see cref="System.Single" /> column vector with polynomial coefficients.
 		/// </summary>
-		/// <param name="size">The size of the column vector.</param>
+		/// <param name="vec">The column vector.</param>
 		/// <param name="num">The base number.</param>
-		/// <returns>A <see cref="System.Single" /> column vector filled with polynomial coefficients.</returns>
-		public static ColumnVector<float> WithPolynomialCoefficients(int size, float num) {
-			var m = new ColumnVector<float>(size);
-			for (var i = 0; i < size; i++)
-				m[i] = (float)System.Math.Pow(num, i);
-			return m;
+		public static void FillWithPolynomialCoefficients(ColumnVector<float> vec, float num) {
+			for (var i = 0; i < vec.Size; i++)
+				vec[i] = (float)System.Math.Pow(num, i);
 		}
 	}
 }

Assets/Cryville/Common/Math/SquareMatrix.cs

@@ -1,4 +1,4 @@
-using System;
+using UnsafeIL;
 
 namespace Cryville.Common.Math {
 	/// <summary>
@@ -40,11 +40,11 @@ namespace Cryville.Common.Math {
 		/// </summary>
 		/// <typeparam name="T">The vector type.</typeparam>
 		/// <param name="v">The column vector.</param>
+		/// <param name="result">The result column vector.</param>
 		/// <param name="o">The column operator.</param>
-		/// <returns>The column vector eliminated.</returns>
-		public ColumnVector<T> Eliminate<T>(ColumnVector<T> v, IVectorOperator<T> o) {
+		public void Eliminate<T>(ColumnVector<T> v, ColumnVector<T> result, IVectorOperator<T> o) {
 			int s = Size;
-			Array.Copy(content, buffer, Size * Size);
+			FillBuffer();
 			for (int i = 0; i < s; i++) refl[i] = i;
 			for (int r = 0; r < s; r++) {
 				for (int r0 = r; r0 < s; r0++)
@@ -66,14 +66,17 @@ namespace Cryville.Common.Math {
 					v[or1] = o.Add(v[or1], o.ScalarMultiply(-sf1, v[or]));
 				}
 			}
-			ColumnVector<T> res = new ColumnVector<T>(s);
 			for (int r2 = s - 1; r2 >= 0; r2--) {
 				var v2 = v[refl[r2]];
 				for (int c2 = r2 + 1; c2 < s; c2++)
-					v2 = o.Add(v2, o.ScalarMultiply(-buffer[refl[r2], c2], res[refl[c2]]));
-				res[refl[r2]] = v2;
+					v2 = o.Add(v2, o.ScalarMultiply(-buffer[refl[r2], c2], result[refl[c2]]));
+				result[refl[r2]] = v2;
+			}
+		}
+		unsafe void FillBuffer() {
+			fixed (void* ptrc = content, ptrb = buffer) {
+				Unsafe.CopyBlock(ptrb, ptrc, (uint)(Size * Size * sizeof(float)));
 			}
-			return res;
 		}
 		/// <summary>
 		/// Creates a square matrix and fills it with polynomial coefficients.

Assets/Cryville/Common/Pdt/PdtAttributes.cs

@@ -1,7 +1,21 @@
 using System;
 
 namespace Cryville.Common.Pdt {
+	/// <summary>
+	/// Indicates that the attributed member is an element list.
+	/// </summary>
+	/// <remarks>
+	/// <para>An element list is a <see cref="System.Collections.IDictionary" /> that represents a collection of PDT elements. There must be at most one element list in a class.</para>
+	/// </remarks>
+	[AttributeUsage(AttributeTargets.Field | AttributeTargets.Property)]
 	public class ElementListAttribute : Attribute { }
-	public class ComponentListAttribute : Attribute { }
+
+	/// <summary>
+	/// Indicates that the attributed member is a property list.
+	/// </summary>
+	/// <remarks>
+	/// <para>A property list is a <see cref="System.Collections.IDictionary" /> that represents a collection of PDT properties. There must be at most one property list in a class.</para>
+	/// </remarks>
+	[AttributeUsage(AttributeTargets.Field | AttributeTargets.Property)]
 	public class PropertyListAttribute : Attribute { }
 }

Assets/Cryville/Common/Pdt/PdtEvaluatorBase.cs

@@ -186,7 +186,7 @@ namespace Cryville.Common.Pdt {
 		protected abstract PdtOperator GetOperator(PdtOperatorSignature sig);
 		unsafe void Operate(PdtOperator op, int pc, bool noset = false) {
 			fixed (byte* pmem = _mem) {
-				op.Begin(this);
+				op.Begin(this, pc);
 				for (int i = 0; i < pc; i++) {
 					var frame = _stack[--_framecount];
 					op.LoadOperand(new PdtVariableMemory(frame.Type, pmem + frame.Offset, frame.Length));

Assets/Cryville/Common/Pdt/PdtExpression.cs

@@ -11,7 +11,7 @@ namespace Cryville.Common.Pdt {
 		/// <summary>
 		/// Whether the value of this expression is constant.
 		/// </summary>
-		/// <remarks>The value of this property is <c>false</c> until it is optimized.</remarks>
+		/// <remarks>The value of this property is <see langword="false" /> until it is optimized.</remarks>
 		public bool IsConstant { get; internal set; }
 		internal bool IsPotentialConstant;
 		internal PdtExpression(LinkedList<PdtInstruction> ins) {

Assets/Cryville/Common/Pdt/PdtInterpreter.cs

@@ -34,9 +34,9 @@ namespace Cryville.Common.Pdt {
 			0x0001, 0x0080, 0x0100, 0x0000, 0x0030, 0x0080, 0x0080, 0x0000, 0x0200, 0x0400, 0x0080, 0x0080, 0x0080, 0x0080, 0x0040, 0x0080,
 			0x0050, 0x0050, 0x0050, 0x0050, 0x0050, 0x0050, 0x0050, 0x0050, 0x0050, 0x0050, 0x1000, 0x1800, 0x0080, 0x0080, 0x0080, 0x0030,
 			0x0080, 0x0030, 0x0030, 0x0030, 0x0030, 0x0030, 0x0030, 0x0030, 0x0030, 0x0030, 0x0030, 0x0030, 0x0030, 0x0030, 0x0030, 0x0030,
-			0x0030, 0x0030, 0x0030, 0x0030, 0x0030, 0x0030, 0x0030, 0x0030, 0x0030, 0x0030, 0x0030, 0x0000, 0x0000, 0x0000, 0x0000, 0x0030,
+			0x0030, 0x0030, 0x0030, 0x0030, 0x0030, 0x0030, 0x0030, 0x0030, 0x0030, 0x0030, 0x0030, 0x0000, 0x0080, 0x0000, 0x0080, 0x0030,
 			0x0000, 0x0030, 0x0030, 0x0030, 0x0030, 0x0030, 0x0030, 0x0030, 0x0030, 0x0030, 0x0030, 0x0030, 0x0030, 0x0030, 0x0030, 0x0030,
-			0x0030, 0x0030, 0x0030, 0x0030, 0x0030, 0x0030, 0x0030, 0x0030, 0x0030, 0x0030, 0x0030, 0x1000, 0x0080, 0x1000, 0x0000, 0x0000,
+			0x0030, 0x0030, 0x0030, 0x0030, 0x0030, 0x0030, 0x0030, 0x0030, 0x0030, 0x0030, 0x0030, 0x1000, 0x0080, 0x1000, 0x0080, 0x0000,
 		};
 
 		/// <summary>
@@ -54,43 +54,92 @@ namespace Cryville.Common.Pdt {
 		/// <param name="binder">The binder.</param>
 		/// <returns>The interpreted object.</returns>
 		public static T Interpret<T>(string src, Binder binder) {
-			return (T)new PdtInterpreter(src, typeof(T), binder).Interpret();
+			return (T)new PdtInterpreter(src, binder).Interpret(typeof(T));
 		}
 
+		/// <summary>
+		/// The source string.
+		/// </summary>
 		public string Source { get; private set; }
-		readonly Type _type;
-		readonly Binder _binder;
+		Binder _binder;
+		/// <summary>
+		/// The current position in the string being parsed by the interpreter.
+		/// </summary>
 		public int Position { get; private set; }
 #pragma warning disable IDE1006
+		/// <summary>
+		/// The character at the current position.
+		/// </summary>
+		/// <exception cref="IndexOutOfRangeException">The end of the source string is reached.</exception>
 		protected char cc { get { return Source[Position]; } }
+		/// <summary>
+		/// The category of the character.
+		/// </summary>
+		/// <exception cref="IndexOutOfRangeException">The end of the source string is reached.</exception>
 		protected int ct { get { return cm[cc]; } }
-		protected string tokenb(int flag) { // Token Whitelist
+		/// <summary>
+		/// Reads a token until a character of type <paramref name="flag" /> is met.
+		/// </summary>
+		/// <param name="flag">The type filter.</param>
+		/// <returns>A token from the current position (inclusive) to the next character of type <paramref name="flag" /> (exclusive).</returns>
+		/// <exception cref="IndexOutOfRangeException">No character of type <paramref name="flag" /> is met.</exception>
+		protected string tokenb(int flag) {
 			int sp = Position;
 			while ((ct & flag) == 0) Position++;
 			return Source.Substring(sp, Position - sp);
 		}
-		protected string tokenw(int flag) { // Token Whitelist
+		/// <summary>
+		/// Reads a token until a character that is not of type <paramref name="flag" /> is met.
+		/// </summary>
+		/// <param name="flag">The type filter.</param>
+		/// <returns>A token from the current position (inclusive) to the next character that is not of type <paramref name="flag" /> (exclusive).</returns>
+		/// <exception cref="IndexOutOfRangeException">No character that is not of type <paramref name="flag" /> is met.</exception>
+		protected string tokenw(int flag) {
 			int sp = Position;
 			while ((ct & flag) != 0) Position++;
 			return Source.Substring(sp, Position - sp);
 		}
+		/// <summary>
+		/// Skips over whitespaces.
+		/// </summary>
+		/// <exception cref="IndexOutOfRangeException">The end of the source string is reached.</exception>
 		protected void ws() {
 			while ((ct & 0x0001) != 0) Position++;
 		}
 #pragma warning restore IDE1006
 
+		/// <summary>
+		/// Reads the current character and increments the position.
+		/// </summary>
+		/// <returns>The current character.</returns>
+		/// <exception cref="IndexOutOfRangeException">The end of the source string is reached.</exception>
 		protected char GetChar() {
 			char r = cc;
 			Position++;
 			return r;
 		}
+		/// <summary>
+		/// Reads an identifier.
+		/// </summary>
+		/// <returns>An identifier.</returns>
+		/// <exception cref="IndexOutOfRangeException">The end of the source string is reached.</exception>
 		protected string GetIdentifier() {
 			if ((ct & 0x0020) == 0) return "";
 			return tokenw(0x0010);
 		}
+		/// <summary>
+		/// Reads a number.
+		/// </summary>
+		/// <returns>A number.</returns>
+		/// <exception cref="IndexOutOfRangeException">The end of the source string is reached.</exception>
 		protected string GetNumber() {
 			return tokenw(0x0040);
 		}
+		/// <summary>
+		/// Reads a string.
+		/// </summary>
+		/// <returns>A string.</returns>
+		/// <exception cref="IndexOutOfRangeException">The end of the source string is reached.</exception>
 		protected string GetString() {
 			int sp = Position;
 			do {
@@ -100,6 +149,11 @@ namespace Cryville.Common.Pdt {
 			Position++;
 			return Regex.Replace(Source.Substring(sp + 1, Position - sp - 2), @"\\(.)", "$1");
 		}
+		/// <summary>
+		/// Reads an expression.
+		/// </summary>
+		/// <returns>An expression.</returns>
+		/// <exception cref="IndexOutOfRangeException">The end of the source string is reached.</exception>
 		protected PdtExpression GetExp() {
 			var ins = new LinkedList<PdtInstruction>();
 			int _;
@@ -112,23 +166,27 @@ namespace Cryville.Common.Pdt {
 		/// Creates an instance of the <see cref="PdtInterpreter" /> class.
 		/// </summary>
 		/// <param name="src">The source string.</param>
-		/// <param name="type">The destination type.</param>
 		/// <param name="binder">The binder. May be <c>null</c>.</param>
-		public PdtInterpreter(string src, Type type, Binder binder) {
+		public PdtInterpreter(string src, Binder binder) {
 			Source = src;
-			_type = type;
 			_binder = binder;
-			if (_binder == null)
-				_binder = BinderAttribute.CreateBinderOfType(_type);
+		}
+		int[] m_formatVersion;
+		public int[] GetFormatVersion() {
+			if (m_formatVersion == null) InterpretDirectives();
+			return m_formatVersion;
 		}
 		/// <summary>
 		/// Interprets the source to an object.
 		/// </summary>
+		/// <param name="type">The output type.</param>
 		/// <returns>The interpreted object.</returns>
-		public object Interpret() {
+		public object Interpret(Type type) {
 			try {
-				InterpretDirectives();
-				return InterpretObject(_type);
+				if (m_formatVersion == null) InterpretDirectives();
+				if (_binder == null)
+					_binder = BinderAttribute.CreateBinderOfType(type);
+				return InterpretObject(type);
 			}
 			catch (Exception ex) {
 				throw new PdtParsingException(this, ex);
@@ -146,7 +204,10 @@ namespace Cryville.Common.Pdt {
 						break;
 					case "format":
 						ws();
-						if (GetNumber() != "1")
+						m_formatVersion = (from i in GetNumber().Split('.') select int.Parse(i)).ToArray();
+						if (m_formatVersion.Length == 0)
+							throw new FormatException("Invalid format version");
+						if (m_formatVersion[0] != 1)
 							throw new NotSupportedException("Format not supported");
 						flag = true;
 						break;
@@ -167,10 +228,14 @@ namespace Cryville.Common.Pdt {
 		}
 		object InterpretObject(Type type) {
 			var result = ReflectionHelper.InvokeEmptyConstructor(type);
-			bool dictflag = ReflectionHelper.IsGenericDictionary(type);
+			bool dictflag = typeof(IDictionary).IsAssignableFrom(type);
 			while (true) {
 				try { ws(); }
 				catch (IndexOutOfRangeException) { return result; }
+				if (cc == '}') {
+					GetChar();
+					return result;
+				}
 				object pkey = InterpretKey(type);
 				char c = GetChar();
 				switch (c) {
@@ -183,19 +248,20 @@ namespace Cryville.Common.Pdt {
 							((IDictionary)result).Add(key, value);
 						}
 						else {
-							MemberInfo prop;
-							bool flag = ReflectionHelper.TryFindMemberWithAttribute<ElementListAttribute>(type, out prop);
-							if (!flag && pkey is string) prop = ReflectionHelper.GetMember(type, (string)pkey);
+							MemberInfo prop = null;
+							bool flag = false;
+							if (pkey is string) prop = ReflectionHelper.GetMember(type, (string)pkey);
+							if (prop == null) flag = ReflectionHelper.TryFindMemberWithAttribute<ElementListAttribute>(type, out prop);
+							if (prop == null) throw new MissingMemberException(string.Format("The property \"{0}\" is not found", pkey));
 							Type ptype = ReflectionHelper.GetMemberType(prop);
-							if (ReflectionHelper.IsGenericDictionary(ptype)) {
+							if (flag) {
+								if (!typeof(IDictionary).IsAssignableFrom(ptype))
+									throw new InvalidOperationException("Internal error: Element list is not a dictionary");
 								var ktype = ptype.GetGenericArguments()[0];
 								var vtype = ptype.GetGenericArguments()[1];
-								if (flag) {
-									object key = _binder.ChangeType(pkey, ktype, null);
-									object value = InterpretObject(vtype);
-									((IDictionary)ReflectionHelper.GetValue(prop, result)).Add(key, value);
-								}
-								else ReflectionHelper.SetValue(prop, result, InterpretObject(ptype));
+								object key = _binder.ChangeType(pkey, ktype, null);
+								object value = InterpretObject(vtype);
+								((IDictionary)ReflectionHelper.GetValue(prop, result)).Add(key, value);
 							}
 							else ReflectionHelper.SetValue(prop, result, InterpretObject(ptype));
 						}
@@ -211,28 +277,36 @@ namespace Cryville.Common.Pdt {
 							((IDictionary)result).Add(key, value);
 						}
 						else {
-							MemberInfo prop;
-							bool flag = ReflectionHelper.TryFindMemberWithAttribute<PropertyListAttribute>(type, out prop);
-							if (!flag && pkey is string) prop = ReflectionHelper.GetMember(type, (string)pkey);
+							MemberInfo prop = null;
+							bool flag = false;
+							if (pkey is string) prop = ReflectionHelper.GetMember(type, (string)pkey);
+							if (prop == null) flag = ReflectionHelper.TryFindMemberWithAttribute<PropertyListAttribute>(type, out prop);
+							if (prop == null) throw new MissingMemberException(string.Format("The property \"{0}\" is not found", pkey));
 							var ptype = ReflectionHelper.GetMemberType(prop);
-							if (!typeof(IDictionary).IsAssignableFrom(ptype)) {
-								object value = _binder.ChangeType(exp, ptype, null);
-								ReflectionHelper.SetValue(prop, result, value, _binder);
-							}
-							else {
+							if (flag) {
+								if (!typeof(IDictionary).IsAssignableFrom(ptype))
+									throw new InvalidOperationException("Internal error: Property list is not a dictionary");
 								var ktype = ptype.GetGenericArguments()[0];
 								var vtype = ptype.GetGenericArguments()[1];
 								object key = _binder.ChangeType(pkey, ktype, null);
 								object value = _binder.ChangeType(exp, vtype, null);
 								((IDictionary)ReflectionHelper.GetValue(prop, result)).Add(key, value);
 							}
+							else {
+								object value = _binder.ChangeType(exp, ptype, null);
+								ReflectionHelper.SetValue(prop, result, value, _binder);
+							}
 						}
 						break;
-					case '}':
-						return result;
+					default:
+						throw new InvalidOperationException("Internal error: Invalid key interpretation");
 				}
 			}
 		}
+		/// <summary>
+		/// Interprets a key from the current position.
+		/// </summary>
+		/// <returns>The interpreted key.</returns>
 		protected virtual object InterpretKey(Type type) {
 			return tokenb(0x1000).Trim();
 		}

Assets/Cryville/Common/Pdt/PdtOperator.cs

@@ -11,7 +11,7 @@ namespace Cryville.Common.Pdt {
 		/// <summary>
 		/// The count of the operands loaded.
 		/// </summary>
-		protected int LoadedOperandCount { get { return ParamCount - _loadindex; } }
+		protected int LoadedOperandCount { get; private set; }
 		/// <summary>
 		/// Gets the operand at the specified index.
 		/// </summary>
@@ -24,24 +24,24 @@ namespace Cryville.Common.Pdt {
 			int i = index + _loadindex;
 			return _operands[i];
 		}
-		internal int ParamCount { get; private set; }
+		readonly int _pc;
 		/// <summary>
 		/// Creates an instance of the <see cref="PdtOperator" /> class.
 		/// </summary>
 		/// <param name="pc">The suggested parameter count.</param>
 		protected PdtOperator(int pc) {
-			ParamCount = pc;
+			_pc = pc;
 			_operands = new PdtVariableMemory[pc];
 		}
 		PdtEvaluatorBase _etor;
 		bool _rfreq = true;
-		internal void Begin(PdtEvaluatorBase etor) {
+		internal void Begin(PdtEvaluatorBase etor, int pc) {
 			_etor = etor;
-			_loadindex = ParamCount;
+			_loadindex = LoadedOperandCount = pc;
 		}
 		internal void LoadOperand(PdtVariableMemory mem) {
-			if (_loadindex == 0) return;
-			_operands[--_loadindex] = mem;
+			if (--_loadindex >= _pc) return;
+			_operands[_loadindex] = mem;
 		}
 		internal void Call(byte* prmem, bool noset) {
 			_prmem = prmem;
@@ -55,6 +55,9 @@ namespace Cryville.Common.Pdt {
 		/// <summary>
 		/// Executes the operator.
 		/// </summary>
+		/// <remarks>
+		/// <para>When overridden, this method reads operands by calling <see cref="GetOperand(int)" />, and writes the result to the frame obtained by calling <see cref="GetReturnFrame(int, int)" />.</para>
+		/// </remarks>
 		protected abstract void Execute();
 		/// <summary>
 		/// Gets a return frame.

Assets/Cryville/Common/Pdt/PdtVariableMemory.cs

@@ -1,4 +1,5 @@
 using System;
+using UnsafeIL;
 
 namespace Cryville.Common.Pdt {
 	/// <summary>
@@ -42,7 +43,9 @@ namespace Cryville.Common.Pdt {
 		/// <param name="dest">The destination buffer.</param>
 		/// <param name="destOffset">The offset on the destination buffer to start copying to.</param>
 		/// <param name="length">The length to copy.</param>
+		/// <exception cref="ArgumentOutOfRangeException"><paramref name="length" /> is greater than the length of the span.</exception>
 		public void CopyTo(byte* dest, int destOffset, int length) {
+			if (length > Length) throw new ArgumentOutOfRangeException("length");
 			for (int i = 0; i < length; i++)
 				dest[destOffset + i] = _ptr[i];
 		}
@@ -126,10 +129,43 @@ namespace Cryville.Common.Pdt {
 				throw new InvalidCastException("Not an identifier");
 			return *(int*)(_ptr + offset);
 		}
-		internal void* TrustedAsOfLength(int len) {
-			if (Length < len)
-				throw new InvalidCastException("Type not matched");
-			return _ptr;
+		/// <summary>
+		/// Gets the memory of the span as an instance of the specified type.
+		/// </summary>
+		/// <typeparam name="T">The specified type.</typeparam>
+		/// <param name="offset">The offset on the span to start reading from.</param>
+		/// <returns>An instance of the specified type.</returns>
+		/// <exception cref="ArgumentOutOfRangeException"><paramref name="offset" /> is not less than the length of the span.</exception>
+		/// <exception cref="InvalidCastException">The length of the span is not sufficient.</exception>
+		/// <remarks>
+		/// <para>Use <see cref="AsNumber(int)" /> instead while reading an unaligned number.</para>
+		/// </remarks>
+		public T As<T>(int offset = 0) {
+			var len = Unsafe.SizeOf<T>();
+			if (offset >= Length)
+				throw new ArgumentOutOfRangeException("offset");
+			if (offset + len > Length)
+				throw new InvalidCastException("Frame length not sufficient");
+			return Unsafe.Read<T>(_ptr + offset);
+		}
+		/// <summary>
+		/// Sets the memory of the span to an instance of the specified type.
+		/// </summary>
+		/// <typeparam name="T">The specified type.</typeparam>
+		/// <param name="value">The value.</param>
+		/// <param name="offset">The offset from the start of the span.</param>
+		/// <exception cref="ArgumentOutOfRangeException"><paramref name="offset" /> is not less than the length of the span.</exception>
+		/// <exception cref="InvalidCastException">The length of the span is not sufficient.</exception>
+		/// <remarks>
+		/// <para>Use <see cref="SetNumber(float, int)" /> instead while writing an unaligned number.</para>
+		/// </remarks>
+		public void Set<T>(T value, int offset = 0) {
+			var len = Unsafe.SizeOf<T>();
+			if (offset >= Length)
+				throw new ArgumentOutOfRangeException("offset");
+			if (offset + len > Length)
+				throw new InvalidCastException("Frame length not sufficient");
+			Unsafe.Write(_ptr + offset, value);
 		}
 		/// <summary>
 		/// Gets the array suffix.

Assets/Cryville/Common/Unity/UI/SetIntegerParameterBehaviour.cs

@@ -0,0 +1,10 @@
+using UnityEngine;
+
+namespace Cryville.Common.Unity.UI {
+	public class SetIntegerParameterBehaviour : SetParameterBehaviour {
+		[SerializeField] int m_value;
+		public override void OnStateEnter(Animator animator, AnimatorStateInfo stateInfo, int layerIndex) {
+			animator.SetInteger(m_name, m_value);
+		}
+	}
+}

Assets/Cryville/Common/Unity/UI/SetIntegerParameterBehaviour.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 57079cdf55a0d1149903f00ee732fa85
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Cryville/Common/Unity/UI/SetParameterBehaviour.cs

@@ -0,0 +1,8 @@
+using UnityEngine;
+
+namespace Cryville.Common.Unity.UI {
+	public abstract class SetParameterBehaviour : StateMachineBehaviour {
+		[SerializeField] protected string m_name;
+		public override abstract void OnStateEnter(Animator animator, AnimatorStateInfo stateInfo, int layerIndex);
+	}
+}

Assets/Cryville/Common/Unity/UI/SetParameterBehaviour.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: d48088ca586ef5a41a42f6564e35b230
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Cryville/Common/Unity/UI/TMPAutoFont.cs

@@ -45,7 +45,7 @@ namespace Cryville.Common.Unity.UI {
 		}
 
 		static MethodInfo _methodCreateFontAsset;
-		static object[] _paramsCreateFontAsset = new object[] { null, null, 90, 9, GlyphRenderMode.SDFAA, 1024, 1024, Type.Missing, Type.Missing };
+		static readonly object[] _paramsCreateFontAsset = new object[] { null, null, 90, 9, GlyphRenderMode.SDFAA, 1024, 1024, Type.Missing, Type.Missing };
 		static FontAsset CreateFontAsset(string path, int index) {
 			if (_methodCreateFontAsset == null) {
 				_methodCreateFontAsset = typeof(FontAsset).GetMethod(

Assets/Cryville/Crtr/Browsing/ExtensionInterface.cs

@@ -1,5 +1,4 @@
-using System;
-using System.Collections.Generic;
+using System.Collections.Generic;
 
 namespace Cryville.Crtr.Browsing {
 	public abstract class ExtensionInterface {

Assets/Cryville/Crtr/Browsing/ResourceBrowserMaster.cs

@@ -1,5 +1,6 @@
 using Cryville.Common;
 using Cryville.Common.Unity.UI;
+using Cryville.Crtr.Config;
 using Newtonsoft.Json;
 using System.Collections.Generic;
 using UnityEngine;
@@ -12,11 +13,12 @@ namespace Cryville.Crtr.Browsing {
 		private Button m_playButton;
 		[SerializeField]
 		private Button m_configButton;
+		[SerializeField]
+		private ConfigPanelMaster m_configPanel;
 
 		private DockLayoutGroup _group;
 		public ResourceBrowser MainBrowser { get; private set; }
 		private DetailPanel _detailPanel;
-		private SettingsPanel _settingsPanel;
 		readonly List<ResourceBrowserUnit> _units = new List<ResourceBrowserUnit>();
 
 #pragma warning disable IDE0051
@@ -25,7 +27,6 @@ namespace Cryville.Crtr.Browsing {
 			MainBrowser = transform.GetChild(0).GetComponent<ResourceBrowser>();
 			MainBrowser.ResourceManager = new LegacyResourceManager(Settings.Default.GameDataPath);
 			_detailPanel = transform.GetChild(1).GetComponent<DetailPanel>();
-			_settingsPanel = transform.GetChild(2).GetComponent<SettingsPanel>();
 			_units.Add(MainBrowser);
 			_units.Add(_detailPanel);
 		}
@@ -80,12 +81,6 @@ namespace Cryville.Crtr.Browsing {
 
 		public void OpenConfig(int id, ChartDetail detail) {
 			SetDataSettings(id, detail);
-#if UNITY_5_3_OR_NEWER
-			SceneManager.LoadScene("Config", LoadSceneMode.Additive);
-#else
-			Application.LoadLevelAdditive("Config");
-#endif
-			GameObject.Find("/Master").GetComponent<Master>().HideMenu();
 		}
 
 		void SetDataSettings(int id, ChartDetail detail) {

Assets/Cryville/Crtr/Chart.cs

@@ -6,6 +6,7 @@ using System.ComponentModel;
 using System.Globalization;
 using System.Linq;
 using System.Text.RegularExpressions;
+using UnsafeIL;
 
 namespace Cryville.Crtr {
 	[JsonConverter(typeof(BeatTimeConverter))]
@@ -109,10 +110,11 @@ namespace Cryville.Crtr {
 		public float BeatOffset;
 		
 		[JsonIgnore]
-		public abstract int Priority {
-			get;
-		}
-		
+		public abstract int Priority { get; }
+
+		[JsonIgnore]
+		public virtual bool Standalone { get { return false; } }
+
 		public ChartEvent Clone() {
 			return (ChartEvent)MemberwiseClone();
 		}
@@ -153,6 +155,10 @@ namespace Cryville.Crtr {
 		protected ChartEvent() {
 			PropSrcs = new Dictionary<int, PropSrc>();
 			PropOps = new Dictionary<int, PropOp>();
+			SubmitPropSrc("event", new PropSrc.Float(() => {
+				int hash = GetHashCode();
+				return Unsafe.As<int, float>(ref hash);
+			}));
 			SubmitPropSrc("long", new PropSrc.Boolean(() => IsLong));
 			SubmitPropSrc("time", new PropSrc.BeatTime(() => time.Value));
 			SubmitPropSrc("endtime", new PropSrc.BeatTime(() => endtime.Value));
@@ -259,9 +265,7 @@ namespace Cryville.Crtr {
 			}
 		}
 
-		public override int Priority {
-			get { return 10; }
-		}
+		public override int Priority { get { return 10; } }
 
 		public class Group : EventContainer {
 			public List<Track> tracks = new List<Track>();
@@ -281,15 +285,11 @@ namespace Cryville.Crtr {
 					default: return base.GetEventsOfType(type);
 				}
 			}
-			public override int Priority {
-				get { return 10; }
-			}
+			public override int Priority { get { return 10; } }
 		}
 
 		public class Track : EventContainer {
-			public override int Priority {
-				get { return 10; }
-			}
+			public override int Priority { get { return 10; } }
 		}
 
 		public class Motion : ChartEvent {
@@ -325,7 +325,7 @@ namespace Cryville.Crtr {
 				else {
 					AbsoluteValue = Vector.Construct(registry.Type, m.Groups[11].Value);
 				}
-				SubmitPropSrc("value", VectorSrc.Construct(() => {
+				SubmitPropSrc("value", new VectorSrc(() => {
 					if (RelativeNode != null) return RelativeNode.Value;
 					else return AbsoluteValue;
 				}));
@@ -375,9 +375,7 @@ namespace Cryville.Crtr {
 			[DefaultValue(0.0f)]
 			public float sumfix = 0.0f;
 
-			public override int Priority {
-				get { return -2; }
-			}
+			public override int Priority { get { return -2; } }
 
 			public Motion() {
 				SubmitPropOp("motion", new PropOp.String(v => motion = v));
@@ -413,9 +411,7 @@ namespace Cryville.Crtr {
 					default: return base.GetEventsOfType(type);
 				}
 			}
-			public override int Priority {
-				get { return 12; }
-			}
+			public override int Priority { get { return 12; } }
 		}
 
 		public class Judge : ChartEvent {
@@ -428,9 +424,8 @@ namespace Cryville.Crtr {
 			}
 #pragma warning restore IDE1006
 
-			public override int Priority {
-				get { return 0; }
-			}
+			public override int Priority { get { return 0; } }
+			public override bool Standalone { get { return true; } }
 
 			public Judge() {
 				SubmitPropSrc("name", new PropSrc.Identifier(() => Id.Key));
@@ -444,9 +439,7 @@ namespace Cryville.Crtr {
 		public class Signature : ChartEvent {
 			public float? tempo;
 
-			public override int Priority {
-				get { return -4; }
-			}
+			public override int Priority { get { return -4; } }
 		}
 
 		public List<Sound> sounds;
@@ -457,9 +450,7 @@ namespace Cryville.Crtr {
 			// TODO [Obsolete]
 			public float offset;
 
-			public override int Priority {
-				get { return 0; }
-			}
+			public override int Priority { get { return 0; } }
 		}
 	}
 }

Assets/Cryville/Crtr/ChartPlayer.cs

@@ -16,7 +16,6 @@ using UnityEngine;
 using UnityEngine.Networking;
 using UnityEngine.SceneManagement;
 using UnityEngine.Scripting;
-using UnityEngine.UI;
 using diag = System.Diagnostics;
 using Logger = Cryville.Common.Logger;
 
@@ -43,14 +42,14 @@ namespace Cryville.Crtr {
 		EventBus bbus;
 		EventBus tbus;
 		EventBus nbus;
+		InputProxy inputProxy;
 		Judge judge;
+		public static EffectManager effectManager;
 		bool started = false;
 
 		static bool initialized;
-		static Text logs;
+		TextMeshProUGUI logs;
 		TextMeshProUGUI status;
-		readonly TargetString statusstr = new TargetString();
-		readonly StringBuffer statusbuf = new StringBuffer();
 
 		static Vector2 screenSize;
 		public static Rect hitRect;
@@ -63,6 +62,7 @@ namespace Cryville.Crtr {
 		static double renderStep = 0.05;
 		public static double actualRenderStep = 0;
 		static bool autoRenderStep = false;
+		public static float graphicalOffset = 0;
 		public static float soundOffset = 0;
 		static float startOffset = 0;
 		public static float sv = 16f;
@@ -70,15 +70,15 @@ namespace Cryville.Crtr {
 		public static Dictionary<Identifier, MotionRegistry> motionRegistry = new Dictionary<Identifier, MotionRegistry>();
 
 		public static PdtEvaluator etor;
-		
-		InputProxy inputProxy;
 		#endregion
 
 		#region MonoBehaviour
 		void Start() {
+			d_addLogEntry = new Action<int, string, string>(AddLogEntry);
+
 			var logobj = GameObject.Find("Logs");
 			if (logobj != null)
-				logs = logobj.GetComponent<Text>();
+				logs = logobj.GetComponent<TextMeshProUGUI>();
 			if (!initialized) {
 				Game.Init();
 				GenericResources.LoadDefault();
@@ -133,7 +133,7 @@ namespace Cryville.Crtr {
 				if (forceSyncFrames != 0) {
 					forceSyncFrames--;
 					double target = Game.AudioClient.Position - atime0;
-					dt = target - cbus.Time;
+					dt = target - cbus.Time - graphicalOffset;
 					step = autoRenderStep ? 1f / Application.targetFrameRate : renderStep;
 					inputProxy.SyncTime(target);
 				}
@@ -142,6 +142,7 @@ namespace Cryville.Crtr {
 					step = autoRenderStep ? Time.smoothDeltaTime : renderStep;
 				}
 				inputProxy.ForceTick();
+				if (paused) return;
 				cbus.ForwardByTime(dt);
 				bbus.ForwardByTime(dt);
 				UnityEngine.Profiling.Profiler.BeginSample("ChartPlayer.Forward");
@@ -160,6 +161,8 @@ namespace Cryville.Crtr {
 				tbus.ForwardStepByTime(renderDist, step);
 				tbus.EndGraphicalUpdate();
 				UnityEngine.Profiling.Profiler.EndSample();
+
+				effectManager.Tick(cbus.Time);
 			}
 			catch (Exception ex) {
 				Game.LogException("Game", "An error occured while playing", ex);
@@ -172,10 +175,21 @@ namespace Cryville.Crtr {
 				string url = texLoader.url;
 				string name = StringUtils.TrimExt(url.Substring(url.LastIndexOfAny(new char[] {'/', '\\'}) + 1));
 #if UNITY_5_4_OR_NEWER
-				if (texHandler.isDone) {
-					var tex = texHandler.texture;
-					tex.wrapMode = TextureWrapMode.Clamp;
-					texs.Add(name, tex);
+				if (texLoader.isDone) {
+					if (texHandler.isDone) {
+						var tex = texHandler.texture;
+						tex.wrapMode = TextureWrapMode.Clamp;
+						if (frames.ContainsKey(name)) {
+							Logger.Log("main", 3, "Load/Prehandle", "Duplicated texture name: {0}", name);
+						}
+						else {
+							frames.Add(name, new SpriteFrame(tex));
+						}
+						texs.Add(name, tex);
+					}
+					else {
+						Logger.Log("main", 4, "Load/Prehandle", "Unable to load texture: {0}", name);
+					}
 					texLoader.Dispose();
 					texHandler.Dispose();
 					texLoader = null;
@@ -190,14 +204,14 @@ namespace Cryville.Crtr {
 				}
 #endif
 			}
-			if (texLoader == null)
+			if (texLoader == null) {
 				if (texLoadQueue.Count > 0) {
 #if UNITY_5_4_OR_NEWER
 					texHandler = new DownloadHandlerTexture();
 					texLoader = new UnityWebRequest(Game.FileProtocolPrefix + texLoadQueue.Dequeue(), "GET", texHandler, null);
 					texLoader.SendWebRequest();
 #else
-						texLoader = new WWW(Game.FileProtocolPrefix + texLoadQueue.Dequeue());
+					texLoader = new WWW(Game.FileProtocolPrefix + texLoadQueue.Dequeue());
 #endif
 				}
 				else if (!texloaddone) {
@@ -205,6 +219,7 @@ namespace Cryville.Crtr {
 					texloadtimer.Stop();
 					Logger.Log("main", 1, "Load/MainThread", "Main thread done ({0}ms)", texloadtimer.Elapsed.TotalMilliseconds);
 				}
+			}
 			if (!loadThread.IsAlive) {
 				if (threadException != null) {
 					Logger.Log("main", 4, "Load/MainThread", "Load failed");
@@ -220,25 +235,46 @@ namespace Cryville.Crtr {
 				}
 			}
 		}
+		readonly TargetString statusstr = new TargetString();
+		readonly StringBuffer statusbuf = new StringBuffer();
+		readonly TargetString logsstr = new TargetString();
+		readonly StringBuffer logsbuf = new StringBuffer();
+		readonly List<string> logEntries = new List<string>();
+		int logsLength = 0;
+		Action<int, string, string> d_addLogEntry;
+		void AddLogEntry(int level, string module, string msg) {
+			string color;
+			switch (level) {
+				case 0: color = "#888888"; break;
+				case 1: color = "#bbbbbb"; break;
+				case 2: color = "#0088ff"; break;
+				case 3: color = "#ffff00"; break;
+				case 4: color = "#ff0000"; break;
+				case 5: color = "#bb0000"; break;
+				default: color = "#ff00ff"; break;
+			}
+			var l = string.Format(
+				"\n<color={1}bb><{2}> {3}</color>",
+				DateTime.UtcNow.ToString("s"), color, module, msg
+			);
+			logEntries.Add(l);
+			logsLength += l.Length;
+		}
 		void LogUpdate() {
-			string _logs = logs.text;
-			Game.MainLogger.Enumerate((level, module, msg) => {
-				string color;
-				switch (level) {
-					case 0: color = "#888888"; break;
-					case 1: color = "#bbbbbb"; break;
-					case 2: color = "#0088ff"; break;
-					case 3: color = "#ffff00"; break;
-					case 4: color = "#ff0000"; break;
-					case 5: color = "#bb0000"; break;
-					default: color = "#ff00ff"; break;
-				}
-				_logs += string.Format(
-					"\r\n<color={1}bb><{2}> {3}</color>",
-					DateTime.UtcNow.ToString("s"), color, module, msg
-				);
-			});
-			logs.text = _logs.Substring(Mathf.Max(0, _logs.IndexOf('\n', Mathf.Max(0, _logs.Length - 4096))));
+			logsbuf.Clear();
+			Game.MainLogger.Enumerate(d_addLogEntry);
+			while (logsLength >= 4096) {
+				logsLength -= logEntries[0].Length;
+				logEntries.RemoveAt(0);
+			}
+			foreach (var l in logEntries) {
+				logsbuf.Append(l);
+			}
+			logsstr.Length = logsbuf.Count;
+			var larr = logsstr.TrustedAsArray();
+			logsbuf.CopyTo(0, larr, 0, logsbuf.Count);
+			logs.SetText(larr, 0, logsbuf.Count);
+
 			statusbuf.Clear();
 			statusbuf.AppendFormat(
 				"FPS: i{0:0} / s{1:0}\nSMem: {2:N0} / {3:N0}\nIMem: {4:N0} / {5:N0}",
@@ -258,15 +294,19 @@ namespace Cryville.Crtr {
 			);
 			if (started) {
 				statusbuf.AppendFormat(
-					"\nStates: c{0} / b{1}",
-					cbus.ActiveStateCount, bbus.ActiveStateCount
+					"\nStates: c{0} / b{1}\nPools: RMV {2}, MC {3}",
+					cbus.ActiveStateCount, bbus.ActiveStateCount,
+					ContainerState.RMVPool.RentedCount,
+					ContainerState.MCPool.RentedCount
 				);
 				statusbuf.AppendFormat(
-					"\nSTime: {0:G17}s {3}\ndATime: {1:+0.0ms;-0.0ms;0} {3}\ndITime: {2:+0.0ms;-0.0ms;0} {3}",
+					"\nSTime: {0:G17}s {3} {4}\ndATime: {1:+0.0ms;-0.0ms;0} {3} {4}\ndITime: {2:+0.0ms;-0.0ms;0} {3} {5}",
 					cbus.Time,
 					(Game.AudioClient.Position - atime0 - cbus.Time) * 1e3,
 					(inputProxy.GetTimestampAverage() - cbus.Time) * 1e3,
-					forceSyncFrames != 0 ? "(force sync)" : ""
+					forceSyncFrames != 0 ? "(force sync)" : "",
+					paused ? "(paused)" : "",
+					paused ? "(semi-locked)" : ""
 				);
 				if (judge != null) {
 					statusbuf.Append("\n== Scores ==\n");
@@ -275,9 +315,9 @@ namespace Cryville.Crtr {
 				}
 			}
 			statusstr.Length = statusbuf.Count;
-			var arr = statusstr.TrustedAsArray();
-			statusbuf.CopyTo(0, arr, 0, statusbuf.Count);
-			status.SetText(arr, 0, statusbuf.Count);
+			var sarr = statusstr.TrustedAsArray();
+			statusbuf.CopyTo(0, sarr, 0, statusbuf.Count);
+			status.SetText(sarr, 0, statusbuf.Count);
 		}
 		#endregion
 
@@ -307,6 +347,8 @@ namespace Cryville.Crtr {
 
 		bool logEnabled = true;
 		public void ToggleLogs() {
+			logEntries.Clear();
+			logsLength = 0;
 			logs.text = "";
 			status.SetText("");
 			logEnabled = !logEnabled;
@@ -319,6 +361,20 @@ namespace Cryville.Crtr {
 				else Logger.Log("main", 2, "Load/MainThread", "The chart is currently loading");
 			}
 		}
+
+		bool paused = false;
+		public void TogglePause() {
+			paused = !paused;
+			if (!paused) {
+				forceSyncFrames = Settings.Default.ForceSyncFrames;
+				Game.AudioClient.Start();
+				inputProxy.UnlockTime();
+			}
+			else {
+				Game.AudioClient.Pause();
+				inputProxy.LockTime();
+			}
+		}
 		#endregion
 
 		#region Load
@@ -329,9 +385,10 @@ namespace Cryville.Crtr {
 			renderStep = Settings.Default.RenderStep;
 			actualRenderStep = renderStep;
 			autoRenderStep = renderStep == 0;
+			graphicalOffset = Settings.Default.GraphicalOffset;
 			soundOffset = Settings.Default.SoundOffset;
 			startOffset = Settings.Default.StartOffset;
-			forceSyncFrames= Settings.Default.ForceSyncFrames;
+			forceSyncFrames = Settings.Default.ForceSyncFrames;
 			texloaddone = false;
 			Game.NetworkTaskWorker.SuspendBackgroundTasks();
 			Game.AudioSession = Game.AudioSequencer.NewSession();
@@ -368,6 +425,7 @@ namespace Cryville.Crtr {
 				});
 			}
 			sv = _rscfg.generic.ScrollVelocity;
+			soundOffset += _rscfg.generic.SoundOffset;
 
 			FileInfo skinFile = new FileInfo(
 				string.Format("{0}/skins/{1}/{2}/.umgs", Game.GameDataPath, rulesetFile.Directory.Name, _rscfg.generic.Skin)
@@ -402,16 +460,6 @@ namespace Cryville.Crtr {
 			try {
 				diag::Stopwatch timer = new diag::Stopwatch();
 				timer.Reset(); timer.Start();
-				Logger.Log("main", 0, "Load/Prehandle", "Initializing textures");
-				foreach (var t in texs) {
-					if (frames.ContainsKey(t.Key)) {
-						Logger.Log("main", 3, "Load/Prehandle", "Duplicated texture name: {0}", t.Key);
-						continue;
-					}
-					var f = new SpriteFrame(t.Value);
-					f.Init();
-					frames.Add(t.Key, f);
-				}
 				Logger.Log("main", 0, "Load/Prehandle", "Prehandling (iteration 2)");
 				cbus.BroadcastPreInit();
 				Logger.Log("main", 0, "Load/Prehandle", "Prehandling (iteration 3)");
@@ -425,11 +473,15 @@ namespace Cryville.Crtr {
 				Logger.Log("main", 0, "Load/Prehandle", "Cleaning up");
 				GC.Collect();
 				if (disableGC) GarbageCollector.GCMode = GarbageCollector.Mode.Disabled;
+				cbus.ForwardByTime(startOffset);
+				bbus.ForwardByTime(startOffset);
 				timer.Stop();
 				Logger.Log("main", 1, "Load/Prehandle", "Prehandling done ({0}ms)", timer.Elapsed.TotalMilliseconds);
 				if (Settings.Default.ClearLogOnPlay) {
-					logs.text = "";
+					logEntries.Clear();
+					logsLength = 0;
 					Game.MainLogger.Enumerate((level, module, msg) => { });
+					logs.text = "";
 				}
 				Game.AudioSequencer.Playing = true;
 				atime0 = Game.AudioClient.BufferPosition;
@@ -447,12 +499,16 @@ namespace Cryville.Crtr {
 		public void Stop() {
 			try {
 				Logger.Log("main", 1, "Game", "Stopping");
+				Game.AudioClient.Start();
 				Game.AudioSession = Game.AudioSequencer.NewSession();
 				inputProxy.Deactivate();
 				if (nbus != null) { nbus.Dispose(); nbus = null; }
 				if (tbus != null) { tbus.Dispose(); tbus = null; }
 				if (bbus != null) { bbus.Dispose(); bbus = null; }
 				if (cbus != null) { cbus.Dispose(); cbus.DisposeAll(); cbus = null; }
+				effectManager.Dispose();
+				effectManager = null;
+				etor = null;
 				Logger.Log("main", 1, "Game", "Stopped");
 			}
 			catch (Exception ex) {
@@ -496,8 +552,6 @@ namespace Cryville.Crtr {
 			try {
 				workerTimer = new diag::Stopwatch();
 				workerTimer.Start();
-				RMVPool.Prepare();
-				MotionCachePool.Prepare();
 				LoadChart(info);
 				workerTimer.Stop();
 				Logger.Log("main", 1, "Load/WorkerThread", "Worker thread done ({0}ms)", workerTimer.Elapsed.TotalMilliseconds);
@@ -533,12 +587,12 @@ namespace Cryville.Crtr {
 				LoadSkin(info.skinFile);
 
 				Logger.Log("main", 0, "Load/WorkerThread", "Initializing judge and input");
-				judge = new Judge(pruleset);
+				judge = new Judge(this, pruleset);
 				etor.ContextJudge = judge;
 
 				inputProxy = new InputProxy(pruleset, judge);
 				inputProxy.LoadFrom(_rscfg.inputs);
-				if (!inputProxy.IsCompleted) {
+				if (!inputProxy.IsCompleted()) {
 					throw new ArgumentException("Input config not completed\nPlease complete the input settings");
 				}
 
@@ -586,6 +640,8 @@ namespace Cryville.Crtr {
 				pruleset = ruleset.Root;
 				pruleset.Optimize(etor);
 			}
+			ContainerState.RMVPool = new RMVPool();
+			ContainerState.MCPool = new MotionCachePool();
 		}
 
 		void LoadSkin(FileInfo file) {
@@ -594,6 +650,7 @@ namespace Cryville.Crtr {
 			skin.LoadPdt(dir);
 			pskin = skin.Root;
 			pskin.Optimize(etor);
+			effectManager = new EffectManager(pskin);
 		}
 		#endregion
 	}

Assets/Cryville/Crtr/Components/MeshBase.cs

@@ -1,12 +1,20 @@
 using System;
+using UnityEngine;
 
 namespace Cryville.Crtr.Components {
 	public abstract class MeshBase : SkinComponent {
 		public MeshBase() {
+			SubmitProperty("color", new PropOp.Color(v => Color = v));
+			SubmitProperty("opacity", new PropOp.Float(v => {
+				var c = Color;
+				c.a *= v;
+				Color = c;
+			}));
 			SubmitProperty("zindex", new PropOp.Integer(v => ZIndex = (short)v));
 		}
 
 		protected MeshWrapper mesh = new MeshWrapper();
+		protected Material[] materials;
 
 		short _zindex;
 		public short ZIndex {
@@ -22,9 +30,36 @@ namespace Cryville.Crtr.Components {
 		}
 		protected void UpdateZIndex() {
 			if (!mesh.Initialized) return;
-			foreach (var mat in mesh.Renderer.materials) {
+			foreach (var mat in materials) {
 				mat.renderQueue = _zindex;
 			}
 		}
+
+		Color _color = Color.white;
+		public Color Color {
+			get { return _color; }
+			set {
+				_color = value;
+				UpdateColor();
+			}
+		}
+		protected void UpdateColor() {
+			if (!mesh.Initialized) return;
+			foreach (var mat in materials) {
+				mat.color = _color;
+			}
+		}
+
+		protected override void OnDestroy() {
+			DestroyMaterials();
+			mesh.Destroy();
+		}
+
+		protected void DestroyMaterials() {
+			if (materials == null) return;
+			foreach (var mat in materials) {
+				Material.Destroy(mat);
+			}
+		}
 	}
 }

Assets/Cryville/Crtr/Components/SectionalGameObject.cs

@@ -19,11 +19,7 @@ namespace Cryville.Crtr.Components {
 
 		public SectionalGameObject() {
 			SubmitProperty("partial", new PropOp.Boolean(v => part = Part.idle));
-			SubmitProperty("part", new PropOp.Enum<Part>(v => part = v, v => (Part)v), 2);
-		}
-
-		protected override void OnDestroy() {
-			mesh.Destroy();
+			SubmitProperty("part", new PropOp.Enum<Part>(v => part = v, v => (Part)v), 1);
 		}
 
 		public override void Init() {
@@ -67,7 +63,7 @@ namespace Cryville.Crtr.Components {
 			SubmitProperty("head", new PropOp.String(v => head.FrameName = v));
 			SubmitProperty("body", new PropOp.String(v => body.FrameName = v));
 			SubmitProperty("tail", new PropOp.String(v => tail.FrameName = v));
-			SubmitProperty("shape", new op_set_shape(this), 2);
+			SubmitProperty("shape", new op_set_shape(this), 1);
 		}
 
 #pragma warning disable IDE1006
@@ -80,11 +76,10 @@ namespace Cryville.Crtr.Components {
 				var o = GetOperand(0);
 				if (o.Type != PdtInternalType.Vector) throw new ArgumentException("Not a vector");
 				_self._shapeLength = (o.Length - sizeof(int)) / sizeof(Vector2);
-				var ptr = (Vector2*)o.TrustedAsOfLength(sizeof(Vector2));
 				if (_self._shape != null) _shapePool.Return(_self._shape);
 				_self._shape = _shapePool.Rent(_self._shapeLength);
 				for (int i = 0; i < _self._shapeLength; i++) {
-					_self._shape[i] = ptr[i];
+					_self._shape[i] = o.As<Vector2>(i * sizeof(Vector2));
 				}
 			}
 		}
@@ -112,23 +107,25 @@ namespace Cryville.Crtr.Components {
 			base.Init();
 			mesh.Init(transform);
 
-			var mats = mesh.Renderer.materials = new Material[] { mesh.NewMaterial, mesh.NewMaterial, mesh.NewMaterial };
-			head.Bind(mats[0]);
-			body.Bind(mats[1]);
-			tail.Bind(mats[2]);
+			mesh.Renderer.sharedMaterials = materials = new Material[] {
+				MeshWrapper.NewMaterial(),
+				MeshWrapper.NewMaterial(),
+				MeshWrapper.NewMaterial(),
+			};
+			head.Bind(materials[0]);
+			body.Bind(materials[1]);
+			tail.Bind(materials[2]);
 
 			UpdateZIndex();
 		}
 
 		protected override void OnDestroy() {
-			base.OnDestroy();
-			Reset();
-			foreach (var m in mesh.Renderer.materials) Material.Destroy(m);
 			if (_shape != null) _shapePool.Return(_shape);
 			if (vertices != null) {
 				_ptPool.Return(vertices);
 				_lPool.Return(lengths);
 			}
+			base.OnDestroy();
 		}
 
 		protected override void AppendPointInternal(Vector3 p, Quaternion r) {
@@ -152,7 +149,7 @@ namespace Cryville.Crtr.Components {
 		List<Vector3> verts;
 		List<Vector2> uvs;
 		List<int> trih = null, trib = null, trit = null;
-		static List<int> _emptyTris = new List<int>();
+		static readonly List<int> _emptyTris = new List<int>();
 
 		public override void Seal() {
 			if (vertCount <= 1 || sumLength == 0) return;

Assets/Cryville/Crtr/Components/SkinAnimation.cs

@@ -0,0 +1,5 @@
+namespace Cryville.Crtr.Components {
+	public class SkinAnimation : SkinComponent {
+		protected override void OnDestroy() { }
+	}
+}

Assets/Cryville/Crtr/Components/SkinAnimation.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 80318e36af5412345871bdbf80d49ef2
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Cryville/Crtr/Components/SkinComponent.cs

@@ -14,8 +14,8 @@ namespace Cryville.Crtr.Components {
 		/// </summary>
 		/// <param name="name">The name of the property.</param>
 		/// <param name="property">The property.</param>
-		protected void SubmitProperty(string name, PdtOperator property, int uct = 1) {
-			Properties.Add(IdentifierManager.SharedInstance.Request(name), new SkinProperty(property, uct));
+		protected void SubmitProperty(string name, PdtOperator property, int udl = 0) {
+			Properties.Add(IdentifierManager.SharedInstance.Request(name), new SkinProperty(property, udl));
 		}
 
 		/// <summary>
@@ -30,10 +30,10 @@ namespace Cryville.Crtr.Components {
 	}
 	public struct SkinProperty {
 		public PdtOperator Operator { get; set; }
-		public int UpdateCloneType { get; set; }
-		public SkinProperty(PdtOperator op, int uct = 1) {
+		public int UpdateDynamicLevel { get; set; }
+		public SkinProperty(PdtOperator op, int udl = 0) {
 			Operator = op;
-			UpdateCloneType = uct;
+			UpdateDynamicLevel = udl;
 		}
 	}
 }

Assets/Cryville/Crtr/Components/SpriteBase.cs

@@ -16,19 +16,15 @@ namespace Cryville.Crtr.Components {
 			public op_set_bound(SpriteBase self) : base(2) {
 				_self = self;
 			}
-			protected unsafe override void Execute() {
+			protected override void Execute() {
 				_self.SetBound(
-					*(Vector2*)GetOperand(0).TrustedAsOfLength(sizeof(Vector2)),
-					*(Vector3*)GetOperand(1).TrustedAsOfLength(sizeof(Vector3))
+					GetOperand(0).As<Vector2>(),
+					GetOperand(1).As<Vector3>()
 				);
 			}
 		}
 #pragma warning restore IDE1006
 
-		protected override void OnDestroy() {
-			mesh.Destroy();
-		}
-
 		Vector2 _scale = Vector2.one;
 		public Vector2 Scale {
 			get { return _scale; }
@@ -92,7 +88,9 @@ namespace Cryville.Crtr.Components {
 
 		protected void InternalInit(string meshName = "quad") {
 			mesh.Init(transform);
+			mesh.Renderer.sharedMaterials = materials = new Material[] { MeshWrapper.NewMaterial() };
 			mesh.Mesh = GenericResources.Meshes[meshName];
+			UpdateColor();
 			UpdateScale();
 			UpdateZIndex();
 		}

Assets/Cryville/Crtr/Components/SpritePlane.cs

@@ -29,19 +29,12 @@ namespace Cryville.Crtr.Components {
 				return Rect.width / Rect.height;
 			}
 		}
-		bool _loaded;
 		Material _mat;
 		public void Bind(Material mat) {
-			_loaded = true;
 			_mat = mat;
 			Reload();
 		}
-		public void Load() {
-			_loaded = true;
-			Reload();
-		}
 		public void Reload() {
-			if (!_loaded) return;
 			if (!string.IsNullOrEmpty(FrameName)) {
 				if (ChartPlayer.frames.ContainsKey(FrameName)) {
 					Frame = ChartPlayer.frames[FrameName];
@@ -56,13 +49,18 @@ namespace Cryville.Crtr.Components {
 				_mat.mainTexture = Frame == null ? null : Frame.Texture;
 			}
 		}
+		public static bool IsNullOrEmpty(SpriteInfo sprite) {
+			return sprite == null || sprite.Frame == null;
+		}
 	}
 
 	public class SpritePlane : SpriteBase {
 		public SpritePlane() {
 			SubmitProperty("frame", new PropOp.String(v => Frame = v));
+			SubmitProperty("frames", new PropOp.StringArray(v => Frames = v));
+			SubmitProperty("index", new PropOp.Integer(v => Index = v));
 			SubmitProperty("fit", new PropOp.Enum<FitMode>(v => Fit = v, v => (FitMode)v));
-			SubmitProperty("opacity", new PropOp.Float(v => Opacity = v));
+			SubmitProperty("shader", new PropOp.String(v => Shader = v));
 		}
 
 		static Vector2[] _origuv;
@@ -83,52 +81,73 @@ namespace Cryville.Crtr.Components {
 			}
 		}
 
-		protected SpriteInfo frameInfo = new SpriteInfo();
-
-		public string Frame {
-			get { return frameInfo.FrameName; }
+		int m_index;
+		public int Index {
+			get { return m_index; }
 			set {
-				frameInfo.FrameName = value;
+				m_index = value;
 				OnFrameUpdate();
 			}
 		}
+		SpriteInfo[] m_frames = new SpriteInfo[] { new SpriteInfo() };
+		public string[] Frames {
+			set {
+				m_frames = new SpriteInfo[value.Length];
+				for (int i = 0; i < value.Length; i++) {
+					m_frames[i] = new SpriteInfo() { FrameName = value[i] };
+				}
+				OnFrameUpdate();
+			}
+		}
+		public string Frame {
+			set {
+				if (value == CurrentFrame.FrameName) return;
+				CurrentFrame.FrameName = value;
+				OnFrameUpdate();
+			}
+		}
+		protected SpriteInfo CurrentFrame {
+			get {
+				if (m_frames.Length == 0) return null;
+				if (m_index < 0) m_index = 0;
+				else if (m_index >= m_frames.Length) m_index = m_frames.Length - 1;
+				return m_frames[m_index];
+			}
+		}
 		protected void OnFrameUpdate() {
 			if (!mesh.Initialized) return;
-			if (frameInfo.Frame == null) {
+			var frame = CurrentFrame;
+			if (SpriteInfo.IsNullOrEmpty(frame)) {
 				mesh.Renderer.enabled = false;
 				return;
 			}
 			mesh.Renderer.enabled = true;
+			mesh.Renderer.sharedMaterial.mainTexture = frame.Frame.Texture;
 			UpdateUV();
 			UpdateScale();
+		}
+		Shader m_shader;
+		public string Shader {
+			set {
+				m_shader = GenericResources.Shaders[value];
+				UpdateShader();
+			}
+		}
+		void UpdateShader() {
+			if (!mesh.Initialized) return;
+			if (m_shader == null) m_shader = GenericResources.Shaders["default"];
+			mesh.Renderer.sharedMaterial.shader = m_shader;
 			UpdateZIndex();
 		}
+		readonly Vector2[] _uvs = new Vector2[4];
 		protected virtual void UpdateUV() {
-			if (frameInfo.Frame == null) {
-				Logger.Log("main", 4, "Skin", "Unable to load texture {0}", frameInfo.FrameName);
-				return;
-			}
+			var frame = CurrentFrame;
+			if (SpriteInfo.IsNullOrEmpty(frame)) return;
 			Vector2[] muv = OriginalUV;
-			Vector2[] uv = new Vector2[muv.Length];
-			for (int i = 0; i < uv.Length; i++) {
-				uv[i] = frameInfo.Frame.GetUV(muv[i]);
+			for (int i = 0; i < _uvs.Length; i++) {
+				_uvs[i] = frame.Frame.GetUV(muv[i]);
 			}
-			mesh.Mesh.uv = uv;
-		}
-
-		float _opacity = 1;
-		public float Opacity {
-			get { return _opacity; }
-			set {
-				_opacity = value;
-				UpdateOpacity();
-			}
-		}
-		void UpdateOpacity() {
-			if (!mesh.Initialized) return;
-			var c = mesh.Renderer.material.color;
-			c.a = _opacity;
-			mesh.Renderer.material.color = c;
+			mesh.Mesh.uv = _uvs;
 		}
 
 		private FitMode m_fit = FitMode.height;
@@ -144,7 +163,7 @@ namespace Cryville.Crtr.Components {
 		}
 
 		protected override void UpdateScale() {
-			if (frameInfo.Frame == null) return;
+			if (SpriteInfo.IsNullOrEmpty(CurrentFrame)) return;
 			base.UpdateScale();
 			if (m_fit != FitMode.none && Scale.x != Scale.y) m_fit = FitMode.none;
 		}
@@ -153,8 +172,8 @@ namespace Cryville.Crtr.Components {
 			get {
 				switch (m_fit) {
 					case FitMode.none: return Vector3.one;
-					case FitMode.width: return new Vector3(1, 1, 1 / frameInfo.Ratio);
-					case FitMode.height: return new Vector3(frameInfo.Ratio, 1, 1);
+					case FitMode.width: return new Vector3(1, 1, 1 / CurrentFrame.Ratio);
+					case FitMode.height: return new Vector3(CurrentFrame.Ratio, 1, 1);
 					default: throw new NotSupportedException("Unsupported fit mode");
 				}
 			}
@@ -162,9 +181,8 @@ namespace Cryville.Crtr.Components {
 
 		public override void Init() {
 			InternalInit();
-			frameInfo.Bind(mesh.Renderer.material);
 			OnFrameUpdate();
-			UpdateOpacity();
+			UpdateShader();
 		}
 	}
 }

Assets/Cryville/Crtr/Components/SpriteRect.cs

@@ -2,22 +2,7 @@
 
 namespace Cryville.Crtr.Components {
 	public class SpriteRect : SpriteBase {
-		public SpriteRect() {
-			SubmitProperty("color", new PropOp.Color(v => Color = v));
-		}
-
-		Color _color;
-		public Color Color {
-			get { return _color; }
-			set {
-				_color = value;
-				OnColorUpdate();
-			}
-		}
-		void OnColorUpdate() {
-			if (!mesh.Initialized) return;
-			mesh.Renderer.material.SetColor("_Color", _color);
-		}
+		public SpriteRect() { }
 		
 		protected override Vector3 BaseScale {
 			get { return Vector3.one; }
@@ -25,7 +10,6 @@ namespace Cryville.Crtr.Components {
 		
 		public override void Init() {
 			InternalInit();
-			OnColorUpdate();
 		}
 	}
 }

Assets/Cryville/Crtr/Components/SpriteScale3.cs

@@ -44,24 +44,26 @@ namespace Cryville.Crtr.Components {
 			UpdateUV();
 		}
 
+		readonly Vector2[] _uvs = new Vector2[8];
+		readonly Vector3[] _verts = new Vector3[8];
 		protected override void UpdateUV() {
-			Vector2[] muv = OriginalUV;
-			Vector2[] uv = new Vector2[muv.Length];
+			var frame = CurrentFrame;
+			if (SpriteInfo.IsNullOrEmpty(frame)) return;
 
-			var or = frameInfo.Ratio;
+			Vector2[] muv = OriginalUV;
+
+			var or = frame.Ratio;
 			var sr = Scale.x / Scale.y;
-			var b = new Vector2(
-				(or / sr) * _border.x,
-				1 - (or / sr) * (1 - _border.y)
-			);
-			Vector3[] vert = mesh.Mesh.vertices;
+			var rr = or / sr;
+			var b1 = rr * _border.x;
+			var b2 = 1 - rr * (1 - _border.y);
 
 			for (int i = 0; i < muv.Length; i++) {
 				float x; float bx;
 				switch ((int)muv[i].x) {
 					case 0: x = 0; bx = 0; break;
-					case 1: x = _border.x; bx = b.x; break;
-					case 2: x = _border.y; bx = b.y; break;
+					case 1: x = _border.x; bx = b1; break;
+					case 2: x = _border.y; bx = b2; break;
 					case 3: x = 1; bx = 1; break;
 					default: throw new NotSupportedException("Built-in resource corrupted");
 				}
@@ -71,16 +73,15 @@ namespace Cryville.Crtr.Components {
 					case 3: y = 1; break;
 					default: throw new NotSupportedException("Built-in resource corrupted");
 				}
-				uv[i] = frameInfo.Frame.GetUV(x, y);
+				_uvs[i] = frame.Frame.GetUV(x, y);
 				bx -= 0.5f; y -= 0.5f;
-				vert[i] = new Vector3(bx, 0, y);
+				_verts[i] = new Vector3(bx, 0, y);
 			}
-			mesh.Mesh.uv = uv;
-			mesh.Mesh.vertices = vert;
+			mesh.Mesh.uv = _uvs;
+			mesh.Mesh.vertices = _verts;
 		}
 		
 		public override void Init() {
-			frameInfo.Load();
 			InternalInit("quad_scale3h");
 			OnFrameUpdate();
 		}

Assets/Cryville/Crtr/Components/SpriteText.cs

@@ -11,7 +11,6 @@ namespace Cryville.Crtr.Components {
 			SubmitProperty("value", new PropOp.TargetString(() => Value));
 			SubmitProperty("size", new PropOp.Float(v => Size = v));
 			SubmitProperty("spacing", new PropOp.Float(v => Spacing = v));
-			SubmitProperty("opacity", new PropOp.Float(v => Opacity = v));
 		}
 
 #pragma warning disable IDE1006
@@ -25,6 +24,8 @@ namespace Cryville.Crtr.Components {
 				var values = GetOperand(1);
 				int arrtype; int len;
 				values.GetArraySuffix(out arrtype, out len);
+				if (arrtype != PdtInternalType.String) throw new InvalidCastException("Not an array of strings");
+				if (len != keys.Length) throw new ArgumentException("Length of key not equal to frame count");
 				var result = new Dictionary<char, SpriteInfo>(len);
 				int o = 0;
 				for (int i = 0; i < len; i++) {
@@ -45,7 +46,7 @@ namespace Cryville.Crtr.Components {
 		Dictionary<char, SpriteInfo> m_frames;
 		public Dictionary<char, SpriteInfo> Frames {
 			get { return m_frames; }
-			set { m_frames = value; UpdateFrames(); UpdateScale(); }
+			set { m_frames = value; UpdateFrames(); }
 		}
 
 		readonly TargetString m_value = new TargetString();
@@ -76,8 +77,11 @@ namespace Cryville.Crtr.Components {
 			meshes.Clear();
 			verts.Clear();
 			uvs.Clear();
+			DestroyMaterials();
+			materials = new Material[m_frames.Count];
+			int i = 0;
 			foreach (var f in m_frames) {
-				f.Value.Load();
+				if (SpriteInfo.IsNullOrEmpty(f.Value)) continue;
 				if (frameHeight == 0) frameHeight = f.Value.Rect.height;
 				else if (frameHeight != f.Value.Rect.height) throw new Exception("Inconsistent frame height for text component");
 				var tex = f.Value.Frame.Texture;
@@ -85,13 +89,17 @@ namespace Cryville.Crtr.Components {
 					var m = new MeshWrapper();
 					m.Init(mesh.MeshTransform);
 					m.Mesh = new Mesh();
-					m.Renderer.material.mainTexture = tex;
+					var mat = MeshWrapper.NewMaterial();
+					mat.mainTexture = tex;
+					m.Renderer.sharedMaterial = materials[i++] = mat;
 					meshes.Add(tex, m);
 					verts.Add(tex, new List<Vector3>());
 					uvs.Add(tex, new List<Vector2>());
 					tris.Add(tex, new List<int>());
 				}
 			}
+			UpdateColor();
+			UpdateScale();
 		}
 
 		float sum_x;
@@ -102,10 +110,11 @@ namespace Cryville.Crtr.Components {
 		void UpdateMeshes() {
 			if (meshes.Count == 0) return;
 			sum_x = 0;
-			foreach (var t in meshes.Keys) {
-				verts[t].Clear();
-				uvs[t].Clear();
-				tris[t].Clear();
+			foreach (var t in meshes) {
+				var key = t.Key;
+				verts[key].Clear();
+				uvs[key].Clear();
+				tris[key].Clear();
 			}
 			foreach (var c in m_value) {
 				var f = m_frames[c];
@@ -121,11 +130,12 @@ namespace Cryville.Crtr.Components {
 				uvs[t].Add(f.Frame.GetUV(new Vector2(0, 1)));
 				sum_x += w + m_spacing;
 			}
-			foreach (var t in meshes.Keys) {
-				var m = meshes[t].Mesh;
+			foreach (var t in meshes) {
+				var key = t.Key;
+				var m = meshes[key].Mesh;
 				m.Clear();
-				int cc = verts[t].Count / 4;
-				var _tris = tris[t];
+				int cc = verts[key].Count / 4;
+				var _tris = tris[key];
 				for (int i = 0; i < cc; i++) {
 					_tris.Add(i * 4);
 					_tris.Add(i * 4 + 3);
@@ -134,9 +144,9 @@ namespace Cryville.Crtr.Components {
 					_tris.Add(i * 4 + 3);
 					_tris.Add(i * 4 + 2);
 				}
-				m.SetVertices(verts[t]);
-				m.SetUVs(0, uvs[t]);
-				m.SetTriangles(tris[t], 0);
+				m.SetVertices(verts[key]);
+				m.SetUVs(0, uvs[key]);
+				m.SetTriangles(tris[key], 0);
 				m.RecalculateNormals();
 			}
 			sum_x -= m_spacing;
@@ -154,23 +164,6 @@ namespace Cryville.Crtr.Components {
 			get { return new Vector2(-0.5f, -0.5f); }
 		}
 
-		float _opacity = 1;
-		public float Opacity {
-			get { return _opacity; }
-			set {
-				_opacity = value;
-				UpdateOpacity();
-			}
-		}
-		void UpdateOpacity() {
-			if (!mesh.Initialized) return;
-			foreach (var m in meshes.Values) {
-				var c = m.Renderer.material.color;
-				c.a = _opacity;
-				m.Renderer.material.color = c;
-			}
-		}
-
 		public override void Init() {
 			InternalInit();
 			UpdateFrames();

Assets/Cryville/Crtr/Config/ConfigPanelMaster.cs

@@ -3,11 +3,13 @@ using System;
 using System.IO;
 using System.Text;
 using UnityEngine;
-using UnityEngine.SceneManagement;
 using Logger = Cryville.Common.Logger;
 
 namespace Cryville.Crtr.Config {
-	public class ConfigScene : MonoBehaviour {
+	public class ConfigPanelMaster : MonoBehaviour {
+		[SerializeField]
+		Menu m_menu;
+
 		[SerializeField]
 		Transform m_content;
 
@@ -20,7 +22,7 @@ namespace Cryville.Crtr.Config {
 		public Ruleset ruleset;
 		RulesetConfig _rscfg;
 
-		void Start() {
+		void OnEnable() {
 			try {
 				ChartPlayer.etor = new PdtEvaluator();
 				FileInfo file = new FileInfo(
@@ -57,11 +59,13 @@ namespace Cryville.Crtr.Config {
 				var proxy = new InputProxy(ruleset.Root, null);
 				proxy.LoadFrom(_rscfg.inputs);
 				m_inputConfigPanel.proxy = proxy;
+
+				m_inputConfigPanel.OnConfigEnable();
 			}
 			catch (Exception ex) {
 				Popup.CreateException(ex);
 				Logger.Log("main", 4, "Config", "An error occured while loading the config: {0}", ex);
-				ReturnToMenu();
+				m_menu.Back();
 			}
 		}
 
@@ -72,7 +76,7 @@ namespace Cryville.Crtr.Config {
 			cat.SetActive(true);
 		}
 
-		public void SaveAndReturnToMenu() {
+		void OnDisable() {
 			m_inputConfigPanel.proxy.SaveTo(_rscfg.inputs);
 			m_inputConfigPanel.proxy.Dispose();
 			FileInfo cfgfile = new FileInfo(
@@ -81,15 +85,7 @@ namespace Cryville.Crtr.Config {
 			using (StreamWriter cfgwriter = new StreamWriter(cfgfile.FullName, false, Encoding.UTF8)) {
 				cfgwriter.Write(JsonConvert.SerializeObject(_rscfg, Game.GlobalJsonSerializerSettings));
 			}
-			ReturnToMenu();
-		}
-		public void ReturnToMenu() {
-			GameObject.Find("Master").GetComponent<Master>().ShowMenu();
-#if UNITY_5_5_OR_NEWER
-			SceneManager.UnloadSceneAsync("Config");
-#elif UNITY_5_3_OR_NEWER
-			SceneManager.UnloadScene("Config");
-#endif
+			m_inputConfigPanel.OnConfigDisable();
 		}
 	}
 }

Assets/Cryville/Crtr/Config/InputConfigPanel.cs

@@ -1,4 +1,5 @@
-using Cryville.Common.Unity;
+using Cryville.Common;
+using Cryville.Common.Unity;
 using Cryville.Common.Unity.Input;
 using System.Collections.Generic;
 using UnityEngine;
@@ -7,7 +8,7 @@ using UnityEngine.UI;
 namespace Cryville.Crtr.Config {
 	public class InputConfigPanel : MonoBehaviour {
 		[SerializeField]
-		ConfigScene m_configScene;
+		ConfigPanelMaster m_configScene;
 
 		[SerializeField]
 		GameObject m_inputDialog;
@@ -24,12 +25,12 @@ namespace Cryville.Crtr.Config {
 		[SerializeField]
 		GameObject m_prefabInputConfigEntry;
 
-		readonly SimpleInputConsumer _consumer = new SimpleInputConsumer(Game.InputManager);
+		SimpleInputConsumer _consumer;
 		public InputProxy proxy;
-		readonly Dictionary<string, InputConfigPanelEntry> _entries = new Dictionary<string, InputConfigPanelEntry>();
+		readonly Dictionary<Identifier, InputConfigPanelEntry> _entries = new Dictionary<Identifier, InputConfigPanelEntry>();
 
-		string _sel;
-		public void OpenDialog(string entry) {
+		Identifier _sel;
+		public void OpenDialog(Identifier entry) {
 			_sel = entry;
 			m_inputDialog.SetActive(true);
 			CallHelper.Purge(m_deviceList);
@@ -50,7 +51,10 @@ namespace Cryville.Crtr.Config {
 			CloseDialog();
 		}
 
-		void Start() {
+		public void OnConfigEnable() {
+			CallHelper.Purge(m_entryList);
+			_entries.Clear();
+			_consumer = new SimpleInputConsumer(Game.InputManager);
 			_consumer.Activate();
 			foreach (var i in m_configScene.ruleset.Root.inputs) {
 				var e = GameObject.Instantiate(m_prefabInputConfigEntry, m_entryList.transform).GetComponent<InputConfigPanelEntry>();
@@ -61,13 +65,12 @@ namespace Cryville.Crtr.Config {
 			proxy.ProxyChanged += OnProxyChanged;
 		}
 
-		void OnDestroy() {
+		public void OnConfigDisable() {
 			_consumer.Deactivate();
 		}
 
 		void OnProxyChanged(object sender, ProxyChangedEventArgs e) {
-			_entries[e.Name].SetEnabled(!e.Used);
-			_entries[e.Name].SetValue(e.Proxy == null ? "None" : e.Proxy.Value.Handler.GetTypeName(e.Proxy.Value.Type));
+			_entries[e.Name].OnProxyChanged(e);
 		}
 
 		readonly List<InputSource?> _recvsrcs = new List<InputSource?>();
@@ -83,9 +86,21 @@ namespace Cryville.Crtr.Config {
 			if (_recvsrcs.Contains(src)) return;
 			_recvsrcs.Add(src);
 			var obj = Instantiate(m_prefabListItem, m_deviceList);
-			obj.transform.Find("Text").GetComponent<Text>().text = src == null ? "None" : src.Value.Handler.GetTypeName(src.Value.Type);
+			var text = obj.transform.Find("Text").GetComponent<Text>();
+			text.text = src == null ? "(None)" : src.Value.Handler.GetTypeName(src.Value.Type);
 			var btn = obj.GetComponent<Button>();
-			if (src != null) btn.interactable = !proxy.IsUsed(src.Value);
+			if (src != null) {
+				var tsrc = src.Value;
+				bool flag = false;
+				if (proxy.IsUsed(tsrc)) {
+					text.text += " <size=9>(Used)</size>";
+				}
+				else if (tsrc.Handler.GetDimension(src.Value.Type) < m_configScene.ruleset.Root.inputs[_sel].dim) {
+					text.text += " <size=9>(Not Applicable)</size>";
+				}
+				else flag = true;
+				btn.interactable = flag;
+			}
 			btn.onClick.AddListener(() => {
 				CloseDialog(src);
 			});

Assets/Cryville/Crtr/Config/InputConfigPanelEntry.cs

@@ -1,4 +1,6 @@
-using UnityEngine;
+using Cryville.Common;
+using UnityEngine;
+using UnityEngine.EventSystems;
 using UnityEngine.UI;
 
 namespace Cryville.Crtr.Config {
@@ -12,20 +14,31 @@ namespace Cryville.Crtr.Config {
 		[SerializeField]
 		Button m_button;
 
-		public void SetKey(InputConfigPanel master, string name) {
-			m_key.text = name;
+		public void SetKey(InputConfigPanel master, Identifier name) {
+			m_key.text = (string)name.Name;
 			m_value.text = "None";
 			m_button.onClick.AddListener(() => {
 				master.OpenDialog(name);
+				EventSystem.current.SetSelectedGameObject(null);
 			});
 		}
 
-		public void SetValue(string name) {
-			m_value.text = name;
-		}
-
-		public void SetEnabled(bool flag) {
-			m_button.interactable = flag;
+		public void OnProxyChanged(ProxyChangedEventArgs e) {
+			if (e.Used) {
+				m_button.interactable = false;
+				m_value.text = "(Not Required)";
+			}
+			else {
+				m_button.interactable = true;
+				if (e.Proxy == null) {
+					m_value.text = "(Unassigned)";
+					if (e.Required) m_value.text += " (Required)";
+				}
+				else {
+					m_value.text = e.Proxy.Value.Handler.GetTypeName(e.Proxy.Value.Type);
+				}
+			}
+			m_value.color = e.Required ? Color.yellow : Color.black;
 		}
 	}
 }

Assets/Cryville/Crtr/Config/RulesetConfig.cs

@@ -12,6 +12,12 @@ namespace Cryville.Crtr.Config {
 			[JsonProperty("skin")]
 			public string Skin { get; set; }
 
+			[Category("gameplay")]
+			[JsonProperty("sound_offset")]
+			[Step(0.04f)]
+			[Precision(1e-3)]
+			public float SoundOffset { get; set; }
+
 			[Category("deprecated")][Obsolete]
 			[JsonProperty("scroll_velocity")][DefaultValue(1)]
 			[LogarithmicScale][Step(0.5f)][Precision(1e-1)]
@@ -19,6 +25,7 @@ namespace Cryville.Crtr.Config {
 
 			public Generic() {
 				Skin = "";
+				SoundOffset = 0;
 				ScrollVelocity = 1;
 			}
 		}

Assets/Cryville/Crtr/EffectGroup.cs

@@ -0,0 +1,65 @@
+using Cryville.Common.Buffers;
+using System.Collections.Generic;
+
+namespace Cryville.Crtr {
+	public class EffectGroup {
+		public EffectDefinition Definition { get; private set; }
+		readonly EffectPool _pool;
+		class EffectPool : ObjectPool<EffectInstance> {
+			readonly List<EffectInstance> _instances
+				= new List<EffectInstance>();
+			readonly EffectGroup _group;
+			public EffectPool(EffectGroup group) : base(256) {
+				_group = group;
+			}
+			protected override EffectInstance Construct() {
+				var result = new EffectInstance(_group.Definition);
+				_instances.Add(result);
+				return result;
+			}
+			public void DisposeAll() {
+				foreach (var i in _instances) i.Dispose();
+			}
+		}
+		readonly Dictionary<float, EffectInstance> _instances
+			= new Dictionary<float, EffectInstance>();
+		readonly List<EffectInstance> _endQueue
+			= new List<EffectInstance>();
+		public EffectGroup(EffectDefinition def) {
+			Definition = def;
+			_pool = new EffectPool(this);
+		}
+		double _time;
+		public void Tick(double time) {
+			_time = time;
+			while (_endQueue.Count > 0) {
+				var item = _endQueue[0];
+				if (item.EndTime > _time) break;
+				item.OnDone();
+				_instances.Remove(item.Index);
+				_pool.Return(item);
+				_endQueue.RemoveAt(0);
+			}
+			foreach (var instance in _instances) {
+				instance.Value.Tick();
+			}
+		}
+		public void Emit(float index) {
+			EffectInstance instance;
+			if (_instances.TryGetValue(index, out instance)) {
+				var i = _endQueue.BinarySearch(instance);
+				_endQueue.RemoveAt(i);
+			}
+			else {
+				_instances.Add(index, instance = _pool.Rent());
+			}
+			instance.Index = index;
+			instance.OnEmit(_time);
+			var i2 = ~_endQueue.BinarySearch(instance);
+			_endQueue.Insert(i2, instance);
+		}
+		public void Dispose() {
+			_pool.DisposeAll();
+		}
+	}
+}

Assets/Cryville/Crtr/EffectGroup.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: d0d27f9b4383b3445a2a27bfe94173a5
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Cryville/Crtr/EffectInstance.cs

@@ -0,0 +1,79 @@
+using Cryville.Common;
+using Cryville.Crtr.Components;
+using System;
+using System.Collections.Generic;
+using System.Globalization;
+using UnityEngine;
+
+namespace Cryville.Crtr {
+	public class EffectInstance : ISkinnableGroup, IComparable<EffectInstance> {
+		readonly EffectDefinition _def;
+		readonly SkinContainer _skinContainer;
+		public Transform RootTransform { get; private set; }
+		public EffectInstance(EffectDefinition def) {
+			_def = def;
+			_skinContainer = new SkinContainer(_def.elements);
+			RootTransform = new GameObject("effect:" + GetHashCode().ToString(CultureInfo.InvariantCulture)).transform;
+			SkinContext = new SkinContext(RootTransform);
+			ChartPlayer.etor.ContextCascadeInsertBlock();
+			_skinContainer.MatchStatic(this);
+			ChartPlayer.etor.ContextCascadeDiscardBlock();
+			foreach (var i in RootTransform.GetComponentsInChildren<SkinComponent>())
+				i.Init();
+			_indexSrc = new PropSrc.Float(() => Index);
+			_durationOp = new PropOp.Float(v => _duration = v);
+		}
+		private float m_index;
+		public float Index {
+			get { return m_index; }
+			set {
+				if (m_index == value) return;
+				m_index = value;
+				_indexSrc.Invalidate();
+			}
+		}
+		internal static readonly int _VAR_EFFECT_INDEX = IdentifierManager.SharedInstance.Request("effect_index");
+		readonly PropSrc _indexSrc;
+		double _startTime;
+		float _duration;
+		readonly PropOp _durationOp;
+		public double EndTime { get { return _startTime + _duration; } }
+		public void Tick() {
+			_skinContainer.MatchDynamic(this, 1);
+		}
+		public void OnEmit(double time) {
+			_startTime = time;
+			RootTransform.gameObject.SetActive(true);
+			ChartPlayer.etor.ContextCascadeInsert();
+			ChartPlayer.etor.ContextCascadeUpdate(_VAR_EFFECT_INDEX, _indexSrc);
+			ChartPlayer.etor.Evaluate(_durationOp, _def.duration);
+			_skinContainer.MatchDynamic(this, 0);
+			ChartPlayer.etor.ContextCascadeDiscard();
+		}
+		public void OnDone() {
+			RootTransform.gameObject.SetActive(false);
+		}
+		public void Dispose() {
+			GameObject.Destroy(RootTransform.gameObject);
+		}
+
+		public string TypeName { get { throw new InvalidOperationException("Type name undefined"); } }
+		public SkinContext SkinContext { get; private set; }
+		public Anchor OpenedAnchor { get { throw new InvalidOperationException("Anchor not supported"); } }
+		public void PushAnchorEvent(double time, int name) {
+			throw new InvalidOperationException("Anchor not supported");
+		}
+		public void RegisterAnchor(int name) {
+			throw new InvalidOperationException("Anchor not supported");
+		}
+		public bool TryGetAnchorsByName(int name, out IReadOnlyCollection<Anchor> result) {
+			throw new InvalidOperationException("Anchor not supported");
+		}
+
+		public int CompareTo(EffectInstance other) {
+			int r = EndTime.CompareTo(other.EndTime);
+			if (r != 0) return r;
+			return GetHashCode().CompareTo(other.GetHashCode());
+		}
+	}
+}

Assets/Cryville/Crtr/EffectInstance.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: f442db34239c47046ba1b6fdae8e1216
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Cryville/Crtr/EffectManager.cs

@@ -0,0 +1,22 @@
+using System.Collections.Generic;
+
+namespace Cryville.Crtr {
+	public class EffectManager {
+		readonly Dictionary<int, EffectGroup> _groups
+			= new Dictionary<int, EffectGroup>();
+		public EffectManager(PdtSkin skin) {
+			foreach (var e in skin.effects) {
+				_groups.Add(e.Key.Key, new EffectGroup(e.Value));
+			}
+		}
+		public void Tick(double time) {
+			foreach (var g in _groups) g.Value.Tick(time);
+		}
+		public void Emit(int id, float index) {
+			_groups[id].Emit(index);
+		}
+		public void Dispose() {
+			foreach (var g in _groups) g.Value.Dispose();
+		}
+	}
+}

Assets/Cryville/Crtr/EffectManager.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 980c0f18a6f491d44a866a85910cb458
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Cryville/Crtr/Event/ContainerHandler.cs

@@ -8,10 +8,9 @@ using System.Runtime.CompilerServices;
 using UnityEngine;
 
 namespace Cryville.Crtr.Event {
-	public abstract class ContainerHandler {
+	public abstract class ContainerHandler : ISkinnableGroup {
 		#region Struct
 		public ContainerHandler() { }
-		public abstract string TypeName { get; }
 
 		/// <summary>
 		/// Prehandling <see cref="ContainerState"/>, prehandling the events.
@@ -42,7 +41,6 @@ namespace Cryville.Crtr.Event {
 		/// <see cref="GameObject"/> group, the <see cref="Transform"/> containing all the generated elements in the <see cref="ContainerHandler"/>.
 		/// </summary>
 		protected Transform gogroup;
-		public SkinContext SkinContext;
 
 		public Vector3 Position { get; protected set; }
 		public Quaternion Rotation { get; protected set; }
@@ -66,23 +64,27 @@ namespace Cryville.Crtr.Event {
 			get { return cs.Container; }
 		}
 
+		static readonly int _var_current_time = IdentifierManager.SharedInstance.Request("current_time");
+		static readonly int _var_invisible_bounds = IdentifierManager.SharedInstance.Request("invisible_bounds");
+		public readonly Dictionary<int, PropSrc> PropSrcs = new Dictionary<int, PropSrc>();
 		SkinContainer skinContainer;
 		protected Judge judge;
 		public void AttachSystems(PdtSkin skin, Judge judge) {
-			skinContainer = new SkinContainer(skin);
+			skinContainer = new SkinContainer(skin.elements);
 			this.judge = judge;
 		}
 
 		public readonly Dictionary<int, List<Anchor>> Anchors = new Dictionary<int, List<Anchor>>();
 		public readonly Dictionary<int, Anchor> DynamicAnchors = new Dictionary<int, Anchor>();
-		public readonly Dictionary<int, bool> DynamicAnchorSet = new Dictionary<int, bool>();
-		public Anchor OpenedAnchor;
-		protected Anchor a_cur;
-		protected Anchor a_head;
-		protected Anchor a_tail;
-		protected readonly static int _a_cur = IdentifierManager.SharedInstance.Request("cur");
-		protected readonly static int _a_head = IdentifierManager.SharedInstance.Request("head");
-		protected readonly static int _a_tail = IdentifierManager.SharedInstance.Request("tail");
+		public readonly Dictionary<int, double> DynamicAnchorSetTime = new Dictionary<int, double>();
+		Anchor a_cur;
+		Anchor a_head;
+		Anchor a_tail;
+		readonly static int _a_cur = IdentifierManager.SharedInstance.Request("cur");
+		readonly static int _a_head = IdentifierManager.SharedInstance.Request("head");
+		readonly static int _a_tail = IdentifierManager.SharedInstance.Request("tail");
+		double atime_head;
+		double atime_tail;
 		public Anchor RegisterAnchor(int name, bool dyn = false, int propSrcCount = 0) {
 			var strname = IdentifierManager.SharedInstance.Retrieve(name);
 			var go = new GameObject("." + strname).transform;
@@ -92,7 +94,7 @@ namespace Cryville.Crtr.Event {
 				if (DynamicAnchors.ContainsKey(name))
 					throw new ArgumentException(string.Format("The anchor \"{0}\" already exists", strname));
 				DynamicAnchors.Add(name, result);
-				DynamicAnchorSet.Add(name, false);
+				DynamicAnchorSetTime.Add(name, double.NaN);
 			}
 			List<Anchor> list;
 			if (!Anchors.TryGetValue(name, out list))
@@ -102,6 +104,7 @@ namespace Cryville.Crtr.Event {
 		}
 		protected void OpenAnchor(Anchor anchor) {
 			if (OpenedAnchor != null) throw new InvalidOperationException("An anchor has been opened");
+			anchor.Transform.gameObject.SetActive(true);
 			OpenedAnchor = anchor;
 		}
 		protected void CloseAnchor() {
@@ -121,11 +124,17 @@ namespace Cryville.Crtr.Event {
 			a_tail = RegisterAnchor(_a_tail, true);
 		}
 		public virtual void Init() {
-			skinContainer.MatchStatic(ps);
+			ChartPlayer.etor.ContextState = ps;
+			ChartPlayer.etor.ContextEvent = Container;
+			skinContainer.MatchStatic(this);
+			ChartPlayer.etor.ContextEvent = null;
+			ChartPlayer.etor.ContextState = null;
 			foreach (var i in gogroup.GetComponentsInChildren<SkinComponent>())
 				i.Init();
 		}
 		public virtual void PostInit() {
+			PropSrcs.Add(_var_current_time, new PropSrc.Float(() => (float)cs.rootPrototype.Time));
+			PropSrcs.Add(_var_invisible_bounds, new PropSrc.Boolean(() => atime_head > atime_tail));
 			gogroup.gameObject.SetActive(false);
 		}
 		#endregion
@@ -135,8 +144,8 @@ namespace Cryville.Crtr.Event {
 			else if (s.CloneType == 17) Init();
 		}
 		public virtual void StartLogicalUpdate(ContainerState s) { }
-		public virtual void StartPreGraphicalUpdate(ContainerState s) { }
-		public virtual void StartGraphicalUpdate(ContainerState s) {
+		protected virtual void StartPreGraphicalUpdate(ContainerState s) { }
+		protected virtual void StartGraphicalUpdate(ContainerState s) {
 			if (gogroup) gogroup.gameObject.SetActive(true);
 		}
 		#endregion
@@ -144,30 +153,30 @@ namespace Cryville.Crtr.Event {
 			if (s.CloneType == 3) SetPreGraphicalActive(true, s);
 			else if (ev is StampedEvent.Anchor) {
 				var tev = (StampedEvent.Anchor)ev;
+				if (gogroup) {
+					OpenAnchor(tev.Target);
+#if UNITY_5_6_OR_NEWER
+					tev.Target.Transform.SetPositionAndRotation(Position, Rotation);
+#else
+					tev.Target.Transform.position = Position;
+					tev.Target.Transform.rotation = Rotation;
+#endif
+					MatchDynamic(s, 1);
+					CloseAnchor();
+				}
 				if (tev.Target == a_head) {
 					SetGraphicalActive(true, s);
 				}
 				else if (tev.Target == a_tail) {
 					SetGraphicalActive(false, s);
 				}
-				if (gogroup) {
-					OpenAnchor(tev.Target);
-#if UNITY_5_6_OR_NEWER
-					tev.Target.Transform.SetPositionAndRotation(Position, Rotation);
-#else
-					tev.Target.Transform.position = GetCurrentWorldPoint();
-					tev.Target.Transform.rotation = Quaternion.Euler(s.Direction);
-#endif
-					skinContainer.MatchDynamic(s);
-					CloseAnchor();
-				}
 				anchorEvPool.Return(tev);
 			}
-			else if (gogroup && s.CloneType == 2) skinContainer.MatchDynamic(s);
+			else if (gogroup && s.CloneType == 2) MatchDynamic(s, 1);
 		}
 		#region End methods
-		public virtual void EndGraphicalUpdate(ContainerState s) { }
-		public virtual void EndPreGraphicalUpdate(ContainerState s) { }
+		protected virtual void EndGraphicalUpdate(ContainerState s) { }
+		protected virtual void EndPreGraphicalUpdate(ContainerState s) { }
 		public virtual void EndLogicalUpdate(ContainerState s) { }
 		public virtual void EndPhysicalUpdate(ContainerState s) { }
 		public virtual void Dispose() {
@@ -177,29 +186,41 @@ namespace Cryville.Crtr.Event {
 		}
 		public virtual void DisposeAll() { }
 		#endregion
+		#region Utils
 		[MethodImpl(MethodImplOptions.AggressiveInlining)]
 		protected static bool CanDoGraphicalUpdate(ContainerState s) { return s.CloneType >= 2 && s.CloneType < 16; }
+		[MethodImpl(MethodImplOptions.AggressiveInlining)]
+		void MatchDynamic(ContainerState s, int dl) {
+			ChartPlayer.etor.ContextState = s;
+			ChartPlayer.etor.ContextEvent = Container;
+			skinContainer.MatchDynamic(this, dl);
+			ChartPlayer.etor.ContextEvent = null;
+			ChartPlayer.etor.ContextState = null;
+		}
+		#endregion
 		#region Anchor
 		public virtual void Anchor() {
-			foreach (var a in DynamicAnchors.Keys) DynamicAnchorSet[a] = false;
-			skinContainer.MatchDynamic(cs);
+			foreach (var p in PropSrcs) p.Value.Invalidate();
+			foreach (var a in DynamicAnchors) DynamicAnchorSetTime[a.Key] = double.NaN;
+			atime_head = cs.StampedContainer.Time;
+			atime_tail = atime_head + cs.StampedContainer.Duration;
+			MatchDynamic(cs, 0);
 			if (cs.Active) PushAnchorEvent(cs.Time, a_cur);
-			if (Alive) {
-				if (!DynamicAnchorSet[_a_head]) PushAnchorEvent(cs.StampedContainer.Time, a_head, -1, true);
-				if (!DynamicAnchorSet[_a_tail]) PushAnchorEvent(cs.StampedContainer.Time + cs.StampedContainer.Duration, a_tail, 1, true);
+			if (double.IsNaN(DynamicAnchorSetTime[_a_head])) DynamicAnchorSetTime[_a_head] = atime_head;
+			if (double.IsNaN(DynamicAnchorSetTime[_a_tail])) DynamicAnchorSetTime[_a_tail] = atime_tail;
+			foreach (var t in DynamicAnchorSetTime) {
+				if (double.IsNaN(t.Value)) continue;
+				int priority = 0;
+				bool forced = true;
+				if (t.Key == _a_head) { priority = -1; }
+				else if (t.Key == _a_tail) { priority = 1; }
+				else forced = false;
+				PushAnchorEvent(t.Value, DynamicAnchors[t.Key], priority, forced);
 			}
+			foreach (var anchors in Anchors) foreach (var anchor in anchors.Value) anchor.Transform.gameObject.SetActive(false);
 		}
 		static readonly SimpleObjectPool<StampedEvent.Anchor> anchorEvPool
 			= new SimpleObjectPool<StampedEvent.Anchor>(1024);
-		public void PushAnchorEvent(double time, int name) {
-			Anchor anchor;
-			if (!DynamicAnchors.TryGetValue(name, out anchor))
-				throw new ArgumentException(string.Format("Specified anchor \"{0}\" not found", IdentifierManager.SharedInstance.Retrieve(name)));
-			if (DynamicAnchorSet[name])
-				throw new InvalidOperationException(string.Format("Specified anchor \"{0}\" has been set", IdentifierManager.SharedInstance.Retrieve(name)));
-			PushAnchorEvent(time, anchor);
-			DynamicAnchorSet[name] = true;
-		}
 		void PushAnchorEvent(double time, Anchor anchor, int priority = 0, bool forced = false) {
 			var tev = anchorEvPool.Rent();
 			tev.Time = time;
@@ -216,5 +237,27 @@ namespace Cryville.Crtr.Event {
 		}
 		#endregion
 		#endregion
+
+		#region ISkinnableGroup
+		public abstract string TypeName { get; }
+		public SkinContext SkinContext { get; private set; }
+		public Anchor OpenedAnchor { get; private set; }
+		public bool TryGetAnchorsByName(int name, out IReadOnlyCollection<Anchor> result) {
+			List<Anchor> anchors;
+			var ret = Anchors.TryGetValue(name, out anchors);
+			result = anchors;
+			return ret;
+		}
+		void ISkinnableGroup.RegisterAnchor(int name) {
+			RegisterAnchor(name, true);
+		}
+		public void PushAnchorEvent(double time, int name) {
+			if (!DynamicAnchors.ContainsKey(name))
+				throw new ArgumentException(string.Format("Specified anchor \"{0}\" not found", IdentifierManager.SharedInstance.Retrieve(name)));
+			if (name == _a_head) atime_head = time;
+			else if (name == _a_tail) atime_tail = time;
+			DynamicAnchorSetTime[name] = time;
+		}
+		#endregion
 	}
 }

Assets/Cryville/Crtr/Event/ContainerState.cs

@@ -1,6 +1,7 @@
 //#define DISABLE_CACHE
 
 using Cryville.Common;
+using Cryville.Common.Buffers;
 using System;
 using System.Collections.Generic;
 using System.Runtime.CompilerServices;
@@ -70,7 +71,6 @@ namespace Cryville.Crtr.Event {
 
 		public byte CloneType;
 		public ContainerState rootPrototype = null;
-		private ContainerState prototype = null;
 
 		public ContainerHandler Handler {
 			get;
@@ -87,10 +87,13 @@ namespace Cryville.Crtr.Event {
 			Container = _ev;
 
 			if (parent != null) {
-				AddChild(_ev, this, parent);
+				AddChild(_ev, parent);
 				Parent = parent;
 			}
 
+			_rmvpa = new CategorizedPoolAccessor<Identifier, RealtimeMotionValue>(RMVPool);
+			_mcpa = new CategorizedPoolAccessor<Identifier, MotionCache>(MCPool);
+
 			Values = new Dictionary<Identifier, RealtimeMotionValue>(ChartPlayer.motionRegistry.Count);
 			CachedValues = new Dictionary<Identifier, MotionCache>(ChartPlayer.motionRegistry.Count);
 			foreach (var m in ChartPlayer.motionRegistry)
@@ -99,11 +102,13 @@ namespace Cryville.Crtr.Event {
 			rootPrototype = this;
 		}
 
-		static void AddChild(EventContainer c, ContainerState s, ContainerState target) {
-			target.Children.Add(c, s);
+		void AddChild(EventContainer c, ContainerState parent) {
+			parent.Children.Add(c, this);
 			Type t = c.GetType();
-			if (!target.TypedChildren.ContainsKey(t)) target.TypedChildren.Add(t, new List<ContainerState>());
-			target.TypedChildren[t].Add(s);
+			List<ContainerState> tc;
+			if (!parent.TypedChildren.TryGetValue(t, out tc))
+				parent.TypedChildren.Add(t, tc = new List<ContainerState>());
+			tc.Add(this);
 		}
 
 		public ContainerState Clone(byte ct) {
@@ -116,18 +121,14 @@ namespace Cryville.Crtr.Event {
 			r.Values = mvs;
 
 			var cvs = new Dictionary<Identifier, MotionCache>(ChartPlayer.motionRegistry.Count);
-			foreach (var cv in CachedValues) {
-				var dv = r.MCPool.Rent(cv.Key);
-				cv.Value.CopyTo(dv);
-				cvs.Add(cv.Key, dv);
-			}
 			r.CachedValues = cvs;
 
 			r.Children = new Dictionary<EventContainer, ContainerState>();
+			r.TypedChildren = new Dictionary<Type, List<ContainerState>>();
 			foreach (var child in Children) {
 				var cc = child.Value.Clone(ct);
 				cc.Parent = r;
-				AddChild(child.Key, cc, r);
+				cc.AddChild(child.Key, r);
 			}
 
 			r.ActiveChildren = new HashSet<EventContainer>();
@@ -142,7 +143,6 @@ namespace Cryville.Crtr.Event {
 			else if (ct == 3) Handler.ns = r;
 			else if (ct >= 16) Handler.ps = r;
 			else throw new InvalidOperationException("Invalid clone type");
-			r.prototype = this;
 			r.CloneType = ct;
 			return r;
 		}
@@ -163,7 +163,7 @@ namespace Cryville.Crtr.Event {
 			foreach (var cv in CachedValues) {
 				MotionCache dv;
 				if (!dest.CachedValues.TryGetValue(cv.Key, out dv)) {
-					dest.CachedValues.Add(cv.Key, dv = dest.MCPool.Rent(cv.Key));
+					dest.CachedValues.Add(cv.Key, dv = dest._mcpa.Rent(cv.Key));
 				}
 				cv.Value.CopyTo(dv);
 			}
@@ -190,10 +190,12 @@ namespace Cryville.Crtr.Event {
 			if (Disposed) return;
 			Disposed = true;
 			if (CloneType == 1) Handler.Dispose();
+			if (CloneType == 1 || CloneType == 17) {
+				_rmvpa.ReturnAll();
+				_mcpa.ReturnAll();
+			}
 			foreach (var s in Children)
 				s.Value.Dispose();
-			RMVPool.ReturnAll();
-			MCPool.ReturnAll();
 		}
 		public void DisposeAll() {
 			foreach (var s in Children)
@@ -214,8 +216,10 @@ namespace Cryville.Crtr.Event {
 		#endregion
 
 		#region Motion
-		readonly RMVPool RMVPool = new RMVPool();
-		readonly MotionCachePool MCPool = new MotionCachePool();
+		internal static RMVPool RMVPool;
+		internal static MotionCachePool MCPool;
+		readonly CategorizedPoolAccessor<Identifier, RealtimeMotionValue> _rmvpa;
+		readonly CategorizedPoolAccessor<Identifier, MotionCache> _mcpa;
 		Dictionary<StampedEvent, RealtimeMotionValue> PlayingMotions = new Dictionary<StampedEvent, RealtimeMotionValue>(4);
 		Dictionary<Identifier, RealtimeMotionValue> Values;
 		Dictionary<Identifier, MotionCache> CachedValues;
@@ -235,7 +239,7 @@ namespace Cryville.Crtr.Event {
 		void InvalidateMotion(Identifier name) {
 			MotionCache cache;
 			if (!CachedValues.TryGetValue(name, out cache))
-				CachedValues.Add(name, cache = MCPool.Rent(name));
+				CachedValues.Add(name, cache = _mcpa.Rent(name));
 			cache.Valid = false;
 			foreach (var c in ActiveChildren)
 				Children[c].InvalidateMotion(name);
@@ -244,7 +248,7 @@ namespace Cryville.Crtr.Event {
 		public Vector GetRawValue(Identifier key) {
 			MotionCache tr;
 			if (!CachedValues.TryGetValue(key, out tr))
-				CachedValues.Add(key, tr = MCPool.Rent(key));
+				CachedValues.Add(key, tr = _mcpa.Rent(key));
 			Vector r = tr.Value;
 #if !DISABLE_CACHE
 			if (tr.Valid) return r;
@@ -353,14 +357,14 @@ namespace Cryville.Crtr.Event {
 			if (ev != null) {
 				if (ev.Unstamped is Chart.Motion) {
 					var tev = (Chart.Motion)ev.Unstamped;
-					var mv = RMVPool.Rent(tev.Name);
+					var mv = _rmvpa.Rent(tev.Name);
 					mv.CloneTypeFlag = CloneType;
 					GetMotionValue(tev.Name).CopyTo(mv);
 					PlayingMotions.Add(ev, mv);
 					Update(ev);
 					if (!ev.Unstamped.IsLong) {
 						PlayingMotions.Remove(ev);
-						RMVPool.Return(mv);
+						_rmvpa.Return(mv);
 					}
 				}
 				else if (ev.Unstamped is EventContainer) {
@@ -378,7 +382,7 @@ namespace Cryville.Crtr.Event {
 					if (nev is Chart.Motion) {
 						Update(ev);
 						var mv = PlayingMotions[ev.Origin];
-						if (mv.CloneTypeFlag == CloneType) RMVPool.Return(mv);
+						if (mv.CloneTypeFlag == CloneType) _rmvpa.Return(mv);
 						PlayingMotions.Remove(ev.Origin);
 					}
 					else if (nev is EventContainer) {
@@ -430,14 +434,14 @@ namespace Cryville.Crtr.Event {
 
 		public void BroadcastPreInit() {
 			Handler.PreInit();
-			foreach (var c in Children.Values) {
-				c.BroadcastPreInit();
+			foreach (var c in Children) {
+				c.Value.BroadcastPreInit();
 			}
 		}
 		public void BroadcastPostInit() {
 			Handler.PostInit();
-			foreach (var c in Children.Values) {
-				c.BroadcastPostInit();
+			foreach (var c in Children) {
+				c.Value.BroadcastPostInit();
 			}
 		}
 
@@ -457,8 +461,8 @@ namespace Cryville.Crtr.Event {
 
 		public void Anchor() {
 			Handler.Anchor();
-			foreach (var ls in Children.Values) {
-				if (ls.Handler.Alive) ls.Anchor();
+			foreach (var ls in Children) {
+				if (ls.Value.Handler.Alive) ls.Value.Anchor();
 			}
 		}
 		#endregion

Assets/Cryville/Crtr/Event/EventBatcher.cs

@@ -48,7 +48,7 @@ namespace Cryville.Crtr.Event {
 			}
 			foreach (var ev in c.Events) {
 				if (ev.time == null) {
-					coevents.Add(ev);
+					if (!ev.Standalone) coevents.Add(ev);
 					ev.time = c.time;
 					if (ev is EventContainer)
 						ev.endtime = c.endtime;

Assets/Cryville/Crtr/Event/EventBus.cs

@@ -1,9 +1,9 @@
 using System;
 using System.Collections.Generic;
+using System.Runtime.CompilerServices;
 
 namespace Cryville.Crtr.Event {
 	public class EventBus : StateBase<EventBatch>, IDisposable {
-		EventBus prototype = null;
 		public ContainerState RootState {
 			get;
 			private set;
@@ -25,7 +25,6 @@ namespace Cryville.Crtr.Event {
 
 		public EventBus Clone(byte ct, float offsetTime = 0) {
 			var r = (EventBus)MemberwiseClone();
-			r.prototype = this;
 			r.states = new Dictionary<EventContainer, ContainerState>();
 			r.activeStates = new HashSet<ContainerState>();
 			r.invalidatedStates = new HashSet<ContainerState>();
@@ -64,8 +63,8 @@ namespace Cryville.Crtr.Event {
 				s = RootState;
 			}
 			AddState(s);
-			foreach (var c in s.Children.Values)
-				Expand(c);
+			foreach (var c in s.Children)
+				Expand(c.Value);
 		}
 
 		public void AddState(ContainerState s) {
@@ -74,13 +73,13 @@ namespace Cryville.Crtr.Event {
 		}
 
 		void AttachBus() {
-			foreach (var s in states.Values)
-				s.Bus = this;
+			foreach (var s in states)
+				s.Value.Bus = this;
 		}
 		
 		public void AttachSystems(PdtSkin skin, Judge judge) {
-			foreach (var s in states.Values)
-				s.AttachSystems(skin, judge);
+			foreach (var s in states)
+				s.Value.AttachSystems(skin, judge);
 		}
 
 		List<StampedEvent.Temporary> tempEvents = new List<StampedEvent.Temporary>();
@@ -122,6 +121,7 @@ namespace Cryville.Crtr.Event {
 					var batch = Events[EventId];
 					for (var i = 0; i < batch.Count; i++) {
 						var ev = batch[i];
+						HandleTempEvents(time0, ev.Priority);
 						if (ev is StampedEvent.ClipBehind) {
 							var cevs = ev.Origin.Coevents;
 							if (cevs != null) foreach (var cev in cevs) {
@@ -139,16 +139,7 @@ namespace Cryville.Crtr.Event {
 					}
 					EventId++;
 				}
-				if (time2 == time0) {
-					while (tempEvents.Count > 0) {
-						var ev = tempEvents[0];
-						if (ev.Time != time0) break;
-						if (ev.Container != null) {
-							states[ev.Container].Handle(ev);
-						}
-						tempEvents.RemoveAt(0);
-					}
-				}
+				HandleTempEvents(time0);
 			}
 			else {
 				Time = toTime;
@@ -156,6 +147,17 @@ namespace Cryville.Crtr.Event {
 			}
 			ValidateStates();
 		}
+		[MethodImpl(MethodImplOptions.AggressiveInlining)]
+		void HandleTempEvents(double time, int maxPriority = int.MaxValue) {
+			while (tempEvents.Count > 0) {
+				var ev2 = tempEvents[0];
+				if (ev2.Time != time || ev2.Priority >= maxPriority) break;
+				if (ev2.Container != null) {
+					states[ev2.Container].Handle(ev2);
+				}
+				tempEvents.RemoveAt(0);
+			}
+		}
 
 		private void ValidateStates() {
 			foreach (var s in invalidatedStates)

Assets/Cryville/Crtr/Event/MotionCache.cs

@@ -11,10 +11,10 @@ namespace Cryville.Crtr.Event {
 			Value.CopyTo(dest.Value);
 		}
 	}
-	internal class MotionCachePool {
+	internal class MotionCachePool : CategorizedPool<Identifier, MotionCache> {
 		private class Bucket : ObjectPool<MotionCache> {
 			readonly MotionRegistry _reg;
-			public Bucket(string name, int capacity) : base(capacity) {
+			public Bucket(Identifier name, int capacity) : base(capacity) {
 				_reg = ChartPlayer.motionRegistry[name];
 			}
 			protected override MotionCache Construct() {
@@ -22,34 +22,16 @@ namespace Cryville.Crtr.Event {
 				result.Value = (Vector)ReflectionHelper.InvokeEmptyConstructor(_reg.Type);
 				return result;
 			}
+			protected override void Reset(MotionCache obj) {
+				obj.Valid = false;
+			}
 		}
-		static Dictionary<Identifier, Bucket> _buckets;
-		public static void Prepare() {
-			_buckets = new Dictionary<Identifier, Bucket>(ChartPlayer.motionRegistry.Count);
+		readonly Dictionary<Identifier, ObjectPool<MotionCache>> m_buckets;
+		protected override IReadOnlyDictionary<Identifier, ObjectPool<MotionCache>> Buckets { get { return m_buckets; } }
+		public MotionCachePool() {
+			m_buckets = new Dictionary<Identifier, ObjectPool<MotionCache>>(ChartPlayer.motionRegistry.Count);
 			foreach (var reg in ChartPlayer.motionRegistry)
-				_buckets.Add(reg.Key, new Bucket(reg.Key, 4096));
-		}
-
-		static readonly SimpleObjectPool<Dictionary<MotionCache, Identifier>> _dictPool
-			= new SimpleObjectPool<Dictionary<MotionCache, Identifier>>(1024);
-		Dictionary<MotionCache, Identifier> _rented;
-		public MotionCache Rent(Identifier name) {
-			var obj = _buckets[name].Rent();
-			obj.Valid = false;
-			if (_rented == null) _rented = _dictPool.Rent();
-			_rented.Add(obj, name);
-			return obj;
-		}
-		public void Return(MotionCache obj) {
-			_buckets[_rented[obj]].Return(obj);
-			_rented.Remove(obj);
-		}
-		public void ReturnAll() {
-			if (_rented == null) return;
-			foreach (var obj in _rented)
-				_buckets[obj.Value].Return(obj.Key);
-			_rented.Clear();
-			_dictPool.Return(_rented);
+				m_buckets.Add(reg.Key, new Bucket(reg.Key, 4096));
 		}
 	}
 }

Assets/Cryville/Crtr/Event/RMVPool.cs

@@ -3,42 +3,22 @@ using Cryville.Common.Buffers;
 using System.Collections.Generic;
 
 namespace Cryville.Crtr.Event {
-	internal class RMVPool {
+	internal class RMVPool : CategorizedPool<Identifier, RealtimeMotionValue> {
 		private class Bucket : ObjectPool<RealtimeMotionValue> {
 			readonly MotionRegistry _reg;
-			public Bucket(string name, int capacity) : base(capacity) {
+			public Bucket(Identifier name, int capacity) : base(capacity) {
 				_reg = ChartPlayer.motionRegistry[name];
 			}
 			protected override RealtimeMotionValue Construct() {
 				return new RealtimeMotionValue().Init(_reg.InitValue);
 			}
 		}
-		static Dictionary<Identifier, Bucket> _buckets;
-		public static void Prepare() {
-			_buckets = new Dictionary<Identifier, Bucket>(ChartPlayer.motionRegistry.Count);
+		readonly Dictionary<Identifier, ObjectPool<RealtimeMotionValue>> m_buckets;
+		protected override IReadOnlyDictionary<Identifier, ObjectPool<RealtimeMotionValue>> Buckets { get { return m_buckets; } }
+		public RMVPool() {
+			m_buckets = new Dictionary<Identifier, ObjectPool<RealtimeMotionValue>>(ChartPlayer.motionRegistry.Count);
 			foreach (var reg in ChartPlayer.motionRegistry)
-				_buckets.Add(reg.Key, new Bucket(reg.Key, 4096));
-		}
-
-		static readonly SimpleObjectPool<Dictionary<RealtimeMotionValue, Identifier>> _dictPool
-			= new SimpleObjectPool<Dictionary<RealtimeMotionValue, Identifier>>(1024);
-		Dictionary<RealtimeMotionValue, Identifier> _rented;
-		public RealtimeMotionValue Rent(Identifier name) {
-			var obj = _buckets[name].Rent();
-			if (_rented == null) _rented = _dictPool.Rent();
-			_rented.Add(obj, name);
-			return obj;
-		}
-		public void Return(RealtimeMotionValue obj) {
-			_buckets[_rented[obj]].Return(obj);
-			_rented.Remove(obj);
-		}
-		public void ReturnAll() {
-			if (_rented == null) return;
-			foreach (var obj in _rented)
-				_buckets[obj.Value].Return(obj.Key);
-			_rented.Clear();
-			_dictPool.Return(_rented);
+				m_buckets.Add(reg.Key, new Bucket(reg.Key, 4096));
 		}
 	}
 }

Assets/Cryville/Crtr/Extensions/osu/osuChartConverter.cs

@@ -10,7 +10,7 @@ namespace Cryville.Crtr.Extensions.osu {
 	public class osuChartConverter : ResourceConverter {
 #pragma warning restore IDE1006
 		static readonly string[] SUPPORTED_FORMATS = { ".osu" };
-		const double OFFSET = 0.07;
+		const double OFFSET = 0.05;
 
 		public override string[] GetSupportedFormats() {
 			return SUPPORTED_FORMATS;

Assets/Cryville/Crtr/Game.cs

@@ -104,16 +104,16 @@ namespace Cryville.Crtr {
 			}
 
 			ChartPlayer.motionRegistry = new Dictionary<Identifier, MotionRegistry> {
-				{ "pt"     , new MotionRegistry(typeof(VecPt)) },
-				{ "dir"    , new MotionRegistry(typeof(Vec3)) },
-				{ "normal" , new MotionRegistry(typeof(Vec3)) },
-				{ "sv"     , new MotionRegistry(new VecPtComp(0f, 0f), new VecPtComp(0f, 1f)) },
-				{ "svm"    , new MotionRegistry(new Vec1m(1f)) },
-				{ "dist"   , new MotionRegistry(new VecPtComp(0f, 0f), new VecPtComp(0f, float.PositiveInfinity)) },
-				{ "corner" , new MotionRegistry(typeof(VecI1)) },
-				{ "ctrl0"  , new MotionRegistry(typeof(VecCtrl)) },
-				{ "ctrl1"  , new MotionRegistry(typeof(VecCtrl)) },
-				{ "track"  , new MotionRegistry(typeof(Vec1)) },
+				{ new Identifier("pt")     , new MotionRegistry(typeof(VecPt)) },
+				{ new Identifier("dir")    , new MotionRegistry(typeof(Vec3)) },
+				{ new Identifier("normal") , new MotionRegistry(typeof(Vec3)) },
+				{ new Identifier("sv")     , new MotionRegistry(new VecPtComp(0f, 0f), new VecPtComp(0f, 1f)) },
+				{ new Identifier("svm")    , new MotionRegistry(new Vec1m(1f)) },
+				{ new Identifier("dist")   , new MotionRegistry(new VecPtComp(0f, 0f), new VecPtComp(0f, float.PositiveInfinity)) },
+				{ new Identifier("corner") , new MotionRegistry(typeof(VecI1)) },
+				{ new Identifier("ctrl0")  , new MotionRegistry(typeof(VecCtrl)) },
+				{ new Identifier("ctrl1")  , new MotionRegistry(typeof(VecCtrl)) },
+				{ new Identifier("track")  , new MotionRegistry(typeof(Vec1)) },
 			};
 
 			var dir = new DirectoryInfo(Settings.Default.GameDataPath + "/charts");

Assets/Cryville/Crtr/GenericResources.cs

@@ -18,6 +18,7 @@ namespace Cryville.Crtr {
 
 		public static void LoadDefault() {
 			if (loaded) return;
+			Components.Add("anim", typeof(SkinAnimation));
 			Components.Add("image", typeof(SpritePlane));
 			Components.Add("mesh", typeof(MeshBase));
 			Components.Add("polysec", typeof(PolygonSGO));
@@ -26,11 +27,13 @@ namespace Cryville.Crtr {
 			Components.Add("sprite", typeof(SpriteBase));
 			Components.Add("text", typeof(SpriteText));
 
-			Meshes.Add("quad", Resources.Load<Mesh>("quad"));
-			Meshes.Add("quad_scale3h", Resources.Load<Mesh>("quad_scale3h"));
-			Meshes.Add("quad_scale9", Resources.Load<Mesh>("quad_scale9"));
+			Meshes.Add("quad", Resources.Load<Mesh>("Meshes/quad"));
+			Meshes.Add("quad_scale3h", Resources.Load<Mesh>("Meshes/quad_scale3h"));
 
-			Materials.Add("-SpriteMat", Resources.Load<Material>("SpriteMat"));
+			Materials.Add("-SpriteMat", Resources.Load<Material>("Materials/SpriteMat"));
+
+			Shaders.Add("default", Shader.Find("Sprites/Default"));
+			Shaders.Add("additive", Shader.Find("Sprites/Additive"));
 
 			loaded = true;
 		}

Assets/Cryville/Crtr/GroupHandler.cs

@@ -1,7 +1,6 @@
 using Cryville.Common.Math;
 using Cryville.Crtr.Event;
 using System;
-using System.Linq;
 using UnityEngine;
 
 namespace Cryville.Crtr {
@@ -10,6 +9,7 @@ namespace Cryville.Crtr {
 
 		SquareMatrix matFrame;
 		ContainerState[] tracks;
+		public int TrackCount { get { return tracks.Length; } }
 
 		public GroupHandler(Chart.Group tg, ChartHandler ch) : base() {
 			this.ch = ch;
@@ -19,20 +19,19 @@ namespace Cryville.Crtr {
 
 		public override void PreInit() {
 			base.PreInit();
-			tracks = (
-				from c in cs.Children
-				where c.Value.Container is Chart.Track
-				select c.Value
-			).ToArray();
+			tracks = cs.TypedChildren[typeof(Chart.Track)].ToArray();
 			matFrame = SquareMatrix.WithPolynomialCoefficients(tracks.Length);
-			frame = new ColumnVector<Vector3>(tracks.Length);
+			frame1 = new ColumnVector<Vector3>(tracks.Length);
+			frame2 = new ColumnVector<Vector3>(tracks.Length);
 		}
 
-		ColumnVector<Vector3> frame;
+		ColumnVector<Vector3> frame1;
+		ColumnVector<Vector3> frame2;
 		public ColumnVector<Vector3> GetCurrentFrame(Func<ContainerState, Vector3> func) {
 			for (int i = 0; i < tracks.Length; i++)
-				frame[i] = func(tracks[i]);
-			return matFrame.Eliminate(frame, Vector3Operator.Instance);
+				frame1[i] = func(tracks[i]);
+			matFrame.Eliminate(frame1, frame2, Vector3Operator.Instance);
+			return frame2;
 		}
 	}
 

Assets/Cryville/Crtr/InputProxy.cs

@@ -23,7 +23,7 @@ namespace Cryville.Crtr {
 			_judge = judge;
 			foreach (var i in ruleset.inputs) {
 				_use.Add(i.Key, 0);
-				_rev.Add(i.Key, new List<string>());
+				_rev.Add(i.Key, new List<Identifier>());
 			}
 			foreach (var i in ruleset.inputs) {
 				if (i.Value.pass != null) {
@@ -33,15 +33,15 @@ namespace Cryville.Crtr {
 			}
 		}
 		#region Settings
-		readonly Dictionary<string, InputProxyEntry> _tproxies = new Dictionary<string, InputProxyEntry>();
+		readonly Dictionary<Identifier, InputProxyEntry> _tproxies = new Dictionary<Identifier, InputProxyEntry>();
 		readonly Dictionary<InputSource, InputProxyEntry> _sproxies = new Dictionary<InputSource, InputProxyEntry>();
-		readonly Dictionary<string, int> _use = new Dictionary<string, int>();
-		readonly Dictionary<string, List<string>> _rev = new Dictionary<string, List<string>>();
+		readonly Dictionary<Identifier, int> _use = new Dictionary<Identifier, int>();
+		readonly Dictionary<Identifier, List<Identifier>> _rev = new Dictionary<Identifier, List<Identifier>>();
 		public event EventHandler<ProxyChangedEventArgs> ProxyChanged;
 		public void LoadFrom(Dictionary<string, RulesetConfig.InputEntry> config) {
 			foreach (var cfg in config) {
 				Set(new InputProxyEntry {
-					Target = cfg.Key,
+					Target = new Identifier(cfg.Key),
 					Source = new InputSource {
 						Handler = Game.InputManager.GetHandler(cfg.Value.handler),
 						Type = cfg.Value.type
@@ -52,7 +52,7 @@ namespace Cryville.Crtr {
 		public void SaveTo(Dictionary<string, RulesetConfig.InputEntry> config) {
 			config.Clear();
 			foreach (var p in _tproxies) {
-				config.Add(p.Key, new RulesetConfig.InputEntry {
+				config.Add((string)p.Key.Name, new RulesetConfig.InputEntry {
 					handler = ReflectionHelper.GetNamespaceQualifiedName(p.Value.Source.Value.Handler.GetType()),
 					type = p.Value.Source.Value.Type
 				});
@@ -81,14 +81,16 @@ namespace Cryville.Crtr {
 		public bool IsUsed(InputSource src) {
 			return _sproxies.ContainsKey(src);
 		}
-		public bool IsCompleted {
-			get {
-				foreach (var i in _use)
-					if (i.Value == 0 && !_tproxies.ContainsKey(i.Key)) return false;
-				return true;
-			}
+		public bool IsCompleted() {
+			foreach (var i in _use)
+				if (!IsCompleted(i.Key)) return false;
+			return true;
 		}
-		void IncrementUseRecursive(string name) {
+		bool IsCompleted(Identifier name) {
+			return name.Key == _var_pause || _use[name] != 0 || _tproxies.ContainsKey(name);
+		}
+		static readonly int _var_pause = IdentifierManager.SharedInstance.Request("pause");
+		void IncrementUseRecursive(Identifier name) {
 			BroadcastProxyChanged(name);
 			var passes = _ruleset.inputs[name].pass;
 			if (passes != null) {
@@ -98,14 +100,14 @@ namespace Cryville.Crtr {
 				}
 			}
 		}
-		void IncrementReversedUseRecursive(string name) {
+		void IncrementReversedUseRecursive(Identifier name) {
 			foreach (var p in _rev[name]) {
 				_use[p]++;
 				BroadcastProxyChanged(p);
 				IncrementReversedUseRecursive(p);
 			}
 		}
-		void DecrementUseRecursive(string name) {
+		void DecrementUseRecursive(Identifier name) {
 			BroadcastProxyChanged(name);
 			var passes = _ruleset.inputs[name].pass;
 			if (passes != null) {
@@ -115,20 +117,20 @@ namespace Cryville.Crtr {
 				}
 			}
 		}
-		void DecrementReversedUseRecursive(string name) {
+		void DecrementReversedUseRecursive(Identifier name) {
 			foreach (var p in _rev[name]) {
 				_use[p]--;
 				BroadcastProxyChanged(p);
 				DecrementReversedUseRecursive(p);
 			}
 		}
-		void BroadcastProxyChanged(string name) {
+		void BroadcastProxyChanged(Identifier name) {
 			var del = ProxyChanged;
 			if (del != null) del(this, this[name]);
 		}
-		public ProxyChangedEventArgs this[string name] {
+		public ProxyChangedEventArgs this[Identifier name] {
 			get {
-				return new ProxyChangedEventArgs(name, _tproxies.ContainsKey(name) ? _tproxies[name].Source : null, _use[name] > 0);
+				return new ProxyChangedEventArgs(name, _tproxies.ContainsKey(name) ? _tproxies[name].Source : null, _use[name] > 0, !IsCompleted(name));
 			}
 		}
 		#endregion
@@ -164,8 +166,8 @@ namespace Cryville.Crtr {
 		protected void Dispose(bool disposing) {
 			if (disposing) {
 				Deactivate();
-				foreach (var proxy in _tproxies.Values) {
-					proxy.Source.Value.Handler.OnInput -= OnInput;
+				foreach (var proxy in _tproxies) {
+					proxy.Value.Source.Value.Handler.OnInput -= OnInput;
 				}
 			}
 		}
@@ -180,12 +182,13 @@ namespace Cryville.Crtr {
 		readonly Dictionary<InputIdentifier, float> _vect = new Dictionary<InputIdentifier, float>();
 		readonly Dictionary<ProxiedInputIdentifier, PropSrc> _vecs = new Dictionary<ProxiedInputIdentifier, PropSrc>();
 		static readonly PropSrc.Arbitrary _nullsrc = new PropSrc.Arbitrary(PdtInternalType.Null, new byte[0]);
+		double? _lockTime = null;
 		unsafe void OnInput(InputIdentifier id, InputVector vec) {
 			lock (_lock) {
 				InputProxyEntry proxy;
 				if (_sproxies.TryGetValue(id.Source, out proxy)) {
 					_etor.ContextCascadeInsert();
-					float ft, tt = (float)(vec.Time - _timeOrigins[id.Source.Handler]);
+					float ft, tt = (float)(_lockTime != null ? _lockTime.Value : (vec.Time - _timeOrigins[id.Source.Handler]));
 					if (!_vect.TryGetValue(id, out ft)) ft = tt;
 					if (vec.IsNull) {
 						_etor.ContextCascadeUpdate(_var_value, _nullsrc);
@@ -235,42 +238,48 @@ namespace Cryville.Crtr {
 			}
 		}
 		public void SyncTime(double time) {
-			foreach (var s in _sproxies.Keys) {
-				var h = s.Handler;
+			foreach (var s in _sproxies) {
+				var h = s.Key.Handler;
 				_timeOrigins[h] = h.GetCurrentTimestamp() - time;
 			}
 		}
 		public void ForceTick() {
-			foreach (var src in _sproxies.Keys) {
+			foreach (var s in _sproxies) {
+				var src = s.Key;
 				if (_activeCounts[src] == 0) {
-					OnInput(new InputIdentifier { Source = src, Id = 0 }, new InputVector(src.Handler.GetCurrentTimestamp()));
+					OnInput(new InputIdentifier { Source = src, Id = 0 }, new InputVector(_lockTime != null ? _lockTime.Value : src.Handler.GetCurrentTimestamp()));
 				}
 			}
 		}
 		public double GetTimestampAverage() {
 			double result = 0;
-			foreach (var src in _sproxies.Keys) {
+			foreach (var s in _sproxies) {
+				var src = s.Key;
 				result += src.Handler.GetCurrentTimestamp() - _timeOrigins[src.Handler];
 			}
 			return result / _sproxies.Count;
 		}
+		public void LockTime() { _lockTime = GetTimestampAverage(); }
+		public void UnlockTime() { _lockTime = null; }
 		#endregion
 	}
 
 	public class ProxyChangedEventArgs : EventArgs {
-		public string Name { get; private set; }
+		public Identifier Name { get; private set; }
 		public InputSource? Proxy { get; private set; }
 		public bool Used { get; private set; }
-		public ProxyChangedEventArgs(string name, InputSource? src, bool used) {
+		public bool Required { get; private set; }
+		public ProxyChangedEventArgs(Identifier name, InputSource? src, bool used, bool required) {
 			Name = name;
 			Proxy = src;
 			Used = used;
+			Required = required;
 		}
 	}
 
 	public class InputProxyEntry {
 		public InputSource? Source { get; set; }
-		public string Target { get; set; }
+		public Identifier Target { get; set; }
 		public byte[] Mapping { get; private set; }
 	}
 

Assets/Cryville/Crtr/Judge.cs

@@ -9,14 +9,15 @@ using System.Text.Formatting;
 namespace Cryville.Crtr {
 	public class Judge {
 		#region Data
+		readonly ChartPlayer _sys;
 		readonly PdtEvaluator _etor;
 		readonly PdtRuleset _rs;
-		readonly Dictionary<Identifier, float> ct
-			= new Dictionary<Identifier, float>();
 		readonly Dictionary<Identifier, List<JudgeEvent>> evs
 			= new Dictionary<Identifier, List<JudgeEvent>>();
 		readonly Dictionary<Identifier, List<JudgeEvent>> activeEvs
 			= new Dictionary<Identifier, List<JudgeEvent>>();
+		static readonly int _var_pause = IdentifierManager.SharedInstance.Request("pause");
+		readonly JudgeDefinition _judgePause;
 		public struct JudgeEvent {
 			public double StartTime { get; set; }
 			public double EndTime { get; set; }
@@ -32,27 +33,38 @@ namespace Cryville.Crtr {
 				return x.StartClip.CompareTo(y.StartClip);
 			}
 		}
-		public Judge(PdtRuleset rs) {
+		public Judge(ChartPlayer sys, PdtRuleset rs) {
+			_sys = sys;
 			_etor = ChartPlayer.etor;
 			_rs = rs;
 			_numsrc1 = new PropSrc.Float(() => _numbuf1);
 			_numsrc2 = new PropSrc.Float(() => _numbuf2);
 			_numsrc3 = new PropSrc.Float(() => _numbuf3);
 			_numsrc4 = new PropSrc.Float(() => _numbuf4);
+			_rs.judges.TryGetValue(new Identifier(_var_pause), out _judgePause);
+			foreach (var i in rs.inputs) {
+				var id = i.Key;
+				var l = new List<JudgeEvent>();
+				evs.Add(id, l);
+				activeEvs.Add(id, new List<JudgeEvent>());
+				if (_judgePause != null && id.Key == _var_pause) {
+					l.Add(new JudgeEvent {
+						StartTime = double.NegativeInfinity, EndTime = double.PositiveInfinity,
+						StartClip = double.NegativeInfinity, EndClip = double.PositiveInfinity,
+						Definition = _judgePause,
+					});
+				}
+			}
 			InitJudges();
 			InitScores();
 		}
 		public void Prepare(StampedEvent sev, NoteHandler handler) {
 			var tev = (Chart.Judge)sev.Unstamped;
+			if (tev.Id.Key == _var_pause) throw new InvalidOperationException("Cannot assign the special judge \"pause\" to notes");
 			Identifier input = default(Identifier);
 			ChartPlayer.etor.Evaluate(new PropOp.Identifier(v => input = new Identifier(v)), _rs.judges[tev.Id].input);
 			double st = sev.Time, et = st + sev.Duration;
-			List<JudgeEvent> list;
-			if (!evs.TryGetValue(input, out list)) {
-				ct.Add(input, 0);
-				evs.Add(input, list = new List<JudgeEvent>());
-				activeEvs.Add(input, new List<JudgeEvent>());
-			}
+			var list = evs[input];
 			var def = _rs.judges[tev.Id];
 			var ev = new JudgeEvent {
 				StartTime = st,
@@ -71,8 +83,9 @@ namespace Cryville.Crtr {
 		#region Judge
 		internal readonly Dictionary<int, int> judgeMap = new Dictionary<int, int>();
 		void InitJudges() {
-			foreach (var i in _rs.judges.Keys) {
-				judgeMap.Add(i.Key, IdentifierManager.SharedInstance.Request("judge_" + i.Name));
+			foreach (var i in _rs.judges) {
+				var id = i.Key;
+				judgeMap.Add(id.Key, IdentifierManager.SharedInstance.Request("judge_" + id.Name));
 			}
 		}
 		static bool _flag;
@@ -130,9 +143,12 @@ namespace Cryville.Crtr {
 					if (def.hit != null) _etor.Evaluate(_flagop, def.hit);
 					else _flag = true;
 					if (_flag) {
+						if (ev.Definition == _judgePause) _sys.TogglePause();
 						if (def.scores != null) UpdateScore(def.scores);
 						if (def.pass != null) Pass(ev, (ft + tt) / 2, def.pass);
-						actlist.RemoveAt(index);
+						if (def.persist != null) _etor.Evaluate(_flagop, def.persist);
+						else _flag = false;
+						if (!_flag) actlist.RemoveAt(index);
 						if (def.prop != 0 && actlist.Count > 0) {
 							index = BinarySearchFirst(actlist, (float)ev.StartClip, def.stack - def.prop);
 							if (index < 0) index = ~index;
@@ -203,7 +219,6 @@ namespace Cryville.Crtr {
 		readonly Dictionary<int, ScoreDefinition> scoreDefs = new Dictionary<int, ScoreDefinition>();
 		readonly Dictionary<int, float> scores = new Dictionary<int, float>();
 		readonly Dictionary<int, string> scoreStringCache = new Dictionary<int, string>();
-		readonly Dictionary<int, PropSrc> scoreStringSrcs = new Dictionary<int, PropSrc>();
 		readonly ArrayPool<byte> scoreStringPool = new ArrayPool<byte>();
 		readonly Dictionary<int, string> scoreFormatCache = new Dictionary<int, string>();
 		readonly TargetString scoreFullStr = new TargetString();
@@ -219,27 +234,25 @@ namespace Cryville.Crtr {
 				scoreDefs.Add(key, s.Value);
 				scores.Add(key, s.Value.init);
 				scoreStringCache.Add(scoreStringKeys[key], null);
-				scoreStringSrcs.Add(scoreStringKeys[key], new ScoreStringSrc(scoreStringPool, () => scores[key], scoreDefs[key].format));
+				scoreSrcs.Add(scoreStringKeys[key], new ScoreStringSrc(scoreStringPool, () => scores[key], scoreDefs[key].format));
 				scoreFormatCache[key] = string.Format("{{0:{0}}}", s.Value.format);
 			}
 		}
 		void InvalidateScore(int key) {
 			scoreSrcs[key].Invalidate();
 			scoreStringCache[scoreStringKeys[key]] = null;
-			scoreStringSrcs[scoreStringKeys[key]].Invalidate();
+			scoreSrcs[scoreStringKeys[key]].Invalidate();
 		}
 		public bool TryGetScoreSrc(int key, out PropSrc value) {
 			return scoreSrcs.TryGetValue(key, out value);
 		}
-		public bool TryGetScoreStringSrc(int key, out PropSrc value) {
-			return scoreStringSrcs.TryGetValue(key, out value);
-		}
 		public TargetString GetFullFormattedScoreString() {
 			bool flag = false;
 			scoreFullBuf.Clear();
-			foreach (var s in scores.Keys) {
-				scoreFullBuf.AppendFormat(flag ? "\n{0}: " : "{0}: ", (string)IdentifierManager.SharedInstance.Retrieve(s));
-				scoreFullBuf.AppendFormat(scoreFormatCache[s], scores[s]);
+			foreach (var s in scores) {
+				var id = s.Key;
+				scoreFullBuf.AppendFormat(flag ? "\n{0}: " : "{0}: ", (string)IdentifierManager.SharedInstance.Retrieve(id));
+				scoreFullBuf.AppendFormat(scoreFormatCache[id], scores[id]);
 				flag = true;
 			}
 			scoreFullStr.Length = scoreFullBuf.Count;
@@ -289,6 +302,7 @@ namespace Cryville.Crtr {
 		public Clip clip;
 		public PdtExpression input;
 		public PdtExpression hit;
+		public PdtExpression persist;
 		public Identifier[] pass;
 		public Identifier[] miss;
 		public Dictionary<ScoreOperation, PdtExpression> scores;

Assets/Cryville/Crtr/Master.cs

@@ -7,13 +7,8 @@ namespace Cryville.Crtr {
 		private GameObject m_menu;
 #pragma warning restore IDE0044
 
-		internal void ShowMenu() {
-			m_menu.SetActive(true);
-		}
-
-		internal void HideMenu() {
-			m_menu.SetActive(false);
-		}
+		internal void ShowMenu() { m_menu.SetActive(true); }
+		internal void HideMenu() { m_menu.SetActive(false); }
 
 		void OnApplicationQuit() {
 			Game.Shutdown();

Assets/Cryville/Crtr/Menu.cs

@@ -1,5 +1,7 @@
 using Cryville.Common.Unity.UI;
 using Cryville.Crtr.Browsing;
+using System.Collections.Generic;
+using TMPro;
 using UnityEngine;
 
 namespace Cryville.Crtr {
@@ -13,6 +15,10 @@ namespace Cryville.Crtr {
 		ProgressBar m_progressBar;
 		[SerializeField]
 		SettingsPanel m_settingsPanel;
+		[SerializeField]
+		TMP_Text m_title;
+		[SerializeField]
+		GameObject[] m_backBlockingObjects;
 #pragma warning restore IDE0044
 
 		int frameIndex = 2;
@@ -23,6 +29,7 @@ namespace Cryville.Crtr {
 			Game.Init();
 			transform.parent.Find("Canvas/Contents").gameObject.SetActive(true);
 			m_settingsPanel.Target = Settings.Default;
+			PushTitle("Chart Browser");
 		}
 		void Update() {
 			if (!initialized) {
@@ -54,9 +61,20 @@ namespace Cryville.Crtr {
 		}
 #pragma warning restore IDE0051
 
+		readonly Stack<string> _uiStack = new Stack<string>();
+		public void PushTitle(string title) {
+			_uiStack.Push(title);
+			m_title.SetText(title);
+		}
 		public void Back() {
+			foreach (var obj in m_backBlockingObjects) {
+				if (obj.activeInHierarchy) return;
+			}
 			if (m_browserMaster.Back()) return;
 			m_targetAnimator.SetTrigger("G_Back");
+			if (_uiStack.Count <= 1) return;
+			_uiStack.Pop();
+			m_title.SetText(_uiStack.Peek());
 		}
 		public void Quit() {
 			Application.Quit();

Assets/Cryville/Crtr/MeshWrapper.cs

@@ -26,10 +26,8 @@ namespace Cryville.Crtr {
 			get;
 			private set;
 		}
-		public Material NewMaterial {
-			get {
-				return Material.Instantiate(GenericResources.Materials["-SpriteMat"]);
-			}
+		public static Material NewMaterial() {
+			return Material.Instantiate(GenericResources.Materials["-SpriteMat"]);
 		}
 		public void Init(Transform parent) {
 			MeshObject = new GameObject("__mesh__");
@@ -41,12 +39,10 @@ namespace Cryville.Crtr {
 				MeshObject.AddComponent<MeshRenderer>();
 			MeshFilter = MeshObject.GetComponent<MeshFilter>();
 			Renderer = MeshObject.GetComponent<Renderer>();
-			Renderer.material = NewMaterial;
 			Initialized = true;
 		}
 		public void Destroy() {
 			Mesh.Destroy(Mesh);
-			if (Renderer.material != null) Material.Destroy(Renderer.material);
 			GameObject.Destroy(MeshObject);
 		}
 	}

Assets/Cryville/Crtr/Motion.cs

@@ -361,7 +361,7 @@ namespace Cryville.Crtr {
 		public abstract float DelerpWith(Vector start, Vector value);
 		public abstract bool IsZero();
 		public override abstract string ToString();
-		public abstract float[] ToArray();
+		public abstract unsafe void ToArray(float* arr);
 
 		public Vector Clone() {
 			return (Vector)MemberwiseClone();
@@ -442,8 +442,8 @@ namespace Cryville.Crtr {
 			return Value.ToString(CultureInfo.InvariantCulture);
 		}
 
-		public override float[] ToArray() {
-			return new float[] { Value };
+		public override unsafe void ToArray(float* arr) {
+			arr[0] = Value;
 		}
 	}
 
@@ -504,8 +504,8 @@ namespace Cryville.Crtr {
 			return Value.ToString(CultureInfo.InvariantCulture);
 		}
 
-		public override float[] ToArray() {
-			return new float[] { Value };
+		public override unsafe void ToArray(float* arr) {
+			arr[0] = Value;
 		}
 	}
 
@@ -566,8 +566,8 @@ namespace Cryville.Crtr {
 			return Value.ToString(CultureInfo.InvariantCulture);
 		}
 
-		public override float[] ToArray() {
-			return new float[] { Value };
+		public override unsafe void ToArray(float* arr) {
+			arr[0] = Value;
 		}
 	}
 
@@ -669,8 +669,9 @@ namespace Cryville.Crtr {
 			return ToString(w, h);
 		}
 
-		public override float[] ToArray() {
-			return new float[] { w.Value, h.Value };
+		public override unsafe void ToArray(float* arr) {
+			arr[0] = w.Value;
+			arr[1] = h.Value;
 		}
 	}
 
@@ -764,8 +765,10 @@ namespace Cryville.Crtr {
 			);
 		}
 
-		public override float[] ToArray() {
-			return new float[] { x.Value, y.Value, z.Value };
+		public override unsafe void ToArray(float* arr) {
+			arr[0] = x.Value;
+			arr[1] = y.Value;
+			arr[2] = z.Value;
 		}
 	}
 
@@ -845,8 +848,11 @@ namespace Cryville.Crtr {
 			return VecPtComp.ToString(xw, xh) + "," + VecPtComp.ToString(yw, yh);
 		}
 
-		public override float[] ToArray() {
-			return new float[] { xw.Value, xh.Value, yw.Value, yh.Value };
+		public override unsafe void ToArray(float* arr) {
+			arr[0] = xw.Value;
+			arr[1] = xh.Value;
+			arr[2] = yw.Value;
+			arr[3] = yh.Value;
 		}
 	}
 
@@ -911,11 +917,11 @@ namespace Cryville.Crtr {
 		}
 
 		public override bool IsZero() {
-			if (!xw.Equals(0)) return false;
-			if (!xh.Equals(0)) return false;
-			if (!yw.Equals(0)) return false;
-			if (!yh.Equals(0)) return false;
-			if (!z.Equals(0)) return false;
+			if (xw == null || xw != 0) return false;
+			if (xh == null || xh != 0) return false;
+			if (yw == null || yw != 0) return false;
+			if (xh == null || xh != 0) return false;
+			if (z == null || z != 0) return false;
 			return true;
 		}
 
@@ -936,40 +942,25 @@ namespace Cryville.Crtr {
 			return VecPtComp.ToString(xw, xh) + "," + VecPtComp.ToString(yw, yh) + "," + (z != null ? z.Value.ToString(CultureInfo.InvariantCulture) : "");
 		}
 
-		public override float[] ToArray() {
-			return new float[] { xw.Value, xh.Value, yw.Value, yh.Value, z.Value };
+		public override unsafe void ToArray(float* arr) {
+			arr[0] = xw.Value;
+			arr[1] = xh.Value;
+			arr[2] = yw.Value;
+			arr[3] = yh.Value;
+			arr[4] = z.Value;
 		}
 	}
 
-	public abstract class VectorSrc : PropSrc {
+	public class VectorSrc : PropSrc.FixedBuffer {
 		protected readonly Func<Vector> _cb;
-		public VectorSrc(Func<Vector> cb, int type) : base(type) { _cb = cb; }
-		public static VectorSrc Construct(Func<Vector> cb) {
-			if (cb().Dimension == 1) return new INumber(cb);
-			else return new IVector(cb);
-		}
-		class INumber : VectorSrc {
-			public INumber(Func<Vector> cb) : base(cb, PdtInternalType.Number) { }
-			protected override unsafe void InternalGet() {
-				var arr = _cb().ToArray();
-				buf = new byte[sizeof(float)];
-				fixed (byte* ptr = buf) {
-					*(float*)ptr = arr[0];
-				}
-			}
-		}
-		class IVector : VectorSrc {
-			public IVector(Func<Vector> cb) : base(cb, PdtInternalType.Vector) { }
-			protected override unsafe void InternalGet() {
-				var arr = _cb().ToArray();
-				buf = new byte[sizeof(float) * arr.Length + sizeof(int)];
-				fixed (byte* rptr = buf) {
-					var ptr = (float*)rptr;
-					for (int i = 0; i < arr.Length; i++, ptr++) {
-						*ptr = arr[i];
-					}
-					*(int*)ptr = PdtInternalType.Number;
-				}
+		public VectorSrc(Func<Vector> cb) : base(PdtInternalType.Vector, 8 * sizeof(float) + sizeof(int)) { _cb = cb; }
+		protected override unsafe void InternalGet() {
+			var v = _cb();
+			if (v.Dimension > 8) throw new NotSupportedException("Vector dimension too large");
+			fixed (byte* rptr = buf) {
+				var ptr = (float*)rptr;
+				v.ToArray(ptr);
+				*(int*)(ptr + v.Dimension) = PdtInternalType.Number;
 			}
 		}
 	}

Assets/Cryville/Crtr/NoteHandler.cs

@@ -50,6 +50,7 @@ namespace Cryville.Crtr {
 
 		public override void PreInit() {
 			base.PreInit();
+			coeffs = new ColumnVector<float>(gh.TrackCount);
 			foreach (var j in Event.judges) {
 				judges.Add(j, new JudgeState(this, j.Id.Key));
 			}
@@ -57,7 +58,7 @@ namespace Cryville.Crtr {
 		public override void Init() {
 			base.Init();
 			sgos = gogroup.GetComponentsInChildren<SectionalGameObject>();
-			foreach (var judge in judges.Values) judge.InitPropSrcs();
+			foreach (var judge in judges) judge.Value.InitPropSrcs();
 		}
 
 		public override void StartPhysicalUpdate(ContainerState s) {
@@ -66,7 +67,7 @@ namespace Cryville.Crtr {
 				TransformAwake(s);
 			}
 		}
-		public override void StartGraphicalUpdate(ContainerState s) {
+		protected override void StartGraphicalUpdate(ContainerState s) {
 			base.StartGraphicalUpdate(s);
 			TransformAwake(s);
 			if (gogroup) {
@@ -92,12 +93,10 @@ namespace Cryville.Crtr {
 		}
 
 		public override void Update(ContainerState s, StampedEvent ev) {
-			base.Update(s, ev);
 			if (s.CloneType <= 2) {
 				Position = GetFramePoint(s.Parent, s.Track);
 				Rotation = GetFrameRotation(s.Parent, s.Track);
-				if (s.CloneType == 2) {
-					if (!gogroup || !Event.IsLong) return;
+				if (s.CloneType == 2 && gogroup && Event.IsLong) {
 					foreach (var i in sgos)
 						i.AppendPoint(Position, Rotation);
 				}
@@ -113,9 +112,22 @@ namespace Cryville.Crtr {
 					ChartPlayer.etor.ContextEvent = null;
 				}
 			}
+			if (s.CloneType == 2 && ev != null && ev.Unstamped is Chart.Judge) {
+				var anchor = judges[(Chart.Judge)ev.Unstamped].StaticAnchor;
+#if UNITY_5_6_OR_NEWER
+				anchor.Transform.SetPositionAndRotation(Position, Rotation);
+#else
+				anchor.Transform.position = Position;
+				anchor.Transform.rotation = Rotation;
+#endif
+				OpenAnchor(anchor);
+				base.Update(s, ev);
+				CloseAnchor();
+			}
+			else base.Update(s, ev);
 		}
 
-		public override void EndGraphicalUpdate(ContainerState s) {
+		protected override void EndGraphicalUpdate(ContainerState s) {
 			if (gogroup) {
 				foreach (var i in sgos) i.Seal();
 			}
@@ -132,6 +144,7 @@ namespace Cryville.Crtr {
 		}
 
 		readonly List<Vector3> ctrl = new List<Vector3>(2);
+		ColumnVector<float> coeffs;
 		Vector3 GetFrame(ContainerState state, float track, Func<ContainerState, Vector3> func) {
 			// TODO
 			int id = Mathf.FloorToInt(track);
@@ -160,12 +173,8 @@ namespace Cryville.Crtr {
 				}
 				if (ctrl.Count == 0) {
 					var frame = gh.GetCurrentFrame(func);
-					return frame.Dot(
-						ColumnVector<float>.WithPolynomialCoefficients(
-							frame.Size, track
-						),
-						Vector3Operator.Instance
-					);
+					ColumnVector<float>.FillWithPolynomialCoefficients(coeffs, track);
+					return frame.Dot(coeffs, Vector3Operator.Instance);
 				}
 				else if (ctrl.Count == 1) {
 					return nt * (nt * p1 + t * (ctrl[0] + p1)) + t * t * p2;

Assets/Cryville/Crtr/PdtBinder.cs

@@ -0,0 +1,91 @@
+using Cryville.Common;
+using Cryville.Common.Pdt;
+using System;
+using System.Globalization;
+using System.Text.RegularExpressions;
+using SIdentifier = Cryville.Common.Identifier;
+
+namespace Cryville.Crtr {
+	public class PdtBinder : EmptyBinder {
+		public override object ChangeType(object value, Type type, CultureInfo culture) {
+			if (value is PdtExpression) {
+				var exp = (PdtExpression)value;
+				if (type.Equals(typeof(bool))) {
+					bool result = false;
+					ChartPlayer.etor.Evaluate(new PropOp.Boolean(r => result = r), exp);
+					return result;
+				}
+				else if (type.Equals(typeof(int))) {
+					int result = 0;
+					ChartPlayer.etor.Evaluate(new PropOp.Integer(r => result = r), exp);
+					return result;
+				}
+				else if (type.Equals(typeof(float))) {
+					float result = 0;
+					ChartPlayer.etor.Evaluate(new PropOp.Float(r => result = r), exp);
+					return result;
+				}
+				else if (type.Equals(typeof(string))) {
+					string result = default(string);
+					ChartPlayer.etor.Evaluate(new PropOp.String(r => result = r), exp);
+					return result;
+				}
+				else if (type.Equals(typeof(Clip))) {
+					Clip result = default(Clip);
+					ChartPlayer.etor.Evaluate(new PropOp.Clip(r => result = r), exp);
+					return result;
+				}
+				else if (type.Equals(typeof(Identifier))) {
+					Identifier result = default(Identifier);
+					ChartPlayer.etor.Evaluate(new pop_identstr(r => result = r), exp);
+					return result;
+				}
+				else if (type.Equals(typeof(Identifier[]))) {
+					Identifier[] result = null;
+					ChartPlayer.etor.Evaluate(new pop_identstrarr(r => result = r), exp);
+					return result;
+				}
+			}
+			else if (value is string) {
+				var exp = (string)value;
+				if (type.Equals(typeof(Identifier))) {
+					return new Identifier(exp);
+				}
+				else if (type == typeof(ScoreOperation)) {
+					var m = Regex.Match(exp, @"^(\S+)\s*?(\S+)?$");
+					var name = new Identifier(m.Groups[1].Value);
+					if (!m.Groups[2].Success) return new ScoreOperation { name = name };
+					var op = new Identifier(m.Groups[2].Value);
+					return new ScoreOperation { name = name, op = op };
+				}
+			}
+			return base.ChangeType(value, type, culture);
+		}
+#pragma warning disable IDE1006
+		class pop_identstr : PropOp {
+			readonly Action<SIdentifier> _cb;
+			public pop_identstr(Action<SIdentifier> cb) { _cb = cb; }
+			protected override void Execute() {
+				var op = GetOperand(0);
+				if (op.Type == PdtInternalType.Undefined) _cb(new SIdentifier(op.AsIdentifier()));
+				else if (op.Type == PdtInternalType.String) _cb(new SIdentifier(op.AsString()));
+				else throw new InvalidCastException("Not an identifier or string");
+			}
+		}
+		class pop_identstrarr : PdtOperator {
+			readonly Action<SIdentifier[]> _cb;
+			public pop_identstrarr(Action<SIdentifier[]> cb) : base(16) { _cb = cb; }
+			protected override void Execute() {
+				var result = new SIdentifier[LoadedOperandCount];
+				for (int i = 0; i < LoadedOperandCount; i++) {
+					var op = GetOperand(i);
+					if (op.Type != PdtInternalType.Undefined)
+						throw new InvalidCastException("Not an identifier");
+					result[i] = new SIdentifier(op.AsIdentifier());
+				}
+				_cb(result);
+			}
+		}
+#pragma warning restore IDE1006
+	}
+}

Assets/Cryville/Crtr/PdtBinder.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 7ba16fc9fce48644b9c7bd49f2c9121d
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Cryville/Crtr/PdtEvaluator.cs

@@ -13,6 +13,8 @@ namespace Cryville.Crtr {
 
 		static readonly byte[] _nullbuf = new byte[0];
 		readonly byte[] _numbuf = new byte[4];
+		readonly PropSrc _vecsrc;
+		Vector _vec;
 		static readonly int _var_w = IdentifierManager.SharedInstance.Request("w");
 		static readonly int _var_h = IdentifierManager.SharedInstance.Request("h");
 		static readonly int _var_current_time = IdentifierManager.SharedInstance.Request("current_time");
@@ -32,19 +34,15 @@ namespace Cryville.Crtr {
 					prop.Get(out type, out value);
 				}
 				else if (ContextState != null && ChartPlayer.motionRegistry.ContainsKey(id)) {
-					var vec = ContextState.GetRawValue(id);
-					VectorSrc.Construct(() => vec).Get(out type, out value);
+					_vec = ContextState.GetRawValue(id);
+					_vecsrc.Invalidate();
+					_vecsrc.Get(out type, out value);
 				}
-				else if (ContextState != null && name == _var_current_time) {
-					LoadNum((float)ContextState.rootPrototype.Time);
-					type = PdtInternalType.Number;
-					value = _numbuf;
-				}
-				else if (ContextJudge != null && ContextJudge.TryGetScoreSrc(name, out prop)) {
+				else if (ContextState != null && ContextState.Handler.PropSrcs.TryGetValue(name, out prop)) {
 					prop.Get(out type, out value);
 					RevokePotentialConstant();
 				}
-				else if (ContextJudge != null && ContextJudge.TryGetScoreStringSrc(name, out prop)) {
+				else if (ContextJudge != null && ContextJudge.TryGetScoreSrc(name, out prop)) {
 					prop.Get(out type, out value);
 					RevokePotentialConstant();
 				}
@@ -109,6 +107,13 @@ namespace Cryville.Crtr {
 		public Judge ContextJudge { private get; set; }
 		public PropSrc ContextSelfValue { private get; set; }
 
+		readonly Stack<int> ContextCascadeBlocks = new Stack<int>();
+		public void ContextCascadeInsertBlock() {
+			ContextCascadeBlocks.Push(_cascadeHeight);
+		}
+		public void ContextCascadeDiscardBlock() {
+			ContextCascadeBlocks.Pop();
+		}
 		readonly Dictionary<int, PropSrc>[] ContextCascade = new Dictionary<int, PropSrc>[256];
 		int _cascadeHeight;
 		public void ContextCascadeInsert() {
@@ -123,7 +128,7 @@ namespace Cryville.Crtr {
 		}
 		public PropSrc ContextCascadeLookup(int name) {
 			PropSrc result;
-			for (int i = _cascadeHeight - 1; i >= 0; i--) {
+			for (int i = _cascadeHeight - 1; i >= ContextCascadeBlocks.Peek(); i--) {
 				Dictionary<int, PropSrc> cas = ContextCascade[i];
 				if (cas.TryGetValue(name, out result)) {
 					return result;
@@ -136,7 +141,9 @@ namespace Cryville.Crtr {
 		}
 
 		public PdtEvaluator() {
+			ContextCascadeBlocks.Push(0);
 			for (int i = 0; i < ContextCascade.Length; i++) ContextCascade[i] = new Dictionary<int, PropSrc>();
+			_vecsrc = new VectorSrc(() => _vec);
 
 			_ctxops.Add(IdentifierManager.SharedInstance.Request("screen_edge"), new func_screen_edge(() => ContextTransform));
 			_ctxops.Add(IdentifierManager.SharedInstance.Request("int"), new func_int(() => ContextSelfValue));
@@ -172,6 +179,7 @@ namespace Cryville.Crtr {
 
 			_shortops.Add(new PdtOperatorSignature("frame_seq", 3), new func_frame_seq());
 			_shortops.Add(new PdtOperatorSignature("in_area", 1), new func_in_area());
+			_shortops.Add(new PdtOperatorSignature("interval", 3), new func_interval());
 			_shortops.Add(new PdtOperatorSignature("is", 2), new func_is());
 		}
 		#region Operators
@@ -355,6 +363,16 @@ namespace Cryville.Crtr {
 				hit.CopyTo(ret);
 			}
 		}
+		class func_interval : PdtOperator {
+			public func_interval() : base(3) { }
+			protected override unsafe void Execute() {
+				var value = GetOperand(0).AsNumber();
+				var min = GetOperand(1).AsNumber();
+				var max = GetOperand(2).AsNumber();
+				var ret = GetReturnFrame(PdtInternalType.Number, sizeof(float));
+				ret.SetNumber((value - min) * (max - value));
+			}
+		}
 		class func_is : PdtOperator {
 			public func_is() : base(2) { }
 			protected override unsafe void Execute() {
@@ -379,9 +397,8 @@ namespace Cryville.Crtr {
 				var ray = new Ray(ctx.position, ctx.rotation * Vector3.forward);
 				ChartPlayer.frustumPlanes[(int)GetOperand(0).AsNumber()].Raycast(ray, out dist);
 				var ret = GetReturnFrame(PdtInternalType.Vector, sizeof(Vector3) + sizeof(int));
-				var ptr = (Vector3*)ret.TrustedAsOfLength(sizeof(Vector3) + sizeof(int));
-				*ptr++ = ray.GetPoint(dist);
-				*(int*)ptr = PdtInternalType.Number;
+				ret.Set(ray.GetPoint(dist));
+				ret.SetArraySuffix(PdtInternalType.Number);
 			}
 		}
 		class func_int : PdtOperator {
@@ -546,7 +563,7 @@ namespace Cryville.Crtr {
 				if (src == null) throw new ArgumentNullException("src");
 				int type; byte[] value;
 				src.Get(out type, out value);
-				if (type != PdtInternalType.Number)
+				if (type != PdtInternalType.Number && type != PdtInternalType.Vector)
 					throw new ArgumentException("Not a number");
 				fixed (byte* ptr = value) {
 					return *(float*)ptr;

Assets/Cryville/Crtr/PropOp.cs

@@ -5,7 +5,10 @@ using System.Collections.Generic;
 using System.Reflection;
 using RBeatTime = Cryville.Crtr.BeatTime;
 using RClip = Cryville.Crtr.Clip;
+using RColor = UnityEngine.Color;
 using RTargetString = Cryville.Common.Buffers.TargetString;
+using RVector2 = UnityEngine.Vector2;
+using RVector3 = UnityEngine.Vector3;
 
 namespace Cryville.Crtr {
 	public abstract class PropOp : PdtOperator {
@@ -57,19 +60,35 @@ namespace Cryville.Crtr {
 				_cb(GetOperand(0).AsString());
 			}
 		}
+		public class StringArray : PropOp {
+			readonly Action<string[]> _cb;
+			public StringArray(Action<string[]> cb) { _cb = cb; }
+			protected unsafe override void Execute() {
+				var op = GetOperand(0);
+				int arrtype; int len;
+				op.GetArraySuffix(out arrtype, out len);
+				if (arrtype != PdtInternalType.String) throw new InvalidCastException("Not an array of strings");
+				var result = new string[len];
+				int o = 0;
+				for (int i = 0; i < len; i++) {
+					string v = op.AsString(o);
+					o += v.Length * sizeof(char) + sizeof(int);
+					result[i] = v;
+				}
+				_cb(result);
+			}
+		}
 		public class TargetString : PropOp {
 			readonly Func<RTargetString> _cb;
 			public TargetString(Func<RTargetString> cb) { _cb = cb; }
-			protected override unsafe void Execute() {
+			protected override void Execute() {
 				var target = _cb();
 				var op = GetOperand(0);
 				if (op.Type != PdtInternalType.String) throw new ArgumentException("Not a string");
-				var ptr = (byte*)op.TrustedAsOfLength(op.Length);
-				var len = *(int*)ptr;
+				int len = op.As<int>();
 				target.Length = len;
-				var cptr = (char*)(ptr + sizeof(int));
 				for (int i = 0; i < len; i++)
-					target[i] = cptr[i];
+					target[i] = op.As<char>(sizeof(int) + i * sizeof(char));
 				target.Validate();
 			}
 		}
@@ -105,22 +124,22 @@ namespace Cryville.Crtr {
 			public BeatTime(Action<RBeatTime> cb) { _cb = cb; }
 			protected override unsafe void Execute() {
 				var o = GetOperand(0);
-				_cb(*(RBeatTime*)o.TrustedAsOfLength(sizeof(RBeatTime)));
+				_cb(o.As<RBeatTime>());
 			}
 		}
 		public class Vector2 : PropOp {
-			readonly Action<UnityEngine.Vector2> _cb;
-			public Vector2(Action<UnityEngine.Vector2> cb) { _cb = cb; }
+			readonly Action<RVector2> _cb;
+			public Vector2(Action<RVector2> cb) { _cb = cb; }
 			protected override unsafe void Execute() {
 				var o = GetOperand(0);
 				switch ((o.Length - 4) / 4) {
 					case 0: // Number
 					case 1: // Array[1]
 						float num = o.AsNumber();
-						_cb(new UnityEngine.Vector2(num, num));
+						_cb(new RVector2(num, num));
 						break;
 					case 2:
-						_cb(*(UnityEngine.Vector2*)o.TrustedAsOfLength(sizeof(UnityEngine.Vector2)));
+						_cb(o.As<RVector2>());
 						break;
 					default:
 						throw new InvalidOperationException("Invalid array size");
@@ -128,21 +147,21 @@ namespace Cryville.Crtr {
 			}
 		}
 		public class Vector3 : PropOp {
-			readonly Action<UnityEngine.Vector3> _cb;
-			public Vector3(Action<UnityEngine.Vector3> cb) { _cb = cb; }
+			readonly Action<RVector3> _cb;
+			public Vector3(Action<RVector3> cb) { _cb = cb; }
 			protected override unsafe void Execute() {
 				var o = GetOperand(0);
 				switch ((o.Length - 4) / 4) {
 					case 0: // Number
 					case 1: // Array[1]
 						float num = o.AsNumber();
-						_cb(new UnityEngine.Vector3(num, num));
+						_cb(new RVector3(num, num));
 						break;
 					case 2:
-						_cb(*(UnityEngine.Vector2*)o.TrustedAsOfLength(sizeof(UnityEngine.Vector2)));
+						_cb(o.As<RVector2>());
 						break;
 					case 3:
-						_cb(*(UnityEngine.Vector3*)o.TrustedAsOfLength(sizeof(UnityEngine.Vector3)));
+						_cb(o.As<RVector3>());
 						break;
 					default:
 						throw new InvalidOperationException("Invalid array size");
@@ -150,17 +169,16 @@ namespace Cryville.Crtr {
 			}
 		}
 		public class Color : PropOp {
-			readonly Action<UnityEngine.Color> _cb;
-			public Color(Action<UnityEngine.Color> cb) { _cb = cb; }
+			readonly Action<RColor> _cb;
+			public Color(Action<RColor> cb) { _cb = cb; }
 			protected override unsafe void Execute() {
 				var o = GetOperand(0);
 				switch ((o.Length - 4) / 4) {
 					case 3:
-						var ptr = (float*)o.TrustedAsOfLength(sizeof(float) * 3);
-						_cb(new UnityEngine.Color(ptr[0], ptr[1], ptr[2]));
+						_cb(new RColor(o.As<float>(), o.As<float>(sizeof(float)), o.As<float>(2 * sizeof(float))));
 						break;
 					case 4:
-						_cb(*(UnityEngine.Color*)o.TrustedAsOfLength(sizeof(UnityEngine.Color)));
+						_cb(o.As<RColor>());
 						break;
 					default:
 						throw new InvalidOperationException("Invalid array size");

Assets/Cryville/Crtr/PropSrc.cs

@@ -43,6 +43,7 @@ namespace Cryville.Crtr {
 				buf[0] = _cb() ? (byte)1 : (byte)0;
 			}
 		}
+		public static readonly PropSrc Error = new Arbitrary(PdtInternalType.Error, new byte[0]);
 		public class Float : FixedBuffer {
 			readonly Func<float> _cb;
 			public Float(Func<float> cb) : base(PdtInternalType.Number, 4) { _cb = cb; }

Assets/Cryville/Crtr/Ruleset.cs

@@ -4,11 +4,8 @@ using Cryville.Crtr.Browsing;
 using Newtonsoft.Json;
 using System;
 using System.Collections.Generic;
-using System.Globalization;
 using System.IO;
 using System.Text;
-using System.Text.RegularExpressions;
-using SIdentifier = Cryville.Common.Identifier;
 
 namespace Cryville.Crtr {
 	public class Ruleset : MetaInfo {
@@ -25,35 +22,38 @@ namespace Cryville.Crtr {
 		public void LoadPdt(DirectoryInfo dir) {
 			using (StreamReader pdtreader = new StreamReader(dir.FullName + "/" + data + ".pdt", Encoding.UTF8)) {
 				var src = pdtreader.ReadToEnd();
-				Root = (PdtRuleset)new RulesetInterpreter(src, null).Interpret();
+				Root = (PdtRuleset)new RulesetInterpreter(src, null).Interpret(typeof(PdtRuleset));
 			}
 		}
 	}
 
-	[Binder(typeof(PdtRulesetBinder))]
+	[Binder(typeof(PdtBinder))]
 	public class PdtRuleset {
 		public Dictionary<Identifier, InputDefinition> inputs;
 		public Dictionary<Identifier, JudgeDefinition> judges;
 		public Dictionary<Identifier, ScoreDefinition> scores;
 		public Constraint constraints;
 		public void Optimize(PdtEvaluatorBase etor) {
-			foreach (var i in inputs.Values) {
-				if (i.pass != null) foreach (var e in i.pass.Values) {
-					etor.Optimize(e);
+			foreach (var i in inputs) {
+				var input = i.Value;
+				if (input.pass != null) foreach (var e in input.pass) {
+					etor.Optimize(e.Value);
 				}
 			}
-			foreach (var j in judges.Values) {
-				if (j.hit != null) etor.Optimize(j.hit);
-				if (j.scores != null) {
-					foreach (var s in j.scores) {
+			foreach (var j in judges) {
+				var judge = j.Value;
+				if (judge.hit != null) etor.Optimize(judge.hit);
+				if (judge.scores != null) {
+					foreach (var s in judge.scores) {
 						if (s.Key.op != default(Identifier))
 							etor.PatchCompound(s.Key.name.Key, s.Key.op.Key, s.Value);
 						etor.Optimize(s.Value);
 					}
 				}
 			}
-			foreach (var s in scores.Values) {
-				if (s.value != null) etor.Optimize(s.value);
+			foreach (var s in scores) {
+				var score = s.Value;
+				if (score.value != null) etor.Optimize(score.value);
 			}
 			constraints.Optimize(etor);
 		}
@@ -68,8 +68,8 @@ namespace Cryville.Crtr {
 		[PropertyList]
 		public Dictionary<PropertyKey, PdtExpression> Properties = new Dictionary<PropertyKey, PdtExpression>();
 		public void Optimize(PdtEvaluatorBase etor) {
-			foreach (var e in Properties.Values) {
-				etor.Optimize(e);
+			foreach (var e in Properties) {
+				etor.Optimize(e.Value);
 			}
 			foreach (var e in Elements) {
 				e.Key.Optimize(etor);
@@ -126,88 +126,6 @@ namespace Cryville.Crtr {
 		Property,
 		Variable,
 	}
-	public class PdtRulesetBinder : EmptyBinder {
-		public override object ChangeType(object value, Type type, CultureInfo culture) {
-			if (value is PdtExpression) {
-				var exp = (PdtExpression)value;
-				if (type.Equals(typeof(bool))) {
-					bool result = false;
-					ChartPlayer.etor.Evaluate(new PropOp.Boolean(r => result = r), exp);
-					return result;
-				}
-				else if (type.Equals(typeof(int))) {
-					int result = 0;
-					ChartPlayer.etor.Evaluate(new PropOp.Integer(r => result = r), exp);
-					return result;
-				}
-				else if (type.Equals(typeof(float))) {
-					float result = 0;
-					ChartPlayer.etor.Evaluate(new PropOp.Float(r => result = r), exp);
-					return result;
-				}
-				else if (type.Equals(typeof(string))) {
-					string result = default(string);
-					ChartPlayer.etor.Evaluate(new PropOp.String(r => result = r), exp);
-					return result;
-				}
-				else if (type.Equals(typeof(Clip))) {
-					Clip result = default(Clip);
-					ChartPlayer.etor.Evaluate(new PropOp.Clip(r => result = r), exp);
-					return result;
-				}
-				else if (type.Equals(typeof(Identifier))) {
-					Identifier result = default(Identifier);
-					ChartPlayer.etor.Evaluate(new pop_identstr(r => result = r), exp);
-					return result;
-				}
-				else if (type.Equals(typeof(Identifier[]))) {
-					Identifier[] result = null;
-					ChartPlayer.etor.Evaluate(new pop_identstrarr(r => result = r), exp);
-					return result;
-				}
-			}
-			else if (value is string) {
-				var exp = (string)value;
-				if (type.Equals(typeof(Identifier))) {
-					return (Identifier)exp;
-				}
-				else if (type == typeof(ScoreOperation)) {
-					var m = Regex.Match(exp, @"^(\S+)\s*?(\S+)?$");
-					var name = new Identifier(m.Groups[1].Value);
-					if (!m.Groups[2].Success) return new ScoreOperation { name = name };
-					var op = new Identifier(m.Groups[2].Value);
-					return new ScoreOperation { name = name, op = op };
-				}
-			}
-			return base.ChangeType(value, type, culture);
-		}
-#pragma warning disable IDE1006
-		class pop_identstr : PropOp {
-			readonly Action<SIdentifier> _cb;
-			public pop_identstr(Action<SIdentifier> cb) { _cb = cb; }
-			protected override void Execute() {
-				var op = GetOperand(0);
-				if (op.Type == PdtInternalType.Undefined) _cb(new SIdentifier(op.AsIdentifier()));
-				else if (op.Type == PdtInternalType.String) _cb(new SIdentifier(op.AsString()));
-				else throw new InvalidCastException("Not an identifier or string");
-			}
-		}
-		class pop_identstrarr : PdtOperator {
-			readonly Action<SIdentifier[]> _cb;
-			public pop_identstrarr(Action<SIdentifier[]> cb) : base(16) { _cb = cb; }
-			protected override void Execute() {
-				var result = new SIdentifier[LoadedOperandCount];
-				for (int i = 0; i < LoadedOperandCount; i++) {
-					var op = GetOperand(i);
-					if (op.Type != PdtInternalType.Undefined)
-						throw new InvalidCastException("Not an identifier");
-					result[i] = new SIdentifier(op.AsIdentifier());
-				}
-				_cb(result);
-			}
-		}
-#pragma warning restore IDE1006
-	}
 	public class RulesetViolationException : Exception {
 		public RulesetViolationException() { }
 		public RulesetViolationException(string message) : base(message) { }

Assets/Cryville/Crtr/RulesetInterpreter.cs

@@ -5,7 +5,7 @@ using System.Reflection;
 
 namespace Cryville.Crtr {
 	internal class RulesetInterpreter : PdtInterpreter {
-		public RulesetInterpreter(string src, Binder binder) : base(src, typeof(PdtRuleset), binder) { }
+		public RulesetInterpreter(string src, Binder binder) : base(src, binder) { }
 
 		readonly List<RulesetSelector> s = new List<RulesetSelector>();
 		readonly List<string> a = new List<string>();

Assets/Cryville/Crtr/Settings.cs

@@ -6,7 +6,7 @@ using RangeAttribute = Cryville.Common.ComponentModel.RangeAttribute;
 namespace Cryville.Crtr {
 	public class Settings {
 		[Category("graphics")]
-		[LogarithmicScale][Step(0.5f)][Precision(1e-2)]
+		[LogarithmicScale][Range(0.01f, 20f)][Step(0.5f)][Precision(1e-2)]
 		public float BackwardClippingDistance {
 			get {
 				return PlayerPrefs.GetFloat("BackwardClippingDistance", 0.2f);
@@ -61,6 +61,17 @@ namespace Cryville.Crtr {
 			}
 		}
 
+		[Category("gameplay")]
+		[Step(0.01f)][Precision(1e-3)]
+		public float GraphicalOffset {
+			get {
+				return PlayerPrefs.GetFloat("GraphicalOffset", 0);
+			}
+			set {
+				PlayerPrefs.SetFloat("GraphicalOffset", value);
+			}
+		}
+
 		[Browsable(false)]
 		public string LastRunVersion {
 			get {
@@ -120,7 +131,7 @@ namespace Cryville.Crtr {
 		}
 
 		[Category("graphics")]
-		[LogarithmicScale][Step(0.5f)][Precision(1e-1)]
+		[LogarithmicScale][Range(0.1f, 200f)][Step(0.5f)][Precision(1e-1)]
 		public float RenderDistance {
 			get {
 				return PlayerPrefs.GetFloat("RenderDistance", 4);
@@ -154,8 +165,8 @@ namespace Cryville.Crtr {
 		}
 
 		[Browsable(false)]
-		[Category("gameplay")]
-		[Description("(Not implemented yet)")]
+		[Category("debug")]
+		[Range(0, float.PositiveInfinity)][Step(10f)][Precision(1e-1)]
 		public float StartOffset {
 			get {
 				return PlayerPrefs.GetFloat("StartOffset", 0);

Assets/Cryville/Crtr/Skin.cs

@@ -1,6 +1,8 @@
+using Cryville.Common;
 using Cryville.Common.Pdt;
 using Cryville.Crtr.Browsing;
 using Newtonsoft.Json;
+using System;
 using System.Collections.Generic;
 using System.IO;
 using System.Text;
@@ -25,12 +27,46 @@ namespace Cryville.Crtr {
 		public void LoadPdt(DirectoryInfo dir) {
 			using (StreamReader pdtreader = new StreamReader(dir.FullName + "/" + data + ".pdt", Encoding.UTF8)) {
 				var src = pdtreader.ReadToEnd();
-				Root = (PdtSkin)new SkinInterpreter(src, null).Interpret();
+				var interpreter = new SkinInterpreter(src, null);
+				var format = interpreter.GetFormatVersion();
+				if (format.Length == 1) {
+					Root = new PdtSkin();
+					Root.elements = (SkinElement)new SkinInterpreter(src, new PdtBinder()).Interpret(typeof(SkinElement));
+				}
+				else {
+					switch (format[1]) {
+						case 1:
+							Root = (PdtSkin)new SkinInterpreter(src, new PdtBinder()).Interpret(typeof(PdtSkin));
+							break;
+						default: throw new NotSupportedException("Unsupported skin format");
+					}
+				}
 			}
 		}
 	}
 
-	public class PdtSkin : SkinElement { }
+	public class PdtSkin {
+		public Dictionary<Identifier, AnimationSpan> animations
+			= new Dictionary<Identifier, AnimationSpan>();
+		public Dictionary<Identifier, EffectDefinition> effects
+			= new Dictionary<Identifier, EffectDefinition>();
+		public SkinElement elements;
+
+		public void Optimize(PdtEvaluator etor) {
+			foreach (var a in animations) {
+				a.Value.Optimize(etor);
+			}
+			foreach (var e in effects) {
+				var effect = e.Value;
+				etor.ContextCascadeInsert();
+				etor.ContextCascadeUpdate(EffectInstance._VAR_EFFECT_INDEX, PropSrc.Error);
+				etor.Optimize(effect.duration);
+				effect.elements.Optimize(etor);
+				etor.ContextCascadeDiscard();
+			}
+			elements.Optimize(etor);
+		}
+	}
 
 	public class SkinElement {
 		[ElementList]
@@ -48,9 +84,9 @@ namespace Cryville.Crtr {
 
 		public void Optimize(PdtEvaluatorBase etor) {
 			IsDynamic = true;
-			foreach (var e in properties.Values) {
-				etor.Optimize(e);
-				if (!e.IsConstant)
+			foreach (var e in properties) {
+				etor.Optimize(e.Value);
+				if (!e.Value.IsConstant)
 					IsDynamic = true;
 			}
 			foreach (var e in elements) {
@@ -61,4 +97,28 @@ namespace Cryville.Crtr {
 			}
 		}
 	}
+
+	public class EffectDefinition {
+		public PdtExpression duration;
+		public SkinElement elements;
+	}
+
+	public class AnimationSpan {
+		[ElementList]
+		public Dictionary<Clip, AnimationSpan> spans
+			= new Dictionary<Clip, AnimationSpan>();
+
+		[PropertyList]
+		public Dictionary<SkinPropertyKey, PdtExpression> properties
+			= new Dictionary<SkinPropertyKey, PdtExpression>();
+
+		public void Optimize(PdtEvaluator etor) {
+			foreach (var p in properties) {
+				etor.Optimize(p.Value);
+			}
+			foreach (var e in spans) {
+				e.Value.Optimize(etor);
+			}
+		}
+	}
 }

Assets/Cryville/Crtr/SkinContainer.cs

@@ -1,12 +1,11 @@
 using Cryville.Common.Pdt;
-using Cryville.Crtr.Event;
 using System.Collections.Generic;
 using UnityEngine;
 using UnityEngine.Profiling;
 
 namespace Cryville.Crtr {
 	public class SkinContainer {
-		readonly PdtSkin skin;
+		readonly SkinElement _rootElement;
 		readonly DynamicStack[] _stacks = new DynamicStack[2];
 		class DynamicStack {
 			public readonly List<DynamicProperty> Properties = new List<DynamicProperty>();
@@ -26,25 +25,24 @@ namespace Cryville.Crtr {
 			public SkinSelectors Selectors { get; set; }
 			public SkinElement Element { get; set; }
 		}
-		public SkinContainer(PdtSkin _skin) {
-			skin = _skin;
+		public SkinContainer(SkinElement rootElement) {
+			_rootElement = rootElement;
 			for (int i = 0; i < _stacks.Length; i++) _stacks[i] = new DynamicStack();
 		}
-		public void MatchStatic(ContainerState state) {
+		public void MatchStatic(ISkinnableGroup group) {
 			var stack = _stacks[0];
 			stack.Clear();
-			ChartPlayer.etor.ContextState = state;
-			ChartPlayer.etor.ContextEvent = state.Container;
-			MatchStatic(skin, state, stack, new RuntimeSkinContext(state.Handler.SkinContext));
-			ChartPlayer.etor.ContextEvent = null;
-			ChartPlayer.etor.ContextState = null;
+			MatchStatic(_rootElement, group, stack, new RuntimeSkinContext(group.SkinContext));
 		}
-		void MatchStatic(SkinElement rel, ContainerState state, DynamicStack stack, RuntimeSkinContext ctx) {
+		void MatchStatic(SkinElement rel, ISkinnableGroup group, DynamicStack stack, RuntimeSkinContext ctx) {
 			var rc = ctx.ReadContext;
 			ChartPlayer.etor.ContextTransform = rc.Transform;
 			if (rc.PropSrcs != null) ChartPlayer.etor.ContextCascadeInsert(rc.PropSrcs);
 			foreach (var p in rel.properties) {
-				p.Key.ExecuteStatic(state, ctx, p.Value);
+				try {
+					p.Key.ExecuteStatic(group, ctx, p.Value); 
+				}
+				catch (EvaluationFailureException) { }
 				if (p.Key.IsValueRequired && !p.Value.IsConstant) stack.Properties.Add(
 					new DynamicProperty { Context = ctx, Key = p.Key, Value = p.Value }
 				);
@@ -52,13 +50,13 @@ namespace Cryville.Crtr {
 			ChartPlayer.etor.ContextTransform = null;
 			foreach (var e in rel.elements) {
 				try {
-					var nctxs = e.Key.MatchStatic(state, rc);
+					var nctxs = e.Key.MatchStatic(group, rc);
 					if (nctxs != null) {
 						var roflag = e.Key.annotations.Contains("if");
 						var woflag = e.Key.annotations.Contains("then");
 						foreach (var nctx in nctxs) {
 							var nrctx = new RuntimeSkinContext(nctx, ctx, roflag, woflag);
-							MatchStatic(e.Value, state, stack, nrctx);
+							MatchStatic(e.Value, group, stack, nrctx);
 						}
 					}
 				}
@@ -70,17 +68,15 @@ namespace Cryville.Crtr {
 			}
 			if (rc.PropSrcs != null) ChartPlayer.etor.ContextCascadeDiscard();
 		}
-		public void MatchDynamic(ContainerState state) {
-			var stack = _stacks[state.CloneType >> 1];
-			var nstack = (state.CloneType >> 1) + 1 < _stacks.Length ? _stacks[(state.CloneType >> 1) + 1] : null;
-			if (nstack != null) nstack.Clear();
+		public void MatchDynamic(ISkinnableGroup group, int dl) {
+			var stack = _stacks[dl];
 			if (stack.Properties.Count == 0 && stack.Elements.Count == 0) return;
+			var nstack = dl + 1 < _stacks.Length ? _stacks[dl + 1] : null;
+			if (nstack != null) nstack.Clear();
 			Profiler.BeginSample("SkinContainer.MatchDynamic");
-			ChartPlayer.etor.ContextState = state;
-			ChartPlayer.etor.ContextEvent = state.Container;
 			for (int i = 0; i < stack.Properties.Count; i++) {
 				DynamicProperty p = stack.Properties[i];
-				p.Key.ExecuteDynamic(state, p.Context, p.Value);
+				p.Key.ExecuteDynamic(group, p.Context, p.Value, dl);
 			}
 			for (int i = 0; i < stack.Elements.Count; i++) {
 				DynamicElement e = stack.Elements[i];
@@ -88,33 +84,36 @@ namespace Cryville.Crtr {
 				if (psrcs != null) ChartPlayer.etor.ContextCascadeInsert(psrcs);
 				SkinContext nctx = null;
 				try {
-					nctx = e.Selectors.MatchDynamic(state, e.Context.ReadContext);
+					nctx = e.Selectors.MatchDynamic(group, e.Context.ReadContext);
 				}
 				catch (SelectorNotAvailableException) {
 					if (nstack == null) throw;
 					nstack.Elements.Add(e);
 				}
-				if (nctx != null) MatchDynamic(e.Element, state, nstack, new RuntimeSkinContext(
-					nctx, e.Context, e.Selectors.annotations.Contains("if"), e.Selectors.annotations.Contains("then")
-				));
+				if (nctx != null) {
+					MatchDynamic(e.Element, group, dl, nstack, new RuntimeSkinContext(
+						nctx, e.Context, e.Selectors.annotations.Contains("if"), e.Selectors.annotations.Contains("then")
+					));
+					if (e.Selectors.annotations.Contains("once")) {
+						stack.Elements.RemoveAt(i--);
+					}
+				}
 				if (psrcs != null) ChartPlayer.etor.ContextCascadeDiscard();
 			}
-			ChartPlayer.etor.ContextEvent = null;
-			ChartPlayer.etor.ContextState = null;
 			Profiler.EndSample();
 		}
-		void MatchDynamic(SkinElement rel, ContainerState state, DynamicStack stack, RuntimeSkinContext ctx) {
+		void MatchDynamic(SkinElement rel, ISkinnableGroup group, int dl, DynamicStack stack, RuntimeSkinContext ctx) {
 			var rc = ctx.ReadContext;
 			ChartPlayer.etor.ContextTransform = rc.Transform;
 			if (rc.PropSrcs != null) ChartPlayer.etor.ContextCascadeInsert(rc.PropSrcs);
 			foreach (var p in rel.properties) {
-				p.Key.ExecuteDynamic(state, ctx, p.Value);
+				p.Key.ExecuteDynamic(group, ctx, p.Value, dl);
 			}
 			ChartPlayer.etor.ContextTransform = null;
 			foreach (var e in rel.elements) {
-				if (e.Key.IsUpdatable(state)) {
-					SkinContext nctx = e.Key.MatchDynamic(state, rc);
-					if (nctx != null) MatchDynamic(e.Value, state, stack, new RuntimeSkinContext(
+				if (e.Key.IsUpdatable(group, dl)) {
+					SkinContext nctx = e.Key.MatchDynamic(group, rc);
+					if (nctx != null) MatchDynamic(e.Value, group, dl, stack, new RuntimeSkinContext(
 						nctx, ctx, e.Key.annotations.Contains("if"), e.Key.annotations.Contains("then")
 					));
 				}
@@ -162,4 +161,12 @@ namespace Cryville.Crtr {
 			}
 		}
 	}
+	public interface ISkinnableGroup {
+		string TypeName { get; }
+		SkinContext SkinContext { get; }
+		Anchor OpenedAnchor { get; }
+		bool TryGetAnchorsByName(int name, out IReadOnlyCollection<Anchor> result);
+		void RegisterAnchor(int name);
+		void PushAnchorEvent(double time, int name);
+	}
 }

Assets/Cryville/Crtr/SkinInterpreter.cs

@@ -7,12 +7,20 @@ using System.Reflection;
 
 namespace Cryville.Crtr {
 	public class SkinInterpreter : PdtInterpreter {
-		public SkinInterpreter(string src, Binder binder) : base(src, typeof(PdtSkin), binder) { }
+		public SkinInterpreter(string src, Binder binder) : base(src, binder) { }
 
 		readonly List<SkinSelector> s = new List<SkinSelector>();
 		readonly HashSet<string> a = new HashSet<string>();
 		readonly List<string> k = new List<string>(2);
 		protected override object InterpretKey(Type type) {
+			if (typeof(SkinElement).IsAssignableFrom(type))
+				return InterpretSkinElementKey();
+			else if (typeof(AnimationSpan).IsAssignableFrom(type))
+				return InterpretAnimationSpanKey();
+			else
+				return base.InterpretKey(type);
+		}
+		object InterpretSkinElementKey() {
 			s.Clear(); a.Clear(); k.Clear();
 			bool invalidKeyFlag = false, compKeyFlag = false;
 			while (true) {
@@ -62,6 +70,12 @@ namespace Cryville.Crtr {
 								Name = IdentifierManager.SharedInstance.Request(k[0])
 							};
 						}
+						else if (a.Contains("emit")) {
+							if (k.Count != 1) throw new FormatException("Invalid effect name");
+							return new SkinPropertyKey.EmitEffect {
+								Name = IdentifierManager.SharedInstance.Request(k[0])
+							};
+						}
 						switch (k.Count) {
 							case 1:
 								if (compKeyFlag) return new SkinPropertyKey.CreateComponent {
@@ -82,7 +96,7 @@ namespace Cryville.Crtr {
 					case '{':
 						return new SkinSelectors(s, a);
 					case '}':
-						return null;
+						throw new FormatException("Invalid token");
 					case '*':
 						GetChar();
 						compKeyFlag = true;
@@ -100,6 +114,59 @@ namespace Cryville.Crtr {
 				if (Position == pp) throw new FormatException("Invalid selector or key format");
 			}
 		}
+		object InterpretAnimationSpanKey() {
+			if ((ct & 0x0040) != 0 || cc == ',') {
+				float start = 0, end = 1;
+				if (cc != ',') {
+					start = float.Parse(GetNumber());
+					ws(); if (cc != ',') throw new FormatException("Invalid span format");
+				}
+				GetChar(); ws();
+				if (cc != '{') end = float.Parse(GetNumber());
+				ws();
+				if (cc != '{') throw new FormatException("Invalid span format");
+				return new Clip(start, end);
+			}
+			k.Clear();
+			while (true) {
+				int pp = Position;
+				switch (cc) {
+					case '.':
+						GetChar();
+						if (k.Count != 1)
+							throw new FormatException("Invalid key format");
+						k.Add(GetIdentifier());
+						break;
+					case ';':
+					case ':':
+						switch (k.Count) {
+							case 1:
+								return new SkinPropertyKey.SetProperty {
+									Component = typeof(TransformInterface),
+									Name = IdentifierManager.SharedInstance.Request(k[0])
+								};
+							case 2:
+								return new SkinPropertyKey.SetProperty {
+									Component = GetComponentByName(k[0]),
+									Name = IdentifierManager.SharedInstance.Request(k[1])
+								};
+							default:
+								throw new FormatException("Unknown error"); // Unreachable
+						}
+					case '{':
+						throw new FormatException("Invalid token");
+					case '}':
+						throw new FormatException("Invalid token");
+					default:
+						if (k.Count != 0)
+							throw new FormatException("Invalid key format");
+						k.Add(GetIdentifier());
+						break;
+				}
+				ws();
+				if (Position == pp) throw new FormatException("Invalid selector or key format");
+			}
+		}
 		static Type GetComponentByName(string name) {
 			Type result;
 			if (GenericResources.Components.TryGetValue(name, out result)) return result;

Assets/Cryville/Crtr/SkinPropertyKey.cs

@@ -1,7 +1,6 @@
 using Cryville.Common;
 using Cryville.Common.Pdt;
 using Cryville.Crtr.Components;
-using Cryville.Crtr.Event;
 using System;
 using UnityEngine;
 
@@ -9,18 +8,18 @@ namespace Cryville.Crtr {
 	public abstract class SkinPropertyKey {
 		public abstract override string ToString();
 		public abstract bool IsValueRequired { get; }
-		public abstract void ExecuteStatic(ContainerState state, RuntimeSkinContext ctx, PdtExpression exp);
-		public abstract void ExecuteDynamic(ContainerState state, RuntimeSkinContext ctx, PdtExpression exp);
+		public abstract void ExecuteStatic(ISkinnableGroup group, RuntimeSkinContext ctx, PdtExpression exp);
+		public abstract void ExecuteDynamic(ISkinnableGroup group, RuntimeSkinContext ctx, PdtExpression exp, int dl);
 		public class CreateComponent : SkinPropertyKey {
 			public Type Component { get; set; }
 			public override string ToString() {
 				return string.Format("*{0}", Component.Name);
 			}
 			public override bool IsValueRequired { get { return false; } }
-			public override void ExecuteStatic(ContainerState state, RuntimeSkinContext ctx, PdtExpression exp) {
-				ctx.ReadContext.Transform.gameObject.AddComponent(Component);
+			public override void ExecuteStatic(ISkinnableGroup group, RuntimeSkinContext ctx, PdtExpression exp) {
+				ctx.WriteTransform.gameObject.AddComponent(Component);
 			}
-			public override void ExecuteDynamic(ContainerState state, RuntimeSkinContext ctx, PdtExpression exp) {
+			public override void ExecuteDynamic(ISkinnableGroup group, RuntimeSkinContext ctx, PdtExpression exp, int dl) {
 				throw new InvalidOperationException("Component creation in dynamic context is not allowed");
 			}
 		}
@@ -31,12 +30,12 @@ namespace Cryville.Crtr {
 				return string.Format("{0}.{1}", Component.Name, IdentifierManager.SharedInstance.Retrieve(Name));
 			}
 			public override bool IsValueRequired { get { return true; } }
-			public override void ExecuteStatic(ContainerState state, RuntimeSkinContext ctx, PdtExpression exp) {
+			public override void ExecuteStatic(ISkinnableGroup group, RuntimeSkinContext ctx, PdtExpression exp) {
 				Execute(ctx, GetPropOp(ctx.WriteTransform).Operator, exp);
 			}
-			public override void ExecuteDynamic(ContainerState state, RuntimeSkinContext ctx, PdtExpression exp) {
+			public override void ExecuteDynamic(ISkinnableGroup group, RuntimeSkinContext ctx, PdtExpression exp, int dl) {
 				var prop = GetPropOp(ctx.WriteTransform);
-				if (state.CloneType > prop.UpdateCloneType) return;
+				if (dl > prop.UpdateDynamicLevel) return;
 				Execute(ctx, prop.Operator, exp);
 			}
 			void Execute(RuntimeSkinContext ctx, PdtOperator op, PdtExpression exp) {
@@ -67,10 +66,10 @@ namespace Cryville.Crtr {
 				return string.Format("@has {0}", IdentifierManager.SharedInstance.Retrieve(Name));
 			}
 			public override bool IsValueRequired { get { return false; } }
-			public override void ExecuteStatic(ContainerState state, RuntimeSkinContext ctx, PdtExpression exp) {
-				state.Handler.RegisterAnchor(Name, true);
+			public override void ExecuteStatic(ISkinnableGroup group, RuntimeSkinContext ctx, PdtExpression exp) {
+				group.RegisterAnchor(Name);
 			}
-			public override void ExecuteDynamic(ContainerState state, RuntimeSkinContext ctx, PdtExpression exp) {
+			public override void ExecuteDynamic(ISkinnableGroup group, RuntimeSkinContext ctx, PdtExpression exp, int dl) {
 				throw new InvalidOperationException("Anchor creation in dynamic context is not allowed");
 			}
 		}
@@ -83,18 +82,37 @@ namespace Cryville.Crtr {
 				return string.Format("@at {0}", IdentifierManager.SharedInstance.Retrieve(Name));
 			}
 			public override bool IsValueRequired { get { return true; } }
-			public override void ExecuteStatic(ContainerState state, RuntimeSkinContext ctx, PdtExpression exp) {
+			public override void ExecuteStatic(ISkinnableGroup group, RuntimeSkinContext ctx, PdtExpression exp) {
 				throw new InvalidOperationException("Setting anchor in static context is not allowed");
 			}
 			float _time;
 			readonly PropOp _timeOp;
-			public override void ExecuteDynamic(ContainerState state, RuntimeSkinContext ctx, PdtExpression exp) {
-				if (state.CloneType > 1) return;
+			public override void ExecuteDynamic(ISkinnableGroup group, RuntimeSkinContext ctx, PdtExpression exp, int dl) {
+				if (dl > 0) return;
 				var psrcs = ctx.ReadContext.PropSrcs;
 				if (psrcs != null) ChartPlayer.etor.ContextCascadeInsert(psrcs);
 				ChartPlayer.etor.Evaluate(_timeOp, exp);
 				if (psrcs != null) ChartPlayer.etor.ContextCascadeDiscard();
-				state.Handler.PushAnchorEvent(_time, Name);
+				group.PushAnchorEvent(_time, Name);
+			}
+		}
+		public class EmitEffect : SkinPropertyKey {
+			public int Name { get; set; }
+			public EmitEffect() {
+				_op = new PropOp.Float(v => _index = v);
+			}
+			public override string ToString() {
+				return string.Format("@emit {0}", IdentifierManager.SharedInstance.Retrieve(Name));
+			}
+			public override bool IsValueRequired { get { return true; } }
+			public override void ExecuteStatic(ISkinnableGroup group, RuntimeSkinContext ctx, PdtExpression exp) {
+				throw new InvalidOperationException("Emitting effect in static context is not allowed");
+			}
+			float _index;
+			readonly PropOp _op;
+			public override void ExecuteDynamic(ISkinnableGroup group, RuntimeSkinContext ctx, PdtExpression exp, int dl) {
+				ChartPlayer.etor.Evaluate(_op, exp);
+				ChartPlayer.effectManager.Emit(Name, _index);
 			}
 		}
 	}

Assets/Cryville/Crtr/SkinSelectors.cs

@@ -1,7 +1,6 @@
 using Cryville.Common;
 using Cryville.Common.Pdt;
 using Cryville.Crtr.Components;
-using Cryville.Crtr.Event;
 using System;
 using System.Collections.Generic;
 using System.Linq;
@@ -37,21 +36,21 @@ namespace Cryville.Crtr {
 				selectors[i].Optimize(etor);
 			}
 		}
-		public IEnumerable<SkinContext> MatchStatic(ContainerState h, SkinContext ctx) {
+		public IEnumerable<SkinContext> MatchStatic(ISkinnableGroup g, SkinContext ctx) {
 			IEnumerable<SkinContext> result = new SkinContext[] { ctx };
 			foreach (var s in selectors) {
-				result = result.SelectMany(l => s.MatchStatic(h, l));
+				result = result.SelectMany(l => s.MatchStatic(g, l));
 			}
 			return result;
 		}
-		public bool IsUpdatable(ContainerState h) {
+		public bool IsUpdatable(ISkinnableGroup g, int dl) {
 			foreach (var s in selectors)
-				if (!s.IsUpdatable(h)) return false;
+				if (!s.IsUpdatable(g, dl)) return false;
 			return true;
 		}
-		public SkinContext MatchDynamic(ContainerState h, SkinContext ctx) {
+		public SkinContext MatchDynamic(ISkinnableGroup g, SkinContext ctx) {
 			foreach (var s in selectors) {
-				ctx = s.MatchDynamic(h, ctx);
+				ctx = s.MatchDynamic(g, ctx);
 				if (ctx == null) return null;
 			}
 			return ctx;
@@ -63,16 +62,16 @@ namespace Cryville.Crtr {
 		public abstract override string ToString();
 
 		public virtual void Optimize(PdtEvaluatorBase etor) { }
-		public virtual IEnumerable<SkinContext> MatchStatic(ContainerState h, SkinContext c) { throw new SelectorNotAvailableException(); }
-		public virtual SkinContext MatchDynamic(ContainerState h, SkinContext c) { throw new SelectorNotAvailableException(); }
-		public virtual bool IsUpdatable(ContainerState h) {
+		public virtual IEnumerable<SkinContext> MatchStatic(ISkinnableGroup g, SkinContext c) { throw new SelectorNotAvailableException(); }
+		public virtual SkinContext MatchDynamic(ISkinnableGroup g, SkinContext c) { throw new SelectorNotAvailableException(); }
+		public virtual bool IsUpdatable(ISkinnableGroup g, int dl) {
 			return true;
 		}
 		public class CreateObject : SkinSelector {
 			public CreateObject() { }
 			public override string ToString() { return "$"; }
 
-			public override IEnumerable<SkinContext> MatchStatic(ContainerState h, SkinContext c) {
+			public override IEnumerable<SkinContext> MatchStatic(ISkinnableGroup g, SkinContext c) {
 				var obj = new GameObject("__obj__");
 				obj.transform.SetParent(c.Transform, false);
 				obj.AddComponent<TransformInterface>();
@@ -86,9 +85,9 @@ namespace Cryville.Crtr {
 			}
 			public override string ToString() { return string.Format(".{0}", IdentifierManager.SharedInstance.Retrieve(Name)); }
 
-			public override IEnumerable<SkinContext> MatchStatic(ContainerState h, SkinContext c) {
-				List<CAnchor> anchors;
-				if (h.Handler.Anchors.TryGetValue(Name, out anchors)) {
+			public override IEnumerable<SkinContext> MatchStatic(ISkinnableGroup g, SkinContext c) {
+				IReadOnlyCollection<CAnchor> anchors;
+				if (g.TryGetAnchorsByName(Name, out anchors)) {
 					return anchors.Select(a => a.SkinContext);
 				}
 				else return Enumerable.Empty<SkinContext>();
@@ -101,11 +100,11 @@ namespace Cryville.Crtr {
 			}
 			public override string ToString() { return string.Format("..{0}", IdentifierManager.SharedInstance.Retrieve(Name)); }
 
-			public override SkinContext MatchDynamic(ContainerState h, SkinContext c) {
-				return h.Handler.OpenedAnchor != null && h.Handler.OpenedAnchor.Name == Name ? c : null;
+			public override SkinContext MatchDynamic(ISkinnableGroup g, SkinContext c) {
+				return g.OpenedAnchor != null && g.OpenedAnchor.Name == Name ? c : null;
 			}
-			public override bool IsUpdatable(ContainerState h) {
-				return h.CloneType >= 2;
+			public override bool IsUpdatable(ISkinnableGroup g, int dl) {
+				return dl >= 1;
 			}
 		}
 		public class Property : SkinSelector {
@@ -121,12 +120,12 @@ namespace Cryville.Crtr {
 			public override void Optimize(PdtEvaluatorBase etor) {
 				etor.Optimize(_exp);
 			}
-			public override IEnumerable<SkinContext> MatchStatic(ContainerState h, SkinContext c) {
+			public override IEnumerable<SkinContext> MatchStatic(ISkinnableGroup g, SkinContext c) {
 				var result = Match(c);
 				if (result != null) return new SkinContext[] { result };
 				else return Enumerable.Empty<SkinContext>();
 			}
-			public override SkinContext MatchDynamic(ContainerState h, SkinContext c) {
+			public override SkinContext MatchDynamic(ISkinnableGroup g, SkinContext c) {
 				return Match(c);
 			}
 			public SkinContext Match(SkinContext a) {
@@ -148,8 +147,8 @@ namespace Cryville.Crtr {
 			public ElementType(string type) { _type = type; }
 			public override string ToString() { return _type; }
 
-			public override IEnumerable<SkinContext> MatchStatic(ContainerState h, SkinContext c) {
-				return h.Handler.TypeName == _type ? new SkinContext[] { c } : Enumerable.Empty<SkinContext>();
+			public override IEnumerable<SkinContext> MatchStatic(ISkinnableGroup g, SkinContext c) {
+				return g.TypeName == _type ? new SkinContext[] { c } : Enumerable.Empty<SkinContext>();
 			}
 		}
 	}

Assets/Cryville/Crtr/SpriteFrame.cs

@@ -61,10 +61,9 @@ namespace Cryville.Crtr {
 				return new Vector2(Texture.width, Texture.height);
 			}
 		}
-
-		public void Init() {
-			if (Texture == null)
-				throw new InvalidOperationException("Missing texture");
+		public SpriteFrame(Texture2D tex) {
+			if (tex == null) throw new ArgumentNullException("tex");
+			Texture = tex;
 			m_frame = new Rect(Vector2.zero, Size);
 			var w = m_frame.width;
 			var h = m_frame.height;
@@ -75,10 +74,5 @@ namespace Cryville.Crtr {
 			if (m_rotated) UV = new Rect(x, y, tw, -th);
 			else UV = new Rect(x, y, tw, -th);
 		}
-
-		public SpriteFrame() { }
-		public SpriteFrame(Texture2D tex) {
-			Texture = tex;
-		}
 	}
 }

Assets/Cryville/Crtr/TrackHandler.cs

@@ -27,11 +27,11 @@ namespace Cryville.Crtr {
 				TransformAwake(s);
 			}
 		}
-		public override void StartPreGraphicalUpdate(ContainerState s) {
+		protected override void StartPreGraphicalUpdate(ContainerState s) {
 			base.StartPreGraphicalUpdate(s);
 			TransformAwake(s);
 		}
-		public override void StartGraphicalUpdate(ContainerState s) {
+		protected override void StartGraphicalUpdate(ContainerState s) {
 			base.StartGraphicalUpdate(s);
 			if (gogroup) {
 				TransformAwake(s);
@@ -105,7 +105,7 @@ namespace Cryville.Crtr {
 			spos = bpos - GetCurrentWorldPoint();
 		}
 
-		public override void EndGraphicalUpdate(ContainerState s) {
+		protected override void EndGraphicalUpdate(ContainerState s) {
 			base.EndGraphicalUpdate(s);
 			EndUpdatePosition(s);
 			var p = GetCurrentWorldPoint();

Assets/Plugins/StringFormatter/CustomNumeric.cs

@@ -211,7 +211,7 @@ namespace System.Text.Formatting {
 				remainingDigitsInGroup -= groupSize;
 				groupIndex++;
 			}
-			bool appendingDigitFlag = false;
+			bool appendingDigitFlag = false, outOfPrecisionFlag = false;
 			decimalFlag = false;
 			for (index = start; index < end; index++) {
 				switch (ptr[index]) {
@@ -229,13 +229,20 @@ namespace System.Text.Formatting {
 					case '#':
 						if (!appendingDigitFlag) {
 							if (number.Scale > integralDigits) while (currentDigitIndex < number.Scale - integralDigits)
-								formatter.AppendIntegralDigit(ref number, ref currentDigitIndex, culture, groupFlag, ref groupIndex, ref remainingDigitsInGroup);
+								formatter.AppendIntegralDigit(ref number, ref currentDigitIndex, culture, groupFlag, ref outOfPrecisionFlag, ref groupIndex, ref remainingDigitsInGroup);
 							appendingDigitFlag = true;
 						}
 						if (decimalFlag) {
-							if (currentDigitIndex < number.Precision) {
-								char digit = number.Digits[currentDigitIndex++];
-								if (digit == '\0') digit = '0';
+							char digit = '0';
+							if (!outOfPrecisionFlag) {
+								if (currentDigitIndex >= number.Precision) outOfPrecisionFlag = true;
+								else {
+									digit = number.Digits[currentDigitIndex++];
+									if (digit == '\0') {
+										outOfPrecisionFlag = true;
+										digit = '0';
+									}
+								}
 								formatter.Append(digit);
 							}
 							else if (decimalZeros > 0)
@@ -245,7 +252,7 @@ namespace System.Text.Formatting {
 						}
 						else {
 							if (integralDigits <= number.Scale)
-								formatter.AppendIntegralDigit(ref number, ref currentDigitIndex, culture, groupFlag, ref groupIndex, ref remainingDigitsInGroup);
+								formatter.AppendIntegralDigit(ref number, ref currentDigitIndex, culture, groupFlag, ref outOfPrecisionFlag, ref groupIndex, ref remainingDigitsInGroup);
 							else if (integralDigits <= integralZeros)
 								formatter.AppendIntegralDigit('0', culture, groupFlag, ref groupIndex, ref remainingDigitsInGroup);
 							--integralDigits;
@@ -295,11 +302,18 @@ namespace System.Text.Formatting {
 				}
 			}
 		}
-		static void AppendIntegralDigit(this StringBuffer self, ref Number number, ref int index, CachedCulture culture, bool groupFlag, ref int groupIndex, ref int remainingDigitsInGroup) {
-			char digit;
-			if (index >= number.Precision) digit = '0';
-			else digit = number.Digits[index];
-			if (digit == '\0') digit = '0';
+		static void AppendIntegralDigit(this StringBuffer self, ref Number number, ref int index, CachedCulture culture, bool groupFlag, ref bool outOfPrecisionFlag, ref int groupIndex, ref int remainingDigitsInGroup) {
+			char digit = '0';
+			if (!outOfPrecisionFlag) {
+				if (index >= number.Precision) outOfPrecisionFlag = true;
+				else {
+					digit = number.Digits[index];
+					if (digit == '\0') {
+						outOfPrecisionFlag = true;
+						digit = '0';
+					}
+				}
+			}
 			self.AppendIntegralDigit(digit, culture, groupFlag, ref groupIndex, ref remainingDigitsInGroup);
 			index++;
 		}

Assets/Plugins/StringFormatter/StringFormatter.cs

@@ -400,7 +400,7 @@ namespace System.Text.Formatting {
                 var segmentsLeft = false;
                 var prevArgIndex = 0;
                 do {
-                    CheckCapacity((int)(end - curr));
+                    CheckCapacity((int)(end - curr) + 1);
                     fixed (char* bufferPtr = &buffer[currentCount])
                         segmentsLeft = AppendSegment(ref curr, end, bufferPtr, ref prevArgIndex, ref args);
                 }
@@ -410,8 +410,16 @@ namespace System.Text.Formatting {
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         void CheckCapacity (int count) {
-            if (currentCount + count > buffer.Length)
-                Array.Resize(ref buffer, buffer.Length * 2);
+			int newCount = currentCount + count;
+			if (newCount > buffer.Length) {
+				int newCapacity = buffer.Length * 2;
+				if (newCapacity < newCount) newCapacity = newCount;
+				char[] newBuffer = new char[newCapacity];
+				fixed (void* nptr = newBuffer, ptr = buffer) {
+					Unsafe.CopyBlock(nptr, ptr, (uint)(currentCount * sizeof(char)));
+				}
+				buffer = newBuffer;
+			}
         }
 
         bool AppendSegment<T>(ref char* currRef, char* end, char* dest, ref int prevArgIndex, ref T args) where T : IArgSet {

Assets/Plugins/UnsafeIL.dll.meta

@@ -1,5 +1,5 @@
 fileFormatVersion: 2
-guid: d927992f95b82f740a0a95bb6d617d73
+guid: 1313487c790be7545a3e1e2ca59e986e
 PluginImporter:
   externalObjects: {}
   serializedVersion: 2