private static bool IsCompatibleMethod(RegistryAssemblyConfiguration cfg, MethodDefinition method)
{
// Methods required by OpenGL.Net
// Note: code should test actual method existence, since they may not loaded for specific profiles
switch (method.Name)
{
case "GetString":
return(true);
}
bool compatible = false;
int featureAttribCount = 0;
foreach (CustomAttribute customAttrib in method.CustomAttributes)
{
switch (customAttrib.AttributeType.Name)
{
case "RequiredByFeatureAttribute":
compatible |= IsCompatible_RequiredAttribute(cfg, customAttrib);
featureAttribCount++;
break;
case "RemovedByFeatureAttribute":
if (IsCompatible_RemovedAttribute(cfg, customAttrib) == false)
{
return(false);
}
featureAttribCount++;
break;
}
}
return(compatible || featureAttribCount == 0);
}
private static bool IsCompatibleField(RegistryAssemblyConfiguration cfg, FieldDefinition field)
{
bool compatible = false;
int featureAttribCount = 0;
foreach (CustomAttribute customAttrib in field.CustomAttributes)
{
switch (customAttrib.AttributeType.Name)
{
case "RequiredByFeatureAttribute":
compatible |= IsCompatible_RequiredAttribute(cfg, customAttrib);
featureAttribCount++;
break;
case "RemovedByFeatureAttribute":
if (IsCompatible_RemovedAttribute(cfg, customAttrib) == false)
{
return(false);
}
break;
}
}
return(compatible || featureAttribCount == 0);
}
private static bool IsCompatible_RequiredAttribute(RegistryAssemblyConfiguration cfg, CustomAttribute customAttrib)
{
string featureName = customAttrib.ConstructorArguments[0].Value as string;
KhronosVersion attribVersion = KhronosVersion.ParseFeature(featureName, false);
// Match at least one feature?
bool compatible = false;
foreach (RegistryAssemblyConfiguration.VersionRange cfgFeature in cfg.Features)
{
if (cfgFeature.Api != null)
{
CustomAttributeNamedArgument apiArg = customAttrib.Fields.FirstOrDefault(delegate(CustomAttributeNamedArgument item) { return(item.Name == "Api"); });
string apiRegex = apiArg.Argument.Value != null ? apiArg.Argument.Value as string : "gl";
if (Regex.IsMatch(cfgFeature.Api, "^(" + apiRegex + ")$"))
{
compatible |= true;
}
}
if (cfgFeature.Profile != null)
{
CustomAttributeNamedArgument apiArg = customAttrib.Fields.FirstOrDefault(delegate(CustomAttributeNamedArgument item) { return(item.Name == "Profile"); });
string apiRegex = apiArg.Argument.Value != null ? apiArg.Argument.Value as string : null;
if (apiRegex != null)
{
compatible &= Regex.IsMatch(cfgFeature.Profile, "^(" + apiRegex + ")$");
}
}
if (attribVersion != null)
{
KhronosVersion minVersion = /*cfgFeature.MinApiVersion != null ? KhronosVersion.Parse(cfgFeature.MinApiVersion) :*/ null;
KhronosVersion maxVersion = /*cfgFeature.MaxApiVersion != null ? KhronosVersion.Parse(cfgFeature.MaxApiVersion) :*/ null;
// API version
if (minVersion != null && attribVersion < minVersion)
{
return(false);
}
if (maxVersion != null && attribVersion > maxVersion)
{
return(false);
}
}
else
{
// Extension (Api must match)
if (compatible)
{
compatible &= cfg.Extensions.Contains(featureName);
}
}
}
return(compatible);
}
private static bool IsCompatible_RemovedAttribute(RegistryAssemblyConfiguration cfg, CustomAttribute customAttrib)
{
string featureName = customAttrib.ConstructorArguments[0].Value as string;
KhronosVersion attribVersion = KhronosVersion.ParseFeature(featureName, false);
if (attribVersion == null)
{
return(true);
}
return(cfg.Features.All(cfgFeature => cfgFeature.Api == null || cfgFeature.Api != attribVersion.Api));
}
private static bool IsCompatible_RemovedAttribute(RegistryAssemblyConfiguration cfg, CustomAttribute customAttrib)
{
string featureName = customAttrib.ConstructorArguments[0].Value as string;
KhronosVersion attribVersion = KhronosVersion.ParseFeature(featureName, false);
if (attribVersion != null)
{
foreach (RegistryAssemblyConfiguration.VersionRange cfgFeature in cfg.Features)
{
if (cfgFeature.Api != null && cfgFeature.Api == attribVersion.Api)
{
return(false);
}
}
}
return(true);
}
private static void CleanTypeDefinition(TypeDefinition type, RegistryAssemblyConfiguration cfg)
{
// Remove fields
List <FieldDefinition> removedFields = new List <FieldDefinition>();
foreach (FieldDefinition field in type.Fields)
{
if (IsCompatibleField(cfg, field) == false)
{
// Console.WriteLine(" - Remove {0}", field.Name);
removedFields.Add(field);
}
}
if (removedFields.Count > 0)
{
Console.WriteLine("- Removed {0} constants from {1}", removedFields.Count, type.FullName);
foreach (FieldDefinition field in removedFields)
{
type.Fields.Remove(field);
}
}
// Remove methods
List <MethodDefinition> removedMethods = new List <MethodDefinition>();
foreach (MethodDefinition method in type.Methods)
{
if (IsCompatibleMethod(cfg, method) == false)
{
// Console.WriteLine(" - Remove {0}", method.ToString());
removedMethods.Add(method);
}
}
if (removedMethods.Count > 0)
{
Console.WriteLine("- Removing {0} methods from {1}", removedMethods.Count, type.FullName);
foreach (MethodDefinition method in removedMethods)
{
RemoveMethod(type, method);
}
}
}
/// <summary>
/// Application entry point.
/// </summary>
/// <param name="args">
/// The command line invocation arguments.
/// </param>
static void Main(string[] args)
{
RegistryContext ctx;
RegistryProcessor glRegistryProcessor;
int index;
DummyStream = Array.FindIndex(args, delegate(string item) { return(item == "--dummy"); }) >= 0;
DocDisabled = Array.FindIndex(args, delegate(string item) { return(item == "--nodoc"); }) >= 0;
#region Assembly processing
if ((args.Length > 0) && ((index = Array.FindIndex(args, delegate(string item) { return(item == "--assembly"); })) >= 0))
{
string assemblyPath = args[index + 1];
bool overwriteAssembly = Array.Exists(args, delegate(string item) { return(item.StartsWith("--assembly-overwrite")); });
bool profileOnlyOpts = Array.Exists(args, delegate(string item) { return(item.StartsWith("--profile-")); });
List <RegistryAssemblyConfiguration> cfgs = new List <RegistryAssemblyConfiguration>();
if (profileOnlyOpts == false)
{
cfgs.Add(RegistryAssemblyConfiguration.Load("BindingsGen.Profiles.CoreProfile.xml"));
cfgs.Add(RegistryAssemblyConfiguration.Load("BindingsGen.Profiles.ES2Profile.xml"));
cfgs.Add(RegistryAssemblyConfiguration.Load("BindingsGen.Profiles.SC2Profile.xml"));
}
else
{
if (Array.Exists(args, delegate(string item) { return(item.StartsWith("--profile-core")); }))
{
cfgs.Add(RegistryAssemblyConfiguration.Load("BindingsGen.Profiles.CoreProfile.xml"));
}
if (Array.Exists(args, delegate(string item) { return(item.StartsWith("--profile-es2")); }))
{
cfgs.Add(RegistryAssemblyConfiguration.Load("BindingsGen.Profiles.ES2Profile.xml"));
}
if (Array.Exists(args, delegate(string item) { return(item.StartsWith("--profile-sc2")); }))
{
cfgs.Add(RegistryAssemblyConfiguration.Load("BindingsGen.Profiles.SC2Profile.xml"));
}
}
foreach (RegistryAssemblyConfiguration cfg in cfgs)
{
try {
RegistryAssembly.CleanAssembly(assemblyPath, cfg, overwriteAssembly);
} catch (Exception exception) {
Console.WriteLine("Unable to process assembly: {0}.", exception.Message);
}
}
// Exclusive option
return;
}
#endregion
#region Log Maps
if ((args.Length > 0) && (Array.FindIndex(args, delegate(string item) { return(item == "--only-logmaps"); }) >= 0))
{
if ((args.Length == 1) || (Array.FindIndex(args, delegate(string item) { return(item == "--gl"); }) >= 0))
{
Console.WriteLine("Generating GL log map...");
ctx = new RegistryContext("Gl", Path.Combine(BasePath, "GLSpecs/gl.xml"));
glRegistryProcessor = new RegistryProcessor(ctx.Registry);
glRegistryProcessor.GenerateLogMap(ctx, Path.Combine(BasePath, "OpenGL.Net/KhronosLogMapGl.xml"));
}
if ((args.Length == 1) || (Array.FindIndex(args, delegate(string item) { return(item == "--wgl"); }) >= 0))
{
Console.WriteLine("Generating WGL log map...");
ctx = new RegistryContext("Wgl", Path.Combine(BasePath, "GLSpecs/wgl.xml"));
glRegistryProcessor = new RegistryProcessor(ctx.Registry);
glRegistryProcessor.GenerateLogMap(ctx, Path.Combine(BasePath, "OpenGL.Net/KhronosLogMapWgl.xml"));
}
if ((args.Length == 1) || (Array.FindIndex(args, delegate(string item) { return(item == "--glx"); }) >= 0))
{
Console.WriteLine("Generating GLX log map...");
ctx = new RegistryContext("Glx", Path.Combine(BasePath, "GLSpecs/glx.xml"));
glRegistryProcessor = new RegistryProcessor(ctx.Registry);
glRegistryProcessor.GenerateLogMap(ctx, Path.Combine(BasePath, "OpenGL.Net/KhronosLogMapGlx.xml"));
}
if ((args.Length == 1) || (Array.FindIndex(args, delegate(string item) { return(item == "--egl"); }) >= 0))
{
Console.WriteLine("Generating EGL log map...");
ctx = new RegistryContext("Egl", Path.Combine(BasePath, "GLSpecs/egl.xml"));
glRegistryProcessor = new RegistryProcessor(ctx.Registry);
glRegistryProcessor.GenerateLogMap(ctx, Path.Combine(BasePath, "OpenGL.Net/KhronosLogMapEgl.xml"));
}
// Exclusive option
return;
}
#endregion
// (Common) Documentation
RegistryDocumentation <RegistryDocumentationHandler_GL4> gl4Documentation = new RegistryDocumentation <RegistryDocumentationHandler_GL4>();
gl4Documentation.Api = "GL4";
if (DocDisabled == false)
{
gl4Documentation.ScanDocumentation(Path.Combine(BasePath, "Refpages/OpenGL/gl4"));
}
RegistryDocumentation <RegistryDocumentationHandler_GL2> gl2Documentation = new RegistryDocumentation <RegistryDocumentationHandler_GL2>();
gl2Documentation.Api = "GL2.1";
if (DocDisabled == false)
{
gl2Documentation.ScanDocumentation(Path.Combine(BasePath, "Refpages/OpenGL/gl2.1"));
}
// XML-based specifications
// OpenGL
if ((args.Length == 0) || (Array.FindIndex(args, delegate(string item) { return(item == "--gl"); }) >= 0))
{
// Additional ES documentation
RegistryDocumentation <RegistryDocumentationHandler_GL4> gles3Documentation = new RegistryDocumentation <RegistryDocumentationHandler_GL4>();
gles3Documentation.Api = "GLES3.2";
if (DocDisabled == false)
{
gles3Documentation.ScanDocumentation(Path.Combine(BasePath, "Refpages/OpenGL/es3"));
}
RegistryDocumentation <RegistryDocumentationHandler_GL2> gles1Documentation = new RegistryDocumentation <RegistryDocumentationHandler_GL2>();
gles1Documentation.Api = "GLES1.1";
if (DocDisabled == false)
{
gles1Documentation.ScanDocumentation(Path.Combine(BasePath, "Refpages/OpenGL/es1.1"));
}
Console.WriteLine("Loading GL specification...");
ctx = new RegistryContext("Gl", Path.Combine(BasePath, "GLSpecs/gl.xml"));
ctx.RefPages.Add(gl4Documentation);
ctx.RefPages.Add(gl2Documentation);
ctx.RefPages.Add(gles3Documentation);
ctx.RefPages.Add(gles1Documentation);
glRegistryProcessor = new RegistryProcessor(ctx.Registry);
GenerateCommandsAndEnums(glRegistryProcessor, ctx);
GenerateExtensionsSupportClass(glRegistryProcessor, ctx);
GenerateLimitsSupportClass(glRegistryProcessor, ctx);
GenerateVersionsSupportClass(glRegistryProcessor, ctx);
GenerateVbCommands(glRegistryProcessor, ctx);
glRegistryProcessor.GenerateLogMap(ctx, Path.Combine(BasePath, "OpenGL.Net/KhronosLogMapGl.xml"));
}
// OpenGL for Windows
if ((args.Length == 0) || (Array.FindIndex(args, delegate(string item) { return(item == "--wgl"); }) >= 0))
{
ctx = new RegistryContext("Wgl", Path.Combine(BasePath, "GLSpecs/wgl.xml"));
ctx.RefPages.Add(gl4Documentation);
ctx.RefPages.Add(gl2Documentation);
glRegistryProcessor = new RegistryProcessor(ctx.Registry);
GenerateCommandsAndEnums(glRegistryProcessor, ctx);
GenerateExtensionsSupportClass(glRegistryProcessor, ctx);
GenerateVersionsSupportClass(glRegistryProcessor, ctx);
GenerateVbCommands(glRegistryProcessor, ctx);
glRegistryProcessor.GenerateLogMap(ctx, Path.Combine(BasePath, "OpenGL.Net/KhronosLogMapWgl.xml"));
}
// OpenGL for Unix
if ((args.Length == 0) || (Array.FindIndex(args, delegate(string item) { return(item == "--glx"); }) >= 0))
{
ctx = new RegistryContext("Glx", Path.Combine(BasePath, "GLSpecs/glx.xml"));
ctx.RefPages.Add(gl4Documentation);
ctx.RefPages.Add(gl2Documentation);
glRegistryProcessor = new RegistryProcessor(ctx.Registry);
GenerateCommandsAndEnums(glRegistryProcessor, ctx);
GenerateExtensionsSupportClass(glRegistryProcessor, ctx);
GenerateVersionsSupportClass(glRegistryProcessor, ctx);
GenerateVbCommands(glRegistryProcessor, ctx);
glRegistryProcessor.GenerateLogMap(ctx, Path.Combine(BasePath, "OpenGL.Net/KhronosLogMapGlx.xml"));
}
// EGL
if ((args.Length == 0) || (Array.FindIndex(args, delegate(string item) { return(item == "--egl"); }) >= 0))
{
RegistryDocumentation <RegistryDocumentationHandler_EGL> eglDocumentation = new RegistryDocumentation <RegistryDocumentationHandler_EGL>();
eglDocumentation.Api = "EGL";
eglDocumentation.ScanDocumentation(Path.Combine(BasePath, "Refpages/EGL-Registry/sdk/docs/man"));
ctx = new RegistryContext("Egl", Path.Combine(BasePath, "GLSpecs/egl.xml"));
ctx.RefPages.Add(eglDocumentation);
glRegistryProcessor = new RegistryProcessor(ctx.Registry);
GenerateCommandsAndEnums(glRegistryProcessor, ctx);
GenerateExtensionsSupportClass(glRegistryProcessor, ctx);
GenerateVersionsSupportClass(glRegistryProcessor, ctx);
GenerateVbCommands(glRegistryProcessor, ctx);
glRegistryProcessor.GenerateLogMap(ctx, Path.Combine(BasePath, "OpenGL.Net/KhronosLogMapEgl.xml"));
}
// OpenWF
_OutputBasePath = "OpenWF.Net";
_Namespace = "OpenWF";
// OpenWF(C)
// Note: you must setup CLI to generate this bindings
if ((args.Length > 0) && (Array.FindIndex(args, delegate(string item) { return(item == "--wfc"); }) >= 0))
{
Header headRegistry = new Header("Wfc");
headRegistry.AppendHeader(Path.Combine(BasePath, "GLSpecs/WF/wfc.h"));
ctx = new RegistryContext("Wfc", headRegistry);
glRegistryProcessor = new RegistryProcessor(ctx.Registry, "OpenWF");
GenerateCommandsAndEnums(glRegistryProcessor, ctx);
GenerateExtensionsSupportClass(glRegistryProcessor, ctx);
GenerateVersionsSupportClass(glRegistryProcessor, ctx);
GenerateVbCommands(glRegistryProcessor, ctx);
}
// OpenWF(D)
if ((args.Length == 0) || (Array.FindIndex(args, delegate(string item) { return(item == "--wfd"); }) >= 0))
{
Header headRegistry = new Header("Wfd");
headRegistry.AppendHeader(Path.Combine(BasePath, "GLSpecs/WF/wfd.h"));
ctx = new RegistryContext("Wfd", headRegistry);
glRegistryProcessor = new RegistryProcessor(ctx.Registry, "OpenWF");
GenerateCommandsAndEnums(glRegistryProcessor, ctx);
GenerateExtensionsSupportClass(glRegistryProcessor, ctx);
GenerateVersionsSupportClass(glRegistryProcessor, ctx);
GenerateVbCommands(glRegistryProcessor, ctx);
}
}
public static void CleanAssembly(string path, RegistryAssemblyConfiguration cfg, bool overwrite)
{
Console.WriteLine("*** Generate assembly {0}", cfg.Name);
AssemblyDefinition assembly = AssemblyDefinition.ReadAssembly(path);
#region Enums
foreach (ModuleDefinition module in assembly.Modules)
{
List <TypeDefinition> removedTypes = new List <TypeDefinition>();
foreach (TypeDefinition type in module.Types)
{
if (type.IsEnum == false)
{
continue;
}
// Remove fields
List <FieldDefinition> removedFields = new List <FieldDefinition>();
foreach (FieldDefinition field in type.Fields)
{
if (IsCompatibleField(cfg, field) == false)
{
removedFields.Add(field);
}
}
// Console.WriteLine("- Removing {0} constants", removedFields.Count);
foreach (FieldDefinition field in removedFields)
{
// Console.WriteLine(" - {0}", field.Name);
type.Fields.Remove(field);
}
if (type.Fields.Count == 1)
{
removedTypes.Add(type);
}
}
Console.WriteLine("- Removing {0} enum types", removedTypes.Count);
foreach (TypeDefinition type in removedTypes)
{
// Console.WriteLine(" - {0}", field.Name);
module.Types.Remove(type);
}
}
#endregion
#region KhronosApi (Gl)
foreach (ModuleDefinition module in assembly.Modules)
{
foreach (TypeDefinition type in module.Types)
{
if (type.BaseType == null || type.BaseType.Name != "KhronosApi")
{
continue;
}
if (type.Name != "Gl")
{
continue;
}
CleanTypeDefinition(type, cfg);
TypeDefinition vbNestedType = type.NestedTypes.GetNestedType("VB");
if (vbNestedType != null)
{
CleanTypeDefinition(vbNestedType, cfg);
}
}
}
#endregion
// Export
string baseDirPath = Path.GetDirectoryName(path);
if (overwrite == false)
{
assembly.Write(Path.Combine(baseDirPath, String.Format("OpenGL.Net-{0}.dll", cfg.Name)));
}
else
{
assembly.Write(Path.Combine(baseDirPath, "OpenGL.Net.dll"));
}
}
private static void CleanTypeDefinition(TypeDefinition type, RegistryAssemblyConfiguration cfg)
{
// Remove fields
List <FieldDefinition> removedFields = new List <FieldDefinition>();
foreach (FieldDefinition field in type.Fields)
{
if (IsCompatibleField(cfg, field) == false)
{
// Console.WriteLine(" - Remove {0}", field.Name);
removedFields.Add(field);
}
}
if (removedFields.Count > 0)
{
Console.WriteLine("- Removed {0} constants from {1}", removedFields.Count, type.FullName);
foreach (FieldDefinition field in removedFields)
{
type.Fields.Remove(field);
}
}
// Remove methods (public static API)
List <MethodDefinition> removedMethods = new List <MethodDefinition>();
foreach (MethodDefinition method in type.Methods)
{
if (IsCompatibleMethod(cfg, method) == false)
{
// Console.WriteLine(" - Remove {0}", method.ToString());
removedMethods.Add(method);
}
}
foreach (MethodDefinition method in removedMethods)
{
type.Methods.Remove(method);
}
// Remove delegates
TypeDefinition delegatesNestedType = type.NestedTypes.GetNestedType("Delegates");
if (delegatesNestedType != null)
{
// Delegate fields
List <FieldDefinition> removedDelegateFields = new List <FieldDefinition>();
foreach (FieldDefinition field in delegatesNestedType.Fields)
{
if (IsCompatibleField(cfg, field) == false)
{
removedDelegateFields.Add(field);
}
}
foreach (FieldDefinition field in removedDelegateFields)
{
delegatesNestedType.Fields.Remove(field);
}
// Delegate types
List <TypeDefinition> removedDelegateTypes = new List <TypeDefinition>();
foreach (TypeDefinition nestedType in delegatesNestedType.NestedTypes)
{
if (IsCompatibleType(cfg, nestedType) == false)
{
removedDelegateTypes.Add(nestedType);
}
}
foreach (TypeDefinition nestedType in removedDelegateTypes)
{
delegatesNestedType.NestedTypes.Remove(nestedType);
}
}
}
/// <summary>
/// Application entry point.
/// </summary>
/// <param name="args">
/// The command line invocation arguments.
/// </param>
static void Main(string[] args)
{
RegistryContext ctx;
RegistryProcessor glRegistryProcessor;
int index;
DummyStream = Array.FindIndex(args, delegate(string item) { return(item == "--dummy"); }) >= 0;
DocDisabled = Array.FindIndex(args, delegate(string item) { return(item == "--nodoc"); }) >= 0;
#region Assembly processing
if ((args.Length > 0) && ((index = Array.FindIndex(args, delegate(string item) { return(item == "--assembly"); })) >= 0))
{
string assemblyPath = args[index + 1];
bool overwriteAssembly = Array.Exists(args, delegate(string item) { return(item.StartsWith("--assembly-overwrite")); });
bool profileOnlyOpts = Array.Exists(args, delegate(string item) { return(item.StartsWith("--profile-")); });
List <RegistryAssemblyConfiguration> cfgs = new List <RegistryAssemblyConfiguration>();
if (profileOnlyOpts == false)
{
cfgs.Add(RegistryAssemblyConfiguration.Load("BindingsGen.Profiles.CoreProfile.xml"));
cfgs.Add(RegistryAssemblyConfiguration.Load("BindingsGen.Profiles.ES2Profile.xml"));
cfgs.Add(RegistryAssemblyConfiguration.Load("BindingsGen.Profiles.SC2Profile.xml"));
}
else
{
if (Array.Exists(args, delegate(string item) { return(item.StartsWith("--profile-core")); }))
{
cfgs.Add(RegistryAssemblyConfiguration.Load("BindingsGen.Profiles.CoreProfile.xml"));
}
if (Array.Exists(args, delegate(string item) { return(item.StartsWith("--profile-es2")); }))
{
cfgs.Add(RegistryAssemblyConfiguration.Load("BindingsGen.Profiles.ES2Profile.xml"));
}
if (Array.Exists(args, delegate(string item) { return(item.StartsWith("--profile-sc2")); }))
{
cfgs.Add(RegistryAssemblyConfiguration.Load("BindingsGen.Profiles.SC2Profile.xml"));
}
}
foreach (RegistryAssemblyConfiguration cfg in cfgs)
{
try {
RegistryAssembly.CleanAssembly(assemblyPath, cfg, overwriteAssembly);
} catch (Exception exception) {
Console.WriteLine("Unable to process assembly: {0}.", exception.ToString());
}
}
// Exclusive option
return;
}
#endregion
#region Log Maps
if ((args.Length > 0) && (Array.FindIndex(args, delegate(string item) { return(item == "--only-logmaps"); }) >= 0))
{
if ((args.Length == 1) || (Array.FindIndex(args, delegate(string item) { return(item == "--gl"); }) >= 0))
{
Console.WriteLine("Generating GL log map...");
ctx = new RegistryContext("Gl", "Gl", Path.Combine(BasePath, "GLSpecs/gl.xml"));
glRegistryProcessor = new RegistryProcessor(ctx.Registry);
glRegistryProcessor.GenerateLogMap(ctx, Path.Combine(BasePath, "OpenGL.Net/KhronosLogMapGl.xml"));
}
if ((args.Length == 1) || (Array.FindIndex(args, delegate(string item) { return(item == "--wgl"); }) >= 0))
{
Console.WriteLine("Generating WGL log map...");
ctx = new RegistryContext("Wgl", "Wgl", Path.Combine(BasePath, "GLSpecs/wgl.xml"));
glRegistryProcessor = new RegistryProcessor(ctx.Registry);
glRegistryProcessor.GenerateLogMap(ctx, Path.Combine(BasePath, "OpenGL.Net/KhronosLogMapWgl.xml"));
}
if ((args.Length == 1) || (Array.FindIndex(args, delegate(string item) { return(item == "--glx"); }) >= 0))
{
Console.WriteLine("Generating GLX log map...");
ctx = new RegistryContext("Glx", "Glx", Path.Combine(BasePath, "GLSpecs/glx.xml"));
glRegistryProcessor = new RegistryProcessor(ctx.Registry);
glRegistryProcessor.GenerateLogMap(ctx, Path.Combine(BasePath, "OpenGL.Net/KhronosLogMapGlx.xml"));
}
if ((args.Length == 1) || (Array.FindIndex(args, delegate(string item) { return(item == "--egl"); }) >= 0))
{
Console.WriteLine("Generating EGL log map...");
ctx = new RegistryContext("Egl", "Egl", Path.Combine(BasePath, "GLSpecs/egl.xml"));
glRegistryProcessor = new RegistryProcessor(ctx.Registry);
glRegistryProcessor.GenerateLogMap(ctx, Path.Combine(BasePath, "OpenGL.Net/KhronosLogMapEgl.xml"));
}
// Exclusive option
return;
}
#endregion
bool genGL = (args.Length == 0) || (Array.FindIndex(args, delegate(string item) { return(item == "--gl"); }) >= 0);
bool genWGL = (args.Length == 0) || (Array.FindIndex(args, delegate(string item) { return(item == "--wgl"); }) >= 0);
bool genGLX = (args.Length == 0) || (Array.FindIndex(args, delegate(string item) { return(item == "--glx"); }) >= 0);
bool genEGL = (args.Length == 0) || (Array.FindIndex(args, delegate(string item) { return(item == "--egl"); }) >= 0);
// (Common) Documentation
RegistryDocumentation <RegistryDocumentationHandler_GL4> gl4Documentation = new RegistryDocumentation <RegistryDocumentationHandler_GL4>();
RegistryDocumentation <RegistryDocumentationHandler_GL2> gl2Documentation = new RegistryDocumentation <RegistryDocumentationHandler_GL2>();
if (genGL || genWGL || genGLX)
{
gl4Documentation.Api = "GL4";
if (DocDisabled == false)
{
gl4Documentation.ScanDocumentation(Path.Combine(BasePath, "RefPages/OpenGL/gl4"));
}
gl2Documentation.Api = "GL2.1";
if (DocDisabled == false)
{
gl2Documentation.ScanDocumentation(Path.Combine(BasePath, "RefPages/OpenGL/gl2.1"));
}
}
// XML-based specifications
// OpenGL
if (genGL)
{
bool genGL_Features = true, genGL_Commands = false, genGL_Extensions = false, genGL_Limits = false;
foreach (string arg in Array.FindAll(args, delegate(string item) { return(item.StartsWith("--gl-")); }))
{
switch (arg.Substring(5, arg.Length - 5))
{
case "commands":
genGL_Commands = true;
break;
case "extensions":
genGL_Extensions = true;
break;
case "limits":
genGL_Limits = true;
break;
}
genGL_Features = false;
}
// Additional ES documentation
RegistryDocumentation <RegistryDocumentationHandler_GL4> gles3Documentation = new RegistryDocumentation <RegistryDocumentationHandler_GL4>();
gles3Documentation.Api = "GLES3.2";
if (DocDisabled == false)
{
gles3Documentation.ScanDocumentation(Path.Combine(BasePath, "RefPages/OpenGL/es3"));
}
RegistryDocumentation <RegistryDocumentationHandler_GL2> gles1Documentation = new RegistryDocumentation <RegistryDocumentationHandler_GL2>();
gles1Documentation.Api = "GLES1.1";
if (DocDisabled == false)
{
gles1Documentation.ScanDocumentation(Path.Combine(BasePath, "RefPages/OpenGL/es1.1"));
}
Console.WriteLine("Loading GL specification...");
ctx = new RegistryContext("Gl", "Gl", Path.Combine(BasePath, "GLSpecs/gl.xml"));
ctx.RefPages.Add(gl4Documentation);
ctx.RefPages.Add(gl2Documentation);
ctx.RefPages.Add(gles3Documentation);
ctx.RefPages.Add(gles1Documentation);
glRegistryProcessor = new RegistryProcessor(ctx.Registry);
glRegistryProcessor.GenerateStronglyTypedEnums(ctx, Path.Combine(BasePath, String.Format("{0}/{1}.Enums.cs", OutputBasePath, ctx.Class)));
if (genGL_Features || genGL_Commands)
{
glRegistryProcessor.GenerateCommandsAndEnums(ctx);
}
if (genGL_Features || genGL_Extensions)
{
glRegistryProcessor.GenerateExtensionsSupportClass(ctx);
}
if (genGL_Features || genGL_Limits)
{
glRegistryProcessor.GenerateLimitsSupportClass(ctx);
}
glRegistryProcessor.GenerateVersionsSupportClass(ctx);
glRegistryProcessor.GenerateVbCommands(ctx);
glRegistryProcessor.GenerateLogMap(ctx, Path.Combine(BasePath, "OpenGL.Net/KhronosLogMapGl.xml"));
}
// OpenGL for Windows
if (genWGL)
{
ctx = new RegistryContext("Wgl", "Wgl", Path.Combine(BasePath, "GLSpecs/wgl.xml"));
ctx.RefPages.Add(gl4Documentation);
ctx.RefPages.Add(gl2Documentation);
glRegistryProcessor = new RegistryProcessor(ctx.Registry);
glRegistryProcessor.GenerateStronglyTypedEnums(ctx, Path.Combine(BasePath, String.Format("{0}/{1}.Enums.cs", OutputBasePath, ctx.Class)));
glRegistryProcessor.GenerateCommandsAndEnums(ctx);
glRegistryProcessor.GenerateExtensionsSupportClass(ctx);
glRegistryProcessor.GenerateVersionsSupportClass(ctx);
glRegistryProcessor.GenerateVbCommands(ctx);
glRegistryProcessor.GenerateLogMap(ctx, Path.Combine(BasePath, "OpenGL.Net/KhronosLogMapWgl.xml"));
}
// OpenGL for Unix
if (genGLX)
{
ctx = new RegistryContext("Glx", "Glx", Path.Combine(BasePath, "GLSpecs/glx.xml"));
ctx.RefPages.Add(gl4Documentation);
ctx.RefPages.Add(gl2Documentation);
glRegistryProcessor = new RegistryProcessor(ctx.Registry);
glRegistryProcessor.GenerateStronglyTypedEnums(ctx, Path.Combine(BasePath, String.Format("{0}/{1}.Enums.cs", OutputBasePath, ctx.Class)));
glRegistryProcessor.GenerateCommandsAndEnums(ctx);
glRegistryProcessor.GenerateExtensionsSupportClass(ctx);
glRegistryProcessor.GenerateVersionsSupportClass(ctx);
glRegistryProcessor.GenerateVbCommands(ctx);
glRegistryProcessor.GenerateLogMap(ctx, Path.Combine(BasePath, "OpenGL.Net/KhronosLogMapGlx.xml"));
}
// EGL
if ((args.Length == 0) || (Array.FindIndex(args, delegate(string item) { return(item == "--egl"); }) >= 0))
{
RegistryDocumentation <RegistryDocumentationHandler_EGL> eglDocumentation = new RegistryDocumentation <RegistryDocumentationHandler_EGL>();
eglDocumentation.Api = "EGL";
eglDocumentation.ScanDocumentation(Path.Combine(BasePath, "RefPages/EGL-Registry/sdk/docs/man"));
ctx = new RegistryContext("Egl", "Egl", Path.Combine(BasePath, "GLSpecs/egl.xml"));
ctx.RefPages.Add(eglDocumentation);
glRegistryProcessor = new RegistryProcessor(ctx.Registry);
glRegistryProcessor.GenerateStronglyTypedEnums(ctx, Path.Combine(BasePath, String.Format("{0}/{1}.Enums.cs", OutputBasePath, ctx.Class)));
glRegistryProcessor.GenerateCommandsAndEnums(ctx);
glRegistryProcessor.GenerateExtensionsSupportClass(ctx);
glRegistryProcessor.GenerateVersionsSupportClass(ctx);
glRegistryProcessor.GenerateVbCommands(ctx);
glRegistryProcessor.GenerateLogMap(ctx, Path.Combine(BasePath, "OpenGL.Net/KhronosLogMapEgl.xml"));
}
// OpenWF
OutputBasePath = "OpenWF.Net";
// OpenWF(C)
// Note: you must setup CLI to generate this bindings
if ((args.Length > 0) && (Array.FindIndex(args, delegate(string item) { return(item == "--wfc"); }) >= 0))
{
Header headRegistry = new Header("Wfc");
headRegistry.CommandExportRegex = "WF(D|C)_APIENTRY ";
headRegistry.CommandCallConventionRegex = "WF(D|C)_API_CALL ";
headRegistry.CommandExitRegex = " WF(D|C)_APIEXIT";
headRegistry.AppendHeader(Path.Combine(BasePath, "GLSpecs/WF/wfc.h"), new KhronosVersion(1, 0, KhronosVersion.ApiWfc));
ctx = new RegistryContext("Wfc", "Wfc", headRegistry);
glRegistryProcessor = new RegistryProcessor(ctx.Registry, "OpenWF");
glRegistryProcessor.GenerateStronglyTypedEnums(ctx, Path.Combine(BasePath, String.Format("{0}/{1}.Enums.cs", OutputBasePath, ctx.Class)));
glRegistryProcessor.GenerateCommandsAndEnums(ctx);
glRegistryProcessor.GenerateExtensionsSupportClass(ctx);
glRegistryProcessor.GenerateVersionsSupportClass(ctx);
glRegistryProcessor.GenerateVbCommands(ctx);
}
// OpenWF(D)
if ((args.Length == 0) || (Array.FindIndex(args, delegate(string item) { return(item == "--wfd"); }) >= 0))
{
Header headRegistry = new Header("Wfd");
headRegistry.CommandExportRegex = "WF(D|C)_APIENTRY ";
headRegistry.CommandCallConventionRegex = "WF(D|C)_API_CALL ";
headRegistry.CommandExitRegex = " WF(D|C)_APIEXIT";
headRegistry.AppendHeader(Path.Combine(BasePath, "GLSpecs/WF/wfd.h"), new KhronosVersion(1, 0, KhronosVersion.ApiWfd));
ctx = new RegistryContext("Wfd", "Wfd", headRegistry);
glRegistryProcessor = new RegistryProcessor(ctx.Registry, "OpenWF");
glRegistryProcessor.GenerateStronglyTypedEnums(ctx, Path.Combine(BasePath, String.Format("{0}/{1}.Enums.cs", OutputBasePath, ctx.Class)));
glRegistryProcessor.GenerateCommandsAndEnums(ctx);
glRegistryProcessor.GenerateExtensionsSupportClass(ctx);
glRegistryProcessor.GenerateVersionsSupportClass(ctx);
glRegistryProcessor.GenerateVbCommands(ctx);
}
// OpenVX
OutputBasePath = "OpenVX.Net";
if ((args.Length == 0) || (Array.FindIndex(args, delegate(string item) { return(item == "--vx"); }) >= 0))
{
Header vxRegistry = new Header("VX");
vxRegistry.CommandExportRegex = "VX_API_ENTRY ";
vxRegistry.CommandCallConventionRegex = "VX_API_CALL ";
vxRegistry.AppendHeader(Path.Combine(BasePath, "VXSpecs/1.2/vx_api.h"), new KhronosVersion(1, 2, KhronosVersion.ApiVx));
vxRegistry.AppendHeader(Path.Combine(BasePath, "VXSpecs/1.2/vx_types.h"), new KhronosVersion(1, 2, KhronosVersion.ApiVx));
vxRegistry.AppendHeader(Path.Combine(BasePath, "VXSpecs/1.2/vx_kernels.h"), new KhronosVersion(1, 2, KhronosVersion.ApiVx));
vxRegistry.AppendHeader(Path.Combine(BasePath, "VXSpecs/1.2/vx_nodes.h"), new KhronosVersion(1, 2, KhronosVersion.ApiVx));
vxRegistry.AppendHeader(Path.Combine(BasePath, "VXSpecs/1.2/vx_vendors.h"), new KhronosVersion(1, 2, KhronosVersion.ApiVx));
vxRegistry.AppendHeader(Path.Combine(BasePath, "VXSpecs/1.2/vx_import.h"), new KhronosVersion(1, 2, KhronosVersion.ApiVx));
vxRegistry.AppendHeader(Path.Combine(BasePath, "VXSpecs/1.2/vx_khr_icd.h"), "VX_KHR_icd");
vxRegistry.AppendHeader(Path.Combine(BasePath, "VXSpecs/1.2/vx_khr_ix.h"), "VX_KHR_ix");
vxRegistry.AppendHeader(Path.Combine(BasePath, "VXSpecs/1.2/vx_khr_nn.h"), "VX_KHR_nn");
vxRegistry.AppendHeader(Path.Combine(BasePath, "VXSpecs/1.2/vx_khr_tiling.h"), "VX_KHR_tiling");
vxRegistry.AppendHeader(Path.Combine(BasePath, "VXSpecs/1.2/vx_khr_xml.h"), "VX_KHR_xml");
ctx = new RegistryContext("VX", "VX", vxRegistry);
glRegistryProcessor = new RegistryProcessor(ctx.Registry, "OpenVX");
glRegistryProcessor.GenerateStronglyTypedEnums(ctx, Path.Combine(BasePath, String.Format("{0}/{1}.Enums.cs", OutputBasePath, ctx.Class)));
glRegistryProcessor.GenerateCommandsAndEnums(ctx);
//glRegistryProcessor.GenerateExtensionsSupportClass(ctx);
//glRegistryProcessor.GenerateVersionsSupportClass(ctx);
Header vxuRegistry = new Header("VXU");
vxuRegistry.CommandExportRegex = "VX_API_ENTRY ";
vxuRegistry.CommandCallConventionRegex = "VX_API_CALL ";
vxuRegistry.AppendHeader(Path.Combine(BasePath, "VXSpecs/1.2/vxu.h"), new KhronosVersion(1, 2, KhronosVersion.ApiVx));
ctx = new RegistryContext("VXU", "VX", vxuRegistry);
glRegistryProcessor = new RegistryProcessor(ctx.Registry, "OpenVX");
glRegistryProcessor.GenerateCommandsAndEnums(ctx);
}
}
