Exporters From Japan
 
Wholesale exporters from Japan   Company Established 1983
CARVIEW
MOTORHOMES
Select Language

Default Framebuffer

WebGL always has a default framebuffer. The FRAMEBUFFER_UNDEFINED enumerant is removed from the WebGL 2.0 API.

String Length Queries

In the WebGL 2.0 API, the enumerants ACTIVE_UNIFORM_BLOCK_MAX_NAME_LENGTH, TRANSFORM_FEEDBACK_VARYING_MAX_LENGTH, UNIFORM_BLOCK_NAME_LENGTH, and UNIFORM_NAME_LENGTH are removed in addition to similar enumerants removed in the WebGL 1.0 API.

Invalid Clears

In the WebGL 2.0 API, trying to perform a clear when there is a mismatch between the type of the specified clear value and the type of a buffer that is being cleared generates an INVALID_OPERATION error instead of producing undefined results.

Invalid Texture Offsets

A GLSL shader which attempts to use a texture offset value outside the range specified by implementation-defined parameters MIN_PROGRAM_TEXEL_OFFSET and MAX_PROGRAM_TEXEL_OFFSET in texture lookup function arguments must fail compilation in the WebGL 2.0 API.

Using an offset outside the valid range returns undefined results, so it can not be allowed. The offset must be a constant expression according to the GLSL ES spec, so checking the value against the correct range can be done at compile time.

Texel Fetches

Texel fetches that have undefined results in the OpenGL ES 3.0 API must return zero, or a texture source color of (0, 0, 0, 1) in the case of a texel fetch from an incomplete texture in the WebGL 2.0 API.

Behavior of out-of-range texel fetches needs to be testable in order to guarantee security.

GLSL ES 1.00 Fragment Shader Output

A fragment shader written in The OpenGL ES Shading Language, Version 1.00, that statically assigns a value to gl_FragData[n] where n does not equal constant value 0 must fail to compile in the WebGL 2.0 API. This is to achieve consistency with The OpenGL ES 3.0 specification section 4.2.1 (OpenGL ES 3.0.6 §4.2.1) and The OpenGL ES Shading Language 3.00.6 specification section 1.5 (GLSL ES 3.00.6 §1.5). As in the OpenGL ES 3.0 API, multiple fragment shader outputs are only supported for GLSL ES 3.00 shaders in the WebGL 2.0 API.

No MapBufferRange

The MapBufferRange, FlushMappedBufferRange, and UnmapBuffer entry points are removed from the WebGL 2.0 API. The following enum values are also removed: BUFFER_ACCESS_FLAGS, BUFFER_MAP_LENGTH, BUFFER_MAP_OFFSET, MAP_READ_BIT, MAP_WRITE_BIT, MAP_INVALIDATE_RANGE_BIT, MAP_INVALIDATE_BUFFER_BIT, MAP_FLUSH_EXPLICIT_BIT, and MAP_UNSYNCHRONIZED_BIT.

Instead of using MapBufferRange, buffer data may be read by using the getBufferSubData entry point.

TIMEOUT_IGNORED

In the WebGL 2.0 API TIMEOUT_IGNORED is defined as a GLint64 with the value -1 instead of a GLuint64 with the value 0xFFFFFFFFFFFFFFFF. This is because Javascript cannot accurately represent an integer that large. For the same reason waitSync takes GLint64 values instead of GLuint64 for timeout.

clientWaitSync

In the WebGL 2.0 API, WebGL implementations must enforce a short maximum timeout on calls to clientWaitSync in order to avoid blocking execution of the main thread for excessive periods of time. This timeout may be queried by calling getParameter with the argument MAX_CLIENT_WAIT_TIMEOUT_WEBGL.

The implementation-defined maximum timeout is not specified. It is acceptable for an implementation to enforce a zero maximum timeout.

Vertex Attribute Aliasing

WebGL 2.0 API implementations must strictly follow GLSL ES 3.00.6 section 12.46, which specifies that any vertex attribute aliasing is disallowed. As stated in [GLES30] p57, GLSL ES 1.00 shaders may still alias, as allowed by the WebGL 1.0 spec section Attribute aliasing.

PRIMITIVE_RESTART_FIXED_INDEX is always enabled

The PRIMITIVE_RESTART_FIXED_INDEX context state, controlled with Enable/Disable in OpenGL ES 3.0, is not supported in WebGL 2.0. Instead, WebGL 2.0 behaves as though this state were always enabled. This is a compatibility difference compared to WebGL 1.0.

