Skip to content

Instantly share code, notes, and snippets.

@dpeek

dpeek/gist:4700522

Created February 3, 2013 04:09
Show Gist options
  • Save dpeek/4700522 to your computer and use it in GitHub Desktop.
Save dpeek/4700522 to your computer and use it in GitHub Desktop.
Download ZIP
WebGL enums
Raw
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;
}
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment