/// <summary> /// Get a variable. /// </summary> /// <param name="varNum">Var number.</param> /// <param name="t">Track.</param> /// <param name="p">Sequence player.</param> /// <returns>The variable.</returns> public static short GetVar(int varNum, Track t, SequencePlayer p) { //0-15 are local. if (varNum >= 0 && varNum <= 15) { return(t.Variables[varNum]); } //16-31 are global. else if (varNum >= 16 && varNum <= 31) { return(p.GlobalVariables[varNum - 16]); } //32-47 are sequence. else if (varNum >= 32 && varNum <= 47) { return(p.SequenceVariables[varNum - 32]); } //Null? else { return(-1); } }
/// <summary> /// Set a variable. /// </summary> /// <param name="value">Value to change variable to.</param> /// <param name="varNum">Var number.</param> /// <param name="t">Track.</param> /// <param name="p">Sequence player.</param> public static void SetVar(short value, int varNum, Track t, SequencePlayer p) { //0-15 are local. if (varNum >= 0 && varNum <= 15) { t.Variables[varNum] = value; } //16-31 are global. else if (varNum >= 16 && varNum <= 31) { p.GlobalVariables[varNum - 16] = value; } //32-47 are sequence. else if (varNum >= 32 && varNum <= 47) { p.SequenceVariables[varNum - 32] = value; } }
public static void ExecuteCommand(SequenceCommand c, Track t, SequencePlayer p) { //Note command. if (c.Identifier >= 0 && c.Identifier <= 127) { //Play note. } //Switch the command type. switch ((CommandType)c.Identifier) { //Wait the provided amount of ticks. case CommandType.Wait: Thread.Sleep(TickTime.Ticks2Milliseconds((c as WaitCommand).Length)); break; //Program change. case CommandType.ProgramChange: t.InstrumentNumber = (int)(c as ProgramChangeCommand).Program; break; //Open track. case CommandType.OpenTrack: OpenTrackCommand openTrackCommand = (c as OpenTrackCommand); p.TracksOpen[openTrackCommand.TrackNumber] = true; p.Tracks[openTrackCommand.TrackNumber] = new Track(p.Tracks[0]); p.Tracks[openTrackCommand.TrackNumber].Offset = (int)openTrackCommand.Offset.Value; break; //Jump. case CommandType.Jump: t.Offset = (int)(c as JumpCommand).Offset.Value; break; //Call. case CommandType.Call: t.ReturnToOffsets.Push(t.Offset + 1); t.Offset = (int)(c as CallCommand).Offset.Value; break; //Time base. case CommandType.TimeBase: t.TimeBase = (c as TimeBaseCommand).QuarterNoteLength; break; //Hold. case CommandType.Hold: t.Hold = (c as HoldCommand).Hold; break; //Monophonic. case CommandType.Monophonic: t.Monophonic = (c as MonophonicCommand).Monophonic; break; //Velocity range. case CommandType.VelocityRange: t.VelocityRange = (c as VelocityRangeCommand).VelocityRange; break; //Biquad type. case CommandType.BiquadType: t.BiquadType = (c as BiquadTypeCommand).BiquadType; break; //Biquad value. case CommandType.BiquadValue: t.BiquadValue = (c as BiquadValueCommand).BiquadValue; break; //Bank select. case CommandType.BankSelect: t.BankNumber = (c as BankSelectCommand).BankNumber; break; //TODO! //Sweep pitch. //Mod period. //Extended command. case CommandType.Extended: ExecuteExtendedCommand((c as ExtendedCommand).SequenceCommand, t, p); break; //Envelope reset. TODO! //Loop end. TODO! //Return from a call. case CommandType.Return: t.Offset = t.ReturnToOffsets.Pop(); break; //Allocate track does nothing. //Fin. Close the track. case CommandType.Fin: int trackIndexToClose = Array.IndexOf(p.Tracks, t); p.TracksOpen[trackIndexToClose] = false; break; //Prefix commands are to do later. } //Increment the command number, if not moving. if ((c as OpenTrackCommand != null) || (c as JumpCommand != null) || (c as CallCommand != null)) { t.Offset++; } }
public static void ExecuteExtendedCommand(SequenceCommand c, Track t, SequencePlayer p) { //Switch the extended command type. switch ((ExtendedCommandType)c.Identifier) { //Set var. case ExtendedCommandType.SetVar: SetVar((c as SetVarCommand).Value, (c as SetVarCommand).Variable, t, p); break; //Add var. case ExtendedCommandType.AddVar: SetVar((short)(GetVar((c as AddVarCommand).Variable, t, p) + (c as AddVarCommand).Value), (c as AddVarCommand).Variable, t, p); break; //Sub var. case ExtendedCommandType.SubtractVar: SetVar((short)(GetVar((c as SubtractVarCommand).Variable, t, p) - (c as SubtractVarCommand).Value), (c as SubtractVarCommand).Variable, t, p); break; //Multiply var. case ExtendedCommandType.MultiplyVar: SetVar((short)(GetVar((c as MultiplyVarCommand).Variable, t, p) * (c as MultiplyVarCommand).Value), (c as MultiplyVarCommand).Variable, t, p); break; //Divide var. case ExtendedCommandType.DivideVar: SetVar((short)(GetVar((c as DivideVarCommand).Variable, t, p) / (c as DivideVarCommand).Value), (c as DivideVarCommand).Variable, t, p); break; //Shift var. case ExtendedCommandType.ShiftVar: if ((c as ShiftVarCommand).Value > 0) { SetVar((short)(GetVar((c as ShiftVarCommand).Variable, t, p) << (c as ShiftVarCommand).Value), (c as ShiftVarCommand).Variable, t, p); } else { SetVar((short)(GetVar((c as ShiftVarCommand).Variable, t, p) >> Math.Abs((c as ShiftVarCommand).Value)), (c as ShiftVarCommand).Variable, t, p); } break; //Random var. case ExtendedCommandType.RandomVar: if ((c as RandomVarCommand).Value >= 0) { SetVar((short)random.Next(0, (c as RandomVarCommand).Value), (c as RandomVarCommand).Variable, t, p); } else { SetVar((short)random.Next((c as RandomVarCommand).Value, 0), (c as RandomVarCommand).Variable, t, p); } break; //And var. case ExtendedCommandType.AndVar: SetVar((short)(GetVar((c as AndVarCommand).Variable, t, p) & (c as AndVarCommand).Value), (c as AndVarCommand).Variable, t, p); break; //Or var. case ExtendedCommandType.OrVar: SetVar((short)(GetVar((c as OrVarCommand).Variable, t, p) | (c as OrVarCommand).Value), (c as OrVarCommand).Variable, t, p); break; //Xor var. case ExtendedCommandType.XorVar: SetVar((short)(GetVar((c as XorVarCommand).Variable, t, p) ^ (c as XorVarCommand).Value), (c as XorVarCommand).Variable, t, p); break; //Not var. case ExtendedCommandType.NotVar: SetVar((short)~(GetVar((c as NotVarCommand).Variable, t, p) & (c as NotVarCommand).Value), (c as NotVarCommand).Variable, t, p); break; //Mod var. case ExtendedCommandType.ModVar: SetVar((short)(GetVar((c as ModVarCommand).Variable, t, p) % (c as ModVarCommand).Value), (c as ModVarCommand).Variable, t, p); break; //Compare equal. case ExtendedCommandType.CompareEqual: t.ConditionFlag = GetVar((c as CompareEqualCommand).Variable, t, p) == (c as CompareEqualCommand).Value; break; //Compare greater than or equal to. case ExtendedCommandType.CompareGreaterThanOrEqualTo: t.ConditionFlag = GetVar((c as CompareGreaterThanOrEqualToCommand).Variable, t, p) >= (c as CompareGreaterThanOrEqualToCommand).Value; break; //Compare greater than. case ExtendedCommandType.CompareGreaterThan: t.ConditionFlag = GetVar((c as CompareGreaterThanCommand).Variable, t, p) > (c as CompareGreaterThanCommand).Value; break; //Compare less than or equal to. case ExtendedCommandType.CompareLessThanOrEqualTo: t.ConditionFlag = GetVar((c as CompareLessThanOrEqualToCommand).Variable, t, p) <= (c as CompareLessThanOrEqualToCommand).Value; break; //Compare less than. case ExtendedCommandType.CompareLessThan: t.ConditionFlag = GetVar((c as CompareLessThanCommand).Variable, t, p) < (c as CompareLessThanCommand).Value; break; //Compare not equal. case ExtendedCommandType.CompareNotEqual: t.ConditionFlag = GetVar((c as CompareNotEqualCommand).Variable, t, p) != (c as CompareNotEqualCommand).Value; break; //TODO: MOD STUFF!!! } }