void UpdateEffectGenerator(EffectEnvelope s, EffectDef d)
{
byte f = (byte)AdvanceEffectEnvelope(s, d);
if ((f & 1) != 0)
{
switch (d.type)
{
case 0:
_operator2Tl = (byte)(s.startLevel + d.phase);
break;
case 13:
_operator1Tl = (byte)(s.startLevel + d.phase);
break;
case 30:
d.s.modWheelState = (sbyte)d.phase;
break;
case 31:
d.s.modWheelSensitivity = (sbyte)d.phase;
break;
}
}
if ((f & 2) != 0)
{
if (d.loopRefresh != 0)
{
KeyOn();
}
}
}
void SetupEffects(MidiChannelPcSpk chan, EffectEnvelope env, EffectDefinition def, byte flags, byte[] data, int offset)
{
def.phase = 0;
def.useModWheel = (byte)(flags & 0x40);
env.loop = (byte)(flags & 0x20);
def.type = (short)(flags & 0x1F);
env.modWheelSensitivity = 31;
if (def.useModWheel != 0)
{
env.modWheelState = (byte)(MidiChannelPcSpk.ModWheel >> 2);
}
else
{
env.modWheelState = 31;
}
switch (def.type)
{
case 0:
env.maxLevel = 767;
env.startLevel = 383;
break;
case 1:
env.maxLevel = 31;
env.startLevel = 15;
break;
case 2:
env.maxLevel = 63;
env.startLevel = chan._out.unkB;
break;
case 3:
env.maxLevel = 63;
env.startLevel = chan._out.unkC;
break;
case 4:
env.maxLevel = 3;
env.startLevel = chan._instrument[4];
break;
case 5:
env.maxLevel = 62;
env.startLevel = 31;
env.modWheelState = 0;
break;
case 6:
env.maxLevel = 31;
env.startLevel = 0;
env.modWheelSensitivity = 0;
break;
}
StartEffect(env, data, offset);
}
int AdvanceEffectEnvelope(EffectEnvelope s, EffectDef d)
{
if (s.duration != 0)
{
s.duration -= 17;
if (s.duration <= 0)
{
s.state = EnvelopeState.Ready;
return(0);
}
}
int t = s.currentLevel + s.incrPerStep;
s.incrCountRem += s.incrPerStepRem;
if (s.incrCountRem >= s.numSteps)
{
s.incrCountRem -= s.numSteps;
t += s.dir;
}
int retFlags = 0;
if (t != s.currentLevel || (s.modWheelState != s.modWheelLast))
{
s.currentLevel = t;
s.modWheelLast = s.modWheelState;
t = GetEffectModLevel(t, s.modWheelState);
if (t != d.phase)
{
d.phase = t;
retFlags |= 1;
}
}
if ((--s.stepCounter) != 0)
{
return(retFlags);
}
if (++s.state > EnvelopeState.Releasing)
{
if (s.loop == 0)
{
s.state = EnvelopeState.Ready;
return(retFlags);
}
s.state = EnvelopeState.Attacking;
retFlags |= 2;
}
InitNextEnvelopeState(s);
return(retFlags);
}
void InitNextEnvelopeState(EffectEnvelope env)
{
byte lastState = (byte)(env.state - 1);
short stepCount = _effectEnvStepTable[GetEffectModifier((ushort)(((env.stateTargetLevels[lastState] & 0x7F) << 5) + env.modWheelSensitivity))];
if ((env.stateTargetLevels[lastState] & 0x80) != 0)
{
stepCount = GetRandScale(stepCount);
}
if (stepCount == 0)
{
stepCount = 1;
}
env.stateNumSteps = env.stateStepCounter = stepCount;
short totalChange = 0;
if (lastState != 2)
{
totalChange = GetEffectModLevel(env.maxLevel, (sbyte)((env.stateModWheelLevels[lastState] & 0x7F) - 31));
if ((env.stateModWheelLevels[lastState] & 0x80) != 0)
{
totalChange = GetRandScale(totalChange);
}
if (totalChange + env.startLevel > env.maxLevel)
{
totalChange = (short)(env.maxLevel - env.startLevel);
}
else if (totalChange + env.startLevel < 0)
{
totalChange = (short)-env.startLevel;
}
totalChange -= env.currentLevel;
}
env.changePerStep = (short)(totalChange / stepCount);
if (totalChange < 0)
{
totalChange = (short)-totalChange;
env.dir = -1;
}
else
{
env.dir = 1;
}
env.changePerStepRem = (short)(totalChange % stepCount);
env.changeCountRem = 0;
}
void InitNextEnvelopeState(EffectEnvelope s)
{
byte v = s.stateTargetLevels[(int)s.state - 1];
int e = _effectEnvStepTable[_driver._operatorLevelTable[((v & 0x7f) << 5) + s.modWheelSensitivity]];
if ((v & 0x80) != 0)
{
e = _driver.RandomValue(e);
}
if (e == 0)
{
e = 1;
}
s.numSteps = (ushort)(s.stepCounter = (uint)e);
int d = 0;
if (s.state != EnvelopeState.Sustaining)
{
v = s.stateModWheelLevels[(int)s.state - 1];
e = GetEffectModLevel(s.maxLevel, (v & 0x7f) - 31);
if ((v & 0x80) != 0)
{
e = _driver.RandomValue(e);
}
if (e + s.startLevel > s.maxLevel)
{
e = s.maxLevel - s.startLevel;
}
else
{
if (e + s.startLevel < 0)
{
e = -s.startLevel;
}
}
d = e - s.currentLevel;
}
s.incrPerStep = d / s.numSteps;
s.dir = (sbyte)((d < 0) ? -1 : 1);
d *= s.dir;
s.incrPerStepRem = (uint)(d % s.numSteps);
s.incrCountRem = 0;
}
void StartEffect(EffectEnvelope s, byte[] effectData, int offset)
{
s.state = EnvelopeState.Attacking;
s.currentLevel = 0;
s.modWheelLast = 31;
s.duration = effectData[offset] * 63;
s.stateTargetLevels[0] = effectData[offset + 1];
s.stateTargetLevels[1] = effectData[offset + 3];
s.stateTargetLevels[2] = effectData[offset + 5];
s.stateTargetLevels[3] = effectData[offset + 6];
s.stateModWheelLevels[0] = effectData[offset + 2];
s.stateModWheelLevels[1] = effectData[offset + 4];
s.stateModWheelLevels[2] = 0;
s.stateModWheelLevels[3] = effectData[offset + 7];
InitNextEnvelopeState(s);
}
public void SetupEffects(int index, byte flags, byte[] effectData, int offset)
{
ushort[] effectMaxLevel = { 0x2FF, 0x1F, 0x07, 0x3F, 0x0F, 0x0F, 0x0F, 0x03, 0x3F, 0x0F, 0x0F, 0x0F, 0x03, 0x3E, 0x1F };
byte[] effectType = { 0x1D, 0x1C, 0x1B, 0x00, 0x03, 0x04, 0x07, 0x08, 0x0D, 0x10, 0x11, 0x14, 0x15, 0x1e, 0x1f, 0x00 };
EffectEnvelope s = _effectEnvelopes[index];
EffectDef d = _effectDefs[index];
d.phase = 0;
d.useModWheel = (byte)(flags & 0x40);
s.loop = (byte)(flags & 0x20);
d.loopRefresh = (byte)(flags & 0x10);
d.type = effectType[flags & 0x0f];
s.maxLevel = effectMaxLevel[flags & 0x0f];
s.modWheelSensitivity = 31;
s.modWheelState = (sbyte)((d.useModWheel != 0) ? _in._modWheel >> 2 : 31);
switch (d.type)
{
case 0:
s.startLevel = _operator2Tl;
break;
case 13:
s.startLevel = _operator1Tl;
break;
case 30:
s.startLevel = 31;
d.s.modWheelState = 0;
break;
case 31:
s.startLevel = 0;
d.s.modWheelSensitivity = 0;
break;
default:
s.startLevel = GetEffectStartLevel(d.type);
break;
}
StartEffect(s, effectData, offset);
}
void StartEffect(EffectEnvelope env, byte[] data, int offset)
{
env.state = 1;
env.currentLevel = 0;
env.modWheelLast = 31;
env.duration = (short)(data[offset + 0] * 63);
env.stateTargetLevels[0] = data[offset + 1];
env.stateTargetLevels[1] = data[offset + 3];
env.stateTargetLevels[2] = data[offset + 5];
env.stateTargetLevels[3] = data[offset + 6];
env.stateModWheelLevels[0] = data[offset + 2];
env.stateModWheelLevels[1] = data[offset + 4];
env.stateModWheelLevels[2] = 0;
env.stateModWheelLevels[3] = data[offset + 7];
InitNextEnvelopeState(env);
}
public TownsMidiOutputChannel(MidiDriver_TOWNS driver, int chanIndex)
{
_driver = driver;
_chan = (byte)chanIndex;
_effectEnvelopes = new EffectEnvelope[2];
for (int i = 0; i < _effectEnvelopes.Length; i++)
{
_effectEnvelopes[i] = new EffectEnvelope();
}
_effectDefs = new EffectDef[2];
for (int i = 0; i < _effectEnvelopes.Length; i++)
{
_effectDefs[i] = new EffectDef();
}
_effectDefs[0].s = _effectEnvelopes[1];
_effectDefs[1].s = _effectEnvelopes[0];
}
public TownsMidiOutputChannel(MidiDriver_TOWNS driver, int chanIndex)
{
_driver = driver;
_chan = (byte)chanIndex;
_effectEnvelopes = new EffectEnvelope[2];
for (int i = 0; i < _effectEnvelopes.Length; i++)
{
_effectEnvelopes[i] = new EffectEnvelope();
}
_effectDefs = new EffectDef[2];
for (int i = 0; i < _effectEnvelopes.Length; i++)
{
_effectDefs[i] = new EffectDef();
}
_effectDefs[0].s = _effectEnvelopes[1];
_effectDefs[1].s = _effectEnvelopes[0];
}
void InitNextEnvelopeState(EffectEnvelope s)
{
byte v = s.stateTargetLevels[(int)s.state - 1];
int e = _effectEnvStepTable[_driver._operatorLevelTable[((v & 0x7f) << 5) + s.modWheelSensitivity]];
if ((v & 0x80) != 0)
e = _driver.RandomValue(e);
if (e == 0)
e = 1;
s.numSteps = (ushort)(s.stepCounter = (uint)e);
int d = 0;
if (s.state != EnvelopeState.Sustaining)
{
v = s.stateModWheelLevels[(int)s.state - 1];
e = GetEffectModLevel(s.maxLevel, (v & 0x7f) - 31);
if ((v & 0x80) != 0)
e = _driver.RandomValue(e);
if (e + s.startLevel > s.maxLevel)
{
e = s.maxLevel - s.startLevel;
}
else
{
if (e + s.startLevel < 0)
e = -s.startLevel;
}
d = e - s.currentLevel;
}
s.incrPerStep = d / s.numSteps;
s.dir = (sbyte)((d < 0) ? -1 : 1);
d *= s.dir;
s.incrPerStepRem = (uint)(d % s.numSteps);
s.incrCountRem = 0;
}
int AdvanceEffectEnvelope(EffectEnvelope s, EffectDef d)
{
if (s.duration != 0)
{
s.duration -= 17;
if (s.duration <= 0)
{
s.state = EnvelopeState.Ready;
return 0;
}
}
int t = s.currentLevel + s.incrPerStep;
s.incrCountRem += s.incrPerStepRem;
if (s.incrCountRem >= s.numSteps)
{
s.incrCountRem -= s.numSteps;
t += s.dir;
}
int retFlags = 0;
if (t != s.currentLevel || (s.modWheelState != s.modWheelLast))
{
s.currentLevel = t;
s.modWheelLast = s.modWheelState;
t = GetEffectModLevel(t, s.modWheelState);
if (t != d.phase)
{
d.phase = t;
retFlags |= 1;
}
}
if ((--s.stepCounter) != 0)
return retFlags;
if (++s.state > EnvelopeState.Releasing)
{
if (s.loop == 0)
{
s.state = EnvelopeState.Ready;
return retFlags;
}
s.state = EnvelopeState.Attacking;
retFlags |= 2;
}
InitNextEnvelopeState(s);
return retFlags;
}
void UpdateEffectGenerator(EffectEnvelope s, EffectDef d)
{
byte f = (byte)AdvanceEffectEnvelope(s, d);
if ((f & 1) != 0)
{
switch (d.type)
{
case 0:
_operator2Tl = (byte)(s.startLevel + d.phase);
break;
case 13:
_operator1Tl = (byte)(s.startLevel + d.phase);
break;
case 30:
d.s.modWheelState = (sbyte)d.phase;
break;
case 31:
d.s.modWheelSensitivity = (sbyte)d.phase;
break;
}
}
if ((f & 2) != 0)
{
if (d.loopRefresh != 0)
KeyOn();
}
}
void StartEffect(EffectEnvelope s, byte[] effectData, int offset)
{
s.state = EnvelopeState.Attacking;
s.currentLevel = 0;
s.modWheelLast = 31;
s.duration = effectData[offset] * 63;
s.stateTargetLevels[0] = effectData[offset + 1];
s.stateTargetLevels[1] = effectData[offset + 3];
s.stateTargetLevels[2] = effectData[offset + 5];
s.stateTargetLevels[3] = effectData[offset + 6];
s.stateModWheelLevels[0] = effectData[offset + 2];
s.stateModWheelLevels[1] = effectData[offset + 4];
s.stateModWheelLevels[2] = 0;
s.stateModWheelLevels[3] = effectData[offset + 7];
InitNextEnvelopeState(s);
}
