Beispiel #1
0
 private void ProcessFootIK(UltimateIK.Model ik, float contact)
 {
     ik.Activation = UltimateIK.ACTIVATION.Constant;
     for (int i = 0; i < ik.Objectives.Length; i++)
     {
         ik.Objectives[i].SetTarget(Vector3.Lerp(ik.Objectives[i].TargetPosition, ik.Bones[ik.Objectives[i].Bone].Transform.position, 1f - contact));
         ik.Objectives[i].SetTarget(ik.Bones[ik.Objectives[i].Bone].Transform.rotation);
     }
     ik.Iterations = 25;
     ik.Solve();
 }
 private void ProcessHandIK(UltimateIK.Model ik, float contact)
 {
     if (Carrier)
     {
         ik.Activation = UltimateIK.ACTIVATION.Linear;
         ik.Objectives.First().SetTarget(Vector3.Lerp(ik.Bones.Last().Transform.position, DribbleSeries.BallTransformations[TimeSeries.Pivot].GetPosition(), contact));
         ik.Objectives.First().SetTarget(ik.Bones.Last().Transform.rotation);
         ik.Iterations = 50;
         ik.Solve();
     }
 }
 private void ProcessFootIK(UltimateIK.Model ik, float contact)
 {
     ik.Activation = UltimateIK.ACTIVATION.Constant;
     ik.Objectives.First().SetTarget(Vector3.Lerp(ik.Objectives[0].TargetPosition, ik.Bones.Last().Transform.position, 1f - contact));
     if (Carrier && Controller.QueryLogic("Hold"))
     {
         ik.Objectives.First().SetTarget(Quaternion.Slerp(ik.Objectives[0].TargetRotation, ik.Bones.Last().Transform.rotation, 1f - contact));
     }
     else
     {
         ik.Objectives.First().SetTarget(ik.Bones.Last().Transform.rotation);
     }
     ik.Iterations = 50;
     ik.Solve();
 }
    public override void Callback(MotionEditor editor)
    {
        if (EditMotion)
        {
            float delta = 1f / editor.TargetFramerate;
            Actor actor = editor.GetActor();
            IK = UltimateIK.BuildModel(IK, actor.Bones[0].Transform, GetObjectives(actor));
            if (IK.Objectives.Length == 0)
            {
                return;
            }
            IK.Iterations       = 50;
            IK.Activation       = UltimateIK.ACTIVATION.Constant;
            IK.RootTranslationY = true;
            IK.SetWeights(GetWeights());
            bool[] solvePositions = GetSolvePositions();
            bool[] solveRotations = GetSolveRotations();
            for (int i = 0; i < IK.Objectives.Length; i++)
            {
                IK.Objectives[i].SolvePosition = solvePositions[i];
                IK.Objectives[i].SolveRotation = solveRotations[i];
            }

            Frame frame    = editor.GetCurrentFrame();
            Frame relative = (frame.Timestamp - delta) < 0f ? Data.GetFrame(frame.Timestamp + delta) : Data.GetFrame(frame.Timestamp - delta);
            actor.WriteTransforms(relative.GetBoneTransformations(editor.Mirror), Data.Source.GetBoneNames());
            IK.Solve(GetTargets(relative, editor.Mirror));
            Matrix4x4[] relativePosture = actor.GetBoneTransformations();
            actor.WriteTransforms(frame.GetBoneTransformations(editor.Mirror), Data.Source.GetBoneNames());
            IK.Solve(GetTargets(frame, editor.Mirror));
            Matrix4x4[] framePosture = actor.GetBoneTransformations();

            for (int i = 0; i < actor.Bones.Length; i++)
            {
                actor.Bones[i].Velocity = (frame.Timestamp - delta) < 0f ?
                                          (relativePosture[i].GetPosition() - framePosture[i].GetPosition()) / delta:
                                          (framePosture[i].GetPosition() - relativePosture[i].GetPosition()) / delta;
            }
        }
    }
    protected override void Setup()
    {
        Collider   = GetComponent <CapsuleCollider>();
        Controller = new Controller(PlayerID);

        GenerativeModel = GetComponent <GenerativeControl>();

        Controller.Logic    stand           = Controller.AddLogic("Stand", () => Controller.QueryLeftJoystickVector().magnitude < 0.25f);
        Controller.Function standControl    = Controller.AddFunction("StandControl", (x) => TimeSeries.GetControl((int)x, 0.5f, 0.1f, 1f));
        Controller.Function standCorrection = Controller.AddFunction("StandCorrection", (x) => TimeSeries.GetCorrection((int)x, 0.1f, 1f, 0f));

        Controller.Logic    move           = Controller.AddLogic("Move", () => !stand.Query() && !Controller.GetButton(Controller.Button.Y));
        Controller.Function moveControl    = Controller.AddFunction("MoveControl", (x) => TimeSeries.GetControl((int)x, 0.5f, 0.1f, 1f));
        Controller.Function moveCorrection = Controller.AddFunction("MoveCorrection", (x) => TimeSeries.GetCorrection((int)x, 0.1f, 1f, 0f));

        Controller.Logic    hold           = Controller.AddLogic("Hold", () => Controller.GetButton(Controller.Button.B));
        Controller.Function holdControl    = Controller.AddFunction("HoldControl", (x) => TimeSeries.GetControl((int)x, hold.Query() ? 0.5f : 1f, 0.1f, 1f));
        Controller.Function holdCorrection = Controller.AddFunction("HoldCorrection", (x) => TimeSeries.GetCorrection((int)x, hold.Query() ? 0.1f : 0f, 1f, 0f));

        Controller.Logic    shoot           = Controller.AddLogic("Shoot", () => Carrier && Controller.GetButton(Controller.Button.Y));
        Controller.Function shootControl    = Controller.AddFunction("ShootControl", (x) => TimeSeries.GetControl((int)x, shoot.Query() ? 0.5f : 1f, 0.1f, 1f));
        Controller.Function shootCorrection = Controller.AddFunction("ShootCorrection", (x) => TimeSeries.GetCorrection((int)x, shoot.Query() ? 0.1f : 0f, 1f, 0f));

        Controller.Logic    dribble           = Controller.AddLogic("Dribble", () => Carrier && !hold.Query() && !shoot.Query());
        Controller.Function dribbleControl    = Controller.AddFunction("DribbleControl", (x) => TimeSeries.GetControl((int)x, hold.Query() || shoot.Query() ? 0.5f : 1f, 0.1f, 1f));
        Controller.Function dribbleCorrection = Controller.AddFunction("DribbleCorrection", (x) => TimeSeries.GetCorrection((int)x, hold.Query() || shoot.Query() ? 0.1f : 0f, 1f, 0f));

        Controller.Logic sprint = Controller.AddLogic("Sprint", () => move.Query() && Controller.QueryLeftJoystickVector().y > 0.25f);

        Controller.Logic spin = Controller.AddLogic("Spin", () => move.Query() && Controller.QueryButtonController() != 0f);

        Controller.Logic horizontalControl = Controller.AddLogic("HorizontalControl", () =>
                                                                 !Carrier && hold.Query() ||
                                                                 Carrier && !spin.Query() && Controller.QueryRightJoystickVector().magnitude > 0.1f
                                                                 );
        Controller.Logic heightControl = Controller.AddLogic("HeightControl", () =>
                                                             !Carrier && hold.Query() ||
                                                             Carrier && Controller.QueryDPadController().z != 0f ||
                                                             Carrier && hold.Query() && horizontalControl.Query()
                                                             );
        Controller.Logic speedControl = Controller.AddLogic("SpeedControl", () =>
                                                            !Carrier && hold.Query() ||
                                                            Carrier && dribble.Query() && DribbleSeries.Pivots[TimeSeries.Pivot].y > HeightDribbleThreshold ||
                                                            Carrier && dribble.Query() && DribbleSeries.Momentums[TimeSeries.Pivot].y < SpeedDribbleThreshold
                                                            );

        Controller.Function phaseStability = Controller.AddFunction("PhaseStability", (x) => TimeSeries.GetCorrection((int)x,
                                                                                                                      1f,
                                                                                                                      0.9f,
                                                                                                                      0.1f
                                                                                                                      ));

        Controller.Logic rootControl = Controller.AddLogic("RootControl", () => true);

        Controller.Function rootPositionControl = Controller.AddFunction("RootPositionControl", (x) => TimeSeries.GetControl((int)x,
                                                                                                                             rootControl.Query() ? 0.25f : 0f,
                                                                                                                             0.1f,
                                                                                                                             1f
                                                                                                                             ));

        Controller.Function rootPositionCorrection = Controller.AddFunction("RootPositionCorrection", (x) => TimeSeries.GetCorrection((int)x,
                                                                                                                                      rootControl.Query() ? 0.25f : 1f,
                                                                                                                                      1f,
                                                                                                                                      0f
                                                                                                                                      ));

        Controller.Function rootRotationControl = Controller.AddFunction("RootRotationControl", (x) => TimeSeries.GetControl((int)x,
                                                                                                                             rootControl.Query() ? 0.5f : 0f,
                                                                                                                             0.1f,
                                                                                                                             1f
                                                                                                                             ));

        Controller.Function rootRotationCorrection = Controller.AddFunction("RootRotationCorrection", (x) => TimeSeries.GetCorrection((int)x,
                                                                                                                                      rootControl.Query() ? 0.25f : 1f,
                                                                                                                                      1f,
                                                                                                                                      0f
                                                                                                                                      ));

        Controller.Function rootVelocityControl = Controller.AddFunction("RootVelocityControl", (x) => TimeSeries.GetControl((int)x,
                                                                                                                             rootControl.Query() ? 0.75f : 0f,
                                                                                                                             0.1f,
                                                                                                                             1f
                                                                                                                             ));

        Controller.Function rootVelocityCorrection = Controller.AddFunction("RootVelocityCorrection", (x) => TimeSeries.GetCorrection((int)x,
                                                                                                                                      rootControl.Query() ? 0.25f : 1f,
                                                                                                                                      1f,
                                                                                                                                      0f
                                                                                                                                      ));

        Controller.Function ballHorizontalControl = Controller.AddFunction("BallHorizontalControl", (x) => TimeSeries.GetControl((int)x,
                                                                                                                                 horizontalControl.Query() ? 0.2f : 0f,
                                                                                                                                 0f,
                                                                                                                                 0.5f
                                                                                                                                 ));

        Controller.Function ballHorizontalCorrection = Controller.AddFunction("BallHorizontalCorrection", (x) => TimeSeries.GetCorrection(
                                                                                  (int)x, horizontalControl.Query() ? 0.2f : 1f,
                                                                                  0.5f,
                                                                                  0f
                                                                                  ));

        Controller.Function ballHeightControl = Controller.AddFunction("BallHeightControl", (x) => TimeSeries.GetControl(
                                                                           (int)x, heightControl.Query() ? 0.1f : 0f,
                                                                           0f,
                                                                           0.5f
                                                                           ));

        Controller.Function ballHeightCorrection = Controller.AddFunction("BallHeightCorrection", (x) => TimeSeries.GetCorrection(
                                                                              (int)x, heightControl.Query() ? 0.1f : 1f,
                                                                              0.5f,
                                                                              0f
                                                                              ));

        Controller.Function ballSpeedControl = Controller.AddFunction("BallSpeedControl", (x) => TimeSeries.GetControl(
                                                                          (int)x, speedControl.Query() ? 0.1f : 0f,
                                                                          0f,
                                                                          0.5f
                                                                          ));

        Controller.Function ballSpeedCorrection = Controller.AddFunction("BallSpeedCorrection", (x) => TimeSeries.GetCorrection(
                                                                             (int)x, speedControl.Query() ? 0.1f : 1f,
                                                                             0.5f,
                                                                             0f
                                                                             ));

        TimeSeries    = new TimeSeries(6, 6, 1f, 1f, 5);
        RootSeries    = new RootSeries(TimeSeries, transform);
        DribbleSeries = new DribbleSeries(TimeSeries, 2.5f, Ball.transform, Actor, RootSeries, null, null);
        StyleSeries   = new StyleSeries(TimeSeries, new string[] { "Stand", "Move", "Dribble", "Hold", "Shoot" }, new float[] { 1f, 0f, 1f, 0f, 0f });
        ContactSeries = new ContactSeries(TimeSeries, "Left Foot", "Right Foot", "Left Hand", "Right Hand", "Ball");
        PhaseSeries   = new PhaseSeries(TimeSeries, "Left Foot", "Right Foot", "Left Hand", "Right Hand", "Ball");

        BodyIK      = UltimateIK.BuildModel(Actor.FindTransform("Player 01:Hips"), Actor.GetBoneTransforms("Player 01:LeftFoot", "Player 01:RightFoot", "Player 01:LeftBallAux", "Player 01:RightBallAux"));
        LeftFootIK  = UltimateIK.BuildModel(Actor.FindTransform("Player 01:LeftUpLeg"), Actor.GetBoneTransforms("Player 01:LeftFoot"));
        RightFootIK = UltimateIK.BuildModel(Actor.FindTransform("Player 01:RightUpLeg"), Actor.GetBoneTransforms("Player 01:RightFoot"));
        LeftHandIK  = UltimateIK.BuildModel(Actor.FindTransform("Player 01:LeftArm"), Actor.GetBoneTransforms("Player 01:LeftBallAux"));
        RightHandIK = UltimateIK.BuildModel(Actor.FindTransform("Player 01:RightArm"), Actor.GetBoneTransforms("Player 01:RightBallAux"));
        HeadIK      = UltimateIK.BuildModel(Actor.FindTransform("Player 01:Neck"), Actor.GetBoneTransforms("Player 01:Head"));

        RootSeries.DrawGUI    = DrawGUI;
        StyleSeries.DrawGUI   = DrawGUI;
        DribbleSeries.DrawGUI = DrawGUI;
        ContactSeries.DrawGUI = DrawGUI;
        PhaseSeries.DrawGUI   = DrawGUI;
        GetComponent <ExpertActivation>().Draw = DrawGUI;
        RootSeries.DrawScene    = DrawDebug;
        StyleSeries.DrawScene   = DrawDebug;
        DribbleSeries.DrawScene = DrawDebug;
        ContactSeries.DrawScene = DrawDebug;
        PhaseSeries.DrawScene   = DrawDebug;
    }
    protected override void Setup()
    {
        Controller = new Controller();
        Controller.Signal idle = Controller.AddSignal("Idle");
        idle.Default  = true;
        idle.Velocity = 0f;
        idle.AddKey(KeyCode.W, false);
        idle.AddKey(KeyCode.A, false);
        idle.AddKey(KeyCode.S, false);
        idle.AddKey(KeyCode.D, false);
        idle.AddKey(KeyCode.Q, false);
        idle.AddKey(KeyCode.E, false);
        idle.AddKey(KeyCode.V, true);
        idle.UserControl    = 0.25f;
        idle.NetworkControl = 0.1f;

        Controller.Signal walk = Controller.AddSignal("Walk");
        walk.AddKey(KeyCode.W, true);
        walk.AddKey(KeyCode.A, true);
        walk.AddKey(KeyCode.S, true);
        walk.AddKey(KeyCode.D, true);
        walk.AddKey(KeyCode.Q, true);
        walk.AddKey(KeyCode.E, true);
        walk.AddKey(KeyCode.LeftShift, false);
        walk.AddKey(KeyCode.C, false);
        walk.Velocity       = 1f;
        walk.UserControl    = 0.25f;
        walk.NetworkControl = 0.25f;

        Controller.Signal run = Controller.AddSignal("Run");
        run.AddKey(KeyCode.LeftShift, true);
        run.Velocity       = 3f;
        run.UserControl    = 0.25f;
        run.NetworkControl = 0.25f;

        Controller.Signal carry = Controller.AddSignal("Carry");
        carry.AddKey(KeyCode.V, true);
        carry.Velocity       = 0f;
        carry.UserControl    = 0.1f;
        carry.NetworkControl = 0f;

        Controller.Signal open = Controller.AddSignal("Open");
        open.AddKey(KeyCode.F, true);
        open.Velocity       = 0f;
        open.UserControl    = 0.1f;
        open.NetworkControl = 0f;

        Controller.Signal sit = Controller.AddSignal("Sit");
        sit.AddKey(KeyCode.C, true);
        sit.Velocity       = 0f;
        sit.UserControl    = 0.25f;
        sit.NetworkControl = 0f;

        Environment = new CylinderMap(4f, 9, 9, true);
        Geometry    = new CuboidMap(new Vector3Int(8, 8, 8));

        TimeSeries    = new TimeSeries(6, 6, 1f, 1f, 5);
        RootSeries    = new TimeSeries.Root(TimeSeries);
        StyleSeries   = new TimeSeries.Style(TimeSeries, "Idle", "Walk", "Run", "Carry", "Open", "Sit", "Climb");
        GoalSeries    = new TimeSeries.Goal(TimeSeries, Controller.GetSignalNames());
        ContactSeries = new TimeSeries.Contact(TimeSeries, "Hips", "RightWrist", "LeftWrist", "RightAnkle", "LeftAnkle");
        PhaseSeries   = new TimeSeries.Phase(TimeSeries);
        for (int i = 0; i < TimeSeries.Samples.Length; i++)
        {
            RootSeries.Transformations[i] = transform.GetWorldMatrix(true);
            if (StyleSeries.Styles.Length > 0)
            {
                StyleSeries.Values[i][0] = 1f;
            }
            if (GoalSeries.Actions.Length > 0)
            {
                GoalSeries.Values[i][0] = 1f;
            }
            GoalSeries.Transformations[i] = transform.GetWorldMatrix(true);
            PhaseSeries.Values[i]         = Mathf.Repeat((float)i / GetFramerate(), 1f);
            Geometry.Pivot         = transform.GetWorldMatrix(true);
            Geometry.References[i] = transform.position;
        }

        PosePrediction = new Vector3[Actor.Bones.Length];
        RootPrediction = new Matrix4x4[7];
        GoalPrediction = new Matrix4x4[7];

        RightFootIK = UltimateIK.BuildModel(Actor.FindTransform("RightHip"), Actor.GetBoneTransforms(ContactSeries.Bones[3]));
        LeftFootIK  = UltimateIK.BuildModel(Actor.FindTransform("LeftHip"), Actor.GetBoneTransforms(ContactSeries.Bones[4]));
    }