When drawElements, drawElementsInstanced, or drawRangeElements processes an index, if the index's value is the maximum for the data type (255 for UNSIGNED_BYTE indices, 65535 for UNSIGNED_SHORT, or 4294967295 for UNSIGNED_INT), then the vertex is not processed normally. Instead, it is as if the drawing command ended with the immediately preceding vertex, and another drawing command is immediately started with the same parameters, but only transferring the immediately following index through the end of the originally specified indices.

This compatibility difference was introduced in order to avoid performance pitfalls in Direct3D based WebGL implementations. Applications and content creation tools can be adjusted to avoid using the maximum vertex index if the primitive restart behavior is not desired.

No texture swizzles

OpenGL ES 3.0 introduces new state on texture objects allowing a four-channel swizzle operation to be specified against the texture. The swizzle is applied to every texture lookup performed within any shader referencing that texture. These texture swizzles are not supported in WebGL 2.0. TEXTURE_SWIZZLE_* enum values are removed from the WebGL 2.0 API.

Texture swizzles can not be implemented in a performant manner on Direct3D based WebGL implementations. Applications relying on this functionality would run significantly more slowly on those implementations. Applications are still able to swizzle results of texture fetches in shaders and swizzle texture data before uploading without this interface.

Queries should fail on a program that failed to link

OpenGL ES 3.0 allows applications to enumerate and query properties of active variables and interface blocks of a specified program even if that program failed to link (OpenGL ES 3.0.6 §2.12.3). In WebGL, these commands will always generate an INVALID_OPERATION error on a program that failed to link, and no information is returned.

The returned information in OpenGL ES 3.0 is implementation dependent and may be incomplete. The error condition is added to ensure consistent behavior across all platforms.

Color values from a fragment shader must match the color buffer format

Color values written by a fragment shader may be floating-point, signed integer, or unsigned integer. If the values written by the fragment shader do not match the format(s) of the corresponding color buffer(s), the result is undefined in OpenGL ES 3.0 (OpenGL ES 3.0.6 §3.9.2.3). In WebGL, generates an INVALID_OPERATION error in the corresponding draw call, including drawArrays, drawElements, drawArraysInstanced , drawElementsInstanced , and drawRangeElements.

If the color buffer has a normalized fixed-point format, floating-point color values are converted to match the format; generates no error in such situation.

A sampler type must match the internal texture format

Texture lookup functions return values as floating point, unsigned integer or signed integer, depending on the sampler type passed to the lookup function. If the wrong sampler type is used for texture access, i.e., the sampler type does not match the texture internal format, the returned values are undefined in OpenGL ES Shading Language 3.00.6 (OpenGL ES Shading Language 3.00.6 §8.8). In WebGL, generates an INVALID_OPERATION error in the corresponding draw call, including drawArrays, drawElements, drawArraysInstanced, drawElementsInstanced , and drawRangeElements.

If the sampler type is floating point and the internal texture format is normalized integer, it is considered as a match and the returned values are converted to floating point in the range [0, 1].

Queries' results must not be made available in the current frame

In OpenGL ES 3.0, if the appropriate primitives (e.g. glFinish() or another synchronous API) are called, a query's result may be made available in the same frame it was issued. In WebGL, in order to improve application portability, a query's result must never be made available to the application in the same frame the query was issued. See the specification of getQueryParameter for discussion and rationale.

GLSL ES 3.00 #extension directive location

The WebGL 1.0 specification section GLSL ES #extension directive location only applies to OpenGL ES Shading Language 1.00 shaders. It does not apply to shaders that are written in OpenGL ES Shading Language 3.00. In shaders written in OpenGL ES Shading Language 3.00, #extension directives must occur before non-preprocessor tokens regardless of what is written in the extension specification.

This is done to make WebGL 2.0 to follow the written GLSL ES 3.00 specification more closely. Enforcing the restriction more strictly than native GLES drivers makes the behavior well-defined.

Only std140 layout supported in uniform blocks

The GLSL ES 3.00 specification supports the shared, packed, and std140 layout qualifiers for uniform blocks, defining how variables are laid out in uniform buffers' storage. Of these, the WebGL 2.0 specification supports only the std140 layout, which is defined in OpenGL ES 3.0.6 §2.12 "Vertex Shaders", subsection "Standard Uniform Block Layout". Shaders attempting to use the shared or packed layout qualifiers will fail either the compilation or linking stages.

