private void Update()
{
if (Box == null)
{
return;
}
float dt = Time.deltaTime;
Box.transform.rotation.ToAngleAxis(out float qAngle, out Vector3 qAxis);
Vector3 c = Mathf.Deg2Rad * qAngle * qAxis;
c.x = 0f;
c.y = 0f;
Matrix3x3 effectiveMass = inertia;
Vector3 jV = a;
jV.x = 0f;
jV.y = 0f;
Vector3 lambda = effectiveMass * (-(jV + (Beta / dt) * c));
a += inertiaInv * lambda;
//a *= 0.9f; // temp magic cheat
// integration
Quaternion q = QuaternionUtil.AxisAngle(VectorUtil.NormalizeSafe(a, Vector3.forward), a.magnitude * dt);
Box.transform.rotation = q * Box.transform.rotation;
}
public void FixedUpdateState()
{
if (isFinishedRotating)
{
return;
}
// Calculate direction to target
Vector3 targetRot = stateMachine.taskDestinationPosition - stateMachine.transform.position;
targetRot.y = 0.0f;
targetRot.Normalize();
// SmoothDamp towards to target rotation
stateMachine.transform.rotation = QuaternionUtil.SmoothDamp(stateMachine.transform.rotation, Quaternion.LookRotation(targetRot), ref angularVelocity, stateMachine.rotationSpeed);
// Calculate the angle between target position and customer forward vector
float fromToDelta = Vector3.Angle(stateMachine.transform.forward, targetRot);
Debug.DrawRay(stateMachine.transform.position, targetRot * 5.0f, Color.green);
Debug.DrawRay(stateMachine.transform.position, stateMachine.transform.forward * 5.0f, Color.red);
// Stop rotation if angle between target and forward vector is lower than margin of error
if (fromToDelta <= marginOfErrorAmount)
{
isFinishedRotating = true;
Debug.Log("Customer is now looking at the target!", stateMachine.gameObject);
}
}
public void Set(object targ, object valueObj)
{
var value = ConvertUtil.ToQuaternion(valueObj);
if (targ is Rigidbody)
{
var rb = targ as Rigidbody;
rb.MoveRotation(QuaternionUtil.FromToRotation(rb.rotation, value));
}
else
{
var trans = GameObjectUtil.GetTransformFromSource(targ);
if (trans == null)
{
return;
}
var rb = trans.GetComponent <Rigidbody>();
if (rb != null && !rb.isKinematic)
{
rb.MoveRotation(QuaternionUtil.FromToRotation(rb.rotation, value));
return;
}
//just update the rotation
trans.rotation = value;
}
}
// master sterp function
public static Quaternion Sterp
(
Quaternion a,
Quaternion b,
Vector3 twistAxis,
float tSwing,
float tTwist,
out Quaternion swing,
out Quaternion twist,
SterpMode mode
)
{
Quaternion q = b * Quaternion.Inverse(a);
Quaternion swingFull;
Quaternion twistFull;
QuaternionUtil.DecomposeSwingTwist(q, twistAxis, out swingFull, out twistFull);
switch (mode)
{
default:
case SterpMode.Nlerp:
swing = Quaternion.Lerp(Quaternion.identity, swingFull, tSwing);
twist = Quaternion.Lerp(Quaternion.identity, twistFull, tTwist);
break;
case SterpMode.Slerp:
swing = Quaternion.Slerp(Quaternion.identity, swingFull, tSwing);
twist = Quaternion.Slerp(Quaternion.identity, twistFull, tTwist);
break;
}
return(twist * swing);
}
public void Update()
{
var player = getPlayerTransform();
var transform = getCameraTransform();
Vector3 playerPosition = player.position;
Torus.GetPoint(playerPosition, out TorusPointInfo pInfo);
Vector3 slope = -pInfo.minorCenterUp;
Vector3 playerUp = -pInfo.minorCenterForward;
Vector3 playerRight = -pInfo.minorCenterRight;
Vector3 targetPosition = playerPosition + slope * config.offset.z + playerUp * config.offset.y;
if (Application.isPlaying)
{
transform.position = Vector3.SmoothDamp(transform.position, targetPosition, ref velocity, config.smoothTime);
}
else
{
transform.position = targetPosition;
}
var lookAtTarget = playerPosition + slope * config.lootAtOffset.z + playerUp * config.lootAtOffset.y;
var lookAt = (lookAtTarget - transform.position).normalized;
var up = Vector3.Cross(playerRight, lookAt);
if (Application.isPlaying)
{
transform.rotation = QuaternionUtil.SmoothDamp(transform.rotation, Quaternion.LookRotation(lookAt, up), ref quaternionDeriv, config.smoothTime);
}
else
{
transform.rotation = Quaternion.LookRotation(lookAt, up);
}
}
void Update()
{
Vector3 axis = Vector3.down;
float angularSpeed = 1.0f;
float dt = m_timeScale * Time.fixedDeltaTime;
// render
Quaternion baseRot = Quaternion.FromToRotation(Vector3.one, Vector3.up);
DebugUtil.DrawBox(Vector3.zero, m_quatClosedForm * baseRot, Vector3.one, m_closedColor, true, DebugUtil.Style.FlatShaded);
DebugUtil.DrawBox(Vector3.zero, m_quatPower * baseRot, 1.05f * Vector3.one, m_powerColor, true, DebugUtil.Style.Wireframe);
DebugUtil.DrawBox(Vector3.zero, m_quatDerivative * baseRot, 1.1f * Vector3.one, m_derivativeColor, true, DebugUtil.Style.Wireframe);
// integrate
Quaternion v = QuaternionUtil.AxisAngle(axis, angularSpeed);
Vector3 o = angularSpeed * axis;
m_quatClosedForm = QuaternionUtil.Normalize(QuaternionUtil.AxisAngle(axis, (m_angle += angularSpeed * dt)));
m_quatPower = QuaternionUtil.Normalize(QuaternionUtil.Integrate(m_quatPower, v, dt));
m_quatDerivative = QuaternionUtil.Normalize(QuaternionUtil.Integrate(m_quatDerivative, o, dt));
if (Input.GetKey(KeyCode.Space))
{
Reset();
}
}
private void Update()
{
if (Input.GetKeyDown(KeyCode.Escape))
{
followTransform = null;
}
if (followTransform != null)
{
position = followTransform.position;
}
else
{
HandleInput();
}
position.x = Mathf.Clamp(position.x, center.x - panLimit.x, center.x + panLimit.x);
position.z = Mathf.Clamp(position.z, center.z - panLimit.y, center.z + panLimit.y);
zoom.y = Mathf.Clamp(zoom.y, minZoom, maxZoom);
zoom.z = Mathf.Clamp(zoom.z, -maxZoom, -minZoom);
transform.position = Vector3.SmoothDamp(transform.position, position, ref velocity, panRate);
transform.rotation = QuaternionUtil.SmoothDamp(transform.rotation, rotation, ref deriv, rotateRate);
cameraTransform.localPosition = Vector3.SmoothDamp(cameraTransform.localPosition, zoom, ref zoomVelocity, zoomRate);
}
public void Fire(Vector2 direction)
{
var rotation = QuaternionUtil.FromDirection2D(direction);
var bulletInstance = (GameObject)Instantiate(bullet, origin.position, rotation);
bulletInstance.GetComponent <Rigidbody2D>().velocity = direction.normalized * 20;
bulletInstance.GetComponent <BulletController>().ignore = ignore;
}
public GameObject CreateRocket()
{
Vector2 pos = mainCircle.GetRandomPoint();
GameObject probe = Instantiate(ProbePrefab, pos, Quaternion.identity);
probe.transform.rotation = QuaternionUtil.GetOppositeDirection(probe, MainObject);
probe.transform.SetParent(MainObject.transform);
probe.GetComponent <RocketBehaviour>().Init(endCircle);
return(probe);
}
public static Quaternion GetQuaternion(IBcx bcx, int jointIndex, float time)
{
var animatedJoint = bcx.Anx1.Joints[jointIndex];
var values = animatedJoint.Values;
var xRadians = animatedJoint.GetAnimValue(values.rotationsX, time);
var yRadians = animatedJoint.GetAnimValue(values.rotationsY, time);
var zRadians = animatedJoint.GetAnimValue(values.rotationsZ, time);
return(QuaternionUtil.Create(xRadians, yRadians, zRadians));
}
public void Integrate(float dt)
{
if (!LockPosition)
{
transform.position = VectorUtil.Integrate(transform.position, LinearVelocity, dt);
}
if (!LockRotation)
{
transform.rotation = QuaternionUtil.Integrate(transform.rotation, AngularVelocity, dt);
}
}
// Update is called once per frame
void FixedUpdate()
{
//if (!target2.gameObject.activeInHierarchy) {
Vector3 desiredPosition = target.position + target.forward * offset;
transform.position = Vector3.SmoothDamp(transform.position, desiredPosition, ref velocity, smoothTimePos);
Quaternion desiredRotation = target.rotation;
transform.rotation = QuaternionUtil.SmoothDamp(transform.rotation, desiredRotation, ref deriv, smoothTimeRot);
//} else {
//this.gameObject.SetActive(false);
//}
}
void LateUpdate()
{
if (desiredPose != null)
{
transform.position = Vector3.SmoothDamp(transform.position, desiredPose.position, ref currentPositionCorrectionVelocity, positionSmoothTime, positionMaxSpeed, Time.deltaTime);
var targForward = desiredPose.forward;
//var targForward = (target.position - this.transform.position).normalized;
transform.rotation = QuaternionUtil.SmoothDamp(transform.rotation,
Quaternion.LookRotation(targForward, Vector3.up), ref quaternionDeriv, rotationSmoothTime);
}
}
public void Integrate(float dt)
{
if (!LockPosition)
{
transform.position += LinearVelocity * dt;;
}
if (!LockRotation)
{
Quaternion q = QuaternionUtil.AxisAngle(VectorUtil.NormalizeSafe(AngularVelocity, Vector3.forward), AngularVelocity.magnitude * dt);
transform.rotation = q * transform.rotation;
}
}
private void FixedUpdate()
{
if (Object == null)
{
return;
}
if (Target == null)
{
return;
}
float dt = Time.fixedDeltaTime;
Vector3 r = Object.transform.rotation * rLocal;
var t = Object.transform;
Matrix3x3 world2Local =
Matrix3x3.FromRows
(
t.TransformVector(new Vector3(1.0f, 0.0f, 0.0f)),
t.TransformVector(new Vector3(0.0f, 1.0f, 0.0f)),
t.TransformVector(new Vector3(0.0f, 0.0f, 1.0f))
);
Matrix3x3 inertiaInvWs = world2Local.Transposed * inertiaInvLs * world2Local;
// gravity
v += Gravity * dt;
// constraint errors
Vector3 cPos = (Object.transform.position + r) - Target.transform.position;
Vector3 cVel = v + Vector3.Cross(a, r);
// constraint resolution
Matrix3x3 s = Matrix3x3.Skew(-r);
Matrix3x3 k = massInv * Matrix3x3.Identity + s * inertiaInvWs * s.Transposed;
Matrix3x3 effectiveMass = k.Inverted;
Vector3 lambda = effectiveMass * (-(cVel + (Beta / dt) * cPos));
// velocity correction
v += massInv * lambda;
a += (inertiaInvWs * s.Transposed) * lambda;
v *= 0.98f; // temp magic
a *= 0.98f; // temp magic
// integration
Object.transform.position += v * dt;
Object.transform.rotation = QuaternionUtil.Integrate(Object.transform.rotation, a, dt);
}
void OnAITargetting(AIShooterInfo info)
{
if (info.State == AIShooterState.NOT_IN_RANGE)
{
this.visualElement.gameObject.SetActive(false);
return;
}
float width = maxThickness * (1 - info.TimeToShoot / info.ShootDelay);
visualElement.SetWidth(width, width);
this.visualElement.gameObject.SetActive(true);
this.visualElement.gameObject.transform.position = info.From;
this.visualElement.gameObject.transform.rotation = QuaternionUtil.FromDirection2D(info.Target);
}
public void UpdateCurrentPose(Transform transform)
{
current_pose.position = transform.position;
current_pose.orientation = transform.rotation;
// Offset position to initial frame
current_pose.position -= initial_pose.position;
current_pose.position = Quaternion.Inverse(initial_pose.orientation) *
current_pose.position;
current_pose.orientation = QuaternionUtil.DispQ(initial_pose.orientation,
current_pose.orientation);
// Convert to robot frame
current_pose.position = UnityToRobotFramePosition(current_pose.position);
current_pose.orientation = UnityToRobotFrameOrientation(current_pose.orientation);
}
// Convert an array of rotation vectors back to quaternions
public static Quaternion[] RotVecsToQuats(Vector3[] rotVecs, Quaternion q0)
{
Quaternion[] quaternions = new Quaternion[rotVecs.Length - 1];
Quaternion qProd = q0;
for (int i = 0; i < rotVecs.Length - 1; i++)
{
for (int j = 0; j < i - 1; j++)
{
qProd *= QuaternionUtil.Exp(rotVecs[j + 1] - rotVecs[j]);
}
quaternions[i] = qProd;
qProd = q0;
}
return(quaternions);
}
void ISupportRedirectToMemberCurve.ConfigureAsRedirectTo(System.Type memberType, float totalDur, object current, object start, object end, object option)
{
_option = ConvertUtil.ToEnum <QuaternionTweenOption>(option);
if (_option == QuaternionTweenOption.Long)
{
var c = QuaternionUtil.MassageAsEuler(current);
var s = QuaternionUtil.MassageAsEuler(start);
var e = QuaternionUtil.MassageAsEuler(end);
c.x = MathUtil.NormalizeAngleToRange(c.x, s.x, e.x, false);
c.y = MathUtil.NormalizeAngleToRange(c.y, s.y, e.y, false);
c.z = MathUtil.NormalizeAngleToRange(c.z, s.z, e.z, false);
_startLong = c;
_endLong = e;
_start = Quaternion.Euler(_startLong);
_end = Quaternion.Euler(_endLong);
c -= s;
e -= s;
this.Duration = totalDur * (VectorUtil.NearZeroVector(e) ? 0f : 1f - c.magnitude / e.magnitude);
}
else
{
//treat as quat
var c = QuaternionUtil.MassageAsQuaternion(current);
var s = QuaternionUtil.MassageAsQuaternion(start);
var e = QuaternionUtil.MassageAsQuaternion(end);
_start = c;
_end = e;
_startLong = _start.eulerAngles;
_endLong = _end.eulerAngles;
var at = Quaternion.Angle(s, e);
if ((System.Math.Abs(at) < MathUtil.EPSILON))
{
this.Duration = 0f;
}
else
{
var ap = Quaternion.Angle(s, c);
this.Duration = (1f - ap / at) * totalDur;
}
}
}
protected override void ReflectiveInit(System.Type memberType, object start, object end, object option)
{
_option = ConvertUtil.ToEnum <QuaternionTweenOption>(option);
if (_option == QuaternionTweenOption.Long)
{
_startLong = QuaternionUtil.MassageAsEuler(start);
_endLong = QuaternionUtil.MassageAsEuler(end);
_start = Quaternion.Euler(_startLong);
_end = Quaternion.Euler(_endLong);
}
else
{
_start = QuaternionUtil.MassageAsQuaternion(start);
_end = QuaternionUtil.MassageAsQuaternion(end);
_startLong = _start.eulerAngles;
_endLong = _end.eulerAngles;
}
}
private void Update()
{
if (Object == null)
{
return;
}
if (Target == null)
{
return;
}
float dt = Time.deltaTime;
Vector3 r = Object.transform.rotation * rLocal;
// gravity
v += Gravity * dt;
// constraint errors
Vector3 cPos = (Object.transform.position + r) - Target.transform.position;
Vector3 cVel = v + Vector3.Cross(a, r);
// constraint resolution
Matrix3x3 s = Matrix3x3.Skew(-r);
Matrix3x3 k = massInv * Matrix3x3.Identity + s * inertiaInv * s.Transposed;
Matrix3x3 effectiveMass = k.Inverted;
Vector3 lambda = effectiveMass * (-(cVel + (Beta / dt) * cPos));
// velocity correction
v += massInv * lambda;
a += (inertiaInv * s.Transposed) * lambda;
v *= 0.98f; // temp magic cheat
a *= 0.98f; // temp magic cheat
// integration
Object.transform.position += v * dt;
Quaternion q = QuaternionUtil.AxisAngle(VectorUtil.NormalizeSafe(a, Vector3.forward), a.magnitude * dt);
Object.transform.rotation = q * Object.transform.rotation;
}
public override bool Trigger(object arg)
{
if (!this.CanTrigger)
{
return(false);
}
var observer = this._observer.GetTarget <Transform>(arg);
if (observer == null)
{
return(false);
}
var targ = this._target.GetTarget <Transform>(arg);
if (targ == null)
{
return(false);
}
var dir = targ.position - observer.position;
var ax = (this._axisIsRelative) ? this.transform.GetAxis(this._axis) : TransformUtil.GetAxis(this._axis);
if (this._flattenOnAxis)
{
dir = dir.SetLengthOnAxis(ax, 0f);
}
var q = Quaternion.LookRotation(dir, ax);
if (this._slerp)
{
observer.rotation = QuaternionUtil.SpeedSlerp(observer.rotation, q, this._slerpAngularSpeed, Time.deltaTime);
}
else
{
observer.rotation = q;
}
return(true);
}
/// <summary>
/// Rotates subject towards the target using SmoothDamp
/// </summary>
/// <param name="transformToTurn">Subject to turn.</param>
/// <param name="target">Target to turn subject towards.</param>
/// <param name="currentVelocity">The current velocity, this value is modified by the function every time you call it.</param>
/// <param name="smoothTime">Approximately the time it will take to reach the target. A smaller value will reach the target faster.</param>
/// <returns>The delta angle between the direction the subject is facing to target position.</returns>
public static float RotateTowardsTargetSmoothDamp(Transform transformToTurn, Vector3 target, ref Quaternion currentVelocity, float smoothTime)
{
// Calculate direction to target
Vector3 targetRot = target - transformToTurn.position;
targetRot.y = 0.0f;
targetRot.Normalize();
// SmoothDamp towards to target rotation
transformToTurn.rotation =
QuaternionUtil.SmoothDamp(
transformToTurn.rotation,
Quaternion.LookRotation(targetRot),
ref currentVelocity,
smoothTime
);
// Debug visuals
Debug.DrawRay(transformToTurn.position, targetRot * 5.0f, Color.green);
Debug.DrawRay(transformToTurn.position, transformToTurn.forward * 5.0f, Color.red);
return(Vector3.Angle(transformToTurn.forward, targetRot));
}
public void Update()
{
m_phase = 0.5f * Mathf.Sin(Time.timeSinceLevelLoad * MathUtil.Pi) + 0.5f;
Vector3 twistAxis = m_rotInit * Vector3.up;
Quaternion swing;
Quaternion twist;
QuaternionUtil.Sterp(m_rotInit, m_rotEnd, twistAxis, m_phase, out swing, out twist);
switch (m_state)
{
case State.InitEnd:
{
m_rot0 = m_rotInit;
m_rot1 = m_rotEnd;
break;
}
case State.Comparison:
{
m_rot0 = Quaternion.Slerp(m_rotInit, m_rotEnd, m_phase);
m_rot1 = swing * twist * m_rotInit;
break;
}
/*
* case State.TwistSwingTrajectory:
* {
* m_rot0 = Quaternion.Slerp(m_rotInit, m_rotEnd, m_phase);
* m_rot1 = swing * twist * m_rotInit;
*
* const int kQueueCapacity = 20;
* if (m_trajectory0.Count >= kQueueCapacity)
* m_trajectory0.Dequeue();
* m_trajectory0.Enqueue(m_pos0 + m_rot0 * ((kRodLegnth - 0.5f * kRodThickness) * Vector3.up));
* if (m_trajectory1.Count >= kQueueCapacity)
* m_trajectory1.Dequeue();
* m_trajectory1.Enqueue(m_pos1 + m_rot1 * ((kRodLegnth - 0.5f * kRodThickness) * Vector3.up));
*
* Queue<Vector3> [] aTrajectory = { m_trajectory0, m_trajectory1 };
* foreach (Queue<Vector3> trajectory in aTrajectory)
* {
* Vector3 p0 = trajectory.Peek();
* foreach (Vector3 p1 in trajectory)
* {
* DebugUtil.DrawSphere(p0, 0.01f, 16, 32, Color.white, false, DebugUtil.Style.FlatShaded);
* DebugUtil.DrawCylinder(p0, p1, 0.005f, 16, Color.white, false, DebugUtil.Style.FlatShaded);
* p0 = p1;
* }
* }
*
* break;
* }
*/
case State.TwistSwing:
{
m_rot0 = swing * m_rotInit;
m_rot1 = twist * m_rotInit;
break;
}
}
DrawRod(m_pos0, m_rot0);
DrawRod(m_pos1, m_rot1);
if (Input.GetKeyDown(KeyCode.Space))
{
++m_state;
if (m_state >= State.Count)
{
m_state = 0;
}
}
}
public unsafe IModel LoadModel(GloModelFileBundle gloModelFileBundle)
{
var gloFile = gloModelFileBundle.GloFile;
var textureDirectories = gloModelFileBundle.TextureDirectories;
var fps = 20;
var glo = gloFile.Impl.ReadNew <Glo>(Endianness.LittleEndian);
var textureFilesByName = new Dictionary <string, IFileHierarchyFile>();
foreach (var textureDirectory in textureDirectories)
{
foreach (var textureFile in textureDirectory.Files)
{
textureFilesByName[textureFile.Name.ToLower()] = textureFile;
}
}
/*new MeshCsvWriter().WriteToFile(
* glo, new FinFile(Path.Join(outputDirectory.FullName, "mesh.csv")));
* new FaceCsvWriter().WriteToFile(
* glo, new FinFile(Path.Join(outputDirectory.FullName, "face.csv")));
* new VertexCsvWriter().WriteToFile(
* glo, new FinFile(Path.Join(outputDirectory.FullName, "vertex.csv")));*/
var finModel = new ModelImpl();
var finSkin = finModel.Skin;
var finRootBone = finModel.Skeleton.Root;
var finTextureMap = new LazyDictionary <string, ITexture?>(
textureFilename => {
if (!textureFilesByName.TryGetValue(textureFilename.ToLower(),
out var textureFile))
{
return(null);
}
using var rawTextureImage = FinImage.FromFile(textureFile.Impl);
var textureImageWithAlpha =
GloModelLoader.AddTransparencyToGloImage_(rawTextureImage);
var finTexture = finModel.MaterialManager.CreateTexture(
textureImageWithAlpha);
finTexture.Name = textureFilename;
if (this.mirrorTextures_.Contains(textureFilename))
{
finTexture.WrapModeU = WrapMode.MIRROR_REPEAT;
finTexture.WrapModeV = WrapMode.MIRROR_REPEAT;
}
else
{
finTexture.WrapModeU = WrapMode.REPEAT;
finTexture.WrapModeV = WrapMode.REPEAT;
}
return(finTexture);
});
var withCullingMap =
new LazyDictionary <string, IMaterial>(textureFilename => {
var finTexture = finTextureMap[textureFilename];
if (finTexture == null)
{
return(finModel.MaterialManager.AddStandardMaterial());
}
return(finModel.MaterialManager.AddTextureMaterial(finTexture));
});
var withoutCullingMap = new LazyDictionary <string, IMaterial>(
textureFilename => {
var finTexture = finTextureMap[textureFilename];
IMaterial finMaterial = finTexture == null
? finModel.MaterialManager
.AddStandardMaterial()
: finModel.MaterialManager
.AddTextureMaterial(
finTexture);
finMaterial.CullingMode = CullingMode.SHOW_BOTH;
return(finMaterial);
});
var firstMeshMap = new Dictionary <string, GloMesh>();
// TODO: Consider separating these out as separate models
foreach (var gloObject in glo.Objects)
{
var finObjectRootBone = finRootBone.AddRoot(0, 0, 0);
var meshQueue = new Queue <(GloMesh, IBone)>();
foreach (var topLevelGloMesh in gloObject.Meshes)
{
meshQueue.Enqueue((topLevelGloMesh, finObjectRootBone));
}
List <(IAnimation, int, int)> finAndGloAnimations = new();
foreach (var animSeg in gloObject.AnimSegs)
{
var startFrame = (int)animSeg.StartFrame;
var endFrame = (int)animSeg.EndFrame;
var finAnimation = finModel.AnimationManager.AddAnimation();
finAnimation.Name = animSeg.Name;
finAnimation.FrameCount =
(int)(animSeg.EndFrame - animSeg.StartFrame + 1);
finAnimation.FrameRate = fps * animSeg.Speed;
finAndGloAnimations.Add((finAnimation, startFrame, endFrame));
}
while (meshQueue.Count > 0)
{
var(gloMesh, parentFinBone) = meshQueue.Dequeue();
var name = gloMesh.Name;
GloMesh idealMesh;
if (!firstMeshMap.TryGetValue(name, out idealMesh))
{
firstMeshMap[name] = idealMesh = gloMesh;
}
var position = gloMesh.MoveKeys[0].Xyz;
var rotation = gloMesh.RotateKeys[0];
var quaternion =
new Quaternion(rotation.X, rotation.Y, rotation.Z, rotation.W);
var xyzRadians = QuaternionUtil.ToEulerRadians(quaternion);
var scale = gloMesh.ScaleKeys[0].Scale;
var finBone = parentFinBone
.AddChild(position.X, position.Y, position.Z)
.SetLocalRotationRadians(
xyzRadians.X, xyzRadians.Y, xyzRadians.Z)
.SetLocalScale(scale.X, scale.Y, scale.Z);
finBone.Name = name + "_bone";
var child = gloMesh.Pointers.Child;
if (child != null)
{
meshQueue.Enqueue((child, finBone));
}
var next = gloMesh.Pointers.Next;
if (next != null)
{
meshQueue.Enqueue((next, parentFinBone));
}
foreach (var(finAnimation, startFrame, endFrame) in
finAndGloAnimations)
{
var finBoneTracks = finAnimation.AddBoneTracks(finBone);
long prevTime = -1;
foreach (var moveKey in gloMesh.MoveKeys)
{
Asserts.True(moveKey.Time > prevTime);
prevTime = moveKey.Time;
if (!(moveKey.Time >= startFrame && moveKey.Time <= endFrame))
{
continue;
}
var time = (int)(moveKey.Time - startFrame);
Asserts.True(time >= 0 && time < finAnimation.FrameCount);
var moveValue = moveKey.Xyz;
finBoneTracks.Positions.Set(time, 0, moveValue.X);
finBoneTracks.Positions.Set(time, 1, moveValue.Y);
finBoneTracks.Positions.Set(time, 2, moveValue.Z);
}
prevTime = -1;
foreach (var rotateKey in gloMesh.RotateKeys)
{
Asserts.True(rotateKey.Time > prevTime);
prevTime = rotateKey.Time;
if (!(rotateKey.Time >= startFrame &&
rotateKey.Time <= endFrame))
{
continue;
}
var time = (int)(rotateKey.Time - startFrame);
Asserts.True(time >= 0 && time < finAnimation.FrameCount);
var quaternionKey =
new Quaternion(rotateKey.X, rotateKey.Y, rotateKey.Z,
rotateKey.W);
var xyzRadiansKey = QuaternionUtil.ToEulerRadians(quaternionKey);
finBoneTracks.Rotations.Set(time, 0,
xyzRadiansKey.X);
finBoneTracks.Rotations.Set(time, 1,
xyzRadiansKey.Y);
finBoneTracks.Rotations.Set(time, 2,
xyzRadiansKey.Z);
}
prevTime = -1;
foreach (var scaleKey in gloMesh.ScaleKeys)
{
Asserts.True(scaleKey.Time > prevTime);
prevTime = scaleKey.Time;
if (!(scaleKey.Time >= startFrame && scaleKey.Time <= endFrame))
{
continue;
}
var time = (int)(scaleKey.Time - startFrame);
Asserts.True(time >= 0 && time < finAnimation.FrameCount);
var scaleValue = scaleKey.Scale;
finBoneTracks.Scales.Set(time, 0, scaleValue.X);
finBoneTracks.Scales.Set(time, 1, scaleValue.Y);
finBoneTracks.Scales.Set(time, 2, scaleValue.Z);
}
}
// Anything with these names are debug objects and can be ignored.
if (this.hiddenNames_.Contains(name))
{
continue;
}
var finMesh = finSkin.AddMesh();
finMesh.Name = name;
var gloVertices = idealMesh.Vertices;
string previousTextureName = null;
IMaterial?previousMaterial = null;
foreach (var gloFace in idealMesh.Faces)
{
// TODO: What can we do if texture filename is empty?
var textureFilename = gloFace.TextureFilename;
var gloFaceColor = gloFace.Color;
var finFaceColor = ColorImpl.FromRgbaBytes(
gloFaceColor.R, gloFaceColor.G, gloFaceColor.B, gloFaceColor.A);
var enableBackfaceCulling = (gloFace.Flags & 1 << 2) == 0;
IMaterial?finMaterial;
if (textureFilename == previousTextureName)
{
finMaterial = previousMaterial;
}
else
{
previousTextureName = textureFilename;
finMaterial = enableBackfaceCulling
? withCullingMap[textureFilename]
: withoutCullingMap[textureFilename];
previousMaterial = finMaterial;
}
// Face flag:
// 0: potentially some kind of repeat mode??
var color = (gloFace.Flags & 1 << 6) != 0
? ColorImpl.FromRgbaBytes(255, 0, 0, 255)
: ColorImpl.FromRgbaBytes(0, 255, 0, 255);
var finFaceVertices = new IVertex[3];
for (var v = 0; v < 3; ++v)
{
var gloVertexRef = gloFace.VertexRefs[v];
var gloVertex = gloVertices[gloVertexRef.Index];
var finVertex = finSkin
.AddVertex(gloVertex.X, gloVertex.Y, gloVertex.Z)
.SetUv(gloVertexRef.U, gloVertexRef.V);
//.SetColor(color);
finVertex.SetBoneWeights(finSkin.GetOrCreateBoneWeights(
PreprojectMode.BONE, finBone));
finFaceVertices[v] = finVertex;
}
// TODO: Merge triangles together
var finTriangles = new (IVertex, IVertex, IVertex)[1];
private System.Collections.IEnumerator DoUpdateRoutine()
{
while (true)
{
if (_linkTarget != null)
{
Constraint c;
var trans = this.transform;
//constrain position
c = (_constraint & Constraint.Position);
if (c == Constraint.Position)
{
if (_doPositionDamping)
{
switch (_positionDampingStyle)
{
case JointDampingStyle.Ease:
trans.position = Vector3.Lerp(trans.position, _linkTarget.position, Time.deltaTime * _positionDampingStrength);
break;
case JointDampingStyle.Linear:
trans.position = Vector3.MoveTowards(trans.position, _linkTarget.position, Time.deltaTime * _positionDampingStrength);
break;
case JointDampingStyle.Elastic:
{
var tpos = _linkTarget.position;
var pos = trans.position;
if (_positionDampingStrength < 0.0001f)
{
trans.position = tpos;
break;
}
float t = 1f - Mathf.Clamp01(1f / _positionDampingStrength) * 0.99f;
tpos += (tpos - pos);
trans.position = Vector3.LerpUnclamped(pos, tpos, t);
}
break;
}
}
else
{
trans.position = _linkTarget.position;
}
}
else if (c != 0)
{
Vector3 pos = trans.position;
Vector3 tpos = _linkTarget.position;
if ((_constraint & Constraint.XPosition) != 0)
{
if (_doPositionDamping)
{
pos.x = DampFloat(pos.x, tpos.x, Time.deltaTime, _positionDampingStrength, _positionDampingStyle);
}
else
{
pos.x = tpos.x;
}
}
if ((_constraint & Constraint.YPosition) != 0)
{
if (_doPositionDamping)
{
pos.y = DampFloat(pos.y, tpos.y, Time.deltaTime, _positionDampingStrength, _positionDampingStyle);
}
else
{
pos.y = tpos.y;
}
}
if ((_constraint & Constraint.ZPosition) != 0)
{
if (_doPositionDamping)
{
pos.z = DampFloat(pos.z, tpos.z, Time.deltaTime, _positionDampingStrength, _positionDampingStyle);
}
else
{
pos.z = tpos.z;
}
}
trans.position = pos;
}
//constrain rotation
c = (_constraint & Constraint.Rotation);
if (c == Constraint.Rotation)
{
if (_doRotationDamping)
{
switch (_positionDampingStyle)
{
case JointDampingStyle.Ease:
trans.rotation = Quaternion.Slerp(trans.rotation, _linkTarget.rotation, Time.deltaTime * _positionDampingStrength);
break;
case JointDampingStyle.Linear:
trans.rotation = Quaternion.RotateTowards(trans.rotation, _linkTarget.rotation, Time.deltaTime * _positionDampingStrength);
break;
case JointDampingStyle.Elastic:
{
var tpos = _linkTarget.rotation;
var pos = trans.rotation;
if (_positionDampingStrength < 0.0001f)
{
trans.rotation = tpos;
break;
}
float t = 1f - Mathf.Clamp01(1f / _positionDampingStrength) * 0.99f;
tpos *= QuaternionUtil.FromToRotation(pos, tpos);
trans.rotation = Quaternion.SlerpUnclamped(pos, tpos, t);
}
break;
}
}
else
{
trans.rotation = _linkTarget.rotation;
}
}
else if (c != 0)
{
var rot = trans.eulerAngles;
var targRot = _linkTarget.eulerAngles;
if ((_constraint & Constraint.XRotation) != 0)
{
if (_doRotationDamping)
{
rot.x = DampFloat(rot.x, targRot.x, Time.deltaTime, _rotationDampingStrength, _rotationDampingStyle);
}
else
{
rot.x = targRot.x;
}
}
if ((_constraint & Constraint.YRotation) != 0)
{
if (_doRotationDamping)
{
rot.y = DampFloat(rot.y, targRot.y, Time.deltaTime, _rotationDampingStrength, _rotationDampingStyle);
}
else
{
rot.y = targRot.y;
}
}
if ((_constraint & Constraint.ZRotation) != 0)
{
if (_doRotationDamping)
{
rot.z = DampFloat(rot.z, targRot.z, Time.deltaTime, _rotationDampingStrength, _rotationDampingStyle);
}
else
{
rot.z = targRot.z;
}
}
trans.eulerAngles = rot;
}
}
switch (_updateMode)
{
case UpdateSequence.None:
case UpdateSequence.Update:
yield return(null);
break;
case UpdateSequence.FixedUpdate:
yield return(RadicalCoroutine.WaitForFixedUpdate);
break;
case UpdateSequence.LateUpdate:
yield return(WaitForLateUpdate.Create());
break;
}
}
}
public static bool IsNaN(Trans t)
{
return(VectorUtil.IsNaN(t.Position) || VectorUtil.IsNaN(t.Scale) || QuaternionUtil.IsNaN(t.Rotation));
}
public override void OnGUI(Rect position, SerializedProperty property, GUIContent label)
{
var r0 = new Rect(position.xMin, position.yMin, position.width / 2f, position.height);
var r1 = new Rect(r0.xMax, position.yMin, position.width - r0.width, position.height);
var propName = property.FindPropertyRelative(PROP_NAME);
var propValue = property.FindPropertyRelative(PROP_VALUE);
var propRef = property.FindPropertyRelative(PROP_REF);
int index = System.Array.IndexOf(_knownPlayerSettingPropNames, propName.stringValue);
EditorGUI.BeginChangeCheck();
index = EditorGUI.Popup(r0, GUIContent.none, index, _knownPlayerSettingPropNamesPretty);
if (EditorGUI.EndChangeCheck())
{
if (index >= 0 && index < _knownPlayerSettingPropNames.Length)
{
propName.stringValue = _knownPlayerSettingPropNames[index];
}
else
{
propName.stringValue = string.Empty;
}
propValue.stringValue = string.Empty;
propRef.objectReferenceValue = null;
}
if (index < 0 || index >= _knownPlayerSettings.Length)
{
return;
}
var info = _knownPlayerSettings[index];
if (info.PropertyType.IsEnum)
{
int ei = ConvertUtil.ToInt(propValue.stringValue);
propValue.stringValue = ConvertUtil.ToInt(EditorGUI.EnumPopup(r1, ConvertUtil.ToEnumOfType(info.PropertyType, ei))).ToString();
propRef.objectReferenceValue = null;
}
else
{
var etp = VariantReference.GetVariantType(info.PropertyType);
switch (etp)
{
case VariantType.Null:
propValue.stringValue = string.Empty;
propRef.objectReferenceValue = null;
break;
case VariantType.String:
propValue.stringValue = EditorGUI.TextField(r1, propValue.stringValue);
propRef.objectReferenceValue = null;
break;
case VariantType.Boolean:
propValue.stringValue = EditorGUI.Toggle(r1, GUIContent.none, ConvertUtil.ToBool(propValue.stringValue)).ToString();
propRef.objectReferenceValue = null;
break;
case VariantType.Integer:
propValue.stringValue = EditorGUI.IntField(r1, GUIContent.none, ConvertUtil.ToInt(propValue.stringValue)).ToString();
propRef.objectReferenceValue = null;
break;
case VariantType.Float:
propValue.stringValue = EditorGUI.FloatField(r1, GUIContent.none, ConvertUtil.ToSingle(propValue.stringValue)).ToString();
propRef.objectReferenceValue = null;
break;
case VariantType.Double:
propValue.stringValue = EditorGUI.DoubleField(r1, GUIContent.none, ConvertUtil.ToDouble(propValue.stringValue)).ToString();
propRef.objectReferenceValue = null;
break;
case VariantType.Vector2:
propValue.stringValue = VectorUtil.Stringify(EditorGUI.Vector2Field(r1, GUIContent.none, ConvertUtil.ToVector2(propValue.stringValue)));
propRef.objectReferenceValue = null;
break;
case VariantType.Vector3:
propValue.stringValue = VectorUtil.Stringify(EditorGUI.Vector3Field(r1, GUIContent.none, ConvertUtil.ToVector3(propValue.stringValue)));
propRef.objectReferenceValue = null;
break;
case VariantType.Vector4:
propValue.stringValue = VectorUtil.Stringify(EditorGUI.Vector4Field(r1, (string)null, ConvertUtil.ToVector4(propValue.stringValue)));
propRef.objectReferenceValue = null;
break;
case VariantType.Quaternion:
propValue.stringValue = QuaternionUtil.Stringify(SPEditorGUI.QuaternionField(r1, GUIContent.none, ConvertUtil.ToQuaternion(propValue.stringValue)));
propRef.objectReferenceValue = null;
break;
case VariantType.Color:
propValue.stringValue = ConvertUtil.ToInt(EditorGUI.ColorField(r1, ConvertUtil.ToColor(propValue.stringValue))).ToString();
propRef.objectReferenceValue = null;
break;
case VariantType.DateTime:
//TODO - should never actually occur
propValue.stringValue = string.Empty;
propRef.objectReferenceValue = null;
break;
case VariantType.GameObject:
case VariantType.Component:
case VariantType.Object:
propValue.stringValue = string.Empty;
propRef.objectReferenceValue = EditorGUI.ObjectField(r1, GUIContent.none, propValue.objectReferenceValue, info.PropertyType, false);
break;
case VariantType.LayerMask:
propValue.stringValue = SPEditorGUI.LayerMaskField(r1, GUIContent.none, ConvertUtil.ToInt(propValue.stringValue)).ToString();
propRef.objectReferenceValue = null;
break;
case VariantType.Rect:
//TODO - should never actually occur
propValue.stringValue = string.Empty;
propRef.objectReferenceValue = null;
break;
case VariantType.Numeric:
break;
}
}
}
public static IFinMatrix4x4 FromRotation(IRotation rotation) => MatrixTransformUtil.FromRotation(QuaternionUtil.Create(rotation));
// Find rotation vector displacement between two quaternions (from q1 to q2)
public static Vector3 Disp(Quaternion q1, Quaternion q2)
{
return(QuaternionUtil.Log(Quaternion.Inverse(q1) * q2));
}
