WebGL enums

gistfile1.hx

package js;

import js.TypedArray;
import js.Canvas;
import js.type.DOMType;
import js.type.GLType;
import js.type.Core;
import js.type.Event;
import js.type.Object;

extern class WebGLRenderingContext
{
  //-------------------------------------------------------------------------- properties

	public var canvas(default, null):HTMLCanvasElement;

	public var drawingBufferWidth(default, null):GLsizei;
	public var drawingBufferHeight(default, null):GLsizei;

	//-------------------------------------------------------------------------- methods

	public function getContextAttributes():WebGLContextAttributes;
	public function isContextLost():Bool;
	public function getSupportedExtensions():Array<DOMString>;
	public function getExtension(name:DOMString):Object;
	public function attachShader(program:WebGLProgram, shader:WebGLShader):Void;
	public function drawArrays(mode:WebGLDrawMode, first:GLint, count:GLsizei):Void;
	public function drawElements(mode:WebGLDrawMode, count:GLsizei, type:GLenum, offset:GLintptr):Void;
	public function checkFramebufferStatus(target:WebGLFramebufferTarget):WebGLFramebufferStatus;

	public function framebufferRenderbuffer(target:WebGLFramebufferTarget, attachment:WebGLAttachment, renderbuffertarget:WebGLRenderbufferTarget, renderbuffer:WebGLRenderbuffer):Void;
	public function framebufferTexture2D(target:WebGLFramebufferTarget, attachment:WebGLAttachment, textarget:WebGLTextureImageTarget, texture:WebGLTexture, level:GLint):Void;

	// shader

	public function createShader(type:WebGLShaderType):WebGLShader;
	public function shaderSource(shader:WebGLShader, source:DOMString):Void;
	public function compileShader(shader:WebGLShader):Void;
	public function getShaderParameter(shader:WebGLShader, pname:WebGLShaderParameter):Dynamic;

	// program

	public function createProgram():WebGLProgram;
	public function linkProgram(program:WebGLProgram):Void;
	public function getProgramParameter(program:WebGLProgram, pname:WebGLProgramParameter):Dynamic;

	// buffer
	
	public function bindBuffer(target:WebGLBufferTarget, buffer:WebGLBuffer):Void;
	@:overload(function(target:WebGLBufferTarget, size:GLsizeiptr, usage:WebGLBufferUsage):Void {} )
	@:overload(function(target:WebGLBufferTarget, data:ArrayBufferView, usage:WebGLBufferUsage):Void {} )
	public function bufferData(target:WebGLBufferTarget, data:ArrayBuffer, usage:WebGLBufferUsage):Void;

	// capabilities

	public function enable(cap:WebGLCapability):Void;
	public function disable(cap:WebGLCapability):Void;

	// parameters

	public function getParameter(pname:WebGLParameter):Dynamic;
	public function getBufferParameter(target:GLenum, pname:WebGLBufferParameter):Dynamic;
	public function getRenderbufferParameter(target:GLenum, pname:WebGLRenderbufferParameter):Dynamic;
	public function getTexParameter(target:GLenum, pname:WebGLTextureParameter):Dynamic;
	public function getFramebufferAttachmentParameter(target:GLenum, attachment:GLenum, pname:WebGLFramebufferAttachmentParameter):Dynamic;

	// attributes

	public function getVertexAttrib(index:GLuint, pname:WebGLVertexAttrib):Dynamic;
	public function getVertexAttribOffset(index:GLuint, pname:WebGLVertexAttrib):GLsizeiptr;

	// binding

	public function bindAttribLocation(program:WebGLProgram, index:GLuint, name:DOMString):Void;
	public function bindFramebuffer(target:WebGLFramebufferTarget, framebuffer:WebGLFramebuffer):Void;
	public function bindRenderbuffer(target:WebGLRenderbufferTarget, renderbuffer:WebGLRenderbuffer):Void;
	public function bindTexture(target:WebGLTextureTarget, texture:WebGLTexture):Void;

	// blending

	public function blendColor(red:GLclampf, green:GLclampf, blue:GLclampf, alpha:GLclampf):Void;
	public function blendEquation(mode:WebGLBlendEquation):Void;
	public function blendEquationSeparate(modeRGB:WebGLBlendEquation, modeAlpha:WebGLBlendEquation):Void;
	public function blendFunc(src:WebGLBlendingFactorSrc, dest:WebGLBlendingFactorDest):Void;
	public function blendFuncSeparate(srcRGB:WebGLBlendingFactorSrc, destRGB:WebGLBlendingFactorDest, srcAlpha:WebGLBlendingFactorSrc, destAlpha:WebGLBlendingFactorDest):Void;

	// textures

	public function activeTexture(texture:WebGLTextureUnit):Void;

	@:overload(function(target:WebGLTextureImageTarget, level:GLint, internalformat:WebGLInternalFormat, width:GLsizei , height:GLsizei , border:GLint , format:GLenum, type:GLenum , pixels:ArrayBufferView):Void {} )
	@:overload(function(target:WebGLTextureImageTarget, level:GLint, internalformat:WebGLInternalFormat, format:GLenum, type:GLenum,  pixels:ImageData):Void {} )
	@:overload(function(target:WebGLTextureImageTarget, level:GLint, internalformat:WebGLInternalFormat, format:GLenum, type:GLenum, image:HTMLImageElement):Void {} )
	@:overload(function(target:WebGLTextureImageTarget, level:GLint, internalformat:WebGLInternalFormat, format:GLenum, type:GLenum, canvas:HTMLCanvasElement):Void {} )
	public function texImage2D(target:WebGLTextureImageTarget, level:GLint, internalformat:WebGLInternalFormat, format:GLenum, type:GLenum, video:HTMLVideoElement):Void;

	public var DEPTH_BUFFER_BIT(default, null):GLenum;
	public var STENCIL_BUFFER_BIT(default, null):GLenum;
	public var COLOR_BUFFER_BIT(default, null):GLenum;
	public var BLEND_EQUATION(default, null):GLenum;

	/* Separate Blend Functions */
		public var CONSTANT_COLOR(default, null):GLenum;
		public var ONE_MINUS_CONSTANT_COLOR(default, null):GLenum;
		public var CONSTANT_ALPHA(default, null):GLenum;
		public var ONE_MINUS_CONSTANT_ALPHA(default, null):GLenum;

	/* Buffer Objects */
		

	/* CullFaceMode */
		public var FRONT(default, null):GLenum;
		public var BACK(default, null):GLenum;
		public var FRONT_AND_BACK(default, null):GLenum;

	/* ErrorCode */
		public var NO_ERROR(default, null):GLenum;
		public var INVALID_ENUM(default, null):GLenum;
		public var INVALID_VALUE(default, null):GLenum;
		public var INVALID_OPERATION(default, null):GLenum;
		public var OUT_OF_MEMORY(default, null):GLenum;

	/* FrontFaceDirection */
		public var CW(default, null):GLenum;
		public var CCW(default, null):GLenum;

	/* HintMode */
		public var DONT_CARE(default, null):GLenum;
		public var FASTEST(default, null):GLenum;
		public var NICEST(default, null):GLenum;

	/* TextureMagFilter */
		public var NEAREST(default, null):GLenum;
		public var LINEAR(default, null):GLenum;

	/* TextureMinFilter */
		/* NEAREST */
		/* LINEAR */
		public var NEAREST_MIPMAP_NEAREST(default, null):GLenum;
		public var LINEAR_MIPMAP_NEAREST(default, null):GLenum;
		public var NEAREST_MIPMAP_LINEAR(default, null):GLenum;
		public var LINEAR_MIPMAP_LINEAR(default, null):GLenum;

	/* Framebuffer Object. */
		
		public var NONE(default, null):GLenum;
		public var INVALID_FRAMEBUFFER_OPERATION(default, null):GLenum;	

	/* WebGL-specific enums */
		public var CONTEXT_LOST_WEBGL(default, null): GLenum;
		public var BROWSER_DEFAULT_WEBGL(default, null):GLenum;	
	
	/* properties */
		
    
	/* methods */
		
		
		  
		@:overload(function(target:GLenum, offset:GLintptr, data:ArrayBufferView):Void {} )  
		public function bufferSubData(target:GLenum, offset:GLintptr, data:ArrayBuffer):Void;
		
		public function clear(mask:GLbitfield):Void;
		public function clearColor(red:GLclampf, green:GLclampf, blue:GLclampf, alpha:GLclampf):Void;
		public function clearDepth(depth:GLclampf):Void;
		public function clearStencil(s:GLint):Void;
		public function colorMask(red:GLboolean, green:GLboolean, blue:GLboolean, alpha:GLboolean):Void;
		public function copyTexImage2D(target:GLenum, level:GLint, internalformat:WebGLInternalFormat, x:GLint, y:GLint,  width:GLsizei, height:GLsizei, border:GLint):Void;
		public function copyTexSubImage2D(target:GLenum, level:GLint, xoffset:GLint, yoffset:GLint, x:GLint, y:GLint, width:GLsizei, height:GLsizei):Void;
		public function createBuffer():WebGLBuffer;
		public function createFramebuffer():WebGLFramebuffer;
		public function createRenderbuffer():WebGLRenderbuffer;
		
		public function createTexture():WebGLTexture;
		public function cullFace(mode:GLenum):Void;
		public function deleteBuffer(buffer:WebGLBuffer):Void;
		public function deleteFramebuffer(framebuffer:WebGLFramebuffer):Void;
		public function deleteProgram(program:WebGLProgram):Void;
		public function deleteRenderbuffer(renderbuffer:WebGLRenderbuffer):Void;
		public function deleteShader(shader:WebGLShader):Void;
		public function deleteTexture(texture:WebGLTexture):Void;
		public function depthFunc(func:GLenum):Void;
		public function depthMask(flag:GLboolean):Void;
		public function depthRange(zNear:GLclampf, zFar:GLclampf):Void;
		public function detachShader(program:WebGLProgram, shader:WebGLShader):Void;
		public function disableVertexAttribArray(index:GLuint):Void;
		
		public function enableVertexAttribArray(index:GLuint):Void;
		public function finish():Void;
		public function flush():Void;
		public function frontFace(mode:GLenum):Void;
		public function generateMipmap(target:GLenum):Void;
		public function getActiveAttrib(program:WebGLProgram, index:GLuint):WebGLActiveInfo;
		public function getActiveUniform(program:WebGLProgram, index:GLuint):WebGLActiveInfo;
		public function getAttachedShaders(program:WebGLProgram):Array<WebGLShader>;
		public function getAttribLocation(program:WebGLProgram, name:DOMString):GLint;
		public function getError():GLenum;
		public function getProgramInfoLog(program:WebGLProgram):DOMString;
		public function getShaderInfoLog(shader:WebGLShader):DOMString;
		public function getShaderSource(shader:WebGLShader):DOMString;
		public function getUniform(program:WebGLProgram, location:WebGLUniformLocation):Dynamic;
		public function getUniformLocation(program:WebGLProgram, name:DOMString):WebGLUniformLocation;
		public function hint(target:GLenum, mode:GLenum):Void;
		public function isBuffer(buffer:WebGLBuffer):GLboolean;
		public function isEnabled(cap:GLenum):GLboolean;
		public function isFramebuffer(framebuffer:WebGLFramebuffer):GLboolean;
		public function isProgram(program:WebGLProgram):GLboolean;
		public function isRenderbuffer(renderbuffer:WebGLRenderbuffer):GLboolean;
		public function isShader(shader:WebGLShader):GLboolean;
		public function isTexture(texture:WebGLTexture):GLboolean;
		public function lineWidth(width:GLfloat):Void;
		
		public function pixelStorei(pname:GLenum, param:GLint):Void;
		public function polygonOffset(factor:GLfloat, units:GLfloat):Void;
		public function readPixels(x:GLint, y:GLint, width:GLsizei, height:GLsizei, format:GLenum, type:GLenum, pixels:ArrayBufferView):Void;
		public function renderbufferStorage(target:GLenum, internalformat:WebGLInternalFormat, width:GLsizei, height:GLsizei):Void;
		public function sampleCoverage(value:GLclampf, invert:GLboolean):Void;
		public function scissor(x:GLint, y:GLint, width:GLsizei, height:GLsizei):Void;
		public function stencilFunc(func:GLenum, ref:GLint, mask:GLuint):Void;
		public function stencilFuncSeparate(face:GLenum, func:GLenum, ref:GLint, mask:GLuint):Void;
		public function stencilMask(mask:GLuint):Void;
		public function stencilMaskSeparate(face:GLenum, mask:GLuint):Void;
		public function stencilOp(fail:GLenum, zfail:GLenum, zpass:GLenum):Void;
		public function stencilOpSeparate(face:GLenum, fail:GLenum, zfail:GLenum, zpass:GLenum):Void;
    	
		@:overload(function(target:GLenum, pname:GLenum, param:GLfloat):Void {} )
		public function texParameteri(target:GLenum, pname:GLenum, param:GLint):Void;
		
		@:overload(function(target:GLenum, level:GLint, xoffset:GLint, yoffset:GLint, width:GLsizei, height:GLsizei, format:GLenum, type:GLenum, pixels:ArrayBufferView):Void {} )
		@:overload(function(target:GLenum, level:GLint, xoffset:GLint, yoffset:GLint, format:GLenum, type:GLenum, pixels:ImageData):Void {} )
		@:overload(function(target:GLenum, level:GLint, xoffset:GLint, yoffset:GLint, format:GLenum, type:GLenum, image:HTMLImageElement):Void {} )
		@:overload(function(target:GLenum, level:GLint, xoffset:GLint, yoffset:GLint, format:GLenum, type:GLenum, canvas:HTMLCanvasElement):Void {} )
		public function texSubImage2D(target:GLenum, level:GLint, xoffset:GLint , yoffset:GLint, format:GLenum, type:GLenum, video:HTMLVideoElement):Void;
		
		public function uniform1f(location:WebGLUniformLocation, x:GLfloat):Void;
		public function uniform1i(location:WebGLUniformLocation, x:GLint):Void;
		public function uniform2f(location:WebGLUniformLocation, x:GLfloat, y:GLfloat):Void;
		public function uniform2i(location:WebGLUniformLocation, x:GLint, y:GLint):Void;
		public function uniform3f(location:WebGLUniformLocation, x:GLfloat, y:GLfloat, z:GLfloat):Void;	
		public function uniform3i(location:WebGLUniformLocation, x:GLint, y:GLint, z:GLint):Void;
		public function uniform4f(location:WebGLUniformLocation, x:GLfloat, y:GLfloat, z:GLfloat, w:GLfloat):Void;
		public function uniform4i(location:WebGLUniformLocation, x:GLint, y:GLint, z:GLint, w:GLint):Void;
		
		@:overload(function(location:WebGLUniformLocation, v:Float32Array):Void {} )
		public function uniform1fv(location:WebGLUniformLocation, v:ArrayAccess<Float>):Void;

    	@:overload(function(location:WebGLUniformLocation, v:Int32Array):Void {} )
		public function uniform1iv(location:WebGLUniformLocation, v:ArrayAccess<Long>):Void;
    	
		@:overload(function(location:WebGLUniformLocation, v:Float32Array):Void {} )
		public function uniform2fv(location:WebGLUniformLocation, v:Array<Float>):Void;

		@:overload(function(location:WebGLUniformLocation, v:Int32Array):Void {} )
		public function uniform2iv(location:WebGLUniformLocation, v:ArrayAccess<Long>):Void;

		@:overload(function(location:WebGLUniformLocation, v:Float32Array):Void {} )
		public function uniform3fv(location:WebGLUniformLocation, v:ArrayAccess<Float>):Void;
		
		@:overload(function(location:WebGLUniformLocation, v:Int32Array):Void {} )
		public function uniform3iv(location:WebGLUniformLocation, v:ArrayAccess<Long>):Void;
		
		@:overload(function(location:WebGLUniformLocation, v:Float32Array):Void {} )
		public function uniform4fv(location:WebGLUniformLocation, v:ArrayAccess<Float>):Void;
		
		@:overload(function(location:WebGLUniformLocation, v:Int32Array):Void {} )
		public function uniform4iv(location:WebGLUniformLocation, v:ArrayAccess<Long>):Void;

		@:overload(function(location:WebGLUniformLocation, transpose:GLboolean, value:Float32Array):Void {} )
		public function uniformMatrix2fv(location:WebGLUniformLocation, transpose:GLboolean, value:ArrayAccess<Float>):Void;
		    
		@:overload(function(location:WebGLUniformLocation, transpose:GLboolean, value:Float32Array):Void {} )
		public function  uniformMatrix3fv(location:WebGLUniformLocation, transpose:GLboolean, value:ArrayAccess<Float>):Void;
		    
		@:overload(function(location:WebGLUniformLocation, transpose:GLboolean, value:Float32Array):Void {} )
		public function uniformMatrix4fv(location:WebGLUniformLocation, transpose:GLboolean, value:ArrayAccess<Float>):Void;
		
		public function useProgram(program:WebGLProgram):Void;
		public function validateProgram(program:WebGLProgram):Void;
		
		public function vertexAttrib1f(indx:GLuint, x:GLfloat):Void;	
		public function vertexAttrib2f(indx:GLuint, x:GLfloat, y:GLfloat):Void;	
		public function vertexAttrib3f(indx:GLuint, x:GLfloat, y:GLfloat, z:GLfloat):Void;
		public function vertexAttrib4f(indx:GLuint, x:GLfloat, y:GLfloat, z:GLfloat, w:GLfloat):Void;
		public function vertexAttribPointer(indx:GLuint, size:GLint, type:WebGLDataType, normalized:GLboolean, stride:GLsizei, offset:GLintptr):Void;

		@:overload(function(indx:GLuint, values:Float32Array):Void {} )
		public function vertexAttrib1fv(indx:GLuint, values:ArrayAccess<Float>):Void;

		@:overload(function(indx:GLuint, values:Float32Array):Void {} )
		public function vertexAttrib2fv(indx:GLuint, values:ArrayAccess<Float>):Void;

		@:overload(function(indx:GLuint, values:Float32Array):Void {} )
		public function vertexAttrib3fv(indx:GLuint, values:ArrayAccess<Float>):Void;

		@:overload(function(indx:GLuint, values:Float32Array):Void {} )
		public function vertexAttrib4fv(indx:GLuint, values:ArrayAccess<Float>):Void;
	
		public function viewport(x:GLint, y:GLint, width:GLsizei, height:GLsizei):Void;	
  
}

