private static void ImportGameObject(CustomImporterArgs args)
{
if (args.value == null || !args.value.IsString)
{
return;
}
if (args.field.HasAttribute <PencilNode>())
{
var childNode = args.findNodeFunc((string)args.value);
if (childNode == null)
{
return;
}
args.SetValueByReflection(childNode);
childNode.transform.parent = args.node.gameObject.transform;
}
else
{
var obj = GameObject.Find((string)args.value);
if (obj == null)
{
return;
}
args.SetValueByReflection(obj);
}
}
private static void ImportUniversalCurve(CustomImporterArgs args)
{
if (args.value == null)
{
return;
}
// UniversalKeysの読み込み
var curveValues = args.value[KeyName.UniversalCurveKeys];
if (!curveValues.IsArray)
{
return;
}
var keyframes = curveValues.Cast <JsonData>()
.Where(p => p.IsArray || p.Count < 2)
.Select(p => new Keyframe(
Convert.ToSingle((double)p[0]),
Convert.ToSingle((double)p[1])));
var animationCurve = new AnimationCurve(keyframes.ToArray());
foreach (var i in Enumerable.Range(0, animationCurve.length))
{
animationCurve.SmoothTangents(i, 0);
}
args.SetValueByReflection(animationCurve);
}
private static void ImportOneParam(
Component node,
JsonData value,
FieldInfo field,
float scale,
Func <string, GameObject> nodeFinder)
{
var args = new CustomImporterArgs
{
node = node,
value = value,
field = field,
scale = scale,
findNodeFunc = nodeFinder
};
if (_customImporter.ContainsKey(field.FieldType))
{
_customImporter[field.FieldType](args);
}
else if (field.FieldType.IsEnum)
{
_customImporter[typeof(int)](args);
}
else
{
throw new InvalidOperationException("Unsupported field type.");
}
}
private static void ImportString(CustomImporterArgs args)
{
if (args.value == null || !args.value.IsString)
{
return;
}
args.SetValueByReflection((string)args.value);
}
private static void ImportBool(CustomImporterArgs args)
{
if (args.value == null || !args.value.IsBoolean)
{
return;
}
args.SetValueByReflection((bool)args.value);
}
private static void ImportInt(CustomImporterArgs args)
{
if (args.value == null || !args.value.IsInt && !args.value.IsLong)
{
return;
}
args.SetValueByReflection((int)args.value);
}
private static void ImportLoopDirection(CustomImporterArgs args)
{
if (args.value == null || !args.value.IsInt)
{
return;
}
var value = (int)args.value;
// 他プラットフォームでEnumの値が逆であるため、値を反転させる
args.SetValueByReflection(value == 0 ? 1 : 0);
}
private static void ImportTexture2D(CustomImporterArgs args)
{
if (args.value == null || !args.value.IsString)
{
return;
}
var texture = _assetFinder("t:texture", (string)args.value) as Texture2D;
args.SetValueByReflection(texture);
}
private static void ImportMaterialList(CustomImporterArgs args)
{
if (args.value == null || !args.value.IsArray)
{
return;
}
var existingMaterials = Utils.EnumerateMaterials().ToList();
var newMaterialList = Enumerable.Range(0, args.value.Count)
.Select(i => args.value[i].TryGetStringValue("Name"))
.SelectMany(x => existingMaterials.Where(y => y.name == EscapeMaterialName(x)))
.ToList();
args.SetValueByReflection(newMaterialList);
}
private static void ImportFloat(CustomImporterArgs args)
{
if (args.value == null || !args.value.IsDouble)
{
return;
}
if (args.field.HasAttribute <JsonScaleDependent>())
{
args.SetValueByReflection(Convert.ToSingle((double)args.value) * args.scale);
}
else
{
args.SetValueByReflection(Convert.ToSingle((double)args.value));
}
}
private static void ImportVector2(CustomImporterArgs args)
{
if (args.value == null || !args.value.IsArray || args.value.Count < 2)
{
return;
}
if (Enumerable.Range(0, 2).Any(i => !args.value[i].IsDouble))
{
return;
}
var vector = new Vector2(
Convert.ToSingle((double)args.value[0]),
Convert.ToSingle((double)args.value[1]));
args.SetValueByReflection(vector);
}
private static void ImportAnimationCurve(CustomImporterArgs args)
{
if (args.value == null || !args.value.IsObject)
{
return;
}
var curveKinds = args.value.Keys;
#if UNITY_EDITOR
if (curveKinds.Contains(KeyName.UnityCurveKeys))
{
ImportUnityCurve(args);
}
else
#endif
if (curveKinds.Contains(KeyName.UniversalCurveKeys))
{
ImportUniversalCurve(args);
}
}
private static void ImportGameObjectList(CustomImporterArgs args)
{
if (args.value == null || !args.value.IsArray)
{
return;
}
var newGameObjectList = new List <GameObject>();
if (args.field.HasAttribute <PencilNode>())
{
foreach (var i in Enumerable.Range(0, args.value.Count))
{
if (!args.value[i].IsString)
{
continue;
}
var childNode = args.findNodeFunc((string)args.value[i]);
newGameObjectList.Add(childNode);
childNode.transform.parent = args.node.gameObject.transform;
}
}
else
{
var objectNames = Enumerable.Range(0, args.value.Count)
.Select(i => args.value[i].IsString ? (string)args.value[i] : null)
.Where(x => x != null)
.Distinct();
var allGameObjects = Object.FindObjectsOfType <GameObject>();
foreach (var name in objectNames)
{
newGameObjectList.AddRange(allGameObjects.Where(x => x.name == name));
}
}
args.SetValueByReflection(newGameObjectList);
}
private static void ImportUnityCurve(CustomImporterArgs args)
{
if (args.value == null)
{
return;
}
var curveKeys = args.value[KeyName.UnityCurveKeys];
if (!curveKeys.IsArray)
{
return;
}
var keyframes = new List <Keyframe>();
foreach (var i in Enumerable.Range(0, curveKeys.Count))
{
var time = Convert.ToSingle((double)curveKeys[i][KeyName.CurveTime]);
var value = Convert.ToSingle((double)curveKeys[i][KeyName.CurveValue]);
var inTangent = Convert.ToSingle((double)curveKeys[i][KeyName.CurveInTangent]);
var outTangent = Convert.ToSingle((double)curveKeys[i][KeyName.CurveOutTangent]);
#if UNITY_2018_1_OR_NEWER
var curveKeyDict = curveKeys[i] as IDictionary;
if (curveKeyDict.Contains(KeyName.CurveInWeight) &&
curveKeyDict.Contains(KeyName.CurveOutWeight) &&
curveKeyDict.Contains(KeyName.CurveWeightedMode))
{
var inWeight = Convert.ToSingle((double)curveKeys[i][KeyName.CurveInWeight]);
var outWeight = Convert.ToSingle((double)curveKeys[i][KeyName.CurveOutWeight]);
var newKeyframe = new Keyframe(time, value, inTangent, outTangent, inWeight, outWeight)
{
weightedMode = (WeightedMode)(int)curveKeys[i][KeyName.CurveWeightedMode]
};
keyframes.Add(newKeyframe);
}
else
{
keyframes.Add(new Keyframe(time, value, inTangent, outTangent));
}
#else
keyframes.Add(new Keyframe(time, value, inTangent, outTangent));
#endif
}
var animationCurve = new AnimationCurve(keyframes.ToArray());
for (var i = 0; i < curveKeys.Count; i++)
{
#if UNITY_EDITOR
AnimationUtility.SetKeyBroken(
animationCurve, i, (bool)curveKeys[i][KeyName.CurveKeyBroken]);
AnimationUtility.SetKeyLeftTangentMode(
animationCurve, i,
(AnimationUtility.TangentMode)(int) curveKeys[i][KeyName.CurveLeftTangentMode]);
AnimationUtility.SetKeyRightTangentMode(
animationCurve, i,
(AnimationUtility.TangentMode)(int) curveKeys[i][KeyName.CurveRightTangentMode]);
#endif
}
args.SetValueByReflection(animationCurve);
}
