SDHK_Tool.Dynamic.SD_Motor_Angle 角度旋转电机

 

* 作者：闪电Y黑客

* 日期： 2019.6.16

* 功能：集合旋转方法

 

使用例子：

using SDHK_Tool.Dynamic;
 
 
 
 
private SD_Motor_Angle Motor_Angle; //旋转电机

public float Speed = 1; //旋转速度

public float Angle = 0; //当前角度

public float TargetAngle = 90; //目标角度
 
 
 
void Start()
{
 
    Motor_Angle = new SD_Motor_Angle(); //新建旋转电机
    Motor_Angle.Set_MotorSpeed(Speed);  //设置电机速度
 
}
 
 
void Update()
{
 
    Angle 
    = Motor_Angle
    .SetTarget_Angle(TargetAngle) //设置旋转目标
    .Run_LerpAngle()              //运行差值旋转
    .Get_MotorSave()              //获取旋转后的数值
    ;
 
}

功能全展开例子：

using SDHK_Tool.Dynamic;
 
 
 
private SD_Motor_Angle Motor_Angle; //旋转电机

public bool Motor = true;    //电机激活

public float Speed = 100;    //电机速度

public float Angle = 0;       //初始角度

public float TargetAngle = 90;    //目标角度


public bool Limit = true;    //限制器激活

public float Limit_Min = -10;   //限制最小范围
public float Limit_Max = 60;    //限制最大范围
 
 
 
void Start()
{

    Motor_Angle = new SD_Motor_Angle();  //新建旋转电机
    Motor_Angle
    .Set_MotorValue(Angle) //设置电机初始位置
    .Set_MotorSpeed(Speed) //设置电机速度
    .Set_MotorConstraint(Limit) //设置电机限制器激活
    .Set_MotorConstraint_Limit(Limit_Min,Limit_Max) //设置电机限制范围
    ;
 
}
 
 
void Update()
{
 
    Angle 
    = Motor_Angle
    .Set_MotorSpeed(Speed) //设置电机速度
    .Set_MotorActivation(Motor) //设置电机激活
    .Set_MotorConstraint(Limit) //设置电机限制器激活
    .SetTarget_Angle(TargetAngle) //设置电机旋转目标
    .Run_MoveTowardsAngle() //设置电机运行方式：匀速旋转
    .Constraint_Angle_Complete_Local() //设置电机限制器方式：本地全面角度限制
    .Get_MotorSave() //获取电机旋转后的角度
    ;
 
}

 

 

 

全篇：

using UnityEngine;
using SDHK_Tool.Static;


/*
 * 作者：闪电Y黑客
 * 
 * 日期： 2019.6.16
 * 
 * 功能：集合旋转方法
 */

namespace SDHK_Tool.Dynamic
{

    /// <summary>
    /// 角度旋转电机
    /// </summary>
    public class SD_Motor_Angle
    {

        /// <summary>
        /// 电机激活
        /// </summary>
        public bool MotorActivation = true;
        /// <summary>
        /// 电机速度
        /// </summary>
        public float MotorSpeed = 10;
        /// <summary>
        /// 限制器激活
        /// </summary>
        public bool MotorConstraint = false;
        /// <summary>
        /// 限制数：最小限制
        /// </summary>
        public float Limit_Min = 0;
        /// <summary>
        /// 限制数：最大限制
        /// </summary>
        public float Limit_Max = 0;
        /// <summary>
        /// 范围半径限制【用于范围限制】
        /// </summary>
        public float Limit_Radius = 0;
        /// <summary>
        /// 目标角度
        /// </summary>
        public float MotorTarget;
        /// <summary>
        /// 电机运行后的角度
        /// </summary>
        public float MotorSave;
        /// <summary>
        /// 平滑运行返回的速度
        /// </summary>
        public float MotorVelocity;



        #region 数值赋值



        /// <summary>
        /// 设置电机激活
        /// </summary>
        /// <param name="Activation">激活</param>
        /// <returns>电机</returns>
        public SD_Motor_Angle Set_MotorActivation(bool Activation)
        {
            MotorActivation = Activation;
            return this;
        }

        /// <summary>
        /// 设置限制器激活
        /// </summary>
        /// <param name="Constraint">激活</param>
        /// <returns></returns>
        public SD_Motor_Angle Set_MotorConstraint(bool Constraint)
        {
            MotorConstraint = Constraint;
            return this;
        }

        /// <summary>
        /// 设置电机限制半径
        /// </summary>
        /// <param name="Radius">半径值</param>
        /// <returns>电机</returns>
        public SD_Motor_Angle Set_MotorConstraint_Radius(float Radius)
        {
            Limit_Radius = Radius;
            return this;
        }

        /// <summary>
        /// 设置电机限制值
        /// </summary>
        /// <param name="Limit_Min">最小值</param>
        /// <param name="Limit_Max">最大值</param>
        /// <returns>电机</returns>
        public SD_Motor_Angle Set_MotorConstraint_Limit(float Limit_Min, float Limit_Max)
        {
            this.Limit_Min = Limit_Min;
            this.Limit_Max = Limit_Max;
            return this;
        }

        /// <summary>
        /// 设置电机速度
        /// </summary>
        /// <param name="Speed">速度值</param>
        /// <returns>电机</returns>
        public SD_Motor_Angle Set_MotorSpeed(float Speed)
        {
            MotorSpeed = Speed;
            return this;
        }