extern interface WebGLContextAttributes
{
    public var alpha:Bool;
    public var depth:Bool;
    public var stencil:Bool;
    public var antialias:Bool;
    public var premultipliedAlpha:Bool;
    public var preserveDrawingBuffer:Bool;
}

extern interface WebGLObject {}
extern interface WebGLBuffer implements WebGLObject {}
extern interface WebGLFramebuffer implements WebGLObject {}
extern interface WebGLProgram implements WebGLObject {}
extern interface WebGLRenderbuffer implements WebGLObject {}
extern interface WebGLShader implements WebGLObject {}
extern interface WebGLTexture implements WebGLObject {}
extern interface WebGLUniformLocation {}

extern interface WebGLActiveInfo
{
    public var size(default, null):GLint;
   	public var type(default, null):GLenum;
   	public var name(default, null):DOMString;
}

extern class WebGLContextEvent extends Event
{
	public var statusMessage(default, null):DOMString;
	public function new(typeArg:DOMString, canBubbleArg:Bool, cancelableArg:Bool, statusMessageArg:DOMString):Void;
}

// @:fakeEnum(Int)
// @:native('WebGLRenderingContext')
// extern enum WebGLStencilOp
// {
// 	KEEP;
// 	REPLACE;
// 	INCR;
// 	DECR;
// 	INVERT;
// 	INCR_WRAP;
// 	DECR_WRAP;
// }

