added glad generator and a glad runtime

tools/glad-0.1.14a0/glad/lang/volt/__init__.py

@@ -0,0 +1,25 @@
+from glad.lang.volt.loader.egl import EGLVoltLoader
+from glad.lang.volt.loader.gl import OpenGLVoltLoader
+from glad.lang.volt.loader.glx import GLXVoltLoader
+from glad.lang.volt.loader.wgl import WGLVoltLoader
+
+from glad.lang.volt.generator import VoltGenerator
+
+
+_specs = {
+    'egl': EGLVoltLoader,
+    'gl': OpenGLVoltLoader,
+    'glx': GLXVoltLoader,
+    'wgl': WGLVoltLoader
+}
+
+_generators = {
+    'volt': VoltGenerator,
+}
+
+
+def get_generator(name, spec):
+    gen = _generators.get(name)
+    loader = _specs.get(spec)
+
+    return gen, loader

tools/glad-0.1.14a0/glad/lang/volt/generator.py

@@ -0,0 +1,86 @@
+import sys
+
+from glad.lang.d.generator import DGenerator
+
+
+if sys.version_info >= (3, 0):
+    basestring = str
+
+
+class VoltGenerator(DGenerator):
+    NAME = 'volt'
+    NAME_LONG = 'Volt'
+
+    MODULE = 'amp'
+    LOADER = 'loader'
+    ENUMS = 'enums'
+    EXT = 'ext'
+    FUNCS = 'funcs'
+    TYPES = 'types'
+    FILE_EXTENSION = '.volt'
+    API = ''
+
+    LOAD_GL_NAME = 'load'
+
+    @property
+    def PACKAGE(self):
+        return 'package'
+
+    def write_module(self, fobj, name):
+        if name == 'package':
+            fobj.write('module {}.{};\n\n'.format(self.MODULE, self.spec.NAME))
+        else:
+            DGenerator.write_module(self, fobj, name)
+
+    def write_prototype_pre(self, fobj):
+        fobj.write('extern(System) @loadDynamic {\n')
+
+    def write_prototype_post(self, fobj):
+        fobj.write('}\n')
+
+    def write_function_pre(self, fobj):
+        pass
+
+    def write_function_post(self, fobj):
+        pass
+
+    def write_shared(self, fobj):
+        fobj.write('global {\n')
+
+    def write_shared_end(self, fobj):
+        fobj.write('}\n')
+
+    def write_function(self, fobj, func):
+        pass
+
+    def write_function_prototype(self, fobj, func):
+        fobj.write('{} {}('
+                .format(func.proto.ret.to_volt(), func.proto.name))
+        fobj.write(', '.join(param.type.to_volt() for param in func.params))
+        fobj.write(');\n')
+
+    def write_boolean(self, fobj, name, **kwargs):
+        fobj.write('global bool {};\n'.format(name))
+
+    def write_enum(self, fobj, name, value, type_='uint'):
+        if isinstance(value, basestring):
+            if value.startswith('0x') and type_.startswith('u'):
+                value += 'U'
+            if len(value) > 12 and type_.startswith('u'):
+                value += 'L'
+
+        try:
+            v = int(value)
+            if v < 0:
+                type_ = 'int'
+        except ValueError:
+            pass
+
+        if isinstance(value, basestring) and '"' in value:
+            type_ = 'const(char)*'
+
+        fobj.write('enum {} {} = {};\n'.format(type_, name, value))
+
+    def write_opaque_struct(self, fobj, name):
+        fobj.write('struct _{name} {{}}\nalias {name} = _{name}*;\n'.format(name=name))
+

tools/glad-0.1.14a0/glad/lang/volt/loader/__init__.py

