// Class: lime._backend.html5.HTML5GLRenderContext

var $global = typeof window != "undefined" ? window : typeof global != "undefined" ? global : typeof self != "undefined" ? self : this

$global.Object.defineProperty(exports, "__esModule", {value: true});

var __map_reserved = {};

// Imports

var $hxClasses = require("./../../../hxClasses_stub").default;
var $import = require("./../../../import_stub").default;
function lime_utils__$DataPointer_DataPointer_$Impl_$() {return require("./../../../lime/utils/_DataPointer/DataPointer_Impl_");}
function js_Boot() {return require("./../../../js/Boot");}
function Std() {return require("./../../../Std");}
function haxe__$Int64__$_$_$Int64() {return require("./../../../haxe/_Int64/___Int64");}
function lime_graphics_opengl_GLContextType() {return require("./../../../lime/graphics/opengl/GLContextType");}
function Reflect() {return require("./../../../Reflect");}
function js_Browser() {return require("./../../../js/Browser");}

// Constructor

var HTML5GLRenderContext = function(context) {
	this.MAX_CLIENT_WAIT_TIMEOUT_WEBGL = 37447;
	this.TIMEOUT_IGNORED = -1;
	this.INVALID_INDEX = -1;
	this.DEPTH32F_STENCIL8 = 36013;
	this.DEPTH_COMPONENT32F = 36012;
	this.DYNAMIC_COPY = 35050;
	this.DYNAMIC_READ = 35049;
	this.STATIC_COPY = 35046;
	this.STATIC_READ = 35045;
	this.STREAM_COPY = 35042;
	this.STREAM_READ = 35041;
	this.DEPTH_COMPONENT24 = 33190;
	this.MAX = 32776;
	this.MIN = 32775;
	this.STENCIL = 6146;
	this.DEPTH = 6145;
	this.COLOR = 6144;
	this.SYNC_FLUSH_COMMANDS_BIT = 1;
	this.WAIT_FAILED = 37149;
	this.CONDITION_SATISFIED = 37148;
	this.TIMEOUT_EXPIRED = 37147;
	this.ALREADY_SIGNALED = 37146;
	this.SIGNALED = 37145;
	this.UNSIGNALED = 37144;
	this.SYNC_GPU_COMMANDS_COMPLETE = 37143;
	this.SYNC_FENCE = 37142;
	this.SYNC_FLAGS = 37141;
	this.SYNC_STATUS = 37140;
	this.SYNC_CONDITION = 37139;
	this.OBJECT_TYPE = 37138;
	this.UNIFORM_BLOCK_REFERENCED_BY_FRAGMENT_SHADER = 35398;
	this.UNIFORM_BLOCK_REFERENCED_BY_VERTEX_SHADER = 35396;
	this.UNIFORM_BLOCK_ACTIVE_UNIFORM_INDICES = 35395;
	this.UNIFORM_BLOCK_ACTIVE_UNIFORMS = 35394;
	this.UNIFORM_BLOCK_DATA_SIZE = 35392;
	this.UNIFORM_BLOCK_BINDING = 35391;
	this.UNIFORM_IS_ROW_MAJOR = 35390;
	this.UNIFORM_MATRIX_STRIDE = 35389;
	this.UNIFORM_ARRAY_STRIDE = 35388;
	this.UNIFORM_OFFSET = 35387;
	this.UNIFORM_BLOCK_INDEX = 35386;
	this.UNIFORM_SIZE = 35384;
	this.UNIFORM_TYPE = 35383;
	this.ACTIVE_UNIFORM_BLOCKS = 35382;
	this.UNIFORM_BUFFER_OFFSET_ALIGNMENT = 35380;
	this.MAX_COMBINED_FRAGMENT_UNIFORM_COMPONENTS = 35379;
	this.MAX_COMBINED_VERTEX_UNIFORM_COMPONENTS = 35377;
	this.MAX_UNIFORM_BLOCK_SIZE = 35376;
	this.MAX_UNIFORM_BUFFER_BINDINGS = 35375;
	this.MAX_COMBINED_UNIFORM_BLOCKS = 35374;
	this.MAX_FRAGMENT_UNIFORM_BLOCKS = 35373;
	this.MAX_VERTEX_UNIFORM_BLOCKS = 35371;
	this.UNIFORM_BUFFER_SIZE = 35370;
	this.UNIFORM_BUFFER_START = 35369;
	this.UNIFORM_BUFFER_BINDING = 35368;
	this.UNIFORM_BUFFER = 35345;
	this.FRAMEBUFFER_INCOMPLETE_MULTISAMPLE = 36182;
	this.FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER = 36052;
	this.RENDERBUFFER_SAMPLES = 36011;
	this.READ_FRAMEBUFFER_BINDING = 36010;
	this.DRAW_FRAMEBUFFER = 36009;
	this.READ_FRAMEBUFFER = 36008;
	this.DRAW_FRAMEBUFFER_BINDING = 36006;
	this.DEPTH24_STENCIL8 = 35056;
	this.FRAMEBUFFER_DEFAULT = 33304;
	this.FRAMEBUFFER_ATTACHMENT_STENCIL_SIZE = 33303;
	this.FRAMEBUFFER_ATTACHMENT_DEPTH_SIZE = 33302;
	this.FRAMEBUFFER_ATTACHMENT_ALPHA_SIZE = 33301;
	this.FRAMEBUFFER_ATTACHMENT_BLUE_SIZE = 33300;
	this.FRAMEBUFFER_ATTACHMENT_GREEN_SIZE = 33299;
	this.FRAMEBUFFER_ATTACHMENT_RED_SIZE = 33298;
	this.FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE = 33297;
	this.FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING = 33296;
	this.TRANSFORM_FEEDBACK_BINDING = 36389;
	this.TRANSFORM_FEEDBACK_ACTIVE = 36388;
	this.TRANSFORM_FEEDBACK_PAUSED = 36387;
	this.TRANSFORM_FEEDBACK = 36386;
	this.TRANSFORM_FEEDBACK_BUFFER_BINDING = 35983;
	this.TRANSFORM_FEEDBACK_BUFFER = 35982;
	this.SEPARATE_ATTRIBS = 35981;
	this.INTERLEAVED_ATTRIBS = 35980;
	this.MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS = 35979;
	this.MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS = 35978;
	this.TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN = 35976;
	this.TRANSFORM_FEEDBACK_BUFFER_SIZE = 35973;
	this.TRANSFORM_FEEDBACK_BUFFER_START = 35972;
	this.TRANSFORM_FEEDBACK_VARYINGS = 35971;
	this.MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS = 35968;
	this.TRANSFORM_FEEDBACK_BUFFER_MODE = 35967;
	this.VERTEX_ATTRIB_ARRAY_DIVISOR = 35070;
	this.VERTEX_ATTRIB_ARRAY_INTEGER = 35069;
	this.SIGNED_NORMALIZED = 36764;
	this.UNSIGNED_NORMALIZED = 35863;
	this.UNSIGNED_INT_VEC4 = 36296;
	this.UNSIGNED_INT_VEC3 = 36295;
	this.UNSIGNED_INT_VEC2 = 36294;
	this.FLOAT_MAT4x3 = 35690;
	this.FLOAT_MAT4x2 = 35689;
	this.FLOAT_MAT3x4 = 35688;
	this.FLOAT_MAT3x2 = 35687;
	this.FLOAT_MAT2x4 = 35686;
	this.FLOAT_MAT2x3 = 35685;
	this.COPY_WRITE_BUFFER_BINDING = 36663;
	this.COPY_READ_BUFFER_BINDING = 36662;
	this.COPY_WRITE_BUFFER = 36663;
	this.COPY_READ_BUFFER = 36662;
	this.PIXEL_UNPACK_BUFFER_BINDING = 35055;
	this.PIXEL_PACK_BUFFER_BINDING = 35053;
	this.PIXEL_UNPACK_BUFFER = 35052;
	this.PIXEL_PACK_BUFFER = 35051;
	this.SAMPLER_BINDING = 35097;
	this.MAX_SAMPLES = 36183;
	this.UNSIGNED_INT_SAMPLER_2D_ARRAY = 36311;
	this.UNSIGNED_INT_SAMPLER_CUBE = 36308;
	this.UNSIGNED_INT_SAMPLER_3D = 36307;
	this.UNSIGNED_INT_SAMPLER_2D = 36306;
	this.INT_SAMPLER_2D_ARRAY = 36303;
	this.INT_SAMPLER_CUBE = 36300;
	this.INT_SAMPLER_3D = 36299;
	this.INT_SAMPLER_2D = 36298;
	this.SAMPLER_CUBE_SHADOW = 36293;
	this.SAMPLER_2D_ARRAY_SHADOW = 36292;
	this.SAMPLER_2D_ARRAY = 36289;
	this.SAMPLER_2D_SHADOW = 35682;
	this.SAMPLER_3D = 35679;
	this.COLOR_ATTACHMENT15 = 36079;
	this.COLOR_ATTACHMENT14 = 36078;
	this.COLOR_ATTACHMENT13 = 36077;
	this.COLOR_ATTACHMENT12 = 36076;
	this.COLOR_ATTACHMENT11 = 36075;
	this.COLOR_ATTACHMENT10 = 36074;
	this.COLOR_ATTACHMENT9 = 36073;
	this.COLOR_ATTACHMENT8 = 36072;
	this.COLOR_ATTACHMENT7 = 36071;
	this.COLOR_ATTACHMENT6 = 36070;
	this.COLOR_ATTACHMENT5 = 36069;
	this.COLOR_ATTACHMENT4 = 36068;
	this.COLOR_ATTACHMENT3 = 36067;
	this.COLOR_ATTACHMENT2 = 36066;
	this.COLOR_ATTACHMENT1 = 36065;
	this.MAX_COLOR_ATTACHMENTS = 36063;
	this.DRAW_BUFFER15 = 34868;
	this.DRAW_BUFFER14 = 34867;
	this.DRAW_BUFFER13 = 34866;
	this.DRAW_BUFFER12 = 34865;
	this.DRAW_BUFFER11 = 34864;
	this.DRAW_BUFFER10 = 34863;
	this.DRAW_BUFFER9 = 34862;
	this.DRAW_BUFFER8 = 34861;
	this.DRAW_BUFFER7 = 34860;
	this.DRAW_BUFFER6 = 34859;
	this.DRAW_BUFFER5 = 34858;
	this.DRAW_BUFFER4 = 34857;
	this.DRAW_BUFFER3 = 34856;
	this.DRAW_BUFFER2 = 34855;
	this.DRAW_BUFFER1 = 34854;
	this.DRAW_BUFFER0 = 34853;
	this.MAX_DRAW_BUFFERS = 34852;
	this.ANY_SAMPLES_PASSED_CONSERVATIVE = 36202;
	this.ANY_SAMPLES_PASSED = 35887;
	this.QUERY_RESULT_AVAILABLE = 34919;
	this.QUERY_RESULT = 34918;
	this.CURRENT_QUERY = 34917;
	this.INT_2_10_10_10_REV = 36255;
	this.RG_INTEGER = 33320;
	this.RG = 33319;
	this.HALF_FLOAT = 5131;
	this.UNSIGNED_INT_24_8 = 34042;
	this.FLOAT_32_UNSIGNED_INT_24_8_REV = 36269;
	this.UNSIGNED_INT_5_9_9_9_REV = 35902;
	this.UNSIGNED_INT_10F_11F_11F_REV = 35899;
	this.UNSIGNED_INT_2_10_10_10_REV = 33640;
	this.TEXTURE_IMMUTABLE_LEVELS = 33503;
	this.TEXTURE_IMMUTABLE_FORMAT = 37167;
	this.RGB10_A2UI = 36975;
	this.RGBA8_SNORM = 36759;
	this.RGB8_SNORM = 36758;
	this.RG8_SNORM = 36757;
	this.R8_SNORM = 36756;
	this.RG32UI = 33340;
	this.RG32I = 33339;
	this.RG16UI = 33338;
	this.RG16I = 33337;
	this.RG8UI = 33336;
	this.RG8I = 33335;
	this.R32UI = 33334;
	this.R32I = 33333;
	this.R16UI = 33332;
	this.R16I = 33331;
	this.R8UI = 33330;
	this.R8I = 33329;
	this.RG32F = 33328;
	this.RG16F = 33327;
	this.R32F = 33326;
	this.R16F = 33325;
	this.RG8 = 33323;
	this.R8 = 33321;
	this.RGBA_INTEGER = 36249;
	this.RGB_INTEGER = 36248;
	this.RED_INTEGER = 36244;
	this.RGB8I = 36239;
	this.RGBA8I = 36238;
	this.RGB16I = 36233;
	this.RGBA16I = 36232;
	this.RGB32I = 36227;
	this.RGBA32I = 36226;
	this.RGB8UI = 36221;
	this.RGBA8UI = 36220;
	this.RGB16UI = 36215;
	this.RGBA16UI = 36214;
	this.RGB32UI = 36209;
	this.RGBA32UI = 36208;
	this.RGB9_E5 = 35901;
	this.R11F_G11F_B10F = 35898;
	this.TEXTURE_BINDING_2D_ARRAY = 35869;
	this.TEXTURE_2D_ARRAY = 35866;
	this.RGB16F = 34843;
	this.RGBA16F = 34842;
	this.RGB32F = 34837;
	this.RGBA32F = 34836;
	this.COMPARE_REF_TO_TEXTURE = 34894;
	this.SRGB8_ALPHA8 = 35907;
	this.SRGB8 = 35905;
	this.SRGB = 35904;
	this.TEXTURE_COMPARE_FUNC = 34893;
	this.TEXTURE_COMPARE_MODE = 34892;
	this.TEXTURE_MAX_LEVEL = 33085;
	this.TEXTURE_BASE_LEVEL = 33084;
	this.TEXTURE_MAX_LOD = 33083;
	this.TEXTURE_MIN_LOD = 33082;
	this.TEXTURE_WRAP_R = 32882;
	this.TEXTURE_3D = 32879;
	this.RGB10_A2 = 32857;
	this.RGBA8 = 32856;
	this.RGB8 = 32849;
	this.RED = 6403;
	this.MAX_ELEMENT_INDEX = 36203;
	this.MAX_SERVER_WAIT_TIMEOUT = 37137;
	this.MAX_FRAGMENT_INPUT_COMPONENTS = 37157;
	this.MAX_VERTEX_OUTPUT_COMPONENTS = 37154;
	this.VERTEX_ARRAY_BINDING = 34229;
	this.RASTERIZER_DISCARD = 35977;
	this.FRAGMENT_SHADER_DERIVATIVE_HINT = 35723;
	this.MAX_VARYING_COMPONENTS = 35659;
	this.MAX_PROGRAM_TEXEL_OFFSET = 35077;
	this.MIN_PROGRAM_TEXEL_OFFSET = 35076;
	this.MAX_ARRAY_TEXTURE_LAYERS = 35071;
	this.MAX_VERTEX_UNIFORM_COMPONENTS = 35658;
	this.MAX_FRAGMENT_UNIFORM_COMPONENTS = 35657;
	this.MAX_TEXTURE_LOD_BIAS = 34045;
	this.MAX_ELEMENTS_INDICES = 33001;
	this.MAX_ELEMENTS_VERTICES = 33000;
	this.MAX_3D_TEXTURE_SIZE = 32883;
	this.UNPACK_IMAGE_HEIGHT = 32878;
	this.UNPACK_SKIP_IMAGES = 32877;
	this.TEXTURE_BINDING_3D = 32874;
	this.PACK_SKIP_PIXELS = 3332;
	this.PACK_SKIP_ROWS = 3331;
	this.PACK_ROW_LENGTH = 3330;
	this.UNPACK_SKIP_PIXELS = 3316;
	this.UNPACK_SKIP_ROWS = 3315;
	this.UNPACK_ROW_LENGTH = 3314;
	this.READ_BUFFER = 3074;
	this.BROWSER_DEFAULT_WEBGL = 37444;
	this.UNPACK_COLORSPACE_CONVERSION_WEBGL = 37443;
	this.CONTEXT_LOST_WEBGL = 37442;
	this.UNPACK_PREMULTIPLY_ALPHA_WEBGL = 37441;
	this.UNPACK_FLIP_Y_WEBGL = 37440;
	this.INVALID_FRAMEBUFFER_OPERATION = 1286;
	this.MAX_RENDERBUFFER_SIZE = 34024;
	this.RENDERBUFFER_BINDING = 36007;
	this.FRAMEBUFFER_BINDING = 36006;
	this.FRAMEBUFFER_UNSUPPORTED = 36061;
	this.FRAMEBUFFER_INCOMPLETE_DIMENSIONS = 36057;
	this.FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT = 36055;
	this.FRAMEBUFFER_INCOMPLETE_ATTACHMENT = 36054;
	this.FRAMEBUFFER_COMPLETE = 36053;
	this.NONE = 0;
	this.DEPTH_STENCIL_ATTACHMENT = 33306;
	this.STENCIL_ATTACHMENT = 36128;
	this.DEPTH_ATTACHMENT = 36096;
	this.COLOR_ATTACHMENT0 = 36064;
	this.FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE = 36051;
	this.FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL = 36050;
	this.FRAMEBUFFER_ATTACHMENT_OBJECT_NAME = 36049;
	this.FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE = 36048;
	this.RENDERBUFFER_STENCIL_SIZE = 36181;
	this.RENDERBUFFER_DEPTH_SIZE = 36180;
	this.RENDERBUFFER_ALPHA_SIZE = 36179;
	this.RENDERBUFFER_BLUE_SIZE = 36178;
	this.RENDERBUFFER_GREEN_SIZE = 36177;
	this.RENDERBUFFER_RED_SIZE = 36176;
	this.RENDERBUFFER_INTERNAL_FORMAT = 36164;
	this.RENDERBUFFER_HEIGHT = 36163;
	this.RENDERBUFFER_WIDTH = 36162;
	this.DEPTH_STENCIL = 34041;
	this.STENCIL_INDEX8 = 36168;
	this.STENCIL_INDEX = 6401;
	this.DEPTH_COMPONENT16 = 33189;
	this.RGB565 = 36194;
	this.RGB5_A1 = 32855;
	this.RGBA4 = 32854;
	this.RENDERBUFFER = 36161;
	this.FRAMEBUFFER = 36160;
	this.HIGH_INT = 36341;
	this.MEDIUM_INT = 36340;
	this.LOW_INT = 36339;
	this.HIGH_FLOAT = 36338;
	this.MEDIUM_FLOAT = 36337;
	this.LOW_FLOAT = 36336;
	this.COMPILE_STATUS = 35713;
	this.POINT_SPRITE = 34913;
	this.VERTEX_PROGRAM_POINT_SIZE = 34370;
	this.VERTEX_ATTRIB_ARRAY_BUFFER_BINDING = 34975;
	this.VERTEX_ATTRIB_ARRAY_POINTER = 34373;
	this.VERTEX_ATTRIB_ARRAY_NORMALIZED = 34922;
	this.VERTEX_ATTRIB_ARRAY_TYPE = 34341;
	this.VERTEX_ATTRIB_ARRAY_STRIDE = 34340;
	this.VERTEX_ATTRIB_ARRAY_SIZE = 34339;
	this.VERTEX_ATTRIB_ARRAY_ENABLED = 34338;
	this.SAMPLER_CUBE = 35680;
	this.SAMPLER_2D = 35678;
	this.FLOAT_MAT4 = 35676;
	this.FLOAT_MAT3 = 35675;
	this.FLOAT_MAT2 = 35674;
	this.BOOL_VEC4 = 35673;
	this.BOOL_VEC3 = 35672;
	this.BOOL_VEC2 = 35671;
	this.BOOL = 35670;
	this.INT_VEC4 = 35669;
	this.INT_VEC3 = 35668;
	this.INT_VEC2 = 35667;
	this.FLOAT_VEC4 = 35666;
	this.FLOAT_VEC3 = 35665;
	this.FLOAT_VEC2 = 35664;
	this.MIRRORED_REPEAT = 33648;
	this.CLAMP_TO_EDGE = 33071;
	this.REPEAT = 10497;
	this.ACTIVE_TEXTURE = 34016;
	this.TEXTURE31 = 34015;
	this.TEXTURE30 = 34014;
	this.TEXTURE29 = 34013;
	this.TEXTURE28 = 34012;
	this.TEXTURE27 = 34011;
	this.TEXTURE26 = 34010;
	this.TEXTURE25 = 34009;
	this.TEXTURE24 = 34008;
	this.TEXTURE23 = 34007;
	this.TEXTURE22 = 34006;
	this.TEXTURE21 = 34005;
	this.TEXTURE20 = 34004;
	this.TEXTURE19 = 34003;
	this.TEXTURE18 = 34002;
	this.TEXTURE17 = 34001;
	this.TEXTURE16 = 34000;
	this.TEXTURE15 = 33999;
	this.TEXTURE14 = 33998;
	this.TEXTURE13 = 33997;
	this.TEXTURE12 = 33996;
	this.TEXTURE11 = 33995;
	this.TEXTURE10 = 33994;
	this.TEXTURE9 = 33993;
	this.TEXTURE8 = 33992;
	this.TEXTURE7 = 33991;
	this.TEXTURE6 = 33990;
	this.TEXTURE5 = 33989;
	this.TEXTURE4 = 33988;
	this.TEXTURE3 = 33987;
	this.TEXTURE2 = 33986;
	this.TEXTURE1 = 33985;
	this.TEXTURE0 = 33984;
	this.MAX_CUBE_MAP_TEXTURE_SIZE = 34076;
	this.TEXTURE_CUBE_MAP_NEGATIVE_Z = 34074;
	this.TEXTURE_CUBE_MAP_POSITIVE_Z = 34073;
	this.TEXTURE_CUBE_MAP_NEGATIVE_Y = 34072;
	this.TEXTURE_CUBE_MAP_POSITIVE_Y = 34071;
	this.TEXTURE_CUBE_MAP_NEGATIVE_X = 34070;
	this.TEXTURE_CUBE_MAP_POSITIVE_X = 34069;
	this.TEXTURE_BINDING_CUBE_MAP = 34068;
	this.TEXTURE_CUBE_MAP = 34067;
	this.TEXTURE = 5890;
	this.TEXTURE_2D = 3553;
	this.TEXTURE_WRAP_T = 10243;
	this.TEXTURE_WRAP_S = 10242;
	this.TEXTURE_MIN_FILTER = 10241;
	this.TEXTURE_MAG_FILTER = 10240;
	this.LINEAR_MIPMAP_LINEAR = 9987;
	this.NEAREST_MIPMAP_LINEAR = 9986;
	this.LINEAR_MIPMAP_NEAREST = 9985;
	this.NEAREST_MIPMAP_NEAREST = 9984;
	this.LINEAR = 9729;
	this.NEAREST = 9728;
	this.VERSION = 7938;
	this.RENDERER = 7937;
	this.VENDOR = 7936;
	this.DECR_WRAP = 34056;
	this.INCR_WRAP = 34055;
	this.INVERT = 5386;
	this.DECR = 7683;
	this.INCR = 7682;
	this.REPLACE = 7681;
	this.KEEP = 7680;
	this.ALWAYS = 519;
	this.GEQUAL = 518;
	this.NOTEQUAL = 517;
	this.GREATER = 516;
	this.LEQUAL = 515;
	this.EQUAL = 514;
	this.LESS = 513;
	this.NEVER = 512;
	this.CURRENT_PROGRAM = 35725;
	this.SHADING_LANGUAGE_VERSION = 35724;
	this.ACTIVE_ATTRIBUTES = 35721;
	this.ACTIVE_UNIFORMS = 35718;
	this.ATTACHED_SHADERS = 35717;
	this.VALIDATE_STATUS = 35715;
	this.LINK_STATUS = 35714;
	this.DELETE_STATUS = 35712;
	this.SHADER_TYPE = 35663;
	this.MAX_FRAGMENT_UNIFORM_VECTORS = 36349;
	this.MAX_TEXTURE_IMAGE_UNITS = 34930;
	this.MAX_VERTEX_TEXTURE_IMAGE_UNITS = 35660;
	this.MAX_COMBINED_TEXTURE_IMAGE_UNITS = 35661;
	this.MAX_VARYING_VECTORS = 36348;
	this.MAX_VERTEX_UNIFORM_VECTORS = 36347;
	this.MAX_VERTEX_ATTRIBS = 34921;
	this.VERTEX_SHADER = 35633;
	this.FRAGMENT_SHADER = 35632;
	this.UNSIGNED_SHORT_5_6_5 = 33635;
	this.UNSIGNED_SHORT_5_5_5_1 = 32820;
	this.UNSIGNED_SHORT_4_4_4_4 = 32819;
	this.LUMINANCE_ALPHA = 6410;
	this.LUMINANCE = 6409;
	this.RGBA = 6408;
	this.RGB = 6407;
	this.ALPHA = 6406;
	this.DEPTH_COMPONENT = 6402;
	this.FLOAT = 5126;
	this.UNSIGNED_INT = 5125;
	this.INT = 5124;
	this.UNSIGNED_SHORT = 5123;
	this.SHORT = 5122;
	this.UNSIGNED_BYTE = 5121;
	this.BYTE = 5120;
	this.GENERATE_MIPMAP_HINT = 33170;
	this.NICEST = 4354;
	this.FASTEST = 4353;
	this.DONT_CARE = 4352;
	this.COMPRESSED_TEXTURE_FORMATS = 34467;
	this.SAMPLE_COVERAGE_INVERT = 32939;
	this.SAMPLE_COVERAGE_VALUE = 32938;
	this.SAMPLES = 32937;
	this.SAMPLE_BUFFERS = 32936;
	this.TEXTURE_BINDING_2D = 32873;
	this.POLYGON_OFFSET_FACTOR = 32824;
	this.POLYGON_OFFSET_UNITS = 10752;
	this.STENCIL_BITS = 3415;
	this.DEPTH_BITS = 3414;
	this.ALPHA_BITS = 3413;
	this.BLUE_BITS = 3412;
	this.GREEN_BITS = 3411;
	this.RED_BITS = 3410;
	this.SUBPIXEL_BITS = 3408;
	this.MAX_VIEWPORT_DIMS = 3386;
	this.MAX_TEXTURE_SIZE = 3379;
	this.PACK_ALIGNMENT = 3333;
	this.UNPACK_ALIGNMENT = 3317;
	this.COLOR_WRITEMASK = 3107;
	this.COLOR_CLEAR_VALUE = 3106;
	this.SCISSOR_BOX = 3088;
	this.VIEWPORT = 2978;
	this.STENCIL_BACK_WRITEMASK = 36005;
	this.STENCIL_BACK_VALUE_MASK = 36004;
	this.STENCIL_BACK_REF = 36003;
	this.STENCIL_BACK_PASS_DEPTH_PASS = 34819;
	this.STENCIL_BACK_PASS_DEPTH_FAIL = 34818;
	this.STENCIL_BACK_FAIL = 34817;
	this.STENCIL_BACK_FUNC = 34816;
	this.STENCIL_WRITEMASK = 2968;
	this.STENCIL_VALUE_MASK = 2963;
	this.STENCIL_REF = 2967;
	this.STENCIL_PASS_DEPTH_PASS = 2966;
	this.STENCIL_PASS_DEPTH_FAIL = 2965;
	this.STENCIL_FAIL = 2964;
	this.STENCIL_FUNC = 2962;
	this.STENCIL_CLEAR_VALUE = 2961;
	this.DEPTH_FUNC = 2932;
	this.DEPTH_CLEAR_VALUE = 2931;
	this.DEPTH_WRITEMASK = 2930;
	this.DEPTH_RANGE = 2928;
	this.FRONT_FACE = 2886;
	this.CULL_FACE_MODE = 2885;
	this.ALIASED_LINE_WIDTH_RANGE = 33902;
	this.ALIASED_POINT_SIZE_RANGE = 33901;
	this.LINE_WIDTH = 2849;
	this.CCW = 2305;
	this.CW = 2304;
	this.OUT_OF_MEMORY = 1285;
	this.INVALID_OPERATION = 1282;
	this.INVALID_VALUE = 1281;
	this.INVALID_ENUM = 1280;
	this.NO_ERROR = 0;
	this.SAMPLE_COVERAGE = 32928;
	this.SAMPLE_ALPHA_TO_COVERAGE = 32926;
	this.POLYGON_OFFSET_FILL = 32823;
	this.SCISSOR_TEST = 3089;
	this.DEPTH_TEST = 2929;
	this.STENCIL_TEST = 2960;
	this.DITHER = 3024;
	this.BLEND = 3042;
	this.CULL_FACE = 2884;
	this.FRONT_AND_BACK = 1032;
	this.BACK = 1029;
	this.FRONT = 1028;
	this.CURRENT_VERTEX_ATTRIB = 34342;
	this.BUFFER_USAGE = 34661;
	this.BUFFER_SIZE = 34660;
	this.DYNAMIC_DRAW = 35048;
	this.STATIC_DRAW = 35044;
	this.STREAM_DRAW = 35040;
	this.ELEMENT_ARRAY_BUFFER_BINDING = 34965;
	this.ARRAY_BUFFER_BINDING = 34964;
	this.ELEMENT_ARRAY_BUFFER = 34963;
	this.ARRAY_BUFFER = 34962;
	this.BLEND_COLOR = 32773;
	this.ONE_MINUS_CONSTANT_ALPHA = 32772;
	this.CONSTANT_ALPHA = 32771;
	this.ONE_MINUS_CONSTANT_COLOR = 32770;
	this.CONSTANT_COLOR = 32769;
	this.BLEND_SRC_ALPHA = 32971;
	this.BLEND_DST_ALPHA = 32970;
	this.BLEND_SRC_RGB = 32969;
	this.BLEND_DST_RGB = 32968;
	this.FUNC_REVERSE_SUBTRACT = 32779;
	this.FUNC_SUBTRACT = 32778;
	this.BLEND_EQUATION_ALPHA = 34877;
	this.BLEND_EQUATION_RGB = 32777;
	this.BLEND_EQUATION = 32777;
	this.FUNC_ADD = 32774;
	this.SRC_ALPHA_SATURATE = 776;
	this.ONE_MINUS_DST_COLOR = 775;
	this.DST_COLOR = 774;
	this.ONE_MINUS_DST_ALPHA = 773;
	this.DST_ALPHA = 772;
	this.ONE_MINUS_SRC_ALPHA = 771;
	this.SRC_ALPHA = 770;
	this.ONE_MINUS_SRC_COLOR = 769;
	this.SRC_COLOR = 768;
	this.ONE = 1;
	this.ZERO = 0;
	this.TRIANGLE_FAN = 6;
	this.TRIANGLE_STRIP = 5;
	this.TRIANGLES = 4;
	this.LINE_STRIP = 3;
	this.LINE_LOOP = 2;
	this.LINES = 1;
	this.POINTS = 0;
	this.COLOR_BUFFER_BIT = 16384;
	this.STENCIL_BUFFER_BIT = 1024;
	this.DEPTH_BUFFER_BIT = 256;
	this.__context = context;
	this.version = 1;
	this.type = (lime_graphics_opengl_GLContextType().default).WEBGL;
	if(context != null) {
		var gl = context;
		if((Reflect().default).hasField(gl,"rawgl")) {
			gl = (Reflect().default).field(context,"rawgl");
		}
		if((Reflect().default).hasField((js_Browser().default).get_window(),"WebGL2RenderingContext") && (Std().default)["is"](gl,WebGL2RenderingContext)) {
			this.version = 2;
		}
	}
}