// @:fakeEnum(Int)
// @:native('WebGLRenderingContext')
// extern enum WebGLTextureWrapMode
// {
// 	REPEAT;
// 	CLAMP_TO_EDGE;
// 	MIRRORED_REPEAT;
// }

// @:fakeEnum(Int)
// @:native('WebGLRenderingContext')
// extern enum WebGLPixelType
// {
// 	UNSIGNED_SHORT_4_4_4_4;
// 	UNSIGNED_SHORT_5_5_5_1;
// 	UNSIGNED_SHORT_5_6_5;
// }

// @:fakeEnum(Int)
// @:native('WebGLRenderingContext')
// extern enum WebGLPixelFormat
// {
// 	DEPTH_COMPONENT;
// 	ALPHA;
// 	RGB;
// 	RGBA;
// 	LUMINANCE;
// 	LUMINANCE_ALPHA;
// }

//------------------------------------------------------------------------------ parameters

@:fakeEnum(Int)
@:native('WebGLRenderingContext')
extern enum WebGLParameter
{
	ALIASED_LINE_WIDTH_RANGE;
	ALIASED_POINT_SIZE_RANGE;
	ALPHA_BITS;
	ARRAY_BUFFER_BINDING;
	BLEND;
	BLEND_COLOR;
	BLEND_DST_ALPHA;
	BLEND_DST_RGB;
	BLEND_EQUATION_ALPHA;
	BLEND_EQUATION_RGB;
	BLEND_SRC_ALPHA;
	BLEND_SRC_RGB;
	BLUE_BITS;
	COLOR_CLEAR_VALUE;
	COLOR_WRITEMASK;
	COMPRESSED_TEXTURE_FORMATS;
	CULL_FACE;
	CULL_FACE_MODE;
	CURRENT_PROGRAM;
	DEPTH_BITS;
	DEPTH_CLEAR_VALUE;
	DEPTH_FUNC;
	DEPTH_RANGE;
	DEPTH_TEST;
	DEPTH_WRITEMASK;
	DITHER;
	ELEMENT_ARRAY_BUFFER_BINDING;
	FRAMEBUFFER_BINDING;
	FRONT_FACE;
	GENERATE_MIPMAP_HINT;
	GREEN_BITS;
	LINE_WIDTH;
	MAX_COMBINED_TEXTURE_IMAGE_UNITS;
	MAX_CUBE_MAP_TEXTURE_SIZE;
	MAX_FRAGMENT_UNIFORM_VECTORS;
	MAX_RENDERBUFFER_SIZE;
	MAX_TEXTURE_IMAGE_UNITS;
	MAX_TEXTURE_SIZE;
	MAX_VARYING_VECTORS;
	MAX_VERTEX_ATTRIBS;
	MAX_VERTEX_TEXTURE_IMAGE_UNITS;
	MAX_VERTEX_UNIFORM_VECTORS;
	MAX_VIEWPORT_DIMS;
	NUM_COMPRESSED_TEXTURE_FORMATS;
	PACK_ALIGNMENT;
	POLYGON_OFFSET_FACTOR;
	POLYGON_OFFSET_FILL;
	POLYGON_OFFSET_UNITS;
	RED_BITS;
	RENDERBUFFER_BINDING;

	/**
	A <code>String</code> containing the name of the renderer. This name is 
	typically specific to a particular configuration of a hardware platform. 
	It does not change from release to release.
	*/
	RENDERER;
	SAMPLE_BUFFERS;
	SAMPLE_COVERAGE_INVERT;
	SAMPLE_COVERAGE_VALUE;
	SAMPLES;
	SCISSOR_BOX;
	SCISSOR_TEST;

	/**
	A <code>String</code> version or release number of the form:
	<code>WebGL GLSL ES 1.0 <vendor-specific information></code>
	*/
	SHADING_LANGUAGE_VERSION;
	STENCIL_BACK_FAIL;
	STENCIL_BACK_FUNC;
	STENCIL_BACK_PASS_DEPTH_FAIL;
	STENCIL_BACK_PASS_DEPTH_PASS;
	STENCIL_BACK_REF;
	STENCIL_BACK_VALUE_MASK;
	STENCIL_BACK_WRITEMASK;
	STENCIL_BITS;
	STENCIL_CLEAR_VALUE;
	STENCIL_FAIL;
	STENCIL_FUNC;
	STENCIL_PASS_DEPTH_FAIL;
	STENCIL_PASS_DEPTH_PASS;
	STENCIL_REF;
	STENCIL_TEST;
	STENCIL_VALUE_MASK;
	STENCIL_WRITEMASK;
	SUBPIXEL_BITS;
	TEXTURE_BINDING_2D;
	TEXTURE_BINDING_CUBE_MAP;
	UNPACK_ALIGNMENT;
	UNPACK_COLORSPACE_CONVERSION_WEBGL;
	UNPACK_FLIP_Y_WEBGL;
	UNPACK_PREMULTIPLY_ALPHA_WEBGL;

	/**
	A <code>String</code> containing company responsible for this WebGL 
	implementation. This name does not change from release to release.
	*/
	VENDOR;

	/**
	A <code>String</code> version or release number of the form:
	<code>WebGL 1.0 <vendor-specific information></code>
	*/
	VERSION;
	VIEWPORT;
}

