private void FinalizeStagingClip()
{
mCurrentInstSet = mLoadedClip.mInstrumentSet;
InstrumentListPanelUI listPanel = InstrumentListPanelUI.Instance;
for (int i = 0; i < mCurrentInstSet.mInstruments.Count; i++)
{
listPanel.AddInstrument(mCurrentInstSet.mInstruments[i]);
InstrumentListUIObject icon = listPanel.mInstrumentIcons[listPanel.mInstrumentIcons.Count - 1];
icon.ToggleSelected();
bool isPercussion = icon.mInstrument.mData.InstrumentType.Contains("p_") ? true : false;
icon.SetDropdown(isPercussion);
InstrumentPanelUI.Instance.SetInstrument(icon.mInstrument);
mInstrumentPanel.mInstrument = mCurrentInstSet.mInstruments[i];
}
InstrumentPanelUI.Instance.SetInstrument(mCurrentInstSet.mInstruments[0]);
mInstrumentPanel.mInstrument = mCurrentInstSet.mInstruments[0];
mClipIsRepeating.isOn = mLoadedClip.mIsRepeating;
mCurrentMeasure.value = 0;
mLoadedClip.SetState(eClipState.Stop);
mMusicGenerator.ClipLoaded.Invoke(mCurrenClipSave);
mMusicGenerator.ResetPlayer();
mMusicGenerator.SetState(eGeneratorState.editing);
ToggleHelperNotes();
UIToggleAllInstruments();
mStaffPlayer.ChangeTimeSignature((int)mCurrentInstSet.mTimeSignature.Signature);
}
/// Changes our time signature.
public void ChangeTimeSignature(int timeSignature = -1)
{
if (timeSignature != -1) //if we're actually trying to force the ui to change. The UI will pass in -1.
{
mTimeSignatureDropdown.value = timeSignature;
return;
}
eTimeSignature signature = (eTimeSignature)mTimeSignatureDropdown.value;
InstrumentSet set = (MusicGenerator.Instance.mState >= eGeneratorState.editorInitializing) ? mMeasureEditor.mCurrentInstSet : MusicGenerator.Instance.mInstrumentSet;
set.SetTimeSignature(signature);
float xPos = mBarLines[0].localPosition.x;
float nextPos = mTotalBarlineDistance / (set.mTimeSignature.mStepsPerMeasure - 1);
for (int i = 0; i < mBarLinesImages.Count; i++)
{
if (i < set.mTimeSignature.mStepsPerMeasure)
{
mBarLinesImages[i].enabled = true;
Vector3 pos = mBarLines[i].localPosition;
mBarLines[i].localPosition = new Vector3(xPos, pos.y, pos.z);
xPos += nextPos;
}
else
{
mBarLinesImages[i].enabled = false;
}
}
}
/// Updates our chord progression text
private void UpdateChordProgressionText(InstrumentSet set)
{
bool dirty = false;
for (int i = 0; i < mMusicGenerator.ChordProgression.Length; i++)
{
if (mCurrentChordProgression[i] != mMusicGenerator.ChordProgression[i])
{
mCurrentChordProgression[i] = mMusicGenerator.ChordProgression[i];
dirty = true;
}
}
int stepsTaken = set.ProgressionStepsTaken >= 0 ? set.ProgressionStepsTaken : 0;
if (mCurrentChordProgression[stepsTaken] != mCurrentStep)
{
mCurrentStep = mCurrentChordProgression[stepsTaken];
dirty = true;
}
if (dirty)
{
mCurrentProgStep.text = "{" +
mCurrentChordProgression[0] + "-" +
mCurrentChordProgression[1] + "-" +
mCurrentChordProgression[2] + "-" +
mCurrentChordProgression[3] + "}" + " :" +
mCurrentStep;
}
}
/// <summary>
/// Async loads the instrument data.
/// </summary>
/// <param name="argResourceDirectory"></param>
/// <returns></returns>
public IEnumerator AsyncLoadInstrumentsData(string argResourceDirectory)
{
///Load the instruments:
InstrumentSet set = MusicGenerator.Instance.mInstrumentSet;
for (int i = 0; i < MusicGenerator.mMaxInstruments; i++)
{
string path = MusicFileConfig.GetConfigDirectory(argResourceDirectory) + "/instruments" + i.ToString() + ".txt";
if (File.Exists(path))
{
InstrumentData instrumentData = InstrumentData.LoadData(argResourceDirectory, "/instruments" + i.ToString() + ".txt");
if (instrumentData == null)
{
yield break;
}
MusicGenerator.Instance.AddInstrument(set);
yield return(null);
set.mInstruments[set.mInstruments.Count - 1].LoadInstrument(instrumentData);
int index = 999;
yield return(StartCoroutine(MusicGenerator.Instance.AsyncLoadBaseClips(set.mInstruments[set.mInstruments.Count - 1].mData.InstrumentType, ((x) => { index = x; }))));
set.mInstruments[set.mInstruments.Count - 1].InstrumentTypeIndex = index;
}
}
yield return(null);
}
// Update is called once per frame
void Update()
{
if (mMusicGenerator == null)
{
return;
}
if (mFileCurrentlyWriting != "")
{
bool completed = MusicHelpers.CheckClipwriteComplete(mFileCurrentlyWriting);
if (completed)
{
Debug.Log(mFileCurrentlyWriting + " clip save complete");
AddPresetOption(mFileCurrentlyWriting + ".txt");
mFileCurrentlyWriting = "";
mPlayClipDropdown.value = mPlayClipDropdown.options.Count - 1;
}
}
else if (mMusicGenerator.mState >= eGeneratorState.editorInitializing)
{
InstrumentSet instrumentSet = mLoadedClip.mInstrumentSet;
instrumentSet.mData.Tempo = mTempo.value;
mCurrentInstSet.mData.RepeatMeasuresNum = mNumberOfMeasures.value;
mCurrentInstSet.mRepeatCount = mCurrentMeasure.value;
if (mInstrumentPanel.mInstrument != null)
{
int currentInstIndex = (int)mInstrumentPanel.mInstrument.InstrumentIndex;
mStaffPlayer.SetEditorNotes(instrumentSet.mInstruments[currentInstIndex]);
}
}
}
/// <summary>
/// Loads the data for an instrument.
/// </summary>
/// <param name="resourceDirectory"></param>
private IEnumerator LoadInstrumentsData(string argDirectory, bool async = false)
{
UnitySystemConsoleRedirector.Redirect();
InstrumentSet set = MusicGenerator.Instance.mInstrumentSet;
for (int i = 0; i < MusicGenerator.mMaxInstruments; i++)
{
string path = "/instruments" + i.ToString() + ".txt";
string data = null;
yield return(MusicHelpers.GetUWR(mSavesPath + "/" + argDirectory + path, (x) => { data = x.downloadHandler.text; }));
if (string.IsNullOrEmpty(data))
{
yield break;
}
InstrumentData instrumentData = null;
InstrumentData.LoadData(data, argDirectory, (x) => { instrumentData = x; });
MusicGenerator.Instance.AddInstrument(set);
set.mInstruments[set.mInstruments.Count - 1].LoadInstrument(instrumentData);
int index = 0;
if (async)
{
yield return(StartCoroutine(MusicGenerator.Instance.AsyncLoadBaseClips(set.mInstruments[set.mInstruments.Count - 1].mData.InstrumentType, ((x) => { index = x; }))));
}
else
{
index = MusicGenerator.Instance.LoadBaseClips(set.mInstruments[set.mInstruments.Count - 1].mData.InstrumentType);
}
set.mInstruments[set.mInstruments.Count - 1].InstrumentTypeIndex = index;
}
yield return(null);
}
/// <summary>
/// Plays the notes for this timestep
/// </summary>
/// <param name="set"></param>
/// <param name="instrument"></param>
/// <param name="stepsTaken"></param>
/// <param name="instIndex"></param>
private void PlayNotes(InstrumentSet set, Instrument instrument, int stepsTaken, int instIndex)
{
// we want to fill this whether we play it or not:
int progressionStep = set.mMusicGenerator.ChordProgression[stepsTaken];
int[] clip = instrument.GetProgressionNotes(progressionStep);
if (instrument.mData.StrumLength == 0.0f || instrument.mData.mSuccessionType != eSuccessionType.rhythm)
{
for (int j = 0; j < clip.Length; j++)
{
if (clip[j] != InstrumentSet.mUnplayed) //we ignore -1
{
try
{
set.mMusicGenerator.PlayAudioClip(set, (int)instrument.InstrumentTypeIndex, clip[j], instrument.mData.Volume, instIndex);
set.mMusicGenerator.UIStaffNotePlayed.Invoke(clip[j], (int)instrument.mData.mStaffPlayerColor);
}
catch (ArgumentOutOfRangeException e)
{
throw new ArgumentOutOfRangeException(e.Message);
}
}
}
}
else
{
set.Strum(clip, instIndex);
}
}
public NotePlayedArgs(InstrumentSet argSet, int argClipIndexX, int argClipIndexY, float argVolumeIN, int argInstrumentIndex)
{
set = argSet;
clipIndexX = argClipIndexX;
clipIndexY = argClipIndexY;
volume = argVolumeIN;
instrumentIndex = argInstrumentIndex;
}
public RepeatNoteArgs(int indexAIN, int indexBIN, int repeatingCountIN, int instrumentSubIndexIN, InstrumentSet setIN)
{
indexA = indexAIN;
indexB = indexBIN;
repeatingCount = repeatingCountIN;
instrumentSubIndex = instrumentSubIndexIN;
instrumentSet = setIN;
}
/// <summary>
/// Sets our notes to repeat.
/// </summary>
private void SetRepeatNotes()
{
InstrumentSet set = mMusicGenerator.mInstrumentSet;
int count = set.SixteenthStepsTaken + (set.mRepeatCount * set.mTimeSignature.mStepsPerMeasure);
for (int i = 0; i < mProgressionNotes.Length; i++)
{
mRepeatingNotes[count][i] = mProgressionNotes[i];
}
}
/// Destroys instrument.
public void RemoveInstrument()
{
InstrumentSet set = (mMusicGenerator.mState >= eGeneratorState.editorInitializing) ? MeasureEditor.Instance.mCurrentInstSet : mMusicGenerator.mInstrumentSet;
mMusicGenerator.RemoveInstrument((int)mInstrument.InstrumentIndex, set);
mInstrumentListPanelUI.RemoveInstrument((int)mInstrument.InstrumentIndex);
if (mbIsSelected)
{
mInstrumentPanelUI.mInstrument = null;
}
Destroy(this.gameObject);
}
/// <summary>
/// Plays through the next step in the measure.
/// </summary>
/// <param name="set"></param>
public override void PlayMeasure(InstrumentSet set)
{
if (set.mMusicGenerator == null)
{
return;
}
set.UpdateTempo();
set.mSixteenthStepTimer -= Time.deltaTime;
if (set.mSixteenthStepTimer <= 0 && set.SixteenthStepsTaken < set.mTimeSignature.mStepsPerMeasure)
{
set.mMusicGenerator.BarlineColorSet.Invoke(set.SixteenthStepsTaken, false);
if (set.SixteenthStepsTaken % (int)set.mData.mProgressionRate == set.mTimeSignature.Whole)
{
set.ProgressionStepsTaken += 1;
set.ProgressionStepsTaken = set.ProgressionStepsTaken % set.mMusicGenerator.ChordProgression.Length;
set.mMusicGenerator.CheckKeyChange();
}
if (set.SixteenthStepsTaken % set.mTimeSignature.Half == 0)
{
TakeStep(set, eTimestep.eighth, set.ProgressionStepsTaken);
}
if (set.SixteenthStepsTaken % set.mTimeSignature.Quarter == 0)
{
TakeStep(set, eTimestep.quarter, set.ProgressionStepsTaken);
}
if (set.SixteenthStepsTaken % set.mTimeSignature.Eighth == 0)
{
TakeStep(set, eTimestep.half, set.ProgressionStepsTaken);
}
if (set.SixteenthStepsTaken % set.mTimeSignature.Sixteenth == 0)
{
TakeStep(set, eTimestep.whole, set.ProgressionStepsTaken);
set.mMeasureStartTimer = 0.0f;
}
TakeStep(set, eTimestep.sixteenth, set.ProgressionStepsTaken);
set.mSixteenthStepTimer = set.mBeatLength;
set.SixteenthStepsTaken += 1;
}
else if (set.SixteenthStepsTaken == set.mTimeSignature.mStepsPerMeasure)
{
set.mMeasureStartTimer += Time.deltaTime;
if (set.mMeasureStartTimer > set.mBeatLength) //We don't actually want to reset until the next beat.
{
set.mMusicGenerator.GenerateNewProgression();
ResetMeasure(set, set.mMusicGenerator.SetThemeRepeat);
}
}
}
private void StartInitialization(ClipSave save)
{
mInstrumentSet = new InstrumentSet();
mInstrumentSet.Init();
mInstrumentSet.LoadData(new InstrumentSetData());
mTempo = save.mTempo;
mNumMeasures = save.mNumberOfMeasures;
mSixteenthMeasure = 60 / mTempo;
mIsRepeating = save.mClipIsRepeating;
mInstrumentSet.mData.Tempo = mTempo;
mInstrumentSet.SetProgressionRate(save.mProgressionRate);
mInstrumentSet.mData.RepeatMeasuresNum = mNumMeasures;
}
/// Adds an instrument to our ui object list:
public void AddInstrument(Instrument instrumentIN)
{
InstrumentSet set = (mMusicGenerator.mState >= eGeneratorState.editorInitializing) ? MeasureEditor.Instance.mCurrentInstSet : mMusicGenerator.mInstrumentSet;
List <Instrument> instruments = set.mInstruments;
if (instruments.Count <= MusicGenerator.mMaxInstruments)
{
mInstrumentIcons.Add((Instantiate(mInstrumentUIObjectBase, transform) as GameObject).GetComponent <InstrumentListUIObject>());
InstrumentListUIObject icon = mInstrumentIcons[mInstrumentIcons.Count - 1];
icon.Init(mMusicGenerator);
icon.transform.position = mAddInstrumentPoint.transform.position;
mAddInstrumentPoint.localPosition -= new Vector3(0, mAddInstrumentPoint.rect.height * mIconPadding, 0);
icon.mInstrument = instrumentIN;
Color color = StaffPlayerUI.Instance.mColors[(int)icon.mInstrument.mData.mStaffPlayerColor];
icon.mPanelBack.color = color;
}
}
/// <summary>
/// Resets a regular measure.
/// </summary>
/// <param name="set"></param>
/// <param name="SetThemeRepeat"></param>
/// <param name="hardReset"></param>
/// <param name="isRepeating"></param>
protected void ResetRegularMeasure(InstrumentSet set, Action SetThemeRepeat = null, bool hardReset = false, bool isRepeating = true)
{
if (set.mMusicGenerator == null)
{
throw new ArgumentNullException("music generator does not exist. Please ensure a game object with this class exists");
}
set.mRepeatCount += 1;
if (SetThemeRepeat != null)
{
SetThemeRepeat();
}
for (int i = 0; i < set.mInstruments.Count; i++)
{
set.mInstruments[i].ClearPatternNotes();
set.mInstruments[i].ResetPatternStepsTaken();
set.mInstruments[i].ClearPlayedLeadNotes();
set.mInstruments[i].GenerateArpeggio();
}
set.SixteenthStepsTaken = 0;
//select groups:
set.SelectGroups();
if (set.ProgressionStepsTaken >= InstrumentSet.mMaxFullstepsTaken - 1)
{
set.ProgressionStepsTaken = -1;
}
if (set.mMusicGenerator.mGeneratorData.mThemeRepeatOptions == eThemeRepeatOptions.eNone)
{
set.mRepeatCount = 0;
for (int i = 0; i < set.mInstruments.Count; i++)
{
set.mInstruments[i].ClearRepeatingNotes();
}
}
set.mMeasureStartTimer = 0.0f;
set.mSixteenthStepTimer = 0.0f;
set.ResetMultipliers();
}
/// non async changes the instrument.
private bool NonAsyncInstrumentChange()
{
if (mMusicGenerator.mState < eGeneratorState.ready)
{
return(true);
}
InstrumentSet set = (mMusicGenerator.mState >= eGeneratorState.editorInitializing) ?
MeasureEditor.Instance.mCurrentInstSet : mMusicGenerator.mInstrumentSet;
int typeToRemove = (int)mInstrument.InstrumentTypeIndex;
int instrumentIndex = 0;
string name = mInstrumentDropdown.options[mInstrumentDropdown.value].text;
if (name == "dummyEntry")
{
return(false);
}
string instrumentType = mInstrumentDropdown.options[mInstrumentDropdown.value].text;
instrumentType = instrumentType.ToLower();
if (mMusicGenerator.LoadedInstrumentNames.Contains(instrumentType) == false)
{
instrumentIndex = mMusicGenerator.LoadBaseClips(instrumentType);
}
else
{
instrumentIndex = mMusicGenerator.LoadedInstrumentNames.IndexOf(instrumentType);
}
List <Instrument> instruments = set.mInstruments;
int value = GetComponentInChildren <Dropdown>().value;
if (mInstrument != null)
{
instruments[(int)mInstrument.InstrumentIndex].InstrumentTypeIndex = instrumentIndex;
instruments[(int)mInstrument.InstrumentIndex].mData.InstrumentType = instrumentType;
mMuteToggle.isOn = instruments[(int)mInstrument.InstrumentIndex].mData.mIsMuted;
}
mMusicGenerator.RemoveBaseClip(typeToRemove, set);
mMusicGenerator.CleanUpInstrumentTypeIndices(set);
return(true);
}
/// <summary>
/// Loads the data for an instrument.
/// </summary>
/// <param name="folderIN"></param>
private static void LoadInstrumentsData(string folderIN)
{
InstrumentSet set = MusicGenerator.Instance.mInstrumentSet;
string configDir = GetConfigDirectory(folderIN);
for (int i = 0; i < MusicGenerator.mMaxInstruments; i++)
{
string path = configDir + "/instruments" + i.ToString() + ".txt";
if (File.Exists(path))
{
InstrumentData instrumentData = InstrumentData.LoadData(folderIN, "/instruments" + i.ToString() + ".txt");
MusicGenerator.Instance.AddInstrument(set);
set.mInstruments[set.mInstruments.Count - 1].LoadInstrument(instrumentData);
int index = MusicGenerator.Instance.LoadBaseClips(set.mInstruments[set.mInstruments.Count - 1].mData.InstrumentType);
set.mInstruments[set.mInstruments.Count - 1].InstrumentTypeIndex = index;
}
}
}
/// <summary>
/// Plays the next step in the measure.
/// </summary>
/// <param name="set"></param>
/// <param name="timeStepIN"></param>
/// <param name="stepsTaken"></param>
public override void TakeStep(InstrumentSet set, eTimestep timeStepIN, int stepsTaken = 0)
{
for (int instIndex = 0; instIndex < set.mInstruments.Count; instIndex++)
{
if (set.mInstruments[instIndex].mData.Group >= set.mMusicGenerator.mGeneratorData.mGroupOdds.Count || set.mData.mProgressionRate < 0)
{
return;
}
Instrument instrument = set.mInstruments[instIndex];
bool groupIsPlaying = set.mMusicGenerator.mGroupIsPlaying[(int)instrument.mData.Group];
if (instrument.mData.mTimeStep == timeStepIN && groupIsPlaying && instrument.mData.mIsMuted == false)
{
PlayNotes(set, instrument, stepsTaken, instIndex);
}
}
}
/// <summary>
/// Plays the next sequence in the measure.
/// </summary>
/// <param name="set"></param>
public override void PlayMeasure(InstrumentSet set)
{
if (set.mMusicGenerator == null)
{
return;
}
set.UpdateTempo();
set.mSixteenthStepTimer -= Time.deltaTime;
if (set.mSixteenthStepTimer <= 0 && set.SixteenthStepsTaken < set.mTimeSignature.mStepsPerMeasure)
{
set.mMusicGenerator.BarlineColorSet.Invoke(set.SixteenthStepsTaken, true);
if (set.SixteenthStepsTaken % set.mTimeSignature.Half == 0)
{
TakeStep(set, eTimestep.eighth);
}
if (set.SixteenthStepsTaken % set.mTimeSignature.Quarter == 0)
{
TakeStep(set, eTimestep.quarter);
}
if (set.SixteenthStepsTaken % set.mTimeSignature.Eighth == 0)
{
TakeStep(set, eTimestep.half);
}
if (set.SixteenthStepsTaken % set.mTimeSignature.Sixteenth == 0)
{
TakeStep(set, eTimestep.whole);
set.mMeasureStartTimer = 0.0f;
}
TakeStep(set, (int)eTimestep.sixteenth);
set.SixteenthRepeatCount += 1;
set.mSixteenthStepTimer = set.mBeatLength;
set.SixteenthStepsTaken += 1;
}
else if (set.SixteenthStepsTaken == set.mTimeSignature.mStepsPerMeasure)
{
set.mMeasureStartTimer += Time.deltaTime;
if (set.mMeasureStartTimer > set.mBeatLength)
{
ResetMeasure(set);
}
}
}
/// Adds an instrument to the Music generator and creates its ui object.
public void AddMusicGeneratorInstrument(bool isPercussion)
{
InstrumentSet set = (mMusicGenerator.mState >= eGeneratorState.editorInitializing) ? MeasureEditor.Instance.mCurrentInstSet : mMusicGenerator.mInstrumentSet;
List <Instrument> instruments = set.mInstruments;
if (instruments.Count < MusicGenerator.mMaxInstruments)
{
mMusicGenerator.AddInstrument(set);
Instrument instrument = set.mInstruments[set.mInstruments.Count - 1];
AddInstrument(instrument);
InstrumentListUIObject icon = mInstrumentIcons[mInstrumentIcons.Count - 1];
icon.mInstrument = instruments[instruments.Count - 1];
Color color = StaffPlayerUI.Instance.mColors[(int)icon.mInstrument.mData.mStaffPlayerColor];
icon.mPanelBack.color = color;
icon.SetDropdown(isPercussion);
}
}
/// <summary>
/// Plays the repeating notes for this timestep.
/// </summary>
/// <param name="set"></param>
/// <param name="instrument"></param>
/// <param name="instIndex"></param>
/// <param name="instSubIndex"></param>
private void PlayRepeatNotes(InstrumentSet set, Instrument instrument, int instIndex, int instSubIndex)
{
for (int chordNote = 0; chordNote < instrument.mData.ChordSize; chordNote++)
{
if (instrument.mRepeatingNotes.Length > set.SixteenthRepeatCount && instrument.mRepeatingNotes[set.SixteenthRepeatCount][chordNote] != InstrumentSet.mUnplayed)
{
if (instrument.mData.StrumLength == 0.0f)
{
set.mMusicGenerator.PlayAudioClip(set, (int)instrument.InstrumentTypeIndex, instrument.mRepeatingNotes[set.SixteenthRepeatCount][chordNote], instrument.mData.Volume, instIndex);
set.mMusicGenerator.UIStaffNotePlayed.Invoke(instrument.mRepeatingNotes[set.SixteenthRepeatCount][chordNote], (int)instrument.mData.mStaffPlayerColor);
}
else
{
int[] clip = instrument.mThemeNotes[set.SixteenthRepeatCount];
set.Strum(clip, instIndex);
break;
}
}
}
}
/// <summary>
/// async init.
/// </summary>
/// <param name="save"></param>
/// <param name="callback"></param>
/// <returns></returns>
public IEnumerator AsyncInit(ClipSave save, System.Action <bool> callback)
{
mInstrumentSet = new InstrumentSet();
mInstrumentSet.Init();
mTempo = save.mTempo;
mNumMeasures = save.mNumberOfMeasures;
mSixteenthMeasure = 60 / mTempo;
mIsRepeating = save.mClipIsRepeating;
mInstrumentSet.mData.Tempo = mTempo;
mInstrumentSet.SetProgressionRate(save.mProgressionRate);
mInstrumentSet.mData.RepeatMeasuresNum = mNumMeasures;
bool isFinished = false;
StartCoroutine(AsyncLoadInstruments(save, ((x) => { isFinished = x; })));
yield return(new WaitUntil(() => isFinished));
callback(isFinished);
yield return(null);
}
/// Updates the helper notes showing/not showing, whether mShowEditorHints.isOn.
public void ToggleHelperNotes(Dropdown colorDropdownIN = null)
{
if (mMusicGenerator.mState >= eGeneratorState.editing)
{
if (mShowEditorHints.isOn)
{
if (mLoadedClip.mInstrumentSet.mInstruments.Count == 0)
{
return;
}
int currentInstIndex = (int)mInstrumentPanel.mInstrument.InstrumentIndex;
if (colorDropdownIN != null)
{
mLoadedClip.mInstrumentSet.mInstruments[currentInstIndex].mData.mStaffPlayerColor = (eStaffPlayerColors)colorDropdownIN.value;
}
mStaffPlayer.ClearNotes(true, true);
Instrument instrument = mLoadedClip.mInstrumentSet.mInstruments[currentInstIndex];
mStaffPlayer.ShowHighlightedNotes(instrument);
if (mShowAllInstruments.isOn)
{
InstrumentSet set = mLoadedClip.mInstrumentSet;
for (int i = 0; i < set.mInstruments.Count; i++)
{
int[][] notes = set.mInstruments[i].mClipNotes[mCurrentMeasure.value];
mStaffPlayer.ShowSetEditorNotes(notes, i);
}
}
else
{
mStaffPlayer.ShowSetEditorNotes(instrument.mClipNotes[mCurrentMeasure.value], instrument.InstrumentIndex);
}
}
else
{
mStaffPlayer.ClearNotes(false, true);
}
}
}
/// Displays a note on the staff player:
public void DisplayNote(int noteIN, int colorIN, bool useShadow, InstrumentSet setIN, bool strummed = false)
{
int sixteenStepsTaken = setIN.SixteenthStepsTaken;
if (useShadow == false)
{
mPlayedNotes[mCurrentNote].gameObject.SetActive(true);
if (strummed == false)
{
mPlayedNotes[mCurrentNote].transform.position = new Vector3(mBarLines[sixteenStepsTaken].position.x, mStaffLines[noteIN].transform.position.y, 0);
}
else
{
mPlayedNotes[mCurrentNote].transform.position = new Vector3(mTimerBar.transform.position.x, mStaffLines[noteIN].transform.position.y, 0);
}
mPlayedNotes[mCurrentNote].mBaseImage.color = mColors[colorIN];
}
else
{
mShadowNotes[mCurrentNote].gameObject.SetActive(true);
if (strummed == false)
{
mShadowNotes[mCurrentNote].transform.position = new Vector2(mBarLines[sixteenStepsTaken].position.x, mStaffLines[noteIN].transform.position.y);
}
else
{
mShadowNotes[mCurrentNote].transform.position = new Vector2(mTimerBar.transform.position.x, mStaffLines[noteIN].transform.position.y);
}
Component[] components2 = mShadowNotes[mCurrentNote].GetComponentsInChildren <Image>();
foreach (Component cp in components2)
{
if (cp.name != "shadow")
{
cp.GetComponent <Image>().color = mColors[colorIN];
}
}
}
IncreaseCurrentNoteCount(ref mCurrentNote, mMaxPlayedNotes);
}
/// <summary>
/// Resets a repeating measure.
/// </summary>
/// <param name="set"></param>
/// <param name="SetThemeRepeat"></param>
/// <param name="hardReset"></param>
/// <param name="isRepeating"></param>
protected void ResetRepeatMeasure(InstrumentSet set, Action SetThemeRepeat = null, bool hardReset = false, bool isRepeating = true)
{
set.mMusicGenerator.RepeatedMeasureExited.Invoke(set.mMusicGenerator.mState);
set.mRepeatCount += 1;
set.mMeasureStartTimer = 0.0f;
set.mSixteenthStepTimer = 0.0f;
set.ResetMultipliers();
set.SixteenthStepsTaken = 0;
if (isRepeating == false)
{
return;
}
//if we've repeated all the measures set to repeat in their entirety, reset the step counts.
bool isEditing = set.mMusicGenerator.OnUIPlayerIsEditing();
int repeatNum = isEditing ? set.mData.RepeatMeasuresNum + 1 : set.mData.RepeatMeasuresNum * 2;
if (set.mRepeatCount >= repeatNum || isEditing || hardReset)
{
if (isEditing == false || hardReset)
{
set.mRepeatCount = 0;
}
set.SixteenthRepeatCount = 0;
for (int i = 0; i < set.mInstruments.Count; i++)
{
set.mInstruments[i].ClearRepeatingNotes();
}
if (set.mMusicGenerator.mState > eGeneratorState.stopped && set.mMusicGenerator.mState < eGeneratorState.editorInitializing)
{
set.mMusicGenerator.SetState(eGeneratorState.playing);
}
}
}
/// <summary>
/// Sets the pattern variables. Mostly for readability in other functions :\
/// </summary>
/// <param name="progressionStep"></param>
private void SetupNoteGeneration(int progressionStep)
{
InstrumentSet set = mMusicGenerator.mInstrumentSet;
int invProgRate = set.GetInverseProgressionRate((int)mData.mTimeStep);
int progRate = set.GetProgressionRate((int)mData.mTimeStep);
// chord progressions are set in their sensible way: I-IV-V for example starting on 1.
// it's easier to leave like that as it's readable (from a music perspective, anyhow) and adjust here, rather than 0 based:
mCurrentProgressionStep = progressionStep - ((progressionStep < 0) ? -1 : 1);
mPatternstepsTaken = (int)(set.SixteenthStepsTaken / invProgRate);
mCurrentPatternStep = mPatternstepsTaken % mData.PatternLength;
mbAreRepeatingPattern = (mPatternstepsTaken >= mData.PatternLength && mPatternstepsTaken < progRate - mData.PatternRelease);
mbAreSettingPattern = (mPatternstepsTaken < mData.PatternLength);
if (mCurrentPatternStep < mPatternNoteOffset.Length - 1)
{
mCurrentPatternNotes = mPatternNoteOffset[(int)mCurrentPatternStep];
mCurrentPatternOctave = mPatternOctaveOffset[(int)mCurrentPatternStep];
}
}
/// <summary>
/// Plays the next steps in the measure.
/// </summary>
/// <param name="set"></param>
public override void PlayMeasure(InstrumentSet set)
{
set.UpdateTempo();
if (set.mMusicGenerator == null)
{
return;
}
set.mSixteenthStepTimer -= Time.deltaTime;
// we'll take a step when the timer hits zero, or it's the first step
if (set.mSixteenthStepTimer <= 0 && set.SixteenthStepsTaken < set.mTimeSignature.mStepsPerMeasure)
{
if (set.SixteenthStepsTaken % (int)set.mData.mProgressionRate == 0)
{
set.ProgressionStepsTaken += 1;
}
if (set.ProgressionStepsTaken > InstrumentSet.mMaxFullstepsTaken - 1)
{
set.ProgressionStepsTaken = -1;
}
TakeStep(set, (int)eTimestep.sixteenth, set.SixteenthRepeatCount);
set.SixteenthRepeatCount += 1;
set.mSixteenthStepTimer = set.mBeatLength;
set.SixteenthStepsTaken += 1;
}
// Reset once we've reached the end
else if (set.SixteenthStepsTaken == set.mTimeSignature.mStepsPerMeasure)
{
set.mMeasureStartTimer += Time.deltaTime;
if (set.mMeasureStartTimer > set.mBeatLength)
{
bool hardReset = false;
ResetMeasure(set, set.mMusicGenerator.SetThemeRepeat, hardReset, true);
}
}
}
///stages a clip for playing. Async version (will load assets on the fly).
public IEnumerator AsyncStageClipForPlaying()
{
ClearCurrentInstruments();
bool isFinished = false;
StartCoroutine(AsyncLoadClip(((x) => { isFinished = x; }), mPlayClipDropdown.options[mPlayClipDropdown.value].text));
yield return(new WaitUntil(() => isFinished));
mCurrentInstSet = mLoadedClip.mInstrumentSet;
InstrumentListPanelUI listPanel = InstrumentListPanelUI.Instance;
for (int i = 0; i < mCurrentInstSet.mInstruments.Count; i++)
{
listPanel.AddInstrument(mCurrentInstSet.mInstruments[i]);
InstrumentListUIObject icon = listPanel.mInstrumentIcons[listPanel.mInstrumentIcons.Count - 1];
icon.mInstrument = mCurrentInstSet.mInstruments[i];
icon.ToggleSelected();
bool isPercussion = icon.mInstrument.mData.InstrumentType.Contains("p_") ? true : false;
icon.SetDropdown(isPercussion);
InstrumentPanelUI.Instance.SetInstrument(icon.mInstrument);
mInstrumentPanel.mInstrument = mCurrentInstSet.mInstruments[i];
}
InstrumentPanelUI.Instance.SetInstrument(mCurrentInstSet.mInstruments[0]);
mInstrumentPanel.mInstrument = mCurrentInstSet.mInstruments[0];
mClipIsRepeating.isOn = mLoadedClip.mIsRepeating;
mCurrentMeasure.value = 0;
mLoadedClip.SetState(eClipState.Stop);
mMusicGenerator.ClipLoaded.Invoke(mCurrenClipSave);
mMusicGenerator.ResetPlayer();
mMusicGenerator.SetState(eGeneratorState.editing);
ToggleHelperNotes();
UIToggleAllInstruments();
yield return(null);
}
/// Takes a measure step.
public override void TakeStep(InstrumentSet set, eTimestep timeStepIN, int value = 0)
{
for (int i = 0; i < set.mInstruments.Count; i++)
{
if (set.mInstruments[i].mData.mIsMuted == false)
{
for (int j = 0; j < set.mInstruments[i].mData.ChordSize; j++)
{
int note = set.mInstruments[i].mClipNotes[set.mRepeatCount][value][j];
if (note != InstrumentSet.mUnplayed)
{
/// set percussion to 0
if (set.mInstruments[i].mData.InstrumentType.Contains("p_"))
{
note = 0;
}
set.mMusicGenerator.PlayAudioClip(set, (int)set.mInstruments[i].InstrumentTypeIndex, note, set.mInstruments[i].mData.Volume, i);
}
}
}
}
}
void Update()
{
if (mMusicGenerator == null)
{
return;
}
if (mMusicGenerator.mState == eGeneratorState.editorInitializing)
{
return;
}
InstrumentSet set = (mMusicGenerator.mState >= eGeneratorState.editorInitializing) ? mMeasureEditor.mCurrentInstSet : mMusicGenerator.mInstrumentSet;
if (mCurrentChordProgression != mMusicGenerator.ChordProgression)
{
UpdateChordProgressionText(set);
}
float sixteenthStepTimer = set.mSixteenthStepTimer;
int sixteenStepsTaken = set.SixteenthStepsTaken - 1;
float sixteenthMeasure = set.mBeatLength;
float dist = mBarLines[1].position.x - mBarLines[0].position.x;
float perc = (sixteenthStepTimer / sixteenthMeasure);
if (sixteenStepsTaken < 0)
{
mTimerBar.gameObject.transform.position = new Vector3(mBarLines[0].position.x,
mTimerBar.transform.position.y, mTimerBar.transform.position.z);
}
else
{
mTimerBar.gameObject.transform.position = new Vector3(mBarLines[sixteenStepsTaken].position.x +
dist * (1.0f - perc), mTimerBar.transform.position.y, mTimerBar.transform.position.z);
}
}