Remove glad and replace it with our own GL header

This completely removes the dependency on glad by generating the GL
headers from gl.xml directly.

This requires adding khrplatform.h so all Khronos dependencies are
gathered in third_party/khronos.

Also removes a stray CMakeLists.txt that was still hanging out.

BUG=dawn:165

Change-Id: Ia64bc51bc8b18c6b48613918e2f309f7405ecb3b
Reviewed-on: https://dawn-review.googlesource.com/c/dawn/+/8163
Commit-Queue: Corentin Wallez <cwallez@chromium.org>
Reviewed-by: Austin Eng <enga@chromium.org>

generator/opengl_loader_generator.py

@@ -19,7 +19,7 @@ import xml.etree.ElementTree as etree
 
 from generator_lib import Generator, run_generator, FileRender
 
-class Proc:
+class ProcName:
     def __init__(self, gl_name, proc_name=None):
         assert(gl_name.startswith('gl'))
         if proc_name == None:
@@ -40,54 +40,137 @@ class Proc:
     def __repr__(self):
         return 'Proc("{}", "{}")'.format(self.gl_name, self.proc_name)
 
+ProcParam = namedtuple('ProcParam', ['name', 'type'])
+class Proc:
+    def __init__(self, element):
+        # Type declaration for return values and arguments all have the same
+        # (weird) format.
+        # <element>[A][<ptype>B</ptype>][C]<other stuff.../></element>
+        #
+        # Some examples are:
+        #   <proto>void <name>glFinish</name></proto>
+        #   <proto><ptype>GLenum</ptype><name>glFenceSync</name></proto>
+        #   <proto>const <ptype>GLubyte</ptype> *<name>glGetString</name></proto>
+        #
+        # This handles all the shapes found in gl.xml except for this one that
+        # has an array specifier after </name>:
+        #   <param><ptype>GLuint</ptype> <name>baseAndCount</name>[2]</param>
+        def parse_type_declaration(element):
+            result = ''
+            if element.text != None:
+                result += element.text
+            ptype = element.find('ptype')
+            if ptype != None:
+                result += ptype.text
+                if ptype.tail != None:
+                    result += ptype.tail
+            return result.strip()
+
+        proto = element.find('proto')
+
+        self.return_type = parse_type_declaration(proto)
+
+        self.params = []
+        for param in element.findall('./param'):
+            self.params.append(ProcParam(param.find('name').text, parse_type_declaration(param)))
+
+        self.gl_name = proto.find('name').text
+        self.alias = None
+        if element.find('alias') != None:
+            self.alias = element.find('alias').attrib['name']
+
+    def glProcName(self):
+        return self.gl_name
+
+    def ProcName(self):
+        assert(self.gl_name.startswith('gl'))
+        return self.gl_name[2:]
+
+    def PFNGLPROCNAME(self):
+        return 'PFN' + self.gl_name.upper() + 'PROC'
+
+    def __repr__(self):
+        return 'Proc("{}")'.format(self.gl_name)
+
+EnumDefine = namedtuple('EnumDefine', ['name', 'value'])
 Version = namedtuple('Version', ['major', 'minor'])
-VersionProcBlock = namedtuple('ProcBlock', ['version', 'procs'])
-HeaderProcBlock = namedtuple('ProcBlock', ['description', 'procs'])
+VersionBlock = namedtuple('VersionBlock', ['version', 'procs', 'enums'])
+HeaderBlock = namedtuple('HeaderBlock', ['description', 'procs', 'enums'])
 
 def parse_version(version):
     return Version(*map(int, version.split('.')))
 
+
 def compute_params(root):
-    # Add proc blocks for OpenGL ES
-    gles_blocks = []
-    for gles_section in root.findall('''feature[@api='gles2']'''):
-        section_procs = []
-        for proc in gles_section.findall('./require/command'):
-            section_procs.append(Proc(proc.attrib['name']))
-        gles_blocks.append(VersionProcBlock(parse_version(gles_section.attrib['number']), section_procs))
+    # Parse all the commands and enums
+    all_procs = {}
+    for command in root.findall('''commands[@namespace='GL']/command'''):
+        proc = Proc(command)
+        assert(proc.gl_name not in all_procs)
+        all_procs[proc.gl_name] = proc
+
+    all_enums = {}
+    for enum in root.findall('''enums[@namespace='GL']/enum'''):
+        enum_name = enum.attrib['name']
+        # Special case an enum we'll never use that has different values in GL and GLES
+        if enum_name == 'GL_ACTIVE_PROGRAM_EXT':
+            continue
+
+        assert(enum_name not in all_enums)
+        all_enums[enum_name] = EnumDefine(enum_name, enum.attrib['value'])
 
     # Get the list of all Desktop OpenGL function removed by the Core Profile.
     core_removed_procs = set()