@:fakeEnum(Int)
@:native('WebGLRenderingContext')
extern enum WebGLBufferParameter
{
	BUFFER_SIZE;
	BUFFER_USAGE;
}

@:fakeEnum(Int)
@:native('WebGLRenderingContext')
extern enum WebGLRenderbufferParameter
{
	RENDERBUFFER_WIDTH;
	RENDERBUFFER_HEIGHT;
	RENDERBUFFER_INTERNAL_FORMAT;
	RENDERBUFFER_RED_SIZE;
	RENDERBUFFER_GREEN_SIZE;
	RENDERBUFFER_BLUE_SIZE;
	RENDERBUFFER_ALPHA_SIZE;
	RENDERBUFFER_DEPTH_SIZE;
	RENDERBUFFER_STENCIL_SIZE;
}

@:fakeEnum(Int)
@:native('WebGLRenderingContext')
extern enum WebGLTextureParameter
{
	TEXTURE_MAG_FILTER;
	TEXTURE_MIN_FILTER;
	TEXTURE_WRAP_S;
	TEXTURE_WRAP_T;
}

@:fakeEnum(Int)
@:native('WebGLRenderingContext')
extern enum WebGLProgramParameter
{
	DELETE_STATUS;
	LINK_STATUS;
	VALIDATE_STATUS;
	ATTACHED_SHADERS;
	ACTIVE_ATTRIBUTES;
	ACTIVE_UNIFORMS;
}

