コード例 #1
0
        private bool _CanReduce(_AnimCurve curve, _Keyframe key0, _Keyframe key1, float time,
                                float allowedError)
        {
            float invT = Mathf.InverseLerp(key0.time, key1.time, time);

            switch (curve.KeyframeType)
            {
            case _AnimCurve.KFType.Position:
            case _AnimCurve.KFType.Scale:
            {
                Vector3 value           = curve.Evaluate_Vector3(time);
                Vector3 v3Key0          = (Vector3)key0;
                Vector3 v3Key1          = (Vector3)key1;
                Vector3 interpolatedVal = Vector3.Lerp(v3Key0, v3Key1, invT);
                return(PositionDistanceError(value, interpolatedVal, allowedError));
            }

            case _AnimCurve.KFType.Rotation:
            {
                Quaternion value           = curve.Evaluate_Quaternion(time);
                Quaternion qKey0           = (Quaternion)key0;
                Quaternion qKey1           = (Quaternion)key1;
                Quaternion interpolatedVal = Quaternion.Lerp(qKey0, qKey1, invT);
                return(QuaternionDistanceError(value, interpolatedVal, allowedError));
            }

            default:
                Dbg.LogErr("AnimCompress._CanReduce: unexpected KFtype: {0}", curve.KeyframeType);
                return(false);
            }
        }
コード例 #2
0
        private bool _CanReduce(_Keyframe fromKey, _Keyframe toKey, _AnimCurve curve,
                                float allowedError, float delta,
                                int firstKey, int lastKey, bool useKeyframeLimit)
        {
            float beginTime = fromKey.time;
            float endTime   = toKey.time;

            bool canReduce = true;

            for (float t = beginTime + delta; t < endTime; t += delta)
            {
                if (!(canReduce = _CanReduce(curve, fromKey, toKey, t, allowedError)))
                {
                    break;
                }
            }

            // we need to check that all keys can be reduced, because keys might be closer to each other than delta
            // this happens when we have steps in curve
            // TODO : we could skip the loop above if keyframes are close enough

            float lastTime = beginTime;

            for (int j = firstKey; canReduce && j < lastKey; ++j)
            {
                float time = curve.Get(j).time;

                // validates point at keyframe (j) and point between (j) and and (j-1) keyframes
                // TODO : For checking point at "time" it could just use keys[j].value instead - that would be faster than sampling the curve
                canReduce =
                    _CanReduce(curve, fromKey, toKey, time, allowedError) &&
                    _CanReduce(curve, fromKey, toKey, (lastTime + time) / 2, allowedError);

                lastTime = time;
            }

            if (canReduce)
            {
                // validate point between last two keyframes
                float time = curve.Get(lastKey).time;
                canReduce = _CanReduce(curve, fromKey, toKey, (lastTime + time) / 2, allowedError);
            }

            // Don't reduce if we are about to reduce more than 50 samples at
            // once to prevent n^2 performance impact
            canReduce = canReduce && (!useKeyframeLimit || (endTime - beginTime < 50.0F * delta));

            return(canReduce);
        }
コード例 #3
0
        private _AnimCurve _GatherScaleCurve(EditorCurveBinding oneBinding)
        {
            AnimationCurve[]     curves   = new AnimationCurve[3];
            EditorCurveBinding[] bindings = new EditorCurveBinding[3];

            for (int i = 0; i < 3; ++i)
            {
                bindings[i] = oneBinding;
                bindings[i].propertyName = PROP_LSCA + SCA_POSTFIX[i];
                curves[i] = AnimationUtility.GetEditorCurve(m_Clip, bindings[i]);
                if (curves[i] == null)
                {
                    Dbg.LogWarn("AnimCompress._GatherScaleCurve: failed to get curve on binding: {0}", bindings[i]);
                    return(null);
                }

                _RegBinding(bindings[i]);
            }

            _AnimCurve newCompCurve = new _AnimCurve(curves, _AnimCurve.KFType.Scale, bindings, m_Clip);

            return(newCompCurve);
        }