@@ -0,0 +1,64 @@
+
+LOAD_OPENGL_DLL = '''
+private global Library libGL;
+extern(System) private alias gladGetProcAddressPtrType = void* function(const(char)*);
+private global gladGetProcAddressPtrType gladGetProcAddressPtr;
+
+%(pre)s
+bool %(init)s() {
+    version(Windows) {
+        libGL = Library.load("opengl32.dll");
+    } else version(OSX) {
+        libGL = Library.loads([
+            "../Frameworks/OpenGL.framework/OpenGL",
+            "/Library/Frameworks/OpenGL.framework/OpenGL",
+            "/System/Library/Frameworks/OpenGL.framework/OpenGL",
+            "/System/Library/Frameworks/OpenGL.framework/Versions/Current/OpenGL"
+        ]);
+    } else {
+        libGL = Library.loads(["libGL.so.1", "libGL.so"]);
+    }
+
+    if(libGL !is null) {
+        version(Windows) {
+            string sym = "wglGetProcAddress";
+        } else {
+            string sym = "glXGetProcAddressARB";
+        }
+        // returns null on OSX, but that's fine
+        gladGetProcAddressPtr = cast(typeof(gladGetProcAddressPtr))libGL.symbol(sym);
+        return true;
+    }
+
+    return false;
+}
+
+private struct StructToDg {
+    void* instance;
+    void* func;
+}
+
+%(pre)s
+void* %(proc)s(string name) {
+    if(libGL is null) return null;
+    void* result;
+
+    if(gladGetProcAddressPtr !is null) {
+        // TODO: name.ptr
+        result = gladGetProcAddressPtr(name.ptr);
+    }
+    if(result is null) {
+        result = libGL.symbol(name);
+    }
+
+    return result;
+}
+
+%(pre)s
+void %(terminate)s() {
+    if(libGL !is null) {
+        libGL.free();
+    }
+    return;
+}
+'''

tools/glad-0.1.14a0/glad/lang/volt/loader/egl.py

@@ -0,0 +1,48 @@
+from glad.lang.common.loader import BaseLoader
+from glad.lang.d.loader.egl import _EGL_HAS_EXT as _D_EGL_HAS_EXT
+
+
+_EGL_LOADER = '''
+private struct StructToDg {
+    void* instance;
+    void* func;
+}
+
+private void* get_proc(string name) {
+    return eglGetProcAddress(arg.ptr);
+}
+
+bool gladLoadEGL() {
+    StructToDg structToDg;
+    structToDg.func = cast(void*)get_proc;
+    auto dg = *cast(Loader*)&structToDg;
+
+    return gladLoadEGL(dg);
+}
+'''
+_EGL_HAS_EXT = _D_EGL_HAS_EXT
+
+
+class EGLVoltLoader(BaseLoader):
+    def write_header_end(self, fobj):
+        pass
+
+    def write_header(self, fobj):
+        pass
+
+    def write(self, fobj):
+        fobj.write('import watt.library;\n')
+        if not self.disabled:
+            fobj.write(_EGL_LOADER)
+
+    def write_begin_load(self, fobj):
+        pass
+
+    def write_end_load(self, fobj):
+        fobj.write('\treturn true;')
+
+    def write_find_core(self, fobj):
+        pass
+
+    def write_has_ext(self, fobj):
+        fobj.write(_EGL_HAS_EXT)

tools/glad-0.1.14a0/glad/lang/volt/loader/gl.py