@:fakeEnum(Int)
@:native('WebGLRenderingContext')
extern enum WebGLShaderParameter
{
	SHADER_TYPE;
	DELETE_STATUS;
	COMPILE_STATUS;
}

@:fakeEnum(Int)
@:native('WebGLRenderingContext')
extern enum WebGLFramebufferAttachmentParameter
{
	FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE;
	FRAMEBUFFER_ATTACHMENT_OBJECT_NAME;
	FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL;
	FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE;
}

//------------------------------------------------------------------------------ capability

@:fakeEnum(Int)
@:native('WebGLRenderingContext')
extern enum WebGLCapability
{
	/**
	If enabled, blend the computed fragment color values with the values in the 
	color buffers.
	*/
	BLEND;

	/**
	If enabled, cull polygons based on their winding in window coordinates.
	*/
	CULL_FACE;

	/**
	If enabled, do depth comparisons and update the depth buffer. Note that 
	even if the depth buffer exists and the depth mask is non-zero, the depth 
	buffer is not updated if the depth test is disabled. 
	*/
	DEPTH_TEST;

	/**
	If enabled, dither color components or indices before they are written to 
	the color buffer.
	*/
	DITHER;

	/**
	If enabled, an offset is added to depth values of a polygon's fragments 
	produced by rasterization.
	*/
	POLYGON_OFFSET_FILL;

	/**
	If enabled, compute a temporary coverage value where each bit is determined 
	by the alpha value at the corresponding sample location. The temporary 
	coverage value is then ANDed with the fragment coverage value.
	*/
	SAMPLE_ALPHA_TO_COVERAGE;

	/**
	If enabled, the fragment's coverage is ANDed with the temporary coverage 
	value. If GL_SAMPLE_COVERAGE_INVERT is set to GL_TRUE, invert the coverage 
	value.
	*/
	SAMPLE_COVERAGE;

	/**
	If enabled, discard fragments that are outside the scissor rectangle.
	*/
	SCISSOR_TEST;

	/**
	If enabled, do stencil testing and update the stencil buffer.
	*/
	STENCIL_TEST;
}

