public static PlayableHandle CreateAnimationClipPlayable(this PlayableGraph graph, AnimationClip clip)
        {
            PlayableHandle @null = PlayableHandle.Null;
            PlayableHandle result;

            if (!AnimationPlayableGraphExtensions.InternalCreateAnimationClipPlayable(ref graph, clip, ref @null))
            {
                result = PlayableHandle.Null;
            }
            else
            {
                result = @null;
            }
            return(result);
        }
        public static AnimationPlayableOutput GetAnimationOutput(this PlayableGraph graph, int index)
        {
            AnimationPlayableOutput animationPlayableOutput = default(AnimationPlayableOutput);
            AnimationPlayableOutput result;

            if (!AnimationPlayableGraphExtensions.InternalGetAnimationOutput(ref graph, index, out animationPlayableOutput.m_Output))
            {
                result = AnimationPlayableOutput.Null;
            }
            else
            {
                result = animationPlayableOutput;
            }
            return(result);
        }
        public static PlayableHandle CreateAnimatorControllerPlayable(this PlayableGraph graph, RuntimeAnimatorController controller)
        {
            PlayableHandle @null = PlayableHandle.Null;
            PlayableHandle result;

            if (!AnimationPlayableGraphExtensions.InternalCreateAnimatorControllerPlayable(ref graph, controller, ref @null))
            {
                result = PlayableHandle.Null;
            }
            else
            {
                result = @null;
            }
            return(result);
        }
        public static AnimationPlayableOutput CreateAnimationOutput(this PlayableGraph graph, string name, Animator target)
        {
            AnimationPlayableOutput animationPlayableOutput = default(AnimationPlayableOutput);
            AnimationPlayableOutput result;

            if (!AnimationPlayableGraphExtensions.InternalCreateAnimationOutput(ref graph, name, out animationPlayableOutput.m_Output))
            {
                result = AnimationPlayableOutput.Null;
            }
            else
            {
                animationPlayableOutput.target = target;
                result = animationPlayableOutput;
            }
            return(result);
        }
        public static PlayableHandle CreateAnimationMixerPlayable(this PlayableGraph graph, [DefaultValue("0")] int inputCount, [DefaultValue("false")] bool normalizeWeights)
        {
            PlayableHandle @null = PlayableHandle.Null;
            PlayableHandle result;

            if (!AnimationPlayableGraphExtensions.InternalCreateAnimationMixerPlayable(ref graph, inputCount, normalizeWeights, ref @null))
            {
                result = PlayableHandle.Null;
            }
            else
            {
                @null.inputCount = inputCount;
                result           = @null;
            }
            return(result);
        }
        internal static PlayableHandle CreateAnimationLayerMixerPlayable(this PlayableGraph graph, [DefaultValue("0")] int inputCount)
        {
            PlayableHandle @null = PlayableHandle.Null;
            PlayableHandle result;

            if (!AnimationPlayableGraphExtensions.InternalCreateAnimationLayerMixerPlayable(ref graph, ref @null))
            {
                result = PlayableHandle.Null;
            }
            else
            {
                @null.inputCount = inputCount;
                result           = @null;
            }
            return(result);
        }
        internal static PlayableHandle CreateAnimationMotionXToDeltaPlayable(this PlayableGraph graph)
        {
            PlayableHandle @null = PlayableHandle.Null;
            PlayableHandle result;

            if (!AnimationPlayableGraphExtensions.InternalCreateAnimationMotionXToDeltaPlayable(ref graph, ref @null))
            {
                result = PlayableHandle.Null;
            }
            else
            {
                @null.inputCount = 1;
                result           = @null;
            }
            return(result);
        }
        internal static PlayableHandle CreateAnimationOffsetPlayable(this PlayableGraph graph, Vector3 position, Quaternion rotation, int inputCount)
        {
            PlayableHandle @null = PlayableHandle.Null;
            PlayableHandle result;

            if (!AnimationPlayableGraphExtensions.InternalCreateAnimationOffsetPlayable(ref graph, position, rotation, ref @null))
            {
                result = PlayableHandle.Null;
            }
            else
            {
                @null.inputCount = inputCount;
                result           = @null;
            }
            return(result);
        }
 private static bool InternalCreateAnimationMixerPlayable(ref PlayableGraph graph, int inputCount, bool normalizeWeights, ref PlayableHandle handle)
 {
     return(AnimationPlayableGraphExtensions.INTERNAL_CALL_InternalCreateAnimationMixerPlayable(ref graph, inputCount, normalizeWeights, ref handle));
 }
 private static bool InternalCreateAnimationClipPlayable(ref PlayableGraph graph, AnimationClip clip, ref PlayableHandle handle)
 {
     return(AnimationPlayableGraphExtensions.INTERNAL_CALL_InternalCreateAnimationClipPlayable(ref graph, clip, ref handle));
 }
 internal static void SyncUpdateAndTimeMode(this PlayableGraph graph, Animator animator)
 {
     AnimationPlayableGraphExtensions.InternalSyncUpdateAndTimeMode(ref graph, animator);
 }
 public static int GetAnimationOutputCount(this PlayableGraph graph)
 {
     return(AnimationPlayableGraphExtensions.InternalAnimationOutputCount(ref graph));
 }
 public static void DestroyOutput(this PlayableGraph graph, AnimationPlayableOutput output)
 {
     AnimationPlayableGraphExtensions.InternalDestroyOutput(ref graph, ref output.m_Output);
 }
 private static bool InternalCreateAnimationMotionXToDeltaPlayable(ref PlayableGraph graph, ref PlayableHandle handle)
 {
     return(AnimationPlayableGraphExtensions.INTERNAL_CALL_InternalCreateAnimationMotionXToDeltaPlayable(ref graph, ref handle));
 }
 private static bool InternalCreateAnimationOffsetPlayable(ref PlayableGraph graph, Vector3 position, Quaternion rotation, ref PlayableHandle handle)
 {
     return(AnimationPlayableGraphExtensions.INTERNAL_CALL_InternalCreateAnimationOffsetPlayable(ref graph, ref position, ref rotation, ref handle));
 }
 private static bool InternalCreateAnimatorControllerPlayable(ref PlayableGraph graph, RuntimeAnimatorController controller, ref PlayableHandle handle)
 {
     return(AnimationPlayableGraphExtensions.INTERNAL_CALL_InternalCreateAnimatorControllerPlayable(ref graph, controller, ref handle));
 }