The initial state of compilation is as if the following were declared:

layout(std140) uniform;

This restriction is enforced to improve portability by avoiding exposing uniform block layouts that are specific to one vendor's GPUs.

Disallowed variants of GLSL ES 3.00 operators

In the WebGL 2.0 API, the following shading language constructs are not allowed and attempting to use them must result in a compile error:

  • Ternary operator applied to void, arrays, or structs containing arrays
  • Sequence operator applied to void, arrays, or structs containing arrays
This restriction ensures easy portability across OpenGL ES 3.0 supporting devices.

checkFramebufferStatus may return FRAMEBUFFER_INCOMPLETE_DIMENSIONS

All attached images much have the same width and height; otherwise, checkFramebufferStatus returns FRAMEBUFFER_INCOMPLETE_DIMENSIONS.

In OpenGL ES 3, attached images for a framebuffer need not to have the same width and height to be framebuffer complete, and FRAMEBUFFER_INCOMPLETE_DIMENSIONS is not one of the valid return values for checkFramebufferStatus. However, in Direct3D 11, on top of which OpenGL ES 3 behavior is emulated in Windows, all render targets must have the same size in all dimensions (see msdn manual page). Emulation of the ES3 semantic on top of DirectX 11 will be inefficient. In order to have consistent WebGL 2.0 behaviors across platforms, it is reasonable to keep the OpenGL ES 2 / WebGL 1.0 restriction for WebGL 2.0 that all attached images must have the same width and height.

Uniform block matching

In the WebGL 2.0 API, layout qualifiers row_major and column_major are required to match in matched uniform blocks even when they are applied exclusively on non-matrix variables.

This uniform block matching rule is known to be inconsistent across OpenGL ES 3.0 implementations.

Framebuffer contents after invalidation

In OpenGL ES 3.0, after calling invalidateFramebuffer or invalidateSubFramebuffer, the affected region's contents become effectively undefined. In WebGL 2.0, it is required for the contents to either stay unchanged or become cleared to their default values. (e.g. 0 for colors and stencil, and 1.0 for depth)

It is acceptable for WebGL 2.0 implementations to make invalidateFramebuffer or invalidateSubFramebuffer a no-op.

No ArrayBufferView matching texture type FLOAT_32_UNSIGNED_INT_24_8_REV

In texImage2D and texImage3D with ArrayBufferView, if type is FLOAT_32_UNSIGNED_INT_24_8_REV and srcData is not null, generates an INVALID_OPERATION.

In texSubImage2D and texSubImage3D with ArrayBufferView, if type is FLOAT_32_UNSIGNED_INT_24_8_REV, generates an INVALID_ENUM.

VertexAttrib function must match shader attribute type

If any of the following situations are true, attempting to draw with drawArrays, drawElements, drawRangeElements or their instanced variants generates an INVALID_OPERATION error:

  • vertexAttribPointer, vertexAttrib{1234}f, or vertexAttrib{1234}fv is used and the base type of the shader attribute at slot index is not floating-point (e.g. is signed or unsigned integer);
  • vertexAttribIPointer is used with type UNSIGNED_BYTE, UNSIGNED_SHORT or UNSIGNED_INT, or vertexAttribI4ui or vertexAttribI4uiv is used, and the base type of the shader attribute at slot index is not unsigned integer (e.g. is floating-point or signed integer);
  • vertexAttribIPointer is used with type BYTE, SHORT or INT, or vertexAttribI4i or vertexAttribI4iv is used, and the base type of the shader attribute at slot index is not signed integer (e.g. is floating-point or unsigned integer).
This undefined behavior is in the OpenGL ES 3.0 specification section 2.8 ( OpenGL ES 3.0.6 §2.8).

Transform feedback primitive capture

If any output variable is specified to be streamed to a buffer object but not actually written by a vertex shader, the value is set to 0.

This undefined behavior is in the OpenGL ES 3.0 specification section 2.15.2 ( OpenGL ES 3.0.6 §2.15.2).

gl_FragDepth

If a fragment shader statically assigns a value to gl_FragDepth, for any fragment where statements assigning a value to gl_FragDepth are not executed, the value 0 is used.

This undefined behavior is in the OpenGL ES 3.0 specification section 3.9.2 ( OpenGL ES 3.0.6 §3.9.2).

