/// <summary>
/// Generate all required files for OpenGL C# bindings.
/// </summary>
/// <param name="glRegistryProcessor">
/// The <see cref="RegistryProcessor"/> that actually process the OpenGL specification.
/// </param>
/// <param name="ctx">
/// The <see cref="RegistryContext"/> that actually parses the OpenGL specification.
/// </param>
private static void GenerateCommandsAndEnums(RegistryProcessor glRegistryProcessor, RegistryContext ctx)
{
Dictionary<string, bool> serializedCommands = new Dictionary<string, bool>();
Dictionary<string, bool> serializedEnums = new Dictionary<string, bool>();
glRegistryProcessor.GenerateStronglyTypedEnums(ctx, Path.Combine(BasePath, String.Format("OpenGL.NET/{0}.Enums.cs", ctx.Class)), null);
glRegistryProcessor.GenerateCommandsImports(ctx, Path.Combine(BasePath, String.Format("OpenGL.NET/{0}.Imports.cs", ctx.Class)), null);
glRegistryProcessor.GenerateCommandsDelegates(ctx, Path.Combine(BasePath, String.Format("OpenGL.NET/{0}.Delegates.cs", ctx.Class)), delegate(Command command) {
return (command.Alias == null);
});
#region By features and extensions
foreach (IFeature feature in ctx.Registry.AllFeatures(ctx)) {
List<Command> featureCommands = new List<Command>();
List<Enumerant> featureEnums = new List<Enumerant>();
#region Select enumerants and commands
foreach (FeatureCommand featureCommand in feature.Requirements) {
if (featureCommand.Api != null && !Regex.IsMatch(ctx.Class.ToLower(), featureCommand.Api))
continue;
foreach (FeatureCommand.Item featureCommandItem in featureCommand.Commands) {
Command command = ctx.Registry.GetCommand(featureCommandItem.Name);
Debug.Assert(command != null);
if (serializedCommands.ContainsKey(command.Prototype.Name))
continue;
serializedCommands.Add(command.Prototype.Name, true);
// Do not generate manually disabled command
if ((command.Flags & CommandFlags.Disable) != 0)
continue;
// Do not generate command with aliases
if (command.Alias != null)
continue;
featureCommands.Add(command);
}
foreach (FeatureCommand.Item featureEnumItem in featureCommand.Enums) {
Enumerant enumerant = ctx.Registry.GetEnumerant(featureEnumItem.Name);
if (enumerant == null)
continue;
if (serializedEnums.ContainsKey(enumerant.Name))
continue;
serializedEnums.Add(enumerant.Name, true);
// Do not generate enumerant if it has an alias
if (enumerant.EnumAlias != null)
continue;
featureEnums.Add(enumerant);
}
}
#endregion
if ((featureCommands.Count == 0) && (featureEnums.Count == 0)) {
// No commands and no enumerations: remove file if existing
string sourceFilePath = GetFeatureFilePath(feature, ctx);
if (File.Exists(sourceFilePath))
File.Delete(sourceFilePath);
// Next...
continue;
}
glRegistryProcessor.GenerateCommands(ctx, GetFeatureFilePath(feature, ctx), delegate(RegistryContext cctx, SourceStreamWriter sw)
{
Console.WriteLine("\tGenerate {0} enumerants...", featureEnums.Count);
foreach (Enumerant enumerant in featureEnums) {
enumerant.GenerateSource(sw, ctx);
sw.WriteLine();
}
Console.WriteLine("\tGenerate {0} commands...", featureCommands.Count);
foreach (Command command in featureCommands) {
command.GenerateImplementations(sw, cctx);
sw.WriteLine();
}
});
}
#endregion
#region Orphans
List<Command> orphanCommands = new List<Command>();
List<Enumerant> orphanEnums = new List<Enumerant>();
foreach (Command command in ctx.Registry.Commands) {
if (serializedCommands.ContainsKey(command.Prototype.Name))
continue;
// Do not generate manually disabled command
if ((command.Flags & CommandFlags.Disable) != 0)
continue;
// Do not generate command with aliases
if (command.Alias != null)
continue;
orphanCommands.Add(command);
}
foreach (Enumerant enumerant in ctx.Registry.Enumerants) {
if (serializedEnums.ContainsKey(enumerant.Name))
continue;
orphanEnums.Add(enumerant);
}
string orphanFile = Path.Combine(BasePath, String.Format("OpenGL.NET/{0}.Orphans.cs", ctx.Class));
if ((orphanCommands.Count != 0) || (orphanEnums.Count != 0)) {
glRegistryProcessor.GenerateCommands(ctx, orphanFile, delegate(RegistryContext cctx, SourceStreamWriter sw) {
Console.WriteLine("\tGenerate {0} enumerants...", orphanEnums.Count);
foreach (Enumerant enumerant in orphanEnums) {
enumerant.GenerateSource(sw, ctx);
sw.WriteLine();
}
Console.WriteLine("\tGenerate {0} commands...", orphanCommands.Count);
foreach (Command command in orphanCommands) {
command.GenerateImplementations(sw, cctx);
sw.WriteLine();
}
});
} else {
if (File.Exists(orphanFile))
File.Delete(orphanFile);
}
#endregion
}
/// <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, item => (item == "--dummy")) >= 0;
DocDisabled = Array.FindIndex(args, item => (item == "--nodoc")) >= 0;
#region Assembly processing
if ((args.Length > 0) && ((index = Array.FindIndex(args, item => item == "--assembly")) >= 0))
{
string assemblyPath = args[index + 1];
bool overwriteAssembly = Array.Exists(args, item => item.StartsWith("--assembly-overwrite"));
bool profileOnlyOpts = Array.Exists(args, item => 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, item => (item.StartsWith("--profile-core"))))
{
cfgs.Add(RegistryAssemblyConfiguration.Load("BindingsGen.Profiles.CoreProfile.xml"));
}
if (Array.Exists(args, item => (item.StartsWith("--profile-es2"))))
{
cfgs.Add(RegistryAssemblyConfiguration.Load("BindingsGen.Profiles.ES2Profile.xml"));
}
if (Array.Exists(args, item => (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);
}
}
// Exclusive option
return;
}
#endregion
#region Log Maps
if ((args.Length > 0) && (Array.FindIndex(args, item => item == "--only-logmaps") >= 0))
{
if ((args.Length == 1) || (Array.FindIndex(args, item => 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, item => 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, item => 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, item => 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, item => item == "--gl") >= 0);
bool genWGL = (args.Length == 0) || (Array.FindIndex(args, item => item == "--wgl") >= 0);
bool genGLX = (args.Length == 0) || (Array.FindIndex(args, item => item == "--glx") >= 0);
bool genEGL = (args.Length == 0) || (Array.FindIndex(args, item => 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, item => (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> {
Api = "GLES3.2"
};
if (DocDisabled == false)
{
gles3Documentation.ScanDocumentation(Path.Combine(BasePath, "RefPages/OpenGL/es3"));
}
RegistryDocumentation <RegistryDocumentationHandler_GL2> gles1Documentation =
new RegistryDocumentation <RegistryDocumentationHandler_GL2> {
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 (genEGL)
{
RegistryDocumentation <RegistryDocumentationHandler_EGL> eglDocumentation =
new RegistryDocumentation <RegistryDocumentationHandler_EGL> {
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, item => item == "--wfc") >= 0))
{
Header headRegistry = new Header("Wfc")
{
CommandExportRegex = "WF(D|C)_APIENTRY ",
CommandCallConventionRegex = "WF(D|C)_API_CALL ",
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, item => item == "--wfd") >= 0))
{
Header headRegistry = new Header("Wfd")
{
CommandExportRegex = "WF(D|C)_APIENTRY ",
CommandCallConventionRegex = "WF(D|C)_API_CALL ",
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, item => item == "--vx") >= 0))
{
Header vxRegistry = new Header("VX")
{
CommandExportRegex = "VX_API_ENTRY ",
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")
{
CommandExportRegex = "VX_API_ENTRY ",
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);
}
}
/// <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", 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);
glRegistryProcessor.GenerateStronglyTypedEnums(ctx, Path.Combine(BasePath, String.Format("{0}/{1}.Enums.cs", OutputBasePath, ctx.Class)));
glRegistryProcessor.GenerateCommandsAndEnums(ctx);
glRegistryProcessor.GenerateExtensionsSupportClass(ctx);
glRegistryProcessor.GenerateLimitsSupportClass(ctx);
glRegistryProcessor.GenerateVersionsSupportClass(ctx);
glRegistryProcessor.GenerateVbCommands(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);
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 ((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);
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", 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.AppendHeader(Path.Combine(BasePath, "GLSpecs/WF/wfc.h"));
ctx = new RegistryContext("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.AppendHeader(Path.Combine(BasePath, "GLSpecs/WF/wfd.h"));
ctx = new RegistryContext("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);
}
}
/// <summary>
/// Generate all required files for OpenGL C# bindings.
/// </summary>
/// <param name="glRegistryProcessor">
/// The <see cref="RegistryProcessor"/> that actually process the OpenGL specification.
/// </param>
/// <param name="ctx">
/// The <see cref="RegistryContext"/> that actually parses the OpenGL specification.
/// </param>
private static void GenerateCommandsAndEnums(RegistryProcessor glRegistryProcessor, RegistryContext ctx)
{
Dictionary <string, bool> serializedCommands = new Dictionary <string, bool>();
Dictionary <string, bool> serializedEnums = new Dictionary <string, bool>();
glRegistryProcessor.GenerateStronglyTypedEnums(ctx, Path.Combine(BasePath, String.Format("OpenGL.NET/{0}.Enums.cs", ctx.Class)), null);
glRegistryProcessor.GenerateCommandsImports(ctx, Path.Combine(BasePath, String.Format("OpenGL.NET/{0}.Imports.cs", ctx.Class)), null);
glRegistryProcessor.GenerateCommandsDelegates(ctx, Path.Combine(BasePath, String.Format("OpenGL.NET/{0}.Delegates.cs", ctx.Class)), delegate(Command command) {
return(command.Alias == null);
});
#region By features and extensions
foreach (IFeature feature in ctx.Registry.AllFeatures(ctx))
{
List <Command> featureCommands = new List <Command>();
List <Enumerant> featureEnums = new List <Enumerant>();
#region Select enumerants and commands
foreach (FeatureCommand featureCommand in feature.Requirements)
{
if (featureCommand.Api != null && !Regex.IsMatch(ctx.Class.ToLower(), featureCommand.Api))
{
continue;
}
foreach (FeatureCommand.Item featureCommandItem in featureCommand.Commands)
{
Command command = ctx.Registry.GetCommand(featureCommandItem.Name);
Debug.Assert(command != null);
if (serializedCommands.ContainsKey(command.Prototype.Name))
{
continue;
}
serializedCommands.Add(command.Prototype.Name, true);
// Do not generate manually disabled command
if ((command.Flags & CommandFlags.Disable) != 0)
{
continue;
}
// Do not generate command with aliases
if (command.Alias != null)
{
continue;
}
featureCommands.Add(command);
}
foreach (FeatureCommand.Item featureEnumItem in featureCommand.Enums)
{
Enumerant enumerant = ctx.Registry.GetEnumerant(featureEnumItem.Name);
if (enumerant == null)
{
continue;
}
if (serializedEnums.ContainsKey(enumerant.Name))
{
continue;
}
serializedEnums.Add(enumerant.Name, true);
// Do not generate enumerant if it has an alias
if (enumerant.EnumAlias != null)
{
continue;
}
featureEnums.Add(enumerant);
}
}
#endregion
if ((featureCommands.Count == 0) && (featureEnums.Count == 0))
{
// No commands and no enumerations: remove file if existing
string sourceFilePath = GetFeatureFilePath(feature, ctx);
if (File.Exists(sourceFilePath))
{
File.Delete(sourceFilePath);
}
// Next...
continue;
}
glRegistryProcessor.GenerateCommands(ctx, GetFeatureFilePath(feature, ctx), delegate(RegistryContext cctx, SourceStreamWriter sw)
{
Console.WriteLine("\tGenerate {0} enumerants...", featureEnums.Count);
foreach (Enumerant enumerant in featureEnums)
{
enumerant.GenerateSource(sw, ctx);
sw.WriteLine();
}
Console.WriteLine("\tGenerate {0} commands...", featureCommands.Count);
foreach (Command command in featureCommands)
{
command.GenerateImplementations(sw, cctx);
sw.WriteLine();
}
});
}
#endregion
#region Orphans
List <Command> orphanCommands = new List <Command>();
List <Enumerant> orphanEnums = new List <Enumerant>();
foreach (Command command in ctx.Registry.Commands)
{
if (serializedCommands.ContainsKey(command.Prototype.Name))
{
continue;
}
// Do not generate manually disabled command
if ((command.Flags & CommandFlags.Disable) != 0)
{
continue;
}
// Do not generate command with aliases
if (command.Alias != null)
{
continue;
}
orphanCommands.Add(command);
}
foreach (Enumerant enumerant in ctx.Registry.Enumerants)
{
if (serializedEnums.ContainsKey(enumerant.Name))
{
continue;
}
orphanEnums.Add(enumerant);
}
string orphanFile = Path.Combine(BasePath, String.Format("OpenGL.NET/{0}.Orphans.cs", ctx.Class));
if ((orphanCommands.Count != 0) || (orphanEnums.Count != 0))
{
glRegistryProcessor.GenerateCommands(ctx, orphanFile, delegate(RegistryContext cctx, SourceStreamWriter sw) {
Console.WriteLine("\tGenerate {0} enumerants...", orphanEnums.Count);
foreach (Enumerant enumerant in orphanEnums)
{
enumerant.GenerateSource(sw, ctx);
sw.WriteLine();
}
Console.WriteLine("\tGenerate {0} commands...", orphanCommands.Count);
foreach (Command command in orphanCommands)
{
command.GenerateImplementations(sw, cctx);
sw.WriteLine();
}
});
}
else
{
if (File.Exists(orphanFile))
{
File.Delete(orphanFile);
}
}
#endregion
}