Beispiel #7
0
    protected override void Setup()
    {
        Collider   = GetComponent <CapsuleCollider>();
        Controller = new Controller(1);

        Controller.Logic    idle            = Controller.AddLogic("Idle", () => Controller.QueryLeftJoystickVector().magnitude < 0.1f);
        Controller.Function idleControl     = Controller.AddFunction("IdleControl", (x) => TimeSeries.GetControl((int)x, ActionBias, 0.1f, ControlStrength));
        Controller.Function idleCorrection  = Controller.AddFunction("IdleCorrection", (x) => TimeSeries.GetCorrection((int)x, CorrectionBias, CorrectionStrength, 0f));
        Controller.Logic    move            = Controller.AddLogic("Move", () => !idle.Query());
        Controller.Function moveControl     = Controller.AddFunction("MoveControl", (x) => TimeSeries.GetControl((int)x, ActionBias, 0.1f, ControlStrength));
        Controller.Function moveCorrection  = Controller.AddFunction("MoveCorrection", (x) => TimeSeries.GetCorrection((int)x, CorrectionBias, CorrectionStrength, 0f));
        Controller.Logic    speed           = Controller.AddLogic("Speed", () => true);
        Controller.Function speedControl    = Controller.AddFunction("SpeedControl", (x) => TimeSeries.GetControl((int)x, ActionBias, 0.1f, ControlStrength));
        Controller.Function speedCorrection = Controller.AddFunction("SpeedCorrection", (x) => TimeSeries.GetCorrection((int)x, CorrectionBias, CorrectionStrength, 0f));

        Controller.Logic sprint = Controller.AddLogic("Sprint", () => move.Query() && Controller.QueryLeftJoystickVector().y > 0.25f);

        Controller.Function rootPositionControl = Controller.AddFunction("RootPositionControl", (x) => TimeSeries.GetControl((int)x,
                                                                                                                             PositionBias,
                                                                                                                             0.1f,
                                                                                                                             ControlStrength
                                                                                                                             ));
        Controller.Function rootPositionCorrection = Controller.AddFunction("RootPositionCorrection", (x) => TimeSeries.GetCorrection((int)x,
                                                                                                                                      CorrectionBias,
                                                                                                                                      CorrectionStrength,
                                                                                                                                      0f
                                                                                                                                      ));
        Controller.Function rootRotationControl = Controller.AddFunction("RootRotationControl", (x) => TimeSeries.GetControl((int)x,
                                                                                                                             RotationBias,
                                                                                                                             0.1f,
                                                                                                                             ControlStrength
                                                                                                                             ));
        Controller.Function rootRotationCorrection = Controller.AddFunction("RootRotationCorrection", (x) => TimeSeries.GetCorrection((int)x,
                                                                                                                                      CorrectionBias,
                                                                                                                                      CorrectionStrength,
                                                                                                                                      0f
                                                                                                                                      ));
        Controller.Function rootVelocityControl = Controller.AddFunction("RootVelocityControl", (x) => TimeSeries.GetControl((int)x,
                                                                                                                             VelocityBias,
                                                                                                                             0.1f,
                                                                                                                             ControlStrength
                                                                                                                             ));
        Controller.Function rootVelocityCorrection = Controller.AddFunction("RootVelocityCorrection", (x) => TimeSeries.GetCorrection((int)x,
                                                                                                                                      CorrectionBias,
                                                                                                                                      CorrectionStrength,
                                                                                                                                      0f
                                                                                                                                      ));

        Controller.Function phaseStability = Controller.AddFunction("PhaseStability", (x) => TimeSeries.GetCorrection((int)x,
                                                                                                                      2f,
                                                                                                                      1f,
                                                                                                                      0.5f
                                                                                                                      ));

        TimeSeries    = new TimeSeries(6, 6, 1f, 1f, 5);
        RootSeries    = new RootSeries(TimeSeries, transform);
        StyleSeries   = new StyleSeries(TimeSeries, new string[] { "Idle", "Move", "Speed" }, new float[] { 1f, 0f, 0f });
        ContactSeries = new ContactSeries(TimeSeries, "Left Hand", "Right Hand", "Left Foot", "Right Foot");
        PhaseSeries   = new PhaseSeries(TimeSeries, "Left Hand", "Right Hand", "Left Foot", "Right Foot");

        LeftHandIK  = UltimateIK.BuildModel(Actor.FindTransform("LeftForeArm"), Actor.GetBoneTransforms("LeftHandSite"));
        RightHandIK = UltimateIK.BuildModel(Actor.FindTransform("RightForeArm"), Actor.GetBoneTransforms("RightHandSite"));
        LeftFootIK  = UltimateIK.BuildModel(Actor.FindTransform("LeftLeg"), Actor.GetBoneTransforms("LeftFootSite"));
        RightFootIK = UltimateIK.BuildModel(Actor.FindTransform("RightLeg"), Actor.GetBoneTransforms("RightFootSite"));

        RootSeries.DrawGUI    = DrawGUI;
        StyleSeries.DrawGUI   = DrawGUI;
        ContactSeries.DrawGUI = DrawGUI;
        PhaseSeries.DrawGUI   = DrawGUI;
        GetComponent <ExpertActivation>().Draw = DrawGUI;
        RootSeries.DrawScene    = DrawDebug;
        StyleSeries.DrawScene   = DrawDebug;
        ContactSeries.DrawScene = DrawDebug;
        PhaseSeries.DrawScene   = DrawDebug;
    }