public static bool GetNodePosition(SampleNode node, string clip, int frame, out IM.Vector3 position)
{
AnimData animData = AnimationSampleManager.Instance.GetAnimData(clip);
IM.Number time = frame / animData.frameRate;
return(GetNodePosition(node, animData, time, out position));
}
public void ShouldReplaceLinkInAll()
{
// arrange
var source = new SampleNode("source");
var target = new SampleNode("target");
var graph = new Graph();
graph.AddNode(source);
graph.AddNode(target);
var firstLink = new SampleLink();
graph.AddLink(source, target, firstLink);
var secondLink = new SecondLink();
// act
graph.ReplaceLink(firstLink, secondLink);
// Assert
Assert.That(graph.Links, Has.Count.EqualTo(1));
Assert.That(graph.Links, Has.No.Member(firstLink));
Assert.That(graph.Links, Has.Member(secondLink));
Assert.That(secondLink.Source, Is.SameAs(source));
Assert.That(secondLink.Target, Is.SameAs(target));
Assert.That(source.OutboundLinks, Has.No.Member(firstLink));
Assert.That(target.InboundLinks, Has.No.Member(firstLink));
Assert.That(source.OutboundLinks, Has.Member(secondLink));
Assert.That(target.InboundLinks, Has.Member(secondLink));
}
public void SimpleTreeCreation()
{
SampleNode N = new SampleNode(0);
N.Condition = (x) => { return(true); };
Assert.IsTrue(ExecutePredicate <int> .Exec(N.Condition, 0));
}
public static bool GetNodePosition(SampleNode node, AnimData animData, IM.Number time, out IM.Vector3 position)
{
int count = animData.sampleDatas.Count;
for (int i = 0; i < count; ++i)
{
SampleData sample1 = animData.sampleDatas[i];
if (time == sample1.time)
{
position = sample1.nodes[node].position;
return(true);
}
else if (time > sample1.time && i < count - 1)
{
SampleData sample2 = animData.sampleDatas[i + 1];
if (time < sample2.time)
{
IM.Vector3 pos1 = sample1.nodes[node].position;
IM.Vector3 pos2 = sample2.nodes[node].position;
IM.Number t = (time - sample1.time) / (sample2.time - sample1.time);
position = IM.Vector3.Lerp(pos1, pos2, t);
return(true);
}
}
}
position = IM.Vector3.zero;
return(false);
}
private IM.Vector3 GetNodePosition(SampleNode node, bool calcRootMotion)
{
IM.Vector3 pos;
IM.Number horiAngle;
GetNodePosAndRot(node, out pos, out horiAngle, calcRootMotion);
return(pos);
}
static void GetNodePosAndRot(PlayInfo info, SampleNode node, out IM.Vector3 pos, out IM.Number horiAngle)
{
SampleData sample1 = info.animData.sampleDatas[info.keyFrameIndex1];
IM.Vector3 pos1 = sample1.nodes[node].position;
IM.Number angle1 = sample1.nodes[node].horiAngle;
if (info.keyFrameIndex1 == info.keyFrameIndex2)
{
pos = pos1;
horiAngle = angle1;
}
else
{
SampleData sample2 = info.animData.sampleDatas[info.keyFrameIndex2];
IM.Vector3 pos2 = sample2.nodes[node].position;
IM.Number angle2 = sample2.nodes[node].horiAngle;
IM.Number t = (info.realTime - sample1.time) / (sample2.time - sample1.time);
pos = IM.Vector3.Lerp(pos1, pos2, t);
horiAngle = IM.Math.LerpAngle(angle1, angle2, t);
}
}
public void ShouldRemoveLinkFromAll()
{
// arrange
var source = new SampleNode("source");
var target = new SampleNode("target");
var graph = new Graph();
graph.AddNode(source);
graph.AddNode(target);
var link = new SampleLink();
graph.AddLink(source, target, link);
// act
graph.RemoveLink(link);
// Assert
Assert.That(graph.Links, Has.Count.EqualTo(0));
Assert.That(source.OutboundLinks, Has.No.Member(link));
Assert.That(target.InboundLinks, Has.No.Member(link));
}
public void ShouldRemoveNodeInAll()
{
// arrange
var graph = new Graph();
var node1 = new SampleNode("node1");
var node2 = new SampleNode("node2");
graph.AddNode(node1);
graph.AddNode(node2);
var inboundLink = new SampleLink();
graph.AddLink(node2, node1, inboundLink);
var outboundLink = new SampleLink();
graph.AddLink(node1, node2, outboundLink);
// act
graph.RemoveNode(node1);
// assert
Assert.That(graph.Nodes, Has.No.Member(node1));
Assert.That(node2.InboundLinks, Has.No.Member(outboundLink));
Assert.That(node2.OutboundLinks, Has.No.Member(inboundLink));
}
public void ShouldReplaceNodeInAll()
{
// arrange
var graph = new Graph();
var firstNode = new SampleNode("firstNode");
var secondNode = new SampleNode("secondNode");
graph.AddNode(firstNode);
graph.AddNode(secondNode);
var inboundLink = new SampleLink();
graph.AddLink(secondNode, firstNode, inboundLink);
var outboundLink = new SampleLink();
graph.AddLink(firstNode, secondNode, outboundLink);
var newNode = new SampleNode("replacedFirstNode");
// act
graph.ReplaceNode(firstNode, newNode);
// Assert
Assert.That(graph.Nodes, Has.No.Member(firstNode));
Assert.That(graph.Nodes, Has.Member(newNode));
Assert.That(inboundLink.Target, Is.SameAs(newNode));
Assert.That(newNode.InboundLinks, Has.Member(inboundLink));
Assert.That(outboundLink.Source, Is.SameAs(newNode));
Assert.That(newNode.OutboundLinks, Has.Member(outboundLink));
}
public void ShouldTrackAddedLinks()
{
// arrange
var source = new SampleNode("source");
var target = new SampleNode("target");
var graph = new Graph();
graph.AddNode(source);
graph.AddNode(target);
var link = new SampleLink();
// act
graph.AddLink(source, target, link);
// Assert
Assert.That(graph.Links, Has.Count.EqualTo(1));
Assert.That(link.Source, Is.SameAs(source));
Assert.That(link.Target, Is.SameAs(target));
Assert.That(source.OutboundLinks, Has.Member(link));
Assert.That(target.InboundLinks, Has.Member(link));
}
static AnimData SampleClip(GameObject go, AnimationClip clip)
{
//Debug.Log("Sample motion, Clip:" + clip.name + " GameObject:" + go.name);
AnimData animData = new AnimData();
animData.sampleDatas = new List <SampleData>();
animData.frameRate = IM.Editor.Tools.Convert(clip.frameRate);
animData.wrapMode = clip.wrapMode;
Dictionary <SampleNode, Transform> transforms = new Dictionary <SampleNode, Transform>();
for (int i = 0; i < (int)SampleNode.Count; ++i)
{
string nodeName = NODE_NAMES[i];
Transform transform = GameUtils.FindChildRecursive(go.transform, nodeName);
transforms.Add((SampleNode)i, transform);
}
Transform root = transforms[SampleNode.Root];
//Debug.Log(clip.averageDuration);
for (IM.Number t = IM.Number.zero; ; t += SAMPLE_INTERVAL)
{
SampleData data = new SampleData();
float time = Mathf.Min((float)t, clip.averageDuration);
clip.SampleAnimation(go, time);
data.time = IM.Editor.Tools.Convert(time);
data.nodes = new Dictionary <SampleNode, SampleNodeData>();
for (int i = 0; i < (int)SampleNode.Count; ++i)
{
SampleNode node = (SampleNode)i;
Transform transform = transforms[node];
Vector3 curPos = transform.position;
Quaternion curRot = transform.rotation;
SampleNodeData nodeData = new SampleNodeData();
if (node == SampleNode.Root) //Root节点采样相对于Player的位置
{
nodeData.position = IM.Editor.Tools.Convert(curPos);
nodeData.horiAngle = IM.Editor.Tools.Convert(curRot.eulerAngles.y);
}
else //其他节点采样相对于Root的位置
{
nodeData.position = IM.Editor.Tools.Convert(root.transform.InverseTransformPoint(transform.position));
}
//Debug.Log(string.Format("Sample, clip:{0} node:{1} time:{2} pos:{3} angle:{4}",
// clip.name, node, time, nodeData.position, nodeData.horiAngle));
data.nodes.Add(node, nodeData);
}
animData.sampleDatas.Add(data);
if ((float)t >= clip.averageDuration)
{
break;
}
}
//Animation event
animData.eventDatas = new List <AnimEventData>();
AnimationEvent[] events = AnimationUtility.GetAnimationEvents(clip);
for (int i = 0; i < events.Length; ++i)
{
AnimationEvent evt = events[i];
AnimEventData eventData = new AnimEventData();
eventData.funcName = evt.functionName;
eventData.time = IM.Editor.Tools.Convert(evt.time);
eventData.intParameter = evt.intParameter;
eventData.floatParameter = IM.Editor.Tools.Convert(evt.floatParameter);
eventData.stringParameter = evt.stringParameter;
animData.eventDatas.Add(eventData);
evt.messageOptions = SendMessageOptions.DontRequireReceiver;
}
AnimationUtility.SetAnimationEvents(clip, events);
return(animData);
}
public IM.Vector3 GetNodePosition(SampleNode node)
{
return(GetNodePosition(node, false));
}
void GetNodePosAndRot(SampleNode node, out IM.Vector3 pos, out IM.Number horiAngle, bool calcRootMotion)
{
pos = IM.Vector3.zero;
horiAngle = IM.Number.zero;
if (node != SampleNode.Root && calcRootMotion)
{
Debug.LogError("RootMotion must calc on Root node.");
}
if (_curInfo == null)
{
return;
}
IM.Vector3 deltaMove = IM.Vector3.zero;
IM.Number deltaAngle = IM.Number.zero;
if (_curInfo.time < CROSS_FADE_LENGTH && _prevInfos.Count > 0) // in cross fading
{
//Total weight
IM.Number totalWeight = IM.Number.zero;
foreach (PlayInfo prevInfo in _prevInfos)
{
totalWeight += prevInfo.blendWeight;
}
totalWeight += _curInfo.blendWeight;
//RootMotion total weight
IM.Number rmTotalWeight = IM.Number.zero;
if (calcRootMotion)
{
foreach (PlayInfo prevInfo in _prevInfos)
{
if (prevInfo.enableRootMotion)
{
rmTotalWeight += prevInfo.blendWeight;
}
}
if (_curInfo.enableRootMotion)
{
rmTotalWeight += _curInfo.blendWeight;
}
}
// Previous play info
foreach (PlayInfo prevInfo in _prevInfos)
{
if (prevInfo.blendWeight <= IM.Number.zero)
{
continue;
}
IM.Number ratio = prevInfo.blendWeight / totalWeight;
IM.Vector3 position;
IM.Number angle;
GetNodePosAndRot(prevInfo, node, out position, out angle);
pos += position * ratio;
horiAngle += angle * ratio;
/*
* Debug.Log(string.Format(Time.frameCount +
* " GetNodePos blend, {0} node:{8} weight:{1} {6} ratio:{2} pos:{3} speed:{4} time:{5} isPlaying:{7}",
* GetOriginName(prevInfo.clipName), prevInfo.blendWeight, ratio, position,
* _animation[prevInfo.clipName].speed, _animation[prevInfo.clipName].time,
* _animation[prevInfo.clipName].weight, _animation.IsPlaying(prevInfo.clipName), node));
* //*/
if (calcRootMotion && prevInfo.enableRootMotion)
{
IM.Number rmRatio = prevInfo.blendWeight / rmTotalWeight;
prevInfo.rootMotion.Apply(position, angle, rmRatio);
}
}
// Current play info
IM.Number curRatio = _curInfo.blendWeight / totalWeight;
IM.Vector3 curPosition;
IM.Number curAngle;
GetNodePosAndRot(_curInfo, node, out curPosition, out curAngle);
pos += curPosition * curRatio;
horiAngle += curAngle * curRatio;
/*
* Debug.Log(string.Format(Time.frameCount +
* " GetNodePos blend, {0}, node:{8}, weight:{1} {4} ratio:{2} pos:{3} speed:{5} time:{6} isPlaying:{7}",
* GetOriginName(_curInfo.clipName), _curInfo.blendWeight, curRatio, curPosition,
* _animation[_curInfo.clipName].weight, _animation[_curInfo.clipName].speed,
* _animation[_curInfo.clipName].time, _animation.IsPlaying(_curInfo.clipName), node));
* //*/
if (calcRootMotion && _curInfo.enableRootMotion)
{
IM.Number rmRatio = _curInfo.blendWeight / rmTotalWeight;
_curInfo.rootMotion.Apply(curPosition, curAngle, rmRatio);
}
}
else
{
// No blend between 2 animation
GetNodePosAndRot(_curInfo, node, out pos, out horiAngle);
if (calcRootMotion && _curInfo.enableRootMotion)
{
_curInfo.rootMotion.Apply(pos, horiAngle, IM.Number.one);
}
}
/*
* Debug.Log(string.Format(Time.frameCount +
* " GetNodePos, clip:{0} node:{1} time:{2} - {3} pos:{4} key:{5} - {6}",
* _animation[_curInfo.clipName].clip.name, node, _curInfo.time,
* _animation[_curInfo.clipName].time,// % _animation[_curInfo.clipName].length,
* pos, _curInfo.keyFrameIndex1, _curInfo.keyFrameIndex2));
* //*/
if (calcRootMotion)
{
pos = deltaMove;
horiAngle = deltaAngle;
}
}
public void ReadConfig()
{
if (isLoadFinish == false)
{
return;
}
isLoadFinish = false;
lock (LockObject) { GameSystem.Instance.readConfigCnt += 1; }
string text = ResourceLoadManager.Instance.GetConfigText(XML_ASSET_NAME);
if (text == null)
{
ErrorDisplay.Instance.HandleLog("LoadConfig failed: " + XML_ASSET_NAME, "", LogType.Error);
return;
}
datas.Clear();
XmlDocument doc = new XmlDocument();
doc.LoadXml(text);
XmlNode root = doc.SelectSingleNode("AnimationSamples");
foreach (XmlNode motion in root.SelectNodes("Animation"))
{
AnimData animData = new AnimData();
string name = motion.Attributes["name"].Value;
datas.Add(name, animData);
animData.wrapMode = (WrapMode)(int.Parse(motion.Attributes["wrapMode"].Value));
animData.frameRate = IM.Number.Parse(motion.Attributes["frameRate"].Value);
animData.sampleDatas = new List <SampleData>();
foreach (XmlNode sample in motion.SelectNodes("Sample"))
{
IM.Number time = IM.Number.Parse(sample.Attributes["time"].Value);
SampleData data = new SampleData();
data.time = time;
animData.sampleDatas.Add(data);
data.nodes = new Dictionary <SampleNode, SampleNodeData>();
foreach (XmlNode node in sample.SelectNodes("Node"))
{
SampleNodeData nodeData = new SampleNodeData();
SampleNode nodeName = (SampleNode)(int.Parse(node.Attributes["name"].Value));
XmlAttribute attrPosition = node.Attributes["position"];
if (attrPosition != null)
{
nodeData.position = IM.Vector3.Parse(attrPosition.Value);
}
XmlAttribute attrHoriAngle = node.Attributes["hori_angle"];
if (attrHoriAngle != null)
{
nodeData.horiAngle = IM.Number.Parse(attrHoriAngle.Value);
}
data.nodes.Add(nodeName, nodeData);
}
}
animData.duration = animData.sampleDatas[animData.sampleDatas.Count - 1].time;
animData.eventDatas = new List <AnimEventData>();
foreach (XmlNode evt in motion.SelectNodes("Event"))
{
AnimEventData eventData = new AnimEventData();
eventData.time = IM.Number.Parse(evt.Attributes["time"].Value);
eventData.funcName = evt.Attributes["func"].Value;
XmlAttribute attrIntParam = evt.Attributes["int_param"];
if (attrIntParam != null)
{
eventData.intParameter = int.Parse(attrIntParam.Value);
}
XmlAttribute attrStringParam = evt.Attributes["string_param"];
if (attrStringParam != null)
{
eventData.stringParameter = attrStringParam.Value;
}
XmlAttribute attrFloatParam = evt.Attributes["float_param"];
if (attrFloatParam != null)
{
eventData.floatParameter = IM.Number.Parse(attrFloatParam.Value);
}
animData.eventDatas.Add(eventData);
}
//按事件时间排序
animData.eventDatas.Sort((d1, d2) => d1.time < d2.time ? -1 : (d1.time > d2.time ? 1 : 0));
}
}