Framebuffer color attachments

If an image is attached to more than one color attachment point in a framebuffer, checkFramebufferStatus returns FRAMEBUFFER_UNSUPPORTED. An image can be an individual mip level, an array slice (from either 2D array or cube map textures), or a 3D texture slice.

This is a limitation of Direct3D 11, on top of which OpenGL ES 3 behavior is emulated on Windows. (see msdn manual page). In order to have consistent WebGL 2.0 behavior across platforms, it is reasonable to add this limitation in WebGL 2.0 for all platforms.

Pixel store parameters for uploads from TexImageSource

UNPACK_ALIGNMENT and UNPACK_ROW_LENGTH are ignored. UNPACK_ALIGNMENT is specified in bytes, and is implicit and implementation-dependent for TexImageSource objects. UNPACK_ROW_LENGTH is currently unused.

Subrect selection is possible using UNPACK_ params. UNPACK_SKIP_PIXELS and UNPACK_SKIP_ROWS determine the origin of the subrect, with the width and height arguments determining the size of the subrect.

For 3D textures, the width, height, and depth arguments specify a rectangular region of a texel array to unpack to. UNPACK_SKIP_IMAGES and UNPACK_IMAGE_HEIGHT allow selection of multiple slices from the 2D source. UNPACK_IMAGE_HEIGHT determines the stride, in rows, between two slices. For example, a TexImageSource 30 pixels tall may have the top 10 and bottom 10 rows uploaded into two slices of a 3D texture by uploading with height equal to 10, UNPACK_IMAGE_HEIGHT set to 20, and depth equal to 2. If UNPACK_IMAGE_HEIGHT is 0, the stride, in rows, between two slices defaults to height.

For an HTMLImageElement 20 pixels wide, passing width = 10 for texture upload will cause only the left half of the image to be selected, thus uploaded. The resulting texture will have a width of 10. If, additionally in this example, UNPACK_SKIP_PIXELS is set to 10, only the right half of the image is selected for unpack.

Also, UNPACK_SKIP_IMAGES applies only to 3D entrypoints, not to 2D entrypoints.

Looking at another example, the above 32x48 image of six colors, each of size 16x16, is uploaded to a 3D texture of width = 2, height = 1, and depth = 3.

  • If UNPACK_SKIP_PIXELS is 0, UNPACK_SKIP_ROWS is 0, and UNPACK_IMAGE_HEIGHT is 0, the entire texel array is set to red.
  • If UNPACK_SKIP_PIXELS is 16, UNPACK_SKIP_ROWS is 16, and UNPACK_IMAGE_HEIGHT is 0, the entire texel array is set to yellow.
  • If UNPACK_SKIP_PIXELS is 0, UNPACK_SKIP_ROWS is 0, and UNPACK_IMAGE_HEIGHT is 16, the first slice of the texel array is red, the second slice is blue, and the third slice is purple.
  • If UNPACK_SKIP_PIXELS is 16, UNPACK_SKIP_ROWS is 0, and UNPACK_IMAGE_HEIGHT is 16, the first slice of the texel array is green, the second slice is yellow, and the third slice is pink.

Pixel store parameter constraints

Define:

  • DataStoreWidth := ROW_LENGTH ? ROW_LENGTH : width
  • DataStoreHeight := IMAGE_HEIGHT ? IMAGE_HEIGHT : height

If PACK_SKIP_PIXELS + width > DataStoreWidth, readPixels generates an INVALID_OPERATION error.

If UNPACK_SKIP_PIXELS + width > DataStoreWidth, texImage2D and texSubImage2D generate an INVALID_OPERATION error. This does not apply to texImage2D if no PIXEL_UNPACK_BUFFER is bound and srcData is null.

If UNPACK_SKIP_PIXELS + width > DataStoreWidth or UNPACK_SKIP_ROWS + height > DataStoreHeight, texImage3D and texSubImage3D generate an INVALID_OPERATION error. This does not apply to texImage3D if no PIXEL_UNPACK_BUFFER is bound and srcData is null.

These constraints normalize the use of these parameters to specify a sub region where pixels are stored. For example, in readPixels cases, if we want to store pixels to a sub area of the entire data store, we can use PACK_ROW_LENGTH to specify the data store width, and PACK_SKIP_PIXELS, PACK_SKIP_ROWS, width and height to specify the subarea's xoffset, yoffset, width, and height.

