private void OnConsoleVideoMode(string arguments)
{
if (!string.IsNullOrEmpty(arguments))
{
try
{
Vec2I mode = Vec2I.Parse(arguments);
if (EngineApp.Instance.FullScreen && !DisplaySettings.VideoModeExists(mode))
{
string text = string.Format("Cannot change screen resolution to \"{0}x{1}\". " +
"This resolution is not supported by the system.", mode.X, mode.Y);
Log.Warning(text);
return;
}
EngineApp.Instance.VideoMode = mode;
}
catch (Exception ex)
{
Log.Warning(ex.Message);
}
}
else
{
Print(string.Format("Value: \"{0}\"", EngineApp.Instance.VideoMode));
}
}
void ChangeVideoMode()
{
Vec2I size;
{
size = EngineApp.Instance.VideoMode;
if (comboBoxResolution.SelectedIndex != -1)
{
string s = (string)(comboBoxResolution).SelectedItem;
s = s.Replace("x", " ");
size = Vec2I.Parse(s);
}
}
EngineApp.Instance.VideoMode = size;
}
private void MainForm_Load(object sender, EventArgs e)
{
//Engine.config parameters
string renderingSystemComponentName = "";
bool allowShaders = true;
bool depthBufferAccess = true;
string fullSceneAntialiasing = "";
RendererWorld.FilteringModes filtering = RendererWorld.FilteringModes.RecommendedSetting;
string renderTechnique = "";
bool fullScreen = true;
string videoMode = "";
bool multiMonitorMode = false;
bool verticalSync = true;
bool allowChangeDisplayFrequency = true;
string physicsSystemComponentName = "";
//bool physicsAllowHardwareAcceleration = false;
string soundSystemComponentName = "";
string language = "Autodetect";
bool localizeEngine = true;
bool localizeToolset = true;
string renderingDeviceName = "";
int renderingDeviceIndex = 0;
//load from Deployment.config
if (VirtualFileSystem.Deployed)
{
if (!string.IsNullOrEmpty(VirtualFileSystem.DeploymentParameters.DefaultLanguage))
{
language = VirtualFileSystem.DeploymentParameters.DefaultLanguage;
}
}
//load from Engine.config
{
string error;
TextBlock block = TextBlockUtils.LoadFromRealFile(
VirtualFileSystem.GetRealPathByVirtual("user:Configs/Engine.config"),
out error);
if (block != null)
{
//Renderer
TextBlock rendererBlock = block.FindChild("Renderer");
if (rendererBlock != null)
{
renderingSystemComponentName = rendererBlock.GetAttribute("implementationComponent");
if (rendererBlock.IsAttributeExist("renderingDeviceName"))
{
renderingDeviceName = rendererBlock.GetAttribute("renderingDeviceName");
}
if (rendererBlock.IsAttributeExist("renderingDeviceIndex"))
{
renderingDeviceIndex = int.Parse(rendererBlock.GetAttribute("renderingDeviceIndex"));
}
if (rendererBlock.IsAttributeExist("allowShaders"))
{
allowShaders = bool.Parse(rendererBlock.GetAttribute("allowShaders"));
}
if (rendererBlock.IsAttributeExist("depthBufferAccess"))
{
depthBufferAccess = bool.Parse(rendererBlock.GetAttribute("depthBufferAccess"));
}
if (rendererBlock.IsAttributeExist("fullSceneAntialiasing"))
{
fullSceneAntialiasing = rendererBlock.GetAttribute("fullSceneAntialiasing");
}
if (rendererBlock.IsAttributeExist("filtering"))
{
try
{
filtering = (RendererWorld.FilteringModes)
Enum.Parse(typeof(RendererWorld.FilteringModes),
rendererBlock.GetAttribute("filtering"));
}
catch { }
}
if (rendererBlock.IsAttributeExist("renderTechnique"))
{
renderTechnique = rendererBlock.GetAttribute("renderTechnique");
}
if (rendererBlock.IsAttributeExist("fullScreen"))
{
fullScreen = bool.Parse(rendererBlock.GetAttribute("fullScreen"));
}
if (rendererBlock.IsAttributeExist("videoMode"))
{
videoMode = rendererBlock.GetAttribute("videoMode");
}
if (rendererBlock.IsAttributeExist("multiMonitorMode"))
{
multiMonitorMode = bool.Parse(rendererBlock.GetAttribute("multiMonitorMode"));
}
if (rendererBlock.IsAttributeExist("verticalSync"))
{
verticalSync = bool.Parse(rendererBlock.GetAttribute("verticalSync"));
}
if (rendererBlock.IsAttributeExist("allowChangeDisplayFrequency"))
{
allowChangeDisplayFrequency = bool.Parse(
rendererBlock.GetAttribute("allowChangeDisplayFrequency"));
}
}
//Physics system
TextBlock physicsSystemBlock = block.FindChild("PhysicsSystem");
if (physicsSystemBlock != null)
{
physicsSystemComponentName = physicsSystemBlock.GetAttribute("implementationComponent");
//if( physicsSystemBlock.IsAttributeExist( "allowHardwareAcceleration" ) )
//{
// physicsAllowHardwareAcceleration =
// bool.Parse( physicsSystemBlock.GetAttribute( "allowHardwareAcceleration" ) );
//}
}
//Sound system
TextBlock soundSystemBlock = block.FindChild("SoundSystem");
if (soundSystemBlock != null)
{
soundSystemComponentName = soundSystemBlock.GetAttribute("implementationComponent");
}
//Localization
TextBlock localizationBlock = block.FindChild("Localization");
if (localizationBlock != null)
{
if (localizationBlock.IsAttributeExist("language"))
{
language = localizationBlock.GetAttribute("language");
}
if (localizationBlock.IsAttributeExist("localizeEngine"))
{
localizeEngine = bool.Parse(localizationBlock.GetAttribute("localizeEngine"));
}
if (localizationBlock.IsAttributeExist("localizeToolset"))
{
localizeToolset = bool.Parse(localizationBlock.GetAttribute("localizeToolset"));
}
}
}
}
//init toolset language
if (localizeToolset)
{
if (!string.IsNullOrEmpty(language))
{
string language2 = language;
if (string.Compare(language2, "autodetect", true) == 0)
{
language2 = DetectLanguage();
}
string languageDirectory = Path.Combine(LanguageManager.LanguagesDirectory, language2);
string fileName = Path.Combine(languageDirectory, "Configurator.language");
ToolsLocalization.Init(fileName);
}
}
//fill render system
{
EngineComponentManager.ComponentInfo[] components = GetSortedComponentsByType(
EngineComponentManager.ComponentTypeFlags.RenderingSystem);
if (string.IsNullOrEmpty(renderingSystemComponentName))
{
//find component by default
foreach (EngineComponentManager.ComponentInfo component2 in components)
{
if (component2.IsEnabledByDefaultForThisPlatform())
{
renderingSystemComponentName = component2.Name;
break;
}
}
}
//rendering systems combo box
foreach (EngineComponentManager.ComponentInfo component in components)
{
string text = component.FullName;
if (component.IsEnabledByDefaultForThisPlatform())
{
text = string.Format(Translate("{0} (default)"), text);
}
int itemId = comboBoxRenderSystems.Items.Add(text);
if (renderingSystemComponentName == component.Name)
{
comboBoxRenderSystems.SelectedIndex = itemId;
}
}
if (comboBoxRenderSystems.Items.Count != 0 && comboBoxRenderSystems.SelectedIndex == -1)
{
comboBoxRenderSystems.SelectedIndex = 0;
}
//rendering device
{
if (comboBoxRenderingDevices.Items.Count > 1 && !string.IsNullOrEmpty(renderingDeviceName))
{
int deviceCountWithSelectedName = 0;
for (int n = 1; n < comboBoxRenderingDevices.Items.Count; n++)
{
string name = (string)comboBoxRenderingDevices.Items[n];
if (name == renderingDeviceName)
{
comboBoxRenderingDevices.SelectedIndex = n;
deviceCountWithSelectedName++;
}
}
if (deviceCountWithSelectedName > 1)
{
int comboBoxIndex = renderingDeviceIndex + 1;
if (comboBoxIndex < comboBoxRenderingDevices.Items.Count)
{
string name = (string)comboBoxRenderingDevices.Items[comboBoxIndex];
if (name == renderingDeviceName)
{
comboBoxRenderingDevices.SelectedIndex = comboBoxIndex;
}
}
}
}
if (comboBoxRenderingDevices.SelectedIndex == -1 && comboBoxRenderingDevices.Items.Count != 0)
{
comboBoxRenderingDevices.SelectedIndex = 0;
}
}
//allowShaders
checkBoxAllowShaders.Checked = allowShaders;
//depthBufferAccess
comboBoxDepthBufferAccess.Items.Add(Translate("No"));
comboBoxDepthBufferAccess.Items.Add(Translate("Yes"));
comboBoxDepthBufferAccess.SelectedIndex = depthBufferAccess ? 1 : 0;
//fullSceneAntialiasing
for (int n = 0; n < comboBoxAntialiasing.Items.Count; n++)
{
ComboBoxItem item = (ComboBoxItem)comboBoxAntialiasing.Items[n];
if (item.Identifier == fullSceneAntialiasing)
{
comboBoxAntialiasing.SelectedIndex = n;
}
}
if (comboBoxAntialiasing.SelectedIndex == -1)
{
comboBoxAntialiasing.SelectedIndex = 0;
}
//filtering
{
Type enumType = typeof(RendererWorld.FilteringModes);
LocalizedEnumConverter enumConverter = new LocalizedEnumConverter(enumType);
RendererWorld.FilteringModes[] values =
(RendererWorld.FilteringModes[])Enum.GetValues(enumType);
for (int n = 0; n < values.Length; n++)
{
RendererWorld.FilteringModes value = values[n];
int index = comboBoxFiltering.Items.Add(enumConverter.ConvertToString(value));
if (filtering == value)
{
comboBoxFiltering.SelectedIndex = index;
}
}
}
//renderTechnique
{
comboBoxRenderTechnique.Items.Add(new ComboBoxItem("RecommendedSetting", "Recommended setting"));
comboBoxRenderTechnique.Items.Add(new ComboBoxItem("Standard", "Low Dynamic Range (Standard)"));
comboBoxRenderTechnique.Items.Add(new ComboBoxItem("HDR", "64-bit High Dynamic Range (HDR)"));
for (int n = 0; n < comboBoxRenderTechnique.Items.Count; n++)
{
ComboBoxItem item = (ComboBoxItem)comboBoxRenderTechnique.Items[n];
if (item.Identifier == renderTechnique)
{
comboBoxRenderTechnique.SelectedIndex = n;
}
}
if (comboBoxRenderTechnique.SelectedIndex == -1)
{
comboBoxRenderTechnique.SelectedIndex = 0;
}
}
//video mode
{
comboBoxVideoMode.Items.Add(Translate("Current screen resolution"));
comboBoxVideoMode.SelectedIndex = 0;
comboBoxVideoMode.Items.Add(Translate("Use all displays (multi-monitor mode)"));
if (multiMonitorMode)
{
comboBoxVideoMode.SelectedIndex = 1;
}
foreach (Vec2I mode in DisplaySettings.VideoModes)
{
if (mode.X < 640)
{
continue;
}
comboBoxVideoMode.Items.Add(string.Format("{0}x{1}", mode.X, mode.Y));
if (mode.ToString() == videoMode)
{
comboBoxVideoMode.SelectedIndex = comboBoxVideoMode.Items.Count - 1;
}
}
if (!string.IsNullOrEmpty(videoMode) && comboBoxVideoMode.SelectedIndex == 0)
{
try
{
Vec2I mode = Vec2I.Parse(videoMode);
comboBoxVideoMode.Items.Add(string.Format("{0}x{1}", mode.X, mode.Y));
comboBoxVideoMode.SelectedIndex = comboBoxVideoMode.Items.Count - 1;
}
catch { }
}
}
//full screen
checkBoxFullScreen.Checked = fullScreen;
//vertical sync
checkBoxVerticalSync.Checked = verticalSync;
}
//fill physics system page
{
EngineComponentManager.ComponentInfo[] components = GetSortedComponentsByType(
EngineComponentManager.ComponentTypeFlags.PhysicsSystem);
if (string.IsNullOrEmpty(physicsSystemComponentName))
{
//find component by default
foreach (EngineComponentManager.ComponentInfo component2 in components)
{
if (component2.IsEnabledByDefaultForThisPlatform())
{
physicsSystemComponentName = component2.Name;
break;
}
}
}
//update combo box
foreach (EngineComponentManager.ComponentInfo component in components)
{
string text = component.FullName;
if (component.IsEnabledByDefaultForThisPlatform())
{
text = string.Format(Translate("{0} (default)"), text);
}
int itemId = comboBoxPhysicsSystems.Items.Add(text);
if (physicsSystemComponentName == component.Name)
{
comboBoxPhysicsSystems.SelectedIndex = itemId;
}
}
if (comboBoxPhysicsSystems.SelectedIndex == -1)
{
comboBoxPhysicsSystems.SelectedIndex = 0;
}
//if( checkBoxPhysicsAllowHardwareAcceleration.Enabled )
// checkBoxPhysicsAllowHardwareAcceleration.Checked = physicsAllowHardwareAcceleration;
}
//fill sound system page
{
EngineComponentManager.ComponentInfo[] components = GetSortedComponentsByType(
EngineComponentManager.ComponentTypeFlags.SoundSystem);
if (string.IsNullOrEmpty(soundSystemComponentName))
{
//find component by default
foreach (EngineComponentManager.ComponentInfo component2 in components)
{
if (component2.IsEnabledByDefaultForThisPlatform())
{
soundSystemComponentName = component2.Name;
break;
}
}
}
//update combo box
foreach (EngineComponentManager.ComponentInfo component in components)
{
string text = component.FullName;
if (component.IsEnabledByDefaultForThisPlatform())
{
text = string.Format(Translate("{0} (default)"), text);
}
int itemId = comboBoxSoundSystems.Items.Add(text);
if (soundSystemComponentName == component.Name)
{
comboBoxSoundSystems.SelectedIndex = itemId;
}
}
if (comboBoxSoundSystems.SelectedIndex == -1)
{
comboBoxSoundSystems.SelectedIndex = 0;
}
}
//fill localization page
{
List <string> languages = new List <string>();
{
languages.Add(Translate("Autodetect"));
string[] directories = VirtualDirectory.GetDirectories(LanguageManager.LanguagesDirectory,
"*.*", SearchOption.TopDirectoryOnly);
foreach (string directory in directories)
{
languages.Add(Path.GetFileNameWithoutExtension(directory));
}
}
foreach (string lang in languages)
{
int itemId = comboBoxLanguages.Items.Add(lang);
if (string.Compare(language, lang, true) == 0)
{
comboBoxLanguages.SelectedIndex = itemId;
}
}
if (comboBoxLanguages.SelectedIndex == -1)
{
comboBoxLanguages.SelectedIndex = 0;
}
checkBoxLocalizeEngine.Checked = localizeEngine;
checkBoxLocalizeToolset.Checked = localizeToolset;
}
Translate();
formLoaded = true;
}
