/// <summary>
/// Refreshes controller. Call this method after adding and/or removing <see cref="CubismEyeBlinkParameter"/>s.
/// </summary>
public void Refresh()
{
var model = this.FindCubismModel();
// Fail silently...
if (model == null)
{
return;
}
// Cache destinations.
var tags = model
.Parameters
.GetComponentsMany <CubismBreathParameter>();
Destinations = new CubismParameter[tags.Length];
for (var i = 0; i < tags.Length; ++i)
{
Destinations[i] = tags[i].GetComponent <CubismParameter>();
}
}
public void setParameter(CubismParameter param, ParametersClass kvp)
{
if (param != null)
{
var get = (kvp.MaxValue - kvp.MinValue) * (kvp.NowValue - kvp.MinSetValue) / (kvp.MaxSetValue - kvp.MinSetValue) + kvp.MinValue;
if (kvp.NowValue <= kvp.MinSetValue)
{
get = kvp.MinValue;
}
else if (kvp.NowValue >= kvp.MaxSetValue)
{
get = kvp.MaxValue;
}
if (get > kvp.MaxParamValue)
{
get = kvp.MaxParamValue;
}
else if (get < kvp.MinParamValue)
{
get = kvp.MinParamValue;
}
var smooth = Mathf.SmoothStep(param.Value, get, kvp.SmoothValue);
param.Value = smooth;
kvp.ParametersValue = smooth;
}
}
public static float Normalize(CubismParameter param, float normalizedMin, float normalizedMax, float normalizedDef, bool isInverted = false)
{
float result = 0.0f;
float maxValue = MathF.Max(param.Maximum, param.Minimum);
float minValue = MathF.Min(param.Maximum, param.Minimum);
if (maxValue < param.Value)
{
param.Value = maxValue;
}
if (minValue > param.Value)
{
param.Value = minValue;
}
float minNormValue = MathF.Min(normalizedMin, normalizedMax);
float maxNormValue = MathF.Min(normalizedMin, normalizedMax);
float midNormValue = normalizedDef;
float midValue = getDefaultValue(minValue, maxValue);
float paramValue = param.Value - midValue;
switch (MathF.Sign(paramValue))
{
case 1:
{
float nLength = maxNormValue - midNormValue;
float pLength = maxValue - midValue;
if (pLength != 0.0f)
{
result = paramValue * (nLength / pLength);
result += midNormValue;
}
break;
}
case -1:
{
float nLength = minNormValue - midNormValue;
float pLength = minValue - midValue;
if (pLength != 0.0f)
{
result = paramValue * (nLength / pLength);
result += midNormValue;
}
break;
}
case 0:
result = midNormValue;
break;
}
return(isInverted ? result : result * -1.0f);
}
/// <summary>
/// Gets output for angle.
/// </summary>
/// <param name="translation">Translation.</param>
/// <param name="parameter">Parameter.</param>
/// <param name="particles">Particles.</param>
/// <param name="particleIndex">Index of particle.</param>
/// <returns>Output value.</returns>
private float GetOutputAngle(
Vector2 translation,
CubismParameter parameter,
CubismPhysicsParticle[] particles,
int particleIndex
)
{
var parentGravity = -CubismPhysics.Gravity;
if (CubismPhysics.UseAngleCorrection && (particleIndex - 1) != 0)
{
parentGravity = particles[particleIndex - 2].Position -
particles[particleIndex - 1].Position;
}
translation.y *= -1.0f;
var outputValue = CubismPhysicsMath.DirectionToRadian(-parentGravity, -translation);
outputValue = (((-translation.x) - (-parentGravity.x)) > 0.0f)
? -outputValue
: outputValue;
if (IsInverted)
{
outputValue *= -1.0f;
}
return(outputValue);
}
/// <summary>
/// Refreshes controller. Call this method after adding and/or removing <see cref="CubismEyeBlinkParameter"/>s.
/// </summary>
public void Refresh()
{
var model = this.FindCubismModel();
// Fail silently...
if (model == null)
{
return;
}
// Cache destinations.
var tags = model
.Parameters
.GetComponentsMany <CubismEyeBlinkParameter>();
Destinations = new CubismParameter[tags.Length];
for (var i = 0; i < tags.Length; ++i)
{
Destinations[i] = tags[i].GetComponent <CubismParameter>();
}
// Get cubism update controller.
HasUpdateController = (GetComponent <CubismUpdateController>() != null);
}
/// <summary>
/// コンストラクタ
/// </summary>
/// <param name="LeftEyeParam">左目</param>
/// <param name="RightEyeParam">右目</param>
public ActionBlink(CubismParameter LeftEyeParam, CubismParameter RightEyeParam)
{
this.LeftEyeParam = LeftEyeParam;
this.RightEyeParam = RightEyeParam;
WaitInterval();
}
void SetParameter(CubismParameter parameter, float value)
{
if (parameter != null)
{
parameter.Value = Mathf.Clamp(value, parameter.MinimumValue, parameter.MaximumValue);
}
}
/// <summary>
/// Checks whether the parameter is an eye blink parameter.
/// </summary>
/// <param name="parameter">Parameter to check.</param>
/// <param name="groupName">Name of group to query for.</param>
/// <returns><see langword="true"/> if parameter is an eye blink parameter; <see langword="false"/> otherwise.</returns>
private bool IsParameterInGroup(CubismParameter parameter, string groupName)
{
// Return early if groups aren't available...
if (Groups == null || Groups.Length == 0)
{
return(false);
}
for (var i = 0; i < Groups.Length; ++i)
{
if (Groups[i].Name != groupName)
{
continue;
}
for (var j = 0; j < Groups[i].Ids.Length; ++j)
{
if (Groups[i].Ids[j] == parameter.name)
{
return(true);
}
}
}
return(false);
}
void Start()
{
_model = this.FindCubismModel();
_param = _model.Parameters.FindById(ParameterID);
Debug.Log(_param.Value);
}
// Update is called once per frame
void Update()
{
// breath
t1 += (Time.deltaTime * 3f);
float value = Mathf.Sin(t1) * 0.5f + 0.5f;
parameter = Model.Parameters[23];
parameter.Value = value;
// hands
t2 += (Time.deltaTime * 2f);
// left hand
float value2 = Mathf.Sin(t2) * 1.0f;
parameter = Model.Parameters[32];
parameter.Value = value2;
// right hand
float value3 = Mathf.Sin(t2) * 1.0f;
parameter = Model.Parameters[33];
parameter.Value = value2;
// update yaw
parameter = Model.Parameters[0];
parameter.Value = angleX;
// update pitch
parameter = Model.Parameters[1];
parameter.Value = angleY;
// update roll
parameter = Model.Parameters[2];
parameter.Value = angleZ;
// update eyes
parameter = Model.Parameters[4]; // left
parameter.Value = eyeLeft;
parameter = Model.Parameters[6]; // right
parameter.Value = eyeRight;
// update eyeballs
parameter = Model.Parameters[8]; // X axis
parameter.Value = eyeBallX;
parameter = Model.Parameters[9]; // Y axis
parameter.Value = eyeBallY;
// update mouth
parameter = Model.Parameters[18];
parameter.Value = mouthWidth;
parameter = Model.Parameters[19];
parameter.Value = mouthVar;
}
/// <summary>
/// コンストラクタ
/// </summary>
/// <param name="HeadZParam">頭のＺ軸のパラメータ</param>
/// <param name="BodyZParam">体のＺ軸のパラメータ</param>
/// <param name="EyesParams">目の開き具合のパラメータ</param>
/// <param name="PositiveParams">プラス方向に更新するパラメータ群</param>
/// <param name="NegativeParams">マイナス方向に更新するパラメータ群</param>
public ActionSmile(CubismParameter HeadZParam, CubismParameter BodyZParam, List <CubismParameter> EyesParams, List <CubismParameter> PositiveParams, List <CubismParameter> NegativeParams)
{
this.HeadZParam = HeadZParam;
this.BodyZParam = BodyZParam;
this.EyesParams = EyesParams;
this.PositiveParams = PositiveParams;
this.NegativeParams = NegativeParams;
IsActive = false;
}
void Update()
{
_t += (Time.deltaTime * 4f);
float value = Mathf.Sin(_t) * 30f; // amplitude
parameter = Momose.Parameters[2]; // head angle Z
parameter.Value = value; // set value
Debug.Log(parameter.Value);
}
public override void Setup()
{
oldHeadEulerAngle = Vector3.zero;
NullCheck(headRotationGetterInterface, "headRotationGetter");
NullCheck(target, "target");
paramAngleX = target.Parameters.FindById("ParamAngleX");
paramAngleY = target.Parameters.FindById("ParamAngleY");
paramAngleZ = target.Parameters.FindById("ParamAngleZ");
}
/// <summary>
/// コンストラクタ
/// </summary>
/// <param name="Source">音声入力ソース</param>
/// <param name="LipParam">口パクパラメータ</param>
public ActionLipSync(AudioSource Source, CubismParameter LipParam)
{
this.Source = Source;
this.LipParam = LipParam;
this.Source.clip = Microphone.Start(null, true, 1, 44100);
while (Microphone.GetPosition(null) < 0)
{
}
this.Source.Play();
this.Source.loop = true;
}
/// <summary>
/// CubismParameterInfo Constructor.
/// </summary>
public CubismParameterInfo(CubismParameter parameter, Toggle toggle, Text valueText, Image backgroundTint,
Slider slider, bool active, bool valueSetByAnimation, float overrideVal)
{
this.Parameter = parameter;
this.Toggle = toggle;
this.ValueText = valueText;
this.BackgroundTint = backgroundTint;
this.Slider = slider;
this.Active = active;
this.ValueSetByAnimation = valueSetByAnimation;
this.OverrideVal = overrideVal;
}
public override void Setup()
{
base.Setup();
NullCheck(live2DCubism3Model, "live2DCubism3Model");
paramEyeLOpen = live2DCubism3Model.Parameters.FindById("ParamEyeLOpen");
paramEyeROpen = live2DCubism3Model.Parameters.FindById("ParamEyeROpen");
paramBrowLY = live2DCubism3Model.Parameters.FindById("ParamBrowLForm");
paramBrowRY = live2DCubism3Model.Parameters.FindById("ParamBrowRForm");
paramMouthOpenY = live2DCubism3Model.Parameters.FindById("ParamMouthOpenY");
paramMouthForm = live2DCubism3Model.Parameters.FindById("ParamMouthForm");
}
void Start()
{
_model = this.FindCubismModel();
_paramEyeR = _model.Parameters.FindById(EyeRParameterID);
_paramEyeL = _model.Parameters.FindById(EyeLParameterID);
_paramMouth = _model.Parameters.FindById(MouthParameterID);
// Debug.Log(_paramEyeR.Value);
// centerOnScreen = Camera.main.WorldToScreenPoint(Anchor.position);
}
/// <summary>
/// Gets output for translation Y-axis.
/// </summary>
/// <param name="translation">Translation.</param>
/// <param name="parameter">Parameter.</param>
/// <param name="particles">Particles.</param>
/// <param name="particleIndex">Index of particle.</param>
/// <returns>Output value.</returns>
private float GetOutputTranslationY(
Vector2 translation,
CubismParameter parameter,
CubismPhysicsParticle[] particles,
int particleIndex
)
{
var outputValue = translation.y;
if (IsInverted)
{
outputValue *= -1.0f;
}
return(outputValue);
}
/// <summary>
/// Gets Normalized parameter value from input rotation.
/// </summary>
/// <param name="targetTranslation">Result of translation.</param>
/// <param name="targetAngle">Result of rotation.</param>
/// <param name="parameter">Parameter.</param>
/// <param name="normalization">Normalized components.</param>
/// <param name="weight">Weight.</param>
private void GetInputAngleFromNormalizedParameterValue(
ref Vector2 targetTranslation,
ref float targetAngle,
CubismParameter parameter,
CubismPhysicsNormalization normalization,
float weight
)
{
targetAngle += CubismPhysicsMath.Normalize(
parameter,
normalization.Angle.Minimum,
normalization.Angle.Maximum,
normalization.Angle.Default,
IsInverted
) * weight;
}
/// <summary>
/// 方向パラメータを取得する
/// </summary>
private void SetDirectionParam()
{
PramAngleX = model.Parameters.FindById("ParamAngleX");
ParamBodyAngleX = model.Parameters.FindById("ParamBodyAngleX");
//NULLなら休パラメータを読んでみる
if (PramAngleX == null)
{
PramAngleX = model.Parameters.FindById("PARAM_ANGLE_X");
}
if (ParamBodyAngleX == null)
{
ParamBodyAngleX = model.Parameters.FindById("PARAM_BODY_ANGLE_X");
}
}
// Use this for initialization
void Start()
{
// References to stuff.
handAnimator = GetComponent <Animator>();
clickAudio = GetComponent <AudioSource>();
img = GetComponent <RawImage>();
transpHandler = GameObject.FindObjectOfType <TranspHandler>();
pt = transform.parent.transform;
startTime = Time.time;
// Find model.
model = GameObject.Find("Hideri_L2D").GetComponent <CubismModel>();
charAnimator = model.gameObject.GetComponent <Animator>();
// Get parameters we want to directly controll.
foreach (CubismParameter p in model.Parameters)
{
if (p.Id == "ParamEyeBallX")
{
eyeX = p;
}
else if (p.Id == "ParamEyeBallY")
{
eyeY = p;
}
else if (p.Id == "ParamEyeLOpen")
{
eyeOpenL = p;
}
else if (p.Id == "ParamEyeROpen")
{
eyeOpenR = p;
}
else if (p.Id == "ParamAngleX")
{
paramX = p;
}
else if (p.Id == "ParamAngleY")
{
paramY = p;
}
else
{
//...
}
}
}
/// <summary>
/// Refreshes the controller. Call this method after adding and/or removing <see cref="CubismLookParameter"/>s.
/// </summary>
public void Refresh()
{
var model = this.FindCubismModel();
// Catch sources and destinations.
Sources = model
.Parameters
.GetComponentsMany <CubismLookParameter>();
Destinations = new CubismParameter[Sources.Length];
for (var i = 0; i < Sources.Length; ++i)
{
Destinations[i] = Sources[i].GetComponent <CubismParameter>();
}
}
//Todo 更新class
public void setRawParameter(CubismParameter param, float value, float MinValue, float MaxValue, float MinSetValue, float MaxSetValue)
{
if (param != null)
{
var get = (MaxValue - MinValue) * (value - MinSetValue) / (MaxSetValue - MinSetValue) + MinValue;
if (value <= MinSetValue)
{
get = MinValue;
}
else if (value >= MaxSetValue)
{
get = MaxValue;
}
var smooth = Mathf.SmoothStep(param.Value, get, 0.5f);
param.Value = smooth;
}
}
private float getOutputTranslationY(
Vector2 translation,
CubismParameter parameter,
PhysicsParticle[] particles,
int particleIndex,
Vector2 gravity
)
{
float outputValue = translation.Y;
if (IsInverted)
{
outputValue *= -1.0f;
}
return(outputValue);
}
private void Awake()
{
for (var i = 0; i < lastAu.Length; i++)
{
lastAu[i] = new Queue <float>();
}
paramAngleX = model.Parameters.FindById(paramAngleXKey);
paramAngleY = model.Parameters.FindById(paramAngleYKey);
paramAngleZ = model.Parameters.FindById(paramAngleZKey);
paramBodyAngleZ = model.Parameters.FindById(paramBodyAngleZKey);
paramEyeBallX = model.Parameters.FindById(paramEyeBallXKey);
paramEyeBallY = model.Parameters.FindById(paramEyeBallYKey);
paramBrowLY = model.Parameters.FindById(paramBrowLYKey);
paramBrowRY = model.Parameters.FindById(paramBrowRYKey);
paramMouthOpenY = model.Parameters.FindById(paramMouthOpenYKey);
paramMouthForm = model.Parameters.FindById(paramMouthFormKey);
paramCheek = model.Parameters.FindById(paramCheekKey);
calibrateHeadOriginButton.onClick.AddListener(OnCalibratePoseOrigin);
}
/// <summary>
/// Updates parameter from output value.
/// </summary>
/// <param name="parameter">Target parameter.</param>
/// <param name="translation">Translation.</param>
/// <param name="output">Output value.</param>
private void UpdateOutputParameterValue(CubismParameter parameter, float translation, CubismPhysicsOutput output)
{
var outputScale = 1.0f;
outputScale = output.GetScale();
var value = translation * outputScale;
if (value < parameter.MinimumValue)
{
if (value < output.ValueBelowMinimum)
{
output.ValueBelowMinimum = value;
}
value = parameter.MinimumValue;
}
else if (value > parameter.MaximumValue)
{
if (value > output.ValueExceededMaximum)
{
output.ValueExceededMaximum = value;
}
value = parameter.MaximumValue;
}
var weight = (output.Weight / CubismPhysics.MaximumWeight);
if (weight >= 1.0f)
{
parameter.Value = value;
}
else
{
value = (parameter.Value * (1.0f - weight)) + (value * weight);
parameter.Value = value;
}
}
/// <summary>
/// Refreshes the controller. Call this method after adding and/or removing <see cref="CubismHarmonicMotionParameter"/>.
/// </summary>
public void Refresh()
{
var model = this.FindCubismModel();
// Catch sources and destinations.
Sources = model
.Parameters
.GetComponentsMany <CubismHarmonicMotionParameter>();
Destinations = new CubismParameter[Sources.Length];
for (var i = 0; i < Sources.Length; ++i)
{
Destinations[i] = Sources[i].GetComponent <CubismParameter>();
}
// Get cubism update controller.
HasUpdateController = (GetComponent <CubismUpdateController>() != null);
}
/// <summary>
/// Gets output for angle.
/// </summary>
/// <param name="translation">Translation.</param>
/// <param name="parameter">Parameter.</param>
/// <param name="particles">Particles.</param>
/// <param name="particleIndex">Index of particle.</param>
/// <param name="gravity">Gravity.</param>
/// <returns>Output value.</returns>
private float GetOutputAngle(
Vector2 translation,
CubismParameter parameter,
CubismPhysicsParticle[] particles,
int particleIndex,
Vector2 gravity
)
{
var parentGravity = Vector2.zero;
if (CubismPhysics.UseAngleCorrection)
{
if (particleIndex < 2)
{
parentGravity = gravity;
parentGravity.y *= -1.0f;
}
else
{
parentGravity = particles[particleIndex - 1].Position -
particles[particleIndex - 2].Position;
}
}
else
{
parentGravity = gravity;
parentGravity.y *= -1.0f;
}
var outputValue = CubismPhysicsMath.DirectionToRadian(parentGravity, translation);
if (IsInverted)
{
outputValue *= -1.0f;
}
return(outputValue);
}
public void Refresh()
{
parameter = this.GetComponent <CubismParameter>();
if (From != null)
{
fromRender = From.GetComponent <CubismRenderer>();
}
if (To != null)
{
toRender = To.GetComponent <CubismRenderer>();
}
var model = this.GetComponentInParent <CubismModel>();
if (model != null)
{
modelTransform = model.transform;
}
}
/// <summary>
/// Blends a value in.
/// </summary>
/// <param name="self"><see langword="this"/>.</param>
/// <param name="value">Value to blend in.</param>
/// <param name="mode">Blend mode to use.</param>
public static void BlendToValue(this CubismParameter self, CubismParameterBlendMode mode, float value)
{
if (mode == CubismParameterBlendMode.Additive)
{
self.AddToValue(value);
return;
}
if (mode == CubismParameterBlendMode.Multiply)
{
self.MultiplyValueBy(value);
return;
}
self.Value = value;
}