//------------------------------------------------------------------------------ targets

@:fakeEnum(Int)
@:native('WebGLRenderingContext')
extern enum WebGLBufferTarget
{
	ARRAY_BUFFER;
	ELEMENT_ARRAY_BUFFER;
}

@:fakeEnum(Int)
@:native('WebGLRenderingContext')
extern enum WebGLFramebufferTarget
{
	FRAMEBUFFER;
}

@:fakeEnum(Int)
@:native('WebGLRenderingContext')
extern enum WebGLRenderbufferTarget
{
	RENDERBUFFER;
}

@:fakeEnum(Int)
@:native('WebGLRenderingContext')
extern enum WebGLTextureTarget
{
	TEXTURE_2D;
	TEXTURE_CUBE_MAP;
}

@:fakeEnum(Int)
@:native('WebGLRenderingContext')
extern enum WebGLBlendEquation
{
	FUNC_ADD;
	FUNC_SUBTRACT;
	FUNC_REVERSE_SUBTRACT;
}

//------------------------------------------------------------------------------ blending

@:fakeEnum(Int)
@:native('WebGLRenderingContext')
extern enum WebGLBlendingFactorDest
{
	ZERO;
	ONE;
	SRC_COLOR;
	ONE_MINUS_SRC_COLOR;
	SRC_ALPHA;
	ONE_MINUS_SRC_ALPHA;
	DST_ALPHA;
	ONE_MINUS_DST_ALPHA;
}