        /// <summary>
        /// 设置电机目标
        /// </summary>
        /// <param name="Value">目标值</param>
        /// <returns>电机</returns>
        public SD_Motor_Angle Set_MotorTarget(float Value)
        {
            MotorTarget = Value;
            return this;
        }

        /// <summary>
        /// 设置电机角度
        /// </summary>
        /// <param name="Value">角度值</param>
        /// <returns>电机</returns>
        public SD_Motor_Angle Set_MotorSave(float Value)
        {
            MotorSave = Value;
            return this;
        }

        /// <summary>
        /// 设置电机目标和位置
        /// </summary>
        /// <param name="Value">值</param>
        /// <returns>电机</returns>
        public SD_Motor_Angle Set_MotorValue(float Value)
        {
            MotorTarget = Value;
            MotorSave = Value;
            return this;
        }



        #endregion



        #region 电机操控



        /// <summary>
        /// 设置电机旋转差值
        /// </summary>
        /// <param name="AngleDelta">旋转差值</param>
        /// <returns>电机</returns>
        public SD_Motor_Angle SetTarget_AngleDelta(float AngleDelta)
        {
            if (MotorActivation) MotorTarget += AngleDelta;
            MotorTarget = SS_EulerAngleConversion.Angle_PN_To_P360(MotorTarget);
            return this;
        }

        /// <summary>
        /// 设置电机旋转目标
        /// </summary>
        /// <param name="Angle">旋转目标</param>
        /// <returns>电机</returns>
        public SD_Motor_Angle SetTarget_Angle(float Angle)
        {
            if (MotorActivation) MotorTarget = Angle;
            MotorTarget = SS_EulerAngleConversion.Angle_PN_To_P360(MotorTarget);
            return this;
        }



        #endregion



        #region 电机运行



        /// <summary>
        /// 电机运行 ： 匀速旋转
        /// </summary>
        /// <returns>电机</returns>
        public SD_Motor_Angle Run_MoveTowardsAngle()
        {
            MotorSave = Mathf.MoveTowardsAngle(MotorSave, MotorTarget, MotorSpeed * Time.deltaTime);
            return this;
        }

        /// <summary>
        /// 电机运行 ： 差值旋转
        /// </summary>
        /// <returns>电机</returns>
        public SD_Motor_Angle Run_LerpAngle()
        {
            MotorSave = Mathf.LerpAngle(MotorSave, MotorTarget, MotorSpeed * Time.deltaTime);
            return this;
        }

        /// <summary>
        /// 电机运行 ： 平滑旋转
        /// </summary>
        /// <returns>电机</returns>
        public SD_Motor_Angle Run_SmoothDampAngle()
        {
            MotorSave = Mathf.SmoothDampAngle(MotorSave, MotorTarget, ref MotorVelocity, MotorSpeed);
            return this;
        }



        #endregion



        #region 限制器



        /// <summary>
        /// 旋转限制器 ： 本地限制【注：需要限制数值】
        /// </summary>
        /// <returns>电机</returns>
        public SD_Motor_Angle Constraint_Angle_Local()
        {
            if (MotorConstraint) MotorSave = SS_VectorConstraint.Constraint_Angle(MotorSave, Limit_Min, Limit_Max);
            return this;
        }

        /// <summary>
        /// 旋转限制器 ： 本地范围限制【注：需要半径值】
        /// </summary>
        /// <returns>电机</returns>
        public SD_Motor_Angle Constraint_Angle_Local_Scope()
        {
            if (MotorConstraint) MotorSave = SS_VectorConstraint.Constraint_Angle(MotorSave, -Limit_Radius, Limit_Radius);
            return this;
        }

        /// <summary>
        /// 旋转限制器 ： 本地全面角度限制【注：需要限制数值】
        /// </summary>
        /// <returns>电机</returns>
        public SD_Motor_Angle Constraint_Angle_Complete_Local()
        {
            if (MotorConstraint) MotorSave = SS_VectorConstraint.Constraint_Angle_Complete(MotorSave, Limit_Min, Limit_Max);
            return this;
        }

        /// <summary>
        /// 旋转限制器 ： 目标限制【注：需要限制数值】
        /// </summary>
        /// <returns>电机</returns>
        public SD_Motor_Angle Constraint_Angle_Target()
        {
            if (MotorConstraint) MotorSave = SS_VectorConstraint.Constraint_Angle_Complete(MotorSave, MotorTarget + Limit_Min, MotorTarget + Limit_Max);
            return this;
        }

        /// <summary>
        /// 旋转限制器 ： 目标范围限制【注：需要半径值】
        /// </summary>
        /// <returns>电机</returns>
        public SD_Motor_Angle Constraint_Angle_Target_Scope()
        {
            if (MotorConstraint) MotorSave = SS_VectorConstraint.Constraint_Angle_Complete_Scope(MotorSave, MotorTarget, Limit_Radius);
            return this;
        }

        #endregion



        #region 数值获取



        /// <summary>
        /// 获取电机当前角度
        /// </summary>
        /// <returns>return : 电机角度</returns>
        public float Get_MotorSave()
        {
            return MotorSave;
        }

        /// <summary>
        /// 判断电机旋转完成
        /// </summary>
        /// <param name="Deviation">偏差值</param>
        /// <returns>bool</returns>
        public bool If_MotorSpinFinish(float Deviation)
        {
            return Mathf.Abs(Mathf.DeltaAngle(MotorTarget, MotorSave)) < Deviation;
        }



        #endregion




    }
}