// Detects the underlying OS and runtime.
internal static void Init(ToolkitOptions options)
{
lock (InitLock)
{
if (!initialized)
{
RunningOnMono = DetectMono();
RunningOnWindows = DetectWindows();
if (!RunningOnWindows)
{
DetectUnix(out runningOnUnix, out runningOnLinux, out runningOnMacOS);
}
if ((runningOnLinux) || options.Backend == PlatformBackend.PreferX11)
{
RunningOnX11 = DetectX11();
}
initialized = true;
Debug.Print("Detected configuration: {0} / {1}",
RunningOnWindows ? "Windows" : RunningOnLinux ? "Linux" : RunningOnMacOS ? "MacOS" :
runningOnUnix ? "Unix" : RunningOnX11 ? "X11" : "Unknown Platform",
RunningOnMono ? "Mono" : ".Net");
}
}
}
public FastEngine(string windowName, int width, int height, int fps)
{
// disabling HiDPI support
var options = new ToolkitOptions
{
EnableHighResolution = false
};
OpenTK.Toolkit.Init(options);
window = new GameWindow (width, height, OpenTK.Graphics.GraphicsMode.Default, windowName);
// call it AFTER GameWindow initialization to avoid problems with Windows.Forms
this.Initialize (windowName, width, height, fps);
// create a new texture
texture = GL.GenTexture ();
// use the texure (as a 2d one)
GL.BindTexture (TextureTarget.Texture2D, texture);
GL.TexParameter (TextureTarget.Texture2D, TextureParameterName.TextureMinFilter, (int)TextureMinFilter.Linear);
GL.TexParameter (TextureTarget.Texture2D, TextureParameterName.TextureMagFilter, (int)TextureMagFilter.Linear);
this.textureRect = new Rectangle (0, 0, width, height);
GL.Enable (EnableCap.Texture2D);
window.Resize += this.Game_Resize;
window.RenderFrame += this.Game_RenderFrame;
// initialize OpenAL context (No ! do it lazily)
// audioContext = new AudioContext ();
}
// Detects the underlying OS and runtime.
internal static void Init(ToolkitOptions options)
{
lock (InitLock)
{
if (!initialized)
{
#if ANDROID || IPHONE
RunningOnMono = true;
#else
RunningOnMono = DetectMono();
RunningOnWindows = DetectWindows();
if (!RunningOnWindows)
{
DetectUnix(out runningOnUnix, out runningOnLinux, out runningOnMacOS);
}
//if (options.Backend == PlatformBackend.Default)
//{
// RunningOnSdl2 = DetectSdl2();
//}
if ((runningOnLinux && !RunningOnSdl2) || options.Backend == PlatformBackend.PreferX11)
{
RunningOnX11 = DetectX11();
}
initialized = true;
#endif
Debug.Print("Detected configuration: {0} / {1}",
RunningOnWindows ? "Windows" : RunningOnLinux ? "Linux" : RunningOnMacOS ? "MacOS" :
runningOnUnix ? "Unix" : RunningOnX11 ? "X11" : "Unknown Platform",
RunningOnMono ? "Mono" : ".Net");
}
}
}
static void LaunchExample(string type)
{
try
{
if (File.Exists("debug.log"))
File.Delete("debug.log");
if (File.Exists("trace.log"))
File.Delete("trace.log");
}
catch (Exception e)
{
Trace.WriteLine(String.Format("Could not access debug.log", e.ToString()));
}
ToolkitOptions options = ToolkitOptions.Default;
if (type.Contains("GLControl") || type.Contains("Form"))
{
// SDL does not currently support embedding in foreign windows
// such as GLControl. We need to use a native OpenTK.Platform
// backend in that case. This hack is specific to the example-browser
// architecture - you do not need to do anything like this in your
// own code (it will just work).
options = new ToolkitOptions
{
Backend = PlatformBackend.PreferNative
};
}
using (TextWriterTraceListener dbg = new TextWriterTraceListener("debug.log"))
using (Toolkit.Init(options))
{
Trace.Listeners.Add(dbg);
try
{
var example = Type.GetType(type);
if (example != null)
{
example.InvokeMember("Main",
BindingFlags.InvokeMethod | BindingFlags.Static |
BindingFlags.Public | BindingFlags.NonPublic,
null, null, null);
}
}
catch (Exception e)
{
Trace.WriteLine(String.Format("Exception occured in example {0}: {1}",
type, e.ToString()));
}
Trace.Listeners.Remove(dbg);
dbg.Flush();
dbg.Close();
}
}
/// <summary>
/// Initializes OpenTK with the specified options. Use this method
/// to influence the OpenTK.Platform implementation that will be used.
/// </summary>
/// <remarks>
/// <para>
/// You *must* call this method if you are combining OpenTK with a
/// third-party windowing toolkit (e.g. GTK#). In this case, this should be the
/// first method called by your application:
/// <code>
/// static void Main()
/// {
/// using (OpenTK.Toolkit.Init())
/// {
/// ...
/// }
/// }
/// </code>
/// </para>
/// <para>
/// The reason is that some toolkits do not configure the underlying platform
/// correctly or configure it in a way that is incompatible with OpenTK.
/// Calling this method first ensures that OpenTK is given the chance to
/// initialize itself and configure the platform correctly.
/// </para>
/// </remarks>
/// <param name="options">A <c>ToolkitOptions</c> instance
/// containing the desired options.</param>
/// <returns>
/// An IDisposable instance that you can use to dispose of the resources
/// consumed by OpenTK.
/// </returns>
public static Toolkit Init(ToolkitOptions options)
{
if (options == null)
{
throw new ArgumentNullException("options");
}
lock (InitLock)
{
if (!initialized)
{
initialized = true;
Configuration.Init(options);
Options = options;
// The actual initialization takes place in the
// platform-specific factory constructors.
toolkit = new Toolkit(new Factory());
}
return(toolkit);
}
}
protected override void InitPlugin()
{
base.InitPlugin();
mainThread = Thread.CurrentThread;
// Initialize OpenTK
{
bool inEditor = DualityApp.ExecEnvironment == DualityApp.ExecutionEnvironment.Editor;
ToolkitOptions options = new ToolkitOptions
{
// Prefer the native backend in the editor, because it supports GLControl. SDL doesn't.
Backend = inEditor ? PlatformBackend.PreferNative : PlatformBackend.Default,
// Disable High Resolution support in the editor, because it's not DPI-Aware
EnableHighResolution = !inEditor
};
Toolkit.Init(options);
}
// Register global / non-windowbound input devices
GlobalGamepadInputSource.UpdateAvailableDecives(DualityApp.Gamepads);
GlobalJoystickInputSource.UpdateAvailableDecives(DualityApp.Joysticks);
}
internal static void InitOpenTK()
{
if (openTKInitialized) return;
openTKInitialized = true;
Assembly execAssembly = Assembly.GetEntryAssembly() ?? typeof(DualityApp).Assembly;
string execAssemblyDir = PathOp.GetFullPath(PathOp.GetDirectoryName(execAssembly.Location));
bool inEditor = DualityApp.ExecEnvironment == DualityApp.ExecutionEnvironment.Editor;
bool isWindows =
Environment.OSVersion.Platform == PlatformID.Win32NT ||
Environment.OSVersion.Platform == PlatformID.Win32S ||
Environment.OSVersion.Platform == PlatformID.Win32Windows ||
Environment.OSVersion.Platform == PlatformID.WinCE;
bool genericFolderSDL = isWindows && !FileOp.Exists("SDL2.dll") && !FileOp.Exists(PathOp.Combine(execAssemblyDir, "SDL2.dll"));
ToolkitOptions options = new ToolkitOptions
{
// Prefer the native backend in the editor, because it supports GLControl. SDL doesn't.
// Also, never use SDL if it isn't in the local game folder, because it might be in PATH on some machines.
Backend = (inEditor || genericFolderSDL) ? PlatformBackend.PreferNative : PlatformBackend.Default,
// Disable High Resolution support in the editor, because it's not DPI-Aware
EnableHighResolution = !inEditor
};
Log.Core.Write("Initializing OpenTK...");
Log.Core.PushIndent();
Log.Core.Write(
"Platform Backend: {0}" + Environment.NewLine +
"EnableHighResolution: {1}",
options.Backend,
options.EnableHighResolution);
Toolkit.Init(options);
Log.Core.PopIndent();
}
// Detects the underlying OS and runtime.
internal static void Init(ToolkitOptions options)
{
lock (InitLock)
{
if (!initialized)
{
#if ANDROID
runningOnMono = true;
runningOnAnroid = true;
#elif IPHONE
runningOnMono = true;
runningOnIOS = true;
#else
runningOnMono = DetectMono();
runningOnWindows = DetectWindows();
if (!runningOnWindows)
{
DetectUnix(out runningOnUnix, out runningOnLinux, out runningOnMacOS);
}
if (options.Backend == PlatformBackend.Default)
{
RunningOnSdl2 = DetectSdl2();
}
if ((runningOnLinux && !RunningOnSdl2) || options.Backend == PlatformBackend.PreferX11)
{
runningOnX11 = DetectX11();
}
initialized = true;
#endif
Debug.Print("Detected configuration: {0} / {1}",
RunningOnWindows ? "Windows" : RunningOnLinux ? "Linux" : RunningOnMacOS ? "MacOS" :
runningOnUnix ? "Unix" : RunningOnX11 ? "X11" : "Unknown Platform",
RunningOnMono ? "Mono" : ".Net");
}
}
}
static ToolkitOptions()
{
Default = new ToolkitOptions();
}
static ToolkitOptions()
{
Default = new ToolkitOptions();
Default.EnableHighResolution = true;
}
/// <summary>
/// Initializes OpenTK with the specified options. Use this method
/// to influence the OpenTK.Platform implementation that will be used.
/// </summary>
/// <remarks>
/// <para>
/// You *must* call this method if you are combining OpenTK with a
/// third-party windowing toolkit (e.g. GTK#). In this case, this should be the
/// first method called by your application:
/// <code>
/// static void Main()
/// {
/// using (OpenTK.Toolkit.Init())
/// {
/// ...
/// }
/// }
/// </code>
/// </para>
/// <para>
/// The reason is that some toolkits do not configure the underlying platform
/// correctly or configure it in a way that is incompatible with OpenTK.
/// Calling this method first ensures that OpenTK is given the chance to
/// initialize itself and configure the platform correctly.
/// </para>
/// </remarks>
/// <param name="options">A <c>ToolkitOptions</c> instance
/// containing the desired options.</param>
/// <returns>
/// An IDisposable instance that you can use to dispose of the resources
/// consumed by OpenTK.
/// </returns>
public static Toolkit Init(ToolkitOptions options)
{
if (options == null)
throw new ArgumentNullException("options");
lock (InitLock)
{
if (!initialized)
{
initialized = true;
Configuration.Init(options);
Options = options;
// The actual initialization takes place in the
// platform-specific factory constructors.
toolkit = new Toolkit(new Factory());
}
return toolkit;
}
}
private static void Main(string[] args) {
#if !DEBUG
// Add handler for UI thread exceptions
Application.ThreadException += new ThreadExceptionEventHandler(CrashHandler.UIThreadException);
// Force all WinForms errors to go through handler
Application.SetUnhandledExceptionMode(UnhandledExceptionMode.CatchException);
// This handler is for catching non-UI thread exceptions
AppDomain.CurrentDomain.UnhandledException += new UnhandledExceptionEventHandler(CrashHandler.CurrentDomain_UnhandledException);
#endif
//Determine the current CPU architecture-
//ARM will generally only support OpenGL-ES
PortableExecutableKinds peKind;
typeof(object).Module.GetPEKind(out peKind, out CurrentCPUArchitecture);
Application.EnableVisualStyles();
Application.SetCompatibleTextRenderingDefault(false);
//--- determine the running environment ---
//I wonder if disabling this hack will stop the craashing on Linux....
CurrentlyRunningOnMono = Type.GetType("Mono.Runtime") != null;
//Doesn't appear to, but Mono have fixed the button appearance bug
CurrentlyRunningOnWindows = Environment.OSVersion.Platform == PlatformID.Win32S | Environment.OSVersion.Platform == PlatformID.Win32Windows | Environment.OSVersion.Platform == PlatformID.Win32NT;
CurrentHost = new Host();
try {
FileSystem = FileSystem.FromCommandLineArgs(args);
FileSystem.CreateFileSystem();
} catch (Exception ex) {
MessageBox.Show(Interface.GetInterfaceString("errors_filesystem_invalid") + Environment.NewLine + Environment.NewLine + ex.Message, Interface.GetInterfaceString("program_title"), MessageBoxButtons.OK, MessageBoxIcon.Hand);
return;
}
//Platform specific startup checks
if (CurrentlyRunningOnMono && !CurrentlyRunningOnWindows)
{
// --- Check if we're running as root, and prompt not to ---
if (getuid() == 0)
{
MessageBox.Show(
"You are currently running as the root user." + System.Environment.NewLine +
"This is a bad idea, please dont!", Interface.GetInterfaceString("program_title"), MessageBoxButtons.OK, MessageBoxIcon.Hand);
}
}
else
{
if (!System.IO.File.Exists(System.IO.Path.Combine(Environment.SystemDirectory, "OpenAL32.dll")))
{
MessageBox.Show(
"OpenAL was not found on your system, and will now be installed." + System.Environment.NewLine + System.Environment.NewLine +
"Please follow the install prompts.", Interface.GetInterfaceString("program_title"), MessageBoxButtons.OK, MessageBoxIcon.Hand);
ProcessStartInfo info = new ProcessStartInfo(System.IO.Path.Combine(FileSystem.DataFolder, "Dependencies\\Win32\\oalinst.exe"));
info.UseShellExecute = true;
if (Environment.OSVersion.Version.Major >= 6)
{
info.Verb = "runas";
}
try
{
System.Diagnostics.Process p = System.Diagnostics.Process.Start(info);
p.WaitForExit();
}
catch (Win32Exception)
{
MessageBox.Show(
"An error occured during OpenAL installation....", Interface.GetInterfaceString("program_title"), MessageBoxButtons.OK, MessageBoxIcon.Hand);
}
}
}
// --- load options and controls ---
Interface.LoadOptions();
//Switch between SDL2 and native backends; use native backend by default
var options = new ToolkitOptions();
if (Interface.CurrentOptions.PreferNativeBackend)
{
options.Backend = PlatformBackend.PreferNative;
}
Toolkit.Init(options);
// --- load language ---
{
string folder = Program.FileSystem.GetDataFolder("Languages");
try
{
string[] LanguageFiles = Directory.GetFiles(folder, "*.cfg");
foreach (var File in LanguageFiles)
{
Interface.AddLanguage(File);
}
}
catch
{
MessageBox.Show(@"An error occured whilst attempting to load the default language files.");
//Environment.Exit(0);
}
}
Interface.LoadControls(null, out Interface.CurrentControls);
{
string folder = Program.FileSystem.GetDataFolder("Controls");
string file = OpenBveApi.Path.CombineFile(folder, "Default keyboard assignment.controls");
Interface.Control[] controls;
Interface.LoadControls(file, out controls);
Interface.AddControls(ref Interface.CurrentControls, controls);
}
// --- check the command-line arguments for route and train ---
formMain.MainDialogResult result = new formMain.MainDialogResult();
CommandLine.ParseArguments(args, ref result);
// --- check whether route and train exist ---
if (result.RouteFile != null) {
if (!System.IO.File.Exists(result.RouteFile))
{
result.RouteFile = null;
}
}
if (result.TrainFolder != null) {
if (!System.IO.Directory.Exists(result.TrainFolder)) {
result.TrainFolder = null;
}
}
// --- if a route was provided but no train, try to use the route default ---
if (result.RouteFile != null & result.TrainFolder == null) {
bool isRW = string.Equals(System.IO.Path.GetExtension(result.RouteFile), ".rw", StringComparison.OrdinalIgnoreCase);
CsvRwRouteParser.ParseRoute(result.RouteFile, isRW, result.RouteEncoding, null, null, null, true);
if (!string.IsNullOrEmpty(Game.TrainName)) {
string folder = System.IO.Path.GetDirectoryName(result.RouteFile);
while (true) {
string trainFolder = OpenBveApi.Path.CombineDirectory(folder, "Train");
if (System.IO.Directory.Exists(trainFolder)) {
folder = OpenBveApi.Path.CombineDirectory(trainFolder, Game.TrainName);
if (System.IO.Directory.Exists(folder)) {
string file = OpenBveApi.Path.CombineFile(folder, "train.dat");
if (System.IO.File.Exists(file)) {
result.TrainFolder = folder;
result.TrainEncoding = System.Text.Encoding.UTF8;
for (int j = 0; j < Interface.CurrentOptions.TrainEncodings.Length; j++) {
if (string.Compare(Interface.CurrentOptions.TrainEncodings[j].Value, result.TrainFolder, StringComparison.InvariantCultureIgnoreCase) == 0) {
result.TrainEncoding = System.Text.Encoding.GetEncoding(Interface.CurrentOptions.TrainEncodings[j].Codepage);
break;
}
}
}
} break;
}
if (folder == null) continue;
System.IO.DirectoryInfo info = System.IO.Directory.GetParent(folder);
if (info != null) {
folder = info.FullName;
} else {
break;
}
}
}
Game.Reset(false);
}
// --- show the main menu if necessary ---
if (result.RouteFile == null | result.TrainFolder == null) {
Joysticks.RefreshJoysticks();
// end HACK //
result = formMain.ShowMainDialog(result);
} else {
result.Start = true;
//Apply translations
Interface.SetInGameLanguage(Interface.CurrentLanguageCode);
}
// --- start the actual program ---
if (result.Start) {
if (Initialize()) {
#if !DEBUG
try {
#endif
MainLoop.StartLoopEx(result);
#if !DEBUG
} catch (Exception ex) {
bool found = false;
//Thread.Sleep(20);
for (int i = 0; i < TrainManager.Trains.Length; i++) {
if (TrainManager.Trains[i] != null && TrainManager.Trains[i].Plugin != null) {
if (TrainManager.Trains[i].Plugin.LastException != null) {
CrashHandler.LoadingCrash(ex.Message, true);
MessageBox.Show("The train plugin " + TrainManager.Trains[i].Plugin.PluginTitle + " caused a runtime exception: " + TrainManager.Trains[i].Plugin.LastException.Message, Application.ProductName, MessageBoxButtons.OK, MessageBoxIcon.Hand);
found = true;
RestartArguments = "";
break;
}
}
}
if (!found)
{
MessageBox.Show("The route and train loader encountered the following critical error: " + Environment.NewLine + ex.Message, Application.ProductName, MessageBoxButtons.OK, MessageBoxIcon.Error);
CrashHandler.LoadingCrash(ex.ToString(), false);
RestartArguments = "";
}
}
#endif
}
Deinitialize();
}
// --- restart the program if necessary ---
if (RestartArguments != null) {
string arguments;
if (FileSystem.RestartArguments.Length != 0 & RestartArguments.Length != 0) {
arguments = FileSystem.RestartArguments + " " + RestartArguments;
} else {
arguments = FileSystem.RestartArguments + RestartArguments;
}
try {
System.Diagnostics.Process.Start(FileSystem.RestartProcess, arguments);
} catch (Exception ex) {
MessageBox.Show(ex.Message + "\n\nProcess = " + FileSystem.RestartProcess + "\nArguments = " + arguments, Application.ProductName, MessageBoxButtons.OK, MessageBoxIcon.Error);
}
}
}
static ToolkitOptions()
{
Default = new ToolkitOptions();
Default.EnableHighResolution = true;
}