@:fakeEnum(Int)
@:native('WebGLRenderingContext')
extern enum WebGLBlendingFactorSrc
{
	// ZERO;
	// ONE;
	DST_COLOR;
	ONE_MINUS_DST_COLOR;
	SRC_ALPHA_SATURATE;
	// SRC_ALPHA;
	// ONE_MINUS_SRC_ALPHA;
	// DST_ALPHA;
	// ONE_MINUS_DST_ALPHA;
}

//------------------------------------------------------------------------------ textures

@:fakeEnum(Int)
@:native('WebGLRenderingContext')
extern enum WebGLTextureUnit
{
	TEXTURE0;
	TEXTURE1;
	TEXTURE2;
	TEXTURE3;
	TEXTURE4;
	TEXTURE5;
	TEXTURE6;
	TEXTURE7;
	TEXTURE8;
	TEXTURE9;
	TEXTURE10;
	TEXTURE11;
	TEXTURE12;
	TEXTURE13;
	TEXTURE14;
	TEXTURE15;
	TEXTURE16;
	TEXTURE17;
	TEXTURE18;
	TEXTURE19;
	TEXTURE20;
	TEXTURE21;
	TEXTURE22;
	TEXTURE23;
	TEXTURE24;
	TEXTURE25;
	TEXTURE26;
	TEXTURE27;
	TEXTURE28;
	TEXTURE29;
	TEXTURE30;
	TEXTURE31;
}