@@ -0,0 +1,60 @@
+from glad.lang.common.loader import BaseLoader
+from glad.lang.volt.loader import LOAD_OPENGL_DLL
+from glad.lang.d.loader.gl import _OPENGL_HAS_EXT as _D_OPENGL_HAS_EXT
+
+
+_OPENGL_LOADER = \
+    LOAD_OPENGL_DLL % {'pre':'private', 'init':'open_gl',
+                       'proc':'get_proc', 'terminate':'close_gl'} + '''
+bool gladLoadGL() {
+    StructToDg structToDg;
+    structToDg.func = cast(void*)get_proc;
+    auto dg = *cast(Loader*)&structToDg;
+
+    bool status = false;
+
+    if(open_gl()) {
+        status = gladLoadGL(dg);
+        close_gl();
+    }
+
+    return status;
+}
+'''
+
+_OPENGL_HAS_EXT = (
+    'global int GL_MAJOR = 0;\nglobal int GL_MINOR = 0;' +
+    '\n'.join(l for l in _D_OPENGL_HAS_EXT.replace('@nogc', '').splitlines() if 'struct' not in l)
+        .replace('GLVersion.major', 'GL_MAJOR') +
+    '\n\n'
+)
+
+
+class OpenGLVoltLoader(BaseLoader):
+    def write_header_end(self, fobj):
+        pass
+
+    def write_header(self, fobj):
+        pass
+
+    def write(self, fobj):
+        fobj.write('import watt.library;\n')
+        if not self.disabled and 'gl' in self.apis:
+            fobj.write(_OPENGL_LOADER)
+
+    def write_begin_load(self, fobj):
+        fobj.write('\tglGetString = cast(typeof(glGetString))load("glGetString");\n')
+        fobj.write('\tif(glGetString is null) { return false; }\n')
+        fobj.write('\tif(glGetString(GL_VERSION) is null) { return false; }\n\n')
+
+    def write_end_load(self, fobj):
+        fobj.write('\treturn GL_MAJOR != 0 || GL_MINOR != 0;\n')
+
+    def write_find_core(self, fobj):
+        fobj.write('\tconst(char)* v = cast(const(char)*)glGetString(GL_VERSION);\n')
+        fobj.write('\tint major = v[0] - \'0\';\n')
+        fobj.write('\tint minor = v[2] - \'0\';\n')
+        fobj.write('\tGL_MAJOR = major; GL_MINOR = minor;\n')
+
+    def write_has_ext(self, fobj):
+        fobj.write(_OPENGL_HAS_EXT)

tools/glad-0.1.14a0/glad/lang/volt/loader/glx.py

@@ -0,0 +1,47 @@
+from glad.lang.common.loader import BaseLoader
+from glad.lang.volt.loader import LOAD_OPENGL_DLL
+
+
+_GLX_LOADER = \
+    LOAD_OPENGL_DLL % {'pre':'private', 'init':'open_gl',
+                       'proc':'get_proc', 'terminate':'close_gl'} + '''
+bool gladLoadGLX() {
+    StructToDg structToDg;
+    structToDg.func = cast(void*)get_proc;
+    auto dg = *cast(Loader*)&structToDg;
+
+    bool status = false;
+
+    if(open_gl()) {
+        status = gladLoadGLX(dg);
+        close_gl();
+    }
+
+    return status;
+}
+'''
+
+_GLX_HAS_EXT = '''
+private bool has_ext(const(char)* name) {
+    return true;
+}
+'''
+
+
+class GLXVoltLoader(BaseLoader):
+    def write(self, fobj):
+        fobj.write('import watt.library;\n')
+        if not self.disabled:
+            fobj.write(_GLX_LOADER)
+
+    def write_begin_load(self, fobj):
+        pass
+
+    def write_end_load(self, fobj):
+        fobj.write('\treturn true;\n')
+
+    def write_find_core(self, fobj):
+        pass
+
+    def write_has_ext(self, fobj):
+        fobj.write(_GLX_HAS_EXT)

tools/glad-0.1.14a0/glad/lang/volt/loader/wgl.py

@@ -0,0 +1,35 @@
+from glad.lang.common.loader import BaseLoader
+from glad.lang.volt.loader.glx import _GLX_LOADER
+
+
+_WGL_LOADER = _GLX_LOADER.replace('GLX', 'WGL')
+_WGL_HAS_EXT = '''
+private bool has_ext(const(char)* name) {
+    return true;
+}
+'''
+
+
+class WGLVoltLoader(BaseLoader):
+    def write_header_end(self, fobj):
+        pass
+
+    def write_header(self, fobj):
+        pass
+
+    def write(self, fobj):
+        fobj.write('import watt.library;\n')
+        if not self.disabled:
+            fobj.write(_WGL_LOADER)
+
+    def write_begin_load(self, fobj):
+        pass
+
+    def write_end_load(self, fobj):
+        fobj.write('\treturn true;\n')
+
+    def write_find_core(self, fobj):
+        pass
+
+    def write_has_ext(self, fobj):
+        fobj.write(_WGL_HAS_EXT)