示例#1
0
        void MouseDown(int note, float time, Sequencer sequencer, SerializedProperty allNotes)
        {
            float divisionLength = sequencer.GetDivisionLength();

            roundingToIndex = false;
            mouseActive     = true;
            activeNote      = sequencer.GetNoteInRange(note, time, time);
            dragTime        = time;
            activeTime      = time;
            pressTime       = time;
            pressNote       = note;

            if (pressedKey >= 0)
            {
                sequencer.NoteOff(pressedKey);
                pressedKey = -1;
            }

            if (time < 0.0f)
            {
                mode       = Mode.kKeyboarding;
                pressedKey = note;
                sequencer.NoteOn(pressedKey, 1.0f);
                return;
            }
            else if (activeNote != null)
            {
                float startPixels = colWidth * (time - activeNote.start) / divisionLength;
                float endPixels   = colWidth * (activeNote.end - time) / divisionLength;

                if (endPixels <= grabResizeWidth)
                {
                    mode = Mode.kDraggingEnd;
                }
                else if (startPixels <= grabResizeWidth)
                {
                    mode = Mode.kDraggingStart;
                }
                else
                {
                    mode = Mode.kDeleting;
                }
            }
            else
            {
                mode = Mode.kAdding;
            }
        }
示例#2
0
        void MouseUp(float time, Sequencer sequencer, SerializedProperty allNotes)
        {
            float divisionLength = sequencer.GetDivisionLength();

            mouseActive = false;
            if (mode == Mode.kKeyboarding)
            {
                sequencer.NoteOff(pressedKey);
                pressedKey = -1;
                return;
            }

            dragTime = Mathf.Clamp(time, 0.0f, sequencer.length);
            float startTime = Mathf.Min(pressTime, dragTime);
            float endTime   = Mathf.Max(pressTime, dragTime);

            if (mode == Mode.kDraggingStart)
            {
                Undo.RecordObject(sequencer, "Move Note Start");

                if (activeNote != null)
                {
                    float newStart = Mathf.Min(activeNote.end - minNoteTime, activeTime);
                    sequencer.ClampNotesInRange(pressNote, newStart, activeNote.end, activeNote);

                    activeNote.start = newStart;
                }
            }
            else if (mode == Mode.kDraggingEnd)
            {
                Undo.RecordObject(sequencer, "Move Note End");

                if (activeNote != null)
                {
                    float newEnd = Mathf.Max(activeNote.start + minNoteTime, activeTime);
                    sequencer.ClampNotesInRange(pressNote, activeNote.start, newEnd, activeNote);

                    activeNote.end = newEnd;
                }
            }
            else if (mode == Mode.kAdding)
            {
                Undo.RecordObject(sequencer, "Add Sequencer Notes");
                int startDragIndex = Mathf.FloorToInt(startTime / divisionLength);
                int endDragIndex   = Mathf.CeilToInt(endTime / divisionLength);

                sequencer.ClampNotesInRange(pressNote, startDragIndex * divisionLength,
                                            endDragIndex * divisionLength);
                for (int i = startDragIndex; i < endDragIndex; ++i)
                {
                    sequencer.AddNote(pressNote, i * divisionLength, (i + 1) * divisionLength, defaultVelocity);
                }
            }
            else if (mode == Mode.kDeleting)
            {
                Undo.RecordObject(sequencer, "Delete Sequencer Notes");
                sequencer.RemoveNotesInRange(pressNote, startTime, endTime);
            }
            mode = Mode.kWaiting;

            if (!Application.isPlaying)
            {
                CopyNoteRowToSerializedProperty(sequencer.allNotes[pressNote],
                                                allNotes.GetArrayElementAtIndex(pressNote));
            }
        }
示例#3
0
        bool MouseDrag(int note, float time, Sequencer sequencer, SerializedProperty allNotes)
        {
            float divisionLength = sequencer.GetDivisionLength();
            float clampedTime    = Mathf.Clamp(time, 0.0f, sequencer.length);
            float lastDragTime   = dragTime;

            dragTime = clampedTime;

            float newActiveTime = dragTime;

            if (roundingToIndex)
            {
                newActiveTime = divisionLength * Mathf.Round(dragTime / divisionLength);
            }

            if (Mathf.Abs(dragTime - pressTime) >= dragDeltaStartRounding)
            {
                roundingToIndex = true;
            }

            if (mode == Mode.kKeyboarding)
            {
                if (note == pressedKey)
                {
                    return(false);
                }

                sequencer.NoteOff(pressedKey);
                sequencer.NoteOn(note);
                pressedKey = note;
                return(true);
            }
            else if (mode == Mode.kDraggingStart)
            {
                if (activeNote == null)
                {
                    return(false);
                }

                newActiveTime = Mathf.Min(activeNote.end - minNoteTime, newActiveTime);
                bool redraw = activeTime == newActiveTime;
                activeTime = newActiveTime;
                return(redraw);
            }
            else if (mode == Mode.kDraggingEnd)
            {
                if (activeNote == null)
                {
                    return(false);
                }

                newActiveTime = Mathf.Max(activeNote.start + minNoteTime, newActiveTime);
                bool redraw = activeTime == newActiveTime;
                activeTime = newActiveTime;
                return(redraw);
            }
            else if (mode == Mode.kAdding)
            {
                int lastIndex = Mathf.FloorToInt(lastDragTime / divisionLength);
                int index     = Mathf.FloorToInt(time / divisionLength);

                return(lastIndex != index);
            }
            return(true);
        }