diff --git a/3rdparty/EGL/egl.d b/3rdparty/EGL/egl.d new file mode 100644 index 00000000..de7e18dc --- /dev/null +++ b/3rdparty/EGL/egl.d @@ -0,0 +1,183 @@ +/* dstep -I/path/to/ndk-r9d/toolchains/llvm-3.4/prebuilt/linux-x86/lib/clang/3.4/include /path/to/ndk-r9d/platforms/android-9/arch-x86/usr/include/EGL/egl.h -o egl.d*/ + +module EGL.egl; + +import EGL.eglplatform; + +version (Android): +extern (C): +@system: +nothrow: +@nogc: + +alias uint EGLBoolean; +alias uint EGLenum; +alias void* EGLConfig; +alias void* EGLContext; +alias void* EGLDisplay; +alias void* EGLSurface; +alias void* EGLClientBuffer; +alias void function() __eglMustCastToProperFunctionPointerType; + +enum EGL_VERSION_1_0 = 1; +enum EGL_VERSION_1_1 = 1; +enum EGL_VERSION_1_2 = 1; +enum EGL_VERSION_1_3 = 1; +enum EGL_VERSION_1_4 = 1; +enum EGL_FALSE = 0; +enum EGL_TRUE = 1; +enum EGL_DEFAULT_DISPLAY = null; +enum EGL_NO_CONTEXT = null; +enum EGL_NO_DISPLAY = null; +enum EGL_NO_SURFACE = null; +enum EGL_DONT_CARE = -1; +enum EGL_SUCCESS = 0x3000; +enum EGL_NOT_INITIALIZED = 0x3001; +enum EGL_BAD_ACCESS = 0x3002; +enum EGL_BAD_ALLOC = 0x3003; +enum EGL_BAD_ATTRIBUTE = 0x3004; +enum EGL_BAD_CONFIG = 0x3005; +enum EGL_BAD_CONTEXT = 0x3006; +enum EGL_BAD_CURRENT_SURFACE = 0x3007; +enum EGL_BAD_DISPLAY = 0x3008; +enum EGL_BAD_MATCH = 0x3009; +enum EGL_BAD_NATIVE_PIXMAP = 0x300A; +enum EGL_BAD_NATIVE_WINDOW = 0x300B; +enum EGL_BAD_PARAMETER = 0x300C; +enum EGL_BAD_SURFACE = 0x300D; +enum EGL_CONTEXT_LOST = 0x300E; +enum EGL_BUFFER_SIZE = 0x3020; +enum EGL_ALPHA_SIZE = 0x3021; +enum EGL_BLUE_SIZE = 0x3022; +enum EGL_GREEN_SIZE = 0x3023; +enum EGL_RED_SIZE = 0x3024; +enum EGL_DEPTH_SIZE = 0x3025; +enum EGL_STENCIL_SIZE = 0x3026; +enum EGL_CONFIG_CAVEAT = 0x3027; +enum EGL_CONFIG_ID = 0x3028; +enum EGL_LEVEL = 0x3029; +enum EGL_MAX_PBUFFER_HEIGHT = 0x302A; +enum EGL_MAX_PBUFFER_PIXELS = 0x302B; +enum EGL_MAX_PBUFFER_WIDTH = 0x302C; +enum EGL_NATIVE_RENDERABLE = 0x302D; +enum EGL_NATIVE_VISUAL_ID = 0x302E; +enum EGL_NATIVE_VISUAL_TYPE = 0x302F; +enum EGL_SAMPLES = 0x3031; +enum EGL_SAMPLE_BUFFERS = 0x3032; +enum EGL_SURFACE_TYPE = 0x3033; +enum EGL_TRANSPARENT_TYPE = 0x3034; +enum EGL_TRANSPARENT_BLUE_VALUE = 0x3035; +enum EGL_TRANSPARENT_GREEN_VALUE = 0x3036; +enum EGL_TRANSPARENT_RED_VALUE = 0x3037; +enum EGL_NONE = 0x3038; +enum EGL_BIND_TO_TEXTURE_RGB = 0x3039; +enum EGL_BIND_TO_TEXTURE_RGBA = 0x303A; +enum EGL_MIN_SWAP_INTERVAL = 0x303B; +enum EGL_MAX_SWAP_INTERVAL = 0x303C; +enum EGL_LUMINANCE_SIZE = 0x303D; +enum EGL_ALPHA_MASK_SIZE = 0x303E; +enum EGL_COLOR_BUFFER_TYPE = 0x303F; +enum EGL_RENDERABLE_TYPE = 0x3040; +enum EGL_MATCH_NATIVE_PIXMAP = 0x3041; +enum EGL_CONFORMANT = 0x3042; +enum EGL_SLOW_CONFIG = 0x3050; +enum EGL_NON_CONFORMANT_CONFIG = 0x3051; +enum EGL_TRANSPARENT_RGB = 0x3052; +enum EGL_RGB_BUFFER = 0x308E; +enum EGL_LUMINANCE_BUFFER = 0x308F; +enum EGL_NO_TEXTURE = 0x305C; +enum EGL_TEXTURE_RGB = 0x305D; +enum EGL_TEXTURE_RGBA = 0x305E; +enum EGL_TEXTURE_2D = 0x305F; +enum EGL_PBUFFER_BIT = 0x0001; +enum EGL_PIXMAP_BIT = 0x0002; +enum EGL_WINDOW_BIT = 0x0004; +enum EGL_VG_COLORSPACE_LINEAR_BIT = 0x0020; +enum EGL_VG_ALPHA_FORMAT_PRE_BIT = 0x0040; +enum EGL_MULTISAMPLE_RESOLVE_BOX_BIT = 0x0200; +enum EGL_SWAP_BEHAVIOR_PRESERVED_BIT = 0x0400; +enum EGL_OPENGL_ES_BIT = 0x0001; +enum EGL_OPENVG_BIT = 0x0002; +enum EGL_OPENGL_ES2_BIT = 0x0004; +enum EGL_OPENGL_BIT = 0x0008; +enum EGL_VENDOR = 0x3053; +enum EGL_VERSION = 0x3054; +enum EGL_EXTENSIONS = 0x3055; +enum EGL_CLIENT_APIS = 0x308D; +enum EGL_HEIGHT = 0x3056; +enum EGL_WIDTH = 0x3057; +enum EGL_LARGEST_PBUFFER = 0x3058; +enum EGL_TEXTURE_FORMAT = 0x3080; +enum EGL_TEXTURE_TARGET = 0x3081; +enum EGL_MIPMAP_TEXTURE = 0x3082; +enum EGL_MIPMAP_LEVEL = 0x3083; +enum EGL_RENDER_BUFFER = 0x3086; +enum EGL_VG_COLORSPACE = 0x3087; +enum EGL_VG_ALPHA_FORMAT = 0x3088; +enum EGL_HORIZONTAL_RESOLUTION = 0x3090; +enum EGL_VERTICAL_RESOLUTION = 0x3091; +enum EGL_PIXEL_ASPECT_RATIO = 0x3092; +enum EGL_SWAP_BEHAVIOR = 0x3093; +enum EGL_MULTISAMPLE_RESOLVE = 0x3099; +enum EGL_BACK_BUFFER = 0x3084; +enum EGL_SINGLE_BUFFER = 0x3085; +enum EGL_VG_COLORSPACE_sRGB = 0x3089; +enum EGL_VG_COLORSPACE_LINEAR = 0x308A; +enum EGL_VG_ALPHA_FORMAT_NONPRE = 0x308B; +enum EGL_VG_ALPHA_FORMAT_PRE = 0x308C; +enum EGL_DISPLAY_SCALING = 10000; +enum EGL_UNKNOWN = -1; +enum EGL_BUFFER_PRESERVED = 0x3094; +enum EGL_BUFFER_DESTROYED = 0x3095; +enum EGL_OPENVG_IMAGE = 0x3096; +enum EGL_CONTEXT_CLIENT_TYPE = 0x3097; +enum EGL_CONTEXT_CLIENT_VERSION = 0x3098; +enum EGL_MULTISAMPLE_RESOLVE_DEFAULT = 0x309A; +enum EGL_MULTISAMPLE_RESOLVE_BOX = 0x309B; +enum EGL_OPENGL_ES_API = 0x30A0; +enum EGL_OPENVG_API = 0x30A1; +enum EGL_OPENGL_API = 0x30A2; +enum EGL_DRAW = 0x3059; +enum EGL_READ = 0x305A; +enum EGL_CORE_NATIVE_ENGINE = 0x305B; +enum EGL_COLORSPACE = EGL_VG_COLORSPACE; +enum EGL_ALPHA_FORMAT = EGL_VG_ALPHA_FORMAT; +enum EGL_COLORSPACE_sRGB = EGL_VG_COLORSPACE_sRGB; +enum EGL_COLORSPACE_LINEAR = EGL_VG_COLORSPACE_LINEAR; +enum EGL_ALPHA_FORMAT_NONPRE = EGL_VG_ALPHA_FORMAT_NONPRE; +enum EGL_ALPHA_FORMAT_PRE = EGL_VG_ALPHA_FORMAT_PRE; + +EGLint eglGetError(); +EGLDisplay eglGetDisplay(EGLNativeDisplayType display_id); +EGLBoolean eglInitialize(EGLDisplay dpy, EGLint* major, EGLint* minor); +EGLBoolean eglTerminate(EGLDisplay dpy); +const(char)* eglQueryString(EGLDisplay dpy, EGLint name); +EGLBoolean eglGetConfigs(EGLDisplay dpy, EGLConfig* configs, EGLint config_size, EGLint* num_config); +EGLBoolean eglChooseConfig(EGLDisplay dpy, const(EGLint)* attrib_list, EGLConfig* configs, EGLint config_size, EGLint* num_config); +EGLBoolean eglGetConfigAttrib(EGLDisplay dpy, EGLConfig config, EGLint attribute, EGLint* value); +EGLSurface eglCreateWindowSurface(EGLDisplay dpy, EGLConfig config, EGLNativeWindowType win, const(EGLint)* attrib_list); +EGLSurface eglCreatePbufferSurface(EGLDisplay dpy, EGLConfig config, const(EGLint)* attrib_list); +EGLSurface eglCreatePixmapSurface(EGLDisplay dpy, EGLConfig config, EGLNativePixmapType pixmap, const(EGLint)* attrib_list); +EGLBoolean eglDestroySurface(EGLDisplay dpy, EGLSurface surface); +EGLBoolean eglQuerySurface(EGLDisplay dpy, EGLSurface surface, EGLint attribute, EGLint* value); +EGLBoolean eglBindAPI(EGLenum api); +EGLenum eglQueryAPI(); +EGLBoolean eglWaitClient(); +EGLBoolean eglReleaseThread(); +EGLSurface eglCreatePbufferFromClientBuffer(EGLDisplay dpy, EGLenum buftype, EGLClientBuffer buffer, EGLConfig config, const(EGLint)* attrib_list); +EGLBoolean eglSurfaceAttrib(EGLDisplay dpy, EGLSurface surface, EGLint attribute, EGLint value); +EGLBoolean eglBindTexImage(EGLDisplay dpy, EGLSurface surface, EGLint buffer); +EGLBoolean eglReleaseTexImage(EGLDisplay dpy, EGLSurface surface, EGLint buffer); +EGLBoolean eglSwapInterval(EGLDisplay dpy, EGLint interval); +EGLContext eglCreateContext(EGLDisplay dpy, EGLConfig config, EGLContext share_context, const(EGLint)* attrib_list); +EGLBoolean eglDestroyContext(EGLDisplay dpy, EGLContext ctx); +EGLBoolean eglMakeCurrent(EGLDisplay dpy, EGLSurface draw, EGLSurface read, EGLContext ctx); +EGLContext eglGetCurrentContext(); +EGLSurface eglGetCurrentSurface(EGLint readdraw); +EGLDisplay eglGetCurrentDisplay(); +EGLBoolean eglQueryContext(EGLDisplay dpy, EGLContext ctx, EGLint attribute, EGLint* value); +EGLBoolean eglWaitGL(); +EGLBoolean eglWaitNative(EGLint engine); +EGLBoolean eglSwapBuffers(EGLDisplay dpy, EGLSurface surface); +EGLBoolean eglCopyBuffers(EGLDisplay dpy, EGLSurface surface, EGLNativePixmapType target); +__eglMustCastToProperFunctionPointerType eglGetProcAddress(const(char)* procname); diff --git a/3rdparty/EGL/eglplatform.d b/3rdparty/EGL/eglplatform.d new file mode 100644 index 00000000..f4e2afd4 --- /dev/null +++ b/3rdparty/EGL/eglplatform.d @@ -0,0 +1,21 @@ +/* dstep -I/path/to/ndk-r9d/toolchains/llvm-3.4/prebuilt/linux-x86/lib/clang/3.4/include /path/to/ndk-r9d/platforms/android-9/arch-x86/usr/include/EGL/eglplatform.h -o eglplatform.d*/ + +module EGL.eglplatform; + +import android.native_window; + +version (Android): +extern (C): +@system: +nothrow: +@nogc: + +struct egl_native_pixmap_t; + +alias ANativeWindow* EGLNativeWindowType; +alias egl_native_pixmap_t* EGLNativePixmapType; +alias void* EGLNativeDisplayType; +alias EGLNativeDisplayType NativeDisplayType; +alias EGLNativePixmapType NativePixmapType; +alias EGLNativeWindowType NativeWindowType; +alias int EGLint; diff --git a/3rdparty/GLES/gl.d b/3rdparty/GLES/gl.d new file mode 100644 index 00000000..0cf3d40d --- /dev/null +++ b/3rdparty/GLES/gl.d @@ -0,0 +1,510 @@ +/* dstep /path/to/ndk-r9d/platforms/android-9/arch-x86/usr/include/GLES/gl.h -o gl.d*/ + +module GLES.gl; + +import core.stdc.config; + +version (Android): +extern (C): +@system: +nothrow: +@nogc: + +alias void GLvoid; +alias char GLchar; +alias uint GLenum; +alias ubyte GLboolean; +alias uint GLbitfield; +alias byte GLbyte; +alias short GLshort; +alias int GLint; +alias int GLsizei; +alias ubyte GLubyte; +alias ushort GLushort; +alias uint GLuint; +alias float GLfloat; +alias float GLclampf; +alias int GLfixed; +alias int GLclampx; +alias c_long GLintptr; +alias c_long GLsizeiptr; + +enum GL_VERSION_ES_CM_1_0 = 1; +enum GL_VERSION_ES_CL_1_0 = 1; +enum GL_VERSION_ES_CM_1_1 = 1; +enum GL_VERSION_ES_CL_1_1 = 1; +enum GL_DEPTH_BUFFER_BIT = 0x00000100; +enum GL_STENCIL_BUFFER_BIT = 0x00000400; +enum GL_COLOR_BUFFER_BIT = 0x00004000; +enum GL_FALSE = 0; +enum GL_TRUE = 1; +enum GL_POINTS = 0x0000; +enum GL_LINES = 0x0001; +enum GL_LINE_LOOP = 0x0002; +enum GL_LINE_STRIP = 0x0003; +enum GL_TRIANGLES = 0x0004; +enum GL_TRIANGLE_STRIP = 0x0005; +enum GL_TRIANGLE_FAN = 0x0006; +enum GL_NEVER = 0x0200; +enum GL_LESS = 0x0201; +enum GL_EQUAL = 0x0202; +enum GL_LEQUAL = 0x0203; +enum GL_GREATER = 0x0204; +enum GL_NOTEQUAL = 0x0205; +enum GL_GEQUAL = 0x0206; +enum GL_ALWAYS = 0x0207; +enum GL_ZERO = 0; +enum GL_ONE = 1; +enum GL_SRC_COLOR = 0x0300; +enum GL_ONE_MINUS_SRC_COLOR = 0x0301; +enum GL_SRC_ALPHA = 0x0302; +enum GL_ONE_MINUS_SRC_ALPHA = 0x0303; +enum GL_DST_ALPHA = 0x0304; +enum GL_ONE_MINUS_DST_ALPHA = 0x0305; +enum GL_DST_COLOR = 0x0306; +enum GL_ONE_MINUS_DST_COLOR = 0x0307; +enum GL_SRC_ALPHA_SATURATE = 0x0308; +enum GL_CLIP_PLANE0 = 0x3000; +enum GL_CLIP_PLANE1 = 0x3001; +enum GL_CLIP_PLANE2 = 0x3002; +enum GL_CLIP_PLANE3 = 0x3003; +enum GL_CLIP_PLANE4 = 0x3004; +enum GL_CLIP_PLANE5 = 0x3005; +enum GL_FRONT = 0x0404; +enum GL_BACK = 0x0405; +enum GL_FRONT_AND_BACK = 0x0408; +enum GL_FOG = 0x0B60; +enum GL_LIGHTING = 0x0B50; +enum GL_TEXTURE_2D = 0x0DE1; +enum GL_CULL_FACE = 0x0B44; +enum GL_ALPHA_TEST = 0x0BC0; +enum GL_BLEND = 0x0BE2; +enum GL_COLOR_LOGIC_OP = 0x0BF2; +enum GL_DITHER = 0x0BD0; +enum GL_STENCIL_TEST = 0x0B90; +enum GL_DEPTH_TEST = 0x0B71; +enum GL_POINT_SMOOTH = 0x0B10; +enum GL_LINE_SMOOTH = 0x0B20; +enum GL_COLOR_MATERIAL = 0x0B57; +enum GL_NORMALIZE = 0x0BA1; +enum GL_RESCALE_NORMAL = 0x803A; +enum GL_VERTEX_ARRAY = 0x8074; +enum GL_NORMAL_ARRAY = 0x8075; +enum GL_COLOR_ARRAY = 0x8076; +enum GL_TEXTURE_COORD_ARRAY = 0x8078; +enum GL_MULTISAMPLE = 0x809D; +enum GL_SAMPLE_ALPHA_TO_COVERAGE = 0x809E; +enum GL_SAMPLE_ALPHA_TO_ONE = 0x809F; +enum GL_SAMPLE_COVERAGE = 0x80A0; +enum GL_NO_ERROR = 0; +enum GL_INVALID_ENUM = 0x0500; +enum GL_INVALID_VALUE = 0x0501; +enum GL_INVALID_OPERATION = 0x0502; +enum GL_STACK_OVERFLOW = 0x0503; +enum GL_STACK_UNDERFLOW = 0x0504; +enum GL_OUT_OF_MEMORY = 0x0505; +enum GL_EXP = 0x0800; +enum GL_EXP2 = 0x0801; +enum GL_FOG_DENSITY = 0x0B62; +enum GL_FOG_START = 0x0B63; +enum GL_FOG_END = 0x0B64; +enum GL_FOG_MODE = 0x0B65; +enum GL_FOG_COLOR = 0x0B66; +enum GL_CW = 0x0900; +enum GL_CCW = 0x0901; +enum GL_CURRENT_COLOR = 0x0B00; +enum GL_CURRENT_NORMAL = 0x0B02; +enum GL_CURRENT_TEXTURE_COORDS = 0x0B03; +enum GL_POINT_SIZE = 0x0B11; +enum GL_POINT_SIZE_MIN = 0x8126; +enum GL_POINT_SIZE_MAX = 0x8127; +enum GL_POINT_FADE_THRESHOLD_SIZE = 0x8128; +enum GL_POINT_DISTANCE_ATTENUATION = 0x8129; +enum GL_SMOOTH_POINT_SIZE_RANGE = 0x0B12; +enum GL_LINE_WIDTH = 0x0B21; +enum GL_SMOOTH_LINE_WIDTH_RANGE = 0x0B22; +enum GL_ALIASED_POINT_SIZE_RANGE = 0x846D; +enum GL_ALIASED_LINE_WIDTH_RANGE = 0x846E; +enum GL_CULL_FACE_MODE = 0x0B45; +enum GL_FRONT_FACE = 0x0B46; +enum GL_SHADE_MODEL = 0x0B54; +enum GL_DEPTH_RANGE = 0x0B70; +enum GL_DEPTH_WRITEMASK = 0x0B72; +enum GL_DEPTH_CLEAR_VALUE = 0x0B73; +enum GL_DEPTH_FUNC = 0x0B74; +enum GL_STENCIL_CLEAR_VALUE = 0x0B91; +enum GL_STENCIL_FUNC = 0x0B92; +enum GL_STENCIL_VALUE_MASK = 0x0B93; +enum GL_STENCIL_FAIL = 0x0B94; +enum GL_STENCIL_PASS_DEPTH_FAIL = 0x0B95; +enum GL_STENCIL_PASS_DEPTH_PASS = 0x0B96; +enum GL_STENCIL_REF = 0x0B97; +enum GL_STENCIL_WRITEMASK = 0x0B98; +enum GL_MATRIX_MODE = 0x0BA0; +enum GL_VIEWPORT = 0x0BA2; +enum GL_MODELVIEW_STACK_DEPTH = 0x0BA3; +enum GL_PROJECTION_STACK_DEPTH = 0x0BA4; +enum GL_TEXTURE_STACK_DEPTH = 0x0BA5; +enum GL_MODELVIEW_MATRIX = 0x0BA6; +enum GL_PROJECTION_MATRIX = 0x0BA7; +enum GL_TEXTURE_MATRIX = 0x0BA8; +enum GL_ALPHA_TEST_FUNC = 0x0BC1; +enum GL_ALPHA_TEST_REF = 0x0BC2; +enum GL_BLEND_DST = 0x0BE0; +enum GL_BLEND_SRC = 0x0BE1; +enum GL_LOGIC_OP_MODE = 0x0BF0; +enum GL_SCISSOR_BOX = 0x0C10; +enum GL_SCISSOR_TEST = 0x0C11; +enum GL_COLOR_CLEAR_VALUE = 0x0C22; +enum GL_COLOR_WRITEMASK = 0x0C23; +enum GL_UNPACK_ALIGNMENT = 0x0CF5; +enum GL_PACK_ALIGNMENT = 0x0D05; +enum GL_MAX_LIGHTS = 0x0D31; +enum GL_MAX_CLIP_PLANES = 0x0D32; +enum GL_MAX_TEXTURE_SIZE = 0x0D33; +enum GL_MAX_MODELVIEW_STACK_DEPTH = 0x0D36; +enum GL_MAX_PROJECTION_STACK_DEPTH = 0x0D38; +enum GL_MAX_TEXTURE_STACK_DEPTH = 0x0D39; +enum GL_MAX_VIEWPORT_DIMS = 0x0D3A; +enum GL_MAX_TEXTURE_UNITS = 0x84E2; +enum GL_SUBPIXEL_BITS = 0x0D50; +enum GL_RED_BITS = 0x0D52; +enum GL_GREEN_BITS = 0x0D53; +enum GL_BLUE_BITS = 0x0D54; +enum GL_ALPHA_BITS = 0x0D55; +enum GL_DEPTH_BITS = 0x0D56; +enum GL_STENCIL_BITS = 0x0D57; +enum GL_POLYGON_OFFSET_UNITS = 0x2A00; +enum GL_POLYGON_OFFSET_FILL = 0x8037; +enum GL_POLYGON_OFFSET_FACTOR = 0x8038; +enum GL_TEXTURE_BINDING_2D = 0x8069; +enum GL_VERTEX_ARRAY_SIZE = 0x807A; +enum GL_VERTEX_ARRAY_TYPE = 0x807B; +enum GL_VERTEX_ARRAY_STRIDE = 0x807C; +enum GL_NORMAL_ARRAY_TYPE = 0x807E; +enum GL_NORMAL_ARRAY_STRIDE = 0x807F; +enum GL_COLOR_ARRAY_SIZE = 0x8081; +enum GL_COLOR_ARRAY_TYPE = 0x8082; +enum GL_COLOR_ARRAY_STRIDE = 0x8083; +enum GL_TEXTURE_COORD_ARRAY_SIZE = 0x8088; +enum GL_TEXTURE_COORD_ARRAY_TYPE = 0x8089; +enum GL_TEXTURE_COORD_ARRAY_STRIDE = 0x808A; +enum GL_VERTEX_ARRAY_POINTER = 0x808E; +enum GL_NORMAL_ARRAY_POINTER = 0x808F; +enum GL_COLOR_ARRAY_POINTER = 0x8090; +enum GL_TEXTURE_COORD_ARRAY_POINTER = 0x8092; +enum GL_SAMPLE_BUFFERS = 0x80A8; +enum GL_SAMPLES = 0x80A9; +enum GL_SAMPLE_COVERAGE_VALUE = 0x80AA; +enum GL_SAMPLE_COVERAGE_INVERT = 0x80AB; +enum GL_NUM_COMPRESSED_TEXTURE_FORMATS = 0x86A2; +enum GL_COMPRESSED_TEXTURE_FORMATS = 0x86A3; +enum GL_DONT_CARE = 0x1100; +enum GL_FASTEST = 0x1101; +enum GL_NICEST = 0x1102; +enum GL_PERSPECTIVE_CORRECTION_HINT = 0x0C50; +enum GL_POINT_SMOOTH_HINT = 0x0C51; +enum GL_LINE_SMOOTH_HINT = 0x0C52; +enum GL_FOG_HINT = 0x0C54; +enum GL_GENERATE_MIPMAP_HINT = 0x8192; +enum GL_LIGHT_MODEL_AMBIENT = 0x0B53; +enum GL_LIGHT_MODEL_TWO_SIDE = 0x0B52; +enum GL_AMBIENT = 0x1200; +enum GL_DIFFUSE = 0x1201; +enum GL_SPECULAR = 0x1202; +enum GL_POSITION = 0x1203; +enum GL_SPOT_DIRECTION = 0x1204; +enum GL_SPOT_EXPONENT = 0x1205; +enum GL_SPOT_CUTOFF = 0x1206; +enum GL_CONSTANT_ATTENUATION = 0x1207; +enum GL_LINEAR_ATTENUATION = 0x1208; +enum GL_QUADRATIC_ATTENUATION = 0x1209; +enum GL_BYTE = 0x1400; +enum GL_UNSIGNED_BYTE = 0x1401; +enum GL_SHORT = 0x1402; +enum GL_UNSIGNED_SHORT = 0x1403; +enum GL_FLOAT = 0x1406; +enum GL_FIXED = 0x140C; +enum GL_CLEAR = 0x1500; +enum GL_AND = 0x1501; +enum GL_AND_REVERSE = 0x1502; +enum GL_COPY = 0x1503; +enum GL_AND_INVERTED = 0x1504; +enum GL_NOOP = 0x1505; +enum GL_XOR = 0x1506; +enum GL_OR = 0x1507; +enum GL_NOR = 0x1508; +enum GL_EQUIV = 0x1509; +enum GL_INVERT = 0x150A; +enum GL_OR_REVERSE = 0x150B; +enum GL_COPY_INVERTED = 0x150C; +enum GL_OR_INVERTED = 0x150D; +enum GL_NAND = 0x150E; +enum GL_SET = 0x150F; +enum GL_EMISSION = 0x1600; +enum GL_SHININESS = 0x1601; +enum GL_AMBIENT_AND_DIFFUSE = 0x1602; +enum GL_MODELVIEW = 0x1700; +enum GL_PROJECTION = 0x1701; +enum GL_TEXTURE = 0x1702; +enum GL_ALPHA = 0x1906; +enum GL_RGB = 0x1907; +enum GL_RGBA = 0x1908; +enum GL_LUMINANCE = 0x1909; +enum GL_LUMINANCE_ALPHA = 0x190A; +enum GL_UNSIGNED_SHORT_4_4_4_4 = 0x8033; +enum GL_UNSIGNED_SHORT_5_5_5_1 = 0x8034; +enum GL_UNSIGNED_SHORT_5_6_5 = 0x8363; +enum GL_FLAT = 0x1D00; +enum GL_SMOOTH = 0x1D01; +enum GL_KEEP = 0x1E00; +enum GL_REPLACE = 0x1E01; +enum GL_INCR = 0x1E02; +enum GL_DECR = 0x1E03; +enum GL_VENDOR = 0x1F00; +enum GL_RENDERER = 0x1F01; +enum GL_VERSION = 0x1F02; +enum GL_EXTENSIONS = 0x1F03; +enum GL_MODULATE = 0x2100; +enum GL_DECAL = 0x2101; +enum GL_ADD = 0x0104; +enum GL_TEXTURE_ENV_MODE = 0x2200; +enum GL_TEXTURE_ENV_COLOR = 0x2201; +enum GL_TEXTURE_ENV = 0x2300; +enum GL_NEAREST = 0x2600; +enum GL_LINEAR = 0x2601; +enum GL_NEAREST_MIPMAP_NEAREST = 0x2700; +enum GL_LINEAR_MIPMAP_NEAREST = 0x2701; +enum GL_NEAREST_MIPMAP_LINEAR = 0x2702; +enum GL_LINEAR_MIPMAP_LINEAR = 0x2703; +enum GL_TEXTURE_MAG_FILTER = 0x2800; +enum GL_TEXTURE_MIN_FILTER = 0x2801; +enum GL_TEXTURE_WRAP_S = 0x2802; +enum GL_TEXTURE_WRAP_T = 0x2803; +enum GL_GENERATE_MIPMAP = 0x8191; +enum GL_TEXTURE0 = 0x84C0; +enum GL_TEXTURE1 = 0x84C1; +enum GL_TEXTURE2 = 0x84C2; +enum GL_TEXTURE3 = 0x84C3; +enum GL_TEXTURE4 = 0x84C4; +enum GL_TEXTURE5 = 0x84C5; +enum GL_TEXTURE6 = 0x84C6; +enum GL_TEXTURE7 = 0x84C7; +enum GL_TEXTURE8 = 0x84C8; +enum GL_TEXTURE9 = 0x84C9; +enum GL_TEXTURE10 = 0x84CA; +enum GL_TEXTURE11 = 0x84CB; +enum GL_TEXTURE12 = 0x84CC; +enum GL_TEXTURE13 = 0x84CD; +enum GL_TEXTURE14 = 0x84CE; +enum GL_TEXTURE15 = 0x84CF; +enum GL_TEXTURE16 = 0x84D0; +enum GL_TEXTURE17 = 0x84D1; +enum GL_TEXTURE18 = 0x84D2; +enum GL_TEXTURE19 = 0x84D3; +enum GL_TEXTURE20 = 0x84D4; +enum GL_TEXTURE21 = 0x84D5; +enum GL_TEXTURE22 = 0x84D6; +enum GL_TEXTURE23 = 0x84D7; +enum GL_TEXTURE24 = 0x84D8; +enum GL_TEXTURE25 = 0x84D9; +enum GL_TEXTURE26 = 0x84DA; +enum GL_TEXTURE27 = 0x84DB; +enum GL_TEXTURE28 = 0x84DC; +enum GL_TEXTURE29 = 0x84DD; +enum GL_TEXTURE30 = 0x84DE; +enum GL_TEXTURE31 = 0x84DF; +enum GL_ACTIVE_TEXTURE = 0x84E0; +enum GL_CLIENT_ACTIVE_TEXTURE = 0x84E1; +enum GL_REPEAT = 0x2901; +enum GL_CLAMP_TO_EDGE = 0x812F; +enum GL_LIGHT0 = 0x4000; +enum GL_LIGHT1 = 0x4001; +enum GL_LIGHT2 = 0x4002; +enum GL_LIGHT3 = 0x4003; +enum GL_LIGHT4 = 0x4004; +enum GL_LIGHT5 = 0x4005; +enum GL_LIGHT6 = 0x4006; +enum GL_LIGHT7 = 0x4007; +enum GL_ARRAY_BUFFER = 0x8892; +enum GL_ELEMENT_ARRAY_BUFFER = 0x8893; +enum GL_ARRAY_BUFFER_BINDING = 0x8894; +enum GL_ELEMENT_ARRAY_BUFFER_BINDING = 0x8895; +enum GL_VERTEX_ARRAY_BUFFER_BINDING = 0x8896; +enum GL_NORMAL_ARRAY_BUFFER_BINDING = 0x8897; +enum GL_COLOR_ARRAY_BUFFER_BINDING = 0x8898; +enum GL_TEXTURE_COORD_ARRAY_BUFFER_BINDING = 0x889A; +enum GL_STATIC_DRAW = 0x88E4; +enum GL_DYNAMIC_DRAW = 0x88E8; +enum GL_BUFFER_SIZE = 0x8764; +enum GL_BUFFER_USAGE = 0x8765; +enum GL_SUBTRACT = 0x84E7; +enum GL_COMBINE = 0x8570; +enum GL_COMBINE_RGB = 0x8571; +enum GL_COMBINE_ALPHA = 0x8572; +enum GL_RGB_SCALE = 0x8573; +enum GL_ADD_SIGNED = 0x8574; +enum GL_INTERPOLATE = 0x8575; +enum GL_CONSTANT = 0x8576; +enum GL_PRIMARY_COLOR = 0x8577; +enum GL_PREVIOUS = 0x8578; +enum GL_OPERAND0_RGB = 0x8590; +enum GL_OPERAND1_RGB = 0x8591; +enum GL_OPERAND2_RGB = 0x8592; +enum GL_OPERAND0_ALPHA = 0x8598; +enum GL_OPERAND1_ALPHA = 0x8599; +enum GL_OPERAND2_ALPHA = 0x859A; +enum GL_ALPHA_SCALE = 0x0D1C; +enum GL_SRC0_RGB = 0x8580; +enum GL_SRC1_RGB = 0x8581; +enum GL_SRC2_RGB = 0x8582; +enum GL_SRC0_ALPHA = 0x8588; +enum GL_SRC1_ALPHA = 0x8589; +enum GL_SRC2_ALPHA = 0x858A; +enum GL_DOT3_RGB = 0x86AE; +enum GL_DOT3_RGBA = 0x86AF; + +void glAlphaFunc(GLenum func, GLclampf ref_); +void glClearColor(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha); +void glClearDepthf(GLclampf depth); +void glClipPlanef(GLenum plane, const(GLfloat)* equation); +void glColor4f(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha); +void glDepthRangef(GLclampf zNear, GLclampf zFar); +void glFogf(GLenum pname, GLfloat param); +void glFogfv(GLenum pname, const(GLfloat)* params); +void glFrustumf(GLfloat left, GLfloat right, GLfloat bottom, GLfloat top, GLfloat zNear, GLfloat zFar); +void glGetClipPlanef(GLenum pname, GLfloat[4] eqn); +void glGetFloatv(GLenum pname, GLfloat* params); +void glGetLightfv(GLenum light, GLenum pname, GLfloat* params); +void glGetMaterialfv(GLenum face, GLenum pname, GLfloat* params); +void glGetTexEnvfv(GLenum env, GLenum pname, GLfloat* params); +void glGetTexParameterfv(GLenum target, GLenum pname, GLfloat* params); +void glLightModelf(GLenum pname, GLfloat param); +void glLightModelfv(GLenum pname, const(GLfloat)* params); +void glLightf(GLenum light, GLenum pname, GLfloat param); +void glLightfv(GLenum light, GLenum pname, const(GLfloat)* params); +void glLineWidth(GLfloat width); +void glLoadMatrixf(const(GLfloat)* m); +void glMaterialf(GLenum face, GLenum pname, GLfloat param); +void glMaterialfv(GLenum face, GLenum pname, const(GLfloat)* params); +void glMultMatrixf(const(GLfloat)* m); +void glMultiTexCoord4f(GLenum target, GLfloat s, GLfloat t, GLfloat r, GLfloat q); +void glNormal3f(GLfloat nx, GLfloat ny, GLfloat nz); +void glOrthof(GLfloat left, GLfloat right, GLfloat bottom, GLfloat top, GLfloat zNear, GLfloat zFar); +void glPointParameterf(GLenum pname, GLfloat param); +void glPointParameterfv(GLenum pname, const(GLfloat)* params); +void glPointSize(GLfloat size); +void glPolygonOffset(GLfloat factor, GLfloat units); +void glRotatef(GLfloat angle, GLfloat x, GLfloat y, GLfloat z); +void glScalef(GLfloat x, GLfloat y, GLfloat z); +void glTexEnvf(GLenum target, GLenum pname, GLfloat param); +void glTexEnvfv(GLenum target, GLenum pname, const(GLfloat)* params); +void glTexParameterf(GLenum target, GLenum pname, GLfloat param); +void glTexParameterfv(GLenum target, GLenum pname, const(GLfloat)* params); +void glTranslatef(GLfloat x, GLfloat y, GLfloat z); +void glActiveTexture(GLenum texture); +void glAlphaFuncx(GLenum func, GLclampx ref_); +void glBindBuffer(GLenum target, GLuint buffer); +void glBindTexture(GLenum target, GLuint texture); +void glBlendFunc(GLenum sfactor, GLenum dfactor); +void glBufferData(GLenum target, GLsizeiptr size, const(GLvoid)* data, GLenum usage); +void glBufferSubData(GLenum target, GLintptr offset, GLsizeiptr size, const(GLvoid)* data); +void glClear(GLbitfield mask); +void glClearColorx(GLclampx red, GLclampx green, GLclampx blue, GLclampx alpha); +void glClearDepthx(GLclampx depth); +void glClearStencil(GLint s); +void glClientActiveTexture(GLenum texture); +void glClipPlanex(GLenum plane, const(GLfixed)* equation); +void glColor4ub(GLubyte red, GLubyte green, GLubyte blue, GLubyte alpha); +void glColor4x(GLfixed red, GLfixed green, GLfixed blue, GLfixed alpha); +void glColorMask(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha); +void glColorPointer(GLint size, GLenum type, GLsizei stride, const(GLvoid)* pointer); +void glCompressedTexImage2D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const(GLvoid)* data); +void glCompressedTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const(GLvoid)* data); +void glCopyTexImage2D(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border); +void glCopyTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height); +void glCullFace(GLenum mode); +void glDeleteBuffers(GLsizei n, const(GLuint)* buffers); +void glDeleteTextures(GLsizei n, const(GLuint)* textures); +void glDepthFunc(GLenum func); +void glDepthMask(GLboolean flag); +void glDepthRangex(GLclampx zNear, GLclampx zFar); +void glDisable(GLenum cap); +void glDisableClientState(GLenum array); +void glDrawArrays(GLenum mode, GLint first, GLsizei count); +void glDrawElements(GLenum mode, GLsizei count, GLenum type, const(GLvoid)* indices); +void glEnable(GLenum cap); +void glEnableClientState(GLenum array); +void glFinish(); +void glFlush(); +void glFogx(GLenum pname, GLfixed param); +void glFogxv(GLenum pname, const(GLfixed)* params); +void glFrontFace(GLenum mode); +void glFrustumx(GLfixed left, GLfixed right, GLfixed bottom, GLfixed top, GLfixed zNear, GLfixed zFar); +void glGetBooleanv(GLenum pname, GLboolean* params); +void glGetBufferParameteriv(GLenum target, GLenum pname, GLint* params); +void glGetClipPlanex(GLenum pname, GLfixed[4] eqn); +void glGenBuffers(GLsizei n, GLuint* buffers); +void glGenTextures(GLsizei n, GLuint* textures); +GLenum glGetError(); +void glGetFixedv(GLenum pname, GLfixed* params); +void glGetIntegerv(GLenum pname, GLint* params); +void glGetLightxv(GLenum light, GLenum pname, GLfixed* params); +void glGetMaterialxv(GLenum face, GLenum pname, GLfixed* params); +void glGetPointerv(GLenum pname, GLvoid** params); +const(GLubyte)* glGetString(GLenum name); +void glGetTexEnviv(GLenum env, GLenum pname, GLint* params); +void glGetTexEnvxv(GLenum env, GLenum pname, GLfixed* params); +void glGetTexParameteriv(GLenum target, GLenum pname, GLint* params); +void glGetTexParameterxv(GLenum target, GLenum pname, GLfixed* params); +void glHint(GLenum target, GLenum mode); +GLboolean glIsBuffer(GLuint buffer); +GLboolean glIsEnabled(GLenum cap); +GLboolean glIsTexture(GLuint texture); +void glLightModelx(GLenum pname, GLfixed param); +void glLightModelxv(GLenum pname, const(GLfixed)* params); +void glLightx(GLenum light, GLenum pname, GLfixed param); +void glLightxv(GLenum light, GLenum pname, const(GLfixed)* params); +void glLineWidthx(GLfixed width); +void glLoadIdentity(); +void glLoadMatrixx(const(GLfixed)* m); +void glLogicOp(GLenum opcode); +void glMaterialx(GLenum face, GLenum pname, GLfixed param); +void glMaterialxv(GLenum face, GLenum pname, const(GLfixed)* params); +void glMatrixMode(GLenum mode); +void glMultMatrixx(const(GLfixed)* m); +void glMultiTexCoord4x(GLenum target, GLfixed s, GLfixed t, GLfixed r, GLfixed q); +void glNormal3x(GLfixed nx, GLfixed ny, GLfixed nz); +void glNormalPointer(GLenum type, GLsizei stride, const(GLvoid)* pointer); +void glOrthox(GLfixed left, GLfixed right, GLfixed bottom, GLfixed top, GLfixed zNear, GLfixed zFar); +void glPixelStorei(GLenum pname, GLint param); +void glPointParameterx(GLenum pname, GLfixed param); +void glPointParameterxv(GLenum pname, const(GLfixed)* params); +void glPointSizex(GLfixed size); +void glPolygonOffsetx(GLfixed factor, GLfixed units); +void glPopMatrix(); +void glPushMatrix(); +void glReadPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLvoid* pixels); +void glRotatex(GLfixed angle, GLfixed x, GLfixed y, GLfixed z); +void glSampleCoverage(GLclampf value, GLboolean invert); +void glSampleCoveragex(GLclampx value, GLboolean invert); +void glScalex(GLfixed x, GLfixed y, GLfixed z); +void glScissor(GLint x, GLint y, GLsizei width, GLsizei height); +void glShadeModel(GLenum mode); +void glStencilFunc(GLenum func, GLint ref_, GLuint mask); +void glStencilMask(GLuint mask); +void glStencilOp(GLenum fail, GLenum zfail, GLenum zpass); +void glTexCoordPointer(GLint size, GLenum type, GLsizei stride, const(GLvoid)* pointer); +void glTexEnvi(GLenum target, GLenum pname, GLint param); +void glTexEnvx(GLenum target, GLenum pname, GLfixed param); +void glTexEnviv(GLenum target, GLenum pname, const(GLint)* params); +void glTexEnvxv(GLenum target, GLenum pname, const(GLfixed)* params); +void glTexImage2D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const(GLvoid)* pixels); +void glTexParameteri(GLenum target, GLenum pname, GLint param); +void glTexParameterx(GLenum target, GLenum pname, GLfixed param); +void glTexParameteriv(GLenum target, GLenum pname, const(GLint)* params); +void glTexParameterxv(GLenum target, GLenum pname, const(GLfixed)* params); +void glTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const(GLvoid)* pixels); +void glTranslatex(GLfixed x, GLfixed y, GLfixed z); +void glVertexPointer(GLint size, GLenum type, GLsizei stride, const(GLvoid)* pointer); +void glViewport(GLint x, GLint y, GLsizei width, GLsizei height); diff --git a/3rdparty/GLES2/gl2.d b/3rdparty/GLES2/gl2.d new file mode 100644 index 00000000..f59a372f --- /dev/null +++ b/3rdparty/GLES2/gl2.d @@ -0,0 +1,476 @@ +/* dstep /path/to/ndk-r9d/platforms/android-9/arch-x86/usr/include/GLES2/gl2.h -o gl2.d*/ + +module GLES2.gl2; + +import core.stdc.config; + +version (Android): +extern (C): +@system: +nothrow: +@nogc: + +alias void GLvoid; +alias char GLchar; +alias uint GLenum; +alias ubyte GLboolean; +alias uint GLbitfield; +alias byte GLbyte; +alias short GLshort; +alias int GLint; +alias int GLsizei; +alias ubyte GLubyte; +alias ushort GLushort; +alias uint GLuint; +alias float GLfloat; +alias float GLclampf; +alias int GLfixed; +alias c_long GLintptr; +alias c_long GLsizeiptr; + +enum GL_ES_VERSION_2_0 = 1 +enum GL_DEPTH_BUFFER_BIT = 0x00000100 +enum GL_STENCIL_BUFFER_BIT = 0x00000400 +enum GL_COLOR_BUFFER_BIT = 0x00004000 +enum GL_FALSE = 0 +enum GL_TRUE = 1 +enum GL_POINTS = 0x0000 +enum GL_LINES = 0x0001 +enum GL_LINE_LOOP = 0x0002 +enum GL_LINE_STRIP = 0x0003 +enum GL_TRIANGLES = 0x0004 +enum GL_TRIANGLE_STRIP = 0x0005 +enum GL_TRIANGLE_FAN = 0x0006 +enum GL_ZERO = 0 +enum GL_ONE = 1 +enum GL_SRC_COLOR = 0x0300 +enum GL_ONE_MINUS_SRC_COLOR = 0x0301 +enum GL_SRC_ALPHA = 0x0302 +enum GL_ONE_MINUS_SRC_ALPHA = 0x0303 +enum GL_DST_ALPHA = 0x0304 +enum GL_ONE_MINUS_DST_ALPHA = 0x0305 +enum GL_DST_COLOR = 0x0306 +enum GL_ONE_MINUS_DST_COLOR = 0x0307 +enum GL_SRC_ALPHA_SATURATE = 0x0308 +enum GL_FUNC_ADD = 0x8006 +enum GL_BLEND_EQUATION = 0x8009 +enum GL_BLEND_EQUATION_RGB = 0x8009 +enum GL_BLEND_EQUATION_ALPHA = 0x883D +enum GL_FUNC_SUBTRACT = 0x800A +enum GL_FUNC_REVERSE_SUBTRACT = 0x800B +enum GL_BLEND_DST_RGB = 0x80C8 +enum GL_BLEND_SRC_RGB = 0x80C9 +enum GL_BLEND_DST_ALPHA = 0x80CA +enum GL_BLEND_SRC_ALPHA = 0x80CB +enum GL_CONSTANT_COLOR = 0x8001 +enum GL_ONE_MINUS_CONSTANT_COLOR = 0x8002 +enum GL_CONSTANT_ALPHA = 0x8003 +enum GL_ONE_MINUS_CONSTANT_ALPHA = 0x8004 +enum GL_BLEND_COLOR = 0x8005 +enum GL_ARRAY_BUFFER = 0x8892 +enum GL_ELEMENT_ARRAY_BUFFER = 0x8893 +enum GL_ARRAY_BUFFER_BINDING = 0x8894 +enum GL_ELEMENT_ARRAY_BUFFER_BINDING = 0x8895 +enum GL_STREAM_DRAW = 0x88E0 +enum GL_STATIC_DRAW = 0x88E4 +enum GL_DYNAMIC_DRAW = 0x88E8 +enum GL_BUFFER_SIZE = 0x8764 +enum GL_BUFFER_USAGE = 0x8765 +enum GL_CURRENT_VERTEX_ATTRIB = 0x8626 +enum GL_FRONT = 0x0404 +enum GL_BACK = 0x0405 +enum GL_FRONT_AND_BACK = 0x0408 +enum GL_TEXTURE_2D = 0x0DE1 +enum GL_CULL_FACE = 0x0B44 +enum GL_BLEND = 0x0BE2 +enum GL_DITHER = 0x0BD0 +enum GL_STENCIL_TEST = 0x0B90 +enum GL_DEPTH_TEST = 0x0B71 +enum GL_SCISSOR_TEST = 0x0C11 +enum GL_POLYGON_OFFSET_FILL = 0x8037 +enum GL_SAMPLE_ALPHA_TO_COVERAGE = 0x809E +enum GL_SAMPLE_COVERAGE = 0x80A0 +enum GL_NO_ERROR = 0 +enum GL_INVALID_ENUM = 0x0500 +enum GL_INVALID_VALUE = 0x0501 +enum GL_INVALID_OPERATION = 0x0502 +enum GL_OUT_OF_MEMORY = 0x0505 +enum GL_CW = 0x0900 +enum GL_CCW = 0x0901 +enum GL_LINE_WIDTH = 0x0B21 +enum GL_ALIASED_POINT_SIZE_RANGE = 0x846D +enum GL_ALIASED_LINE_WIDTH_RANGE = 0x846E +enum GL_CULL_FACE_MODE = 0x0B45 +enum GL_FRONT_FACE = 0x0B46 +enum GL_DEPTH_RANGE = 0x0B70 +enum GL_DEPTH_WRITEMASK = 0x0B72 +enum GL_DEPTH_CLEAR_VALUE = 0x0B73 +enum GL_DEPTH_FUNC = 0x0B74 +enum GL_STENCIL_CLEAR_VALUE = 0x0B91 +enum GL_STENCIL_FUNC = 0x0B92 +enum GL_STENCIL_FAIL = 0x0B94 +enum GL_STENCIL_PASS_DEPTH_FAIL = 0x0B95 +enum GL_STENCIL_PASS_DEPTH_PASS = 0x0B96 +enum GL_STENCIL_REF = 0x0B97 +enum GL_STENCIL_VALUE_MASK = 0x0B93 +enum GL_STENCIL_WRITEMASK = 0x0B98 +enum GL_STENCIL_BACK_FUNC = 0x8800 +enum GL_STENCIL_BACK_FAIL = 0x8801 +enum GL_STENCIL_BACK_PASS_DEPTH_FAIL = 0x8802 +enum GL_STENCIL_BACK_PASS_DEPTH_PASS = 0x8803 +enum GL_STENCIL_BACK_REF = 0x8CA3 +enum GL_STENCIL_BACK_VALUE_MASK = 0x8CA4 +enum GL_STENCIL_BACK_WRITEMASK = 0x8CA5 +enum GL_VIEWPORT = 0x0BA2 +enum GL_SCISSOR_BOX = 0x0C10 +enum GL_COLOR_CLEAR_VALUE = 0x0C22 +enum GL_COLOR_WRITEMASK = 0x0C23 +enum GL_UNPACK_ALIGNMENT = 0x0CF5 +enum GL_PACK_ALIGNMENT = 0x0D05 +enum GL_MAX_TEXTURE_SIZE = 0x0D33 +enum GL_MAX_VIEWPORT_DIMS = 0x0D3A +enum GL_SUBPIXEL_BITS = 0x0D50 +enum GL_RED_BITS = 0x0D52 +enum GL_GREEN_BITS = 0x0D53 +enum GL_BLUE_BITS = 0x0D54 +enum GL_ALPHA_BITS = 0x0D55 +enum GL_DEPTH_BITS = 0x0D56 +enum GL_STENCIL_BITS = 0x0D57 +enum GL_POLYGON_OFFSET_UNITS = 0x2A00 +enum GL_POLYGON_OFFSET_FACTOR = 0x8038 +enum GL_TEXTURE_BINDING_2D = 0x8069 +enum GL_SAMPLE_BUFFERS = 0x80A8 +enum GL_SAMPLES = 0x80A9 +enum GL_SAMPLE_COVERAGE_VALUE = 0x80AA +enum GL_SAMPLE_COVERAGE_INVERT = 0x80AB +enum GL_NUM_COMPRESSED_TEXTURE_FORMATS = 0x86A2 +enum GL_COMPRESSED_TEXTURE_FORMATS = 0x86A3 +enum GL_DONT_CARE = 0x1100 +enum GL_FASTEST = 0x1101 +enum GL_NICEST = 0x1102 +enum GL_GENERATE_MIPMAP_HINT = 0x8192 +enum GL_BYTE = 0x1400 +enum GL_UNSIGNED_BYTE = 0x1401 +enum GL_SHORT = 0x1402 +enum GL_UNSIGNED_SHORT = 0x1403 +enum GL_INT = 0x1404 +enum GL_UNSIGNED_INT = 0x1405 +enum GL_FLOAT = 0x1406 +enum GL_FIXED = 0x140C +enum GL_DEPTH_COMPONENT = 0x1902 +enum GL_ALPHA = 0x1906 +enum GL_RGB = 0x1907 +enum GL_RGBA = 0x1908 +enum GL_LUMINANCE = 0x1909 +enum GL_LUMINANCE_ALPHA = 0x190A +enum GL_UNSIGNED_SHORT_4_4_4_4 = 0x8033 +enum GL_UNSIGNED_SHORT_5_5_5_1 = 0x8034 +enum GL_UNSIGNED_SHORT_5_6_5 = 0x8363 +enum GL_FRAGMENT_SHADER = 0x8B30 +enum GL_VERTEX_SHADER = 0x8B31 +enum GL_MAX_VERTEX_ATTRIBS = 0x8869 +enum GL_MAX_VERTEX_UNIFORM_VECTORS = 0x8DFB +enum GL_MAX_VARYING_VECTORS = 0x8DFC +enum GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS = 0x8B4D +enum GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS = 0x8B4C +enum GL_MAX_TEXTURE_IMAGE_UNITS = 0x8872 +enum GL_MAX_FRAGMENT_UNIFORM_VECTORS = 0x8DFD +enum GL_SHADER_TYPE = 0x8B4F +enum GL_DELETE_STATUS = 0x8B80 +enum GL_LINK_STATUS = 0x8B82 +enum GL_VALIDATE_STATUS = 0x8B83 +enum GL_ATTACHED_SHADERS = 0x8B85 +enum GL_ACTIVE_UNIFORMS = 0x8B86 +enum GL_ACTIVE_UNIFORM_MAX_LENGTH = 0x8B87 +enum GL_ACTIVE_ATTRIBUTES = 0x8B89 +enum GL_ACTIVE_ATTRIBUTE_MAX_LENGTH = 0x8B8A +enum GL_SHADING_LANGUAGE_VERSION = 0x8B8C +enum GL_CURRENT_PROGRAM = 0x8B8D +enum GL_NEVER = 0x0200 +enum GL_LESS = 0x0201 +enum GL_EQUAL = 0x0202 +enum GL_LEQUAL = 0x0203 +enum GL_GREATER = 0x0204 +enum GL_NOTEQUAL = 0x0205 +enum GL_GEQUAL = 0x0206 +enum GL_ALWAYS = 0x0207 +enum GL_KEEP = 0x1E00 +enum GL_REPLACE = 0x1E01 +enum GL_INCR = 0x1E02 +enum GL_DECR = 0x1E03 +enum GL_INVERT = 0x150A +enum GL_INCR_WRAP = 0x8507 +enum GL_DECR_WRAP = 0x8508 +enum GL_VENDOR = 0x1F00 +enum GL_RENDERER = 0x1F01 +enum GL_VERSION = 0x1F02 +enum GL_EXTENSIONS = 0x1F03 +enum GL_NEAREST = 0x2600 +enum GL_LINEAR = 0x2601 +enum GL_NEAREST_MIPMAP_NEAREST = 0x2700 +enum GL_LINEAR_MIPMAP_NEAREST = 0x2701 +enum GL_NEAREST_MIPMAP_LINEAR = 0x2702 +enum GL_LINEAR_MIPMAP_LINEAR = 0x2703 +enum GL_TEXTURE_MAG_FILTER = 0x2800 +enum GL_TEXTURE_MIN_FILTER = 0x2801 +enum GL_TEXTURE_WRAP_S = 0x2802 +enum GL_TEXTURE_WRAP_T = 0x2803 +enum GL_TEXTURE = 0x1702 +enum GL_TEXTURE_CUBE_MAP = 0x8513 +enum GL_TEXTURE_BINDING_CUBE_MAP = 0x8514 +enum GL_TEXTURE_CUBE_MAP_POSITIVE_X = 0x8515 +enum GL_TEXTURE_CUBE_MAP_NEGATIVE_X = 0x8516 +enum GL_TEXTURE_CUBE_MAP_POSITIVE_Y = 0x8517 +enum GL_TEXTURE_CUBE_MAP_NEGATIVE_Y = 0x8518 +enum GL_TEXTURE_CUBE_MAP_POSITIVE_Z = 0x8519 +enum GL_TEXTURE_CUBE_MAP_NEGATIVE_Z = 0x851A +enum GL_MAX_CUBE_MAP_TEXTURE_SIZE = 0x851C +enum GL_TEXTURE0 = 0x84C0 +enum GL_TEXTURE1 = 0x84C1 +enum GL_TEXTURE2 = 0x84C2 +enum GL_TEXTURE3 = 0x84C3 +enum GL_TEXTURE4 = 0x84C4 +enum GL_TEXTURE5 = 0x84C5 +enum GL_TEXTURE6 = 0x84C6 +enum GL_TEXTURE7 = 0x84C7 +enum GL_TEXTURE8 = 0x84C8 +enum GL_TEXTURE9 = 0x84C9 +enum GL_TEXTURE10 = 0x84CA +enum GL_TEXTURE11 = 0x84CB +enum GL_TEXTURE12 = 0x84CC +enum GL_TEXTURE13 = 0x84CD +enum GL_TEXTURE14 = 0x84CE +enum GL_TEXTURE15 = 0x84CF +enum GL_TEXTURE16 = 0x84D0 +enum GL_TEXTURE17 = 0x84D1 +enum GL_TEXTURE18 = 0x84D2 +enum GL_TEXTURE19 = 0x84D3 +enum GL_TEXTURE20 = 0x84D4 +enum GL_TEXTURE21 = 0x84D5 +enum GL_TEXTURE22 = 0x84D6 +enum GL_TEXTURE23 = 0x84D7 +enum GL_TEXTURE24 = 0x84D8 +enum GL_TEXTURE25 = 0x84D9 +enum GL_TEXTURE26 = 0x84DA +enum GL_TEXTURE27 = 0x84DB +enum GL_TEXTURE28 = 0x84DC +enum GL_TEXTURE29 = 0x84DD +enum GL_TEXTURE30 = 0x84DE +enum GL_TEXTURE31 = 0x84DF +enum GL_ACTIVE_TEXTURE = 0x84E0 +enum GL_REPEAT = 0x2901 +enum GL_CLAMP_TO_EDGE = 0x812F +enum GL_MIRRORED_REPEAT = 0x8370 +enum GL_FLOAT_VEC2 = 0x8B50 +enum GL_FLOAT_VEC3 = 0x8B51 +enum GL_FLOAT_VEC4 = 0x8B52 +enum GL_INT_VEC2 = 0x8B53 +enum GL_INT_VEC3 = 0x8B54 +enum GL_INT_VEC4 = 0x8B55 +enum GL_BOOL = 0x8B56 +enum GL_BOOL_VEC2 = 0x8B57 +enum GL_BOOL_VEC3 = 0x8B58 +enum GL_BOOL_VEC4 = 0x8B59 +enum GL_FLOAT_MAT2 = 0x8B5A +enum GL_FLOAT_MAT3 = 0x8B5B +enum GL_FLOAT_MAT4 = 0x8B5C +enum GL_SAMPLER_2D = 0x8B5E +enum GL_SAMPLER_CUBE = 0x8B60 +enum GL_VERTEX_ATTRIB_ARRAY_ENABLED = 0x8622 +enum GL_VERTEX_ATTRIB_ARRAY_SIZE = 0x8623 +enum GL_VERTEX_ATTRIB_ARRAY_STRIDE = 0x8624 +enum GL_VERTEX_ATTRIB_ARRAY_TYPE = 0x8625 +enum GL_VERTEX_ATTRIB_ARRAY_NORMALIZED = 0x886A +enum GL_VERTEX_ATTRIB_ARRAY_POINTER = 0x8645 +enum GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING = 0x889F +enum GL_IMPLEMENTATION_COLOR_READ_TYPE = 0x8B9A +enum GL_IMPLEMENTATION_COLOR_READ_FORMAT = 0x8B9B +enum GL_COMPILE_STATUS = 0x8B81 +enum GL_INFO_LOG_LENGTH = 0x8B84 +enum GL_SHADER_SOURCE_LENGTH = 0x8B88 +enum GL_SHADER_COMPILER = 0x8DFA +enum GL_SHADER_BINARY_FORMATS = 0x8DF8 +enum GL_NUM_SHADER_BINARY_FORMATS = 0x8DF9 +enum GL_LOW_FLOAT = 0x8DF0 +enum GL_MEDIUM_FLOAT = 0x8DF1 +enum GL_HIGH_FLOAT = 0x8DF2 +enum GL_LOW_INT = 0x8DF3 +enum GL_MEDIUM_INT = 0x8DF4 +enum GL_HIGH_INT = 0x8DF5 +enum GL_FRAMEBUFFER = 0x8D40 +enum GL_RENDERBUFFER = 0x8D41 +enum GL_RGBA4 = 0x8056 +enum GL_RGB5_A1 = 0x8057 +enum GL_RGB565 = 0x8D62 +enum GL_DEPTH_COMPONENT16 = 0x81A5 +enum GL_STENCIL_INDEX = 0x1901 +enum GL_STENCIL_INDEX8 = 0x8D48 +enum GL_RENDERBUFFER_WIDTH = 0x8D42 +enum GL_RENDERBUFFER_HEIGHT = 0x8D43 +enum GL_RENDERBUFFER_INTERNAL_FORMAT = 0x8D44 +enum GL_RENDERBUFFER_RED_SIZE = 0x8D50 +enum GL_RENDERBUFFER_GREEN_SIZE = 0x8D51 +enum GL_RENDERBUFFER_BLUE_SIZE = 0x8D52 +enum GL_RENDERBUFFER_ALPHA_SIZE = 0x8D53 +enum GL_RENDERBUFFER_DEPTH_SIZE = 0x8D54 +enum GL_RENDERBUFFER_STENCIL_SIZE = 0x8D55 +enum GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE = 0x8CD0 +enum GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME = 0x8CD1 +enum GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL = 0x8CD2 +enum GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE = 0x8CD3 +enum GL_COLOR_ATTACHMENT0 = 0x8CE0 +enum GL_DEPTH_ATTACHMENT = 0x8D00 +enum GL_STENCIL_ATTACHMENT = 0x8D20 +enum GL_NONE = 0 +enum GL_FRAMEBUFFER_COMPLETE = 0x8CD5 +enum GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT = 0x8CD6 +enum GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT = 0x8CD7 +enum GL_FRAMEBUFFER_INCOMPLETE_DIMENSIONS = 0x8CD9 +enum GL_FRAMEBUFFER_UNSUPPORTED = 0x8CDD +enum GL_FRAMEBUFFER_BINDING = 0x8CA6 +enum GL_RENDERBUFFER_BINDING = 0x8CA7 +enum GL_MAX_RENDERBUFFER_SIZE = 0x84E8 +enum GL_INVALID_FRAMEBUFFER_OPERATION = 0x0506 + +void glActiveTexture(GLenum texture); +void glAttachShader(GLuint program, GLuint shader); +void glBindAttribLocation(GLuint program, GLuint index, const(GLchar)* name); +void glBindBuffer(GLenum target, GLuint buffer); +void glBindFramebuffer(GLenum target, GLuint framebuffer); +void glBindRenderbuffer(GLenum target, GLuint renderbuffer); +void glBindTexture(GLenum target, GLuint texture); +void glBlendColor(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha); +void glBlendEquation(GLenum mode); +void glBlendEquationSeparate(GLenum modeRGB, GLenum modeAlpha); +void glBlendFunc(GLenum sfactor, GLenum dfactor); +void glBlendFuncSeparate(GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha, GLenum dstAlpha); +void glBufferData(GLenum target, GLsizeiptr size, const(GLvoid)* data, GLenum usage); +void glBufferSubData(GLenum target, GLintptr offset, GLsizeiptr size, const(GLvoid)* data); +GLenum glCheckFramebufferStatus(GLenum target); +void glClear(GLbitfield mask); +void glClearColor(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha); +void glClearDepthf(GLclampf depth); +void glClearStencil(GLint s); +void glColorMask(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha); +void glCompileShader(GLuint shader); +void glCompressedTexImage2D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const(GLvoid)* data); +void glCompressedTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const(GLvoid)* data); +void glCopyTexImage2D(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border); +void glCopyTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height); +GLuint glCreateProgram(); +GLuint glCreateShader(GLenum type); +void glCullFace(GLenum mode); +void glDeleteBuffers(GLsizei n, const(GLuint)* buffers); +void glDeleteFramebuffers(GLsizei n, const(GLuint)* framebuffers); +void glDeleteProgram(GLuint program); +void glDeleteRenderbuffers(GLsizei n, const(GLuint)* renderbuffers); +void glDeleteShader(GLuint shader); +void glDeleteTextures(GLsizei n, const(GLuint)* textures); +void glDepthFunc(GLenum func); +void glDepthMask(GLboolean flag); +void glDepthRangef(GLclampf zNear, GLclampf zFar); +void glDetachShader(GLuint program, GLuint shader); +void glDisable(GLenum cap); +void glDisableVertexAttribArray(GLuint index); +void glDrawArrays(GLenum mode, GLint first, GLsizei count); +void glDrawElements(GLenum mode, GLsizei count, GLenum type, const(GLvoid)* indices); +void glEnable(GLenum cap); +void glEnableVertexAttribArray(GLuint index); +void glFinish(); +void glFlush(); +void glFramebufferRenderbuffer(GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer); +void glFramebufferTexture2D(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level); +void glFrontFace(GLenum mode); +void glGenBuffers(GLsizei n, GLuint* buffers); +void glGenerateMipmap(GLenum target); +void glGenFramebuffers(GLsizei n, GLuint* framebuffers); +void glGenRenderbuffers(GLsizei n, GLuint* renderbuffers); +void glGenTextures(GLsizei n, GLuint* textures); +void glGetActiveAttrib(GLuint program, GLuint index, GLsizei bufsize, GLsizei* length, GLint* size, GLenum* type, GLchar* name); +void glGetActiveUniform(GLuint program, GLuint index, GLsizei bufsize, GLsizei* length, GLint* size, GLenum* type, GLchar* name); +void glGetAttachedShaders(GLuint program, GLsizei maxcount, GLsizei* count, GLuint* shaders); +GLint glGetAttribLocation(GLuint program, const(GLchar)* name); +void glGetBooleanv(GLenum pname, GLboolean* params); +void glGetBufferParameteriv(GLenum target, GLenum pname, GLint* params); +GLenum glGetError(); +void glGetFloatv(GLenum pname, GLfloat* params); +void glGetFramebufferAttachmentParameteriv(GLenum target, GLenum attachment, GLenum pname, GLint* params); +void glGetIntegerv(GLenum pname, GLint* params); +void glGetProgramiv(GLuint program, GLenum pname, GLint* params); +void glGetProgramInfoLog(GLuint program, GLsizei bufsize, GLsizei* length, GLchar* infolog); +void glGetRenderbufferParameteriv(GLenum target, GLenum pname, GLint* params); +void glGetShaderiv(GLuint shader, GLenum pname, GLint* params); +void glGetShaderInfoLog(GLuint shader, GLsizei bufsize, GLsizei* length, GLchar* infolog); +void glGetShaderPrecisionFormat(GLenum shadertype, GLenum precisiontype, GLint* range, GLint* precision); +void glGetShaderSource(GLuint shader, GLsizei bufsize, GLsizei* length, GLchar* source); +const(GLubyte)* glGetString(GLenum name); +void glGetTexParameterfv(GLenum target, GLenum pname, GLfloat* params); +void glGetTexParameteriv(GLenum target, GLenum pname, GLint* params); +void glGetUniformfv(GLuint program, GLint location, GLfloat* params); +void glGetUniformiv(GLuint program, GLint location, GLint* params); +GLint glGetUniformLocation(GLuint program, const(GLchar)* name); +void glGetVertexAttribfv(GLuint index, GLenum pname, GLfloat* params); +void glGetVertexAttribiv(GLuint index, GLenum pname, GLint* params); +void glGetVertexAttribPointerv(GLuint index, GLenum pname, GLvoid** pointer); +void glHint(GLenum target, GLenum mode); +GLboolean glIsBuffer(GLuint buffer); +GLboolean glIsEnabled(GLenum cap); +GLboolean glIsFramebuffer(GLuint framebuffer); +GLboolean glIsProgram(GLuint program); +GLboolean glIsRenderbuffer(GLuint renderbuffer); +GLboolean glIsShader(GLuint shader); +GLboolean glIsTexture(GLuint texture); +void glLineWidth(GLfloat width); +void glLinkProgram(GLuint program); +void glPixelStorei(GLenum pname, GLint param); +void glPolygonOffset(GLfloat factor, GLfloat units); +void glReadPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLvoid* pixels); +void glReleaseShaderCompiler(); +void glRenderbufferStorage(GLenum target, GLenum internalformat, GLsizei width, GLsizei height); +void glSampleCoverage(GLclampf value, GLboolean invert); +void glScissor(GLint x, GLint y, GLsizei width, GLsizei height); +void glShaderBinary(GLsizei n, const(GLuint)* shaders, GLenum binaryformat, const(GLvoid)* binary, GLsizei length); +void glShaderSource(GLuint shader, GLsizei count, in GLchar** string, const(GLint)* length); +void glStencilFunc(GLenum func, GLint ref_, GLuint mask); +void glStencilFuncSeparate(GLenum face, GLenum func, GLint ref_, GLuint mask); +void glStencilMask(GLuint mask); +void glStencilMaskSeparate(GLenum face, GLuint mask); +void glStencilOp(GLenum fail, GLenum zfail, GLenum zpass); +void glStencilOpSeparate(GLenum face, GLenum fail, GLenum zfail, GLenum zpass); +void glTexImage2D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const(GLvoid)* pixels); +void glTexParameterf(GLenum target, GLenum pname, GLfloat param); +void glTexParameterfv(GLenum target, GLenum pname, const(GLfloat)* params); +void glTexParameteri(GLenum target, GLenum pname, GLint param); +void glTexParameteriv(GLenum target, GLenum pname, const(GLint)* params); +void glTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const(GLvoid)* pixels); +void glUniform1f(GLint location, GLfloat x); +void glUniform1fv(GLint location, GLsizei count, const(GLfloat)* v); +void glUniform1i(GLint location, GLint x); +void glUniform1iv(GLint location, GLsizei count, const(GLint)* v); +void glUniform2f(GLint location, GLfloat x, GLfloat y); +void glUniform2fv(GLint location, GLsizei count, const(GLfloat)* v); +void glUniform2i(GLint location, GLint x, GLint y); +void glUniform2iv(GLint location, GLsizei count, const(GLint)* v); +void glUniform3f(GLint location, GLfloat x, GLfloat y, GLfloat z); +void glUniform3fv(GLint location, GLsizei count, const(GLfloat)* v); +void glUniform3i(GLint location, GLint x, GLint y, GLint z); +void glUniform3iv(GLint location, GLsizei count, const(GLint)* v); +void glUniform4f(GLint location, GLfloat x, GLfloat y, GLfloat z, GLfloat w); +void glUniform4fv(GLint location, GLsizei count, const(GLfloat)* v); +void glUniform4i(GLint location, GLint x, GLint y, GLint z, GLint w); +void glUniform4iv(GLint location, GLsizei count, const(GLint)* v); +void glUniformMatrix2fv(GLint location, GLsizei count, GLboolean transpose, const(GLfloat)* value); +void glUniformMatrix3fv(GLint location, GLsizei count, GLboolean transpose, const(GLfloat)* value); +void glUniformMatrix4fv(GLint location, GLsizei count, GLboolean transpose, const(GLfloat)* value); +void glUseProgram(GLuint program); +void glValidateProgram(GLuint program); +void glVertexAttrib1f(GLuint indx, GLfloat x); +void glVertexAttrib1fv(GLuint indx, const(GLfloat)* values); +void glVertexAttrib2f(GLuint indx, GLfloat x, GLfloat y); +void glVertexAttrib2fv(GLuint indx, const(GLfloat)* values); +void glVertexAttrib3f(GLuint indx, GLfloat x, GLfloat y, GLfloat z); +void glVertexAttrib3fv(GLuint indx, const(GLfloat)* values); +void glVertexAttrib4f(GLuint indx, GLfloat x, GLfloat y, GLfloat z, GLfloat w); +void glVertexAttrib4fv(GLuint indx, const(GLfloat)* values); +void glVertexAttribPointer(GLuint indx, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const(GLvoid)* ptr); +void glViewport(GLint x, GLint y, GLsizei width, GLsizei height); diff --git a/3rdparty/GLES3/gl3.d b/3rdparty/GLES3/gl3.d new file mode 100644 index 00000000..00fe5c42 --- /dev/null +++ b/3rdparty/GLES3/gl3.d @@ -0,0 +1,891 @@ +/* dstep /path/to/ndk-r10/platforms/android-18/arch-x86/usr/include/GLES3/gl3.h -o gl3.d*/ + +module GLES3.gl3; + +import core.stdc.config; + +version (Android): +extern (C): +@system: +nothrow: +@nogc: + +alias void GLvoid; +alias char GLchar; +alias uint GLenum; +alias ubyte GLboolean; +alias uint GLbitfield; +alias byte GLbyte; +alias short GLshort; +alias int GLint; +alias int GLsizei; +alias ubyte GLubyte; +alias ushort GLushort; +alias uint GLuint; +alias float GLfloat; +alias float GLclampf; +alias int GLfixed; +alias c_long GLintptr; +alias c_long GLsizeiptr; +alias ushort GLhalf; +alias long GLint64; +alias ulong GLuint64; +alias __GLsync* GLsync; + +enum GL_ES_VERSION_3_0 = 1; +enum GL_ES_VERSION_2_0 = 1; +enum GL_DEPTH_BUFFER_BIT = 0x00000100; +enum GL_STENCIL_BUFFER_BIT = 0x00000400; +enum GL_COLOR_BUFFER_BIT = 0x00004000; +enum GL_FALSE = 0; +enum GL_TRUE = 1; +enum GL_POINTS = 0x0000; +enum GL_LINES = 0x0001; +enum GL_LINE_LOOP = 0x0002; +enum GL_LINE_STRIP = 0x0003; +enum GL_TRIANGLES = 0x0004; +enum GL_TRIANGLE_STRIP = 0x0005; +enum GL_TRIANGLE_FAN = 0x0006; +enum GL_ZERO = 0; +enum GL_ONE = 1; +enum GL_SRC_COLOR = 0x0300; +enum GL_ONE_MINUS_SRC_COLOR = 0x0301; +enum GL_SRC_ALPHA = 0x0302; +enum GL_ONE_MINUS_SRC_ALPHA = 0x0303; +enum GL_DST_ALPHA = 0x0304; +enum GL_ONE_MINUS_DST_ALPHA = 0x0305; +enum GL_DST_COLOR = 0x0306; +enum GL_ONE_MINUS_DST_COLOR = 0x0307; +enum GL_SRC_ALPHA_SATURATE = 0x0308; +enum GL_FUNC_ADD = 0x8006; +enum GL_BLEND_EQUATION = 0x8009; +enum GL_BLEND_EQUATION_RGB = 0x8009; +enum GL_BLEND_EQUATION_ALPHA = 0x883D; +enum GL_FUNC_SUBTRACT = 0x800A; +enum GL_FUNC_REVERSE_SUBTRACT = 0x800B; +enum GL_BLEND_DST_RGB = 0x80C8; +enum GL_BLEND_SRC_RGB = 0x80C9; +enum GL_BLEND_DST_ALPHA = 0x80CA; +enum GL_BLEND_SRC_ALPHA = 0x80CB; +enum GL_CONSTANT_COLOR = 0x8001; +enum GL_ONE_MINUS_CONSTANT_COLOR = 0x8002; +enum GL_CONSTANT_ALPHA = 0x8003; +enum GL_ONE_MINUS_CONSTANT_ALPHA = 0x8004; +enum GL_BLEND_COLOR = 0x8005; +enum GL_ARRAY_BUFFER = 0x8892; +enum GL_ELEMENT_ARRAY_BUFFER = 0x8893; +enum GL_ARRAY_BUFFER_BINDING = 0x8894; +enum GL_ELEMENT_ARRAY_BUFFER_BINDING = 0x8895; +enum GL_STREAM_DRAW = 0x88E0; +enum GL_STATIC_DRAW = 0x88E4; +enum GL_DYNAMIC_DRAW = 0x88E8; +enum GL_BUFFER_SIZE = 0x8764; +enum GL_BUFFER_USAGE = 0x8765; +enum GL_CURRENT_VERTEX_ATTRIB = 0x8626; +enum GL_FRONT = 0x0404; +enum GL_BACK = 0x0405; +enum GL_FRONT_AND_BACK = 0x0408; +enum GL_TEXTURE_2D = 0x0DE1; +enum GL_CULL_FACE = 0x0B44; +enum GL_BLEND = 0x0BE2; +enum GL_DITHER = 0x0BD0; +enum GL_STENCIL_TEST = 0x0B90; +enum GL_DEPTH_TEST = 0x0B71; +enum GL_SCISSOR_TEST = 0x0C11; +enum GL_POLYGON_OFFSET_FILL = 0x8037; +enum GL_SAMPLE_ALPHA_TO_COVERAGE = 0x809E; +enum GL_SAMPLE_COVERAGE = 0x80A0; +enum GL_NO_ERROR = 0; +enum GL_INVALID_ENUM = 0x0500; +enum GL_INVALID_VALUE = 0x0501; +enum GL_INVALID_OPERATION = 0x0502; +enum GL_OUT_OF_MEMORY = 0x0505; +enum GL_CW = 0x0900; +enum GL_CCW = 0x0901; +enum GL_LINE_WIDTH = 0x0B21; +enum GL_ALIASED_POINT_SIZE_RANGE = 0x846D; +enum GL_ALIASED_LINE_WIDTH_RANGE = 0x846E; +enum GL_CULL_FACE_MODE = 0x0B45; +enum GL_FRONT_FACE = 0x0B46; +enum GL_DEPTH_RANGE = 0x0B70; +enum GL_DEPTH_WRITEMASK = 0x0B72; +enum GL_DEPTH_CLEAR_VALUE = 0x0B73; +enum GL_DEPTH_FUNC = 0x0B74; +enum GL_STENCIL_CLEAR_VALUE = 0x0B91; +enum GL_STENCIL_FUNC = 0x0B92; +enum GL_STENCIL_FAIL = 0x0B94; +enum GL_STENCIL_PASS_DEPTH_FAIL = 0x0B95; +enum GL_STENCIL_PASS_DEPTH_PASS = 0x0B96; +enum GL_STENCIL_REF = 0x0B97; +enum GL_STENCIL_VALUE_MASK = 0x0B93; +enum GL_STENCIL_WRITEMASK = 0x0B98; +enum GL_STENCIL_BACK_FUNC = 0x8800; +enum GL_STENCIL_BACK_FAIL = 0x8801; +enum GL_STENCIL_BACK_PASS_DEPTH_FAIL = 0x8802; +enum GL_STENCIL_BACK_PASS_DEPTH_PASS = 0x8803; +enum GL_STENCIL_BACK_REF = 0x8CA3; +enum GL_STENCIL_BACK_VALUE_MASK = 0x8CA4; +enum GL_STENCIL_BACK_WRITEMASK = 0x8CA5; +enum GL_VIEWPORT = 0x0BA2; +enum GL_SCISSOR_BOX = 0x0C10; +enum GL_COLOR_CLEAR_VALUE = 0x0C22; +enum GL_COLOR_WRITEMASK = 0x0C23; +enum GL_UNPACK_ALIGNMENT = 0x0CF5; +enum GL_PACK_ALIGNMENT = 0x0D05; +enum GL_MAX_TEXTURE_SIZE = 0x0D33; +enum GL_MAX_VIEWPORT_DIMS = 0x0D3A; +enum GL_SUBPIXEL_BITS = 0x0D50; +enum GL_RED_BITS = 0x0D52; +enum GL_GREEN_BITS = 0x0D53; +enum GL_BLUE_BITS = 0x0D54; +enum GL_ALPHA_BITS = 0x0D55; +enum GL_DEPTH_BITS = 0x0D56; +enum GL_STENCIL_BITS = 0x0D57; +enum GL_POLYGON_OFFSET_UNITS = 0x2A00; +enum GL_POLYGON_OFFSET_FACTOR = 0x8038; +enum GL_TEXTURE_BINDING_2D = 0x8069; +enum GL_SAMPLE_BUFFERS = 0x80A8; +enum GL_SAMPLES = 0x80A9; +enum GL_SAMPLE_COVERAGE_VALUE = 0x80AA; +enum GL_SAMPLE_COVERAGE_INVERT = 0x80AB; +enum GL_NUM_COMPRESSED_TEXTURE_FORMATS = 0x86A2; +enum GL_COMPRESSED_TEXTURE_FORMATS = 0x86A3; +enum GL_DONT_CARE = 0x1100; +enum GL_FASTEST = 0x1101; +enum GL_NICEST = 0x1102; +enum GL_GENERATE_MIPMAP_HINT = 0x8192; +enum GL_BYTE = 0x1400; +enum GL_UNSIGNED_BYTE = 0x1401; +enum GL_SHORT = 0x1402; +enum GL_UNSIGNED_SHORT = 0x1403; +enum GL_INT = 0x1404; +enum GL_UNSIGNED_INT = 0x1405; +enum GL_FLOAT = 0x1406; +enum GL_FIXED = 0x140C; +enum GL_DEPTH_COMPONENT = 0x1902; +enum GL_ALPHA = 0x1906; +enum GL_RGB = 0x1907; +enum GL_RGBA = 0x1908; +enum GL_LUMINANCE = 0x1909; +enum GL_LUMINANCE_ALPHA = 0x190A; +enum GL_UNSIGNED_SHORT_4_4_4_4 = 0x8033; +enum GL_UNSIGNED_SHORT_5_5_5_1 = 0x8034; +enum GL_UNSIGNED_SHORT_5_6_5 = 0x8363; +enum GL_FRAGMENT_SHADER = 0x8B30; +enum GL_VERTEX_SHADER = 0x8B31; +enum GL_MAX_VERTEX_ATTRIBS = 0x8869; +enum GL_MAX_VERTEX_UNIFORM_VECTORS = 0x8DFB; +enum GL_MAX_VARYING_VECTORS = 0x8DFC; +enum GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS = 0x8B4D; +enum GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS = 0x8B4C; +enum GL_MAX_TEXTURE_IMAGE_UNITS = 0x8872; +enum GL_MAX_FRAGMENT_UNIFORM_VECTORS = 0x8DFD; +enum GL_SHADER_TYPE = 0x8B4F; +enum GL_DELETE_STATUS = 0x8B80; +enum GL_LINK_STATUS = 0x8B82; +enum GL_VALIDATE_STATUS = 0x8B83; +enum GL_ATTACHED_SHADERS = 0x8B85; +enum GL_ACTIVE_UNIFORMS = 0x8B86; +enum GL_ACTIVE_UNIFORM_MAX_LENGTH = 0x8B87; +enum GL_ACTIVE_ATTRIBUTES = 0x8B89; +enum GL_ACTIVE_ATTRIBUTE_MAX_LENGTH = 0x8B8A; +enum GL_SHADING_LANGUAGE_VERSION = 0x8B8C; +enum GL_CURRENT_PROGRAM = 0x8B8D; +enum GL_NEVER = 0x0200; +enum GL_LESS = 0x0201; +enum GL_EQUAL = 0x0202; +enum GL_LEQUAL = 0x0203; +enum GL_GREATER = 0x0204; +enum GL_NOTEQUAL = 0x0205; +enum GL_GEQUAL = 0x0206; +enum GL_ALWAYS = 0x0207; +enum GL_KEEP = 0x1E00; +enum GL_REPLACE = 0x1E01; +enum GL_INCR = 0x1E02; +enum GL_DECR = 0x1E03; +enum GL_INVERT = 0x150A; +enum GL_INCR_WRAP = 0x8507; +enum GL_DECR_WRAP = 0x8508; +enum GL_VENDOR = 0x1F00; +enum GL_RENDERER = 0x1F01; +enum GL_VERSION = 0x1F02; +enum GL_EXTENSIONS = 0x1F03; +enum GL_NEAREST = 0x2600; +enum GL_LINEAR = 0x2601; +enum GL_NEAREST_MIPMAP_NEAREST = 0x2700; +enum GL_LINEAR_MIPMAP_NEAREST = 0x2701; +enum GL_NEAREST_MIPMAP_LINEAR = 0x2702; +enum GL_LINEAR_MIPMAP_LINEAR = 0x2703; +enum GL_TEXTURE_MAG_FILTER = 0x2800; +enum GL_TEXTURE_MIN_FILTER = 0x2801; +enum GL_TEXTURE_WRAP_S = 0x2802; +enum GL_TEXTURE_WRAP_T = 0x2803; +enum GL_TEXTURE = 0x1702; +enum GL_TEXTURE_CUBE_MAP = 0x8513; +enum GL_TEXTURE_BINDING_CUBE_MAP = 0x8514; +enum GL_TEXTURE_CUBE_MAP_POSITIVE_X = 0x8515; +enum GL_TEXTURE_CUBE_MAP_NEGATIVE_X = 0x8516; +enum GL_TEXTURE_CUBE_MAP_POSITIVE_Y = 0x8517; +enum GL_TEXTURE_CUBE_MAP_NEGATIVE_Y = 0x8518; +enum GL_TEXTURE_CUBE_MAP_POSITIVE_Z = 0x8519; +enum GL_TEXTURE_CUBE_MAP_NEGATIVE_Z = 0x851A; +enum GL_MAX_CUBE_MAP_TEXTURE_SIZE = 0x851C; +enum GL_TEXTURE0 = 0x84C0; +enum GL_TEXTURE1 = 0x84C1; +enum GL_TEXTURE2 = 0x84C2; +enum GL_TEXTURE3 = 0x84C3; +enum GL_TEXTURE4 = 0x84C4; +enum GL_TEXTURE5 = 0x84C5; +enum GL_TEXTURE6 = 0x84C6; +enum GL_TEXTURE7 = 0x84C7; +enum GL_TEXTURE8 = 0x84C8; +enum GL_TEXTURE9 = 0x84C9; +enum GL_TEXTURE10 = 0x84CA; +enum GL_TEXTURE11 = 0x84CB; +enum GL_TEXTURE12 = 0x84CC; +enum GL_TEXTURE13 = 0x84CD; +enum GL_TEXTURE14 = 0x84CE; +enum GL_TEXTURE15 = 0x84CF; +enum GL_TEXTURE16 = 0x84D0; +enum GL_TEXTURE17 = 0x84D1; +enum GL_TEXTURE18 = 0x84D2; +enum GL_TEXTURE19 = 0x84D3; +enum GL_TEXTURE20 = 0x84D4; +enum GL_TEXTURE21 = 0x84D5; +enum GL_TEXTURE22 = 0x84D6; +enum GL_TEXTURE23 = 0x84D7; +enum GL_TEXTURE24 = 0x84D8; +enum GL_TEXTURE25 = 0x84D9; +enum GL_TEXTURE26 = 0x84DA; +enum GL_TEXTURE27 = 0x84DB; +enum GL_TEXTURE28 = 0x84DC; +enum GL_TEXTURE29 = 0x84DD; +enum GL_TEXTURE30 = 0x84DE; +enum GL_TEXTURE31 = 0x84DF; +enum GL_ACTIVE_TEXTURE = 0x84E0; +enum GL_REPEAT = 0x2901; +enum GL_CLAMP_TO_EDGE = 0x812F; +enum GL_MIRRORED_REPEAT = 0x8370; +enum GL_FLOAT_VEC2 = 0x8B50; +enum GL_FLOAT_VEC3 = 0x8B51; +enum GL_FLOAT_VEC4 = 0x8B52; +enum GL_INT_VEC2 = 0x8B53; +enum GL_INT_VEC3 = 0x8B54; +enum GL_INT_VEC4 = 0x8B55; +enum GL_BOOL = 0x8B56; +enum GL_BOOL_VEC2 = 0x8B57; +enum GL_BOOL_VEC3 = 0x8B58; +enum GL_BOOL_VEC4 = 0x8B59; +enum GL_FLOAT_MAT2 = 0x8B5A; +enum GL_FLOAT_MAT3 = 0x8B5B; +enum GL_FLOAT_MAT4 = 0x8B5C; +enum GL_SAMPLER_2D = 0x8B5E; +enum GL_SAMPLER_CUBE = 0x8B60; +enum GL_VERTEX_ATTRIB_ARRAY_ENABLED = 0x8622; +enum GL_VERTEX_ATTRIB_ARRAY_SIZE = 0x8623; +enum GL_VERTEX_ATTRIB_ARRAY_STRIDE = 0x8624; +enum GL_VERTEX_ATTRIB_ARRAY_TYPE = 0x8625; +enum GL_VERTEX_ATTRIB_ARRAY_NORMALIZED = 0x886A; +enum GL_VERTEX_ATTRIB_ARRAY_POINTER = 0x8645; +enum GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING = 0x889F; +enum GL_IMPLEMENTATION_COLOR_READ_TYPE = 0x8B9A; +enum GL_IMPLEMENTATION_COLOR_READ_FORMAT = 0x8B9B; +enum GL_COMPILE_STATUS = 0x8B81; +enum GL_INFO_LOG_LENGTH = 0x8B84; +enum GL_SHADER_SOURCE_LENGTH = 0x8B88; +enum GL_SHADER_COMPILER = 0x8DFA; +enum GL_SHADER_BINARY_FORMATS = 0x8DF8; +enum GL_NUM_SHADER_BINARY_FORMATS = 0x8DF9; +enum GL_LOW_FLOAT = 0x8DF0; +enum GL_MEDIUM_FLOAT = 0x8DF1; +enum GL_HIGH_FLOAT = 0x8DF2; +enum GL_LOW_INT = 0x8DF3; +enum GL_MEDIUM_INT = 0x8DF4; +enum GL_HIGH_INT = 0x8DF5; +enum GL_FRAMEBUFFER = 0x8D40; +enum GL_RENDERBUFFER = 0x8D41; +enum GL_RGBA4 = 0x8056; +enum GL_RGB5_A1 = 0x8057; +enum GL_RGB565 = 0x8D62; +enum GL_DEPTH_COMPONENT16 = 0x81A5; +enum GL_STENCIL_INDEX8 = 0x8D48; +enum GL_RENDERBUFFER_WIDTH = 0x8D42; +enum GL_RENDERBUFFER_HEIGHT = 0x8D43; +enum GL_RENDERBUFFER_INTERNAL_FORMAT = 0x8D44; +enum GL_RENDERBUFFER_RED_SIZE = 0x8D50; +enum GL_RENDERBUFFER_GREEN_SIZE = 0x8D51; +enum GL_RENDERBUFFER_BLUE_SIZE = 0x8D52; +enum GL_RENDERBUFFER_ALPHA_SIZE = 0x8D53; +enum GL_RENDERBUFFER_DEPTH_SIZE = 0x8D54; +enum GL_RENDERBUFFER_STENCIL_SIZE = 0x8D55; +enum GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE = 0x8CD0; +enum GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME = 0x8CD1; +enum GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL = 0x8CD2; +enum GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE = 0x8CD3; +enum GL_COLOR_ATTACHMENT0 = 0x8CE0; +enum GL_DEPTH_ATTACHMENT = 0x8D00; +enum GL_STENCIL_ATTACHMENT = 0x8D20; +enum GL_NONE = 0; +enum GL_FRAMEBUFFER_COMPLETE = 0x8CD5; +enum GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT = 0x8CD6; +enum GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT = 0x8CD7; +enum GL_FRAMEBUFFER_INCOMPLETE_DIMENSIONS = 0x8CD9; +enum GL_FRAMEBUFFER_UNSUPPORTED = 0x8CDD; +enum GL_FRAMEBUFFER_BINDING = 0x8CA6; +enum GL_RENDERBUFFER_BINDING = 0x8CA7; +enum GL_MAX_RENDERBUFFER_SIZE = 0x84E8; +enum GL_INVALID_FRAMEBUFFER_OPERATION = 0x0506; +enum GL_READ_BUFFER = 0x0C02; +enum GL_UNPACK_ROW_LENGTH = 0x0CF2; +enum GL_UNPACK_SKIP_ROWS = 0x0CF3; +enum GL_UNPACK_SKIP_PIXELS = 0x0CF4; +enum GL_PACK_ROW_LENGTH = 0x0D02; +enum GL_PACK_SKIP_ROWS = 0x0D03; +enum GL_PACK_SKIP_PIXELS = 0x0D04; +enum GL_COLOR = 0x1800; +enum GL_DEPTH = 0x1801; +enum GL_STENCIL = 0x1802; +enum GL_RED = 0x1903; +enum GL_RGB8 = 0x8051; +enum GL_RGBA8 = 0x8058; +enum GL_RGB10_A2 = 0x8059; +enum GL_TEXTURE_BINDING_3D = 0x806A; +enum GL_UNPACK_SKIP_IMAGES = 0x806D; +enum GL_UNPACK_IMAGE_HEIGHT = 0x806E; +enum GL_TEXTURE_3D = 0x806F; +enum GL_TEXTURE_WRAP_R = 0x8072; +enum GL_MAX_3D_TEXTURE_SIZE = 0x8073; +enum GL_UNSIGNED_INT_2_10_10_10_REV = 0x8368; +enum GL_MAX_ELEMENTS_VERTICES = 0x80E8; +enum GL_MAX_ELEMENTS_INDICES = 0x80E9; +enum GL_TEXTURE_MIN_LOD = 0x813A; +enum GL_TEXTURE_MAX_LOD = 0x813B; +enum GL_TEXTURE_BASE_LEVEL = 0x813C; +enum GL_TEXTURE_MAX_LEVEL = 0x813D; +enum GL_MIN = 0x8007; +enum GL_MAX = 0x8008; +enum GL_DEPTH_COMPONENT24 = 0x81A6; +enum GL_MAX_TEXTURE_LOD_BIAS = 0x84FD; +enum GL_TEXTURE_COMPARE_MODE = 0x884C; +enum GL_TEXTURE_COMPARE_FUNC = 0x884D; +enum GL_CURRENT_QUERY = 0x8865; +enum GL_QUERY_RESULT = 0x8866; +enum GL_QUERY_RESULT_AVAILABLE = 0x8867; +enum GL_BUFFER_MAPPED = 0x88BC; +enum GL_BUFFER_MAP_POINTER = 0x88BD; +enum GL_STREAM_READ = 0x88E1; +enum GL_STREAM_COPY = 0x88E2; +enum GL_STATIC_READ = 0x88E5; +enum GL_STATIC_COPY = 0x88E6; +enum GL_DYNAMIC_READ = 0x88E9; +enum GL_DYNAMIC_COPY = 0x88EA; +enum GL_MAX_DRAW_BUFFERS = 0x8824; +enum GL_DRAW_BUFFER0 = 0x8825; +enum GL_DRAW_BUFFER1 = 0x8826; +enum GL_DRAW_BUFFER2 = 0x8827; +enum GL_DRAW_BUFFER3 = 0x8828; +enum GL_DRAW_BUFFER4 = 0x8829; +enum GL_DRAW_BUFFER5 = 0x882A; +enum GL_DRAW_BUFFER6 = 0x882B; +enum GL_DRAW_BUFFER7 = 0x882C; +enum GL_DRAW_BUFFER8 = 0x882D; +enum GL_DRAW_BUFFER9 = 0x882E; +enum GL_DRAW_BUFFER10 = 0x882F; +enum GL_DRAW_BUFFER11 = 0x8830; +enum GL_DRAW_BUFFER12 = 0x8831; +enum GL_DRAW_BUFFER13 = 0x8832; +enum GL_DRAW_BUFFER14 = 0x8833; +enum GL_DRAW_BUFFER15 = 0x8834; +enum GL_MAX_FRAGMENT_UNIFORM_COMPONENTS = 0x8B49; +enum GL_MAX_VERTEX_UNIFORM_COMPONENTS = 0x8B4A; +enum GL_SAMPLER_3D = 0x8B5F; +enum GL_SAMPLER_2D_SHADOW = 0x8B62; +enum GL_FRAGMENT_SHADER_DERIVATIVE_HINT = 0x8B8B; +enum GL_PIXEL_PACK_BUFFER = 0x88EB; +enum GL_PIXEL_UNPACK_BUFFER = 0x88EC; +enum GL_PIXEL_PACK_BUFFER_BINDING = 0x88ED; +enum GL_PIXEL_UNPACK_BUFFER_BINDING = 0x88EF; +enum GL_FLOAT_MAT2x3 = 0x8B65; +enum GL_FLOAT_MAT2x4 = 0x8B66; +enum GL_FLOAT_MAT3x2 = 0x8B67; +enum GL_FLOAT_MAT3x4 = 0x8B68; +enum GL_FLOAT_MAT4x2 = 0x8B69; +enum GL_FLOAT_MAT4x3 = 0x8B6A; +enum GL_SRGB = 0x8C40; +enum GL_SRGB8 = 0x8C41; +enum GL_SRGB8_ALPHA8 = 0x8C43; +enum GL_COMPARE_REF_TO_TEXTURE = 0x884E; +enum GL_MAJOR_VERSION = 0x821B; +enum GL_MINOR_VERSION = 0x821C; +enum GL_NUM_EXTENSIONS = 0x821D; +enum GL_RGBA32F = 0x8814; +enum GL_RGB32F = 0x8815; +enum GL_RGBA16F = 0x881A; +enum GL_RGB16F = 0x881B; +enum GL_VERTEX_ATTRIB_ARRAY_INTEGER = 0x88FD; +enum GL_MAX_ARRAY_TEXTURE_LAYERS = 0x88FF; +enum GL_MIN_PROGRAM_TEXEL_OFFSET = 0x8904; +enum GL_MAX_PROGRAM_TEXEL_OFFSET = 0x8905; +enum GL_MAX_VARYING_COMPONENTS = 0x8B4B; +enum GL_TEXTURE_2D_ARRAY = 0x8C1A; +enum GL_TEXTURE_BINDING_2D_ARRAY = 0x8C1D; +enum GL_R11F_G11F_B10F = 0x8C3A; +enum GL_UNSIGNED_INT_10F_11F_11F_REV = 0x8C3B; +enum GL_RGB9_E5 = 0x8C3D; +enum GL_UNSIGNED_INT_5_9_9_9_REV = 0x8C3E; +enum GL_TRANSFORM_FEEDBACK_VARYING_MAX_LENGTH = 0x8C76; +enum GL_TRANSFORM_FEEDBACK_BUFFER_MODE = 0x8C7F; +enum GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS = 0x8C80; +enum GL_TRANSFORM_FEEDBACK_VARYINGS = 0x8C83; +enum GL_TRANSFORM_FEEDBACK_BUFFER_START = 0x8C84; +enum GL_TRANSFORM_FEEDBACK_BUFFER_SIZE = 0x8C85; +enum GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN = 0x8C88; +enum GL_RASTERIZER_DISCARD = 0x8C89; +enum GL_MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS = 0x8C8A; +enum GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS = 0x8C8B; +enum GL_INTERLEAVED_ATTRIBS = 0x8C8C; +enum GL_SEPARATE_ATTRIBS = 0x8C8D; +enum GL_TRANSFORM_FEEDBACK_BUFFER = 0x8C8E; +enum GL_TRANSFORM_FEEDBACK_BUFFER_BINDING = 0x8C8F; +enum GL_RGBA32UI = 0x8D70; +enum GL_RGB32UI = 0x8D71; +enum GL_RGBA16UI = 0x8D76; +enum GL_RGB16UI = 0x8D77; +enum GL_RGBA8UI = 0x8D7C; +enum GL_RGB8UI = 0x8D7D; +enum GL_RGBA32I = 0x8D82; +enum GL_RGB32I = 0x8D83; +enum GL_RGBA16I = 0x8D88; +enum GL_RGB16I = 0x8D89; +enum GL_RGBA8I = 0x8D8E; +enum GL_RGB8I = 0x8D8F; +enum GL_RED_INTEGER = 0x8D94; +enum GL_RGB_INTEGER = 0x8D98; +enum GL_RGBA_INTEGER = 0x8D99; +enum GL_SAMPLER_2D_ARRAY = 0x8DC1; +enum GL_SAMPLER_2D_ARRAY_SHADOW = 0x8DC4; +enum GL_SAMPLER_CUBE_SHADOW = 0x8DC5; +enum GL_UNSIGNED_INT_VEC2 = 0x8DC6; +enum GL_UNSIGNED_INT_VEC3 = 0x8DC7; +enum GL_UNSIGNED_INT_VEC4 = 0x8DC8; +enum GL_INT_SAMPLER_2D = 0x8DCA; +enum GL_INT_SAMPLER_3D = 0x8DCB; +enum GL_INT_SAMPLER_CUBE = 0x8DCC; +enum GL_INT_SAMPLER_2D_ARRAY = 0x8DCF; +enum GL_UNSIGNED_INT_SAMPLER_2D = 0x8DD2; +enum GL_UNSIGNED_INT_SAMPLER_3D = 0x8DD3; +enum GL_UNSIGNED_INT_SAMPLER_CUBE = 0x8DD4; +enum GL_UNSIGNED_INT_SAMPLER_2D_ARRAY = 0x8DD7; +enum GL_BUFFER_ACCESS_FLAGS = 0x911F; +enum GL_BUFFER_MAP_LENGTH = 0x9120; +enum GL_BUFFER_MAP_OFFSET = 0x9121; +enum GL_DEPTH_COMPONENT32F = 0x8CAC; +enum GL_DEPTH32F_STENCIL8 = 0x8CAD; +enum GL_FLOAT_32_UNSIGNED_INT_24_8_REV = 0x8DAD; +enum GL_FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING = 0x8210; +enum GL_FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE = 0x8211; +enum GL_FRAMEBUFFER_ATTACHMENT_RED_SIZE = 0x8212; +enum GL_FRAMEBUFFER_ATTACHMENT_GREEN_SIZE = 0x8213; +enum GL_FRAMEBUFFER_ATTACHMENT_BLUE_SIZE = 0x8214; +enum GL_FRAMEBUFFER_ATTACHMENT_ALPHA_SIZE = 0x8215; +enum GL_FRAMEBUFFER_ATTACHMENT_DEPTH_SIZE = 0x8216; +enum GL_FRAMEBUFFER_ATTACHMENT_STENCIL_SIZE = 0x8217; +enum GL_FRAMEBUFFER_DEFAULT = 0x8218; +enum GL_FRAMEBUFFER_UNDEFINED = 0x8219; +enum GL_DEPTH_STENCIL_ATTACHMENT = 0x821A; +enum GL_DEPTH_STENCIL = 0x84F9; +enum GL_UNSIGNED_INT_24_8 = 0x84FA; +enum GL_DEPTH24_STENCIL8 = 0x88F0; +enum GL_UNSIGNED_NORMALIZED = 0x8C17; +enum GL_DRAW_FRAMEBUFFER_BINDING = GL_FRAMEBUFFER_BINDING; +enum GL_READ_FRAMEBUFFER = 0x8CA8; +enum GL_DRAW_FRAMEBUFFER = 0x8CA9; +enum GL_READ_FRAMEBUFFER_BINDING = 0x8CAA; +enum GL_RENDERBUFFER_SAMPLES = 0x8CAB; +enum GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER = 0x8CD4; +enum GL_MAX_COLOR_ATTACHMENTS = 0x8CDF; +enum GL_COLOR_ATTACHMENT1 = 0x8CE1; +enum GL_COLOR_ATTACHMENT2 = 0x8CE2; +enum GL_COLOR_ATTACHMENT3 = 0x8CE3; +enum GL_COLOR_ATTACHMENT4 = 0x8CE4; +enum GL_COLOR_ATTACHMENT5 = 0x8CE5; +enum GL_COLOR_ATTACHMENT6 = 0x8CE6; +enum GL_COLOR_ATTACHMENT7 = 0x8CE7; +enum GL_COLOR_ATTACHMENT8 = 0x8CE8; +enum GL_COLOR_ATTACHMENT9 = 0x8CE9; +enum GL_COLOR_ATTACHMENT10 = 0x8CEA; +enum GL_COLOR_ATTACHMENT11 = 0x8CEB; +enum GL_COLOR_ATTACHMENT12 = 0x8CEC; +enum GL_COLOR_ATTACHMENT13 = 0x8CED; +enum GL_COLOR_ATTACHMENT14 = 0x8CEE; +enum GL_COLOR_ATTACHMENT15 = 0x8CEF; +enum GL_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE = 0x8D56; +enum GL_MAX_SAMPLES = 0x8D57; +enum GL_HALF_FLOAT = 0x140B; +enum GL_MAP_READ_BIT = 0x0001; +enum GL_MAP_WRITE_BIT = 0x0002; +enum GL_MAP_INVALIDATE_RANGE_BIT = 0x0004; +enum GL_MAP_INVALIDATE_BUFFER_BIT = 0x0008; +enum GL_MAP_FLUSH_EXPLICIT_BIT = 0x0010; +enum GL_MAP_UNSYNCHRONIZED_BIT = 0x0020; +enum GL_RG = 0x8227; +enum GL_RG_INTEGER = 0x8228; +enum GL_R8 = 0x8229; +enum GL_RG8 = 0x822B; +enum GL_R16F = 0x822D; +enum GL_R32F = 0x822E; +enum GL_RG16F = 0x822F; +enum GL_RG32F = 0x8230; +enum GL_R8I = 0x8231; +enum GL_R8UI = 0x8232; +enum GL_R16I = 0x8233; +enum GL_R16UI = 0x8234; +enum GL_R32I = 0x8235; +enum GL_R32UI = 0x8236; +enum GL_RG8I = 0x8237; +enum GL_RG8UI = 0x8238; +enum GL_RG16I = 0x8239; +enum GL_RG16UI = 0x823A; +enum GL_RG32I = 0x823B; +enum GL_RG32UI = 0x823C; +enum GL_VERTEX_ARRAY_BINDING = 0x85B5; +enum GL_R8_SNORM = 0x8F94; +enum GL_RG8_SNORM = 0x8F95; +enum GL_RGB8_SNORM = 0x8F96; +enum GL_RGBA8_SNORM = 0x8F97; +enum GL_SIGNED_NORMALIZED = 0x8F9C; +enum GL_PRIMITIVE_RESTART_FIXED_INDEX = 0x8D69; +enum GL_COPY_READ_BUFFER = 0x8F36; +enum GL_COPY_WRITE_BUFFER = 0x8F37; +enum GL_COPY_READ_BUFFER_BINDING = GL_COPY_READ_BUFFER; +enum GL_COPY_WRITE_BUFFER_BINDING = GL_COPY_WRITE_BUFFER; +enum GL_UNIFORM_BUFFER = 0x8A11; +enum GL_UNIFORM_BUFFER_BINDING = 0x8A28; +enum GL_UNIFORM_BUFFER_START = 0x8A29; +enum GL_UNIFORM_BUFFER_SIZE = 0x8A2A; +enum GL_MAX_VERTEX_UNIFORM_BLOCKS = 0x8A2B; +enum GL_MAX_FRAGMENT_UNIFORM_BLOCKS = 0x8A2D; +enum GL_MAX_COMBINED_UNIFORM_BLOCKS = 0x8A2E; +enum GL_MAX_UNIFORM_BUFFER_BINDINGS = 0x8A2F; +enum GL_MAX_UNIFORM_BLOCK_SIZE = 0x8A30; +enum GL_MAX_COMBINED_VERTEX_UNIFORM_COMPONENTS = 0x8A31; +enum GL_MAX_COMBINED_FRAGMENT_UNIFORM_COMPONENTS = 0x8A33; +enum GL_UNIFORM_BUFFER_OFFSET_ALIGNMENT = 0x8A34; +enum GL_ACTIVE_UNIFORM_BLOCK_MAX_NAME_LENGTH = 0x8A35; +enum GL_ACTIVE_UNIFORM_BLOCKS = 0x8A36; +enum GL_UNIFORM_TYPE = 0x8A37; +enum GL_UNIFORM_SIZE = 0x8A38; +enum GL_UNIFORM_NAME_LENGTH = 0x8A39; +enum GL_UNIFORM_BLOCK_INDEX = 0x8A3A; +enum GL_UNIFORM_OFFSET = 0x8A3B; +enum GL_UNIFORM_ARRAY_STRIDE = 0x8A3C; +enum GL_UNIFORM_MATRIX_STRIDE = 0x8A3D; +enum GL_UNIFORM_IS_ROW_MAJOR = 0x8A3E; +enum GL_UNIFORM_BLOCK_BINDING = 0x8A3F; +enum GL_UNIFORM_BLOCK_DATA_SIZE = 0x8A40; +enum GL_UNIFORM_BLOCK_NAME_LENGTH = 0x8A41; +enum GL_UNIFORM_BLOCK_ACTIVE_UNIFORMS = 0x8A42; +enum GL_UNIFORM_BLOCK_ACTIVE_UNIFORM_INDICES = 0x8A43; +enum GL_UNIFORM_BLOCK_REFERENCED_BY_VERTEX_SHADER = 0x8A44; +enum GL_UNIFORM_BLOCK_REFERENCED_BY_FRAGMENT_SHADER = 0x8A46; +enum GL_INVALID_INDEX = 0xFFFFFFFF; +enum GL_MAX_VERTEX_OUTPUT_COMPONENTS = 0x9122; +enum GL_MAX_FRAGMENT_INPUT_COMPONENTS = 0x9125; +enum GL_MAX_SERVER_WAIT_TIMEOUT = 0x9111; +enum GL_OBJECT_TYPE = 0x9112; +enum GL_SYNC_CONDITION = 0x9113; +enum GL_SYNC_STATUS = 0x9114; +enum GL_SYNC_FLAGS = 0x9115; +enum GL_SYNC_FENCE = 0x9116; +enum GL_SYNC_GPU_COMMANDS_COMPLETE = 0x9117; +enum GL_UNSIGNALED = 0x9118; +enum GL_SIGNALED = 0x9119; +enum GL_ALREADY_SIGNALED = 0x911A; +enum GL_TIMEOUT_EXPIRED = 0x911B; +enum GL_CONDITION_SATISFIED = 0x911C; +enum GL_WAIT_FAILED = 0x911D; +enum GL_SYNC_FLUSH_COMMANDS_BIT = 0x00000001; +enum GL_TIMEOUT_IGNORED = 0xFFFFFFFFFFFFFFFF; +enum GL_VERTEX_ATTRIB_ARRAY_DIVISOR = 0x88FE; +enum GL_ANY_SAMPLES_PASSED = 0x8C2F; +enum GL_ANY_SAMPLES_PASSED_CONSERVATIVE = 0x8D6A; +enum GL_SAMPLER_BINDING = 0x8919; +enum GL_RGB10_A2UI = 0x906F; +enum GL_TEXTURE_SWIZZLE_R = 0x8E42; +enum GL_TEXTURE_SWIZZLE_G = 0x8E43; +enum GL_TEXTURE_SWIZZLE_B = 0x8E44; +enum GL_TEXTURE_SWIZZLE_A = 0x8E45; +enum GL_GREEN = 0x1904; +enum GL_BLUE = 0x1905; +enum GL_INT_2_10_10_10_REV = 0x8D9F; +enum GL_TRANSFORM_FEEDBACK = 0x8E22; +enum GL_TRANSFORM_FEEDBACK_PAUSED = 0x8E23; +enum GL_TRANSFORM_FEEDBACK_ACTIVE = 0x8E24; +enum GL_TRANSFORM_FEEDBACK_BINDING = 0x8E25; +enum GL_PROGRAM_BINARY_RETRIEVABLE_HINT = 0x8257; +enum GL_PROGRAM_BINARY_LENGTH = 0x8741; +enum GL_NUM_PROGRAM_BINARY_FORMATS = 0x87FE; +enum GL_PROGRAM_BINARY_FORMATS = 0x87FF; +enum GL_COMPRESSED_R11_EAC = 0x9270; +enum GL_COMPRESSED_SIGNED_R11_EAC = 0x9271; +enum GL_COMPRESSED_RG11_EAC = 0x9272; +enum GL_COMPRESSED_SIGNED_RG11_EAC = 0x9273; +enum GL_COMPRESSED_RGB8_ETC2 = 0x9274; +enum GL_COMPRESSED_SRGB8_ETC2 = 0x9275; +enum GL_COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2 = 0x9276; +enum GL_COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2 = 0x9277; +enum GL_COMPRESSED_RGBA8_ETC2_EAC = 0x9278; +enum GL_COMPRESSED_SRGB8_ALPHA8_ETC2_EAC = 0x9279; +enum GL_TEXTURE_IMMUTABLE_FORMAT = 0x912F; +enum GL_MAX_ELEMENT_INDEX = 0x8D6B; +enum GL_NUM_SAMPLE_COUNTS = 0x9380; +enum GL_TEXTURE_IMMUTABLE_LEVELS = 0x82DF; + +struct __GLsync; + +void glActiveTexture(GLenum texture); +void glAttachShader(GLuint program, GLuint shader); +void glBindAttribLocation(GLuint program, GLuint index, const(GLchar)* name); +void glBindBuffer(GLenum target, GLuint buffer); +void glBindFramebuffer(GLenum target, GLuint framebuffer); +void glBindRenderbuffer(GLenum target, GLuint renderbuffer); +void glBindTexture(GLenum target, GLuint texture); +void glBlendColor(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha); +void glBlendEquation(GLenum mode); +void glBlendEquationSeparate(GLenum modeRGB, GLenum modeAlpha); +void glBlendFunc(GLenum sfactor, GLenum dfactor); +void glBlendFuncSeparate(GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha, GLenum dstAlpha); +void glBufferData(GLenum target, GLsizeiptr size, const(GLvoid)* data, GLenum usage); +void glBufferSubData(GLenum target, GLintptr offset, GLsizeiptr size, const(GLvoid)* data); +GLenum glCheckFramebufferStatus(GLenum target); +void glClear(GLbitfield mask); +void glClearColor(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha); +void glClearDepthf(GLfloat depth); +void glClearStencil(GLint s); +void glColorMask(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha); +void glCompileShader(GLuint shader); +void glCompressedTexImage2D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const(GLvoid)* data); +void glCompressedTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const(GLvoid)* data); +void glCopyTexImage2D(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border); +void glCopyTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height); +GLuint glCreateProgram(); +GLuint glCreateShader(GLenum type); +void glCullFace(GLenum mode); +void glDeleteBuffers(GLsizei n, const(GLuint)* buffers); +void glDeleteFramebuffers(GLsizei n, const(GLuint)* framebuffers); +void glDeleteProgram(GLuint program); +void glDeleteRenderbuffers(GLsizei n, const(GLuint)* renderbuffers); +void glDeleteShader(GLuint shader); +void glDeleteTextures(GLsizei n, const(GLuint)* textures); +void glDepthFunc(GLenum func); +void glDepthMask(GLboolean flag); +void glDepthRangef(GLfloat n, GLfloat f); +void glDetachShader(GLuint program, GLuint shader); +void glDisable(GLenum cap); +void glDisableVertexAttribArray(GLuint index); +void glDrawArrays(GLenum mode, GLint first, GLsizei count); +void glDrawElements(GLenum mode, GLsizei count, GLenum type, const(GLvoid)* indices); +void glEnable(GLenum cap); +void glEnableVertexAttribArray(GLuint index); +void glFinish(); +void glFlush(); +void glFramebufferRenderbuffer(GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer); +void glFramebufferTexture2D(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level); +void glFrontFace(GLenum mode); +void glGenBuffers(GLsizei n, GLuint* buffers); +void glGenerateMipmap(GLenum target); +void glGenFramebuffers(GLsizei n, GLuint* framebuffers); +void glGenRenderbuffers(GLsizei n, GLuint* renderbuffers); +void glGenTextures(GLsizei n, GLuint* textures); +void glGetActiveAttrib(GLuint program, GLuint index, GLsizei bufsize, GLsizei* length, GLint* size, GLenum* type, GLchar* name); +void glGetActiveUniform(GLuint program, GLuint index, GLsizei bufsize, GLsizei* length, GLint* size, GLenum* type, GLchar* name); +void glGetAttachedShaders(GLuint program, GLsizei maxcount, GLsizei* count, GLuint* shaders); +GLint glGetAttribLocation(GLuint program, const(GLchar)* name); +void glGetBooleanv(GLenum pname, GLboolean* params); +void glGetBufferParameteriv(GLenum target, GLenum pname, GLint* params); +GLenum glGetError(); +void glGetFloatv(GLenum pname, GLfloat* params); +void glGetFramebufferAttachmentParameteriv(GLenum target, GLenum attachment, GLenum pname, GLint* params); +void glGetIntegerv(GLenum pname, GLint* params); +void glGetProgramiv(GLuint program, GLenum pname, GLint* params); +void glGetProgramInfoLog(GLuint program, GLsizei bufsize, GLsizei* length, GLchar* infolog); +void glGetRenderbufferParameteriv(GLenum target, GLenum pname, GLint* params); +void glGetShaderiv(GLuint shader, GLenum pname, GLint* params); +void glGetShaderInfoLog(GLuint shader, GLsizei bufsize, GLsizei* length, GLchar* infolog); +void glGetShaderPrecisionFormat(GLenum shadertype, GLenum precisiontype, GLint* range, GLint* precision); +void glGetShaderSource(GLuint shader, GLsizei bufsize, GLsizei* length, GLchar* source); +const(GLubyte)* glGetString(GLenum name); +void glGetTexParameterfv(GLenum target, GLenum pname, GLfloat* params); +void glGetTexParameteriv(GLenum target, GLenum pname, GLint* params); +void glGetUniformfv(GLuint program, GLint location, GLfloat* params); +void glGetUniformiv(GLuint program, GLint location, GLint* params); +GLint glGetUniformLocation(GLuint program, const(GLchar)* name); +void glGetVertexAttribfv(GLuint index, GLenum pname, GLfloat* params); +void glGetVertexAttribiv(GLuint index, GLenum pname, GLint* params); +void glGetVertexAttribPointerv(GLuint index, GLenum pname, GLvoid** pointer); +void glHint(GLenum target, GLenum mode); +GLboolean glIsBuffer(GLuint buffer); +GLboolean glIsEnabled(GLenum cap); +GLboolean glIsFramebuffer(GLuint framebuffer); +GLboolean glIsProgram(GLuint program); +GLboolean glIsRenderbuffer(GLuint renderbuffer); +GLboolean glIsShader(GLuint shader); +GLboolean glIsTexture(GLuint texture); +void glLineWidth(GLfloat width); +void glLinkProgram(GLuint program); +void glPixelStorei(GLenum pname, GLint param); +void glPolygonOffset(GLfloat factor, GLfloat units); +void glReadPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLvoid* pixels); +void glReleaseShaderCompiler(); +void glRenderbufferStorage(GLenum target, GLenum internalformat, GLsizei width, GLsizei height); +void glSampleCoverage(GLfloat value, GLboolean invert); +void glScissor(GLint x, GLint y, GLsizei width, GLsizei height); +void glShaderBinary(GLsizei n, const(GLuint)* shaders, GLenum binaryformat, const(GLvoid)* binary, GLsizei length); +void glShaderSource(GLuint shader, GLsizei count, const(GLchar*)* string, const(GLint)* length); +void glStencilFunc(GLenum func, GLint ref_, GLuint mask); +void glStencilFuncSeparate(GLenum face, GLenum func, GLint ref_, GLuint mask); +void glStencilMask(GLuint mask); +void glStencilMaskSeparate(GLenum face, GLuint mask); +void glStencilOp(GLenum fail, GLenum zfail, GLenum zpass); +void glStencilOpSeparate(GLenum face, GLenum fail, GLenum zfail, GLenum zpass); +void glTexImage2D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const(GLvoid)* pixels); +void glTexParameterf(GLenum target, GLenum pname, GLfloat param); +void glTexParameterfv(GLenum target, GLenum pname, const(GLfloat)* params); +void glTexParameteri(GLenum target, GLenum pname, GLint param); +void glTexParameteriv(GLenum target, GLenum pname, const(GLint)* params); +void glTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const(GLvoid)* pixels); +void glUniform1f(GLint location, GLfloat x); +void glUniform1fv(GLint location, GLsizei count, const(GLfloat)* v); +void glUniform1i(GLint location, GLint x); +void glUniform1iv(GLint location, GLsizei count, const(GLint)* v); +void glUniform2f(GLint location, GLfloat x, GLfloat y); +void glUniform2fv(GLint location, GLsizei count, const(GLfloat)* v); +void glUniform2i(GLint location, GLint x, GLint y); +void glUniform2iv(GLint location, GLsizei count, const(GLint)* v); +void glUniform3f(GLint location, GLfloat x, GLfloat y, GLfloat z); +void glUniform3fv(GLint location, GLsizei count, const(GLfloat)* v); +void glUniform3i(GLint location, GLint x, GLint y, GLint z); +void glUniform3iv(GLint location, GLsizei count, const(GLint)* v); +void glUniform4f(GLint location, GLfloat x, GLfloat y, GLfloat z, GLfloat w); +void glUniform4fv(GLint location, GLsizei count, const(GLfloat)* v); +void glUniform4i(GLint location, GLint x, GLint y, GLint z, GLint w); +void glUniform4iv(GLint location, GLsizei count, const(GLint)* v); +void glUniformMatrix2fv(GLint location, GLsizei count, GLboolean transpose, const(GLfloat)* value); +void glUniformMatrix3fv(GLint location, GLsizei count, GLboolean transpose, const(GLfloat)* value); +void glUniformMatrix4fv(GLint location, GLsizei count, GLboolean transpose, const(GLfloat)* value); +void glUseProgram(GLuint program); +void glValidateProgram(GLuint program); +void glVertexAttrib1f(GLuint indx, GLfloat x); +void glVertexAttrib1fv(GLuint indx, const(GLfloat)* values); +void glVertexAttrib2f(GLuint indx, GLfloat x, GLfloat y); +void glVertexAttrib2fv(GLuint indx, const(GLfloat)* values); +void glVertexAttrib3f(GLuint indx, GLfloat x, GLfloat y, GLfloat z); +void glVertexAttrib3fv(GLuint indx, const(GLfloat)* values); +void glVertexAttrib4f(GLuint indx, GLfloat x, GLfloat y, GLfloat z, GLfloat w); +void glVertexAttrib4fv(GLuint indx, const(GLfloat)* values); +void glVertexAttribPointer(GLuint indx, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const(GLvoid)* ptr); +void glViewport(GLint x, GLint y, GLsizei width, GLsizei height); +void glReadBuffer(GLenum mode); +void glDrawRangeElements(GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const(GLvoid)* indices); +void glTexImage3D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const(GLvoid)* pixels); +void glTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const(GLvoid)* pixels); +void glCopyTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height); +void glCompressedTexImage3D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const(GLvoid)* data); +void glCompressedTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const(GLvoid)* data); +void glGenQueries(GLsizei n, GLuint* ids); +void glDeleteQueries(GLsizei n, const(GLuint)* ids); +GLboolean glIsQuery(GLuint id); +void glBeginQuery(GLenum target, GLuint id); +void glEndQuery(GLenum target); +void glGetQueryiv(GLenum target, GLenum pname, GLint* params); +void glGetQueryObjectuiv(GLuint id, GLenum pname, GLuint* params); +GLboolean glUnmapBuffer(GLenum target); +void glGetBufferPointerv(GLenum target, GLenum pname, GLvoid** params); +void glDrawBuffers(GLsizei n, const(GLenum)* bufs); +void glUniformMatrix2x3fv(GLint location, GLsizei count, GLboolean transpose, const(GLfloat)* value); +void glUniformMatrix3x2fv(GLint location, GLsizei count, GLboolean transpose, const(GLfloat)* value); +void glUniformMatrix2x4fv(GLint location, GLsizei count, GLboolean transpose, const(GLfloat)* value); +void glUniformMatrix4x2fv(GLint location, GLsizei count, GLboolean transpose, const(GLfloat)* value); +void glUniformMatrix3x4fv(GLint location, GLsizei count, GLboolean transpose, const(GLfloat)* value); +void glUniformMatrix4x3fv(GLint location, GLsizei count, GLboolean transpose, const(GLfloat)* value); +void glBlitFramebuffer(GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter); +void glRenderbufferStorageMultisample(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height); +void glFramebufferTextureLayer(GLenum target, GLenum attachment, GLuint texture, GLint level, GLint layer); +GLvoid* glMapBufferRange(GLenum target, GLintptr offset, GLsizeiptr length, GLbitfield access); +void glFlushMappedBufferRange(GLenum target, GLintptr offset, GLsizeiptr length); +void glBindVertexArray(GLuint array); +void glDeleteVertexArrays(GLsizei n, const(GLuint)* arrays); +void glGenVertexArrays(GLsizei n, GLuint* arrays); +GLboolean glIsVertexArray(GLuint array); +void glGetIntegeri_v(GLenum target, GLuint index, GLint* data); +void glBeginTransformFeedback(GLenum primitiveMode); +void glEndTransformFeedback(); +void glBindBufferRange(GLenum target, GLuint index, GLuint buffer, GLintptr offset, GLsizeiptr size); +void glBindBufferBase(GLenum target, GLuint index, GLuint buffer); +void glTransformFeedbackVaryings(GLuint program, GLsizei count, const(GLchar*)* varyings, GLenum bufferMode); +void glGetTransformFeedbackVarying(GLuint program, GLuint index, GLsizei bufSize, GLsizei* length, GLsizei* size, GLenum* type, GLchar* name); +void glVertexAttribIPointer(GLuint index, GLint size, GLenum type, GLsizei stride, const(GLvoid)* pointer); +void glGetVertexAttribIiv(GLuint index, GLenum pname, GLint* params); +void glGetVertexAttribIuiv(GLuint index, GLenum pname, GLuint* params); +void glVertexAttribI4i(GLuint index, GLint x, GLint y, GLint z, GLint w); +void glVertexAttribI4ui(GLuint index, GLuint x, GLuint y, GLuint z, GLuint w); +void glVertexAttribI4iv(GLuint index, const(GLint)* v); +void glVertexAttribI4uiv(GLuint index, const(GLuint)* v); +void glGetUniformuiv(GLuint program, GLint location, GLuint* params); +GLint glGetFragDataLocation(GLuint program, const(GLchar)* name); +void glUniform1ui(GLint location, GLuint v0); +void glUniform2ui(GLint location, GLuint v0, GLuint v1); +void glUniform3ui(GLint location, GLuint v0, GLuint v1, GLuint v2); +void glUniform4ui(GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3); +void glUniform1uiv(GLint location, GLsizei count, const(GLuint)* value); +void glUniform2uiv(GLint location, GLsizei count, const(GLuint)* value); +void glUniform3uiv(GLint location, GLsizei count, const(GLuint)* value); +void glUniform4uiv(GLint location, GLsizei count, const(GLuint)* value); +void glClearBufferiv(GLenum buffer, GLint drawbuffer, const(GLint)* value); +void glClearBufferuiv(GLenum buffer, GLint drawbuffer, const(GLuint)* value); +void glClearBufferfv(GLenum buffer, GLint drawbuffer, const(GLfloat)* value); +void glClearBufferfi(GLenum buffer, GLint drawbuffer, GLfloat depth, GLint stencil); +const(GLubyte)* glGetStringi(GLenum name, GLuint index); +void glCopyBufferSubData(GLenum readTarget, GLenum writeTarget, GLintptr readOffset, GLintptr writeOffset, GLsizeiptr size); +void glGetUniformIndices(GLuint program, GLsizei uniformCount, const(GLchar*)* uniformNames, GLuint* uniformIndices); +void glGetActiveUniformsiv(GLuint program, GLsizei uniformCount, const(GLuint)* uniformIndices, GLenum pname, GLint* params); +GLuint glGetUniformBlockIndex(GLuint program, const(GLchar)* uniformBlockName); +void glGetActiveUniformBlockiv(GLuint program, GLuint uniformBlockIndex, GLenum pname, GLint* params); +void glGetActiveUniformBlockName(GLuint program, GLuint uniformBlockIndex, GLsizei bufSize, GLsizei* length, GLchar* uniformBlockName); +void glUniformBlockBinding(GLuint program, GLuint uniformBlockIndex, GLuint uniformBlockBinding); +void glDrawArraysInstanced(GLenum mode, GLint first, GLsizei count, GLsizei instanceCount); +void glDrawElementsInstanced(GLenum mode, GLsizei count, GLenum type, const(GLvoid)* indices, GLsizei instanceCount); +GLsync glFenceSync(GLenum condition, GLbitfield flags); +GLboolean glIsSync(GLsync sync); +void glDeleteSync(GLsync sync); +GLenum glClientWaitSync(GLsync sync, GLbitfield flags, GLuint64 timeout); +void glWaitSync(GLsync sync, GLbitfield flags, GLuint64 timeout); +void glGetInteger64v(GLenum pname, GLint64* params); +void glGetSynciv(GLsync sync, GLenum pname, GLsizei bufSize, GLsizei* length, GLint* values); +void glGetInteger64i_v(GLenum target, GLuint index, GLint64* data); +void glGetBufferParameteri64v(GLenum target, GLenum pname, GLint64* params); +void glGenSamplers(GLsizei count, GLuint* samplers); +void glDeleteSamplers(GLsizei count, const(GLuint)* samplers); +GLboolean glIsSampler(GLuint sampler); +void glBindSampler(GLuint unit, GLuint sampler); +void glSamplerParameteri(GLuint sampler, GLenum pname, GLint param); +void glSamplerParameteriv(GLuint sampler, GLenum pname, const(GLint)* param); +void glSamplerParameterf(GLuint sampler, GLenum pname, GLfloat param); +void glSamplerParameterfv(GLuint sampler, GLenum pname, const(GLfloat)* param); +void glGetSamplerParameteriv(GLuint sampler, GLenum pname, GLint* params); +void glGetSamplerParameterfv(GLuint sampler, GLenum pname, GLfloat* params); +void glVertexAttribDivisor(GLuint index, GLuint divisor); +void glBindTransformFeedback(GLenum target, GLuint id); +void glDeleteTransformFeedbacks(GLsizei n, const(GLuint)* ids); +void glGenTransformFeedbacks(GLsizei n, GLuint* ids); +GLboolean glIsTransformFeedback(GLuint id); +void glPauseTransformFeedback(); +void glResumeTransformFeedback(); +void glGetProgramBinary(GLuint program, GLsizei bufSize, GLsizei* length, GLenum* binaryFormat, GLvoid* binary); +void glProgramBinary(GLuint program, GLenum binaryFormat, const(GLvoid)* binary, GLsizei length); +void glProgramParameteri(GLuint program, GLenum pname, GLint value); +void glInvalidateFramebuffer(GLenum target, GLsizei numAttachments, const(GLenum)* attachments); +void glInvalidateSubFramebuffer(GLenum target, GLsizei numAttachments, const(GLenum)* attachments, GLint x, GLint y, GLsizei width, GLsizei height); +void glTexStorage2D(GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height); +void glTexStorage3D(GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth); +void glGetInternalformativ(GLenum target, GLenum internalformat, GLenum pname, GLsizei bufSize, GLint* params); diff --git a/3rdparty/android/asset_manager.d b/3rdparty/android/asset_manager.d new file mode 100644 index 00000000..43c715c8 --- /dev/null +++ b/3rdparty/android/asset_manager.d @@ -0,0 +1,37 @@ +/* dstep -I/path/to/ndk-r9d/toolchains/llvm-3.4/prebuilt/linux-x86/lib/clang/3.4/include /path/to/ndk-r9d/platforms/android-9/arch-x86/usr/include/android/asset_manager.h -o asset_manager.d */ + +module android.asset_manager; + +import core.sys.posix.sys.types; + +version (Android): +extern (C): +@system: +nothrow: +@nogc: + +enum +{ + AASSET_MODE_UNKNOWN, + AASSET_MODE_RANDOM, + AASSET_MODE_STREAMING, + AASSET_MODE_BUFFER +} + +struct AAssetManager; +struct AAssetDir; +struct AAsset; + +AAssetDir* AAssetManager_openDir(AAssetManager* mgr, const(char)* dirName); +AAsset* AAssetManager_open(AAssetManager* mgr, const(char)* filename, int mode); +const(char)* AAssetDir_getNextFileName(AAssetDir* assetDir); +void AAssetDir_rewind(AAssetDir* assetDir); +void AAssetDir_close(AAssetDir* assetDir); +int AAsset_read(AAsset* asset, void* buf, size_t count); +off_t AAsset_seek(AAsset* asset, off_t offset, int whence); +void AAsset_close(AAsset* asset); +const(void)* AAsset_getBuffer(AAsset* asset); +off_t AAsset_getLength(AAsset* asset); +off_t AAsset_getRemainingLength(AAsset* asset); +int AAsset_openFileDescriptor(AAsset* asset, off_t* outStart, off_t* outLength); +int AAsset_isAllocated(AAsset* asset); diff --git a/3rdparty/android/bitmap.d b/3rdparty/android/bitmap.d new file mode 100644 index 00000000..0da3f928 --- /dev/null +++ b/3rdparty/android/bitmap.d @@ -0,0 +1,38 @@ +/* dstep -I/path/to/ndk-r10/platforms/android-9/arch-x86/usr/include -I/path/to/ndk-r10/toolchains/llvm-3.4/prebuilt/linux-x86/lib/clang/3.4/include /path/to/ndk-r10/platforms/android-9/arch-x86/usr/include/android/bitmap.h -o bitmap.d*/ + +module android.bitmap; + +import jni; + +version (Android): +extern (C): +@system: +nothrow: +@nogc: + +enum ANDROID_BITMAP_RESULT_SUCCESS = 0; +enum ANDROID_BITMAP_RESULT_BAD_PARAMETER = -1; +enum ANDROID_BITMAP_RESULT_JNI_EXCEPTION = -2; +enum ANDROID_BITMAP_RESULT_ALLOCATION_FAILED = -3; + +enum AndroidBitmapFormat +{ + ANDROID_BITMAP_FORMAT_NONE = 0, + ANDROID_BITMAP_FORMAT_RGBA_8888 = 1, + ANDROID_BITMAP_FORMAT_RGB_565 = 4, + ANDROID_BITMAP_FORMAT_RGBA_4444 = 7, + ANDROID_BITMAP_FORMAT_A_8 = 8 +} + +struct AndroidBitmapInfo +{ + uint width; + uint height; + uint stride; + int format; + uint flags; +} + +int AndroidBitmap_getInfo(JNIEnv* env, jobject jbitmap, AndroidBitmapInfo* info); +int AndroidBitmap_lockPixels(JNIEnv* env, jobject jbitmap, void** addrPtr); +int AndroidBitmap_unlockPixels(JNIEnv* env, jobject jbitmap); diff --git a/3rdparty/android/configuration.d b/3rdparty/android/configuration.d new file mode 100644 index 00000000..943cd484 --- /dev/null +++ b/3rdparty/android/configuration.d @@ -0,0 +1,125 @@ +/* dstep -I/path/to/ndk-r9d/platforms/android-9/arch-x86/usr/include -I/path/to/ndk-r9d/toolchains/llvm-3.4/prebuilt/linux-x86/lib/clang/3.4/include /path/to/ndk-r9d/platforms/android-9/arch-x86/usr/include/android/configuration.h -o configuration.d*/ + +module android.configuration; + +import android.asset_manager; + +version (Android): +extern (C): +@system: +nothrow: +@nogc: + +enum +{ + ACONFIGURATION_ORIENTATION_ANY = 0, + ACONFIGURATION_ORIENTATION_PORT = 1, + ACONFIGURATION_ORIENTATION_LAND = 2, + ACONFIGURATION_ORIENTATION_SQUARE = 3, + + ACONFIGURATION_TOUCHSCREEN_ANY = 0, + ACONFIGURATION_TOUCHSCREEN_NOTOUCH = 1, + ACONFIGURATION_TOUCHSCREEN_STYLUS = 2, + ACONFIGURATION_TOUCHSCREEN_FINGER = 3, + + ACONFIGURATION_DENSITY_DEFAULT = 0, + ACONFIGURATION_DENSITY_LOW = 120, + ACONFIGURATION_DENSITY_MEDIUM = 160, + ACONFIGURATION_DENSITY_HIGH = 240, + ACONFIGURATION_DENSITY_NONE = 65535, + + ACONFIGURATION_KEYBOARD_ANY = 0, + ACONFIGURATION_KEYBOARD_NOKEYS = 1, + ACONFIGURATION_KEYBOARD_QWERTY = 2, + ACONFIGURATION_KEYBOARD_12KEY = 3, + + ACONFIGURATION_NAVIGATION_ANY = 0, + ACONFIGURATION_NAVIGATION_NONAV = 1, + ACONFIGURATION_NAVIGATION_DPAD = 2, + ACONFIGURATION_NAVIGATION_TRACKBALL = 3, + ACONFIGURATION_NAVIGATION_WHEEL = 4, + + ACONFIGURATION_KEYSHIDDEN_ANY = 0, + ACONFIGURATION_KEYSHIDDEN_NO = 1, + ACONFIGURATION_KEYSHIDDEN_YES = 2, + ACONFIGURATION_KEYSHIDDEN_SOFT = 3, + + ACONFIGURATION_NAVHIDDEN_ANY = 0, + ACONFIGURATION_NAVHIDDEN_NO = 1, + ACONFIGURATION_NAVHIDDEN_YES = 2, + + ACONFIGURATION_SCREENSIZE_ANY = 0, + ACONFIGURATION_SCREENSIZE_SMALL = 1, + ACONFIGURATION_SCREENSIZE_NORMAL = 2, + ACONFIGURATION_SCREENSIZE_LARGE = 3, + ACONFIGURATION_SCREENSIZE_XLARGE = 4, + + ACONFIGURATION_SCREENLONG_ANY = 0, + ACONFIGURATION_SCREENLONG_NO = 1, + ACONFIGURATION_SCREENLONG_YES = 2, + + ACONFIGURATION_UI_MODE_TYPE_ANY = 0, + ACONFIGURATION_UI_MODE_TYPE_NORMAL = 1, + ACONFIGURATION_UI_MODE_TYPE_DESK = 2, + ACONFIGURATION_UI_MODE_TYPE_CAR = 3, + + ACONFIGURATION_UI_MODE_NIGHT_ANY = 0, + ACONFIGURATION_UI_MODE_NIGHT_NO = 1, + ACONFIGURATION_UI_MODE_NIGHT_YES = 2, + + ACONFIGURATION_MCC = 1, + ACONFIGURATION_MNC = 2, + ACONFIGURATION_LOCALE = 4, + ACONFIGURATION_TOUCHSCREEN = 8, + ACONFIGURATION_KEYBOARD = 16, + ACONFIGURATION_KEYBOARD_HIDDEN = 32, + ACONFIGURATION_NAVIGATION = 64, + ACONFIGURATION_ORIENTATION = 128, + ACONFIGURATION_DENSITY = 256, + ACONFIGURATION_SCREEN_SIZE = 512, + ACONFIGURATION_VERSION = 1024, + ACONFIGURATION_SCREEN_LAYOUT = 2048, + ACONFIGURATION_UI_MODE = 4096 +} + +struct AConfiguration; + +AConfiguration* AConfiguration_new(); +void AConfiguration_delete(AConfiguration* config); +void AConfiguration_fromAssetManager(AConfiguration* out_, AAssetManager* am); +void AConfiguration_copy(AConfiguration* dest, AConfiguration* src); +int AConfiguration_getMcc(AConfiguration* config); +void AConfiguration_setMcc(AConfiguration* config, int mcc); +int AConfiguration_getMnc(AConfiguration* config); +void AConfiguration_setMnc(AConfiguration* config, int mnc); +void AConfiguration_getLanguage(AConfiguration* config, char* outLanguage); +void AConfiguration_setLanguage(AConfiguration* config, const(char)* language); +void AConfiguration_getCountry(AConfiguration* config, char* outCountry); +void AConfiguration_setCountry(AConfiguration* config, const(char)* country); +int AConfiguration_getOrientation(AConfiguration* config); +void AConfiguration_setOrientation(AConfiguration* config, int orientation); +int AConfiguration_getTouchscreen(AConfiguration* config); +void AConfiguration_setTouchscreen(AConfiguration* config, int touchscreen); +int AConfiguration_getDensity(AConfiguration* config); +void AConfiguration_setDensity(AConfiguration* config, int density); +int AConfiguration_getKeyboard(AConfiguration* config); +void AConfiguration_setKeyboard(AConfiguration* config, int keyboard); +int AConfiguration_getNavigation(AConfiguration* config); +void AConfiguration_setNavigation(AConfiguration* config, int navigation); +int AConfiguration_getKeysHidden(AConfiguration* config); +void AConfiguration_setKeysHidden(AConfiguration* config, int keysHidden); +int AConfiguration_getNavHidden(AConfiguration* config); +void AConfiguration_setNavHidden(AConfiguration* config, int navHidden); +int AConfiguration_getSdkVersion(AConfiguration* config); +void AConfiguration_setSdkVersion(AConfiguration* config, int sdkVersion); +int AConfiguration_getScreenSize(AConfiguration* config); +void AConfiguration_setScreenSize(AConfiguration* config, int screenSize); +int AConfiguration_getScreenLong(AConfiguration* config); +void AConfiguration_setScreenLong(AConfiguration* config, int screenLong); +int AConfiguration_getUiModeType(AConfiguration* config); +void AConfiguration_setUiModeType(AConfiguration* config, int uiModeType); +int AConfiguration_getUiModeNight(AConfiguration* config); +void AConfiguration_setUiModeNight(AConfiguration* config, int uiModeNight); +int AConfiguration_diff(AConfiguration* config1, AConfiguration* config2); +int AConfiguration_match(AConfiguration* base, AConfiguration* requested); +int AConfiguration_isBetterThan(AConfiguration* base, AConfiguration* test, AConfiguration* requested); diff --git a/3rdparty/android/input.d b/3rdparty/android/input.d new file mode 100644 index 00000000..64b4c64f --- /dev/null +++ b/3rdparty/android/input.d @@ -0,0 +1,185 @@ +/* dstep -I/path/to/ndk-r9d/platforms/android-9/arch-x86/usr/include -I/path/to/ndk-r9d/toolchains/llvm-3.4/prebuilt/linux-x86/lib/clang/3.4/include /path/to/ndk-r9d/platforms/android-9/arch-x86/usr/include/android/input.h -o input.d*/ + +module android.input; + +import android.keycodes, android.looper; + +version (Android): +extern (C): +@system: +nothrow: +@nogc: + +enum +{ + AKEY_STATE_UNKNOWN = -1, + AKEY_STATE_UP = 0, + AKEY_STATE_DOWN = 1, + AKEY_STATE_VIRTUAL = 2 +} + +enum +{ + AMETA_NONE = 0, + AMETA_ALT_ON = 2, + AMETA_ALT_LEFT_ON = 16, + AMETA_ALT_RIGHT_ON = 32, + AMETA_SHIFT_ON = 1, + AMETA_SHIFT_LEFT_ON = 64, + AMETA_SHIFT_RIGHT_ON = 128, + AMETA_SYM_ON = 4 +} + +enum +{ + AINPUT_EVENT_TYPE_KEY = 1, + AINPUT_EVENT_TYPE_MOTION = 2 +} + +enum +{ + AKEY_EVENT_ACTION_DOWN = 0, + AKEY_EVENT_ACTION_UP = 1, + AKEY_EVENT_ACTION_MULTIPLE = 2 +} + +enum +{ + AKEY_EVENT_FLAG_WOKE_HERE = 1, + AKEY_EVENT_FLAG_SOFT_KEYBOARD = 2, + AKEY_EVENT_FLAG_KEEP_TOUCH_MODE = 4, + AKEY_EVENT_FLAG_FROM_SYSTEM = 8, + AKEY_EVENT_FLAG_EDITOR_ACTION = 16, + AKEY_EVENT_FLAG_CANCELED = 32, + AKEY_EVENT_FLAG_VIRTUAL_HARD_KEY = 64, + AKEY_EVENT_FLAG_LONG_PRESS = 128, + AKEY_EVENT_FLAG_CANCELED_LONG_PRESS = 256, + AKEY_EVENT_FLAG_TRACKING = 512 +} + +enum AMOTION_EVENT_ACTION_POINTER_INDEX_SHIFT = 8; + +enum +{ + AMOTION_EVENT_ACTION_MASK = 255, + AMOTION_EVENT_ACTION_POINTER_INDEX_MASK = 65280, + AMOTION_EVENT_ACTION_DOWN = 0, + AMOTION_EVENT_ACTION_UP = 1, + AMOTION_EVENT_ACTION_MOVE = 2, + AMOTION_EVENT_ACTION_CANCEL = 3, + AMOTION_EVENT_ACTION_OUTSIDE = 4, + AMOTION_EVENT_ACTION_POINTER_DOWN = 5, + AMOTION_EVENT_ACTION_POINTER_UP = 6 +} + +enum +{ + AMOTION_EVENT_FLAG_WINDOW_IS_OBSCURED = 1 +} + +enum +{ + AMOTION_EVENT_EDGE_FLAG_NONE = 0, + AMOTION_EVENT_EDGE_FLAG_TOP = 1, + AMOTION_EVENT_EDGE_FLAG_BOTTOM = 2, + AMOTION_EVENT_EDGE_FLAG_LEFT = 4, + AMOTION_EVENT_EDGE_FLAG_RIGHT = 8 +} + +enum +{ + AINPUT_SOURCE_CLASS_MASK = 255, + AINPUT_SOURCE_CLASS_BUTTON = 1, + AINPUT_SOURCE_CLASS_POINTER = 2, + AINPUT_SOURCE_CLASS_NAVIGATION = 4, + AINPUT_SOURCE_CLASS_POSITION = 8 +} + +enum +{ + AINPUT_SOURCE_UNKNOWN = 0, + AINPUT_SOURCE_KEYBOARD = 257, + AINPUT_SOURCE_DPAD = 513, + AINPUT_SOURCE_TOUCHSCREEN = 4098, + AINPUT_SOURCE_MOUSE = 8194, + AINPUT_SOURCE_TRACKBALL = 65540, + AINPUT_SOURCE_TOUCHPAD = 1048584, + AINPUT_SOURCE_ANY = 0xffffff00 +} + +enum +{ + AINPUT_KEYBOARD_TYPE_NONE = 0, + AINPUT_KEYBOARD_TYPE_NON_ALPHABETIC = 1, + AINPUT_KEYBOARD_TYPE_ALPHABETIC = 2 +} + +enum +{ + AINPUT_MOTION_RANGE_X = 0, + AINPUT_MOTION_RANGE_Y = 1, + AINPUT_MOTION_RANGE_PRESSURE = 2, + AINPUT_MOTION_RANGE_SIZE = 3, + AINPUT_MOTION_RANGE_TOUCH_MAJOR = 4, + AINPUT_MOTION_RANGE_TOUCH_MINOR = 5, + AINPUT_MOTION_RANGE_TOOL_MAJOR = 6, + AINPUT_MOTION_RANGE_TOOL_MINOR = 7, + AINPUT_MOTION_RANGE_ORIENTATION = 8 +} + +struct AInputQueue; +struct AInputEvent; + +int AInputEvent_getType(const(AInputEvent)* event); +int AInputEvent_getDeviceId(const(AInputEvent)* event); +int AInputEvent_getSource(const(AInputEvent)* event); +int AKeyEvent_getAction(const(AInputEvent)* key_event); +int AKeyEvent_getFlags(const(AInputEvent)* key_event); +int AKeyEvent_getKeyCode(const(AInputEvent)* key_event); +int AKeyEvent_getScanCode(const(AInputEvent)* key_event); +int AKeyEvent_getMetaState(const(AInputEvent)* key_event); +int AKeyEvent_getRepeatCount(const(AInputEvent)* key_event); +long AKeyEvent_getDownTime(const(AInputEvent)* key_event); +long AKeyEvent_getEventTime(const(AInputEvent)* key_event); +int AMotionEvent_getAction(const(AInputEvent)* motion_event); +int AMotionEvent_getFlags(const(AInputEvent)* motion_event); +int AMotionEvent_getMetaState(const(AInputEvent)* motion_event); +int AMotionEvent_getEdgeFlags(const(AInputEvent)* motion_event); +long AMotionEvent_getDownTime(const(AInputEvent)* motion_event); +long AMotionEvent_getEventTime(const(AInputEvent)* motion_event); +float AMotionEvent_getXOffset(const(AInputEvent)* motion_event); +float AMotionEvent_getYOffset(const(AInputEvent)* motion_event); +float AMotionEvent_getXPrecision(const(AInputEvent)* motion_event); +float AMotionEvent_getYPrecision(const(AInputEvent)* motion_event); +size_t AMotionEvent_getPointerCount(const(AInputEvent)* motion_event); +int AMotionEvent_getPointerId(const(AInputEvent)* motion_event, size_t pointer_index); +float AMotionEvent_getRawX(const(AInputEvent)* motion_event, size_t pointer_index); +float AMotionEvent_getRawY(const(AInputEvent)* motion_event, size_t pointer_index); +float AMotionEvent_getX(const(AInputEvent)* motion_event, size_t pointer_index); +float AMotionEvent_getY(const(AInputEvent)* motion_event, size_t pointer_index); +float AMotionEvent_getPressure(const(AInputEvent)* motion_event, size_t pointer_index); +float AMotionEvent_getSize(const(AInputEvent)* motion_event, size_t pointer_index); +float AMotionEvent_getTouchMajor(const(AInputEvent)* motion_event, size_t pointer_index); +float AMotionEvent_getTouchMinor(const(AInputEvent)* motion_event, size_t pointer_index); +float AMotionEvent_getToolMajor(const(AInputEvent)* motion_event, size_t pointer_index); +float AMotionEvent_getToolMinor(const(AInputEvent)* motion_event, size_t pointer_index); +float AMotionEvent_getOrientation(const(AInputEvent)* motion_event, size_t pointer_index); +size_t AMotionEvent_getHistorySize(const(AInputEvent)* motion_event); +long AMotionEvent_getHistoricalEventTime(const(AInputEvent)* motion_event, size_t history_index); +float AMotionEvent_getHistoricalRawX(const(AInputEvent)* motion_event, size_t pointer_index, size_t history_index); +float AMotionEvent_getHistoricalRawY(const(AInputEvent)* motion_event, size_t pointer_index, size_t history_index); +float AMotionEvent_getHistoricalX(const(AInputEvent)* motion_event, size_t pointer_index, size_t history_index); +float AMotionEvent_getHistoricalY(const(AInputEvent)* motion_event, size_t pointer_index, size_t history_index); +float AMotionEvent_getHistoricalPressure(const(AInputEvent)* motion_event, size_t pointer_index, size_t history_index); +float AMotionEvent_getHistoricalSize(const(AInputEvent)* motion_event, size_t pointer_index, size_t history_index); +float AMotionEvent_getHistoricalTouchMajor(const(AInputEvent)* motion_event, size_t pointer_index, size_t history_index); +float AMotionEvent_getHistoricalTouchMinor(const(AInputEvent)* motion_event, size_t pointer_index, size_t history_index); +float AMotionEvent_getHistoricalToolMajor(const(AInputEvent)* motion_event, size_t pointer_index, size_t history_index); +float AMotionEvent_getHistoricalToolMinor(const(AInputEvent)* motion_event, size_t pointer_index, size_t history_index); +float AMotionEvent_getHistoricalOrientation(const(AInputEvent)* motion_event, size_t pointer_index, size_t history_index); +void AInputQueue_attachLooper(AInputQueue* queue, ALooper* looper, int ident, ALooper_callbackFunc callback, void* data); +void AInputQueue_detachLooper(AInputQueue* queue); +int AInputQueue_hasEvents(AInputQueue* queue); +int AInputQueue_getEvent(AInputQueue* queue, AInputEvent** outEvent); +int AInputQueue_preDispatchEvent(AInputQueue* queue, AInputEvent* event); +void AInputQueue_finishEvent(AInputQueue* queue, AInputEvent* event, int handled); diff --git a/3rdparty/android/keycodes.d b/3rdparty/android/keycodes.d new file mode 100644 index 00000000..cd4dfaad --- /dev/null +++ b/3rdparty/android/keycodes.d @@ -0,0 +1,124 @@ +/* dstep -I/path/to/ndk-r9d/toolchains/llvm-3.4/prebuilt/linux-x86/lib/clang/3.4/include /path/to/ndk-r9d/platforms/android-9/arch-x86/usr/include/android/keycodes.h -o keycodes.d*/ + +module android.keycodes; + +version (Android): +extern (C): +@system: +nothrow: +@nogc: + +enum +{ + AKEYCODE_UNKNOWN = 0, + AKEYCODE_SOFT_LEFT = 1, + AKEYCODE_SOFT_RIGHT = 2, + AKEYCODE_HOME = 3, + AKEYCODE_BACK = 4, + AKEYCODE_CALL = 5, + AKEYCODE_ENDCALL = 6, + AKEYCODE_0 = 7, + AKEYCODE_1 = 8, + AKEYCODE_2 = 9, + AKEYCODE_3 = 10, + AKEYCODE_4 = 11, + AKEYCODE_5 = 12, + AKEYCODE_6 = 13, + AKEYCODE_7 = 14, + AKEYCODE_8 = 15, + AKEYCODE_9 = 16, + AKEYCODE_STAR = 17, + AKEYCODE_POUND = 18, + AKEYCODE_DPAD_UP = 19, + AKEYCODE_DPAD_DOWN = 20, + AKEYCODE_DPAD_LEFT = 21, + AKEYCODE_DPAD_RIGHT = 22, + AKEYCODE_DPAD_CENTER = 23, + AKEYCODE_VOLUME_UP = 24, + AKEYCODE_VOLUME_DOWN = 25, + AKEYCODE_POWER = 26, + AKEYCODE_CAMERA = 27, + AKEYCODE_CLEAR = 28, + AKEYCODE_A = 29, + AKEYCODE_B = 30, + AKEYCODE_C = 31, + AKEYCODE_D = 32, + AKEYCODE_E = 33, + AKEYCODE_F = 34, + AKEYCODE_G = 35, + AKEYCODE_H = 36, + AKEYCODE_I = 37, + AKEYCODE_J = 38, + AKEYCODE_K = 39, + AKEYCODE_L = 40, + AKEYCODE_M = 41, + AKEYCODE_N = 42, + AKEYCODE_O = 43, + AKEYCODE_P = 44, + AKEYCODE_Q = 45, + AKEYCODE_R = 46, + AKEYCODE_S = 47, + AKEYCODE_T = 48, + AKEYCODE_U = 49, + AKEYCODE_V = 50, + AKEYCODE_W = 51, + AKEYCODE_X = 52, + AKEYCODE_Y = 53, + AKEYCODE_Z = 54, + AKEYCODE_COMMA = 55, + AKEYCODE_PERIOD = 56, + AKEYCODE_ALT_LEFT = 57, + AKEYCODE_ALT_RIGHT = 58, + AKEYCODE_SHIFT_LEFT = 59, + AKEYCODE_SHIFT_RIGHT = 60, + AKEYCODE_TAB = 61, + AKEYCODE_SPACE = 62, + AKEYCODE_SYM = 63, + AKEYCODE_EXPLORER = 64, + AKEYCODE_ENVELOPE = 65, + AKEYCODE_ENTER = 66, + AKEYCODE_DEL = 67, + AKEYCODE_GRAVE = 68, + AKEYCODE_MINUS = 69, + AKEYCODE_EQUALS = 70, + AKEYCODE_LEFT_BRACKET = 71, + AKEYCODE_RIGHT_BRACKET = 72, + AKEYCODE_BACKSLASH = 73, + AKEYCODE_SEMICOLON = 74, + AKEYCODE_APOSTROPHE = 75, + AKEYCODE_SLASH = 76, + AKEYCODE_AT = 77, + AKEYCODE_NUM = 78, + AKEYCODE_HEADSETHOOK = 79, + AKEYCODE_FOCUS = 80, + AKEYCODE_PLUS = 81, + AKEYCODE_MENU = 82, + AKEYCODE_NOTIFICATION = 83, + AKEYCODE_SEARCH = 84, + AKEYCODE_MEDIA_PLAY_PAUSE = 85, + AKEYCODE_MEDIA_STOP = 86, + AKEYCODE_MEDIA_NEXT = 87, + AKEYCODE_MEDIA_PREVIOUS = 88, + AKEYCODE_MEDIA_REWIND = 89, + AKEYCODE_MEDIA_FAST_FORWARD = 90, + AKEYCODE_MUTE = 91, + AKEYCODE_PAGE_UP = 92, + AKEYCODE_PAGE_DOWN = 93, + AKEYCODE_PICTSYMBOLS = 94, + AKEYCODE_SWITCH_CHARSET = 95, + AKEYCODE_BUTTON_A = 96, + AKEYCODE_BUTTON_B = 97, + AKEYCODE_BUTTON_C = 98, + AKEYCODE_BUTTON_X = 99, + AKEYCODE_BUTTON_Y = 100, + AKEYCODE_BUTTON_Z = 101, + AKEYCODE_BUTTON_L1 = 102, + AKEYCODE_BUTTON_R1 = 103, + AKEYCODE_BUTTON_L2 = 104, + AKEYCODE_BUTTON_R2 = 105, + AKEYCODE_BUTTON_THUMBL = 106, + AKEYCODE_BUTTON_THUMBR = 107, + AKEYCODE_BUTTON_START = 108, + AKEYCODE_BUTTON_SELECT = 109, + AKEYCODE_BUTTON_MODE = 110 +} diff --git a/3rdparty/android/log.d b/3rdparty/android/log.d new file mode 100644 index 00000000..aa92dadb --- /dev/null +++ b/3rdparty/android/log.d @@ -0,0 +1,29 @@ +/* dstep -I/path/to/ndk-r9d/toolchains/llvm-3.4/prebuilt/linux-x86/lib/clang/3.4/include /path/to/ndk-r9d/platforms/android-9/arch-x86/usr/include/android/log.h -o log.d*/ + +module android.log; + +import core.stdc.stdarg; + +version (Android): +extern (C): +@system: +nothrow: +@nogc: + +enum android_LogPriority +{ + ANDROID_LOG_UNKNOWN, + ANDROID_LOG_DEFAULT, + ANDROID_LOG_VERBOSE, + ANDROID_LOG_DEBUG, + ANDROID_LOG_INFO, + ANDROID_LOG_WARN, + ANDROID_LOG_ERROR, + ANDROID_LOG_FATAL, + ANDROID_LOG_SILENT +} + +int __android_log_write(int prio, const(char)* tag, const(char)* text); +int __android_log_print(int prio, const(char)* tag, const(char)* fmt, ...); +int __android_log_vprint(int prio, const(char)* tag, const(char)* fmt, va_list ap); +void __android_log_assert(const(char)* cond, const(char)* tag, const(char)* fmt, ...); diff --git a/3rdparty/android/looper.d b/3rdparty/android/looper.d new file mode 100644 index 00000000..a94b70a4 --- /dev/null +++ b/3rdparty/android/looper.d @@ -0,0 +1,45 @@ +/* dstep /path/to/ndk-r9d/platforms/android-9/arch-x86/usr/include/android/looper.h -o looper.d*/ + +module android.looper; + +version (Android): +extern (C): +@system: +nothrow: +@nogc: + +alias int function(int, int, void*) ALooper_callbackFunc; + +enum +{ + ALOOPER_PREPARE_ALLOW_NON_CALLBACKS = 1 +} + +enum +{ + ALOOPER_POLL_WAKE = -1, + ALOOPER_POLL_CALLBACK = -2, + ALOOPER_POLL_TIMEOUT = -3, + ALOOPER_POLL_ERROR = -4 +} + +enum +{ + ALOOPER_EVENT_INPUT = 1, + ALOOPER_EVENT_OUTPUT = 2, + ALOOPER_EVENT_ERROR = 4, + ALOOPER_EVENT_HANGUP = 8, + ALOOPER_EVENT_INVALID = 16 +} + +struct ALooper; + +ALooper* ALooper_forThread(); +ALooper* ALooper_prepare(int opts); +void ALooper_acquire(ALooper* looper); +void ALooper_release(ALooper* looper); +int ALooper_pollOnce(int timeoutMillis, int* outFd, int* outEvents, void** outData); +int ALooper_pollAll(int timeoutMillis, int* outFd, int* outEvents, void** outData); +void ALooper_wake(ALooper* looper); +int ALooper_addFd(ALooper* looper, int fd, int ident, int events, ALooper_callbackFunc callback, void* data); +int ALooper_removeFd(ALooper* looper, int fd); diff --git a/3rdparty/android/native_activity.d b/3rdparty/android/native_activity.d new file mode 100644 index 00000000..fc05b9a6 --- /dev/null +++ b/3rdparty/android/native_activity.d @@ -0,0 +1,65 @@ +/* dstep -I/path/to/ndk-r9d/platforms/android-9/arch-x86/usr/include -I/path/to/ndk-r9d/toolchains/llvm-3.4/prebuilt/linux-x86/lib/clang/3.4/include /path/to/ndk-r9d/platforms/android-9/arch-x86/usr/include/android/native_activity.h -o native_activity.d*/ + +module android.native_activity; + +import jni; +import android.rect; +import android.asset_manager, android.input, android.native_window; + +version (Android): +extern (C): +@system: +nothrow: +@nogc: + +enum +{ + ANATIVEACTIVITY_SHOW_SOFT_INPUT_IMPLICIT = 1, + ANATIVEACTIVITY_SHOW_SOFT_INPUT_FORCED = 2 +} + +enum +{ + ANATIVEACTIVITY_HIDE_SOFT_INPUT_IMPLICIT_ONLY = 1, + ANATIVEACTIVITY_HIDE_SOFT_INPUT_NOT_ALWAYS = 2 +} + +struct ANativeActivity +{ + ANativeActivityCallbacks* callbacks; + JavaVM* vm; + JNIEnv* env; + jobject clazz; + const(char)* internalDataPath; + const(char)* externalDataPath; + int sdkVersion; + void* instance; + AAssetManager* assetManager; +} + +struct ANativeActivityCallbacks +{ + void function(ANativeActivity*) onStart; + void function(ANativeActivity*) onResume; + void* function(ANativeActivity*, size_t*) onSaveInstanceState; + void function(ANativeActivity*) onPause; + void function(ANativeActivity*) onStop; + void function(ANativeActivity*) onDestroy; + void function(ANativeActivity*, int) onWindowFocusChanged; + void function(ANativeActivity*, ANativeWindow*) onNativeWindowCreated; + void function(ANativeActivity*, ANativeWindow*) onNativeWindowResized; + void function(ANativeActivity*, ANativeWindow*) onNativeWindowRedrawNeeded; + void function(ANativeActivity*, ANativeWindow*) onNativeWindowDestroyed; + void function(ANativeActivity*, AInputQueue*) onInputQueueCreated; + void function(ANativeActivity*, AInputQueue*) onInputQueueDestroyed; + void function(ANativeActivity*, const(ARect)*) onContentRectChanged; + void function(ANativeActivity*) onConfigurationChanged; + void function(ANativeActivity*) onLowMemory; +} + +void ANativeActivity_onCreate(ANativeActivity* activity, void* savedState, size_t savedStateSize); +void ANativeActivity_finish(ANativeActivity* activity); +void ANativeActivity_setWindowFormat(ANativeActivity* activity, int format); +void ANativeActivity_setWindowFlags(ANativeActivity* activity, uint addFlags, uint removeFlags); +void ANativeActivity_showSoftInput(ANativeActivity* activity, uint flags); +void ANativeActivity_hideSoftInput(ANativeActivity* activity, uint flags); diff --git a/3rdparty/android/native_window.d b/3rdparty/android/native_window.d new file mode 100644 index 00000000..45e2d442 --- /dev/null +++ b/3rdparty/android/native_window.d @@ -0,0 +1,39 @@ +/* dstep -I/path/to/ndk-r9d/platforms/android-9/arch-x86/usr/include -I/path/to/ndk-r9d/toolchains/llvm-3.4/prebuilt/linux-x86/lib/clang/3.4/include /path/to/ndk-r9d/platforms/android-9/arch-x86/usr/include/android/native_window.h -o native_window.d*/ + +module android.native_window; + +import android.rect; + +version (Android): +extern (C): +@system: +nothrow: +@nogc: + +enum +{ + WINDOW_FORMAT_RGBA_8888 = 1, + WINDOW_FORMAT_RGBX_8888 = 2, + WINDOW_FORMAT_RGB_565 = 4 +} + +struct ANativeWindow; + +struct ANativeWindow_Buffer +{ + int width; + int height; + int stride; + int format; + void* bits; + uint[6] reserved; +} + +void ANativeWindow_acquire(ANativeWindow* window); +void ANativeWindow_release(ANativeWindow* window); +int ANativeWindow_getWidth(ANativeWindow* window); +int ANativeWindow_getHeight(ANativeWindow* window); +int ANativeWindow_getFormat(ANativeWindow* window); +int ANativeWindow_setBuffersGeometry(ANativeWindow* window, int width, int height, int format); +int ANativeWindow_lock(ANativeWindow* window, ANativeWindow_Buffer* outBuffer, ARect* inOutDirtyBounds); +int ANativeWindow_unlockAndPost(ANativeWindow* window); diff --git a/3rdparty/android/obb.d b/3rdparty/android/obb.d new file mode 100644 index 00000000..c2e30744 --- /dev/null +++ b/3rdparty/android/obb.d @@ -0,0 +1,22 @@ +/* dstep -I/path/to/ndk-r10/platforms/android-9/arch-x86/usr/include -I/path/to/ndk-r10/toolchains/llvm-3.4/prebuilt/linux-x86/lib/clang/3.4/include /path/to/ndk-r10/platforms/android-9/arch-x86/usr/include/android/obb.h -o obb.d*/ + +module android.obb; + +version (Android): +extern (C): +@system: +nothrow: +@nogc: + +enum +{ + AOBBINFO_OVERLAY = 1 +} + +struct AObbInfo; + +AObbInfo* AObbScanner_getObbInfo(const(char)* filename); +void AObbInfo_delete(AObbInfo* obbInfo); +const(char)* AObbInfo_getPackageName(AObbInfo* obbInfo); +int AObbInfo_getVersion(AObbInfo* obbInfo); +int AObbInfo_getFlags(AObbInfo* obbInfo); diff --git a/3rdparty/android/rect.d b/3rdparty/android/rect.d new file mode 100644 index 00000000..5ffba32e --- /dev/null +++ b/3rdparty/android/rect.d @@ -0,0 +1,17 @@ +/* dstep /path/to/ndk-r9d/platforms/android-9/arch-x86/usr/include/android/rect.h -o rect.d*/ + +module android.rect; + +version (Android): +extern (C): +@system: +nothrow: +@nogc: + +struct ARect +{ + int left; + int top; + int right; + int bottom; +} diff --git a/3rdparty/android/sensor.d b/3rdparty/android/sensor.d new file mode 100644 index 00000000..7f470387 --- /dev/null +++ b/3rdparty/android/sensor.d @@ -0,0 +1,98 @@ +/* dstep -I/path/to/ndk-r9d/platforms/android-9/arch-x86/usr/include -I/path/to/ndk-r9d/toolchains/llvm-3.4/prebuilt/linux-x86/lib/clang/3.4/include /path/to/ndk-r9d/platforms/android-9/arch-x86/usr/include/android/sensor.h -o sensor.d*/ + +module android.sensor; + +import core.sys.posix.sys.types; +import android.looper; + +version (Android): +extern (C): +@system: +nothrow: +@nogc: + +enum +{ + ASENSOR_TYPE_ACCELEROMETER = 1, + ASENSOR_TYPE_MAGNETIC_FIELD = 2, + ASENSOR_TYPE_GYROSCOPE = 4, + ASENSOR_TYPE_LIGHT = 5, + ASENSOR_TYPE_PROXIMITY = 8 +} + +enum +{ + ASENSOR_STATUS_UNRELIABLE = 0, + ASENSOR_STATUS_ACCURACY_LOW = 1, + ASENSOR_STATUS_ACCURACY_MEDIUM = 2, + ASENSOR_STATUS_ACCURACY_HIGH = 3 +} + +enum ASENSOR_STANDARD_GRAVITY = 9.80665f; +enum ASENSOR_MAGNETIC_FIELD_EARTH_MAX = 60.0f; +enum ASENSOR_MAGNETIC_FIELD_EARTH_MIN = 30.0f; + +struct ASensorVector +{ + union + { + float[3] v; + struct + { + float x; + float y; + float z; + } + struct + { + float azimuth; + float pitch; + float roll; + } + } + byte status; + ubyte[3] reserved; +} + +struct ASensorEvent +{ + int version_; + int sensor; + int type; + int reserved0; + long timestamp; + union + { + float[16] data; + ASensorVector vector; + ASensorVector acceleration; + ASensorVector magnetic; + float temperature; + float distance; + float light; + float pressure; + } + int[4] reserved1; +} + +struct ASensorManager; +struct ASensorEventQueue; +struct ASensor; +alias const(ASensor)* ASensorRef; +alias const(ASensorRef)* ASensorList; + +ASensorManager* ASensorManager_getInstance(); +int ASensorManager_getSensorList(ASensorManager* manager, ASensorList* list); +const(ASensor)* ASensorManager_getDefaultSensor(ASensorManager* manager, int type); +ASensorEventQueue* ASensorManager_createEventQueue(ASensorManager* manager, ALooper* looper, int ident, ALooper_callbackFunc callback, void* data); +int ASensorManager_destroyEventQueue(ASensorManager* manager, ASensorEventQueue* queue); +int ASensorEventQueue_enableSensor(ASensorEventQueue* queue, const(ASensor)* sensor); +int ASensorEventQueue_disableSensor(ASensorEventQueue* queue, const(ASensor)* sensor); +int ASensorEventQueue_setEventRate(ASensorEventQueue* queue, const(ASensor)* sensor, int usec); +int ASensorEventQueue_hasEvents(ASensorEventQueue* queue); +ssize_t ASensorEventQueue_getEvents(ASensorEventQueue* queue, ASensorEvent* events, size_t count); +const(char)* ASensor_getName(const(ASensor)* sensor); +const(char)* ASensor_getVendor(const(ASensor)* sensor); +int ASensor_getType(const(ASensor)* sensor); +float ASensor_getResolution(const(ASensor)* sensor); +int ASensor_getMinDelay(const(ASensor)* sensor); diff --git a/3rdparty/android/storage_manager.d b/3rdparty/android/storage_manager.d new file mode 100644 index 00000000..bdb020e5 --- /dev/null +++ b/3rdparty/android/storage_manager.d @@ -0,0 +1,32 @@ +/* dstep /path/to/ndk-r10/platforms/android-9/arch-x86/usr/include/android/storage_manager.h -o storage_manager.d*/ + +module android.storage_manager; + +version (Android): +extern (C): +@system: +nothrow: +@nogc: + +alias void function(const(char)*, const int, void*) AStorageManager_obbCallbackFunc; + +enum +{ + AOBB_STATE_MOUNTED = 1, + AOBB_STATE_UNMOUNTED = 2, + AOBB_STATE_ERROR_INTERNAL = 20, + AOBB_STATE_ERROR_COULD_NOT_MOUNT = 21, + AOBB_STATE_ERROR_COULD_NOT_UNMOUNT = 22, + AOBB_STATE_ERROR_NOT_MOUNTED = 23, + AOBB_STATE_ERROR_ALREADY_MOUNTED = 24, + AOBB_STATE_ERROR_PERMISSION_DENIED = 25 +} + +struct AStorageManager; + +AStorageManager* AStorageManager_new(); +void AStorageManager_delete(AStorageManager* mgr); +void AStorageManager_mountObb(AStorageManager* mgr, const(char)* filename, const(char)* key, AStorageManager_obbCallbackFunc cb, void* data); +void AStorageManager_unmountObb(AStorageManager* mgr, const(char)* filename, const int force, AStorageManager_obbCallbackFunc cb, void* data); +int AStorageManager_isObbMounted(AStorageManager* mgr, const(char)* filename); +const(char)* AStorageManager_getMountedObbPath(AStorageManager* mgr, const(char)* filename); diff --git a/3rdparty/android/window.d b/3rdparty/android/window.d new file mode 100644 index 00000000..679c0eba --- /dev/null +++ b/3rdparty/android/window.d @@ -0,0 +1,36 @@ +/* dstep /path/to/ndk-r10/platforms/android-9/arch-x86/usr/include/android/window.h -o window.d*/ + +module android.window; + +version (Android): +extern (C): +@system: +nothrow: +@nogc: + +enum +{ + AWINDOW_FLAG_ALLOW_LOCK_WHILE_SCREEN_ON = 1, + AWINDOW_FLAG_DIM_BEHIND = 2, + AWINDOW_FLAG_BLUR_BEHIND = 4, + AWINDOW_FLAG_NOT_FOCUSABLE = 8, + AWINDOW_FLAG_NOT_TOUCHABLE = 16, + AWINDOW_FLAG_NOT_TOUCH_MODAL = 32, + AWINDOW_FLAG_TOUCHABLE_WHEN_WAKING = 64, + AWINDOW_FLAG_KEEP_SCREEN_ON = 128, + AWINDOW_FLAG_LAYOUT_IN_SCREEN = 256, + AWINDOW_FLAG_LAYOUT_NO_LIMITS = 512, + AWINDOW_FLAG_FULLSCREEN = 1024, + AWINDOW_FLAG_FORCE_NOT_FULLSCREEN = 2048, + AWINDOW_FLAG_DITHER = 4096, + AWINDOW_FLAG_SECURE = 8192, + AWINDOW_FLAG_SCALED = 16384, + AWINDOW_FLAG_IGNORE_CHEEK_PRESSES = 32768, + AWINDOW_FLAG_LAYOUT_INSET_DECOR = 65536, + AWINDOW_FLAG_ALT_FOCUSABLE_IM = 131072, + AWINDOW_FLAG_WATCH_OUTSIDE_TOUCH = 262144, + AWINDOW_FLAG_SHOW_WHEN_LOCKED = 524288, + AWINDOW_FLAG_SHOW_WALLPAPER = 1048576, + AWINDOW_FLAG_TURN_SCREEN_ON = 2097152, + AWINDOW_FLAG_DISMISS_KEYGUARD = 4194304 +}