forks
/
dlangui
mirror of https://github.com/buggins/dlangui.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

android files by Joakim Noah (putting them there until proper DUB package is created

This commit is contained in:
Vadim Lopatin 2016-04-19 07:56:24 +03:00
parent 194a2546a3
commit fdb6149ce9
19 changed files with 2973 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

183
3rdparty/EGL/egl.d vendored Normal file
View File

@ -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);

21
3rdparty/EGL/eglplatform.d vendored Normal file
View File

@ -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;

510
3rdparty/GLES/gl.d vendored Normal file
View File

@ -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);

476
3rdparty/GLES2/gl2.d vendored Normal file
View File

@ -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);

891
3rdparty/GLES3/gl3.d vendored Normal file
View File

@ -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);

37
3rdparty/android/asset_manager.d vendored Normal file
View File

@ -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);

38
3rdparty/android/bitmap.d vendored Normal file
View File

@ -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);

125
3rdparty/android/configuration.d vendored Normal file
View File

@ -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);

185
3rdparty/android/input.d vendored Normal file
View File

@ -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);

124
3rdparty/android/keycodes.d vendored Normal file
View File

@ -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
}

29
3rdparty/android/log.d vendored Normal file
View File

@ -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, ...);

45
3rdparty/android/looper.d vendored Normal file
View File

@ -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);

65
3rdparty/android/native_activity.d vendored Normal file
View File

@ -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);

39
3rdparty/android/native_window.d vendored Normal file
View File

@ -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);

22
3rdparty/android/obb.d vendored Normal file
View File

@ -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);

17
3rdparty/android/rect.d vendored Normal file
View File

@ -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;
}

98
3rdparty/android/sensor.d vendored Normal file
View File

@ -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);

32
3rdparty/android/storage_manager.d vendored Normal file
View File

@ -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);

36
3rdparty/android/window.d vendored Normal file
View File

@ -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
}