/// <summary>
/// Application entry point.
/// </summary>
/// <param name="args">
/// The command line invocation arguments.
/// </param>
static void Main(string[] args)
{
RegistryContext ctx;
RegistryProcessor glRegistryProcessor;
RegistryDocumentation.CreateLog();
// OpenGL
if ((args.Length == 0) || (Array.FindIndex(args, delegate(string item) { return(item == "--gl"); }) >= 0))
{
ctx = new RegistryContext("Gl", Path.Combine(BasePath, "GLSpecs/gl.xml"));
glRegistryProcessor = new RegistryProcessor(ctx.Registry);
GenerateCommandsAndEnums(glRegistryProcessor, ctx);
GenerateExtensionsSupportClass(glRegistryProcessor, ctx);
GenerateVersionsSupportClass(glRegistryProcessor, ctx);
}
#if false
// OpenGL ES
if ((args.Length == 0) || (Array.FindIndex(args, delegate(string item) { return(item == "--gles"); }) >= 0))
{
ctx = new RegistryContext("Gles", Path.Combine(BasePath, "GLSpecs/gl.xml"));
glRegistryProcessor = new RegistryProcessor(ctx.Registry);
GenerateCommandsAndEnums(glRegistryProcessor, ctx);
}
#endif
// 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"));
glRegistryProcessor = new RegistryProcessor(ctx.Registry);
GenerateCommandsAndEnums(glRegistryProcessor, ctx);
GenerateExtensionsSupportClass(glRegistryProcessor, ctx);
GenerateVersionsSupportClass(glRegistryProcessor, ctx);
}
// OpenGL for Unix
if ((args.Length == 0) || (Array.FindIndex(args, delegate(string item) { return(item == "--xgl"); }) >= 0))
{
ctx = new RegistryContext("Glx", Path.Combine(BasePath, "GLSpecs/glx.xml"));
glRegistryProcessor = new RegistryProcessor(ctx.Registry);
GenerateCommandsAndEnums(glRegistryProcessor, ctx);
GenerateExtensionsSupportClass(glRegistryProcessor, ctx);
GenerateVersionsSupportClass(glRegistryProcessor, ctx);
}
// EGL
if ((args.Length == 0) || (Array.FindIndex(args, delegate(string item) { return(item == "--egl"); }) >= 0))
{
ctx = new RegistryContext("Egl", Path.Combine(BasePath, "GLSpecs/egl.xml"));
glRegistryProcessor = new RegistryProcessor(ctx.Registry);
GenerateCommandsAndEnums(glRegistryProcessor, ctx);
GenerateExtensionsSupportClass(glRegistryProcessor, ctx);
GenerateVersionsSupportClass(glRegistryProcessor, ctx);
}
RegistryDocumentation.CloseLog();
}
/// <summary>
/// Application entry point.
/// </summary>
/// <param name="args">
/// The command line invocation arguments.
/// </param>
static void Main(string[] args)
{
RegistryContext ctx;
RegistryProcessor glRegistryProcessor;
RegistryDocumentation.CreateLog();
// OpenGL
if ((args.Length == 0) || (Array.FindIndex(args, delegate(string item) { return (item == "--gl"); }) >= 0)) {
ctx = new RegistryContext("Gl", Path.Combine(BasePath, "GLSpecs/gl.xml"));
glRegistryProcessor = new RegistryProcessor(ctx.Registry);
GenerateCommandsAndEnums(glRegistryProcessor, ctx);
GenerateExtensionsSupportClass(glRegistryProcessor, ctx);
GenerateVersionsSupportClass(glRegistryProcessor, ctx);
}
#if false
// OpenGL ES
if ((args.Length == 0) || (Array.FindIndex(args, delegate(string item) { return (item == "--gles"); }) >= 0)) {
ctx = new RegistryContext("Gles", Path.Combine(BasePath, "GLSpecs/gl.xml"));
glRegistryProcessor = new RegistryProcessor(ctx.Registry);
GenerateCommandsAndEnums(glRegistryProcessor, ctx);
}
#endif
// 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"));
glRegistryProcessor = new RegistryProcessor(ctx.Registry);
GenerateCommandsAndEnums(glRegistryProcessor, ctx);
GenerateExtensionsSupportClass(glRegistryProcessor, ctx);
GenerateVersionsSupportClass(glRegistryProcessor, ctx);
}
// OpenGL for Unix
if ((args.Length == 0) || (Array.FindIndex(args, delegate(string item) { return (item == "--xgl"); }) >= 0)) {
ctx = new RegistryContext("Glx", Path.Combine(BasePath, "GLSpecs/glx.xml"));
glRegistryProcessor = new RegistryProcessor(ctx.Registry);
GenerateCommandsAndEnums(glRegistryProcessor, ctx);
GenerateExtensionsSupportClass(glRegistryProcessor, ctx);
GenerateVersionsSupportClass(glRegistryProcessor, ctx);
}
// EGL
if ((args.Length == 0) || (Array.FindIndex(args, delegate(string item) { return (item == "--egl"); }) >= 0)) {
ctx = new RegistryContext("Egl", Path.Combine(BasePath, "GLSpecs/egl.xml"));
glRegistryProcessor = new RegistryProcessor(ctx.Registry);
GenerateCommandsAndEnums(glRegistryProcessor, ctx);
GenerateExtensionsSupportClass(glRegistryProcessor, ctx);
GenerateVersionsSupportClass(glRegistryProcessor, ctx);
}
RegistryDocumentation.CloseLog();
}
private static void GenerateVersionsSupportClass(RegistryProcessor glRegistryProcessor, RegistryContext ctx)
{
string path = String.Format("{0}/{1}.Versions.cs", _OutputBasePath, ctx.Class);
Console.WriteLine("Generate version support class to {0}.", path);
using (SourceStreamWriter sw = new SourceStreamWriter(Path.Combine(BasePath, path), false)) {
RegistryProcessor.GenerateLicensePreamble(sw);
sw.WriteLine("namespace {0}", _Namespace);
sw.WriteLine("{");
sw.Indent();
sw.WriteLine("public partial class {0}", ctx.Class);
sw.WriteLine("{");
sw.Indent();
sw.WriteLine("#region Known Versions Constants");
sw.WriteLine();
foreach (Feature featureVersion in ctx.Registry.Features)
{
if (featureVersion.Number == null)
{
continue;
}
// Determine version value (support up to 3 version numbers)
Match versionMatch = Regex.Match(featureVersion.Number, @"(?<Major>\d+)\.(?<Minor>\d+)(\.(?<Rev>\d+))?");
if (versionMatch.Success == false)
{
continue;
}
int versionMajor = Int32.Parse(versionMatch.Groups["Major"].Value);
int versionMinor = Int32.Parse(versionMatch.Groups["Minor"].Value);
int versionRev = versionMatch.Groups["Rev"].Success ? Int32.Parse(versionMatch.Groups["Rev"].Value) : 0;
int versionValue = versionMajor * 100 + versionMinor * 10 + versionRev;
// Determine version/api name
string versionName = String.Format("Version_{0}", versionValue);
string api = ctx.Class;
if (featureVersion.IsEsVersion)
{
versionName = String.Format("Version_{0}_ES", versionValue);
switch (versionMajor)
{
case 1:
api = "Gles1";
break;
case 2:
default:
api = "Gles2";
break;
}
}
else if (featureVersion.IsScVersion)
{
versionName = String.Format("Version_{0}_SC", versionValue);
api = "Glsc2";
}
sw.WriteLine("/// <summary>");
sw.WriteLine("/// Version for {0} API.", SpecificationStyle.GetKhronosVersionHumanReadable(featureVersion.Name));
sw.WriteLine("/// </summary>");
if (versionRev != 0)
{
sw.WriteLine("public static readonly KhronosVersion {0} = new KhronosVersion({1}, {2}, {3}, KhronosVersion.Api{4});", versionName, versionMajor, versionMinor, versionRev, api);
}
else
{
sw.WriteLine("public static readonly KhronosVersion {0} = new KhronosVersion({1}, {2}, KhronosVersion.Api{3});", versionName, versionMajor, versionMinor, api);
}
sw.WriteLine();
}
sw.WriteLine("#endregion");
sw.WriteLine();
sw.Unindent();
sw.WriteLine("}");
sw.Unindent();
sw.WriteLine();
sw.WriteLine("}");
}
}
private static void GenerateLimitsSupportClass(RegistryProcessor glRegistryProcessor, RegistryContext ctx)
{
string path = String.Format("{0}/{1}.Limits.cs", _OutputBasePath, ctx.Class);
List <Enumerant> limitEnums = new List <Enumerant>();
foreach (Enumerant enumerant in ctx.Registry.Enumerants)
{
// Skip enumeration with aliases
if (enumerant.EnumAlias != null)
{
continue;
}
bool maxLimit = enumerant.Name.StartsWith("GL_MAX_");
bool minLimit = enumerant.Name.StartsWith("GL_MIN_");
if (!maxLimit && !minLimit)
{
continue;
}
if (CommandFlagsDatabase.IsExcludedLimit(enumerant.Name))
{
continue;
}
limitEnums.Add(enumerant);
}
foreach (CommandFlagsDatabase.Limit limit in CommandFlagsDatabase.GetLimits())
{
if (limitEnums.Exists(delegate(Enumerant item) { return(item.Name == limit.Name); }))
{
continue;
}
Enumerant addedEnum = ctx.Registry.GetEnumerant(limit.Name);
Debug.Assert(addedEnum != null);
if (addedEnum == null)
{
continue;
}
limitEnums.Add(addedEnum);
}
Console.WriteLine("Generate API limits to {0}.", path);
using (SourceStreamWriter sw = new SourceStreamWriter(Path.Combine(BasePath, path), false)) {
RegistryProcessor.GenerateLicensePreamble(sw);
sw.WriteLine("using System;");
sw.WriteLine();
sw.WriteLine("namespace {0}", _Namespace);
sw.WriteLine("{");
sw.Indent();
sw.WriteLine("public partial class {0}", ctx.Class);
sw.WriteLine("{");
sw.Indent();
sw.WriteLine("/// <summary>");
sw.WriteLine("/// Limits support listing.");
sw.WriteLine("/// </summary>");
sw.WriteLine("public sealed partial class Limits");
sw.WriteLine("{");
sw.Indent();
foreach (Enumerant enumerant in limitEnums)
{
// Filter enumerant
CommandFlagsDatabase.Limit limit = CommandFlagsDatabase.GetLimit(enumerant.Name);
string fieldName = SpecificationStyle.GetCamelCase(enumerant.ImplementationName);
string fieldType = "int";
int fieldLength = 1;
if (limit != null)
{
fieldType = limit.Type;
fieldLength = limit.Length;
}
enumerant.GenerateDocumentation(sw, ctx);
if (fieldLength > 1)
{
sw.WriteLine("[Limit({0}, ArrayLength = {1})]", enumerant.ImplementationName, fieldLength);
enumerant.GenerateRequirements(sw, ctx);
StringBuilder sb = new StringBuilder();
sb.AppendFormat("public {0}[] {1} = new {0}[] {{", fieldType, fieldName);
for (int i = 0; i < fieldLength; i++)
{
switch (fieldType)
{
case "int":
sb.Append("0");
break;
case "float":
sb.Append("0.0f");
break;
}
if (i < fieldLength - 1)
{
sb.Append(", ");
}
}
sb.Append(" };");
sw.WriteLine(sb.ToString());
}
else
{
sw.WriteLine("[Limit({0})]", enumerant.ImplementationName);
enumerant.GenerateRequirements(sw, ctx);
sw.WriteLine("public {0} {1};", fieldType, fieldName);
}
sw.WriteLine();
}
sw.Unindent();
sw.WriteLine("}");
sw.Unindent();
sw.Unindent();
sw.WriteLine("}");
sw.Unindent();
sw.WriteLine();
sw.WriteLine("}");
}
}
private static void GenerateExtensionsSupportClass(RegistryProcessor glRegistryProcessor, RegistryContext ctx)
{
string path = String.Format("{0}/{1}.Extensions.cs", _OutputBasePath, ctx.Class);
Console.WriteLine("Generate registry khronosExtensions to {0}.", path);
SortedList <int, List <IFeature> > khronosExtensions = new SortedList <int, List <IFeature> >();
SortedList <int, List <IFeature> > vendorExtensions = new SortedList <int, List <IFeature> >();
foreach (IFeature feature in ctx.Registry.Extensions)
{
SortedList <int, List <IFeature> > extensionDict;
List <IFeature> extensionFeatures;
if (Extension.IsArbVendor(feature.Name))
{
extensionDict = khronosExtensions;
}
else
{
extensionDict = vendorExtensions;
}
int index = ExtensionIndices.GetIndex(feature.Name);
if (extensionDict.TryGetValue(index, out extensionFeatures) == false)
{
extensionFeatures = new List <IFeature>();
extensionDict.Add(index, extensionFeatures);
}
extensionFeatures.Add(feature);
}
using (SourceStreamWriter sw = new SourceStreamWriter(Path.Combine(BasePath, path), false)) {
RegistryProcessor.GenerateLicensePreamble(sw);
sw.WriteLine("using System;");
sw.WriteLine();
sw.WriteLine("namespace {0}", _Namespace);
sw.WriteLine("{");
sw.Indent();
sw.WriteLine("public partial class {0}", ctx.Class);
sw.WriteLine("{");
sw.Indent();
sw.WriteLine("/// <summary>");
sw.WriteLine("/// Extension support listing.");
sw.WriteLine("/// </summary>");
sw.WriteLine("public partial class Extensions : ExtensionsCollection");
sw.WriteLine("{");
sw.Indent();
foreach (KeyValuePair <int, List <IFeature> > pair in khronosExtensions)
{
IFeature mainFeature = pair.Value[0];
string extensionFieldName = SpecificationStyle.GetExtensionBindingName(mainFeature.Name);
sw.WriteLine("/// <summary>");
sw.WriteLine("/// Support for extension {0}.", mainFeature.Name);
sw.WriteLine("/// </summary>");
foreach (IFeature feature in pair.Value)
{
if (feature.Api != null && feature.Api != ctx.Class.ToLower())
{
sw.WriteLine("[Extension(\"{0}\", Api = \"{1}\")]", feature.Name, feature.Api);
}
else
{
sw.WriteLine("[Extension(\"{0}\")]", feature.Name);
}
}
Extension mainExtension = (Extension)mainFeature;
if (String.IsNullOrEmpty(mainExtension.Supported) == false)
{
sw.WriteLine("[ExtensionSupport(\"{0}\")]", mainExtension.Supported);
}
sw.WriteLine("public bool {0};", extensionFieldName);
sw.WriteLine();
}
foreach (KeyValuePair <int, List <IFeature> > pair in vendorExtensions)
{
IFeature mainFeature = pair.Value[0];
string extensionFieldName = SpecificationStyle.GetExtensionBindingName(mainFeature.Name);
sw.WriteLine("/// <summary>");
sw.WriteLine("/// Support for extension {0}.", mainFeature.Name);
sw.WriteLine("/// </summary>");
foreach (IFeature feature in pair.Value)
{
if (feature.Api != null && feature.Api != ctx.Class.ToLower())
{
sw.WriteLine("[Extension(\"{0}\", Api = \"{1}\")]", feature.Name, feature.Api);
}
else
{
sw.WriteLine("[Extension(\"{0}\")]", feature.Name);
}
}
sw.WriteLine("public bool {0};", extensionFieldName);
sw.WriteLine();
}
sw.Unindent();
sw.WriteLine("}");
sw.Unindent();
sw.Unindent();
sw.WriteLine("}");
sw.Unindent();
sw.WriteLine();
sw.WriteLine("}");
}
}
private static void GenerateVbCommands(RegistryProcessor glRegistryProcessor, RegistryContext ctx)
{
Dictionary <string, bool> serializedCommands = new Dictionary <string, bool>();
Dictionary <string, bool> serializedEnums = new Dictionary <string, bool>();
List <Command> featureVbCommands = new List <Command>();
List <Enumerant> featureVbEnums = new List <Enumerant>();
Console.WriteLine("Testing for VB.Net incompatibilities.");
#region Select VB incompatible commands
foreach (IFeature feature in ctx.Registry.AllFeatures(ctx))
{
foreach (FeatureCommand featureCommand in feature.Requirements)
{
if (featureCommand.Api != null && !ctx.IsSupportedApi(featureCommand.Api))
{
Console.WriteLine("Skip command: API {1} not supported", 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;
}
// Do not generate methods not conflicting with enumerations having the same name with different case
Enumerant enumInConflict = ctx.Registry.GetEnumerantNoCase(command.GetImplementationName(ctx));
if (enumInConflict == null)
{
continue;
}
// VB.Net command
featureVbCommands.Add(command);
if (serializedEnums.ContainsKey(enumInConflict.Name))
{
continue;
}
serializedEnums.Add(enumInConflict.Name, true);
// VB.Net enum
featureVbEnums.Add(enumInConflict);
}
}
}
#endregion
string path = Path.Combine(BasePath, String.Format("{0}/{1}.Vb.cs", _OutputBasePath, ctx.Class));
if (featureVbCommands.Count > 0)
{
Console.WriteLine("Generate registry commands to {0}.", path);
using (SourceStreamWriter sw = new SourceStreamWriter(path, false)) {
RegistryProcessor.GenerateLicensePreamble(sw);
// Warning CS1734 XML comment on 'method' has a paramref tag for 'param', but there is no parameter by that name
// sw.WriteLine("#pragma warning disable 1734");
// sw.WriteLine();
sw.WriteLine("#pragma warning disable 649, 1572, 1573");
sw.WriteLine();
sw.WriteLine("using System;");
sw.WriteLine("using System.Diagnostics;");
sw.WriteLine("using System.Runtime.InteropServices;");
sw.WriteLine("using System.Security;");
sw.WriteLine("using System.Text;");
sw.WriteLine();
sw.WriteLine("namespace {0}", _Namespace);
sw.WriteLine("{");
sw.Indent();
sw.WriteLine("/// <summary>");
sw.WriteLine("/// Class for scoping those methods conflicting with other fields/enums.");
sw.WriteLine("/// </summary>");
sw.WriteLine("public partial class {0}", ctx.Class);
sw.WriteLine("{");
sw.Indent();
// VB Commands class
sw.WriteLine("public static class VB");
sw.WriteLine("{");
sw.Indent();
// VB Function implementations
foreach (Command command in featureVbCommands)
{
command.GenerateImplementations(sw, ctx);
sw.WriteLine();
}
sw.Unindent();
sw.WriteLine("}");
// VB Commands class
sw.WriteLine();
sw.WriteLine("public static class VBEnum");
sw.WriteLine("{");
sw.Indent();
// VB Function implementations
foreach (Enumerant enumerant in featureVbEnums)
{
enumerant.GenerateSource(sw, ctx);
sw.WriteLine();
}
sw.Unindent();
sw.WriteLine("}");
sw.Unindent();
sw.Unindent();
sw.WriteLine("}");
sw.Unindent();
sw.WriteLine();
sw.WriteLine("}");
}
}
else
{
if (File.Exists(path))
{
File.Delete(path);
}
}
}
/// <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);
}
}
/// <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("{0}/{1}.Enums.cs", _OutputBasePath, ctx.Class)), 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 && !ctx.IsSupportedApi(featureCommand.Api))
{
Console.WriteLine("Skip command: API {1} not supported", 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();
}
if (featureCommands.Count > 0)
{
GenerateCommandsImports(cctx, sw, featureCommands);
sw.WriteLine();
}
if (featureCommands.Count > 0)
{
GenerateCommandsDelegates(cctx, sw, featureCommands);
}
});
}
#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("{0}/{1}.Orphans.cs", _OutputBasePath, 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
}
private static void GenerateVersionsSupportClass(RegistryProcessor glRegistryProcessor, RegistryContext ctx)
{
string path = String.Format("OpenGL.NET/{0}.Versions.cs", ctx.Class);
Console.WriteLine("Generate version support class to {0}.", path);
using (SourceStreamWriter sw = new SourceStreamWriter(Path.Combine(BasePath, path), false)) {
RegistryProcessor.GenerateLicensePreamble(sw);
sw.WriteLine("namespace OpenGL");
sw.WriteLine("{");
sw.Indent();
sw.WriteLine("public partial class {0}", ctx.Class);
sw.WriteLine("{");
sw.Indent();
sw.WriteLine("#region Known Versions Constants");
sw.WriteLine();
foreach (Feature featureVersion in ctx.Registry.Features) {
if (featureVersion.Number == null)
continue;
// Determine version value (support up to 3 version numbers)
Match versionMatch = Regex.Match(featureVersion.Number, @"(?<Major>\d+)\.(?<Minor>\d+)(\.(?<Rev>\d+))?");
if (versionMatch.Success == false)
continue;
int versionMajor = Int32.Parse(versionMatch.Groups["Major"].Value);
int versionMinor = Int32.Parse(versionMatch.Groups["Minor"].Value);
int versionRev = versionMatch.Groups["Rev"].Success ? Int32.Parse(versionMatch.Groups["Rev"].Value) : 0;
int versionValue = versionMajor * 100 + versionMinor * 10 + versionRev;
// Determine version name
string versionName = String.Format("Version_{0}", versionValue);
if (featureVersion.IsEsVersion)
versionName = String.Format("Version_{0}ES", versionValue);
sw.WriteLine("/// <summary>");
sw.WriteLine("/// Version for {0} API.", SpecificationStyle.GetKhronosVersionHumanReadable(featureVersion.Name));
sw.WriteLine("/// </summary>");
sw.WriteLine("public const int {0} = {1};", versionName, versionValue);
sw.WriteLine();
}
sw.WriteLine("#endregion");
sw.WriteLine();
sw.Unindent();
sw.WriteLine("}");
sw.Unindent();
sw.WriteLine();
sw.WriteLine("}");
}
}
private static void GenerateExtensionsSupportClass(RegistryProcessor glRegistryProcessor, RegistryContext ctx)
{
string path = String.Format("OpenGL.NET/{0}.Extensions.cs", ctx.Class);
Console.WriteLine("Generate registry khronosExtensions to {0}.", path);
SortedList<int, List<IFeature>> khronosExtensions = new SortedList<int, List<IFeature>>();
SortedList<int, List<IFeature>> vendorExtensions = new SortedList<int, List<IFeature>>();
foreach (IFeature feature in ctx.Registry.Extensions) {
SortedList<int, List<IFeature>> extensionDict;
List<IFeature> extensionFeatures;
if (Extension.IsArbVendor(feature.Name))
extensionDict = khronosExtensions;
else
extensionDict = vendorExtensions;
int index = ExtensionIndices.GetIndex(feature.Name);
if (extensionDict.TryGetValue(index, out extensionFeatures) == false) {
extensionFeatures = new List<IFeature>();
extensionDict.Add(index, extensionFeatures);
}
extensionFeatures.Add(feature);
}
using (SourceStreamWriter sw = new SourceStreamWriter(Path.Combine(BasePath, path), false)) {
RegistryProcessor.GenerateLicensePreamble(sw);
sw.WriteLine("using System;");
sw.WriteLine();
sw.WriteLine("namespace OpenGL");
sw.WriteLine("{");
sw.Indent();
sw.WriteLine("public partial class {0}", ctx.Class);
sw.WriteLine("{");
sw.Indent();
sw.WriteLine("/// <summary>");
sw.WriteLine("/// Extension support listing.");
sw.WriteLine("/// </summary>");
sw.WriteLine("public partial class Extensions : ExtensionsCollection");
sw.WriteLine("{");
sw.Indent();
foreach (KeyValuePair<int, List<IFeature>> pair in khronosExtensions) {
IFeature mainFeature = pair.Value[0];
string extensionFieldName = SpecificationStyle.GetExtensionBindingName(mainFeature.Name);
sw.WriteLine("/// <summary>");
sw.WriteLine("/// Support for extension {0}.", mainFeature.Name);
sw.WriteLine("/// </summary>");
foreach (IFeature feature in pair.Value)
sw.WriteLine("[Extension(\"{0}\")]", feature.Name);
Extension mainExtension = (Extension)mainFeature;
if (String.IsNullOrEmpty(mainExtension.Supported) == false)
sw.WriteLine("[ExtensionSupport(\"{0}\")]", mainExtension.Supported);
sw.WriteLine("public bool {0};", extensionFieldName);
sw.WriteLine();
}
foreach (KeyValuePair<int, List<IFeature>> pair in vendorExtensions) {
IFeature mainFeature = pair.Value[0];
string extensionFieldName = SpecificationStyle.GetExtensionBindingName(mainFeature.Name);
sw.WriteLine("/// <summary>");
sw.WriteLine("/// Support for extension {0}.", mainFeature.Name);
sw.WriteLine("/// </summary>");
foreach (IFeature feature in pair.Value)
sw.WriteLine("[Extension(\"{0}\")]", feature.Name);
sw.WriteLine("public bool {0};", extensionFieldName);
sw.WriteLine();
}
sw.Unindent();
sw.WriteLine("}");
sw.Unindent();
sw.Unindent();
sw.WriteLine("}");
sw.Unindent();
sw.WriteLine();
sw.WriteLine("}");
}
}
/// <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, 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);
}
}
/// <summary>
/// Application entry point.
/// </summary>
/// <param name="args">
/// The command line invocation arguments.
/// </param>
static void Main(string[] args)
{
RegistryContext ctx;
RegistryProcessor glRegistryProcessor;
RegistryDocumentation.CreateLog();
// XML-based speicfications
// OpenGL
if ((args.Length == 0) || (Array.FindIndex(args, delegate(string item) { return(item == "--gl"); }) >= 0))
{
ctx = new RegistryContext("Gl", Path.Combine(BasePath, "GLSpecs/gl.xml"));
glRegistryProcessor = new RegistryProcessor(ctx.Registry);
GenerateCommandsAndEnums(glRegistryProcessor, ctx);
GenerateExtensionsSupportClass(glRegistryProcessor, ctx);
GenerateVersionsSupportClass(glRegistryProcessor, ctx);
GenerateVbCommands(glRegistryProcessor, ctx);
}
// 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"));
glRegistryProcessor = new RegistryProcessor(ctx.Registry);
GenerateCommandsAndEnums(glRegistryProcessor, ctx);
GenerateExtensionsSupportClass(glRegistryProcessor, ctx);
GenerateVersionsSupportClass(glRegistryProcessor, ctx);
GenerateVbCommands(glRegistryProcessor, ctx);
}
// 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"));
glRegistryProcessor = new RegistryProcessor(ctx.Registry);
GenerateCommandsAndEnums(glRegistryProcessor, ctx);
GenerateExtensionsSupportClass(glRegistryProcessor, ctx);
GenerateVersionsSupportClass(glRegistryProcessor, ctx);
GenerateVbCommands(glRegistryProcessor, ctx);
}
// EGL
if ((args.Length == 0) || (Array.FindIndex(args, delegate(string item) { return(item == "--egl"); }) >= 0))
{
ctx = new RegistryContext("Egl", Path.Combine(BasePath, "GLSpecs/egl.xml"));
glRegistryProcessor = new RegistryProcessor(ctx.Registry);
GenerateCommandsAndEnums(glRegistryProcessor, ctx);
GenerateExtensionsSupportClass(glRegistryProcessor, ctx);
GenerateVersionsSupportClass(glRegistryProcessor, ctx);
GenerateVbCommands(glRegistryProcessor, ctx);
}
// OpenWF
_OutputBasePath = "OpenWF.Net";
_Namespace = "OpenWF";
// OpenWF(C)
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);
}
RegistryDocumentation.CloseLog();
}
private static void GenerateVersionsSupportClass(RegistryProcessor glRegistryProcessor, RegistryContext ctx)
{
string path = String.Format("OpenGL.NET/{0}.Versions.cs", ctx.Class);
Console.WriteLine("Generate version support class to {0}.", path);
using (SourceStreamWriter sw = new SourceStreamWriter(Path.Combine(BasePath, path), false)) {
RegistryProcessor.GenerateLicensePreamble(sw);
sw.WriteLine("namespace OpenGL");
sw.WriteLine("{");
sw.Indent();
sw.WriteLine("public partial class {0}", ctx.Class);
sw.WriteLine("{");
sw.Indent();
sw.WriteLine("#region Known Versions Constants");
sw.WriteLine();
foreach (Feature featureVersion in ctx.Registry.Features)
{
if (featureVersion.Number == null)
{
continue;
}
// Determine version value (support up to 3 version numbers)
Match versionMatch = Regex.Match(featureVersion.Number, @"(?<Major>\d+)\.(?<Minor>\d+)(\.(?<Rev>\d+))?");
if (versionMatch.Success == false)
{
continue;
}
int versionMajor = Int32.Parse(versionMatch.Groups["Major"].Value);
int versionMinor = Int32.Parse(versionMatch.Groups["Minor"].Value);
int versionRev = versionMatch.Groups["Rev"].Success ? Int32.Parse(versionMatch.Groups["Rev"].Value) : 0;
int versionValue = versionMajor * 100 + versionMinor * 10 + versionRev;
// Determine version name
string versionName = String.Format("Version_{0}", versionValue);
if (featureVersion.IsEsVersion)
{
versionName = String.Format("Version_{0}ES", versionValue);
}
sw.WriteLine("/// <summary>");
sw.WriteLine("/// Version for {0} API.", SpecificationStyle.GetKhronosVersionHumanReadable(featureVersion.Name));
sw.WriteLine("/// </summary>");
sw.WriteLine("public const int {0} = {1};", versionName, versionValue);
sw.WriteLine();
}
sw.WriteLine("#endregion");
sw.WriteLine();
sw.Unindent();
sw.WriteLine("}");
sw.Unindent();
sw.WriteLine();
sw.WriteLine("}");
}
}