コード例 #4
0
        private float _ReduceKeyFrames(_AnimCurve curve, float sampleRate, float allowedError)
        {
            int keycnt = curve.KeyCnt;

            if (keycnt <= 2)
            {
                return(100f);
            }

            float            delta  = 1f / sampleRate;
            List <_Keyframe> keyLst = new List <_Keyframe>(keycnt);

            _Keyframe[] keys    = curve.keys;
            _Keyframe   kfStart = keys[0].Clone();
            _Keyframe   kfEnd   = keys[keycnt - 1].Clone();

            // at first try reducing to const curve
            kfStart.inTangent = kfStart.outTangent = 0f;
            kfEnd.inTangent   = kfEnd.outTangent = 0f;
            kfEnd.value       = kfStart.value;

            bool bCanReduceToConstCurve = _CanReduce(kfStart, kfEnd, curve, allowedError, delta, 0, keycnt - 1, false);

            if (bCanReduceToConstCurve)
            {
                keyLst.Add(kfStart);
                keyLst.Add(kfEnd);
            }
            else
            {
                keyLst.Capacity = keycnt;
                keyLst.Add(keys[0]);

                int lastUsedKey = 0;

                for (int i = 1; i < keycnt - 1; i++)
                {
                    _Keyframe fromKey = keys[lastUsedKey];
                    _Keyframe toKey   = keys[i + 1];

                    //FitTangentsToCurve(curve, fromKey, toKey);

                    bool canReduce = _CanReduce(fromKey, toKey, curve, allowedError, delta, lastUsedKey + 1, i + 1, true);

                    if (!canReduce)
                    {
                        keyLst.Add(keys[i]);
                        // fitting tangents between last two keys
                        //FitTangentsToCurve(curve, *(output.end() - 2), output.back());

                        lastUsedKey = i;
                    }
                }

                // We always add the last key
                keyLst.Add(keys[keycnt - 1]);
                // fitting tangents between last and the one before last keys
                //FitTangentsToCurve(curve, *(output.end() - 2), output.back());
            }

            float compressRatio = (float)keyLst.Count / (float)keycnt * 100.0F;

            if (m_Verbose)
            {
                Dbg.Log("compressRatio = {0}%, {1}/{2}\t{3} : {4}", compressRatio, keyLst.Count, keycnt, curve.Binding0.path, curve.Binding0.propertyName);
            }

            curve.keys = keyLst.ToArray();

            return(compressRatio);
        }
コード例 #5
0
        public void ReduceKeyframes(AnimationClip clip,
                                    float posErr, float rotErr, float scaleErr, float floatErr)
        {
            m_Clip = clip;

            posErr   /= 100f;
            scaleErr /= 100f;
            floatErr /= 100f;
            rotErr    = Mathf.Cos(rotErr * Mathf.Deg2Rad / 2f);

            var allCurveData = AnimationUtility.GetAllCurves(clip, false);
            int curveCnt     = m_CurveCnt = allCurveData.Length;

            m_FinishedCurveCnt = 0;

            if (curveCnt == 0)
            {
                Dbg.LogWarn("There is no curves in given clip: {0}", clip.name);
                return;
            }

            m_checkedCurves = new HashSet <string>();

            double time      = EditorApplication.timeSinceStartup;
            int    oldKeyCnt = 0;
            int    newKeyCnt = 0;
            float  compRatio = 0f;

            float sampleRate = clip.frameRate;

            // execute
            EditorCurveBinding[] bindings = AnimationUtility.GetCurveBindings(clip);
            foreach (var oneBinding in bindings)
            {
                oldKeyCnt += _GetKeyCnt(oneBinding);

                if (!_HasBinding(oneBinding))
                {
                    string pName = oneBinding.propertyName;
                    if (pName.StartsWith(PROP_LPOS))
                    {
                        // gather all other curves to form a position curve
                        _AnimCurve newCurve = _GatherPosCurve(oneBinding);
                        _ReduceKeyFrames(newCurve, sampleRate, posErr);
                    }
                    else if (pName.StartsWith(PROP_LROT))
                    {
                        // gather all other curves to form a rotation curve
                        _AnimCurve newCurve = _GatherRotCurve(oneBinding);
                        _ReduceKeyFrames(newCurve, sampleRate, rotErr);
                    }
                    else if (pName.StartsWith(PROP_LSCA))
                    {
                        // gather all other curves to form a scale curve
                        _AnimCurve newCurve = _GatherScaleCurve(oneBinding);
                        _ReduceKeyFrames(newCurve, sampleRate, scaleErr);
                    }
                    else
                    {
                        Dbg.Log("Ignore curve: {0}", pName);
                    }
                }

                newKeyCnt += _GetKeyCnt(oneBinding);
                m_FinishedCurveCnt++;

                if (m_FinishedCurveCnt % 10 == 0)
                {
                    EditorUtility.DisplayProgressBar("Crunching curves...",
                                                     "Working hard to compress clip..." + m_FinishedCurveCnt + "/" + m_CurveCnt,
                                                     m_FinishedCurveCnt / (float)m_CurveCnt
                                                     );
                }
            }

            EditorUtility.ClearProgressBar();

            if (oldKeyCnt != 0)
            {
                compRatio = (float)newKeyCnt / (float)oldKeyCnt;
            }
            time = EditorApplication.timeSinceStartup - time;

            Dbg.Log("ReduceKeyFrames: compress ratio: {0:F2}%, time: {1:F4}", compRatio * 100f, time);

            m_checkedCurves.Clear();
            m_checkedCurves = null;
        }