-    for removed_section in root.findall('feature/remove'):
-        assert(removed_section.attrib['profile'] == 'core')
-        for proc in removed_section.findall('./command'):
-            core_removed_procs.add(proc.attrib['name'])
+    for proc in root.findall('''feature/remove[@profile='core']/command'''):
+        core_removed_procs.add(proc.attrib['name'])
 
-    # Add proc blocks for Desktop GL
-    desktop_gl_blocks = []
-    for gl_section in root.findall('''feature[@api='gl']'''):
-        section_procs = []
-        for proc in gl_section.findall('./require/command'):
-            if proc.attrib['name'] not in core_removed_procs:
-                section_procs.append(Proc(proc.attrib['name']))
-        desktop_gl_blocks.append(VersionProcBlock(parse_version(gl_section.attrib['number']), section_procs))
+    # Get list of enums and procs per OpenGL ES/Desktop OpenGL version
+    def parse_version_blocks(api, removed_procs = set()):
+        blocks = []
+        for section in root.findall('''feature[@api='{}']'''.format(api)):
+            section_procs = []
+            for command in section.findall('./require/command'):
+                proc_name = command.attrib['name']
+                assert(all_procs[proc_name].alias == None)
+                if proc_name not in removed_procs:
+                    section_procs.append(all_procs[proc_name])
 
+            section_enums = []
+            for enum in section.findall('./require/enum'):
+                section_enums.append(all_enums[enum.attrib['name']])
+
+            blocks.append(VersionBlock(parse_version(section.attrib['number']), section_procs, section_enums))
+
+        return blocks
+
+    gles_blocks = parse_version_blocks('gles2')
+    desktop_gl_blocks = parse_version_blocks('gl', core_removed_procs)
+
+    # Compute the blocks for headers such that there is no duplicate definition
     already_added_header_procs = set()
+    already_added_header_enums = set()
     header_blocks = []
-    def add_header_block(description, procs):
+    def add_header_block(description, block):
         block_procs = []
-        for proc in procs:
+        for proc in block.procs:
             if not proc.glProcName() in already_added_header_procs:
                 already_added_header_procs.add(proc.glProcName())
                 block_procs.append(proc)
-        if len(block_procs) > 0:
-            header_blocks.append(HeaderProcBlock(description, block_procs))
+
+        block_enums = []
+        for enum in block.enums:
+            if not enum.name in already_added_header_enums:
+                already_added_header_enums.add(enum.name)
+                block_enums.append(enum)
+
+        if len(block_procs) > 0 or len(block_enums) > 0:
+            header_blocks.append(HeaderBlock(description, block_procs, block_enums))
 
     for block in gles_blocks:
-        add_header_block('OpenGL ES {}.{}'.format(block.version.major, block.version.minor), block.procs)
+        add_header_block('OpenGL ES {}.{}'.format(block.version.major, block.version.minor), block)
 
     for block in desktop_gl_blocks:
-        add_header_block('Desktop OpenGL {}.{}'.format(block.version.major, block.version.minor), block.procs)
+        add_header_block('Desktop OpenGL {}.{}'.format(block.version.major, block.version.minor), block)
 
     return {
         'gles_blocks': gles_blocks,
@@ -108,6 +191,7 @@ class OpenGLLoaderGenerator(Generator):
         return [
             FileRender('opengl/OpenGLFunctionsBase.cpp', 'dawn_native/opengl/OpenGLFunctionsBase_autogen.cpp', [params]),
             FileRender('opengl/OpenGLFunctionsBase.h', 'dawn_native/opengl/OpenGLFunctionsBase_autogen.h', [params]),
+            FileRender('opengl/opengl_platform.h', 'dawn_native/opengl/opengl_platform_autogen.h', [params]),
         ]
 
     def get_dependencies(self, args):