public void pauseClip(bool status)
{
if (Application.isPlaying && currentAudio != null)
{
if (status)
{
StartCoroutine(
MyAnimationController.playAnimation(
audioPauseContinueAnimator,
"pause"
)
);
currentAudio.Pause();
}
else
{
StartCoroutine(
MyAnimationController.playAnimation(
audioPauseContinueAnimator,
"play"
)
);
currentAudio.UnPause();
}
}
}
public unsafe void Init(MyCharacterBone[] bones, MyAnimationController controller)
{
List <MyAnimationStateMachine> list = new List <MyAnimationStateMachine>(controller.GetLayerCount());
for (int i = 0; i < controller.GetLayerCount(); i++)
{
list.Add(controller.GetLayerByIndex(i));
}
this.m_boneIndexToData = new BoneData[bones.Length];
foreach (MyCharacterBone bone in bones)
{
BoneData *dataPtr1;
BoneData data = new BoneData {
WeightId = MyStringId.GetOrCompute("rd_weight_" + bone.Name),
BlendTimeId = MyStringId.GetOrCompute("rd_blend_time_" + bone.Name),
BlendTimeMs = -1.0,
StartingWeight = 0f,
TargetWeight = 0f,
PrevWeight = 0f
};
dataPtr1->Layers = (from layer in list
where layer.BoneMask[bone.Index]
select new LayerData {
LayerId = MyStringId.GetOrCompute("rd_weight_" + layer.Name),
LayerBlendTimeId = MyStringId.GetOrCompute("rd_blend_time_" + layer.Name)
}).ToArray <LayerData>();
dataPtr1 = (BoneData *)ref data;
this.m_boneIndexToData[bone.Index] = data;
}
this.m_defautlBlendTimeId = MyStringId.GetOrCompute("rd_default_blend_time");
this.Initialized = true;
}
// Convert one condition from object builder to in-game representation.
private static MyCondition <float> ParseOneCondition(MyAnimationController animationController,
MyObjectBuilder_AnimationSMCondition objBuilderCondition)
{
MyCondition <float> condition;
if (objBuilderCondition.ValueLeft == null || objBuilderCondition.ValueRight == null)
{
Debug.Fail("Missing operand in transition condition.");
return(null);
}
double lhs, rhs;
if (Double.TryParse(objBuilderCondition.ValueLeft, out lhs))
{
if (Double.TryParse(objBuilderCondition.ValueRight, out rhs))
{
condition =
new VRage.Generics.StateMachine.MyCondition <float>(
animationController.Variables,
ConvertOperation(objBuilderCondition.Operation), (float)lhs,
(float)rhs);
}
else
{
condition =
new VRage.Generics.StateMachine.MyCondition <float>(
animationController.Variables,
ConvertOperation(objBuilderCondition.Operation), (float)lhs,
objBuilderCondition.ValueRight);
}
}
else
{
if (Double.TryParse(objBuilderCondition.ValueRight, out rhs))
{
condition =
new VRage.Generics.StateMachine.MyCondition <float>(
animationController.Variables,
ConvertOperation(objBuilderCondition.Operation),
objBuilderCondition.ValueLeft, (float)rhs);
}
else
{
condition =
new VRage.Generics.StateMachine.MyCondition <float>(
animationController.Variables,
ConvertOperation(objBuilderCondition.Operation),
objBuilderCondition.ValueLeft, objBuilderCondition.ValueRight);
}
}
return(condition);
}
// Convert one condition from object builder to in-game representation.
private static MyCondition <float> ParseOneCondition(MyAnimationController animationController,
MyObjectBuilder_AnimationSMCondition objBuilderCondition)
{
MyCondition <float> condition;
objBuilderCondition.ValueLeft = objBuilderCondition.ValueLeft != null?objBuilderCondition.ValueLeft.ToLower() : "0";
objBuilderCondition.ValueRight = objBuilderCondition.ValueRight != null?objBuilderCondition.ValueRight.ToLower() : "0";
double lhs, rhs;
if (Double.TryParse(objBuilderCondition.ValueLeft, System.Globalization.NumberStyles.Float, System.Globalization.CultureInfo.InvariantCulture, out lhs))
{
if (Double.TryParse(objBuilderCondition.ValueRight, System.Globalization.NumberStyles.Float, System.Globalization.CultureInfo.InvariantCulture, out rhs))
{
condition =
new VRage.Generics.StateMachine.MyCondition <float>(
animationController.Variables,
ConvertOperation(objBuilderCondition.Operation), (float)lhs,
(float)rhs);
}
else
{
condition =
new VRage.Generics.StateMachine.MyCondition <float>(
animationController.Variables,
ConvertOperation(objBuilderCondition.Operation), (float)lhs,
objBuilderCondition.ValueRight);
}
}
else
{
if (Double.TryParse(objBuilderCondition.ValueRight, System.Globalization.NumberStyles.Float, System.Globalization.CultureInfo.InvariantCulture, out rhs))
{
condition =
new VRage.Generics.StateMachine.MyCondition <float>(
animationController.Variables,
ConvertOperation(objBuilderCondition.Operation),
objBuilderCondition.ValueLeft, (float)rhs);
}
else
{
condition =
new VRage.Generics.StateMachine.MyCondition <float>(
animationController.Variables,
ConvertOperation(objBuilderCondition.Operation),
objBuilderCondition.ValueLeft, objBuilderCondition.ValueRight);
}
}
return(condition);
}
// Resumen:
// playAnimation(string animationName, Action callBack, bool
// checkOtherAnimationPlaying = true) plays the animation
// indicated by animationName on the animator, then the
// callBack function is executed. The
// checkOtherAnimationPlaying parameter prevents the execution
// of a new animation if there is any currently playing.
protected void playAnimation(string animationName, Action callBack, bool checkOtherAnimationPlaying = true)
{
if (checkOtherAnimationPlaying && MyAnimationController.isAnyAnimationPlaying())
{
return;
}
StartCoroutine(
MyAnimationController.playAnimationThenDoSomething(
animator,
animationName,
() => callBack()
)
);
}
private void LiveDebugging_SendAnimationStateChangesToEditor(MyAnimationController animController)
{
if (animController == null)
{
return;
}
int layerCount = animController.GetLayerCount();
if (layerCount != m_debuggingAnimControllerCurrentNodes.Count)
{
m_debuggingAnimControllerCurrentNodes.Clear();
for (int i = 0; i < layerCount; i++)
{
m_debuggingAnimControllerCurrentNodes.Add(null);
}
m_debuggingAnimControllerTreePath.Clear();
for (int i = 0; i < layerCount; i++)
{
m_debuggingAnimControllerTreePath.Add(new int[animController.GetLayerByIndex(i).VisitedTreeNodesPath.Length]);
}
}
for (int i = 0; i < layerCount; i++)
{
var layerVisitedTreeNodesPath = animController.GetLayerByIndex(i).VisitedTreeNodesPath;
if (animController.GetLayerByIndex(i).CurrentNode != m_debuggingAnimControllerCurrentNodes[i] ||
!LiveDebugging_CompareAnimTreePathSeqs(layerVisitedTreeNodesPath, m_debuggingAnimControllerTreePath[i]))
{
Array.Copy(layerVisitedTreeNodesPath, m_debuggingAnimControllerTreePath[i], layerVisitedTreeNodesPath.Length); // local copy
m_debuggingAnimControllerCurrentNodes[i] = animController.GetLayerByIndex(i).CurrentNode;
if (m_debuggingAnimControllerCurrentNodes[i] != null)
{
var msg =
MyExternalDebugStructures.ACSendStateToEditorMsg.Create(m_debuggingAnimControllerCurrentNodes[i].Name, m_debuggingAnimControllerTreePath[i]);
MySessionComponentExtDebug.Static.SendMessageToClients(msg);
}
}
}
}
private void ReproducePauseContinueBtns(string stateName)
{
if (stateName == "init")
{
StartCoroutine(
MyAnimationController.playAnimation(
audioPauseContinueAnimator,
"donotletcontinue"
)
);
}
else if (stateName == "play")
{
StartCoroutine(
MyAnimationController.playAnimation(
audioPauseContinueAnimator,
"play"
)
);
}
}
private static void CreateTransition(MyAnimationStateMachine layer, MyAnimationController animationController,
string absoluteNameNodeFrom, string absoluteNameNodeTo, MyObjectBuilder_AnimationSMTransition objBuilderTransition)
{
int conditionConjunctionIndex = 0;
do
{
// generate transition for each condition conjunction
var transition = layer.AddTransition(absoluteNameNodeFrom, absoluteNameNodeTo,
new VRage.Animations.MyAnimationStateMachineTransition()) as
VRage.Animations.MyAnimationStateMachineTransition;
// if ok, fill in conditions
if (transition != null)
{
transition.Name =
MyStringId.GetOrCompute(objBuilderTransition.Name != null ? objBuilderTransition.Name.ToLower() : null);
transition.TransitionTimeInSec = objBuilderTransition.TimeInSec;
transition.Sync = objBuilderTransition.Sync;
transition.Priority = objBuilderTransition.Priority;
if (objBuilderTransition.Conditions != null &&
objBuilderTransition.Conditions[conditionConjunctionIndex] != null)
{
var conjunctionOfConditions =
objBuilderTransition.Conditions[conditionConjunctionIndex].Conditions;
foreach (var objBuilderCondition in conjunctionOfConditions)
{
var condition = ParseOneCondition(animationController, objBuilderCondition);
if (condition != null)
{
transition.Conditions.Add(condition);
}
}
}
}
conditionConjunctionIndex++;
} while (objBuilderTransition.Conditions != null &&
conditionConjunctionIndex < objBuilderTransition.Conditions.Length);
}
// Initialize state machine of one layer.
private static bool InitLayerNodes(MyAnimationStateMachine layer, string stateMachineName, MyAnimationControllerDefinition animControllerDefinition,
MyAnimationController animationController, string currentNodeNamePrefix, MyAnimationVirtualNodes virtualNodes)
{
var objBuilderStateMachine = animControllerDefinition.StateMachines.FirstOrDefault(x => x.Name == stateMachineName);
if (objBuilderStateMachine == null)
{
Debug.Fail("Animation state machine " + stateMachineName + " was not found.");
return(false);
}
bool result = true;
// 1st step: generate nodes
if (objBuilderStateMachine.Nodes != null)
{
foreach (var objBuilderNode in objBuilderStateMachine.Nodes)
{
string absoluteNodeName = currentNodeNamePrefix + objBuilderNode.Name;
if (objBuilderNode.StateMachineName != null)
{
// embedded state machine, copy its nodes
if (!InitLayerNodes(layer, objBuilderNode.StateMachineName, animControllerDefinition, animationController, absoluteNodeName + "/", virtualNodes))
{
result = false;
}
}
else
{
var smNode = new VRage.Animations.MyAnimationStateMachineNode(absoluteNodeName);
if (objBuilderNode.Type == MyObjectBuilder_AnimationSMNode.MySMNodeType.PassThrough ||
objBuilderNode.Type == MyObjectBuilder_AnimationSMNode.MySMNodeType.Any ||
objBuilderNode.Type == MyObjectBuilder_AnimationSMNode.MySMNodeType.AnyExceptTarget)
{
smNode.PassThrough = true;
}
else
{
smNode.PassThrough = false;
}
if (objBuilderNode.Type == MyObjectBuilder_AnimationSMNode.MySMNodeType.Any ||
objBuilderNode.Type == MyObjectBuilder_AnimationSMNode.MySMNodeType.AnyExceptTarget)
{
virtualNodes.NodesAny.Add(absoluteNodeName, new MyAnimationVirtualNodeData()
{
AnyNodePrefix = currentNodeNamePrefix,
ExceptTarget = (objBuilderNode.Type == MyObjectBuilder_AnimationSMNode.MySMNodeType.AnyExceptTarget)
});
}
layer.AddNode(smNode);
if (objBuilderNode.AnimationTree != null)
{
var smNodeAnimTree = InitNodeAnimationTree(objBuilderNode.AnimationTree.Child);
smNode.RootAnimationNode = smNodeAnimTree;
}
else
{
smNode.RootAnimationNode = new MyAnimationTreeNodeDummy();
}
}
}
}
// 2nd step: generate transitions
if (objBuilderStateMachine.Transitions != null)
{
foreach (var objBuilderTransition in objBuilderStateMachine.Transitions)
{
string absoluteNameNodeFrom = currentNodeNamePrefix + objBuilderTransition.From;
string absoluteNameNodeTo = currentNodeNamePrefix + objBuilderTransition.To;
MyAnimationVirtualNodeData virtualNodeData;
if (virtualNodes.NodesAny.TryGetValue(absoluteNameNodeFrom, out virtualNodeData))
{
// nodes of type "any":
// "any" node is source: we create transitions directly from all nodes
// "any" node is target: we will use "any" node as pass through
foreach (var nodeFromCandidate in layer.AllNodes)
{
if (nodeFromCandidate.Key.StartsWith(virtualNodeData.AnyNodePrefix) && // select nodes in the same SM
nodeFromCandidate.Key != absoluteNameNodeFrom) // disallow from "any" to the same "any"
{
// create transition if target is different from source or when we don't care about it
if (!virtualNodeData.ExceptTarget || absoluteNameNodeTo != nodeFromCandidate.Key)
{
CreateTransition(layer, animationController, nodeFromCandidate.Key, absoluteNameNodeTo, objBuilderTransition);
}
}
}
}
CreateTransition(layer, animationController, absoluteNameNodeFrom, absoluteNameNodeTo, objBuilderTransition);
}
}
return(result);
}