These contraints also forbid row and image overlap, where the situations are not tested in the OpenGL ES 3.0 DEQP test suites, and many drivers behave incorrectly. They also forbid skipping random pixels or rows, but that can be achieved by adjusting the data store offset accordingly.

Further, for uploads from TexImageSource, implied UNPACK_ROW_LENGTH and UNPACK_ALIGNMENT are not strictly defined. These restrictions ensure consistent and efficient behavior regardless of implied UNPACK_ params.

If UNPACK_FLIP_Y_WEBGL or UNPACK_PREMULTIPLY_ALPHA_WEBGL is set to true, texImage2D and texSubImage2D generate an INVALID_OPERATION error if they upload data from a PIXEL_UNPACK_BUFFER.

If UNPACK_FLIP_Y_WEBGL or UNPACK_PREMULTIPLY_ALPHA_WEBGL is set to true, texImage3D and texSubImage3D generate an INVALID_OPERATION error if they upload data from a PIXEL_UNPACK_BUFFER or a non-null client side ArrayBufferView.

No ETC2 and EAC compressed texture formats

OpenGL ES 3.0 requires support for the following ETC2 and EAC compressed texture formats: COMPRESSED_R11_EAC, COMPRESSED_SIGNED_R11_EAC, COMPRESSED_RG11_EAC, COMPRESSED_SIGNED_RG11_EAC, COMPRESSED_RGB8_ETC2, COMPRESSED_SRGB8_ETC2, COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2, COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2, COMPRESSED_RGBA8_ETC2_EAC, and COMPRESSED_SRGB8_ALPHA8_ETC2_EAC.

These texture formats are not supported by default in WebGL 2.0.

These formats are not natively supported by most desktop GPU hardware. As such, supporting these formats requires software decompression in either the WebGL implementation or the underlying driver. This results in a drastic increase in video memory usage, causing performance losses which are invisible to the WebGL application.

On hardware which supports the ETC2 and EAC compressed texture formats natively (e.g. mobile OpenGL ES 3.0+ hardware), they may be exposed via the extension WEBGL_compressed_texture_etc.

The value of UNIFORM_BUFFER_OFFSET_ALIGNMENT must be divisible by 4

The value of UNIFORM_BUFFER_OFFSET_ALIGNMENT, as given in basic machine units, must be divisible by 4.

If the value of UNIFORM_BUFFER_OFFSET_ALIGNMENT was not divisible by 4, it would make it impractical to upload ArrayBuffers to uniform buffers which are bound with BindBufferRange.

Sync objects' results must not be made available in the current frame

In OpenGL ES 3.0, if the appropriate primitives (e.g. glFinish() or another synchronous API) are called, a sync object may be signaled in the same frame it was issued. In WebGL, in order to improve application portability, a sync object must never transition to the signaled state in the same frame the sync was issued. See the specification of getSyncParameter and clientWaitSync for discussion and rationale.

blitFramebuffer rectangle width/height limitations

blitFramebuffer() src* and dst* parameters must be set so that the resulting width and height of the source and destination rectangles are less than or equal to the maximum value that can be stored in a GLint. In case computing any of the width or height values as a GLint results in integer overflow, blitFramebuffer() generates an INVALID_VALUE error.

Using larger than max 32-bit int sized rectangles for blitFramebuffer triggers issues on most desktop OpenGL drivers, and there is no general workaround for cases where blitFramebuffer is used to scale the framebuffer.

GenerateMipmap requires positive image dimensions

generateMipmap requires that TEXTURE_BASE_LEVEL's dimensions are all positive.

GLES 3.0.6 technically allows calling GenerateMipmap on 0x0 images, though cubemaps must be cube-complete, thus having positive dimensions.
This change simplifies implementations by allowing a concept of base-level-completeness for textures, as otherwise required for non-mipmap-sampled validation. Since GenerateMipmap has no effect on a 0x0 texture, and is illegal in WebGL 1 (0 is not a power of two), this is an easy restriction to add. Further, GenerateMipmap would otherwise be the only entrypoint that has to operate on undefined texture images, skipping an otherwise-common validation.

deleteQuery implicitly calls endQuery if the query is active

In GLES, DeleteQueries does not implicitly end queries, even if they are active.

