Last active
October 3, 2019 08:17
-
-
Save codehz/1dc6ae02dafa547e5a88026b8252cff6 to your computer and use it in GitHub Desktop.
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| declare module 'picogl' { | |
| enum GL { | |
| DEPTH_BUFFER_BIT = 0x00000100, | |
| STENCIL_BUFFER_BIT = 0x00000400, | |
| COLOR_BUFFER_BIT = 0x00004000, | |
| POINTS = 0x0000, | |
| LINES = 0x0001, | |
| LINE_LOOP = 0x0002, | |
| LINE_STRIP = 0x0003, | |
| TRIANGLES = 0x0004, | |
| TRIANGLE_STRIP = 0x0005, | |
| TRIANGLE_FAN = 0x0006, | |
| ZERO = 0, | |
| ONE = 1, | |
| SRC_COLOR = 0x0300, | |
| ONE_MINUS_SRC_COLOR = 0x0301, | |
| SRC_ALPHA = 0x0302, | |
| ONE_MINUS_SRC_ALPHA = 0x0303, | |
| DST_ALPHA = 0x0304, | |
| ONE_MINUS_DST_ALPHA = 0x0305, | |
| DST_COLOR = 0x0306, | |
| ONE_MINUS_DST_COLOR = 0x0307, | |
| SRC_ALPHA_SATURATE = 0x0308, | |
| FUNC_ADD = 0x8006, | |
| BLEND_EQUATION = 0x8009, | |
| BLEND_EQUATION_RGB = 0x8009, | |
| BLEND_EQUATION_ALPHA = 0x883d, | |
| FUNC_SUBTRACT = 0x800a, | |
| FUNC_REVERSE_SUBTRACT = 0x800b, | |
| BLEND_DST_RGB = 0x80c8, | |
| BLEND_SRC_RGB = 0x80c9, | |
| BLEND_DST_ALPHA = 0x80ca, | |
| BLEND_SRC_ALPHA = 0x80cb, | |
| CONSTANT_COLOR = 0x8001, | |
| ONE_MINUS_CONSTANT_COLOR = 0x8002, | |
| CONSTANT_ALPHA = 0x8003, | |
| ONE_MINUS_CONSTANT_ALPHA = 0x8004, | |
| BLEND_COLOR = 0x8005, | |
| ARRAY_BUFFER = 0x8892, | |
| ELEMENT_ARRAY_BUFFER = 0x8893, | |
| ARRAY_BUFFER_BINDING = 0x8894, | |
| ELEMENT_ARRAY_BUFFER_BINDING = 0x8895, | |
| STREAM_DRAW = 0x88e0, | |
| STATIC_DRAW = 0x88e4, | |
| DYNAMIC_DRAW = 0x88e8, | |
| BUFFER_SIZE = 0x8764, | |
| BUFFER_USAGE = 0x8765, | |
| CURRENT_VERTEX_ATTRIB = 0x8626, | |
| FRONT = 0x0404, | |
| BACK = 0x0405, | |
| FRONT_AND_BACK = 0x0408, | |
| CULL_FACE = 0x0b44, | |
| BLEND = 0x0be2, | |
| DITHER = 0x0bd0, | |
| STENCIL_TEST = 0x0b90, | |
| DEPTH_TEST = 0x0b71, | |
| SCISSOR_TEST = 0x0c11, | |
| POLYGON_OFFSET_FILL = 0x8037, | |
| SAMPLE_ALPHA_TO_COVERAGE = 0x809e, | |
| SAMPLE_COVERAGE = 0x80a0, | |
| NO_ERROR = 0, | |
| INVALID_ENUM = 0x0500, | |
| INVALID_VALUE = 0x0501, | |
| INVALID_OPERATION = 0x0502, | |
| OUT_OF_MEMORY = 0x0505, | |
| CW = 0x0900, | |
| CCW = 0x0901, | |
| LINE_WIDTH = 0x0b21, | |
| ALIASED_POINT_SIZE_RANGE = 0x846d, | |
| ALIASED_LINE_WIDTH_RANGE = 0x846e, | |
| CULL_FACE_MODE = 0x0b45, | |
| FRONT_FACE = 0x0b46, | |
| DEPTH_RANGE = 0x0b70, | |
| DEPTH_WRITEMASK = 0x0b72, | |
| DEPTH_CLEAR_VALUE = 0x0b73, | |
| DEPTH_FUNC = 0x0b74, | |
| STENCIL_CLEAR_VALUE = 0x0b91, | |
| STENCIL_FUNC = 0x0b92, | |
| STENCIL_FAIL = 0x0b94, | |
| STENCIL_PASS_DEPTH_FAIL = 0x0b95, | |
| STENCIL_PASS_DEPTH_PASS = 0x0b96, | |
| STENCIL_REF = 0x0b97, | |
| STENCIL_VALUE_MASK = 0x0b93, | |
| STENCIL_WRITEMASK = 0x0b98, | |
| STENCIL_BACK_FUNC = 0x8800, | |
| STENCIL_BACK_FAIL = 0x8801, | |
| STENCIL_BACK_PASS_DEPTH_FAIL = 0x8802, | |
| STENCIL_BACK_PASS_DEPTH_PASS = 0x8803, | |
| STENCIL_BACK_REF = 0x8ca3, | |
| STENCIL_BACK_VALUE_MASK = 0x8ca4, | |
| STENCIL_BACK_WRITEMASK = 0x8ca5, | |
| VIEWPORT = 0x0ba2, | |
| SCISSOR_BOX = 0x0c10, | |
| COLOR_CLEAR_VALUE = 0x0c22, | |
| COLOR_WRITEMASK = 0x0c23, | |
| UNPACK_ALIGNMENT = 0x0cf5, | |
| PACK_ALIGNMENT = 0x0d05, | |
| MAX_TEXTURE_SIZE = 0x0d33, | |
| MAX_VIEWPORT_DIMS = 0x0d3a, | |
| SUBPIXEL_BITS = 0x0d50, | |
| RED_BITS = 0x0d52, | |
| GREEN_BITS = 0x0d53, | |
| BLUE_BITS = 0x0d54, | |
| ALPHA_BITS = 0x0d55, | |
| DEPTH_BITS = 0x0d56, | |
| STENCIL_BITS = 0x0d57, | |
| POLYGON_OFFSET_UNITS = 0x2a00, | |
| POLYGON_OFFSET_FACTOR = 0x8038, | |
| TEXTURE_BINDING_2D = 0x8069, | |
| SAMPLE_BUFFERS = 0x80a8, | |
| SAMPLES = 0x80a9, | |
| SAMPLE_COVERAGE_VALUE = 0x80aa, | |
| SAMPLE_COVERAGE_INVERT = 0x80ab, | |
| COMPRESSED_TEXTURE_FORMATS = 0x86a3, | |
| DONT_CARE = 0x1100, | |
| FASTEST = 0x1101, | |
| NICEST = 0x1102, | |
| GENERATE_MIPMAP_HINT = 0x8192, | |
| BYTE = 0x1400, | |
| UNSIGNED_BYTE = 0x1401, | |
| SHORT = 0x1402, | |
| UNSIGNED_SHORT = 0x1403, | |
| INT = 0x1404, | |
| UNSIGNED_INT = 0x1405, | |
| FLOAT = 0x1406, | |
| DEPTH_COMPONENT = 0x1902, | |
| ALPHA = 0x1906, | |
| RGB = 0x1907, | |
| RGBA = 0x1908, | |
| LUMINANCE = 0x1909, | |
| LUMINANCE_ALPHA = 0x190a, | |
| UNSIGNED_SHORT_4_4_4_4 = 0x8033, | |
| UNSIGNED_SHORT_5_5_5_1 = 0x8034, | |
| UNSIGNED_SHORT_5_6_5 = 0x8363, | |
| FRAGMENT_SHADER = 0x8b30, | |
| VERTEX_SHADER = 0x8b31, | |
| MAX_VERTEX_ATTRIBS = 0x8869, | |
| MAX_VERTEX_UNIFORM_VECTORS = 0x8dfb, | |
| MAX_VARYING_VECTORS = 0x8dfc, | |
| MAX_COMBINED_TEXTURE_IMAGE_UNITS = 0x8b4d, | |
| MAX_VERTEX_TEXTURE_IMAGE_UNITS = 0x8b4c, | |
| MAX_TEXTURE_IMAGE_UNITS = 0x8872, | |
| MAX_FRAGMENT_UNIFORM_VECTORS = 0x8dfd, | |
| SHADER_TYPE = 0x8b4f, | |
| DELETE_STATUS = 0x8b80, | |
| LINK_STATUS = 0x8b82, | |
| VALIDATE_STATUS = 0x8b83, | |
| ATTACHED_SHADERS = 0x8b85, | |
| ACTIVE_UNIFORMS = 0x8b86, | |
| ACTIVE_ATTRIBUTES = 0x8b89, | |
| SHADING_LANGUAGE_VERSION = 0x8b8c, | |
| CURRENT_PROGRAM = 0x8b8d, | |
| NEVER = 0x0200, | |
| LESS = 0x0201, | |
| EQUAL = 0x0202, | |
| LEQUAL = 0x0203, | |
| GREATER = 0x0204, | |
| NOTEQUAL = 0x0205, | |
| GEQUAL = 0x0206, | |
| ALWAYS = 0x0207, | |
| KEEP = 0x1e00, | |
| REPLACE = 0x1e01, | |
| INCR = 0x1e02, | |
| DECR = 0x1e03, | |
| INVERT = 0x150a, | |
| INCR_WRAP = 0x8507, | |
| DECR_WRAP = 0x8508, | |
| VENDOR = 0x1f00, | |
| RENDERER = 0x1f01, | |
| VERSION = 0x1f02, | |
| NEAREST = 0x2600, | |
| LINEAR = 0x2601, | |
| NEAREST_MIPMAP_NEAREST = 0x2700, | |
| LINEAR_MIPMAP_NEAREST = 0x2701, | |
| NEAREST_MIPMAP_LINEAR = 0x2702, | |
| LINEAR_MIPMAP_LINEAR = 0x2703, | |
| TEXTURE_MAG_FILTER = 0x2800, | |
| TEXTURE_MIN_FILTER = 0x2801, | |
| TEXTURE_WRAP_S = 0x2802, | |
| TEXTURE_WRAP_T = 0x2803, | |
| TEXTURE_2D = 0x0de1, | |
| TEXTURE = 0x1702, | |
| TEXTURE_CUBE_MAP = 0x8513, | |
| TEXTURE_BINDING_CUBE_MAP = 0x8514, | |
| TEXTURE_CUBE_MAP_POSITIVE_X = 0x8515, | |
| TEXTURE_CUBE_MAP_NEGATIVE_X = 0x8516, | |
| TEXTURE_CUBE_MAP_POSITIVE_Y = 0x8517, | |
| TEXTURE_CUBE_MAP_NEGATIVE_Y = 0x8518, | |
| TEXTURE_CUBE_MAP_POSITIVE_Z = 0x8519, | |
| TEXTURE_CUBE_MAP_NEGATIVE_Z = 0x851a, | |
| MAX_CUBE_MAP_TEXTURE_SIZE = 0x851c, | |
| TEXTURE0 = 0x84c0, | |
| TEXTURE1 = 0x84c1, | |
| TEXTURE2 = 0x84c2, | |
| TEXTURE3 = 0x84c3, | |
| TEXTURE4 = 0x84c4, | |
| TEXTURE5 = 0x84c5, | |
| TEXTURE6 = 0x84c6, | |
| TEXTURE7 = 0x84c7, | |
| TEXTURE8 = 0x84c8, | |
| TEXTURE9 = 0x84c9, | |
| TEXTURE10 = 0x84ca, | |
| TEXTURE11 = 0x84cb, | |
| TEXTURE12 = 0x84cc, | |
| TEXTURE13 = 0x84cd, | |
| TEXTURE14 = 0x84ce, | |
| TEXTURE15 = 0x84cf, | |
| TEXTURE16 = 0x84d0, | |
| TEXTURE17 = 0x84d1, | |
| TEXTURE18 = 0x84d2, | |
| TEXTURE19 = 0x84d3, | |
| TEXTURE20 = 0x84d4, | |
| TEXTURE21 = 0x84d5, | |
| TEXTURE22 = 0x84d6, | |
| TEXTURE23 = 0x84d7, | |
| TEXTURE24 = 0x84d8, | |
| TEXTURE25 = 0x84d9, | |
| TEXTURE26 = 0x84da, | |
| TEXTURE27 = 0x84db, | |
| TEXTURE28 = 0x84dc, | |
| TEXTURE29 = 0x84dd, | |
| TEXTURE30 = 0x84de, | |
| TEXTURE31 = 0x84df, | |
| ACTIVE_TEXTURE = 0x84e0, | |
| REPEAT = 0x2901, | |
| CLAMP_TO_EDGE = 0x812f, | |
| MIRRORED_REPEAT = 0x8370, | |
| FLOAT_VEC2 = 0x8b50, | |
| FLOAT_VEC3 = 0x8b51, | |
| FLOAT_VEC4 = 0x8b52, | |
| INT_VEC2 = 0x8b53, | |
| INT_VEC3 = 0x8b54, | |
| INT_VEC4 = 0x8b55, | |
| BOOL = 0x8b56, | |
| BOOL_VEC2 = 0x8b57, | |
| BOOL_VEC3 = 0x8b58, | |
| BOOL_VEC4 = 0x8b59, | |
| FLOAT_MAT2 = 0x8b5a, | |
| FLOAT_MAT3 = 0x8b5b, | |
| FLOAT_MAT4 = 0x8b5c, | |
| SAMPLER_2D = 0x8b5e, | |
| SAMPLER_CUBE = 0x8b60, | |
| VERTEX_ATTRIB_ARRAY_ENABLED = 0x8622, | |
| VERTEX_ATTRIB_ARRAY_SIZE = 0x8623, | |
| VERTEX_ATTRIB_ARRAY_STRIDE = 0x8624, | |
| VERTEX_ATTRIB_ARRAY_TYPE = 0x8625, | |
| VERTEX_ATTRIB_ARRAY_NORMALIZED = 0x886a, | |
| VERTEX_ATTRIB_ARRAY_POINTER = 0x8645, | |
| VERTEX_ATTRIB_ARRAY_BUFFER_BINDING = 0x889f, | |
| IMPLEMENTATION_COLOR_READ_TYPE = 0x8b9a, | |
| IMPLEMENTATION_COLOR_READ_FORMAT = 0x8b9b, | |
| COMPILE_STATUS = 0x8b81, | |
| LOW_FLOAT = 0x8df0, | |
| MEDIUM_FLOAT = 0x8df1, | |
| HIGH_FLOAT = 0x8df2, | |
| LOW_INT = 0x8df3, | |
| MEDIUM_INT = 0x8df4, | |
| HIGH_INT = 0x8df5, | |
| FRAMEBUFFER = 0x8d40, | |
| RENDERBUFFER = 0x8d41, | |
| RGBA4 = 0x8056, | |
| RGB5_A1 = 0x8057, | |
| RGB565 = 0x8d62, | |
| DEPTH_COMPONENT16 = 0x81a5, | |
| STENCIL_INDEX = 0x1901, | |
| STENCIL_INDEX8 = 0x8d48, | |
| DEPTH_STENCIL = 0x84f9, | |
| RENDERBUFFER_WIDTH = 0x8d42, | |
| RENDERBUFFER_HEIGHT = 0x8d43, | |
| RENDERBUFFER_INTERNAL_FORMAT = 0x8d44, | |
| RENDERBUFFER_RED_SIZE = 0x8d50, | |
| RENDERBUFFER_GREEN_SIZE = 0x8d51, | |
| RENDERBUFFER_BLUE_SIZE = 0x8d52, | |
| RENDERBUFFER_ALPHA_SIZE = 0x8d53, | |
| RENDERBUFFER_DEPTH_SIZE = 0x8d54, | |
| RENDERBUFFER_STENCIL_SIZE = 0x8d55, | |
| FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE = 0x8cd0, | |
| FRAMEBUFFER_ATTACHMENT_OBJECT_NAME = 0x8cd1, | |
| FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL = 0x8cd2, | |
| FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE = 0x8cd3, | |
| COLOR_ATTACHMENT0 = 0x8ce0, | |
| DEPTH_ATTACHMENT = 0x8d00, | |
| STENCIL_ATTACHMENT = 0x8d20, | |
| DEPTH_STENCIL_ATTACHMENT = 0x821a, | |
| NONE = 0, | |
| FRAMEBUFFER_COMPLETE = 0x8cd5, | |
| FRAMEBUFFER_INCOMPLETE_ATTACHMENT = 0x8cd6, | |
| FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT = 0x8cd7, | |
| FRAMEBUFFER_INCOMPLETE_DIMENSIONS = 0x8cd9, | |
| FRAMEBUFFER_UNSUPPORTED = 0x8cdd, | |
| FRAMEBUFFER_BINDING = 0x8ca6, | |
| RENDERBUFFER_BINDING = 0x8ca7, | |
| MAX_RENDERBUFFER_SIZE = 0x84e8, | |
| INVALID_FRAMEBUFFER_OPERATION = 0x0506, | |
| UNPACK_FLIP_Y_WEBGL = 0x9240, | |
| UNPACK_PREMULTIPLY_ALPHA_WEBGL = 0x9241, | |
| CONTEXT_LOST_WEBGL = 0x9242, | |
| UNPACK_COLORSPACE_CONVERSION_WEBGL = 0x9243, | |
| BROWSER_DEFAULT_WEBGL = 0x9244, | |
| READ_BUFFER = 0x0c02, | |
| UNPACK_ROW_LENGTH = 0x0cf2, | |
| UNPACK_SKIP_ROWS = 0x0cf3, | |
| UNPACK_SKIP_PIXELS = 0x0cf4, | |
| PACK_ROW_LENGTH = 0x0d02, | |
| PACK_SKIP_ROWS = 0x0d03, | |
| PACK_SKIP_PIXELS = 0x0d04, | |
| COLOR = 0x1800, | |
| DEPTH = 0x1801, | |
| STENCIL = 0x1802, | |
| RED = 0x1903, | |
| RGB8 = 0x8051, | |
| RGBA8 = 0x8058, | |
| RGB10_A2 = 0x8059, | |
| TEXTURE_BINDING_3D = 0x806a, | |
| UNPACK_SKIP_IMAGES = 0x806d, | |
| UNPACK_IMAGE_HEIGHT = 0x806e, | |
| TEXTURE_3D = 0x806f, | |
| TEXTURE_WRAP_R = 0x8072, | |
| MAX_3D_TEXTURE_SIZE = 0x8073, | |
| UNSIGNED_INT_2_10_10_10_REV = 0x8368, | |
| MAX_ELEMENTS_VERTICES = 0x80e8, | |
| MAX_ELEMENTS_INDICES = 0x80e9, | |
| TEXTURE_MIN_LOD = 0x813a, | |
| TEXTURE_MAX_LOD = 0x813b, | |
| TEXTURE_BASE_LEVEL = 0x813c, | |
| TEXTURE_MAX_LEVEL = 0x813d, | |
| MIN = 0x8007, | |
| MAX = 0x8008, | |
| DEPTH_COMPONENT24 = 0x81a6, | |
| MAX_TEXTURE_LOD_BIAS = 0x84fd, | |
| TEXTURE_COMPARE_MODE = 0x884c, | |
| TEXTURE_COMPARE_FUNC = 0x884d, | |
| CURRENT_QUERY = 0x8865, | |
| QUERY_RESULT = 0x8866, | |
| QUERY_RESULT_AVAILABLE = 0x8867, | |
| STREAM_READ = 0x88e1, | |
| STREAM_COPY = 0x88e2, | |
| STATIC_READ = 0x88e5, | |
| STATIC_COPY = 0x88e6, | |
| DYNAMIC_READ = 0x88e9, | |
| DYNAMIC_COPY = 0x88ea, | |
| MAX_DRAW_BUFFERS = 0x8824, | |
| DRAW_BUFFER0 = 0x8825, | |
| DRAW_BUFFER1 = 0x8826, | |
| DRAW_BUFFER2 = 0x8827, | |
| DRAW_BUFFER3 = 0x8828, | |
| DRAW_BUFFER4 = 0x8829, | |
| DRAW_BUFFER5 = 0x882a, | |
| DRAW_BUFFER6 = 0x882b, | |
| DRAW_BUFFER7 = 0x882c, | |
| DRAW_BUFFER8 = 0x882d, | |
| DRAW_BUFFER9 = 0x882e, | |
| DRAW_BUFFER10 = 0x882f, | |
| DRAW_BUFFER11 = 0x8830, | |
| DRAW_BUFFER12 = 0x8831, | |
| DRAW_BUFFER13 = 0x8832, | |
| DRAW_BUFFER14 = 0x8833, | |
| DRAW_BUFFER15 = 0x8834, | |
| MAX_FRAGMENT_UNIFORM_COMPONENTS = 0x8b49, | |
| MAX_VERTEX_UNIFORM_COMPONENTS = 0x8b4a, | |
| SAMPLER_3D = 0x8b5f, | |
| SAMPLER_2D_SHADOW = 0x8b62, | |
| FRAGMENT_SHADER_DERIVATIVE_HINT = 0x8b8b, | |
| PIXEL_PACK_BUFFER = 0x88eb, | |
| PIXEL_UNPACK_BUFFER = 0x88ec, | |
| PIXEL_PACK_BUFFER_BINDING = 0x88ed, | |
| PIXEL_UNPACK_BUFFER_BINDING = 0x88ef, | |
| FLOAT_MAT2x3 = 0x8b65, | |
| FLOAT_MAT2x4 = 0x8b66, | |
| FLOAT_MAT3x2 = 0x8b67, | |
| FLOAT_MAT3x4 = 0x8b68, | |
| FLOAT_MAT4x2 = 0x8b69, | |
| FLOAT_MAT4x3 = 0x8b6a, | |
| SRGB = 0x8c40, | |
| SRGB8 = 0x8c41, | |
| SRGB8_ALPHA8 = 0x8c43, | |
| COMPARE_REF_TO_TEXTURE = 0x884e, | |
| RGBA32F = 0x8814, | |
| RGB32F = 0x8815, | |
| RGBA16F = 0x881a, | |
| RGB16F = 0x881b, | |
| VERTEX_ATTRIB_ARRAY_INTEGER = 0x88fd, | |
| MAX_ARRAY_TEXTURE_LAYERS = 0x88ff, | |
| MIN_PROGRAM_TEXEL_OFFSET = 0x8904, | |
| MAX_PROGRAM_TEXEL_OFFSET = 0x8905, | |
| MAX_VARYING_COMPONENTS = 0x8b4b, | |
| TEXTURE_2D_ARRAY = 0x8c1a, | |
| TEXTURE_BINDING_2D_ARRAY = 0x8c1d, | |
| R11F_G11F_B10F = 0x8c3a, | |
| UNSIGNED_INT_10F_11F_11F_REV = 0x8c3b, | |
| RGB9_E5 = 0x8c3d, | |
| UNSIGNED_INT_5_9_9_9_REV = 0x8c3e, | |
| TRANSFORM_FEEDBACK_BUFFER_MODE = 0x8c7f, | |
| MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS = 0x8c80, | |
| TRANSFORM_FEEDBACK_VARYINGS = 0x8c83, | |
| TRANSFORM_FEEDBACK_BUFFER_START = 0x8c84, | |
| TRANSFORM_FEEDBACK_BUFFER_SIZE = 0x8c85, | |
| TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN = 0x8c88, | |
| RASTERIZER_DISCARD = 0x8c89, | |
| MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS = 0x8c8a, | |
| MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS = 0x8c8b, | |
| INTERLEAVED_ATTRIBS = 0x8c8c, | |
| SEPARATE_ATTRIBS = 0x8c8d, | |
| TRANSFORM_FEEDBACK_BUFFER = 0x8c8e, | |
| TRANSFORM_FEEDBACK_BUFFER_BINDING = 0x8c8f, | |
| RGBA32UI = 0x8d70, | |
| RGB32UI = 0x8d71, | |
| RGBA16UI = 0x8d76, | |
| RGB16UI = 0x8d77, | |
| RGBA8UI = 0x8d7c, | |
| RGB8UI = 0x8d7d, | |
| RGBA32I = 0x8d82, | |
| RGB32I = 0x8d83, | |
| RGBA16I = 0x8d88, | |
| RGB16I = 0x8d89, | |
| RGBA8I = 0x8d8e, | |
| RGB8I = 0x8d8f, | |
| RED_INTEGER = 0x8d94, | |
| RGB_INTEGER = 0x8d98, | |
| RGBA_INTEGER = 0x8d99, | |
| SAMPLER_2D_ARRAY = 0x8dc1, | |
| SAMPLER_2D_ARRAY_SHADOW = 0x8dc4, | |
| SAMPLER_CUBE_SHADOW = 0x8dc5, | |
| UNSIGNED_INT_VEC2 = 0x8dc6, | |
| UNSIGNED_INT_VEC3 = 0x8dc7, | |
| UNSIGNED_INT_VEC4 = 0x8dc8, | |
| INT_SAMPLER_2D = 0x8dca, | |
| INT_SAMPLER_3D = 0x8dcb, | |
| INT_SAMPLER_CUBE = 0x8dcc, | |
| INT_SAMPLER_2D_ARRAY = 0x8dcf, | |
| UNSIGNED_INT_SAMPLER_2D = 0x8dd2, | |
| UNSIGNED_INT_SAMPLER_3D = 0x8dd3, | |
| UNSIGNED_INT_SAMPLER_CUBE = 0x8dd4, | |
| UNSIGNED_INT_SAMPLER_2D_ARRAY = 0x8dd7, | |
| DEPTH_COMPONENT32F = 0x8cac, | |
| DEPTH32F_STENCIL8 = 0x8cad, | |
| FLOAT_32_UNSIGNED_INT_24_8_REV = 0x8dad, | |
| FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING = 0x8210, | |
| FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE = 0x8211, | |
| FRAMEBUFFER_ATTACHMENT_RED_SIZE = 0x8212, | |
| FRAMEBUFFER_ATTACHMENT_GREEN_SIZE = 0x8213, | |
| FRAMEBUFFER_ATTACHMENT_BLUE_SIZE = 0x8214, | |
| FRAMEBUFFER_ATTACHMENT_ALPHA_SIZE = 0x8215, | |
| FRAMEBUFFER_ATTACHMENT_DEPTH_SIZE = 0x8216, | |
| FRAMEBUFFER_ATTACHMENT_STENCIL_SIZE = 0x8217, | |
| FRAMEBUFFER_DEFAULT = 0x8218, | |
| UNSIGNED_INT_24_8 = 0x84fa, | |
| DEPTH24_STENCIL8 = 0x88f0, | |
| UNSIGNED_NORMALIZED = 0x8c17, | |
| DRAW_FRAMEBUFFER_BINDING = 0x8ca6, | |
| READ_FRAMEBUFFER = 0x8ca8, | |
| DRAW_FRAMEBUFFER = 0x8ca9, | |
| READ_FRAMEBUFFER_BINDING = 0x8caa, | |
| RENDERBUFFER_SAMPLES = 0x8cab, | |
| FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER = 0x8cd4, | |
| MAX_COLOR_ATTACHMENTS = 0x8cdf, | |
| COLOR_ATTACHMENT1 = 0x8ce1, | |
| COLOR_ATTACHMENT2 = 0x8ce2, | |
| COLOR_ATTACHMENT3 = 0x8ce3, | |
| COLOR_ATTACHMENT4 = 0x8ce4, | |
| COLOR_ATTACHMENT5 = 0x8ce5, | |
| COLOR_ATTACHMENT6 = 0x8ce6, | |
| COLOR_ATTACHMENT7 = 0x8ce7, | |
| COLOR_ATTACHMENT8 = 0x8ce8, | |
| COLOR_ATTACHMENT9 = 0x8ce9, | |
| COLOR_ATTACHMENT10 = 0x8cea, | |
| COLOR_ATTACHMENT11 = 0x8ceb, | |
| COLOR_ATTACHMENT12 = 0x8cec, | |
| COLOR_ATTACHMENT13 = 0x8ced, | |
| COLOR_ATTACHMENT14 = 0x8cee, | |
| COLOR_ATTACHMENT15 = 0x8cef, | |
| FRAMEBUFFER_INCOMPLETE_MULTISAMPLE = 0x8d56, | |
| MAX_SAMPLES = 0x8d57, | |
| HALF_FLOAT = 0x140b, | |
| RG = 0x8227, | |
| RG_INTEGER = 0x8228, | |
| R8 = 0x8229, | |
| RG8 = 0x822b, | |
| R16F = 0x822d, | |
| R32F = 0x822e, | |
| RG16F = 0x822f, | |
| RG32F = 0x8230, | |
| R8I = 0x8231, | |
| R8UI = 0x8232, | |
| R16I = 0x8233, | |
| R16UI = 0x8234, | |
| R32I = 0x8235, | |
| R32UI = 0x8236, | |
| RG8I = 0x8237, | |
| RG8UI = 0x8238, | |
| RG16I = 0x8239, | |
| RG16UI = 0x823a, | |
| RG32I = 0x823b, | |
| RG32UI = 0x823c, | |
| VERTEX_ARRAY_BINDING = 0x85b5, | |
| R8_SNORM = 0x8f94, | |
| RG8_SNORM = 0x8f95, | |
| RGB8_SNORM = 0x8f96, | |
| RGBA8_SNORM = 0x8f97, | |
| SIGNED_NORMALIZED = 0x8f9c, | |
| COPY_READ_BUFFER = 0x8f36, | |
| COPY_WRITE_BUFFER = 0x8f37, | |
| COPY_READ_BUFFER_BINDING = 0x8f36, | |
| COPY_WRITE_BUFFER_BINDING = 0x8f37, | |
| UNIFORM_BUFFER = 0x8a11, | |
| UNIFORM_BUFFER_BINDING = 0x8a28, | |
| UNIFORM_BUFFER_START = 0x8a29, | |
| UNIFORM_BUFFER_SIZE = 0x8a2a, | |
| MAX_VERTEX_UNIFORM_BLOCKS = 0x8a2b, | |
| MAX_FRAGMENT_UNIFORM_BLOCKS = 0x8a2d, | |
| MAX_COMBINED_UNIFORM_BLOCKS = 0x8a2e, | |
| MAX_UNIFORM_BUFFER_BINDINGS = 0x8a2f, | |
| MAX_UNIFORM_BLOCK_SIZE = 0x8a30, | |
| MAX_COMBINED_VERTEX_UNIFORM_COMPONENTS = 0x8a31, | |
| MAX_COMBINED_FRAGMENT_UNIFORM_COMPONENTS = 0x8a33, | |
| UNIFORM_BUFFER_OFFSET_ALIGNMENT = 0x8a34, | |
| ACTIVE_UNIFORM_BLOCKS = 0x8a36, | |
| UNIFORM_TYPE = 0x8a37, | |
| UNIFORM_SIZE = 0x8a38, | |
| UNIFORM_BLOCK_INDEX = 0x8a3a, | |
| UNIFORM_OFFSET = 0x8a3b, | |
| UNIFORM_ARRAY_STRIDE = 0x8a3c, | |
| UNIFORM_MATRIX_STRIDE = 0x8a3d, | |
| UNIFORM_IS_ROW_MAJOR = 0x8a3e, | |
| UNIFORM_BLOCK_BINDING = 0x8a3f, | |
| UNIFORM_BLOCK_DATA_SIZE = 0x8a40, | |
| UNIFORM_BLOCK_ACTIVE_UNIFORMS = 0x8a42, | |
| UNIFORM_BLOCK_ACTIVE_UNIFORM_INDICES = 0x8a43, | |
| UNIFORM_BLOCK_REFERENCED_BY_VERTEX_SHADER = 0x8a44, | |
| UNIFORM_BLOCK_REFERENCED_BY_FRAGMENT_SHADER = 0x8a46, | |
| INVALID_INDEX = 0xffffffff, | |
| MAX_VERTEX_OUTPUT_COMPONENTS = 0x9122, | |
| MAX_FRAGMENT_INPUT_COMPONENTS = 0x9125, | |
| MAX_SERVER_WAIT_TIMEOUT = 0x9111, | |
| OBJECT_TYPE = 0x9112, | |
| SYNC_CONDITION = 0x9113, | |
| SYNC_STATUS = 0x9114, | |
| SYNC_FLAGS = 0x9115, | |
| SYNC_FENCE = 0x9116, | |
| SYNC_GPU_COMMANDS_COMPLETE = 0x9117, | |
| UNSIGNALED = 0x9118, | |
| SIGNALED = 0x9119, | |
| ALREADY_SIGNALED = 0x911a, | |
| TIMEOUT_EXPIRED = 0x911b, | |
| CONDITION_SATISFIED = 0x911c, | |
| WAIT_FAILED = 0x911d, | |
| SYNC_FLUSH_COMMANDS_BIT = 0x00000001, | |
| VERTEX_ATTRIB_ARRAY_DIVISOR = 0x88fe, | |
| ANY_SAMPLES_PASSED = 0x8c2f, | |
| ANY_SAMPLES_PASSED_CONSERVATIVE = 0x8d6a, | |
| SAMPLER_BINDING = 0x8919, | |
| RGB10_A2UI = 0x906f, | |
| INT_2_10_10_10_REV = 0x8d9f, | |
| TRANSFORM_FEEDBACK = 0x8e22, | |
| TRANSFORM_FEEDBACK_PAUSED = 0x8e23, | |
| TRANSFORM_FEEDBACK_ACTIVE = 0x8e24, | |
| TRANSFORM_FEEDBACK_BINDING = 0x8e25, | |
| TEXTURE_IMMUTABLE_FORMAT = 0x912f, | |
| MAX_ELEMENT_INDEX = 0x8d6b, | |
| TEXTURE_IMMUTABLE_LEVELS = 0x82df, | |
| TIMEOUT_IGNORED = -1, | |
| MAX_CLIENT_WAIT_TIMEOUT_WEBGL = 0x9247, | |
| QUERY_COUNTER_BITS_EXT = 0x8864, | |
| TIME_ELAPSED_EXT = 0x88bf, | |
| TIMESTAMP_EXT = 0x8e28, | |
| GPU_DISJOINT_EXT = 0x8fbb, | |
| TEXTURE_MAX_ANISOTROPY_EXT = 0x84fe, | |
| MAX_TEXTURE_MAX_ANISOTROPY_EXT = 0x84ff, | |
| UNMASKED_VENDOR_WEBGL = 0x9245, | |
| UNMASKED_RENDERER_WEBGL = 0x9246, | |
| COMPLETION_STATUS_KHR = 0x91b1, | |
| COMPRESSED_RGB_S3TC_DXT1_EXT = 0x83f0, | |
| COMPRESSED_RGBA_S3TC_DXT1_EXT = 0x83f1, | |
| COMPRESSED_RGBA_S3TC_DXT3_EXT = 0x83f2, | |
| COMPRESSED_RGBA_S3TC_DXT5_EXT = 0x83f3, | |
| COMPRESSED_SRGB_S3TC_DXT1_EXT = 0x8c4c, | |
| COMPRESSED_SRGB_ALPHA_S3TC_DXT1_EXT = 0x8c4d, | |
| COMPRESSED_SRGB_ALPHA_S3TC_DXT3_EXT = 0x8c4e, | |
| COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT = 0x8c4f, | |
| COMPRESSED_R11_EAC = 0x9270, | |
| COMPRESSED_SIGNED_R11_EAC = 0x9271, | |
| COMPRESSED_RG11_EAC = 0x9272, | |
| COMPRESSED_SIGNED_RG11_EAC = 0x9273, | |
| COMPRESSED_RGB8_ETC2 = 0x9274, | |
| COMPRESSED_SRGB8_ETC2 = 0x9275, | |
| COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2 = 0x9276, | |
| COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2 = 0x9277, | |
| COMPRESSED_RGBA8_ETC2_EAC = 0x9278, | |
| COMPRESSED_SRGB8_ALPHA8_ETC2_EAC = 0x9279, | |
| COMPRESSED_RGB_PVRTC_4BPPV1_IMG = 0x8c00, | |
| COMPRESSED_RGB_PVRTC_2BPPV1_IMG = 0x8c01, | |
| COMPRESSED_RGBA_PVRTC_4BPPV1_IMG = 0x8c02, | |
| COMPRESSED_RGBA_PVRTC_2BPPV1_IMG = 0x8c03, | |
| COMPRESSED_RGBA_ASTC_4x4_KHR = 0x93b0, | |
| COMPRESSED_RGBA_ASTC_5x4_KHR = 0x93b1, | |
| COMPRESSED_RGBA_ASTC_5x5_KHR = 0x93b2, | |
| COMPRESSED_RGBA_ASTC_6x5_KHR = 0x93b3, | |
| COMPRESSED_RGBA_ASTC_6x6_KHR = 0x93b4, | |
| COMPRESSED_RGBA_ASTC_8x5_KHR = 0x93b5, | |
| COMPRESSED_RGBA_ASTC_8x6_KHR = 0x93b6, | |
| COMPRESSED_RGBA_ASTC_8x8_KHR = 0x93b7, | |
| COMPRESSED_RGBA_ASTC_10x5_KHR = 0x93b8, | |
| COMPRESSED_RGBA_ASTC_10x6_KHR = 0x93b9, | |
| COMPRESSED_RGBA_ASTC_10x8_KHR = 0x93ba, | |
| COMPRESSED_RGBA_ASTC_10x10_KHR = 0x93bb, | |
| COMPRESSED_RGBA_ASTC_12x10_KHR = 0x93bc, | |
| COMPRESSED_RGBA_ASTC_12x12_KHR = 0x93bd, | |
| COMPRESSED_SRGB8_ALPHA8_ASTC_4x4_KHR = 0x93d0, | |
| COMPRESSED_SRGB8_ALPHA8_ASTC_5x4_KHR = 0x93d1, | |
| COMPRESSED_SRGB8_ALPHA8_ASTC_5x5_KHR = 0x93d2, | |
| COMPRESSED_SRGB8_ALPHA8_ASTC_6x5_KHR = 0x93d3, | |
| COMPRESSED_SRGB8_ALPHA8_ASTC_6x6_KHR = 0x93d4, | |
| COMPRESSED_SRGB8_ALPHA8_ASTC_8x5_KHR = 0x93d5, | |
| COMPRESSED_SRGB8_ALPHA8_ASTC_8x6_KHR = 0x93d6, | |
| COMPRESSED_SRGB8_ALPHA8_ASTC_8x8_KHR = 0x93d7, | |
| COMPRESSED_SRGB8_ALPHA8_ASTC_10x5_KHR = 0x93d8, | |
| COMPRESSED_SRGB8_ALPHA8_ASTC_10x6_KHR = 0x93d9, | |
| COMPRESSED_SRGB8_ALPHA8_ASTC_10x8_KHR = 0x93da, | |
| COMPRESSED_SRGB8_ALPHA8_ASTC_10x10_KHR = 0x93db, | |
| COMPRESSED_SRGB8_ALPHA8_ASTC_12x10_KHR = 0x93dc, | |
| COMPRESSED_SRGB8_ALPHA8_ASTC_12x12_KHR = 0x93dd, | |
| } | |
| type WEBGL_INFO = { | |
| MAX_TEXTURE_UNITS: GLint | |
| MAX_UNIFORM_BUFFERS: GLint | |
| MAX_UNIFORMS: GLint | |
| SAMPLES: GLint | |
| VENDOR: string | |
| RENDERER: string | |
| FLOAT_RENDER_TARGETS: boolean | |
| LINEAR_FLOAT_TEXTURES: boolean | |
| S3TC_TEXTURES: boolean | |
| S3TC_SRGB_TEXTURES: boolean | |
| ETC_TEXTURES: boolean | |
| ASTC_TEXTURES: boolean | |
| PVRTC_TEXTURES: boolean | |
| LOSE_CONTEXT: boolean | |
| DEBUG_SHADERS: boolean | |
| GPU_TIMER: boolean | |
| TEXTURE_ANISOTROPY: boolean | |
| MAX_TEXTURE_ANISOTROPY: GLint | |
| DEBUG_RENDERER_INFO: boolean | |
| PARALLEL_SHADER_COMPILE: boolean | |
| MULTI_DRAW_INSTANCED: boolean | |
| } | |
| export const PicoGL: { | |
| readonly version: string | |
| /** Create a PicoGL app. The app is the primary entry point to PicoGL. It stores the canvas, the WebGL context and all WebGL state. */ | |
| createApp(canvas: OffscreenCanvas | HTMLCanvasElement, attributes: WebGLContextAttributes): App | |
| } & Readonly<WEBGL_INFO> & | |
| { | |
| readonly [key in keyof typeof GL]: (typeof GL)[key] | |
| } | |
| export default PicoGL | |
| type GLReadPixelFormat = GL.STENCIL_INDEX | GL.DEPTH_COMPONENT | GL.RED | GL.ALPHA | GL.RGB | GL.RGBA | GL.LUMINANCE | GL.LUMINANCE_ALPHA | |
| type GLInternalFormat = | |
| | GL.R8 | |
| | GL.R8UI | |
| | GL.R8I | |
| | GL.R16UI | |
| | GL.R16I | |
| | GL.R32UI | |
| | GL.R32I | |
| | GL.RG8 | |
| | GL.RG8UI | |
| | GL.RG8I | |
| | GL.RG16UI | |
| | GL.RG16I | |
| | GL.RG32UI | |
| | GL.RG32I | |
| | GL.RGB8 | |
| | GL.RGBA8 | |
| | GL.SRGB8_ALPHA8 | |
| | GL.RGBA4 | |
| | GL.RGB565 | |
| | GL.RGB5_A1 | |
| | GL.RGB10_A2 | |
| | GL.RGBA8UI | |
| | GL.RGBA8I | |
| | GL.RGB10_A2UI | |
| | GL.RGBA16UI | |
| | GL.RGBA16I | |
| | GL.RGBA32I | |
| | GL.RGBA32UI | |
| | GL.DEPTH_COMPONENT16 | |
| | GL.DEPTH_COMPONENT24 | |
| | GL.DEPTH_COMPONENT32F | |
| | GL.DEPTH_STENCIL | |
| | GL.DEPTH24_STENCIL8 | |
| | GL.DEPTH32F_STENCIL8 | |
| | GL.STENCIL_INDEX8 | |
| type GLType = | |
| | GL.UNSIGNED_BYTE | |
| | GL.UNSIGNED_SHORT_5_6_5 | |
| | GL.UNSIGNED_SHORT_4_4_4_4 | |
| | GL.UNSIGNED_SHORT_5_5_5_1 | |
| | GL.FLOAT | |
| | GL.BYTE | |
| | GL.UNSIGNED_INT_2_10_10_10_REV | |
| | GL.HALF_FLOAT | |
| | GL.SHORT | |
| | GL.UNSIGNED_SHORT | |
| | GL.INT | |
| | GL.UNSIGNED_INT | |
| | GL.UNSIGNED_INT_10F_11F_11F_REV | |
| | GL.UNSIGNED_INT_5_9_9_9_REV | |
| type GLMatrixType = | |
| | GL.FLOAT_MAT2 | |
| | GL.FLOAT_MAT2x3 | |
| | GL.FLOAT_MAT2x4 | |
| | GL.FLOAT_MAT3 | |
| | GL.FLOAT_MAT3x2 | |
| | GL.FLOAT_MAT3x4 | |
| | GL.FLOAT_MAT4 | |
| | GL.FLOAT_MAT4x2 | |
| | GL.FLOAT_MAT4x3 | |
| type GLMagFilter = GL.NEAREST | GL.LINEAR | |
| type GLMinFilter = GLMagFilter | GL.NEAREST_MIPMAP_NEAREST | GL.LINEAR_MIPMAP_NEAREST | GL.NEAREST_MIPMAP_LINEAR | GL.LINEAR_MIPMAP_LINEAR | |
| type GLWrap = GL.CLAMP_TO_EDGE | GL.MIRRORED_REPEAT | GL.REPEAT | |
| type GLCompareMode = GL.NONE | GL.COMPARE_REF_TO_TEXTURE | |
| type GLCompareFunc = GL.LEQUAL | GL.GEQUAL | GL.LESS | GL.GREATER | GL.EQUAL | GL.NOTEQUAL | GL.ALWAYS | GL.NEVER | |
| type GLBlend = | |
| | GL.ZERO | |
| | GL.ONE | |
| | GL.SRC_COLOR | |
| | GL.ONE_MINUS_SRC_COLOR | |
| | GL.DST_COLOR | |
| | GL.ONE_MINUS_DST_COLOR | |
| | GL.SRC_ALPHA | |
| | GL.ONE_MINUS_SRC_ALPHA | |
| | GL.DST_ALPHA | |
| | GL.ONE_MINUS_DST_ALPHA | |
| | GL.CONSTANT_COLOR | |
| | GL.ONE_MINUS_CONSTANT_COLOR | |
| | GL.CONSTANT_ALPHA | |
| | GL.ONE_MINUS_CONSTANT_ALPHA | |
| | GL.SRC_ALPHA_SATURATE | |
| type GLFace = GL.FRONT | GL.BACK | GL.FRONT_AND_BACK | |
| type GLStencilOP = GL.KEEP | GL.ZERO | GL.REPLACE | GL.INCR | GL.INCR_WRAP | GL.DECR | GL.DECR_WRAP | GL.INVERT | |
| type GLShaderType = GL.VERTEX_SHADER | GL.FRAGMENT_SHADER | |
| type GLUsage = | |
| | GL.STREAM_DRAW | |
| | GL.STREAM_READ | |
| | GL.STREAM_COPY | |
| | GL.STATIC_DRAW | |
| | GL.STATIC_READ | |
| | GL.STATIC_COPY | |
| | GL.DYNAMIC_DRAW | |
| | GL.DYNAMIC_READ | |
| | GL.DYNAMIC_COPY | |
| type GLQueryType = GL.ANY_SAMPLES_PASSED | GL.ANY_SAMPLES_PASSED_CONSERVATIVE | GL.TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN | |
| type GLTextTarget = | |
| | GL.TEXTURE_2D | |
| | GL.TEXTURE_CUBE_MAP_POSITIVE_X | |
| | GL.TEXTURE_CUBE_MAP_NEGATIVE_X | |
| | GL.TEXTURE_CUBE_MAP_POSITIVE_Y | |
| | GL.TEXTURE_CUBE_MAP_NEGATIVE_Y | |
| | GL.TEXTURE_CUBE_MAP_POSITIVE_Z | |
| | GL.TEXTURE_CUBE_MAP_NEGATIVE_Z | |
| type GLFrameBufferStatus = | |
| | GL.FRAMEBUFFER_COMPLETE | |
| | GL.FRAMEBUFFER_INCOMPLETE_ATTACHMENT | |
| | GL.FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT | |
| | GL.FRAMEBUFFER_INCOMPLETE_DIMENSIONS | |
| | GL.FRAMEBUFFER_UNSUPPORTED | |
| | GL.FRAMEBUFFER_INCOMPLETE_MULTISAMPLE | |
| | GL.RENDERBUFFER_SAMPLES | |
| type GLBinding = GL.ARRAY_BUFFER | GL.ELEMENT_ARRAY_BUFFER | |
| type GLPrimitive = GL.POINTS | GL.LINE_STRIP | GL.LINE_LOOP | GL.LINES | GL.TRIANGLE_STRIP | GL.TRIANGLE_FAN | GL.TRIANGLES | |
| /** Blit options. */ | |
| interface BlitFramebufferOptions { | |
| /** Source start x coordinate. */ | |
| srcStartX?: number | |
| /** Source start y coordinate. */ | |
| srcStartY?: number | |
| /** Source end x coordinate. */ | |
| srcEndX?: number | |
| /** Source end y coordinate. */ | |
| srcEndY?: number | |
| /** Destination start x coordinate. */ | |
| dstStartX?: number | |
| /** Destination start y coordinate. */ | |
| dstStartY?: number | |
| /** Destination end x coordinate. */ | |
| dstEndX?: number | |
| /** Destination end y coordinate. */ | |
| dstEndY?: number | |
| /** Sampling filter. */ | |
| filter?: GLMagFilter | |
| } | |
| interface ReadPixelOptions { | |
| /** Type of data stored in the read framebuffer. */ | |
| type?: GLType | |
| /** Read framebuffer data format. */ | |
| format?: GLReadPixelFormat | |
| } | |
| /** Texture2D options. */ | |
| interface Texture2DOptions { | |
| /** Texture data internal format. Must be a sized format. | |
| * @default PicoGL.RGBA8 | |
| */ | |
| internalFormat?: GLInternalFormat | |
| /** Type of data stored in the texture. Default based on **internalFormat**. */ | |
| type?: GLType | |
| /** Whether the y-axis should be flipped when unpacking the texture. | |
| * @default false | |
| */ | |
| flipY?: boolean | |
| /** Whether the alpha channel should be pre-multiplied when unpacking the texture. | |
| * @default false | |
| */ | |
| premultiplyAlpha?: boolean | |
| /** Minification filter. Defaults to LINEAR_MIPMAP_NEAREST if image data is provided, NEAREST otherwise. */ | |
| minFilter?: GLMinFilter | |
| /** Magnification filter. Defaults to LINEAR if image data is provided, NEAREST otherwise. */ | |
| magFilter?: GLMagFilter | |
| /** Horizontal wrap mode. | |
| * @default PicoGL.REPEAT | |
| */ | |
| wrapS?: GLWrap | |
| /** Vertical wrap mode. | |
| * @default PicoGL.REPEAT | |
| */ | |
| wrapT?: GLWrap | |
| /** Comparison mode. | |
| * @default PicoGL.NONE | |
| */ | |
| compareMode?: GLCompareMode | |
| /** Comparison function. | |
| * @default PicoGL.LEQUAL | |
| */ | |
| compareFunc?: GLCompareFunc | |
| /** Base mipmap level. */ | |
| baseLevel?: GLint | |
| /** Maximum mipmap level. */ | |
| maxLevel?: GLint | |
| /** Mimimum level of detail. */ | |
| minLOD?: GLfloat | |
| /** Maximum level of detail. */ | |
| maxLOD?: GLfloat | |
| /** Maximum anisotropy in filtering. */ | |
| maxAnisotropy?: GLfloat | |
| } | |
| interface Texture3DOptions extends Texture2DOptions { | |
| /** Depth wrap mode. | |
| * @default PicoGL.REPEAT | |
| */ | |
| wrapR?: GLWrap | |
| } | |
| interface CubemapOptions extends Texture2DOptions { | |
| /** The image data for the negative X direction. Can be any format that would be accepted by texImage2D. */ | |
| negX: CanvasImageSource | ArrayBufferView | |
| /** The image data for the positive X direction. Can be any format that would be accepted by texImage2D. */ | |
| posX: CanvasImageSource | ArrayBufferView | |
| /** The image data for the negative Y direction. Can be any format that would be accepted by texImage2D. */ | |
| negY: CanvasImageSource | ArrayBufferView | |
| /** The image data for the positive Y direction. Can be any format that would be accepted by texImage2D. */ | |
| posY: CanvasImageSource | ArrayBufferView | |
| /** The image data for the negative Z direction. Can be any format that would be accepted by texImage2D. */ | |
| negZ: CanvasImageSource | ArrayBufferView | |
| /** The image data for the positive Z direction. Can be any format that would be accepted by texImage2D. */ | |
| posZ: CanvasImageSource | ArrayBufferView | |
| /** Cubemap side width. Defaults to the width of negX if negX is an image. */ | |
| width?: number | |
| /** Cubemap side height. Defaults to the height of negX if negX is an image. */ | |
| height?: number | |
| } | |
| /** | |
| Primary entry point to PicoGL. An app will store all parts of the WebGL state. | |
| */ | |
| export interface App { | |
| /** The canvas on which this app drawing. */ | |
| canvas: OffscreenCanvas | HTMLCanvasElement | |
| /** The WebGL context. */ | |
| gl: WebGL2RenderingContext | |
| /** The width of the drawing surface. */ | |
| width: number | |
| /** The height of the drawing surface. */ | |
| height: number | |
| /** Tracked GL state. */ | |
| state: { | |
| // todo | |
| } | |
| /** Current clear mask to use with clear(). */ | |
| clearBits: GLbitfield | |
| /** | |
| * Simulate context loss. | |
| * @method | |
| * @return {App} The App object. | |
| */ | |
| loseContext(): this | |
| /** | |
| * Simulate context restoration. | |
| * @method | |
| * @return {App} The App object. | |
| */ | |
| restoreContext(): this | |
| /** | |
| * Set function to handle context restoration after loss. | |
| * @method | |
| * @param {function} fn Context restored handler. | |
| * @return {App} The App object. | |
| */ | |
| onContextRestored(fn: () => void): this | |
| /** | |
| * Set the color mask to selectively enable or disable particular color channels while rendering. | |
| * @method | |
| * @param {boolean} r Red channel. | |
| * @param {boolean} g Green channel. | |
| * @param {boolean} b Blue channel. | |
| * @param {boolean} a Alpha channel. | |
| * @return {App} The App object. | |
| */ | |
| colorMask(r: number, g: number, b: number, a: number): this | |
| /** | |
| * Set the clear color. | |
| * @method | |
| * @param {number} r Red channel. | |
| * @param {number} g Green channel. | |
| * @param {number} b Blue channel. | |
| * @param {number} a Alpha channel. | |
| * @return {App} The App object. | |
| */ | |
| clearColor(r: number, g: number, b: number, a: number): this | |
| /** | |
| * Set the clear mask bits to use when calling clear(). | |
| * E.g. app.clearMask(PicoGL.COLOR_BUFFER_BIT). | |
| * @method | |
| * @param {GLbitfield} mask Bit mask of buffers to clear. | |
| * @return {App} The App object. | |
| */ | |
| clearMask(mask: GLbitfield): this | |
| /** | |
| * Clear the canvas | |
| * @method | |
| * @return {App} The App object. | |
| */ | |
| clear(): this | |
| /** | |
| * Bind a draw framebuffer to the WebGL context. | |
| * @method | |
| * @param {Framebuffer} framebuffer The Framebuffer object to bind. | |
| * @see Framebuffer | |
| * @return {App} The App object. | |
| */ | |
| drawFramebuffer(framebuffer: Framebuffer): this | |
| /** | |
| * Bind a read framebuffer to the WebGL context. | |
| * @method | |
| * @param {Framebuffer} framebuffer The Framebuffer object to bind. | |
| * @see Framebuffer | |
| * @return {App} The App object. | |
| */ | |
| readFramebuffer(framebuffer: Framebuffer): this | |
| /** | |
| * Switch back to the default framebuffer for drawing (i.e. draw to the screen). | |
| * Note that this method resets the viewport to match the default framebuffer. | |
| * @method | |
| * @return {App} The App object. | |
| */ | |
| defaultDrawFramebuffer(): this | |
| /** | |
| * Switch back to the default framebuffer for reading (i.e. read from the screen). | |
| * @method | |
| * @return {App} The App object. | |
| */ | |
| defaultReadFramebuffer(): this | |
| /** | |
| * Copy data from framebuffer attached to READ_FRAMEBUFFER to framebuffer attached to DRAW_FRAMEBUFFER. | |
| * @method | |
| * @param {GLbitfield} mask Write mask (e.g. PicoGL.COLOR_BUFFER_BIT). | |
| * @param {Object} [options] Blit options. | |
| * @return {App} The App object. | |
| */ | |
| blitFramebuffer(mask: GLbitfield, options?: BlitFramebufferOptions): this | |
| /** | |
| * Set the depth range. | |
| * @method | |
| * @param {number} near Minimum depth value. | |
| * @param {number} far Maximum depth value. | |
| * @return {App} The App object. | |
| */ | |
| depthRange(near: number, far: number): this | |
| /** | |
| * Enable depth testing. | |
| * @method | |
| * @return {App} The App object. | |
| */ | |
| depthTest(): this | |
| /** | |
| * Disable depth testing. | |
| * @method | |
| * @return {App} The App object. | |
| */ | |
| noDepthTest(): this | |
| /** | |
| * Enable or disable writing to the depth buffer. | |
| * @method | |
| * @param {boolean} mask The depth mask. | |
| * @return {App} The App object. | |
| */ | |
| depthMask(mask: boolean): this | |
| /** | |
| * Set the depth test function. E.g. app.depthFunc(PicoGL.LEQUAL). | |
| * @method | |
| * @param {GLCompareFunc} func The depth testing function to use. | |
| * @return {App} The App object. | |
| */ | |
| depthFunc(func: GLCompareFunc): this | |
| /** | |
| * Enable blending. | |
| * @method | |
| * @return {App} The App object. | |
| */ | |
| blend(): this | |
| /** | |
| * Disable blending | |
| * @method | |
| * @return {App} The App object. | |
| */ | |
| noBlend(): this | |
| /** | |
| * Set the blend function. E.g. app.blendFunc(PicoGL.ONE, PicoGL.ONE_MINUS_SRC_ALPHA). | |
| * @method | |
| * @param {GLBlend} src The source blending weight. | |
| * @param {GLBlend} dest The destination blending weight. | |
| * @return {App} The App object. | |
| */ | |
| blendFunc(src: GLBlend, dest: GLBlend): this | |
| /** | |
| * Set the blend function, with separate weighting for color and alpha channels. | |
| * E.g. app.blendFuncSeparate(PicoGL.ONE, PicoGL.ONE_MINUS_SRC_ALPHA, PicoGL.ONE, PicoGL.ONE). | |
| * @method | |
| * @param {GLBlend} csrc The source blending weight for the RGB channels. | |
| * @param {GLBlend} cdest The destination blending weight for the RGB channels. | |
| * @param {GLBlend} asrc The source blending weight for the alpha channel. | |
| * @param {GLBlend} adest The destination blending weight for the alpha channel. | |
| * @return {App} The App object. | |
| */ | |
| blendFuncSeparate(csrc: GLBlend, cdest: GLBlend, asrc: GLBlend, adest: GLBlend): this | |
| /** | |
| * Enable stencil testing. | |
| * NOTE: Only works if { stencil: true } passed as a context attribute when creating the App! | |
| * @method | |
| * @return {App} The App object. | |
| */ | |
| stencilTest(): this | |
| /** | |
| * Disable stencil testing. | |
| * @method | |
| * @return {App} The App object. | |
| */ | |
| noStencilTest(): this | |
| /** | |
| * Enable scissor testing. | |
| * @method | |
| * @return {App} The App object. | |
| */ | |
| scissorTest(): this | |
| /** | |
| * Disable scissor testing. | |
| * @method | |
| * @return {App} The App object. | |
| */ | |
| noScissorTest(): this | |
| /** | |
| * Define the scissor box. | |
| * @method | |
| * @return {App} The App object. | |
| */ | |
| scissor(x: number, y: number, width: number, height: number): this | |
| /** | |
| * Set the bitmask to use for tested stencil values. | |
| * E.g. app.stencilMask(0xFF). | |
| * NOTE: Only works if { stencil: true } passed as a context attribute when creating the App! | |
| * @method | |
| * @param {GLuint} mask The mask value. | |
| * @return {App} The App object. | |
| */ | |
| stencilMask(mask: GLuint): this | |
| /** | |
| * Set the bitmask to use for tested stencil values for a particular face orientation. | |
| * E.g. app.stencilMaskSeparate(PicoGL.FRONT, 0xFF). | |
| * NOTE: Only works if { stencil: true } passed as a context attribute when creating the App! | |
| * @method | |
| * @param {GLFace} face The face orientation to apply the mask to. | |
| * @param {GLuint} mask The mask value. | |
| * @return {App} The App object. | |
| */ | |
| stencilMaskSeparate(face: GLFace, mask: GLuint): this | |
| /** | |
| * Set the stencil function and reference value. | |
| * E.g. app.stencilFunc(PicoGL.EQUAL, 1, 0xFF). | |
| * NOTE: Only works if { stencil: true } passed as a context attribute when creating the App! | |
| * @method | |
| * @param {GLCompareFunc} func The testing function. | |
| * @param {number} ref The reference value. | |
| * @param {GLuint} mask The bitmask to use against tested values before applying | |
| * the stencil function. | |
| * @return {App} The App object. | |
| */ | |
| stencilFunc(func: GLCompareFunc, ref: number, mask: GLuint): this | |
| /** | |
| * Set the stencil function and reference value for a particular face orientation. | |
| * E.g. app.stencilFuncSeparate(PicoGL.FRONT, PicoGL.EQUAL, 1, 0xFF). | |
| * NOTE: Only works if { stencil: true } passed as a context attribute when creating the App! | |
| * @method | |
| * @param {GLFace} face The face orientation to apply the function to. | |
| * @param {GLCompareFunc} func The testing function. | |
| * @param {number} ref The reference value. | |
| * @param {GLuint} mask The bitmask to use against tested values before applying | |
| * the stencil function. | |
| * @return {App} The App object. | |
| */ | |
| stencilFuncSeparate(face: GLFace, func: GLCompareFunc, ref: number, mask: GLuint): this | |
| /** | |
| * Set the operations for updating stencil buffer values. | |
| * E.g. app.stencilOp(PicoGL.KEEP, PicoGL.KEEP, PicoGL.REPLACE). | |
| * NOTE: Only works if { stencil: true } passed as a context attribute when creating the App! | |
| * @method | |
| * @param {GLStencilOP} stencilFail Operation to apply if the stencil test fails. | |
| * @param {GLStencilOP} depthFail Operation to apply if the depth test fails. | |
| * @param {GLStencilOP} pass Operation to apply if the both the depth and stencil tests pass. | |
| * @return {App} The App object. | |
| */ | |
| stencilOp(stencilFail: GLStencilOP, depthFail: GLStencilOP, pass: GLStencilOP): this | |
| /** | |
| * Set the operations for updating stencil buffer values for a particular face orientation. | |
| * E.g. app.stencilOpSeparate(PicoGL.FRONT, PicoGL.KEEP, PicoGL.KEEP, PicoGL.REPLACE). | |
| * NOTE: Only works if { stencil: true } passed as a context attribute when creating the App! | |
| * @method | |
| * @param {GLFace} face The face orientation to apply the operations to. | |
| * @param {GLStencilOP} stencilFail Operation to apply if the stencil test fails. | |
| * @param {GLStencilOP} depthFail Operation to apply if the depth test fails. | |
| * @param {GLStencilOP} pass Operation to apply if the both the depth and stencil tests pass. | |
| * @return {App} The App object. | |
| */ | |
| stencilOpSeparate(face: GLFace, stencilFail: GLStencilOP, depthFail: GLStencilOP, pass: GLStencilOP): this | |
| /** | |
| * Enable rasterization step. | |
| * @method | |
| * @return {App} The App object. | |
| */ | |
| rasterize(): this | |
| /** | |
| * Disable rasterization step. | |
| * @method | |
| * @return {App} The App object. | |
| */ | |
| noRasterize(): this | |
| /** | |
| * Enable backface culling. | |
| * @method | |
| * @return {App} The App object. | |
| */ | |
| cullBackfaces(): this | |
| /** | |
| * Disable backface culling. | |
| * @method | |
| * @return {App} The App object. | |
| */ | |
| drawBackfaces(): this | |
| /** | |
| * Read a pixel's color value from the currently-bound framebuffer. | |
| * @method | |
| * @param {number} x The x coordinate of the pixel. | |
| * @param {number} y The y coordinate of the pixel. | |
| * @param {ArrayBufferView} outColor Typed array to store the pixel's color. | |
| * @param {object} [options] Options. | |
| * @return {App} The App object. | |
| */ | |
| readPixel(x: number, y: number, outColor: ArrayBufferView, options?: ReadPixelOptions): this | |
| /** | |
| * Set the viewport. | |
| * @method | |
| * @param {number} x Left bound of the viewport rectangle. | |
| * @param {number} y Lower bound of the viewport rectangle. | |
| * @param {number} width Width of the viewport rectangle. | |
| * @param {number} height Height of the viewport rectangle. | |
| * @return {App} The App object. | |
| */ | |
| viewport(x: number, y: number, width: number, height: number): this | |
| /** | |
| * Set the viewport to the full canvas. | |
| * @method | |
| * @return {App} The App object. | |
| */ | |
| defaultViewport(): this | |
| /** | |
| * Resize the drawing surface. | |
| * @method | |
| * @param {number} width The new canvas width. | |
| * @param {number} height The new canvas height. | |
| * @return {App} The App object. | |
| */ | |
| resize(width: number, height: number): this | |
| /** | |
| * Create a program synchronously. It is highly recommended to use <b>createPrograms</b> instead as that method will compile shaders in parallel where possible. | |
| * @method | |
| * @param {Shader|string} vertexShader Vertex shader object or source code. | |
| * @param {Shader|string} fragmentShader Fragment shader object or source code. | |
| * @param {Array} [xformFeedbackVars] Transform feedback varyings. | |
| * @return {Program} New Program object. | |
| */ | |
| createProgram(vsSource: Shader | string, fsSource: Shader | string, xformFeedbackVars?: string[]): Program | |
| /** | |
| * Create several programs. Preferred method for program creation as it will compile shaders | |
| * in parallel where possible. | |
| * @method | |
| * @param {...Array} sources Variable number of 2 or 3 element arrays, each containing: | |
| * <ul> | |
| * <li> (Shader|string) Vertex shader object or source code. | |
| * <li> (Shader|string) Fragment shader object or source code. | |
| * <li> (Array - optional) Array of names of transform feedback varyings. | |
| * </ul> | |
| * @return {Promise} Promise that will resolve to an array of Programs when compilation and | |
| * linking are complete for all programs. | |
| */ | |
| createPrograms(...sources: Array<[Shader | string, Shader | string] | [Shader | string, Shader | string, string[]]>): Promise<Program[]> | |
| /** | |
| * Restore several programs after a context loss. Will do so in parallel where available. | |
| * @method | |
| * @param {...Program} sources Variable number of programs to restore. | |
| * @return {Promise} Promise that will resolve once all programs have been restored. | |
| */ | |
| restorePrograms(...programs: Program[]): Promise<void> | |
| /** | |
| * Create a shader. Creating a shader separately from a program allows for | |
| * shader reuse. | |
| * @method | |
| * @param {GLShaderType} type Shader type. | |
| * @param {string} source Shader source. | |
| * @return {Shader} New Shader object. | |
| */ | |
| createShader(type: GLShaderType, source: string): Shader | |
| /** | |
| * Create a vertex array. | |
| * @method | |
| * @return {VertexArray} New VertexArray object. | |
| */ | |
| createVertexArray(): VertexArray | |
| /** | |
| * Create a transform feedback object. | |
| * @method | |
| * @return {TransformFeedback} New TransformFeedback object. | |
| */ | |
| createTransformFeedback(): TransformFeedback | |
| /** | |
| * Create a vertex buffer. | |
| * @method | |
| * @param {GLType} type The data type stored in the vertex buffer. | |
| * @param {number} itemSize Number of elements per vertex. | |
| * @param {ArrayBufferView|number} data Buffer data itself or the total number of elements to be allocated. | |
| * @param {GLUsage} [usage=STATIC_DRAW] Buffer usage. | |
| * @return {VertexBuffer} New VertexBuffer object. | |
| */ | |
| createVertexBuffer(type: GLType, itemSize: number, data: ArrayBufferView | number, usage?: GLUsage): VertexBuffer | |
| /** | |
| * Create a per-vertex matrix buffer. Matrix buffers ensure that columns | |
| * are correctly split across attribute locations. | |
| * @method | |
| * @param {GLMatrixType} type The data type stored in the matrix buffer. Valid types | |
| * are FLOAT_MAT4, FLOAT_MAT4x2, FLOAT_MAT4x3, FLOAT_MAT3, FLOAT_MAT3x2, | |
| * FLOAT_MAT3x4, FLOAT_MAT2, FLOAT_MAT2x3, FLOAT_MAT2x4. | |
| * @param {ArrayBufferView} data Matrix buffer data. | |
| * @param {GLUsage} [usage=STATIC_DRAW] Buffer usage. | |
| * @return {VertexBuffer} New VertexBuffer object. | |
| */ | |
| createMatrixBuffer(type: GLMatrixType, data: ArrayBufferView, usage?: GLUsage): VertexBuffer | |
| /** | |
| * Create an buffer without any structure information. Structure | |
| * must be fully specified when binding to a VertexArray. | |
| * @method | |
| * @param {number} bytesPerVertex Number of bytes per vertex. | |
| * @param {ArrayBufferView|number} data Buffer data itself or the total | |
| * number of bytes to be allocated. | |
| * @param {GLUsage} [usage=STATIC_DRAW] Buffer usage. | |
| * @return {VertexBuffer} New VertexBuffer object. | |
| */ | |
| createInterleavedBuffer(bytesPerVertex: number, data: ArrayBufferView | number, usage?: GLUsage): VertexBuffer | |
| /** | |
| * Create an index buffer. | |
| * @method | |
| * @param {GLType} type The data type stored in the index buffer. | |
| * @param {number} itemSize Number of elements per primitive. | |
| * @param {ArrayBufferView} data Index buffer data. | |
| * @param {GLUsage} [usage=STATIC_DRAW] Buffer usage. | |
| * @return {VertexBuffer} New VertexBuffer object. | |
| */ | |
| createIndexBuffer(type: GLType, itemSize: number, data: ArrayBufferView, usage?: GLUsage): VertexBuffer | |
| /** | |
| * Create a uniform buffer in std140 layout. NOTE: FLOAT_MAT2, FLOAT_MAT3x2, FLOAT_MAT4x2, | |
| * FLOAT_MAT3, FLOAT_MAT2x3, FLOAT_MAT4x3 are supported, but must be manually padded to | |
| * 4-float column alignment by the application! | |
| * @method | |
| * @param {Array} layout Array indicating the order and types of items to | |
| * * be stored in the buffer. | |
| * @param {GLUsage} [usage=DYNAMIC_DRAW] Buffer usage. | |
| * @return {UniformBuffer} New UniformBuffer object. | |
| */ | |
| createUniformBuffer(layout: Array<GLType | GLMatrixType>, usage?: GLUsage): UniformBuffer | |
| /** | |
| * Create a 2D texture. Can be used in several ways depending on the type of texture data: | |
| * @method | |
| * @param {DOMElement} image Image data. An array can be passed to manually set all levels | |
| * of the mipmap chain. If a single level is passed and mipmap filtering is being used, | |
| * generateMipmap() will be called to produce the remaining levels. | |
| * @param {Texture2DOptions} [options] Texture options. | |
| * @return {Texture} New Texture object. | |
| */ | |
| createTexture2D(image: CanvasImageSource, options?: Texture2DOptions): Texture | |
| /** | |
| * Create a 2D texture. Can be used in several ways depending on the type of texture data: | |
| * @method | |
| * @param {ArrayBufferView|Array} image Image data. An array can be passed to manually set all levels | |
| * of the mipmap chain. If a single level is passed and mipmap filtering is being used, | |
| * generateMipmap() will be called to produce the remaining levels. | |
| * @param {number} width Texture width. Required for array or empty data. | |
| * @param {number} height Texture height. Required for array or empty data. | |
| * @param {Texture2DOptions} [options] Texture options. | |
| * @return {Texture} New Texture object. | |
| */ | |
| createTexture2D(image: ArrayBufferView | Array<number>, width: number, height: number, options?: Texture2DOptions): Texture | |
| /** | |
| * Create a 2D texture. Can be used in several ways depending on the type of texture data: | |
| * @method | |
| * @param {number} width Texture width. Required for array or empty data. | |
| * @param {number} height Texture height. Required for array or empty data. | |
| * @param {Texture2DOptions} [options] Texture options. | |
| * @return {Texture} New Texture object. | |
| */ | |
| createTexture2D(width: number, height: number, options?: Texture2DOptions): Texture | |
| /** | |
| * Create a 3D texture. | |
| * @method | |
| * @param {ArrayBufferView|Array} image Pixel data. An array can be passed to manually set all levels of the mipmap chain. If a single level is passed and mipmap filtering is being used, generateMipmap() will be called to produce the remaining levels. | |
| * @param {number} width Texture width. Required for array or empty data. | |
| * @param {number} height Texture height. Required for array or empty data. | |
| * @param {number} depth Texture depth. | |
| * @param {Texture3DOptions} [options] Texture options. | |
| * @return {Texture} New Texture object. | |
| */ | |
| createTexture3D(image: ArrayBufferView | Array<number>, width: number, height: number, options?: Texture3DOptions): Texture | |
| /** | |
| * Create a cubemap. | |
| * @method | |
| * @param {CubemapOptions} options Texture options. | |
| * @return {Cubemap} New Cubemap object. | |
| */ | |
| createCubemap(options: CubemapOptions): Cubemap | |
| /** | |
| * Create a renderbuffer. | |
| * @method | |
| * @param {number} width Renderbuffer width. | |
| * @param {number} height Renderbuffer height. | |
| * @param {GLInternalFormat} internalFormat Internal arrangement of the renderbuffer data. | |
| * @param {number} [samples=0] Number of MSAA samples. | |
| * @return {Renderbuffer} New Renderbuffer object. | |
| */ | |
| createRenderbuffer(width: number, height: number, internalFormat: GLInternalFormat, samples: number): Renderbuffer | |
| /** | |
| * Create a framebuffer. | |
| * @method | |
| * @return {Framebuffer} New Framebuffer object. | |
| */ | |
| createFramebuffer(): Framebuffer | |
| /** | |
| * Create a query. | |
| * @method | |
| * @param {GLQueryType} target Information to query. | |
| * @return {Query} New Query object. | |
| */ | |
| createQuery(target: GLQueryType): Query | |
| /** | |
| * Create a timer. | |
| * @method | |
| * @return {Timer} New Timer object. | |
| */ | |
| createTimer(): Timer | |
| /** | |
| * Create a DrawCall. A DrawCall manages the state associated with | |
| * a WebGL draw call including a program and associated vertex data, textures, | |
| * uniforms and uniform blocks. | |
| * @method | |
| * @param {Program} program The program to use for this DrawCall. | |
| * @param {VertexArray} [vertexArray=null] Vertex data to use for drawing. | |
| * @return {DrawCall} New DrawCall object. | |
| */ | |
| createDrawCall(program: Program, vertexArray: VertexArray): DrawCall | |
| // Clear the canvas | |
| clear(): this | |
| } | |
| /** Offscreen drawing surface. */ | |
| export interface Framebuffer { | |
| /** The WebGL context. */ | |
| gl: WebGL2RenderingContext | |
| /** Handle to the framebuffer. */ | |
| framebuffer: WebGLFramebuffer | |
| /** Framebuffer width. */ | |
| width: number | |
| /** Framebuffer height. */ | |
| height: number | |
| /** Array of color attachments. */ | |
| colorAttachments: Array<Texture | Cubemap | Renderbuffer> | |
| /** Depth attachment. */ | |
| depthAttachment: Texture | Cubemap | Renderbuffer | |
| appState: { | |
| // TODO | |
| } | |
| /** | |
| * Restore framebuffer after context loss. | |
| * @method | |
| * @return {Framebuffer} The Framebuffer object. | |
| */ | |
| restore(): this | |
| /** | |
| * Attach a color target to this framebuffer. | |
| * @method | |
| * @param {number} index Color attachment index. | |
| * @param {Texture|Cubemap|Renderbuffer} attachment The texture, cubemap or renderbuffer to attach. | |
| * @param {GLTextTarget} [target] The texture target or layer to attach. If the texture is 3D or a texture array, | |
| * defaults to 0, otherwise to TEXTURE_2D. Ignored for renderbuffers. | |
| * @return {Framebuffer} The Framebuffer object. | |
| */ | |
| colorTarget(index: number, attachment: Texture | Cubemap | Renderbuffer, target?: GLTextTarget): this | |
| /** | |
| * Attach a depth target to this framebuffer. | |
| * @method | |
| * @param {Texture|Cubemap|Renderbuffer} texture The texture, cubemap or renderbuffer to attach. | |
| * @param {GLTextTarget} [target] The texture target or layer to attach. If the texture is 3D or a texture array or renderbuffer, | |
| * defaults to 0, otherwise to TEXTURE_2D. Ignored for renderbuffers. | |
| * @return {Framebuffer} The Framebuffer object. | |
| */ | |
| depthTarget(attachment: Texture | Cubemap | Renderbuffer, target?: GLTextTarget): this | |
| /** | |
| * Resize all attachments. | |
| * @method | |
| * @param {number} [width=app.width] New width of the framebuffer. | |
| * @param {number} [height=app.height] New height of the framebuffer. | |
| * @return {Framebuffer} The Framebuffer object. | |
| */ | |
| resize(width: number, height: number): this | |
| /** | |
| * Delete this framebuffer. | |
| * @method | |
| * @return {Framebuffer} The Framebuffer object. | |
| */ | |
| delete(): this | |
| /** | |
| * Get the current status of this framebuffer. | |
| * @method | |
| * @return {GLFrameBufferStatus} The current status of this framebuffer. | |
| */ | |
| getStatus(): GLFrameBufferStatus | |
| } | |
| /** WebGL shader. */ | |
| export interface Shader { | |
| gl: WebGL2RenderingContext | |
| shader: WebGLShader | |
| /** | |
| * Restore shader after context loss. | |
| * @method | |
| * @return {Shader} The Shader object. | |
| */ | |
| restore(): this | |
| /** | |
| * Get the shader source translated for the platform's API. | |
| * @method | |
| * @return {String} The translated shader source. | |
| */ | |
| translatedSource(): string | |
| /** | |
| * Delete this shader. | |
| * @method | |
| * @return {Shader} The Shader object. | |
| */ | |
| delete(): this | |
| } | |
| /** WebGL program consisting of compiled and linked vertex and fragment shaders. */ | |
| export interface Program { | |
| gl: WebGL2RenderingContext | |
| program: WebGLProgram | |
| transformFeedback: boolean | |
| uniforms: object | |
| /** | |
| * Restore program after context loss. Note that this | |
| * will stall for completion. <b>App.restorePrograms</b> | |
| * is the preferred method for program restoration as | |
| * it will parallelize compilation where available. | |
| * @method | |
| * @return {Program} The Program object. | |
| */ | |
| restore(): this | |
| /** | |
| * Get the vertex shader source translated for the platform's API. | |
| * @method | |
| * @return {String} The translated vertex shader source. | |
| */ | |
| translatedVertexSource(): string | |
| /** | |
| * Get the fragment shader source translated for the platform's API. | |
| * @method | |
| * @return {String} The translated fragment shader source. | |
| */ | |
| translatedFragmentSource(): string | |
| /** | |
| * Delete this program. | |
| * @method | |
| * @return {Program} The Program object. | |
| */ | |
| delete(): Program | |
| } | |
| interface VertexArrayBufferOptions { | |
| /** Type of data stored in the buffer. */ | |
| type?: GLType | |
| /** Number of components per vertex. */ | |
| size?: 1 | 2 | 3 | 4 | |
| /** Number of bytes between the start of data for each vertex. */ | |
| stride?: GLuint | |
| /** Number of bytes before the start of data for the first vertex. */ | |
| offset?: GLuint | |
| /** Data is integer data that should be normalized to a float. */ | |
| normalized?: boolean | |
| /** Pass data as integers. */ | |
| integer?: boolean | |
| } | |
| /** Organizes vertex buffer and attribute state. */ | |
| export interface VertexArray { | |
| /** The WebGL context. */ | |
| gl: WebGL2RenderingContext | |
| /** Vertex array object. */ | |
| vertexArray: WebGLVertexArrayObject | |
| /** Number of elements in the vertex array. */ | |
| numElements: number | |
| /** Whether this vertex array is set up for indexed drawing. */ | |
| indexed: boolean | |
| /** Data type of the indices. */ | |
| indexType: GLType | |
| /** Number of instances to draw with this vertex array. */ | |
| numInstances: number | |
| /** | |
| * Restore vertex array after context loss. | |
| * @method | |
| * @return {VertexArray} The VertexArray object. | |
| */ | |
| restore(): this | |
| /** | |
| * Bind an per-vertex attribute buffer to this vertex array. | |
| * @method | |
| * @param {number} attributeIndex The attribute location to bind to. | |
| * @param {VertexBuffer} vertexBuffer The VertexBuffer to bind. | |
| * @param {VertexArrayBufferOptions} [options] Attribute pointer options. These will override those provided in the VertexBuffer. | |
| * @return {VertexArray} The VertexArray object. | |
| */ | |
| vertexAttributeBuffer(attributeIndex: number, vertexBuffer: VertexBuffer, options?: VertexArrayBufferOptions): this | |
| /** | |
| * Bind an per-instance attribute buffer to this vertex array. | |
| * @method | |
| * @param {number} attributeIndex The attribute location to bind to. | |
| * @param {VertexBuffer} vertexBuffer The VertexBuffer to bind. | |
| * @param {VertexArrayBufferOptions} [options] Attribute pointer options. These will override those provided in the VertexBuffer. | |
| * @return {VertexArray} The VertexArray object. | |
| */ | |
| instanceAttributeBuffer(attributeIndex: number, vertexBuffer: VertexBuffer, options?: VertexArrayBufferOptions): this | |
| /** | |
| * Bind an index buffer to this vertex array. | |
| * @method | |
| * @param {VertexBuffer} vertexBuffer The VertexBuffer to bind. | |
| * @return {VertexArray} The VertexArray object. | |
| */ | |
| indexBuffer(vertexBuffer: VertexBuffer): this | |
| /** | |
| * Delete this vertex array. | |
| * @method | |
| * @return {VertexArray} The VertexArray object. | |
| */ | |
| delete(): this | |
| } | |
| /** Tranform feedback object. */ | |
| export interface TransformFeedback { | |
| /** The WebGL context. */ | |
| gl: WebGL2RenderingContext | |
| /** Transform feedback object. */ | |
| transformFeedback: WebGLTransformFeedback | |
| /** | |
| * Restore transform feedback after context loss. | |
| * @method | |
| * @return {TransformFeedback} The TransformFeedback object. | |
| */ | |
| restore(): this | |
| /** | |
| * Bind a feedback buffer to capture transform output. | |
| * @method | |
| * @param {number} index Index of transform feedback varying to capture. | |
| * @param {VertexBuffer} buffer Buffer to record output into. | |
| * @return {TransformFeedback} The TransformFeedback object. | |
| */ | |
| feedbackBuffer(index: number, buffer: VertexBuffer): this | |
| /** | |
| * Delete this transform feedback. | |
| * @method | |
| * @return {TransformFeedback} The TransformFeedback object. | |
| */ | |
| delete(): this | |
| } | |
| /** Storage for vertex data. */ | |
| export interface VertexBuffer { | |
| /** The WebGL context. */ | |
| gl: WebGL2RenderingContext | |
| /** Allocated buffer storage. */ | |
| buffer: WebGLBuffer | |
| /** The type of data stored in the buffer. */ | |
| type: GLType | |
| /** Number of array elements per vertex. */ | |
| itemSize: number | |
| /** Number of vertices represented. */ | |
| numItems: number | |
| /** The usage pattern of the buffer. */ | |
| usage: GLUsage | |
| /** Whether this is an index array. */ | |
| indexArray: boolean | |
| /** GL binding point (ARRAY_BUFFER or ELEMENT_ARRAY_BUFFER). */ | |
| binding: GLBinding | |
| /** | |
| * Restore vertex buffer after context loss. | |
| * @method | |
| * @param {ArrayBufferView|number} data Buffer data itself or the total number of elements to be allocated. | |
| * @return {VertexBuffer} The VertexBuffer object. | |
| */ | |
| restore(data: ArrayBufferView | number): this | |
| /** | |
| * Update data in this buffer. NOTE: the data must fit the originally-allocated buffer! | |
| * @method | |
| * @param {ArrayBufferView} data Data to store in the buffer. | |
| * @return {VertexBuffer} The VertexBuffer object. | |
| */ | |
| data(data: ArrayBufferView): this | |
| /** | |
| * Delete this array buffer. | |
| * @method | |
| * @return {VertexBuffer} The VertexBuffer object. | |
| */ | |
| delete(): this | |
| } | |
| /** General-purpose texture. */ | |
| export interface Texture { | |
| /** The WebGL context. */ | |
| gl: WebGL2RenderingContext | |
| /** Handle to the texture. */ | |
| texture: WebGLTexture | |
| /** Texture width. */ | |
| width: number | |
| /** Texture height. */ | |
| height: number | |
| /** Texture depth. */ | |
| depth: number | |
| /** Binding point for the texture. */ | |
| binding: GLBinding | |
| /** Type of data stored in the texture. */ | |
| type: GLType | |
| /** Layout of texture data. */ | |
| format: GLInternalFormat | |
| /** Internal arrangement of the texture data. */ | |
| internalFormat: GLInternalFormat | |
| /** The current texture unit this texture is bound to. */ | |
| currentUnit: number | |
| /** Whether this texture contains 3D data. */ | |
| is3D: boolean | |
| /** Whether the y-axis is flipped for this texture. */ | |
| flipY: boolean | |
| /** Whether alpha should be pre-multiplied when loading this texture. */ | |
| premultiplyAlpha: boolean | |
| /** Whether this texture is using mipmap filtering (and thus should have a complete mipmap chain). */ | |
| mipmaps: boolean | |
| /** | |
| * Restore texture after context loss. | |
| * @method | |
| * @param {DOMElement|ArrayBufferView|Array} [image] Image data. An array can be passed to manually set all levels of the mipmap chain. If a single level is passed and mipmap filtering is being used, generateMipmap() will be called to produce the remaining levels. | |
| * @return {Texture} The Texture object. | |
| */ | |
| restore(image: CanvasImageSource | ArrayBufferView): this | |
| /** | |
| * Re-allocate texture storage. | |
| * @method | |
| * @param {number} width Image width. | |
| * @param {number} height Image height. | |
| * @param {number} [depth] Image depth or number of images. Required when passing 3D or texture array data. | |
| * @return {Texture} The Texture object. | |
| */ | |
| resize(width: number, height: number, depth?: number): this | |
| /** | |
| * Set the image data for the texture. An array can be passed to manually set all levels of the mipmap chain. If a single level is passed and mipmap filtering is being used, generateMipmap() will be called to produce the remaining levels. | |
| * NOTE: the data must fit the currently-allocated storage! | |
| * @method | |
| * @param {ImageElement|ArrayBufferView|Array} data Image data. If an array is passed, it will be | |
| * used to set mip map levels. | |
| * @return {Texture} The Texture object. | |
| */ | |
| data(image: CanvasImageSource | ArrayBufferView): this | |
| /** | |
| * Delete this texture. | |
| * @method | |
| * @return {Texture} The Texture object. | |
| */ | |
| delete(): this | |
| } | |
| /** Cubemap for environment mapping. */ | |
| export interface Cubemap { | |
| /** The WebGL context. */ | |
| gl: WebGL2RenderingContext | |
| /** Handle to the texture. */ | |
| texture: WebGLTexture | |
| /** Type of data stored in the texture. */ | |
| type: GLType | |
| /** Layout of texture data. */ | |
| format: GLInternalFormat | |
| /** Internal arrangement of the texture data. */ | |
| internalFormat: GLInternalFormat | |
| /** The current texture unit this texture is bound to. */ | |
| currentUnit: number | |
| /** Whether the y-axis is flipped for this texture. */ | |
| flipY: boolean | |
| /** Whether alpha should be pre-multiplied when loading this texture. */ | |
| premultiplyAlpha: boolean | |
| /** | |
| * Restore cubemap after context loss. | |
| * @method | |
| * @param {CubemapOptions} [options] Texture options. | |
| * @return {Cubemap} The Cubemap object. | |
| */ | |
| restore(options?: CubemapOptions): this | |
| /** | |
| * Delete this cubemap. | |
| * @method | |
| * @return {Cubemap} The Cubemap object. | |
| */ | |
| delete(): this | |
| } | |
| /** Offscreen drawing attachment. */ | |
| export interface Renderbuffer { | |
| /** The WebGL context. */ | |
| gl: WebGL2RenderingContext | |
| /** Handle to the renderbuffer. */ | |
| renderbuffer: WebGLRenderbuffer | |
| /** Texture width. */ | |
| width: number | |
| /** Texture height. */ | |
| height: number | |
| /** Internal arrangement of the texture data. */ | |
| internalFormat: GLInternalFormat | |
| /** Number of MSAA samples. */ | |
| samples: number | |
| /** | |
| * Restore renderbuffer after context loss. | |
| * @method | |
| * @return {Renderbuffer} The Renderbuffer object. | |
| */ | |
| restore(): this | |
| /** | |
| * Resize the renderbuffer. | |
| * @method | |
| * @param {number} width New width of the renderbuffer. | |
| * @param {number} height New height of the renderbuffer. | |
| * @return {Renderbuffer} The Renderbuffer object. | |
| */ | |
| resize(width: number, height: number): this | |
| /** | |
| * Delete this renderbuffer. | |
| * @method | |
| * @return {Renderbuffer} The Renderbuffer object. | |
| */ | |
| delete(): this | |
| } | |
| /** Generic query object. */ | |
| export interface Query { | |
| /** The WebGL context. */ | |
| gl: WebGL2RenderingContext | |
| /** Query object. */ | |
| query: WebGLQuery | |
| /** The type of information being queried. */ | |
| target: GLQueryType | |
| /** Whether or not a query is currently in progress. */ | |
| active: boolean | |
| /** The result of the query (only available after a call to ready() returns true). */ | |
| result: any | |
| /** | |
| * Restore query after context loss. | |
| * @method | |
| * @return {Query} The Query object. | |
| */ | |
| restore(): this | |
| /** | |
| * Begin a query. | |
| * @method | |
| * @return {Query} The Query object. | |
| */ | |
| begin(): this | |
| /** | |
| * End a query. | |
| * @method | |
| * @return {Query} The Query object. | |
| */ | |
| end(): this | |
| /** | |
| * Check if query result is available. | |
| * @method | |
| * @return {boolean} If results are available. | |
| */ | |
| ready(): boolean | |
| /** | |
| * Delete this query. | |
| * @method | |
| * @return {Query} The Query object. | |
| */ | |
| delete(): this | |
| } | |
| export interface Timer { | |
| /** The WebGL context. */ | |
| gl: WebGL2RenderingContext | |
| /** Timer for CPU. Will be window.performance, if available, or window.Date. */ | |
| cpuTimer: Object | |
| /** Timer query object for GPU (if gpu timing is supported). */ | |
| gpuTimerQuery: WebGLQuery | |
| /** Whether a gpu timer query is currently in progress. */ | |
| gpuTimerQueryInProgress: boolean | |
| /** When the last CPU timing started. */ | |
| cpuStartTime: number | |
| /** Time spent on CPU during last timing. Only valid if ready() returns true. */ | |
| cpuTime: number | |
| /** Time spent on GPU during last timing. Only valid if ready() returns true. Will remain 0 if extension EXT_disjoint_timer_query_webgl2 is unavailable. */ | |
| gpuTime: number | |
| /** | |
| * Restore timer after context loss. | |
| * @method | |
| * @return {Timer} The Timer object. | |
| */ | |
| restore(): this | |
| /** | |
| * Start timing. | |
| * @method | |
| * @return {Timer} The Timer object. | |
| */ | |
| start(): this | |
| /** | |
| * Stop timing. | |
| * @method | |
| * @return {Timer} The Timer object. | |
| */ | |
| end(): this | |
| /** | |
| * Check if timing results are available. If | |
| * this method returns true, the cpuTime and | |
| * gpuTime properties will be set to valid | |
| * values. | |
| * @method | |
| * @return {boolean} If results are available. | |
| */ | |
| ready(): boolean | |
| /** | |
| * Delete this timer. | |
| * @method | |
| * @return {Timer} The Timer object. | |
| */ | |
| delete(): this | |
| } | |
| /** A DrawCall represents the program and values of associated attributes, uniforms and textures for a single draw call. */ | |
| export interface DrawCall { | |
| /** The WebGL context. */ | |
| gl: WebGL2RenderingContext | |
| /** The program to use for this draw call. */ | |
| currentProgram: Program | |
| /** Vertex array to use for this draw call. */ | |
| currentVertexArray: VertexArray | |
| /** Transform feedback to use for this draw call. */ | |
| currentTransformFeedback: TransformFeedback | |
| /** Ordered list of active uniform buffers. */ | |
| uniformBuffers: UniformBuffer[] | |
| /** Ordered list of uniform block names. */ | |
| uniformBlockNames: string[] | |
| /** Number of active uniform blocks for this draw call. */ | |
| uniformBlockCount: number | |
| /** Map of uniform names to indices in the uniform arrays. */ | |
| uniformIndices: { [key: string]: number } | |
| /** Ordered list of uniform names. */ | |
| uniformNames: string[] | |
| /** Ordered list of uniform values. */ | |
| uniformValue: any[] | |
| /** The number of active uniforms for this draw call. */ | |
| uniformCount: number | |
| /** Array of active textures. */ | |
| textures: Array<Texture | Cubemap | Renderbuffer> | |
| /** The number of active textures for this draw call. */ | |
| textureCount: number | |
| /** The number of element to draw. */ | |
| numElements: number | |
| /** The number of instances to draw. */ | |
| numInstances: number | |
| /** | |
| * Set the current draw primitive for this draw call. | |
| * @method | |
| * @param {GLPrimitive} primitive Primitive to draw. | |
| * @return {DrawCall} The DrawCall object. | |
| */ | |
| primitive(primitive: GLPrimitive): this | |
| /** | |
| * Set the current TransformFeedback object for draw. | |
| * @method | |
| * @param {TransformFeedback} transformFeedback Transform Feedback to set. | |
| * @return {DrawCall} The DrawCall object. | |
| */ | |
| transformFeedback(transformFeedback: TransformFeedback): this | |
| /** | |
| * Set the value for a uniform. Array uniforms are supported by | |
| * using appending "[0]" to the array name and passing a flat array | |
| * with all required values. | |
| * @method | |
| * @param {string} name Uniform name. | |
| * @param {any} value Uniform value. | |
| * @return {DrawCall} The DrawCall object. | |
| */ | |
| uniform(name: string, value: any): this | |
| /** | |
| * Set texture to bind to a sampler uniform. | |
| * @method | |
| * @param {string} name Sampler uniform name. | |
| * @param {Texture|Cubemap|Renderbuffer} texture Texture or Cubemap to bind. | |
| * @return {DrawCall} The DrawCall object. | |
| */ | |
| texture(name: string, texture: Texture | Cubemap | Renderbuffer): this | |
| /** | |
| * Set uniform buffer to bind to a uniform block. | |
| * @method | |
| * @param {string} name Uniform block name. | |
| * @param {UniformBuffer} buffer Uniform buffer to bind. | |
| * @return {DrawCall} The DrawCall object. | |
| */ | |
| uniformBlock(name: string, buffer: UniformBuffer): this | |
| /** | |
| * Ranges in the vertex array to draw. Multiple arguments can be provided to set up | |
| * a multi-draw. | |
| * @method | |
| * @param {...Array} counts Variable number of 2 or 3 element arrays, each containing: | |
| * <ul> | |
| * <li> (Number) Number of elements to skip at the start of the array. | |
| * <li> (Number) Number of elements to draw. | |
| * <li> (Number - optional) Number of instances to draw of the given range. | |
| * </ul> | |
| * @return {DrawCall} The DrawCall object. | |
| */ | |
| drawRanges(...counts: Array<[number, number] | [number, number, number]>): this | |
| /** | |
| * Draw based on current state. | |
| * @method | |
| * @return {DrawCall} The DrawCall object. | |
| */ | |
| draw(): this | |
| } | |
| /** Storage for uniform data. Data is stored in std140 layout. */ | |
| export interface UniformBuffer { | |
| /** The WebGL context. */ | |
| gl: WebGL2RenderingContext | |
| /** Allocated buffer storage. */ | |
| buffer: WebGLBuffer | |
| /** Buffer data. */ | |
| data: Float32Array | |
| /** Map of base data types to matching ArrayBufferViews of the buffer data. */ | |
| dataViews: object | |
| /** Offsets into the array for each item in the buffer. */ | |
| offsets: number[] | |
| /** Size of the item at the given offset. */ | |
| sizes: number[] | |
| /** The base type of the item at the given offset (FLOAT, INT or UNSIGNED_INT). */ | |
| types: GLType[] | |
| /** The size of the buffer (in 4-byte items). */ | |
| size: number | |
| /** Usage pattern of the buffer. */ | |
| usage: GLUsage | |
| /** | |
| * Restore uniform buffer after context loss. | |
| * @method | |
| * @return {UniformBuffer} The UniformBuffer object. | |
| */ | |
| restore(): this | |
| /** | |
| * Update data for a given item in the buffer. NOTE: Data is not | |
| * sent the the GPU until the update() method is called! | |
| * @method | |
| * @param {number} index Index in the layout of item to set. | |
| * @param {ArrayBufferView} value Value to store at the layout location. | |
| * @return {UniformBuffer} The UniformBuffer object. | |
| */ | |
| set(index: number, value: ArrayBufferView): this | |
| /** | |
| * Send stored buffer data to the GPU. | |
| * @method | |
| * @return {UniformBuffer} The UniformBuffer object. | |
| */ | |
| update(): this | |
| /** | |
| * Delete this uniform buffer. | |
| * @method | |
| * @return {UniformBuffer} The UniformBuffer object. | |
| */ | |
| delete(): this | |
| } | |
| } |
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment