private void UpdateKeyframes(bool selected, IList <DsRow> rows, Material material, int index, float rowHeight, float aspect, Vector3 offset, float visibleColumns, Vector3 keyframeScale)
        {
            int rowNumber = 0;

            for (int i = 0; i < rows.Count; ++i)
            {
                DsRow row = rows[i];
                if (row.IsVisible)
                {
                    List <DsKeyframe> keyframes = selected ? row.SelectedKeyframes : row.Keyframes;
                    for (int j = 0; j < keyframes.Count; ++j)
                    {
                        DsKeyframe keyframe = keyframes[j];
                        m_matrices[index] = Matrix4x4.TRS(
                            offset + new Vector3(aspect * keyframe.Col / visibleColumns, -rowHeight * rowNumber, 1),
                            Quaternion.Euler(0, 0, 45),
                            keyframeScale);

                        index++;
                        if (index == k_batchSize)
                        {
                            index = 0;
                            m_rteCamera.CommandBuffer.DrawMeshInstanced(m_quad, 0, material, 0, m_matrices, k_batchSize);
                        }
                    }

                    rowNumber++;
                }
            }

            if (0 < index && index < k_batchSize)
            {
                m_rteCamera.CommandBuffer.DrawMeshInstanced(m_quad, 0, material, 0, m_matrices, index);
            }
        }
            public void RemoveKeyframes(bool all, params DsKeyframe[] keyframes)
            {
                for (int i = 0; i < keyframes.Length; ++i)
                {
                    DsKeyframe kf  = keyframes[i];
                    int        key = kf.Row.Index * ColsCount + kf.Col;

                    if (all)
                    {
                        if (m_kfDictionary.TryGetValue(key, out kf))
                        {
                            m_keyframes.Remove(kf);
                            m_kfDictionary.Remove(key);
                            kf.Row.Keyframes.Remove(kf);
                        }
                        else if (m_selectedKfDictionary.TryGetValue(key, out kf))
                        {
                            m_selectedKeyframes.Remove(kf);
                            m_selectedKfDictionary.Remove(key);
                            kf.Row.SelectedKeyframes.Remove(kf);
                        }
                    }
                    else
                    {
                        if (m_kfDictionary.TryGetValue(key, out kf))
                        {
                            m_keyframes.Remove(kf);
                            m_kfDictionary.Remove(key);
                            kf.Row.Keyframes.Remove(kf);
                        }
                    }
                }
            }
 public void ResizeClip(IList <DsKeyframe> keyframes)
 {
     for (int i = 0; i < keyframes.Count; ++i)
     {
         DsKeyframe kf = keyframes[i];
         if (ColsCount <= kf.Col || RowsCount <= kf.Row.Index)
         {
             ColsCount = Mathf.Max(ColsCount, kf.Col + 1);
             RefreshDictionaries();
         }
     }
 }
예제 #4
0
            private void SelectKeyframe(DsKeyframe kf, int key)
            {
                m_keyframes.Remove(kf);
                m_kfDictionary.Remove(key);
                kf.Row.Keyframes.Remove(kf);

                m_selectedKfDictionary.Add(key, kf);
                m_selectedKeyframes.Add(kf);

                DsRow dopesheetRow = kf.Row;
                dopesheetRow.SelectedKeyframes.Add(kf);
            }
            private void RefreshFirstAndLastSample()
            {
                if (m_rows.Count == 0)
                {
                    FirstSample = 0;
                    LastSample  = 0;
                }
                else
                {
                    int min = ColsCount - 1;
                    int max = 0;
                    for (int i = 0; i < m_keyframes.Count; ++i)
                    {
                        DsKeyframe keyframe = m_keyframes[i];
                        if (keyframe.Col < min)
                        {
                            min = keyframe.Col;
                        }
                        if (keyframe.Col > max)
                        {
                            max = keyframe.Col;
                        }
                    }

                    for (int i = 0; i < m_selectedKeyframes.Count; ++i)
                    {
                        DsKeyframe keyframe = m_selectedKeyframes[i];
                        if (keyframe.Col < min)
                        {
                            min = keyframe.Col;
                        }
                        if (keyframe.Col > max)
                        {
                            max = keyframe.Col;
                        }
                    }

                    FirstSample = min;
                    LastSample  = max;
                    ColsCount   = LastSample + 1;
                }
            }
            public void RefreshCurve(float frameRate)
            {
                if (Curve != null)
                {
                    Keyframe[] keyframes = Curve.keys;
                    Array.Resize(ref keyframes, Keyframes.Count + SelectedKeyframes.Count);

                    DsKeyframe[] dsKeyframes = Keyframes.Union(SelectedKeyframes).OrderBy(k => k.Col).ToArray();
                    for (int i = 0; i < dsKeyframes.Length; ++i)
                    {
                        DsKeyframe dsKeyframe = dsKeyframes[i];
                        dsKeyframe.Index = i;

                        Keyframe keyframe = new Keyframe(dsKeyframe.Col / frameRate, dsKeyframe.Value);
                        keyframes[i] = keyframe;
                    }

                    Curve.keys = keyframes;
                }
            }
            public void AddKeyframes(params DsKeyframe[] keyframes)
            {
                for (int i = 0; i < keyframes.Length; ++i)
                {
                    DsKeyframe kf  = keyframes[i];
                    int        key = kf.Row.Index * ColsCount + kf.Col;
                    m_kfDictionary.Add(key, kf);
                    m_keyframes.Add(kf);
                    kf.Row.Keyframes.Add(kf);

                    if (kf.Col > LastSample)
                    {
                        LastSample = kf.Col;
                    }
                    if (kf.Col < FirstSample)
                    {
                        FirstSample = kf.Col;
                    }
                }
            }
            public void SelectKeyframes(params DsKeyframe[] keyframes)
            {
                for (int i = 0; i < keyframes.Length; ++i)
                {
                    DsKeyframe kf  = keyframes[i];
                    int        key = kf.Row.Index * ColsCount + kf.Col;

                    if (m_kfDictionary.TryGetValue(key, out kf))
                    {
                        SelectKeyframe(kf, key);
                        DsRow dopesheetRow = kf.Row;
                        while (dopesheetRow.Parent != null)
                        {
                            DsKeyframe parentKf;
                            int        parentKey = dopesheetRow.Parent.Index * ColsCount + kf.Col;
                            if (m_kfDictionary.TryGetValue(parentKey, out parentKf))
                            {
                                SelectKeyframe(parentKf, parentKey);
                            }
                            dopesheetRow = dopesheetRow.Parent;
                        }

                        dopesheetRow = kf.Row;
                        if (dopesheetRow.Children != null)
                        {
                            List <DsKeyframe> childKeyframes = new List <DsKeyframe>();
                            for (int c = 0; c < dopesheetRow.Children.Count; ++c)
                            {
                                DsRow      childRow      = dopesheetRow.Children[c];
                                DsKeyframe childKeyframe = GetKeyframe(childRow.Index, kf.Col);
                                if (childKeyframe != null)
                                {
                                    childKeyframes.Add(childKeyframe);
                                }
                            }

                            SelectKeyframes(childKeyframes.ToArray());
                        }
                    }
                }
            }
            private void RefreshDictionaries()
            {
                m_kfDictionary.Clear();
                m_selectedKfDictionary.Clear();

                for (int i = 0; i < m_keyframes.Count; ++i)
                {
                    DsKeyframe kf  = m_keyframes[i];
                    int        key = kf.Row.Index * ColsCount + kf.Col;

                    m_kfDictionary.Add(key, kf);
                }

                for (int i = 0; i < m_selectedKeyframes.Count; ++i)
                {
                    DsKeyframe kf  = m_selectedKeyframes[i];
                    int        key = kf.Row.Index * ColsCount + kf.Col;

                    m_selectedKfDictionary.Add(key, kf);
                }
            }
            public void UnselectKeyframes(params DsKeyframe[] keyframes)
            {
                for (int i = 0; i < keyframes.Length; ++i)
                {
                    DsKeyframe kf  = keyframes[i];
                    int        key = kf.Row.Index * ColsCount + kf.Col;

                    if (m_selectedKfDictionary.TryGetValue(key, out kf))
                    {
                        m_selectedKeyframes.Remove(kf);
                        m_selectedKfDictionary.Remove(key);
                        kf.Row.SelectedKeyframes.Remove(kf);
                    }
                    else
                    {
                        continue;
                    }

                    m_kfDictionary.Add(key, kf);
                    m_keyframes.Add(kf);
                    kf.Row.Keyframes.Add(kf);
                }
            }