public void OnTrackablesUpdated()
{
if (rotations.Count >= smoothingFrames)
{
rotations.Dequeue();
positions.Dequeue();
}
rotations.Enqueue(transform.rotation);
positions.Enqueue(transform.position);
Vector4 avgr = Vector4.zero;
foreach (Quaternion singleRotation in rotations)
{
Math3d.AverageQuaternion(ref avgr, singleRotation, rotations.Peek(), rotations.Count);
}
Vector3 avgp = Vector3.zero;
foreach (Vector3 singlePosition in positions)
{
avgp += singlePosition;
}
avgp /= positions.Count;
smoothedRotation = new Quaternion(avgr.x, avgr.y, avgr.z, avgr.w);
smoothedPosition = avgp;
}
// Update is called once per frame
void Update()
{
if (nonVuforiaTracker != null && !isAnimating)
{
Vector3 v3 = new Vector3(nonVuforiaTracker.position.x, nonVuforiaTracker.position.y, nonVuforiaTracker.position.z);
Quaternion r3 = nonVuforiaTracker.rotation;
if (rotations.Count >= smoothingFrames)
{
rotations.Dequeue();
positions.Dequeue();
}
rotations.Enqueue(r3);
positions.Enqueue(v3);
Vector4 avgr = Vector4.zero;
foreach (Quaternion singleRotation in rotations)
{
Math3d.AverageQuaternion(ref avgr, singleRotation, rotations.Peek(), rotations.Count);
}
Vector3 avgp = Vector3.zero;
foreach (Vector3 singlePosition in positions)
{
avgp += singlePosition;
}
avgp /= positions.Count;
smoothedRotation = new Quaternion(avgr.x, avgr.y, avgr.z, avgr.w);
smoothedPosition = avgp;
transform.position = smoothedPosition;
transform.rotation = smoothedRotation;
}
}
// Update is called once per frame
void Update()
{
if (trackingmarker != null && !isAnimating && trackingmarker.isActiveAndEnabled)
{
Vector3 v3 = new Vector3(trackingmarker.transform.position.x + locationoffset.x, trackingmarker.transform.position.y + locationoffset.y, trackingmarker.transform.position.z + locationoffset.z);
Quaternion r3 = trackingmarker.transform.rotation * rotationoffset;
if (rotations.Count >= smoothingFrames)
{
rotations.Dequeue();
positions.Dequeue();
}
rotations.Enqueue(r3);
positions.Enqueue(v3);
Vector4 avgr = Vector4.zero;
foreach (Quaternion singleRotation in rotations)
{
Math3d.AverageQuaternion(ref avgr, singleRotation, rotations.Peek(), rotations.Count);
}
Vector3 avgp = Vector3.zero;
foreach (Vector3 singlePosition in positions)
{
avgp += singlePosition;
}
avgp /= positions.Count;
smoothedRotation = new Quaternion(avgr.x, avgr.y, avgr.z, avgr.w);
smoothedPosition = avgp;
transform.position = smoothedPosition;
transform.rotation = smoothedRotation;
}
}
public void OnTrackablesUpdated()
{
// --------------------------------------------------------------------------
// Position
// Optional low pass filter
if (filterPosition)
{
if (cameraPositionFilter != null)
{
position = cameraPositionFilter.Append(transform.position);
}
else
{
cameraPositionFilter = new LowPassFilter <Vector3>(FILTER_ALPHA, transform.position);
position = transform.position;
}
Debug.Log("position delta = " + (transform.position.x - position.x) + ", " + (transform.position.y - position.y) + ", " + (transform.position.z - position.z));
}
else
{
position = transform.position;
}
// Optional smoothing
if (smoothPosition)
{
if (smoothingPositions.Count >= smoothingFrames)
{
smoothingPositions.Dequeue();
}
smoothingPositions.Enqueue(position);
Vector3 avgp = Vector3.zero;
foreach (Vector3 singlePosition in smoothingPositions)
{
avgp += singlePosition;
}
position = avgp / smoothingPositions.Count;
}
//Debug.Log("position = " + position.x + ", " + position.y + ", " + position.z);
// --------------------------------------------------------------------------
// ROTATION
// Optional low pass filter
if (filterPosition)
{
if (cameraPositionFilter != null)
{
rotation = cameraRotationFilter.Append(transform.rotation);
}
else
{
cameraRotationFilter = new LowPassFilter <Quaternion>(FILTER_ALPHA, transform.rotation);
rotation = transform.rotation;
}
}
else
{
rotation = transform.rotation;
}
// Optional smoothing
if (smoothRotation)
{
if (smoothingRotations.Count >= smoothingFrames)
{
smoothingRotations.Dequeue();
}
smoothingRotations.Enqueue(rotation);
Vector4 avgr = Vector4.zero;
foreach (Quaternion singleRotation in smoothingRotations)
{
Math3d.AverageQuaternion(ref avgr, singleRotation, smoothingRotations.Peek(), smoothingRotations.Count);
}
rotation = new Quaternion(avgr.x, avgr.y, avgr.z, avgr.w);
}
}
