public override void ParseDefinition(string definitionKey, JsonData jsonData)
{
this.definitionKey = definitionKey;
var keys = jsonData.Keys;
portraitKey = ContentHelper.ParseString(jsonData, D.PORTRAITKEY, "Portrait_1");
voiceVolume = ContentHelper.ParseFloat(jsonData, "voiceVolume", 1.0f);
this.name = ContentHelper.ParseString(jsonData, D.NAME, definitionKey);
this.factionKey = ContentHelper.ParseString(jsonData, D.FACTION_KEY, "FACTION_GUARDS");
if (keys.Contains(D.REWARDS_ON_START))
{
this._onStartRewardDefinitions = EffectDefinition.ParseDefinitions(jsonData[D.REWARDS_ON_START], definitionKey);
}
else
{
this._onStartRewardDefinitions = new Definition <Effect> [0];
}
this.voiceType = ContentHelper.ParseString(jsonData, "voiceKey", "A");
if (keys.Contains(D.REWARDS_ON_TUNE))
{
this._onTuneInRewardDefinitions = EffectDefinition.ParseDefinitions(jsonData[D.REWARDS_ON_TUNE], definitionKey);
}
else
{
this._onTuneInRewardDefinitions = new Definition <Effect> [0];
}
}
public void SetValues()
{
var definition = new EffectDefinition();
definition.EffectId = StandardEffects.AudioMixerEffect;
Assert.AreEqual(definition.EffectId, StandardEffects.AudioMixerEffect);
}
public void JumpVolume()
{
// and audible demonstration of the difference between interpolating
// parameter values for an effect, and jumping directly to them.
string outputFile = "JumpVolume.wma";
using (ITimeline timeline = new DefaultTimeline())
{
IGroup group = timeline.AddAudioGroup();
ITrack track = group.AddTrack();
IClip clip = track.AddClip("testinput.mp3", GroupMediaType.Audio, InsertPosition.Relative, 0, 0, 10);
EffectDefinition effectDefinition = new EffectDefinition(DxtSubObjects.AudioMixer);
Parameter volumeParameter = new Parameter("Vol", 0.0, 2, 1.0);
volumeParameter.Intervals.Add(new Interval(IntervalMode.Jump, 2.5, "0.2"));
volumeParameter.Intervals.Add(new Interval(IntervalMode.Jump, 3.5, "0.8"));
volumeParameter.Intervals.Add(new Interval(IntervalMode.Jump, 4.5, "0.2"));
volumeParameter.Intervals.Add(new Interval(IntervalMode.Jump, 5, "1.0"));
volumeParameter.Intervals.Add(new Interval(IntervalMode.Interpolate, clip.Duration, "0.0"));
effectDefinition.Parameters.Add(volumeParameter);
clip.AddEffect(0, clip.Duration, effectDefinition);
using (
IRenderer renderer =
new WindowsMediaRenderer(timeline, outputFile, WindowsMediaProfiles.MediumQualityAudio))
{
renderer.Render();
}
}
}
public void Constructor1()
{
EffectDefinition definition = new EffectDefinition();
Assert.AreEqual(Guid.Empty, definition.EffectId);
Assert.AreEqual(0, definition.Parameters.Count);
}
public void Constructor2()
{
EffectDefinition definition = new EffectDefinition(DxtSubObjects.sIEMatrixFxGuid);
Assert.AreEqual(DxtSubObjects.sIEMatrixFxGuid, definition.EffectId);
Assert.AreEqual(0, definition.Parameters.Count);
}
public void AddEffectSetsApropriateContainer()
{
using (ITimeline timeline = new DefaultTimeline())
{
EffectDefinition def = StandardEffects.CreateDefaultBlur();
IGroup group = timeline.AddVideoGroup(24, 100, 100);
IEffect groupEffect = group.AddEffect(0, 10, def);
Assert.AreSame(group, groupEffect.Group);
Assert.AreSame(group, groupEffect.Container);
ITrack track = group.AddTrack();
IEffect trackEffect = track.AddEffect(0, 10, def);
Assert.AreSame(group, trackEffect.Group);
Assert.AreSame(track, trackEffect.Container);
IComposition composition = group.AddComposition();
IEffect compositionEffect = composition.AddEffect(0, 10, def);
Assert.AreSame(group, compositionEffect.Group);
Assert.AreSame(composition, compositionEffect.Container);
IClip clip = track.AddClip("..\\..\\image1.jpg", GroupMediaType.Image, InsertPosition.Absolute, 0, 0, 10);
IEffect clipEffect = clip.AddEffect(0, 10, def);
Assert.AreSame(group, clip.Group);
Assert.AreSame(clip, clipEffect.Container);
}
}
private void loadEffectToolStripMenuItem_Click(object sender, EventArgs e)
{
if (openEffectDialog.ShowDialog() == DialogResult.OK)
{
mEffectDefinition = EffectDefinition.FromFile(openEffectDialog.FileName);
this.SuspendLayout();
effectComponentsList.DataSource = null;
effectComponentsList.DataSource = mEffectDefinition.Components;
UpdateAvailableComponents();
effectParametersList.Parameters = mEffectDefinition.Parameters;
UpdateStandardParameters();
effectEdit_vertexShaderListChanged(null, new EventArgs());
effectEdit_pixelShaderListChanged(null, new EventArgs());
if (mEffectDefinition.VertexShaders.Count > 0)
{
vertexShadersList.SelectedIndex = 0;
}
if (mEffectDefinition.PixelShaders.Count > 0)
{
pixelShadersList.SelectedIndex = 0;
}
effectTechniquesList.DataSource = null;
effectTechniquesList.DataSource = mEffectDefinition.Techniques;
this.ResumeLayout();
}
}
public void Constructor2()
{
var definition = new EffectDefinition(StandardEffects.MatrixEffect);
Assert.AreEqual(StandardEffects.MatrixEffect, definition.EffectId);
Assert.AreEqual(0, definition.Parameters.Count);
}
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);
}
private void AddEffectButton_Click(object sender, EventArgs e)
{
EffectDefinition newDef = new EffectDefinition();
newDef.DBID = GetNewDBID();
newDef.Type = "NewEffect";
mTriggerDefinition.EffectDefinitions.Add(newDef);
RefreshUI();
EffectsListBox.SelectedItem = "NewEffect";
}
public static EffectDefinition CreateEaseOutEffect()
{
var definition = new EffectDefinition(WMTFX);
definition.Parameters.Add(new Parameter("InternalName", "Simple3D"));
definition.Parameters.Add(new Parameter("InitialScaleA", 1.5));
definition.Parameters.Add(new Parameter("ScaleA", 0.5));
definition.Parameters.Add(new Parameter("ExponentialProgressDuration", 0.01));
return(definition);
}
public void SetValues()
{
EffectDefinition definition = new EffectDefinition();
List <Parameter> newParams = new List <Parameter>();
definition.Parameters = newParams;
Assert.AreSame(newParams, definition.Parameters);
definition.EffectId = DxtSubObjects.AudioMixer;
Assert.AreEqual(definition.EffectId, DxtSubObjects.AudioMixer);
}
public static EffectDefinition RotateAndZoomOut()
{
var definition = new EffectDefinition(WMTFX);
definition.Parameters.Add(new Parameter("InternalName", "Simple3D"));
definition.Parameters.Add(new Parameter("InitialScaleA", 1.00));
definition.Parameters.Add(new Parameter("ScaleA", "smaller"));
definition.Parameters.Add(new Parameter("RotateA", "right"));
definition.Parameters.Add(new Parameter("ExponentialProgressDuration", 1));
return(definition);
}
public static EffectDefinition PanRight()
{
var definition = new EffectDefinition(WMTFX);
definition.Parameters.Add(new Parameter("InternalName", "Simple3D"));
definition.Parameters.Add(new Parameter("InitialScaleA", 1.00));
definition.Parameters.Add(new Parameter("ScaleA", 1.00));
definition.Parameters.Add(new Parameter("MoveA", "right"));
definition.Parameters.Add(new Parameter("MoveSpeedA", 0.4));
return(definition);
}
public static EffectDefinition PinWheelZoomOut()
{
var definition = new EffectDefinition(WMTFX);
definition.Parameters.Add(new Parameter("InternalName", "Simple3D"));
definition.Parameters.Add(new Parameter("InitialScaleA", 1.5));
definition.Parameters.Add(new Parameter("ScaleA", 0.5));
definition.Parameters.Add(new Parameter("RotateA", "right"));
definition.Parameters.Add(new Parameter("ExponentialProgressScale", 0.5));
return(definition);
}
public static EffectDefinition FlipOut()
{
var definition = new EffectDefinition(WMTFX);
definition.Parameters.Add(new Parameter("InternalName", "Simple3D"));
definition.Parameters.Add(new Parameter("InitialScaleA", 1.00));
definition.Parameters.Add(new Parameter("ScaleA", 1.0));
definition.Parameters.Add(new Parameter("RotateA", "out"));
definition.Parameters.Add(new Parameter("ExponentialProgressScale", 1));
return(definition);
}
public void setActive(bool active_)
{
active = active_;
// set color and turn on outline
if (active)
{
EffectDefinition def = Shoot.getCubeEffectDefinition(effect);
outlinePulser.OutlinePulseOn = true;
outlinePulser.setOutlineAccentColor(def.outlineColor, def.accentColor);
lightRipple.setRippleColor(def.outlineColor);
}
setActiveChild(active);
}
public void AddEffectToClip()
{
bool beforeFired = false;
bool afterFired = false;
using (ITimeline timeline = new DefaultTimeline())
{
IGroup group = timeline.AddVideoGroup(24, 64, 64);
ITrack track = group.AddTrack();
IClip clip = track.AddClip("transitions.wmv", GroupMediaType.Video, InsertPosition.Absoloute, 0, 0, -1);
clip.BeforeEffectAdded += new EventHandler(delegate
{
beforeFired = true;
});
clip.AfterEffectAdded += new EventHandler <AfterEffectAddedEventArgs>(delegate
{
afterFired = true;
});
EffectDefinition defintion = StandardEffects.CreateBlurEffect(2, clip.Duration, 20);
IEffect effect =
clip.AddEffect("blur", -1, 0, clip.Duration, defintion);
Assert.IsTrue(beforeFired);
Assert.IsTrue(afterFired);
Assert.AreEqual("blur", effect.Name);
Assert.AreEqual(0, effect.Priority);
Assert.AreEqual(clip.Duration, effect.Duration);
Assert.AreEqual(0, clip.Offset);
Assert.AreSame(defintion, effect.EffectDefinition);
PrepareToExecute(timeline,
@"<timeline framerate=""30.0000000"">
<group type=""video"" bitdepth=""24"" width=""64"" height=""64"" framerate=""30.0000000"" previewmode=""0"">
<track>
<clip start=""0"" stop=""7.9990000"" src=""transitions.wmv"" mstart=""0"">
<effect start=""0"" stop=""7.9990000"" clsid=""{7312498D-E87A-11D1-81E0-0000F87557DB}"" username=""blur"">
<param name=""PixelRadius"" value=""2"">
<linear time=""7.9990000"" value=""20"" />
</param>
</effect>
</clip>
</track>
</group>
</timeline>");
}
}
public EditorForm()
{
InitializeComponent();
mEffectDefinition = new EffectDefinition("NewEffect");
// Allow model drag-drop
modelViewPanel.AllowDrop = true;
modelViewPanel.DragEnter += new DragEventHandler(modelViewPanel_DragEnter);
modelViewPanel.DragDrop += new DragEventHandler(modelViewPanel_DragDrop);
// Allow effect drag-drop
effectEditBox.AllowDrop = true;
effectEditBox.DragEnter += new DragEventHandler(effectEditBox_DragEnter);
effectEditBox.DragDrop += new DragEventHandler(effectEditBox_DragDrop);
modelViewPanel.ModelLoaded = ModelLoaded;
hlslInfoBox.ReadOnly = true;
hlslInfoBox.Clear();
effectParametersList.Parameters = mEffectDefinition.Parameters;
UpdateStandardParameters();
effectComponentsList.DataSource = mEffectDefinition.Components;
effectTechniquesList.DataSource = mEffectDefinition.Techniques;
// populate shader profiles boxes in techniques tab
string[] shaderProfiles = Enum.GetNames(typeof(ShaderProfile));
for (int i = 0; i < shaderProfiles.Length; i++)
{
if (shaderProfiles[i].Contains("VS"))
{
passVertexShaderProfileBox.Items.Add(shaderProfiles[i]);
}
if (shaderProfiles[i].Contains("PS"))
{
passPixelShaderProfileBox.Items.Add(shaderProfiles[i]);
}
}
mLoadedComponents = new List <EffectComponent>();
vertexShaderEditor.AllowComponentUsage = true;
pixelShaderEditor.AllowComponentUsage = true;
}
private void addGun(Cube.CubeEffect_e effect)
{
EffectDefinition def = Shoot.getCubeEffectDefinition(effect);
GameObject textGO = Instantiate(effectTextPrefab);
textGO.transform.SetParent(transform, false);
Text text = textGO.GetComponent <Text>();
if (text != null)
{
text.text = def.text;
if (!string.IsNullOrEmpty(def.reverseText))
{
text.text += "|" + def.reverseText;
}
cubeEffectText[effect] = text;
}
}
void Start()
{
EffectDefinition def = Shoot.getCubeEffectDefinition(effect);
Light light = GetComponent <Light>();
if (light != null)
{
light.color = def.outlineColor;
}
Renderer rend = GetComponent <Renderer>();
rend.material.color = def.outlineColor;
// set outline color in shader
if (rend.material.shader.name.Equals("Outlined/Silhouette Only"))
{
rend.material.SetColor("_OutlineColor", def.outlineColor);
}
}
public void EffectPrioirities()
{
using (ITimeline timeline = new DefaultTimeline())
{
EffectDefinition definition = StandardEffects.CreateBlurEffect(2, 10, 2);
IGroup group = timeline.AddAudioGroup();
IEffect first = group.AddEffect("first", -1, 0, 10, definition);
IEffect second = group.AddEffect("second", 0, 0, 10, definition);
IEffect third = group.AddEffect("third", 1, 0, 10, definition);
IEffect fourth = group.AddEffect("fourth", -1, 0, 10, definition);
IEffect fifth = group.AddEffect("fifth", 2, 0, 10, definition);
Assert.AreEqual(3, first.Priority);
Assert.AreEqual(0, second.Priority);
Assert.AreEqual(1, third.Priority);
Assert.AreEqual(4, fourth.Priority);
Assert.AreEqual(2, fifth.Priority);
}
}
public void setEffect(Cube.CubeEffect_e effect_, bool reverse_)
{
effect = effect_;
reverse = reverse_;
EffectDefinition def = Shoot.getCubeEffectDefinition(effect);
outlineColor = def.outlineColor;
accentColor = def.accentColor;
// set color
Material mat = GetComponent <Renderer>().material;
mat.color = def.outlineColor;
// set outline color in shader
Renderer rend = GetComponent <Renderer> ();
if (rend.material.shader.name.Equals("Outlined/Silhouette Only"))
{
rend.material.SetColor("_OutlineColor", def.outlineColor);
}
}
// Update is called once per frame
void Update()
{
if (shootKeyDown())
{
if (effects.Count == 0)
{
print("Update: can't shoot without gun");
return;
}
startCharging();
}
else if (charging && (shootKeyUp() || chargeTime > maxChargeTime))
{
if (chargeTime > maxChargeTime)
{
scatterShoot();
}
else
{
shoot();
}
stopCharging();
}
if (charging)
{
chargeTime += Time.deltaTime;
EffectDefinition def = getCubeEffectDefinition(currentEffect());
Color col = chargingOutline.GetComponent <Image> ().color;
col = def.outlineColor;
float chargePercentage = chargeTime / maxChargeTime;
float lerpValue = Mathf.Pow(chargePercentage, chargePercentageExponent);
col.a = maxChargingEffectFactor * lerpValue;
chargingOutline.GetComponent <Image>().color = col;
player.caneColor = Color.Lerp(Color.white, def.outlineColor, lerpValue);
player.caneScale = Mathf.Lerp(1, caneScaleFactor, lerpValue);
}
switchGun();
}
public IEffect Instance(Timestep step, Entity entity, EntityPainter painter, EntityUniverseFacade facade, Blob data,
EffectDefinition definition, EffectMode mode)
{
return(new ModOptionsEvent());
}
private void ParseBody(Parser parser)
{
Measure measure = new Measure();
Tick tick = new Tick();
Position time = new Position();
List <Tick> ticks = new List <Tick>(64);
EffectType customEffectType = EffectType.UserDefined0;
while (true)
{
if (!parser.Next())
{
return; // End of file
}
string line = parser.Line;
if (line.Length == 0)
{
continue; // Skip empty lines
}
if (line == Separator) // End this block
{
measure.Ticks = ticks.ToArray();
ticks.Clear();
Measures.Add(measure);
measure = new Measure();
time.Measure++;
time.Tick = 0;
}
else
{
if (line[0] == '#') // Detect custom effect type
{
string[] split = line.Split(' ');
// Load custom effect type
if (split[0] == "#define_fx")
{
if (split.Length != 3)
{
parser.Throw("Invalid custom effect definition");
}
EffectDefinition effectDefinition = new EffectDefinition();
effectDefinition.Name = split[1];
effectDefinition.Type = customEffectType;
effectDefinition.BaseType = EffectType.UserDefined0;
string[] options = split[2].Split(';');
foreach (var option in options)
{
string[] kvp = option.Split('=');
if (kvp.Length != 2)
{
parser.Throw($"Invalid effect key/value pair \"{option}\"");
}
if (kvp[0] == "type")
{
effectDefinition.BaseType = ParseEffectType(kvp[1]);
}
effectDefinition.Options.Add(kvp[0], kvp[1]);
}
if (effectDefinition.BaseType == EffectType.UserDefined0)
{
parser.Throw($"Missing base effect type for custom effect definition \"{effectDefinition.Name}\"");
}
EffectDefinitions.Add(effectDefinition);
customEffectType = (EffectType)((int)customEffectType + 1);
}
}
else if (line.Contains("=")) // Detect options
{
string[] split = line.Split('=');
if (split.Length != 2)
{
parser.Throw("Invalid options string", line.IndexOf("="));
}
if (tick.Options == null)
{
tick.Options = new Dictionary <string, string>();
}
tick.Options[split[0]] = split[1];
}
else
{
string[] split = line.Split('|');
if (split.Length != 3)
{
parser.Throw("Invalid tick format");
}
if (split[0].Length != 4)
{
parser.Throw("Invalid button format");
}
if (split[1].Length != 2)
{
parser.Throw("Invalid fx button format", 5);
}
tick.Button[0] = Convert.ToByte(split[0][0]);
tick.Button[1] = Convert.ToByte(split[0][1]);
tick.Button[2] = Convert.ToByte(split[0][2]);
tick.Button[3] = Convert.ToByte(split[0][3]);
tick.Button[4] = Convert.ToByte(split[1][0]);
tick.Button[5] = Convert.ToByte(split[1][1]);
if (split[2].Length < 2)
{
parser.Throw("Invalid laser button format", 5);
}
tick.Lasers[0] = TranslateLaserCharacter(split[2][0]);
tick.Lasers[1] = TranslateLaserCharacter(split[2][1]);
// TODO: Laser roll information
ticks.Add(tick);
tick = new Tick();
time.Tick++;
}
}
}
}
public IEffect AddEffect(string name, int priority, double offset, double duration,
EffectDefinition effectDefinition)
{
throw new Exception("The method or operation is not implemented.");
}
public IEffect AddEffect(string name, int priority, double offset, double duration,
EffectDefinition effectDefinition)
{
throw new Exception("The method or operation is not implemented.");
}
public SkyDome(Device device)
{
_device = device;
_skyEffectDefinition = new(_device, "Content/Effect/RayleightScatter.fx", PrimitiveTopology.TriangleList);
_skyBuffer = GenerateSkyDome(device);
}
void VersionListBox_SelectedIndexChanged(object sender, EventArgs e)
{
SaveToNewVersionButton.Enabled = false;
SaveToSelectedButton.Enabled = false;
mTempCondDef = null;
mTempEffectDef = null;
ConditionDefinition condDef = VersionListBox.SelectedItem as ConditionDefinition;
EffectDefinition effDef = VersionListBox.SelectedItem as EffectDefinition;
mCurrentCondDef = condDef;
mCurrentEffectDef = effDef;
TriggerComponentDefinition compDef = VersionListBox.SelectedItem as TriggerComponentDefinition;
if (condDef != null)
{
mTempCondDef = new ConditionDefinition();
condDef.CopyTo(mTempCondDef);
ItemPropertyGrid.SelectedObject = mTempCondDef;
InVariblesList.ObjectList = mTempCondDef.InParameterDefinitions;
OutVariablesList.ObjectList = mTempCondDef.OutParameterDefinitions;
ConversionList.ObjectList = mTempCondDef.ParameterConversionOverrides;
}
if (effDef != null)
{
mTempEffectDef = new EffectDefinition();
effDef.CopyTo(mTempEffectDef);
ItemPropertyGrid.SelectedObject = mTempEffectDef;
InVariblesList.ObjectList = mTempEffectDef.InParameterDefinitions;
OutVariablesList.ObjectList = mTempEffectDef.OutParameterDefinitions;
ConversionList.ObjectList = mTempEffectDef.ParameterConversionOverrides;
}
if (compDef != null)
{
int version = compDef.Version;
if (version > 1)
{
TriggerComponentDefinition lastversion = null;
foreach (object o in mEntries[compDef.Type])
{
TriggerComponentDefinition oldCompDef = o as TriggerComponentDefinition;
if (oldCompDef != null)
{
if (oldCompDef.Version == version - 1)
{
lastversion = oldCompDef;
break;
}
}
}
ConversionList.AddMetaDataForProp("ParameterConversionOverride", "OldParameter", "StringIntEnumeration", GetParameterConversionInfo(lastversion));
ConversionList.AddMetaDataForProp("ParameterConversionOverride", "NewParameter", "StringIntEnumeration", GetParameterConversionInfo(compDef));
ConversionList.ObjectList = compDef.ParameterConversionOverrides;
}
}
}
public void LoadUI()
{
mEntries.Clear();
ConditionsListBox.Items.Clear();
EffectsListBox.Items.Clear();
mTopVersion.Clear();
bool bHideObsolete = HideObsoleteCheckBox.Checked;
foreach (ConditionDefinition item in mTriggerDefinition.ConditionDefinitions)
{
string key = item.Type;
if (mEntries.ContainsKey(key) == false)
{
mEntries[key] = new List <object>();
//ConditionsListBox.Items.Add(key);
}
mEntries[key].Add(item);
if (mTopVersion.ContainsKey(key) == false)
{
mTopVersion[key] = item.Version;
}
if (item.Version > mTopVersion[key])
{
mTopVersion[key] = item.Version;
}
}
foreach (EffectDefinition item in mTriggerDefinition.EffectDefinitions)
{
string key = item.Type;
if (mEntries.ContainsKey(key) == false)
{
mEntries[key] = new List <object>();
//EffectsListBox.Items.Add(key);
}
mEntries[key].Add(item);
if (mTopVersion.ContainsKey(key) == false)
{
mTopVersion[key] = item.Version;
}
if (item.Version > mTopVersion[key])
{
mTopVersion[key] = item.Version;
}
}
Dictionary <string, int> .Enumerator it = mTopVersion.GetEnumerator();
while (it.MoveNext())
{
foreach (object entry in mEntries[it.Current.Key])
{
if (entry is ConditionDefinition)
{
ConditionDefinition def = entry as ConditionDefinition;
if (def.Version == it.Current.Value)
{
if (bHideObsolete && def.Obsolete == true)
{
continue;
}
else
{
ConditionsListBox.Items.Add(it.Current.Key);
}
}
}
else if (entry is EffectDefinition)
{
EffectDefinition def = entry as EffectDefinition;
if (def.Version == it.Current.Value)
{
if (bHideObsolete && def.Obsolete == true)
{
continue;
}
else
{
EffectsListBox.Items.Add(it.Current.Key);
}
}
}
}
}
ConditionsListBox.Sorted = true;
EffectsListBox.Sorted = true;
}
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);
}
