new void Awake()
 {
     base.Awake();
     sustainRen = sustain.GetComponent <Renderer>();
     whammy     = sustainRen.GetComponent <Whammy>();
 }
Ejemplo n.º 2
0
        private List <MidiEvent> CreateTabTrack(List <ZObject> tabTracks, string trackName)
        {
            const int AUDIO_EFFECT = 127;
            const int CHORD        = 126;
            const int EVENT_PHRASE = 125; // Event/phrase
            const int SPREAD       = 124;
            const int WHAMMY       = 123;

            const int TAB_BASS_START = 79;
            //const int TAB_RESERVED_START = 71;
            const int TAB_TREMELO_START       = 63;
            const int TAB_PALM_MUTE_START     = 55;
            const int TAB_EXTENDED_START      = 47;
            const int TAB_VIBRATO_START       = 39;
            const int TAB_BEND_STRENGTH_START = 31;
            const int TAB_BEND_START          = 23;
            const int TAB_TYPE_START          = 15;
            const int TAB_NOTE_START          = 7;

            List <MidiEvent> track = new List <MidiEvent>();

            track.Add(new NAudio.Midi.TextEvent(trackName, MetaEventType.SequenceTrackName, 0));
            if (tabTracks.Count <= 0)
            {
                return(track);
            }

            Tab tab = tabTracks.FirstOrDefault(x => x is Tab) as Tab;

            if (tab != null)
            {
                foreach (TabEntry entry in tab.Events)
                {
                    long start        = GetAbsoluteTime(entry.Start);
                    long end          = GetAbsoluteTime(entry.End);
                    int  stringNumber = entry.StringNumber - 1;

                    // Playable notes
                    track.Add(new NoteEvent(start, 1 + (int)entry.Finger, MidiCommandCode.NoteOn, TAB_NOTE_START - stringNumber, 100 + entry.FretNumber));
                    track.Add(new NoteEvent(end, 1 + (int)entry.Finger, MidiCommandCode.NoteOff, TAB_NOTE_START - stringNumber, 100 + entry.FretNumber));

                    // Note type (Modifier)
                    if (entry.NoteType > 0)
                    {
                        track.Add(new NoteEvent(start, (int)entry.NoteType, MidiCommandCode.NoteOn, TAB_TYPE_START - stringNumber, 100));
                        track.Add(new NoteEvent(end, (int)entry.NoteType, MidiCommandCode.NoteOff, TAB_TYPE_START - stringNumber, 100));
                    }

                    // Bend type
                    if (entry.BendType > 0)
                    {
                        track.Add(new NoteEvent(start, (int)entry.BendType, MidiCommandCode.NoteOn, TAB_BEND_START - stringNumber, 100));
                        track.Add(new NoteEvent(end, (int)entry.BendType, MidiCommandCode.NoteOff, TAB_BEND_START - stringNumber, 100));
                    }

                    // Bend strength
                    if (entry.BendStrength != 0.0f)
                    {
                        // Should be increments of 0.25f
                        int value = (int)(entry.BendStrength / 0.25f);

                        track.Add(new NoteEvent(start, 1, MidiCommandCode.NoteOn, TAB_BEND_STRENGTH_START - stringNumber, 100 + value));
                        track.Add(new NoteEvent(end, 1, MidiCommandCode.NoteOff, TAB_BEND_STRENGTH_START - stringNumber, 100 + value));
                    }

                    // Vibrato type
                    if (entry.VibratoType > 0)
                    {
                        track.Add(new NoteEvent(start, (int)entry.VibratoType, MidiCommandCode.NoteOn, TAB_VIBRATO_START - stringNumber, 100));
                        track.Add(new NoteEvent(end, (int)entry.VibratoType, MidiCommandCode.NoteOff, TAB_VIBRATO_START - stringNumber, 100));
                    }

                    // Extended note
                    if (entry.ExtendedNote)
                    {
                        track.Add(new NoteEvent(start, 1, MidiCommandCode.NoteOn, TAB_EXTENDED_START - stringNumber, 100));
                        track.Add(new NoteEvent(end, 1, MidiCommandCode.NoteOff, TAB_EXTENDED_START - stringNumber, 100));
                    }

                    // Palm mute
                    if (entry.PalmMute)
                    {
                        track.Add(new NoteEvent(start, 1, MidiCommandCode.NoteOn, TAB_PALM_MUTE_START - stringNumber, 100));
                        track.Add(new NoteEvent(end, 1, MidiCommandCode.NoteOff, TAB_PALM_MUTE_START - stringNumber, 100));
                    }

                    // Extended note
                    if (entry.Tremelo)
                    {
                        track.Add(new NoteEvent(start, 1, MidiCommandCode.NoteOn, TAB_TREMELO_START - stringNumber, 100));
                        track.Add(new NoteEvent(end, 1, MidiCommandCode.NoteOff, TAB_TREMELO_START - stringNumber, 100));
                    }

                    // Bass type
                    if (entry.BassType > 0)
                    {
                        track.Add(new NoteEvent(start, (int)entry.BassType, MidiCommandCode.NoteOn, TAB_BASS_START - stringNumber, 100));
                        track.Add(new NoteEvent(end, (int)entry.BassType, MidiCommandCode.NoteOff, TAB_BASS_START - stringNumber, 100));
                    }
                }
            }

            AudioEffect aEffect = tabTracks.FirstOrDefault(x => x is AudioEffect) as AudioEffect;

            if (aEffect != null)
            {
                foreach (AudioEffectEntry entry in aEffect.Events)
                {
                    long start = GetAbsoluteTime(entry.Start);
                    long end   = GetAbsoluteTime(entry.End);

                    track.Add(new NAudio.Midi.TextEvent($"a \"{entry.EffectPath}\"", MetaEventType.TextEvent, start));
                    track.Add(new NoteEvent(start, 1, MidiCommandCode.NoteOn, AUDIO_EFFECT, 100));
                    track.Add(new NoteEvent(end, 1, MidiCommandCode.NoteOff, AUDIO_EFFECT, 100));
                }
            }

            Chord chord = tabTracks.FirstOrDefault(x => x is Chord) as Chord;

            if (chord != null)
            {
                foreach (var entry in chord.Events)
                {
                    long start = GetAbsoluteTime(entry.Start);
                    long end   = GetAbsoluteTime(entry.End);

                    track.Add(new NAudio.Midi.TextEvent($"c \"{entry.EventName}\"", MetaEventType.TextEvent, start));
                    track.Add(new NoteEvent(start, 1, MidiCommandCode.NoteOn, CHORD, 100));
                    track.Add(new NoteEvent(end, 1, MidiCommandCode.NoteOff, CHORD, 100));
                }
            }

            Event ev = tabTracks.FirstOrDefault(x => x is Event) as Event;

            if (ev != null)
            {
                foreach (var entry in ev.Events)
                {
                    long start = GetAbsoluteTime(entry.Start);
                    long end   = GetAbsoluteTime(entry.End);

                    if (entry.EventName.Value != "Phrase")
                    {
                        // Should always be a phrase but idk...
                        track.Add(new NAudio.Midi.TextEvent($"e \"{entry.EventName}\"", MetaEventType.TextEvent, start));
                    }

                    track.Add(new NoteEvent(start, 1, MidiCommandCode.NoteOn, EVENT_PHRASE, 100));
                    track.Add(new NoteEvent(end, 1, MidiCommandCode.NoteOff, EVENT_PHRASE, 100));
                }
            }

            Spread spread = tabTracks.FirstOrDefault(x => x is Spread) as Spread;

            if (spread != null)
            {
                foreach (SpreadEntry entry in spread.Events)
                {
                    long start = GetAbsoluteTime(entry.Start);
                    long end   = GetAbsoluteTime(entry.End);

                    // Should be increments of 0.25f
                    int value = (int)((entry.Speed - 1.0f) / 0.25f);

                    track.Add(new NoteEvent(start, 1, MidiCommandCode.NoteOn, SPREAD, 100 + value));
                    track.Add(new NoteEvent(end, 1, MidiCommandCode.NoteOff, SPREAD, 100 + value));
                }
            }

            Whammy whammy = tabTracks.FirstOrDefault(x => x is Whammy) as Whammy;

            if (whammy != null)
            {
                foreach (WhammyEntry entry in whammy.Events)
                {
                    long start = GetAbsoluteTime(entry.Start);
                    long end   = GetAbsoluteTime(entry.End);

                    track.Add(new NoteEvent(start, 1, MidiCommandCode.NoteOn, WHAMMY, 100));
                    track.Add(new NoteEvent(end, 1, MidiCommandCode.NoteOff, WHAMMY, 100));
                }
            }

            // Sort by absolute time (And ensure track name is first event)
            track.Sort((x, y) => (int)(x is NAudio.Midi.TextEvent &&
                                       ((NAudio.Midi.TextEvent)x).MetaEventType == MetaEventType.SequenceTrackName
                                       ? int.MinValue : x.AbsoluteTime - y.AbsoluteTime));

            // Adds end track
            track.Add(new MetaEvent(MetaEventType.EndTrack, 0, track.Last().AbsoluteTime));
            return(track);
        }