// Meta

HTML5GLRenderContext.__name__ = ["lime","_backend","html5","HTML5GLRenderContext"];
HTML5GLRenderContext.prototype = {
	activeTexture: function(texture) {
		this.__context.activeTexture(texture);
	},
	attachShader: function(program,shader) {
		this.__context.attachShader(program,shader);
	},
	beginQuery: function(target,query) {
		this.__context.beginQuery(target,query);
	},
	beginTransformFeedback: function(primitiveNode) {
		this.__context.beginTransformFeedback(primitiveNode);
	},
	bindAttribLocation: function(program,index,name) {
		this.__context.bindAttribLocation(program,index,name);
	},
	bindBuffer: function(target,buffer) {
		this.__context.bindBuffer(target,buffer);
	},
	bindBufferBase: function(target,index,buffer) {
		this.__context.bindBufferBase(target,index,buffer);
	},
	bindBufferRange: function(target,index,buffer,offset,size) {
		this.__context.bindBufferRange(target,index,buffer,(lime_utils__$DataPointer_DataPointer_$Impl_$().default).fromInt((lime_utils__$DataPointer_DataPointer_$Impl_$().default).toValue(offset)),(lime_utils__$DataPointer_DataPointer_$Impl_$().default).fromInt(size));
	},
	bindFramebuffer: function(target,framebuffer) {
		this.__context.bindFramebuffer(target,framebuffer);
	},
	bindRenderbuffer: function(target,renderbuffer) {
		this.__context.bindRenderbuffer(target,renderbuffer);
	},
	bindSampler: function(unit,sampler) {
		this.__context.bindSampler(unit,sampler);
	},
	bindTexture: function(target,texture) {
		this.__context.bindTexture(target,texture);
	},
	bindTransformFeedback: function(target,transformFeedback) {
		this.__context.bindTransformFeedback(target,transformFeedback);
	},
	bindVertexArray: function(vertexArray) {
		this.__context.bindVertexArray(vertexArray);
	},
	blendColor: function(red,green,blue,alpha) {
		this.__context.blendColor(red,green,blue,alpha);
	},
	blendEquation: function(mode) {
		this.__context.blendEquation(mode);
	},
	blendEquationSeparate: function(modeRGB,modeAlpha) {
		this.__context.blendEquationSeparate(modeRGB,modeAlpha);
	},
	blendFunc: function(sfactor,dfactor) {
		this.__context.blendFunc(sfactor,dfactor);
	},
	blendFuncSeparate: function(srcRGB,dstRGB,srcAlpha,dstAlpha) {
		this.__context.blendFuncSeparate(srcRGB,dstRGB,srcAlpha,dstAlpha);
	},
	blitFramebuffer: function(srcX0,srcY0,srcX1,srcY1,dstX0,dstY0,dstX1,dstY1,mask,filter) {
		this.__context.blitFramebuffer(srcX0,srcY0,srcX1,srcY1,dstX0,dstY0,dstX1,dstY1,mask,filter);
	},
	bufferData: function(target,size,data,usage) {
		this.__context.bufferData(target,(lime_utils__$DataPointer_DataPointer_$Impl_$().default).toBufferView(data,size),usage);
	},
	bufferDataWEBGL: function(target,srcData,usage,srcOffset,length) {
		if(srcOffset != null) {
			this.__context.bufferData(target,srcData,usage,srcOffset,length);
		} else {
			this.__context.bufferData(target,srcData,usage);
		}
	},
	bufferSubData: function(target,dstByteOffset,size,data) {
		this.__context.bufferSubData(target,dstByteOffset,(lime_utils__$DataPointer_DataPointer_$Impl_$().default).toBufferView(data,size));
	},
	bufferSubDataWEBGL: function(target,dstByteOffset,srcData,srcOffset,length) {
		if(srcOffset != null) {
			this.__context.bufferSubData(target,dstByteOffset,srcData,srcOffset,length);
		} else {
			this.__context.bufferSubData(target,dstByteOffset,srcData);
		}
	},
	checkFramebufferStatus: function(target) {
		return this.__context.checkFramebufferStatus(target);
	},
	clear: function(mask) {
		this.__context.clear(mask);
	},
	clearBufferfi: function(buffer,drawbuffer,depth,stencil) {
		this.__context.clearBufferfi(buffer,drawbuffer,depth,stencil);
	},
	clearBufferfv: function(buffer,drawbuffer,values) {
		this.__context.clearBufferfv(buffer,drawbuffer,(lime_utils__$DataPointer_DataPointer_$Impl_$().default).toFloat32Array(values));
	},
	clearBufferfvWEBGL: function(buffer,drawbuffer,values,srcOffset) {
		this.__context.clearBufferfv(buffer,drawbuffer,values,srcOffset);
	},
	clearBufferiv: function(buffer,drawbuffer,values) {
		this.__context.clearBufferiv(buffer,drawbuffer,(lime_utils__$DataPointer_DataPointer_$Impl_$().default).toInt32Array(values));
	},
	clearBufferivWEBGL: function(buffer,drawbuffer,values,srcOffset) {
		this.__context.clearBufferiv(buffer,drawbuffer,values,srcOffset);
	},
	clearBufferuiv: function(buffer,drawbuffer,values) {
		this.__context.clearBufferuiv(buffer,drawbuffer,(lime_utils__$DataPointer_DataPointer_$Impl_$().default).toUInt32Array(values));
	},
	clearBufferuivWEBGL: function(buffer,drawbuffer,values,srcOffset) {
		this.__context.clearBufferuiv(buffer,drawbuffer,values,srcOffset);
	},
	clearColor: function(red,green,blue,alpha) {
		this.__context.clearColor(red,green,blue,alpha);
	},
	clearDepth: function(depth) {
		this.__context.clearDepth(depth);
	},
	clearDepthf: function(depth) {
		this.clearDepth(depth);
	},
	clearStencil: function(s) {
		this.__context.clearStencil(s);
	},
	clientWaitSync: function(sync,flags,timeout) {
		return this.__context.clientWaitSync(sync,flags,timeout);
	},
	copyBufferSubData: function(readTarget,writeTarget,readOffset,writeOffset,size) {
	},
	colorMask: function(red,green,blue,alpha) {
		this.__context.colorMask(red,green,blue,alpha);
	},
	compileShader: function(shader) {
		this.__context.compileShader(shader);
	},
	compressedTexImage2D: function(target,level,internalformat,width,height,border,imageSize,data) {
		this.__context.compressedTexImage2D(target,level,internalformat,width,height,border,(lime_utils__$DataPointer_DataPointer_$Impl_$().default).toBufferView(data,imageSize));
	},
	compressedTexImage2DWEBGL: function(target,level,internalformat,width,height,border,srcData,srcOffset,srcLengthOverride) {
		if(srcOffset != null) {
			this.__context.compressedTexImage2D(target,level,internalformat,width,height,border,srcData,srcOffset,srcLengthOverride);
		} else {
			this.__context.compressedTexImage2D(target,level,internalformat,width,height,border,srcData);
		}
	},
	compressedTexImage3D: function(target,level,internalformat,width,height,depth,border,imageSize,data) {
		this.__context.compressedTexImage3D(target,level,internalformat,width,height,depth,border,(lime_utils__$DataPointer_DataPointer_$Impl_$().default).toBufferView(data,imageSize));
	},
	compressedTexImage3DWEBGL: function(target,level,internalformat,width,height,depth,border,srcData,srcOffset,srcLengthOverride) {
		this.__context.compressedTexImage3D(target,level,internalformat,width,height,depth,border,srcData,srcOffset,srcLengthOverride);
	},
	compressedTexSubImage2D: function(target,level,xoffset,yoffset,width,height,format,imageSize,data) {
		this.__context.compressedTexSubImage2D(target,level,xoffset,yoffset,width,height,format,(lime_utils__$DataPointer_DataPointer_$Impl_$().default).toBufferView(data,imageSize));
	},
	compressedTexSubImage2DWEBGL: function(target,level,xoffset,yoffset,width,height,format,srcData,srcOffset,srcLengthOverride) {
		if(srcOffset != null) {
			this.__context.compressedTexSubImage2D(target,level,xoffset,yoffset,width,height,format,srcData,srcOffset,srcLengthOverride);
		} else {
			this.__context.compressedTexSubImage2D(target,level,xoffset,yoffset,width,height,format,srcData);
		}
	},
	compressedTexSubImage3D: function(target,level,xoffset,yoffset,zoffset,width,height,depth,format,imageSize,data) {
		this.__context.compressedTexSubImage3D(target,level,xoffset,yoffset,zoffset,width,height,depth,format,(lime_utils__$DataPointer_DataPointer_$Impl_$().default).toBufferView(data,imageSize));
	},
	compressedTexSubImage3DWEBGL: function(target,level,xoffset,yoffset,zoffset,width,height,depth,format,srcData,srcOffset,srcLengthOverride) {
		this.__context.compressedTexSubImage3D(target,level,xoffset,yoffset,zoffset,width,height,depth,format,srcData,srcOffset,srcLengthOverride);
	},
	copySubBufferData: function(readTarget,writeTarget,readOffset,writeOffset,size) {
		this.__context.copySubBufferData(readTarget,writeTarget,(lime_utils__$DataPointer_DataPointer_$Impl_$().default).fromInt((lime_utils__$DataPointer_DataPointer_$Impl_$().default).toValue(readOffset)),(lime_utils__$DataPointer_DataPointer_$Impl_$().default).fromInt((lime_utils__$DataPointer_DataPointer_$Impl_$().default).toValue(writeOffset)),size);
	},
	copyTexImage2D: function(target,level,internalformat,x,y,width,height,border) {
		this.__context.copyTexImage2D(target,level,internalformat,x,y,width,height,border);
	},
	copyTexSubImage2D: function(target,level,xoffset,yoffset,x,y,width,height) {
		this.__context.copyTexSubImage2D(target,level,xoffset,yoffset,x,y,width,height);
	},
	copyTexSubImage3D: function(target,level,xoffset,yoffset,zoffset,x,y,width,height) {
		this.__context.copyTexSubImage3D(target,level,xoffset,yoffset,zoffset,x,y,width,height);
	},
	createBuffer: function() {
		return this.__context.createBuffer();
	},
	createFramebuffer: function() {
		return this.__context.createFramebuffer();
	},
	createProgram: function() {
		return this.__context.createProgram();
	},
	createQuery: function() {
		return this.__context.createQuery();
	},
	createRenderbuffer: function() {
		return this.__context.createRenderbuffer();
	},
	createSampler: function() {
		return this.__context.createSampler();
	},
	createShader: function(type) {
		return this.__context.createShader(type);
	},
	createTexture: function() {
		return this.__context.createTexture();
	},
	createTransformFeedback: function() {
		return this.__context.createTransformFeedback();
	},
	createVertexArray: function() {
		return this.__context.createVertexArray();
	},
	cullFace: function(mode) {
		this.__context.cullFace(mode);
	},
	deleteBuffer: function(buffer) {
		this.__context.deleteBuffer(buffer);
	},
	deleteFramebuffer: function(framebuffer) {
		this.__context.deleteFramebuffer(framebuffer);
	},
	deleteProgram: function(program) {
		this.__context.deleteProgram(program);
	},
	deleteQuery: function(query) {
		this.__context.deleteQuery(query);
	},
	deleteRenderbuffer: function(renderbuffer) {
		this.__context.deleteRenderbuffer(renderbuffer);
	},
	deleteSampler: function(sampler) {
		this.__context.deleteSampler(sampler);
	},
	deleteShader: function(shader) {
		this.__context.deleteShader(shader);
	},
	deleteSync: function(sync) {
		this.__context.deleteSync(sync);
	},
	deleteTexture: function(texture) {
		this.__context.deleteTexture(texture);
	},
	deleteTransformFeedback: function(transformFeedback) {
		this.__context.deleteTransformFeedback(transformFeedback);
	},
	deleteVertexArray: function(vertexArray) {
		this.__context.deleteVertexArray(vertexArray);
	},
	depthFunc: function(func) {
		this.__context.depthFunc(func);
	},
	depthMask: function(flag) {
		this.__context.depthMask(flag);
	},
	depthRange: function(zNear,zFar) {
		this.__context.depthRange(zNear,zFar);
	},
	depthRangef: function(zNear,zFar) {
		this.depthRange(zNear,zFar);
	},
	detachShader: function(program,shader) {
		this.__context.detachShader(program,shader);
	},
	disable: function(cap) {
		this.__context.disable(cap);
	},
	disableVertexAttribArray: function(index) {
		this.__context.disableVertexAttribArray(index);
	},
	drawArrays: function(mode,first,count) {
		this.__context.drawArrays(mode,first,count);
	},
	drawArraysInstanced: function(mode,first,count,instanceCount) {
		this.__context.drawArraysInstanced(mode,first,count,instanceCount);
	},
	drawBuffers: function(buffers) {
		this.__context.drawBuffers(buffers);
	},
	drawElements: function(mode,count,type,offset) {
		this.__context.drawElements(mode,count,type,(lime_utils__$DataPointer_DataPointer_$Impl_$().default).toValue(offset));
	},
	drawElementsInstanced: function(mode,count,type,offset,instanceCount) {
		this.__context.drawElementsInstanced(mode,count,type,(lime_utils__$DataPointer_DataPointer_$Impl_$().default).fromInt((lime_utils__$DataPointer_DataPointer_$Impl_$().default).toValue(offset)),instanceCount);
	},
	drawRangeElements: function(mode,start,end,count,type,offset) {
		this.__context.drawRangeElements(mode,start,end,count,type,(lime_utils__$DataPointer_DataPointer_$Impl_$().default).fromInt((lime_utils__$DataPointer_DataPointer_$Impl_$().default).toValue(offset)));
	},
	enable: function(cap) {
		this.__context.enable(cap);
	},
	enableVertexAttribArray: function(index) {
		this.__context.enableVertexAttribArray(index);
	},
	endQuery: function(target) {
		this.__context.endQuery(target);
	},
	endTransformFeedback: function() {
		this.__context.endTransformFeedback();
	},
	fenceSync: function(condition,flags) {
		return this.__context.fenceSync(condition,flags);
	},
	finish: function() {
		this.__context.finish();
	},
	flush: function() {
		this.__context.flush();
	},
	framebufferRenderbuffer: function(target,attachment,renderbuffertarget,renderbuffer) {
		this.__context.framebufferRenderbuffer(target,attachment,renderbuffertarget,renderbuffer);
	},
	framebufferTexture2D: function(target,attachment,textarget,texture,level) {
		this.__context.framebufferTexture2D(target,attachment,textarget,texture,level);
	},
	framebufferTextureLayer: function(target,attachment,texture,level,layer) {
		this.__context.framebufferTextureLayer(target,attachment,texture,level,layer);
	},
	frontFace: function(mode) {
		this.__context.frontFace(mode);
	},
	generateMipmap: function(target) {
		this.__context.generateMipmap(target);
	},
	getActiveAttrib: function(program,index) {
		return this.__context.getActiveAttrib(program,index);
	},
	getActiveUniform: function(program,index) {
		return this.__context.getActiveUniform(program,index);
	},
	getActiveUniformBlocki: function(program,uniformBlockIndex,pname) {
		return this.getActiveUniformBlockParameter(program,uniformBlockIndex,pname);
	},
	getActiveUniformBlockiv: function(program,uniformBlockIndex,pname,params) {
		var view = (lime_utils__$DataPointer_DataPointer_$Impl_$().default).toInt32Array(params);
		view[0] = this.getActiveUniformBlockParameter(program,uniformBlockIndex,pname);
	},
	getActiveUniformBlockName: function(program,uniformBlockIndex) {
		return this.__context.getActiveUniformBlockName(program,uniformBlockIndex);
	},
	getActiveUniformBlockParameter: function(program,uniformBlockIndex,pname) {
		return this.__context.getActiveUniformBlockParameter(program,uniformBlockIndex,pname);
	},
	getActiveUniforms: function(program,uniformIndices,pname) {
		return this.__context.getActiveUniforms(program,uniformIndices,pname);
	},
	getActiveUniformsiv: function(program,uniformIndices,pname,params) {
	},
	getAttachedShaders: function(program) {
		return this.__context.getAttachedShaders(program);
	},
	getAttribLocation: function(program,name) {
		return this.__context.getAttribLocation(program,name);
	},
	getBoolean: function(pname) {
		return this.getParameter(pname);
	},
	getBooleanv: function(pname,params) {
		var view = (lime_utils__$DataPointer_DataPointer_$Impl_$().default).toUInt8Array(params);
		var result = this.getParameter(pname);
		if((result instanceof Array) && result.__enum__ == null) {
			var data = result;
			var _g1 = 0;
			var _g = data.length;
			while(_g1 < _g) {
				var i = _g1++;
				view[i] = data[i] ? 1 : 0;
			}
		} else {
			view[0] = (js_Boot().default).__cast(result , $hxClasses["Bool"]) ? 1 : 0;
		}
	},
	getBufferParameter: function(target,pname) {
		return this.__context.getBufferParameter(target,pname);
	},
	getBufferParameteri: function(target,pname) {
		return this.getBufferParameter(target,pname);
	},
	getBufferParameteri64v: function(target,pname,params) {
	},
	getBufferParameteriv: function(target,pname,data) {
		var view = (lime_utils__$DataPointer_DataPointer_$Impl_$().default).toInt32Array(data);
		view[0] = this.getBufferParameter(target,pname);
	},
	getBufferPointerv: function(target,pname) {
		return (lime_utils__$DataPointer_DataPointer_$Impl_$().default).fromInt(0);
	},
	getBufferSubData: function(target,offset,size,data) {
		this.__context.getBufferSubData(target,(lime_utils__$DataPointer_DataPointer_$Impl_$().default).fromInt((lime_utils__$DataPointer_DataPointer_$Impl_$().default).toValue(offset)),(lime_utils__$DataPointer_DataPointer_$Impl_$().default).toBufferView(data,size));
	},
	getBufferSubDataWEBGL: function(target,srcByteOffset,dstData,srcOffset,length) {
		if(srcOffset != null) {
			this.__context.getBufferSubData(target,srcByteOffset,dstData,srcOffset,length);
		} else {
			this.__context.getBufferSubData(target,srcByteOffset,dstData);
		}
	},
	getContextAttributes: function() {
		return this.__context.getContextAttributes();
	},
	getError: function() {
		return this.__context.getError();
	},
	getExtension: function(name) {
		return this.__context.getExtension(name);
	},
	getFloat: function(pname) {
		return this.getParameter(pname);
	},
	getFloatv: function(pname,params) {
		var view = (lime_utils__$DataPointer_DataPointer_$Impl_$().default).toFloat32Array(params);
		var result = this.getParameter(pname);
		if((Std().default)["is"](result,ArrayBufferView)) {
			var data = result;
			var _g1 = 0;
			var _g = data.length;
			while(_g1 < _g) {
				var i = _g1++;
				view[i] = data[i];
			}
		} else {
			view[0] = (js_Boot().default).__cast(result , $hxClasses["Float"]);
		}
	},
	getFragDataLocation: function(program,name) {
		return this.__context.getFragDataLocation(program,name);
	},
	getFramebufferAttachmentParameter: function(target,attachment,pname) {
		return this.__context.getFramebufferAttachmentParameter(target,attachment,pname);
	},
	getFramebufferAttachmentParameteri: function(target,attachment,pname) {
		return this.getFramebufferAttachmentParameter(target,attachment,pname);
	},
	getFramebufferAttachmentParameteriv: function(target,attachment,pname,params) {
		var value = this.getFramebufferAttachmentParameteri(target,attachment,pname);
		var view = (lime_utils__$DataPointer_DataPointer_$Impl_$().default).toInt32Array(params);
		view[0] = value;
	},
	getIndexedParameter: function(target,index) {
		return this.__context.getIndexedParameter(target,index);
	},
	getInteger: function(pname) {
		return this.getParameter(pname);
	},
	getInteger64: function(pname) {
		var this1 = new (haxe__$Int64__$_$_$Int64().default)(0,0);
		return this1;
	},
	getInteger64i: function(pname) {
		var this1 = new (haxe__$Int64__$_$_$Int64().default)(0,0);
		return this1;
	},
	getInteger64i_v: function(pname,index,params) {
	},
	getInteger64v: function(pname,params) {
	},
	getIntegeri: function(pname) {
		return 0;
	},
	getIntegeri_v: function(pname,index,params) {
	},
	getIntegerv: function(pname,params) {
		var view = (lime_utils__$DataPointer_DataPointer_$Impl_$().default).toInt32Array(params);
		var result = this.getParameter(pname);
		if((Std().default)["is"](result,ArrayBufferView)) {
			var data = result;
			var _g1 = 0;
			var _g = data.length;
			while(_g1 < _g) {
				var i = _g1++;
				view[i] = data[i];
			}
		} else {
			view[0] = (js_Boot().default).__cast(result , $hxClasses["Int"]);
		}
	},
	getInternalformati: function(target,internalformat,pname) {
		return 0;
	},
	getInternalformativ: function(target,internalformat,pname,bufSize,params) {
	},
	getInternalformatParameter: function(target,internalformat,pname) {
		return this.__context.getInternalformatParameter(target,internalformat,pname);
	},
	getParameter: function(pname) {
		return this.__context.getParameter(pname);
	},
	getProgramBinary: function(program,binaryFormat) {
		return null;
	},
	getProgrami: function(program,pname) {
		return this.getProgramParameter(program,pname);
	},
	getProgramiv: function(program,pname,params) {
		var view = (lime_utils__$DataPointer_DataPointer_$Impl_$().default).toInt32Array(params);
		view[0] = this.getProgramParameter(program,pname);
	},
	getProgramInfoLog: function(program) {
		return this.__context.getProgramInfoLog(program);
	},
	getProgramParameter: function(program,pname) {
		return this.__context.getProgramParameter(program,pname);
	},
	getQuery: function(target,pname) {
		return this.__context.getQuery(target,pname);
	},
	getQueryi: function(target,pname) {
		return 0;
	},
	getQueryiv: function(target,pname,params) {
	},
	getQueryObjectui: function(query,pname) {
		return 0;
	},
	getQueryObjectuiv: function(query,pname,params) {
	},
	getQueryParameter: function(query,pname) {
		return this.__context.getQueryParameter(query,pname);
	},
	getRenderbufferParameter: function(target,pname) {
		return this.__context.getRenderbufferParameter(target,pname);
	},
	getRenderbufferParameteri: function(target,pname) {
		return this.getRenderbufferParameter(target,pname);
	},
	getRenderbufferParameteriv: function(target,pname,params) {
		var view = (lime_utils__$DataPointer_DataPointer_$Impl_$().default).toInt32Array(params);
		view[0] = this.getRenderbufferParameter(target,pname);
	},
	getSamplerParameter: function(sampler,pname) {
		return this.__context.getSamplerParameter(sampler,pname);
	},
	getSamplerParameterf: function(sampler,pname) {
		return 0;
	},
	getSamplerParameterfv: function(sampler,pname,params) {
	},
	getSamplerParameteri: function(sampler,pname) {
		return 0;
	},
	getSamplerParameteriv: function(sampler,pname,params) {
	},
	getShaderi: function(shader,pname) {
		return this.getShaderParameter(shader,pname);
	},
	getShaderiv: function(shader,pname,params) {
		var view = (lime_utils__$DataPointer_DataPointer_$Impl_$().default).toInt32Array(params);
		view[0] = this.getShaderParameter(shader,pname);
	},
	getShaderInfoLog: function(shader) {
		return this.__context.getShaderInfoLog(shader);
	},
	getShaderParameter: function(shader,pname) {
		return this.__context.getShaderParameter(shader,pname);
	},
	getShaderPrecisionFormat: function(shadertype,precisiontype) {
		return this.__context.getShaderPrecisionFormat(shadertype,precisiontype);
	},
	getShaderSource: function(shader) {
		return this.__context.getShaderSource(shader);
	},
	getString: function(pname) {
		if(pname == 7939) {
			return this.getSupportedExtensions().join(" ");
		} else {
			return this.getParameter(pname);
		}
	},
	getStringi: function(name,index) {
		return null;
	},
	getSupportedExtensions: function() {
		return this.__context.getSupportedExtensions();
	},
	getSyncParameter: function(sync,pname) {
		return this.__context.getSyncParameter(sync,pname);
	},
	getSyncParameteri: function(sync,pname) {
		return 0;
	},
	getSyncParameteriv: function(sync,pname,params) {
	},
	getTexParameter: function(target,pname) {
		return this.__context.getTexParameter(target,pname);
	},
	getTexParameterf: function(target,pname) {
		return this.getTexParameter(target,pname);
	},
	getTexParameterfv: function(target,pname,params) {
		var view = (lime_utils__$DataPointer_DataPointer_$Impl_$().default).toFloat32Array(params);
		view[0] = this.getTexParameter(target,pname);
	},
	getTexParameteri: function(target,pname) {
		return this.getTexParameter(target,pname);
	},
	getTexParameteriv: function(target,pname,params) {
		var view = (lime_utils__$DataPointer_DataPointer_$Impl_$().default).toInt32Array(params);
		view[0] = this.getTexParameter(target,pname);
	},
	getTransformFeedbackVarying: function(program,index) {
		return this.__context.getTransformFeedbackVarying(program,index);
	},
	getUniform: function(program,location) {
		return this.__context.getUniform(program,location);
	},
	getUniformf: function(program,location) {
		return this.getUniform(program,location);
	},
	getUniformfv: function(program,location,params) {
		var view = (lime_utils__$DataPointer_DataPointer_$Impl_$().default).toFloat32Array(params);
		view[0] = this.getUniformf(program,location);
	},
	getUniformi: function(program,location) {
		return this.getUniform(program,location);
	},
	getUniformiv: function(program,location,params) {
		var value = this.getUniformi(program,location);
		var view = (lime_utils__$DataPointer_DataPointer_$Impl_$().default).toInt32Array(params);
		view[0] = value;
	},
	getUniformui: function(program,location) {
		return 0;
	},
	getUniformuiv: function(program,location,params) {
	},
	getUniformBlockIndex: function(program,uniformBlockName) {
		return this.__context.getUniformBlockIndex(program,uniformBlockName);
	},
	getUniformIndices: function(program,uniformNames) {
		return this.__context.getUniformIndices(program,uniformNames);
	},
	getUniformLocation: function(program,name) {
		return this.__context.getUniformLocation(program,name);
	},
	getVertexAttrib: function(index,pname) {
		return this.__context.getVertexAttrib(index,pname);
	},
	getVertexAttribf: function(index,pname) {
		return 0;
	},
	getVertexAttribfv: function(index,pname,params) {
	},
	getVertexAttribi: function(index,pname) {
		return 0;
	},
	getVertexAttribIi: function(index,pname) {
		return 0;
	},
	getVertexAttribIiv: function(index,pname,params) {
	},
	getVertexAttribIui: function(index,pname) {
		return 0;
	},
	getVertexAttribIuiv: function(index,pname,params) {
	},
	getVertexAttribiv: function(index,pname,params) {
	},
	getVertexAttribOffset: function(index,pname) {
		return (lime_utils__$DataPointer_DataPointer_$Impl_$().default).fromInt(this.__context.getVertexAttribOffset(index,pname));
	},
	getVertexAttribPointerv: function(index,pname) {
		return this.getVertexAttribOffset(index,pname);
	},
	hint: function(target,mode) {
		this.__context.hint(target,mode);
	},
	invalidateFramebuffer: function(target,attachments) {
		this.__context.invalidateFramebuffer(target,attachments);
	},
	invalidateSubFramebuffer: function(target,attachments,x,y,width,height) {
		this.__context.invalidateSubFramebuffer(target,attachments,x,y,width,height);
	},
	isBuffer: function(buffer) {
		return this.__context.isBuffer(buffer);
	},
	isContextLost: function() {
		if(!this.__contextLost) {
			return this.__context.isContextLost();
		} else {
			return true;
		}
	},
	isEnabled: function(cap) {
		return this.__context.isEnabled(cap);
	},
	isFramebuffer: function(framebuffer) {
		return this.__context.isFramebuffer(framebuffer);
	},
	isProgram: function(program) {
		return this.__context.isProgram(program);
	},
	isQuery: function(query) {
		return this.__context.isQuery(query);
	},
	isRenderbuffer: function(renderbuffer) {
		return this.__context.isRenderbuffer(renderbuffer);
	},
	isSampler: function(sampler) {
		return this.__context.isSampler(sampler);
	},
	isShader: function(shader) {
		return this.__context.isShader(shader);
	},
	isSync: function(sync) {
		return this.__context.isSync(sync);
	},
	isTexture: function(texture) {
		return this.__context.isTexture(texture);
	},
	isTransformFeedback: function(transformFeedback) {
		return this.__context.isTransformFeedback(transformFeedback);
	},
	isVertexArray: function(vertexArray) {
		return this.__context.isVertexArray(vertexArray);
	},
	lineWidth: function(width) {
		this.__context.lineWidth(width);
	},
	linkProgram: function(program) {
		this.__context.linkProgram(program);
	},
	mapBufferRange: function(target,offset,length,access) {
		return (lime_utils__$DataPointer_DataPointer_$Impl_$().default).fromInt(0);
	},
	pauseTransformFeedback: function() {
		this.__context.pauseTransformFeedback();
	},
	pixelStorei: function(pname,param) {
		this.__context.pixelStorei(pname,param);
	},
	polygonOffset: function(factor,units) {
		this.__context.polygonOffset(factor,units);
	},
	programBinary: function(program,binaryFormat,binary,length) {
	},
	programParameteri: function(program,pname,value) {
	},
	readBuffer: function(src) {
		this.__context.readBuffer(src);
	},
	readPixels: function(x,y,width,height,format,type,pixels) {
		this.__context.readPixels(x,y,width,height,format,type,(lime_utils__$DataPointer_DataPointer_$Impl_$().default).toBufferView(pixels));
	},
	readPixelsWEBGL: function(x,y,width,height,format,type,pixels,dstOffset) {
		if(dstOffset != null) {
			this.__context.readPixels(x,y,width,height,format,type,pixels,dstOffset);
		} else {
			this.__context.readPixels(x,y,width,height,format,type,pixels);
		}
	},
	releaseShaderCompiler: function() {
	},
	renderbufferStorage: function(target,internalformat,width,height) {
		this.__context.renderbufferStorage(target,internalformat,width,height);
	},
	renderbufferStorageMultisample: function(target,samples,internalFormat,width,height) {
		this.__context.renderbufferStorageMultisample(target,samples,internalFormat,width,height);
	},
	resumeTransformFeedback: function() {
		this.__context.resumeTransformFeedback();
	},
	sampleCoverage: function(value,invert) {
		this.__context.sampleCoverage(value,invert);
	},
	samplerParameterf: function(sampler,pname,param) {
		this.__context.samplerParameterf(sampler,pname,param);
	},
	samplerParameteri: function(sampler,pname,param) {
		this.__context.samplerParameteri(sampler,pname,param);
	},
	scissor: function(x,y,width,height) {
		this.__context.scissor(x,y,width,height);
	},
	shaderBinary: function(shaders,binaryformat,binary,length) {
	},
	shaderSource: function(shader,source) {
		this.__context.shaderSource(shader,source);
	},
	stencilFunc: function(func,ref,mask) {
		this.__context.stencilFunc(func,ref,mask);
	},
	stencilFuncSeparate: function(face,func,ref,mask) {
		this.__context.stencilFuncSeparate(face,func,ref,mask);
	},
	stencilMask: function(mask) {
		this.__context.stencilMask(mask);
	},
	stencilMaskSeparate: function(face,mask) {
		this.__context.stencilMaskSeparate(face,mask);
	},
	stencilOp: function(fail,zfail,zpass) {
		this.__context.stencilOp(fail,zfail,zpass);
	},
	stencilOpSeparate: function(face,fail,zfail,zpass) {
		this.__context.stencilOpSeparate(face,fail,zfail,zpass);
	},
	texImage2D: function(target,level,internalformat,width,height,border,format,type,data) {
		this.__context.texImage2D(target,level,internalformat,width,height,border,format,type,(lime_utils__$DataPointer_DataPointer_$Impl_$().default).toBufferView(data));
	},
	texImage2DWEBGL: function(target,level,internalformat,width,height,border,format,type,srcData,srcOffset) {
		if(srcOffset != null) {
			this.__context.texImage2D(target,level,internalformat,width,height,border,format,type,srcData,srcOffset);
		} else if(format != null) {
			this.__context.texImage2D(target,level,internalformat,width,height,border,format,type,srcData);
		} else {
			this.__context.texImage2D(target,level,internalformat,width,height,border);
		}
	},
	texImage3D: function(target,level,internalformat,width,height,depth,border,format,type,data) {
		this.__context.texImage3D(target,level,internalformat,width,height,depth,border,format,type,(lime_utils__$DataPointer_DataPointer_$Impl_$().default).toBufferView(data));
	},
	texImage3DWEBGL: function(target,level,internalformat,width,height,depth,border,format,type,srcData,srcOffset) {
		this.__context.texImage3D(target,level,internalformat,width,height,depth,border,format,type,srcData,srcOffset);
	},
	texStorage2D: function(target,level,internalformat,width,height) {
		this.__context.texStorage2D(target,level,internalformat,width,height);
	},
	texStorage3D: function(target,level,internalformat,width,height,depth) {
		this.__context.texStorage3D(target,level,internalformat,width,height,depth);
	},
	texParameterf: function(target,pname,param) {
		this.__context.texParameterf(target,pname,param);
	},
	texParameteri: function(target,pname,param) {
		this.__context.texParameteri(target,pname,param);
	},
	texSubImage2D: function(target,level,xoffset,yoffset,width,height,format,type,data) {
		this.__context.texSubImage2D(target,level,xoffset,yoffset,width,height,format,type,(lime_utils__$DataPointer_DataPointer_$Impl_$().default).toBufferView(data));
	},
	texSubImage2DWEBGL: function(target,level,xoffset,yoffset,width,height,format,type,srcData,srcOffset) {
		if(srcOffset != null) {
			this.__context.texSubImage2D(target,level,xoffset,yoffset,width,height,format,type,srcData,srcOffset);
		} else if(type != null) {
			this.__context.texSubImage2D(target,level,xoffset,yoffset,width,height,format,type,srcData);
		} else {
			this.__context.texSubImage2D(target,level,xoffset,yoffset,width,height,format);
		}
	},
	texSubImage3D: function(target,level,xoffset,yoffset,zoffset,width,height,depth,format,type,data) {
		this.__context.texSubImage3D(target,level,xoffset,yoffset,zoffset,width,height,depth,format,type,(lime_utils__$DataPointer_DataPointer_$Impl_$().default).toBufferView(data));
	},
	texSubImage3DWEBGL: function(target,level,xoffset,yoffset,zoffset,width,height,depth,format,type,source,srcOffset) {
		this.__context.texSubImage3D(target,level,xoffset,yoffset,zoffset,width,height,depth,format,type,source,srcOffset);
	},
	transformFeedbackVaryings: function(program,varyings,bufferMode) {
		this.__context.transformFeedbackVaryings(program,varyings,bufferMode);
	},
	uniform1f: function(location,v0) {
		this.__context.uniform1f(location,v0);
	},
	uniform1fv: function(location,count,v) {
		this.__context.uniform1fv(location,(lime_utils__$DataPointer_DataPointer_$Impl_$().default).toFloat32Array(v,count * 4));
	},
	uniform1fvWEBGL: function(location,data,srcOffset,srcLength) {
		if(srcOffset != null) {
			this.__context.uniform1fv(location,data,srcOffset,srcLength);
		} else {
			this.__context.uniform1fv(location,data);
		}
	},
	uniform1i: function(location,v0) {
		this.__context.uniform1i(location,v0);
	},
	uniform1iv: function(location,count,v) {
		this.__context.uniform1iv(location,(lime_utils__$DataPointer_DataPointer_$Impl_$().default).toInt32Array(v,count * 4));
	},
	uniform1ivWEBGL: function(location,data,srcOffset,srcLength) {
		if(srcOffset != null) {
			this.__context.uniform1iv(location,data,srcOffset,srcLength);
		} else {
			this.__context.uniform1iv(location,data);
		}
	},
	uniform1ui: function(location,v0) {
		this.__context.uniform1ui(location,v0);
		return;
	},
	uniform1uiv: function(location,count,v) {
		this.__context.uniform1uiv(location,(lime_utils__$DataPointer_DataPointer_$Impl_$().default).toUInt32Array(v,count * 4));
	},
	uniform1uivWEBGL: function(location,data,srcOffset,srcLength) {
		this.__context.uniform1uiv(location,data,srcOffset,srcLength);
	},
	uniform2f: function(location,v0,v1) {
		this.__context.uniform2f(location,v0,v1);
	},
	uniform2fv: function(location,count,v) {
		this.__context.uniform2fv(location,(lime_utils__$DataPointer_DataPointer_$Impl_$().default).toFloat32Array(v,count * 4 * 2));
	},
	uniform2fvWEBGL: function(location,data,srcOffset,srcLength) {
		if(srcOffset != null) {
			this.__context.uniform2fv(location,data,srcOffset,srcLength);
		} else {
			this.__context.uniform2fv(location,data);
		}
	},
	uniform2i: function(location,x,y) {
		this.__context.uniform2i(location,x,y);
	},
	uniform2iv: function(location,count,v) {
		this.__context.uniform2iv(location,(lime_utils__$DataPointer_DataPointer_$Impl_$().default).toInt32Array(v,count * 4 * 2));
	},
	uniform2ivWEBGL: function(location,data,srcOffset,srcLength) {
		if(srcOffset != null) {
			this.__context.uniform2iv(location,data,srcOffset,srcLength);
		} else {
			this.__context.uniform2iv(location,data);
		}
	},
	uniform2ui: function(location,v0,v1) {
		this.__context.uniform2ui(location,v0,v1);
	},
	uniform2uiv: function(location,count,v) {
		this.__context.uniform2uiv(location,(lime_utils__$DataPointer_DataPointer_$Impl_$().default).toUInt32Array(v,count * 4 * 2));
	},
	uniform2uivWEBGL: function(location,data,srcOffset,srcLength) {
		this.__context.uniform2uiv(location,data,srcOffset,srcLength);
	},
	uniform3f: function(location,v0,v1,v2) {
		this.__context.uniform3f(location,v0,v1,v2);
	},
	uniform3fv: function(location,count,v) {
		this.__context.uniform3fv(location,(lime_utils__$DataPointer_DataPointer_$Impl_$().default).toFloat32Array(v,count * 4 * 3));
	},
	uniform3fvWEBGL: function(location,data,srcOffset,srcLength) {
		if(srcOffset != null) {
			this.__context.uniform3fv(location,data,srcOffset,srcLength);
		} else {
			this.__context.uniform3fv(location,data);
		}
	},
	uniform3i: function(location,x,y,z) {
		this.__context.uniform3i(location,x,y,z);
	},
	uniform3iv: function(location,count,v) {
		this.__context.uniform3iv(location,(lime_utils__$DataPointer_DataPointer_$Impl_$().default).toInt32Array(v,count * 4 * 3));
	},
	uniform3ivWEBGL: function(location,data,srcOffset,srcLength) {
		if(srcOffset != null) {
			this.__context.uniform3iv(location,data,srcOffset,srcLength);
		} else {
			this.__context.uniform3iv(location,data);
		}
	},
	uniform3ui: function(location,v0,v1,v2) {
		this.__context.uniform3ui(location,v0,v1,v2);
	},
	uniform3uiv: function(location,count,v) {
		this.__context.uniform3uiv(location,(lime_utils__$DataPointer_DataPointer_$Impl_$().default).toUInt32Array(v,count * 4 * 3));
	},
	uniform3uivWEBGL: function(location,data,srcOffset,srcLength) {
		this.__context.uniform3uiv(location,data,srcOffset,srcLength);
	},
	uniform4f: function(location,v0,v1,v2,v3) {
		this.__context.uniform4f(location,v0,v1,v2,v3);
	},
	uniform4fv: function(location,count,v) {
		this.__context.uniform4fv(location,(lime_utils__$DataPointer_DataPointer_$Impl_$().default).toFloat32Array(v,count * 4 * 4));
	},
	uniform4fvWEBGL: function(location,data,srcOffset,srcLength) {
		if(srcOffset != null) {
			this.__context.uniform4fv(location,data,srcOffset,srcLength);
		} else {
			this.__context.uniform4fv(location,data);
		}
	},
	uniform4i: function(location,v0,v1,v2,v3) {
		this.__context.uniform4i(location,v0,v1,v2,v3);
	},
	uniform4iv: function(location,count,v) {
		this.__context.uniform4iv(location,(lime_utils__$DataPointer_DataPointer_$Impl_$().default).toInt32Array(v,count * 4 * 4));
	},
	uniform4ivWEBGL: function(location,data,srcOffset,srcLength) {
		if(srcOffset != null) {
			this.__context.uniform4iv(location,data,srcOffset,srcLength);
		} else {
			this.__context.uniform4iv(location,data);
		}
	},
	uniform4ui: function(location,v0,v1,v2,v3) {
		this.__context.uniform4ui(location,v0,v1,v2,v3);
	},
	uniform4uiv: function(location,count,v) {
		this.__context.uniform4uiv(location,(lime_utils__$DataPointer_DataPointer_$Impl_$().default).toUInt32Array(v,count * 4 * 4));
	},
	uniform4uivWEBGL: function(location,data,srcOffset,srcLength) {
		this.__context.uniform4uiv(location,data,srcOffset,srcLength);
	},
	uniformBlockBinding: function(program,uniformBlockIndex,uniformBlockBinding) {
		this.__context.uniformBlockBinding(program,uniformBlockIndex,uniformBlockBinding);
	},
	uniformMatrix2fv: function(location,count,transpose,v) {
		this.__context.uniformMatrix2fv(location,transpose,(lime_utils__$DataPointer_DataPointer_$Impl_$().default).toFloat32Array(v,count * 4 * 4));
	},
	uniformMatrix2fvWEBGL: function(location,transpose,data,srcOffset,srcLength) {
		if(srcOffset != null) {
			this.__context.uniformMatrix2fv(location,transpose,data,srcOffset,srcLength);
		} else {
			this.__context.uniformMatrix2fv(location,transpose,data);
		}
	},
	uniformMatrix2x3fv: function(location,count,transpose,v) {
		this.__context.uniformMatrix2x3fv(location,transpose,(lime_utils__$DataPointer_DataPointer_$Impl_$().default).toFloat32Array(v,count * 4 * 6));
	},
	uniformMatrix2x3fvWEBGL: function(location,transpose,data,srcOffset,srcLength) {
		this.__context.uniformMatrix2x3fv(location,transpose,data,srcOffset,srcLength);
	},
	uniformMatrix2x4fv: function(location,count,transpose,v) {
		this.__context.uniformMatrix2x4fv(location,transpose,(lime_utils__$DataPointer_DataPointer_$Impl_$().default).toFloat32Array(v,count * 4 * 8));
	},
	uniformMatrix2x4fvWEBGL: function(location,transpose,data,srcOffset,srcLength) {
		this.__context.uniformMatrix2x4fv(location,transpose,data,srcOffset,srcLength);
	},
	uniformMatrix3fv: function(location,count,transpose,v) {
		this.__context.uniformMatrix3fv(location,transpose,(lime_utils__$DataPointer_DataPointer_$Impl_$().default).toFloat32Array(v,count * 4 * 9));
	},
	uniformMatrix3fvWEBGL: function(location,transpose,data,srcOffset,srcLength) {
		if(srcOffset != null) {
			this.__context.uniformMatrix3fv(location,transpose,data,srcOffset,srcLength);
		} else {
			this.__context.uniformMatrix3fv(location,transpose,data);
		}
	},
	uniformMatrix3x2fv: function(location,count,transpose,v) {
		this.__context.uniformMatrix3x2fv(location,transpose,(lime_utils__$DataPointer_DataPointer_$Impl_$().default).toFloat32Array(v,count * 4 * 6));
	},
	uniformMatrix3x2fvWEBGL: function(location,transpose,data,srcOffset,srcLength) {
		this.__context.uniformMatrix3x2fv(location,transpose,data,srcOffset,srcLength);
	},
	uniformMatrix3x4fv: function(location,count,transpose,v) {
		this.__context.uniformMatrix3x4fv(location,transpose,(lime_utils__$DataPointer_DataPointer_$Impl_$().default).toFloat32Array(v,count * 4 * 12));
	},
	uniformMatrix3x4fvWEBGL: function(location,transpose,data,srcOffset,srcLength) {
		this.__context.uniformMatrix3x4fv(location,transpose,data,srcOffset,srcLength);
	},
	uniformMatrix4fv: function(location,count,transpose,v) {
		this.__context.uniformMatrix4fv(location,transpose,(lime_utils__$DataPointer_DataPointer_$Impl_$().default).toFloat32Array(v,count * 4 * 16));
	},
	uniformMatrix4fvWEBGL: function(location,transpose,data,srcOffset,srcLength) {
		if(srcOffset != null) {
			this.__context.uniformMatrix4fv(location,transpose,data,srcOffset,srcLength);
		} else {
			this.__context.uniformMatrix4fv(location,transpose,data);
		}
	},
	uniformMatrix4x2fv: function(location,count,transpose,v) {
		this.__context.uniformMatrix4x2fv(location,transpose,(lime_utils__$DataPointer_DataPointer_$Impl_$().default).toFloat32Array(v,count * 4 * 8));
	},
	uniformMatrix4x2fvWEBGL: function(location,transpose,data,srcOffset,srcLength) {
		if(srcOffset != null) {
			this.__context.uniformMatrix4x2fv(location,transpose,data,srcOffset,srcLength);
		} else {
			this.__context.uniformMatrix4x2fv(location,transpose,data);
		}
	},
	uniformMatrix4x3fv: function(location,count,transpose,v) {
		this.__context.uniformMatrix4x3fv(location,transpose,(lime_utils__$DataPointer_DataPointer_$Impl_$().default).toFloat32Array(v,count * 4 * 12));
	},
	uniformMatrix4x3fvWEBGL: function(location,transpose,data,srcOffset,srcLength) {
		this.__context.uniformMatrix4x3fv(location,transpose,data,srcOffset,srcLength);
	},
	unmapBuffer: function(target) {
		return false;
	},
	useProgram: function(program) {
		this.__context.useProgram(program);
	},
	validateProgram: function(program) {
		this.__context.validateProgram(program);
	},
	vertexAttrib1f: function(index,v0) {
		this.__context.vertexAttrib1f(index,v0);
	},
	vertexAttrib1fv: function(index,v) {
		this.__context.vertexAttrib1fv(index,(lime_utils__$DataPointer_DataPointer_$Impl_$().default).toFloat32Array(v));
	},
	vertexAttrib1fvWEBGL: function(index,v) {
		this.__context.vertexAttrib1fv(index,v);
	},
	vertexAttrib2f: function(index,v0,v1) {
		this.__context.vertexAttrib2f(index,v0,v1);
	},
	vertexAttrib2fv: function(index,v) {
		this.__context.vertexAttrib2fv(index,(lime_utils__$DataPointer_DataPointer_$Impl_$().default).toFloat32Array(v));
	},
	vertexAttrib2fvWEBGL: function(index,v) {
		this.__context.vertexAttrib2fv(index,v);
	},
	vertexAttrib3f: function(index,v0,v1,v2) {
		this.__context.vertexAttrib3f(index,v0,v1,v2);
	},
	vertexAttrib3fv: function(index,v) {
		this.__context.vertexAttrib3fv(index,(lime_utils__$DataPointer_DataPointer_$Impl_$().default).toFloat32Array(v));
	},
	vertexAttrib3fvWEBGL: function(index,v) {
		this.__context.vertexAttrib3fv(index,v);
	},
	vertexAttrib4f: function(index,v0,v1,v2,v3) {
		this.__context.vertexAttrib4f(index,v0,v1,v2,v3);
	},
	vertexAttrib4fv: function(index,v) {
		this.__context.vertexAttrib4fv(index,(lime_utils__$DataPointer_DataPointer_$Impl_$().default).toFloat32Array(v));
	},
	vertexAttrib4fvWEBGL: function(index,v) {
		this.__context.vertexAttrib4fv(index,v);
	},
	vertexAttribDivisor: function(index,divisor) {
		this.__context.vertexAttribDivisor(index,divisor);
	},
	vertexAttribI4i: function(index,v0,v1,v2,v3) {
		this.__context.vertexAttribI4i(index,v0,v1,v2,v3);
	},
	vertexAttribI4iv: function(index,v) {
		this.__context.vertexAttribI4iv(index,(lime_utils__$DataPointer_DataPointer_$Impl_$().default).toInt32Array(v));
	},
	vertexAttribI4ivWEBGL: function(index,v) {
		this.__context.vertexAttribI4iv(index,v);
	},
	vertexAttribI4ui: function(index,v0,v1,v2,v3) {
		this.__context.vertexAttribI4ui(index,v0,v1,v2,v3);
	},
	vertexAttribI4uiv: function(index,v) {
		this.__context.vertexAttribI4uiv(index,(lime_utils__$DataPointer_DataPointer_$Impl_$().default).toUInt32Array(v));
	},
	vertexAttribI4uivWEBGL: function(index,v) {
		this.__context.vertexAttribI4uiv(index,v);
	},
	vertexAttribIPointer: function(index,size,type,stride,offset) {
		this.__context.vertexAttribIPointer(index,size,type,stride,(lime_utils__$DataPointer_DataPointer_$Impl_$().default).fromInt((lime_utils__$DataPointer_DataPointer_$Impl_$().default).toValue(offset)));
	},
	vertexAttribPointer: function(index,size,type,normalized,stride,offset) {
		this.__context.vertexAttribPointer(index,size,type,normalized,stride,(lime_utils__$DataPointer_DataPointer_$Impl_$().default).toValue(offset));
	},
	viewport: function(x,y,width,height) {
		this.__context.viewport(x,y,width,height);
	},
	waitSync: function(sync,flags,timeout) {
		this.__context.waitSync(sync,flags,timeout);
	},
	get_canvas: function() {
		return this.__context.canvas;
	},
	get_drawingBufferHeight: function() {
		return this.__context.drawingBufferHeight;
	},
	get_drawingBufferWidth: function() {
		return this.__context.drawingBufferWidth;
	}
};
HTML5GLRenderContext.prototype.__class__ = HTML5GLRenderContext.prototype.constructor = $hxClasses["lime._backend.html5.HTML5GLRenderContext"] = HTML5GLRenderContext;

// Init



// Statics




// Export

exports.default = HTML5GLRenderContext;