@:fakeEnum(Int)
@:native('WebGLRenderingContext')
extern enum WebGLTextureImageTarget
{
	TEXTURE_2D;
	TEXTURE_CUBE_MAP_POSITIVE_X;
	TEXTURE_CUBE_MAP_NEGATIVE_X;
	TEXTURE_CUBE_MAP_POSITIVE_Y;
	TEXTURE_CUBE_MAP_NEGATIVE_Y;
	TEXTURE_CUBE_MAP_POSITIVE_Z;
	TEXTURE_CUBE_MAP_NEGATIVE_Z;
}

//------------------------------------------------------------------------------ attributes

@:fakeEnum(Int)
@:native('WebGLRenderingContext')
extern enum WebGLVertexAttrib
{
	VERTEX_ATTRIB_ARRAY_ENABLED;
	VERTEX_ATTRIB_ARRAY_SIZE;
	VERTEX_ATTRIB_ARRAY_STRIDE;
	VERTEX_ATTRIB_ARRAY_TYPE;
	VERTEX_ATTRIB_ARRAY_NORMALIZED;
	VERTEX_ATTRIB_ARRAY_POINTER;
	VERTEX_ATTRIB_ARRAY_BUFFER_BINDING;
	CURRENT_VERTEX_ATTRIB;
}

//------------------------------------------------------------------------------ misc

@:fakeEnum(Int)
@:native('WebGLRenderingContext')
extern enum WebGLDrawMode
{
	POINTS;
	LINES;
	LINE_LOOP;
	LINE_STRIP;
	TRIANGLES;
	TRIANGLE_STRIP;
	TRIANGLE_FAN;
}

@:fakeEnum(Int)
@:native('WebGLRenderingContext')
extern enum WebGLFramebufferStatus
{
	FRAMEBUFFER_COMPLETE;
	FRAMEBUFFER_INCOMPLETE_ATTACHMENT;
	FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT;
	FRAMEBUFFER_INCOMPLETE_DIMENSIONS;
	FRAMEBUFFER_UNSUPPORTED;
}

@:fakeEnum(Int)
@:native('WebGLRenderingContext')
extern enum WebGLAttachment
{
	COLOR_ATTACHMENT0;
	DEPTH_ATTACHMENT;
	STENCIL_ATTACHMENT;
	DEPTH_STENCIL_ATTACHMENT;
}

@:fakeEnum(Int)
@:native('WebGLRenderingContext')
extern enum WebGLInternalFormat
{
	RGBA4;
	RGB5_A1;
	RGB565;
	DEPTH_COMPONENT16;
	STENCIL_INDEX;
	STENCIL_INDEX8;
	DEPTH_STENCIL;
}

@:fakeEnum(Int)
@:native('WebGLRenderingContext')
extern enum WebGLDataType
{
	BYTE;
	UNSIGNED_BYTE;
	SHORT;
	UNSIGNED_SHORT;
	INT;
	UNSIGNED_INT;
	FLOAT;
}

@:fakeEnum(Int)
@:native('WebGLRenderingContext')
extern enum WebGLShaderPrecisionType
{
	LOW_FLOAT;
	MEDIUM_FLOAT;
	HIGH_FLOAT;
	LOW_INT;
	MEDIUM_INT;
	HIGH_INT;
}

@:fakeEnum(Int)
@:native('WebGLRenderingContext')
extern enum WebGLDepthFunction
{
	NEVER;
	LESS;
	EQUAL;
	LEQUAL;
	GREATER;
	NOTEQUAL;
	GEQUAL;
	ALWAYS;
}

@:fakeEnum(Int)
@:native('WebGLRenderingContext')
extern enum WebGLUniformType
{
	FLOAT_VEC2;
	FLOAT_VEC3;
	FLOAT_VEC4;
	INT_VEC2;
	INT_VEC3;
	INT_VEC4;
	BOOL;
	BOOL_VEC2;
	BOOL_VEC3;
	BOOL_VEC4;
	FLOAT_MAT2;
	FLOAT_MAT3;
	FLOAT_MAT4;
	SAMPLER_2D;
	SAMPLER_CUBE;
}

@:fakeEnum(Int)
@:native('WebGLRenderingContext')
extern enum WebGLShaderType
{
	FRAGMENT_SHADER;
	VERTEX_SHADER;
}

@:fakeEnum(Int)
@:native('WebGLRenderingContext')
extern enum WebGLBufferUsage
{
	STREAM_DRAW;
	STATIC_DRAW;
	DYNAMIC_DRAW;
}