This deviation was not originally specified, but was implicitly standardized across browsers by conformance tests. Some implementations found this behavior simpler to implement. Reverting this behavior to match the GLES specs could break content, and at this point it's better to spec what we implemented.

Required compressed texture formats

Implementations must support at least one suite of compressed texture formats.


Implementations must support:

To best support our ecosystem, we require implementations to support either ETC2/EAC formats (universal on GLES3 or similar drivers, like many phones) or S3TC formats (universal all other drivers). This guarantees to authors that they can always use compressed textures (including srgb variants) on all devices while maintaining support for as few as two different formats.

There are roughly equivalent formats in each suite for the following uses:

Usage S3TC/RGTC option (desktop) ETC2/EAC option (mobile)
R11 unsigned COMPRESSED_RED_RGTC1_EXT COMPRESSED_R11_EAC
R11 signed COMPRESSED_SIGNED_RED_RGTC1_EXT COMPRESSED_SIGNED_R11_EAC
RG11 unsigned COMPRESSED_RED_GREEN_RGTC2_EXT COMPRESSED_RG11_EAC
RG11 signed COMPRESSED_SIGNED_RED_GREEN_RGTC2_EXT COMPRESSED_SIGNED_RG11_EAC
RGB8 unsigned COMPRESSED_RGB_S3TC_DXT1_EXT COMPRESSED_RGB8_ETC2
RGB8 sRGB COMPRESSED_SRGB_S3TC_DXT1_EXT COMPRESSED_SRGB8_ETC2
RGB8 punchthrough unsigned COMPRESSED_RGBA_S3TC_DXT1_EXT COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2
RGB8 punchthrough sRGB COMPRESSED_SRGB_ALPHA_S3TC_DXT1_EXT COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2
RGBA8 unsigned COMPRESSED_RGBA_S3TC_DXT5_EXT COMPRESSED_RGBA8_ETC2_EAC
RGBA8 sRGB COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT COMPRESSED_SRGB8_ALPHA8_ETC2_EAC

E.g. sampler2DShadow does not guarantee e.g. LINEAR filtering

When TEXTURE_COMPARE_MODE is set to COMPARE_REF_TO_TEXTURE, a texture is always complete even if it uses a LINEAR filtering without the required extensions. However, it is implementation-defined whether the LINEAR filtering occurs. (Implementations may do NEAREST sampling instead)

This functionality is underspecified in GLES. It is common but not universal. We choose to be liberal here, though implementations may warn on requests for this functionality.

Clamped Constant Blend Color

Implementations may clamp constant blend color on store when the underlying platform does the same. Applications may query BLEND_COLOR parameter to check the effective behavior.

Generic TRANSFORM_FEEDBACK_BUFFER state location

The TRANSFORM_FEEDBACK_BUFFER generic buffer binding point has been moved to context state, rather than per-object state.

A similar change was made in OpenGL ES 3.2.

Uninitialized Compressed Textures

In OpenGL ES 2.0 the specification omitted declaring whether it should be possible to create a compressed 2D texture with uninitialized data. In WebGL 1.0, this is explicitly disallowed.

In OpenGL ES 3.0 it is explicitly allowed to create a compressed 2D texture with uninitialized data by passing null to glCompressedTexImage2D. In WebGL 2.0, however, this is still explicitly disallowed. Users can use texStorage2D with a compressed internal format to allocate zero-initialized compressed textures; these textures are however immutable, and not completely compatible with textures allocated via compressedTexImage2D.

References

[WEBGL10]
WebGL Specification 1.0.4 Editor's Draft, Dean Jackson, Jeff Gilbert.
[CANVAS]
HTML5: The Canvas Element, World Wide Web Consortium (W3C).
[OFFSCREENCANVAS]
HTML Living Standard - The OffscreenCanvas interface, WHATWG.
[CANVASCONTEXTS]
Canvas Context Registry, WHATWG.
[GLES30]
OpenGL® ES Version 3.0.6, J. Leech, B. Lipchak, August 2019.
[GLES30GLSL]
The OpenGL® ES Shading Language Version 3.00.6, R. Simpson, January 2016.
[REGISTRY]
WebGL Extension Registry
[RFC2119]
Key words for use in RFCs to Indicate Requirement Levels, S. Bradner. IETF, March 1997.
[WEBIDL]
Web IDL - Living Standard, E. Chen, T. Gu, B. Zbarsky, C. McCormack, T. Langel.
 
Original Source | Taken Source