mirror of
https://github.com/Ryujinx/Opentk.git
synced 2024-12-26 04:45:38 +00:00
774ebd1df7
We can use DllImports for OpenGL functions <= v1.1 on all platforms, including Windows. This allows us to reduce the number of required GetProcAddress calls by 474, reducing startup time and memory consumption. This setting can be turned off through Settings.Legacy.UseDllImports and UseWindowsCompatibleGL.
222 lines
10 KiB
C#
222 lines
10 KiB
C#
#region --- License ---
|
|
/* Copyright (c) 2006, 2007 Stefanos Apostolopoulos
|
|
* See license.txt for license info
|
|
*/
|
|
#endregion
|
|
|
|
using System;
|
|
using System.IO;
|
|
using System.Runtime.Serialization;
|
|
using System.Runtime.Serialization.Formatters.Binary;
|
|
|
|
namespace Bind
|
|
{
|
|
[Serializable]
|
|
class Settings
|
|
{
|
|
// Disable BeforeFieldInit.
|
|
public Settings()
|
|
{
|
|
}
|
|
|
|
public string DefaultInputPath = "../../../Source/Bind/Specifications";
|
|
public string DefaultOutputPath = "../../../Source/OpenTK/Graphics/OpenGL";
|
|
public string DefaultOutputNamespace = "OpenTK.Graphics.OpenGL";
|
|
public string DefaultDocPath = "../../../Source/Bind/Specifications/Docs";
|
|
public string DefaultFallbackDocPath = "../../../Source/Bind/Specifications/Docs/GL";
|
|
public string DefaultLicenseFile = "License.txt";
|
|
public string DefaultOverridesFile = "GL2/gloverrides.xml";
|
|
public string DefaultLanguageTypeMapFile = "csharp.tm";
|
|
public string DefaultKeywordEscapeCharacter = "@";
|
|
public string DefaultImportsFile = "Core.cs";
|
|
public string DefaultDelegatesFile = "Delegates.cs";
|
|
public string DefaultEnumsFile = "Enums.cs";
|
|
public string DefaultWrappersFile = "GL.cs";
|
|
public Legacy DefaultCompatibility = Legacy.NoDropMultipleTokens;
|
|
|
|
string inputPath, outputPath, outputNamespace, docPath, fallbackDocPath, licenseFile, overridesFile,
|
|
languageTypeMapFile, keywordEscapeCharacter, importsFile, delegatesFile, enumsFile,
|
|
wrappersFile;
|
|
Nullable<Legacy> compatibility;
|
|
public string InputPath { get { return inputPath ?? DefaultInputPath; } set { inputPath = value; } }
|
|
public string OutputPath { get { return outputPath ?? DefaultOutputPath; } set { outputPath = value; } }
|
|
public string OutputNamespace { get { return outputNamespace ?? DefaultOutputNamespace; } set { outputNamespace = value; } }
|
|
public string DocPath { get { return docPath ?? DefaultDocPath; } set { docPath = value; } }
|
|
public string FallbackDocPath { get { return fallbackDocPath ?? DefaultFallbackDocPath; } set { fallbackDocPath = value; } }
|
|
public string LicenseFile { get { return licenseFile ?? DefaultLicenseFile; } set { licenseFile = value; } }
|
|
public string OverridesFile { get { return overridesFile ?? DefaultOverridesFile; } set { overridesFile = value; } }
|
|
public string LanguageTypeMapFile { get { return languageTypeMapFile ?? DefaultLanguageTypeMapFile; } set { languageTypeMapFile = value; } }
|
|
public string KeywordEscapeCharacter { get { return keywordEscapeCharacter ?? DefaultKeywordEscapeCharacter; } set { keywordEscapeCharacter = value; } }
|
|
public string ImportsFile { get { return importsFile ?? DefaultImportsFile; } set { importsFile = value; } }
|
|
public string DelegatesFile { get { return delegatesFile ?? DefaultDelegatesFile; } set { delegatesFile = value; } }
|
|
public string EnumsFile { get { return enumsFile ?? DefaultEnumsFile; } set { enumsFile = value; } }
|
|
public string WrappersFile { get { return wrappersFile ?? DefaultWrappersFile; } set { wrappersFile = value; } }
|
|
public Legacy Compatibility { get { return compatibility ?? DefaultCompatibility; } set { compatibility = value; } }
|
|
|
|
public string GLClass = "GL"; // Needed by Glu for the AuxEnumsClass. Can be set through -gl:"xxx".
|
|
public string OutputClass = "GL"; // The real output class. Can be set through -class:"xxx".
|
|
public string FunctionPrefix = "gl";
|
|
public string ConstantPrefix = "GL_";
|
|
public string EnumPrefix = "";
|
|
public string NamespaceSeparator = ".";
|
|
|
|
// TODO: This code is too fragile.
|
|
// Old enums code:
|
|
public string normalEnumsClassOverride = null;
|
|
public string NestedEnumsClass = "Enums";
|
|
public string NormalEnumsClass
|
|
{
|
|
get
|
|
{
|
|
return
|
|
normalEnumsClassOverride == null ?
|
|
String.IsNullOrEmpty(NestedEnumsClass) ? OutputClass : OutputClass + NamespaceSeparator + NestedEnumsClass :
|
|
normalEnumsClassOverride;
|
|
}
|
|
}
|
|
|
|
public string AuxEnumsClass
|
|
{
|
|
get { return GLClass + NamespaceSeparator + NestedEnumsClass; }
|
|
}
|
|
|
|
public string EnumsOutput
|
|
{
|
|
get
|
|
{
|
|
if ((Compatibility & Legacy.NestedEnums) != Legacy.None)
|
|
return OutputNamespace + NamespaceSeparator + OutputClass + NamespaceSeparator + NestedEnumsClass;
|
|
else
|
|
return String.IsNullOrEmpty(EnumsNamespace) ? OutputNamespace : OutputNamespace + NamespaceSeparator + EnumsNamespace;
|
|
}
|
|
}
|
|
|
|
public string EnumsAuxOutput
|
|
{
|
|
get
|
|
{
|
|
if ((Compatibility & Legacy.NestedEnums) != Legacy.None)
|
|
return OutputNamespace + NamespaceSeparator + GLClass + NamespaceSeparator + NestedEnumsClass;
|
|
else
|
|
return OutputNamespace + NamespaceSeparator + EnumsNamespace;
|
|
}
|
|
}
|
|
|
|
// New enums namespace (don't use a nested class).
|
|
public string EnumsNamespace = null;// = "Enums";
|
|
|
|
public string DelegatesClass = "Delegates";
|
|
public string ImportsClass = "Core";
|
|
|
|
/// <summary>
|
|
/// The name of the C# enum which holds every single OpenGL enum (for compatibility purposes).
|
|
/// </summary>
|
|
public string CompleteEnumName = "All";
|
|
[Flags]
|
|
public enum Legacy
|
|
{
|
|
/// <summary>Default value.</summary>
|
|
None = 0x00,
|
|
/// <summary>Leave enums as plain const ints.</summary>
|
|
ConstIntEnums = 0x01,
|
|
/// <summary>Leave enums in the default STRANGE_capitalization.ALL_CAPS form.</summary>
|
|
NoAdvancedEnumProcessing = 0x02,
|
|
/// <summary>Don't allow unsafe wrappers in the interface.</summary>
|
|
NoPublicUnsafeFunctions = 0x04,
|
|
/// <summary>Don't trim the [fdisub]v? endings from functions.</summary>
|
|
NoTrimFunctionEnding = NoPublicUnsafeFunctions,
|
|
/// <summary>Don't trim the [gl|wgl|glx|glu] prefixes from functions.</summary>
|
|
NoTrimFunctionPrefix = 0x08,
|
|
/// <summary>
|
|
/// Don't spearate functions in different namespaces, according to their extension category
|
|
/// (e.g. GL.Arb, GL.Ext etc).
|
|
/// </summary>
|
|
NoSeparateFunctionNamespaces = 0x10,
|
|
/// <summary>
|
|
/// No public void* parameters (should always be enabled. Disable at your own risk. Disabling
|
|
/// means that BitmapData.Scan0 and other .Net properties/functions must be cast to (void*)
|
|
/// explicitly, to avoid the 'object' overload from being called.)
|
|
/// </summary>
|
|
TurnVoidPointersToIntPtr = 0x20,
|
|
/// <summary>Generate all possible permutations for ref/array/pointer parameters.</summary>
|
|
GenerateAllPermutations = 0x40,
|
|
/// <summary>Nest enums inside the GL class.</summary>
|
|
NestedEnums = 0x80,
|
|
/// <summary>Turn GLboolean to int (Boolean enum), not bool.</summary>
|
|
NoBoolParameters = 0x100,
|
|
/// <summary>Keep all enum tokens, even if same value (e.g. FooARB, FooEXT and FooSGI).</summary>
|
|
NoDropMultipleTokens = 0x200,
|
|
/// <summary>Do not emit inline documentation.</summary>
|
|
NoDocumentation = 0x400,
|
|
/// <summary>Disables ErrorHelper generation.</summary>
|
|
NoDebugHelpers = 0x800,
|
|
/// <summary>Generate both typed and untyped ("All") signatures for enum parameters.</summary>
|
|
KeepUntypedEnums = 0x1000,
|
|
/// <summary>Marks deprecated functions as [Obsolete]</summary>
|
|
AddDeprecationWarnings = 0x2000,
|
|
/// <summary>Use DllImport declaration for core functions (do not generate entry point slots)</summary>
|
|
UseDllImports = 0x4000,
|
|
/// <summary>
|
|
/// Use in conjuction with UseDllImports, to create
|
|
/// bindings that are compatible with opengl32.dll on Windows.
|
|
/// This uses DllImports up to GL 1.1 and function pointers
|
|
/// for higher versions.
|
|
/// </summary>
|
|
UseWindowsCompatibleGL = 0x8000,
|
|
Tao = ConstIntEnums |
|
|
NoAdvancedEnumProcessing |
|
|
NoPublicUnsafeFunctions |
|
|
NoTrimFunctionEnding |
|
|
NoTrimFunctionPrefix |
|
|
NoSeparateFunctionNamespaces |
|
|
TurnVoidPointersToIntPtr |
|
|
NestedEnums |
|
|
NoBoolParameters |
|
|
NoDropMultipleTokens |
|
|
NoDocumentation |
|
|
NoDebugHelpers,
|
|
/*GenerateAllPermutations,*/
|
|
}
|
|
|
|
// Returns true if flag is enabled.
|
|
public bool IsEnabled(Legacy flag)
|
|
{
|
|
return (Compatibility & flag) != (Legacy)0;
|
|
}
|
|
|
|
// Enables the specified flag.
|
|
public void Enable(Legacy flag)
|
|
{
|
|
Compatibility |= flag;
|
|
}
|
|
|
|
// Disables the specified flag.
|
|
public void Disable(Legacy flag)
|
|
{
|
|
Compatibility &= ~flag;
|
|
}
|
|
|
|
/// <summary>True if multiple tokens should be dropped (e.g. FooARB, FooEXT and FooSGI).</summary>
|
|
public bool DropMultipleTokens
|
|
{
|
|
get { return (Compatibility & Legacy.NoDropMultipleTokens) == Legacy.None; }
|
|
set { if (value) Compatibility |= Legacy.NoDropMultipleTokens; else Compatibility &= ~Legacy.NoDropMultipleTokens; }
|
|
}
|
|
|
|
public string WindowsGDI = "OpenTK.Platform.Windows.API";
|
|
|
|
public GeneratorLanguage Language { get; set; }
|
|
|
|
public Settings Clone()
|
|
{
|
|
IFormatter formatter = new BinaryFormatter();
|
|
using (var stream = new MemoryStream())
|
|
{
|
|
formatter.Serialize(stream, this);
|
|
stream.Seek(0, SeekOrigin.Begin);
|
|
return (Settings)formatter.Deserialize(stream);
|
|
}
|
|
}
|
|
}
|
|
}
|