/**

* @license

* Copyright 2010 The Emscripten Authors

* SPDX-License-Identifier: MIT

*/

// Specifies the size of the GL temp buffer pool, in bytes. Must be a multiple

// of 9 and 16.

{{{ GL_POOL_TEMP_BUFFERS_SIZE = 2*9*16 }}} // = 288

{{{

global.isCurrentContextWebGL2 = function isCurrentContextWebGL2() {

if (MIN_WEBGL_VERSION >= 2) return 'true';

if (MAX_WEBGL_VERSION <= 1) return 'false';

return 'GL.currentContext.version >= 2';

}

}}}

var LibraryGL = {

// For functions such as glDrawBuffers, glInvalidateFramebuffer and glInvalidateSubFramebuffer that need to pass a short array to the WebGL API,

// create a set of short fixed-length arrays to avoid having to generate any garbage when calling those functions.

$tempFixedLengthArray__postset: 'for (var i = 0; i < 32; ++i) tempFixedLengthArray.push(new Array(i));',

$tempFixedLengthArray: [],

$miniTempWebGLFloatBuffers: [],

$miniTempWebGLFloatBuffers__postset:

'var miniTempWebGLFloatBuffersStorage = new Float32Array(' + {{{ GL_POOL_TEMP_BUFFERS_SIZE }}} + ');\n'

+ 'for (/**@suppress{duplicate}*/var i = 0; i < ' + {{{ GL_POOL_TEMP_BUFFERS_SIZE }}} + '; ++i) {\n'

+ 'miniTempWebGLFloatBuffers[i] = miniTempWebGLFloatBuffersStorage.subarray(0, i+1);\n'

+ '}\n',

_miniTempWebGLIntBuffers: [],

_miniTempWebGLIntBuffers__postset:

'var __miniTempWebGLIntBuffersStorage = new Int32Array(' + {{{ GL_POOL_TEMP_BUFFERS_SIZE }}} + ');\n'

+ 'for (/**@suppress{duplicate}*/var i = 0; i < ' + {{{ GL_POOL_TEMP_BUFFERS_SIZE }}} + '; ++i) {\n'

+ '__miniTempWebGLIntBuffers[i] = __miniTempWebGLIntBuffersStorage.subarray(0, i+1);\n'

+ '}\n',

$heapObjectForWebGLType: function(type) {

// Micro-optimization for size: Subtract lowest GL enum number (0x1400/* GL_BYTE */) from type to compare

// smaller values for the heap, for shorter generated code size.

// Also the type HEAPU16 is not tested for explicitly, but any unrecognized type will return out HEAPU16.

// (since most types are HEAPU16)

type -= 0x1400;

#if MAX_WEBGL_VERSION >= 2

if (type == {{{ 0x1400 - 0x1400/* GL_BYTE */ }}}) return HEAP8;

#endif

if (type == {{{ 0x1401 - 0x1400/* GL_UNSIGNED_BYTE */ }}}) return HEAPU8;

#if MAX_WEBGL_VERSION >= 2

if (type == {{{ 0x1402 - 0x1400/* GL_SHORT */ }}}) return HEAP16;

#endif

if (type == {{{ 0x1404 - 0x1400/* GL_INT */ }}}) return HEAP32;

if (type == {{{ 0x1406 - 0x1400/* GL_FLOAT */ }}}) return HEAPF32;

if (type == {{{ 0x1405 - 0x1400 /* GL_UNSIGNED_INT */ }}}

|| type == {{{ 0x84FA - 0x1400 /* GL_UNSIGNED_INT_24_8_WEBGL/GL_UNSIGNED_INT_24_8 */ }}}

#if MAX_WEBGL_VERSION >= 2

|| type == {{{ 0x8368 - 0x1400 /* GL_UNSIGNED_INT_2_10_10_10_REV */ }}}

|| type == {{{ 0x8C3B - 0x1400 /* GL_UNSIGNED_INT_10F_11F_11F_REV */ }}}

|| type == {{{ 0x8C3E - 0x1400 /* GL_UNSIGNED_INT_5_9_9_9_REV */ }}}

#endif

)

return HEAPU32;

#if GL_ASSERTIONS

if (type != {{{ 0x1403 - 0x1400 /* GL_UNSIGNED_SHORT */ }}}

#if MAX_WEBGL_VERSION >= 2

&& type != {{{ 0x140B - 0x1400 /* GL_HALF_FLOAT */ }}}

#endif

&& type != {{{ 0x8033 - 0x1400 /* GL_UNSIGNED_SHORT_4_4_4_4 */ }}}

&& type != {{{ 0x8034 - 0x1400 /* GL_UNSIGNED_SHORT_5_5_5_1 */ }}}

&& type != {{{ 0x8363 - 0x1400 /* GL_UNSIGNED_SHORT_5_6_5 */ }}}

&& type != {{{ 0x8D61 - 0x1400 /* GL_HALF_FLOAT_OES */ }}}) {

err('Invalid WebGL type 0x' + (type+0x1400).toString() + ' passed to $heapObjectForWebGLType!');

}

#endif

return HEAPU16;

},

$heapAccessShiftForWebGLHeap: function(heap) {

return 31 - Math.clz32(heap.BYTES_PER_ELEMENT);

},

#if MIN_WEBGL_VERSION == 1

_webgl_enable_ANGLE_instanced_arrays: function(ctx) {

// Extension available in WebGL 1 from Firefox 26 and Google Chrome 30 onwards. Core feature in WebGL 2.

var ext = ctx.getExtension('ANGLE_instanced_arrays');

if (ext) {

ctx['vertexAttribDivisor'] = function(index, divisor) { ext['vertexAttribDivisorANGLE'](index, divisor); };

ctx['drawArraysInstanced'] = function(mode, first, count, primcount) { ext['drawArraysInstancedANGLE'](mode, first, count, primcount); };

ctx['drawElementsInstanced'] = function(mode, count, type, indices, primcount) { ext['drawElementsInstancedANGLE'](mode, count, type, indices, primcount); };

return 1;

}

},

emscripten_webgl_enable_ANGLE_instanced_arrays__deps: ['_webgl_enable_ANGLE_instanced_arrays'],

emscripten_webgl_enable_ANGLE_instanced_arrays: function(ctx) {

return __webgl_enable_ANGLE_instanced_arrays(GL.contexts[ctx].GLctx);

},

_webgl_enable_OES_vertex_array_object: function(ctx) {

// Extension available in WebGL 1 from Firefox 25 and WebKit 536.28/desktop Safari 6.0.3 onwards. Core feature in WebGL 2.

var ext = ctx.getExtension('OES_vertex_array_object');

if (ext) {

ctx['createVertexArray'] = function() { return ext['createVertexArrayOES'](); };

ctx['deleteVertexArray'] = function(vao) { ext['deleteVertexArrayOES'](vao); };

ctx['bindVertexArray'] = function(vao) { ext['bindVertexArrayOES'](vao); };

ctx['isVertexArray'] = function(vao) { return ext['isVertexArrayOES'](vao); };

return 1;

}

},

emscripten_webgl_enable_OES_vertex_array_object__deps: ['_webgl_enable_OES_vertex_array_object'],

emscripten_webgl_enable_OES_vertex_array_object: function(ctx) {

return __webgl_enable_OES_vertex_array_object(GL.contexts[ctx].GLctx);

},

_webgl_enable_WEBGL_draw_buffers: function(ctx) {

// Extension available in WebGL 1 from Firefox 28 onwards. Core feature in WebGL 2.

var ext = ctx.getExtension('WEBGL_draw_buffers');

if (ext) {

ctx['drawBuffers'] = function(n, bufs) { ext['drawBuffersWEBGL'](n, bufs); };

return 1;

}

},

emscripten_webgl_enable_WEBGL_draw_buffers__deps: ['_webgl_enable_WEBGL_draw_buffers'],

emscripten_webgl_enable_WEBGL_draw_buffers: function(ctx) {

return __webgl_enable_WEBGL_draw_buffers(GL.contexts[ctx].GLctx);

},

#endif

_webgl_enable_WEBGL_multi_draw: function(ctx) {

// Closure is expected to be allowed to minify the '.multiDrawWebgl' property, so not accessing it quoted.

return !!(ctx.multiDrawWebgl = ctx.getExtension('WEBGL_multi_draw'));

},

emscripten_webgl_enable_WEBGL_multi_draw__deps: ['_webgl_enable_WEBGL_multi_draw'],

emscripten_webgl_enable_WEBGL_multi_draw: function(ctx) {

return __webgl_enable_WEBGL_multi_draw(GL.contexts[ctx].GLctx);

},

$GL__postset: 'var GLctx;',

#if GL_SUPPORT_AUTOMATIC_ENABLE_EXTENSIONS

// If GL_SUPPORT_AUTOMATIC_ENABLE_EXTENSIONS is enabled, GL.initExtensions() will call to initialize these.

$GL__deps: [

#if MIN_WEBGL_VERSION == 1

'_webgl_enable_ANGLE_instanced_arrays',

'_webgl_enable_OES_vertex_array_object',

'_webgl_enable_WEBGL_draw_buffers',

#endif

#if MAX_WEBGL_VERSION >= 2

'_webgl_enable_WEBGL_draw_instanced_base_vertex_base_instance',

'_webgl_enable_WEBGL_multi_draw_instanced_base_vertex_base_instance',

#endif

'_webgl_enable_WEBGL_multi_draw',

],

#endif

$GL: {

#if GL_DEBUG

debug: true,

#endif

/* We do not depend on the exact initial values of falsey member fields - these fields can be populated on-demand

to save code size.

(but still documented here to keep track of what is supposed to be present)

#if GL_TRACK_ERRORS

lastError: 0,

#endif

currentContext: null,

#if FULL_ES2 || LEGACY_GL_EMULATION

currArrayBuffer: 0,

currElementArrayBuffer: 0,

#endif

*/

counter: 1, // 0 is reserved as 'null' in gl

buffers: [],

#if FULL_ES3

mappedBuffers: {},

#endif

programs: [],

framebuffers: [],

renderbuffers: [],

textures: [],

shaders: [],

vaos: [],

#if USE_PTHREADS // with pthreads a context is a location in memory with some synchronized data between threads

contexts: {},

#else // without pthreads, it's just an integer ID

contexts: [],

#endif

offscreenCanvases: {}, // DOM ID -> OffscreenCanvas mappings of <canvas> elements that have their rendering control transferred to offscreen.

queries: [], // on WebGL1 stores WebGLTimerQueryEXT, on WebGL2 WebGLQuery

#if MAX_WEBGL_VERSION >= 2

samplers: [],

transformFeedbacks: [],

syncs: [],

#endif

#if FULL_ES2 || LEGACY_GL_EMULATION

byteSizeByTypeRoot: 0x1400, // GL_BYTE

byteSizeByType: [

1, // GL_BYTE

1, // GL_UNSIGNED_BYTE

2, // GL_SHORT

2, // GL_UNSIGNED_SHORT

4, // GL_INT

4, // GL_UNSIGNED_INT

4, // GL_FLOAT

2, // GL_2_BYTES

3, // GL_3_BYTES

4, // GL_4_BYTES

8 // GL_DOUBLE

],

#endif

stringCache: {},

#if MAX_WEBGL_VERSION >= 2

stringiCache: {},

#endif

unpackAlignment: 4, // default alignment is 4 bytes

// Records a GL error condition that occurred, stored until user calls glGetError() to fetch it. As per GLES2 spec, only the first error

// is remembered, and subsequent errors are discarded until the user has cleared the stored error by a call to glGetError().

recordError: function recordError(errorCode) {

#if GL_TRACK_ERRORS

if (!GL.lastError) {

GL.lastError = errorCode;

}

#endif

},

// Get a new ID for a texture/buffer/etc., while keeping the table dense and fast. Creation is fairly rare so it is worth optimizing lookups later.

getNewId: function(table) {

var ret = GL.counter++;

for (var i = table.length; i < ret; i++) {

table[i] = null;

}

return ret;

},

#if FULL_ES2 || LEGACY_GL_EMULATION

// When user GL code wants to render from client-side memory, we need to upload the vertex data to a temp VBO

// for rendering. Maintain a set of temp VBOs that are created-on-demand to appropriate sizes, and never destroyed.

// Also, for best performance the VBOs are double-buffered, i.e. every second frame we switch the set of VBOs we

// upload to, so that rendering from the previous frame is not disturbed by uploading from new data to it, which

// could cause a GPU-CPU pipeline stall.

// Note that index buffers are not double-buffered (at the moment) in this manner.

MAX_TEMP_BUFFER_SIZE: {{{ GL_MAX_TEMP_BUFFER_SIZE }}},

// Maximum number of temp VBOs of one size to maintain, after that we start reusing old ones, which is safe but can give

// a performance impact. If CPU-GPU stalls are a problem, increasing this might help.

numTempVertexBuffersPerSize: 64, // (const)

// Precompute a lookup table for the function ceil(log2(x)), i.e. how many bits are needed to represent x, or,

// if x was rounded up to next pow2, which index is the single '1' bit at?

// Then log2ceilLookup[x] returns ceil(log2(x)).

log2ceilLookup: function(i) {

return 32 - Math.clz32(i === 0 ? 0 : i - 1);

},

generateTempBuffers: function(quads, context) {

var largestIndex = GL.log2ceilLookup(GL.MAX_TEMP_BUFFER_SIZE);

context.tempVertexBufferCounters1 = [];

context.tempVertexBufferCounters2 = [];

context.tempVertexBufferCounters1.length = context.tempVertexBufferCounters2.length = largestIndex+1;

context.tempVertexBuffers1 = [];

context.tempVertexBuffers2 = [];

context.tempVertexBuffers1.length = context.tempVertexBuffers2.length = largestIndex+1;

context.tempIndexBuffers = [];

context.tempIndexBuffers.length = largestIndex+1;

for (var i = 0; i <= largestIndex; ++i) {

context.tempIndexBuffers[i] = null; // Created on-demand

context.tempVertexBufferCounters1[i] = context.tempVertexBufferCounters2[i] = 0;

var ringbufferLength = GL.numTempVertexBuffersPerSize;

context.tempVertexBuffers1[i] = [];

context.tempVertexBuffers2[i] = [];

var ringbuffer1 = context.tempVertexBuffers1[i];

var ringbuffer2 = context.tempVertexBuffers2[i];

ringbuffer1.length = ringbuffer2.length = ringbufferLength;

for (var j = 0; j < ringbufferLength; ++j) {

ringbuffer1[j] = ringbuffer2[j] = null; // Created on-demand

}

}

if (quads) {

// GL_QUAD indexes can be precalculated

context.tempQuadIndexBuffer = GLctx.createBuffer();

context.GLctx.bindBuffer(0x8893 /*GL_ELEMENT_ARRAY_BUFFER*/, context.tempQuadIndexBuffer);

var numIndexes = GL.MAX_TEMP_BUFFER_SIZE >> 1;

var quadIndexes = new Uint16Array(numIndexes);

var i = 0, v = 0;

while (1) {

quadIndexes[i++] = v;

if (i >= numIndexes) break;

quadIndexes[i++] = v+1;

if (i >= numIndexes) break;

quadIndexes[i++] = v+2;

if (i >= numIndexes) break;

quadIndexes[i++] = v;

if (i >= numIndexes) break;

quadIndexes[i++] = v+2;

if (i >= numIndexes) break;

quadIndexes[i++] = v+3;

if (i >= numIndexes) break;

v += 4;

}

context.GLctx.bufferData(0x8893 /*GL_ELEMENT_ARRAY_BUFFER*/, quadIndexes, 0x88E4 /*GL_STATIC_DRAW*/);

context.GLctx.bindBuffer(0x8893 /*GL_ELEMENT_ARRAY_BUFFER*/, null);

}

},

getTempVertexBuffer: function getTempVertexBuffer(sizeBytes) {

var idx = GL.log2ceilLookup(sizeBytes);

var ringbuffer = GL.currentContext.tempVertexBuffers1[idx];

var nextFreeBufferIndex = GL.currentContext.tempVertexBufferCounters1[idx];

GL.currentContext.tempVertexBufferCounters1[idx] = (GL.currentContext.tempVertexBufferCounters1[idx]+1) & (GL.numTempVertexBuffersPerSize-1);

var vbo = ringbuffer[nextFreeBufferIndex];

if (vbo) {

return vbo;

}

var prevVBO = GLctx.getParameter(0x8894 /*GL_ARRAY_BUFFER_BINDING*/);

ringbuffer[nextFreeBufferIndex] = GLctx.createBuffer();

GLctx.bindBuffer(0x8892 /*GL_ARRAY_BUFFER*/, ringbuffer[nextFreeBufferIndex]);

GLctx.bufferData(0x8892 /*GL_ARRAY_BUFFER*/, 1 << idx, 0x88E8 /*GL_DYNAMIC_DRAW*/);

GLctx.bindBuffer(0x8892 /*GL_ARRAY_BUFFER*/, prevVBO);

return ringbuffer[nextFreeBufferIndex];

},

getTempIndexBuffer: function getTempIndexBuffer(sizeBytes) {

var idx = GL.log2ceilLookup(sizeBytes);

var ibo = GL.currentContext.tempIndexBuffers[idx];

if (ibo) {

return ibo;

}

var prevIBO = GLctx.getParameter(0x8895 /*ELEMENT_ARRAY_BUFFER_BINDING*/);

GL.currentContext.tempIndexBuffers[idx] = GLctx.createBuffer();

GLctx.bindBuffer(0x8893 /*GL_ELEMENT_ARRAY_BUFFER*/, GL.currentContext.tempIndexBuffers[idx]);

GLctx.bufferData(0x8893 /*GL_ELEMENT_ARRAY_BUFFER*/, 1 << idx, 0x88E8 /*GL_DYNAMIC_DRAW*/);

GLctx.bindBuffer(0x8893 /*GL_ELEMENT_ARRAY_BUFFER*/, prevIBO);

return GL.currentContext.tempIndexBuffers[idx];

},

// Called at start of each new WebGL rendering frame. This swaps the doublebuffered temp VB memory pointers,

// so that every second frame utilizes different set of temp buffers. The aim is to keep the set of buffers

// being rendered, and the set of buffers being updated disjoint.

newRenderingFrameStarted: function newRenderingFrameStarted() {

if (!GL.currentContext) {

return;

}

var vb = GL.currentContext.tempVertexBuffers1;

GL.currentContext.tempVertexBuffers1 = GL.currentContext.tempVertexBuffers2;

GL.currentContext.tempVertexBuffers2 = vb;

vb = GL.currentContext.tempVertexBufferCounters1;

GL.currentContext.tempVertexBufferCounters1 = GL.currentContext.tempVertexBufferCounters2;

GL.currentContext.tempVertexBufferCounters2 = vb;

var largestIndex = GL.log2ceilLookup(GL.MAX_TEMP_BUFFER_SIZE);

for (var i = 0; i <= largestIndex; ++i) {

GL.currentContext.tempVertexBufferCounters1[i] = 0;

}

},

#endif

getSource: function(shader, count, string, length) {

var source = '';

for (var i = 0; i < count; ++i) {

var len = length ? {{{ makeGetValue('length', 'i*4', 'i32') }}} : -1;

source += UTF8ToString({{{ makeGetValue('string', 'i*4', 'i32') }}}, len < 0 ? undefined : len);

}

#if LEGACY_GL_EMULATION

// Let's see if we need to enable the standard derivatives extension

var type = GLctx.getShaderParameter(GL.shaders[shader], 0x8B4F /* GL_SHADER_TYPE */);

if (type == 0x8B30 /* GL_FRAGMENT_SHADER */) {

if (GLEmulation.findToken(source, "dFdx") ||

GLEmulation.findToken(source, "dFdy") ||

GLEmulation.findToken(source, "fwidth")) {

source = "#extension GL_OES_standard_derivatives : enable\n" + source;

var extension = GLctx.getExtension("OES_standard_derivatives");

#if GL_DEBUG

if (!extension) {

err("Shader attempts to use the standard derivatives extension which is not available.");

}

#endif

}

}

#endif

return source;

},

#if GL_FFP_ONLY

enabledClientAttribIndices: [],

enableVertexAttribArray: function enableVertexAttribArray(index) {

if (!GL.enabledClientAttribIndices[index]) {

GL.enabledClientAttribIndices[index] = true;

GLctx.enableVertexAttribArray(index);

}

},

disableVertexAttribArray: function disableVertexAttribArray(index) {

if (GL.enabledClientAttribIndices[index]) {

GL.enabledClientAttribIndices[index] = false;

GLctx.disableVertexAttribArray(index);

}

},

#endif

#if FULL_ES2

calcBufLength: function calcBufLength(size, type, stride, count) {

if (stride > 0) {

return count * stride; // XXXvlad this is not exactly correct I don't think

}

var typeSize = GL.byteSizeByType[type - GL.byteSizeByTypeRoot];

return size * typeSize * count;

},

usedTempBuffers: [],

preDrawHandleClientVertexAttribBindings: function preDrawHandleClientVertexAttribBindings(count) {

GL.resetBufferBinding = false;

// TODO: initial pass to detect ranges we need to upload, might not need an upload per attrib

for (var i = 0; i < GL.currentContext.maxVertexAttribs; ++i) {

var cb = GL.currentContext.clientBuffers[i];

if (!cb.clientside || !cb.enabled) continue;

GL.resetBufferBinding = true;

var size = GL.calcBufLength(cb.size, cb.type, cb.stride, count);

var buf = GL.getTempVertexBuffer(size);

GLctx.bindBuffer(0x8892 /*GL_ARRAY_BUFFER*/, buf);

GLctx.bufferSubData(0x8892 /*GL_ARRAY_BUFFER*/,

0,

HEAPU8.subarray(cb.ptr, cb.ptr + size));

#if GL_ASSERTIONS

GL.validateVertexAttribPointer(cb.size, cb.type, cb.stride, 0);

#endif

cb.vertexAttribPointerAdaptor.call(GLctx, i, cb.size, cb.type, cb.normalized, cb.stride, 0);

}

},

postDrawHandleClientVertexAttribBindings: function postDrawHandleClientVertexAttribBindings() {

if (GL.resetBufferBinding) {

GLctx.bindBuffer(0x8892 /*GL_ARRAY_BUFFER*/, GL.buffers[GLctx.currentArrayBufferBinding]);

}

},

#endif

#if GL_ASSERTIONS

validateGLObjectID: function(objectHandleArray, objectID, callerFunctionName, objectReadableType) {

if (objectID != 0) {

if (objectHandleArray[objectID] === null) {

console.error(callerFunctionName + ' called with an already deleted ' + objectReadableType + ' ID ' + objectID + '!');

} else if (!(objectID in objectHandleArray)) {

console.error(callerFunctionName + ' called with a nonexisting ' + objectReadableType + ' ID ' + objectID + '!');

}

}

},

// Validates that user obeys GL spec #6.4: http://www.khronos.org/registry/webgl/specs/latest/1.0/#6.4

validateVertexAttribPointer: function(dimension, dataType, stride, offset) {

var sizeBytes = 1;

switch (dataType) {

case 0x1400 /* GL_BYTE */:

case 0x1401 /* GL_UNSIGNED_BYTE */:

sizeBytes = 1;

break;

case 0x1402 /* GL_SHORT */:

case 0x1403 /* GL_UNSIGNED_SHORT */:

sizeBytes = 2;

break;

case 0x1404 /* GL_INT */:

case 0x1405 /* GL_UNSIGNED_INT */:

case 0x1406 /* GL_FLOAT */:

sizeBytes = 4;

break;

case 0x140A /* GL_DOUBLE */:

sizeBytes = 8;

break;

default:

#if MAX_WEBGL_VERSION >= 2

if ({{{ isCurrentContextWebGL2() }}}) {

if (dataType == 0x8368 /* GL_UNSIGNED_INT_2_10_10_10_REV */ || dataType == 0x8D9F /* GL_INT_2_10_10_10_REV */) {

sizeBytes = 4;

break;

} else if (dataType == 0x140B /* GL_HALF_FLOAT */) {

sizeBytes = 2;

break;

} else {

// else fall through

}

}

#endif

console.error('Invalid vertex attribute data type GLenum ' + dataType + ' passed to GL function!');

}

if (dimension == 0x80E1 /* GL_BGRA */) {

console.error('WebGL does not support size=GL_BGRA in a call to glVertexAttribPointer! Please use size=4 and type=GL_UNSIGNED_BYTE instead!');

} else if (dimension < 1 || dimension > 4) {

console.error('Invalid dimension='+dimension+' in call to glVertexAttribPointer, must be 1,2,3 or 4.');

}

if (stride < 0 || stride > 255) {

console.error('Invalid stride='+stride+' in call to glVertexAttribPointer. Note that maximum supported stride in WebGL is 255!');

}

if (offset % sizeBytes != 0) {

console.error('GL spec section 6.4 error: vertex attribute data offset of ' + offset + ' bytes should have been a multiple of the data type size that was used: GLenum ' + dataType + ' has size of ' + sizeBytes + ' bytes!');

}

if (stride % sizeBytes != 0) {

console.error('GL spec section 6.4 error: vertex attribute data stride of ' + stride + ' bytes should have been a multiple of the data type size that was used: GLenum ' + dataType + ' has size of ' + sizeBytes + ' bytes!');

}

},

#endif

#if TRACE_WEBGL_CALLS

hookWebGLFunction: function(f, glCtx) {

var realf = 'real_' + f;

glCtx[realf] = glCtx[f];

var numArgs = glCtx[realf].length;

if (numArgs === undefined) console.warn('Unexpected WebGL function ' + f + ' when binding TRACE_WEBGL_CALLS');

var contextHandle = glCtx.canvas.GLctxObject.handle;

var threadId = (typeof _pthread_self !== 'undefined') ? _pthread_self : function() { return 1; };

// Accessing 'arguments' is super slow, so to avoid overhead, statically reason the number of arguments.

switch (numArgs) {

case 0: glCtx[f] = function webgl_0() { var ret = glCtx[realf](); console.error('[Thread ' + threadId() + ', GL ctx: ' + contextHandle + ']: ' + f + '() -> ' + ret); return ret; }; break;

case 1: glCtx[f] = function webgl_1(a1) { var ret = glCtx[realf](a1); console.error('[Thread ' + threadId() + ', GL ctx: ' + contextHandle + ']: ' + f + '('+a1+') -> ' + ret); return ret; }; break;

case 2: glCtx[f] = function webgl_2(a1, a2) { var ret = glCtx[realf](a1, a2); console.error('[Thread ' + threadId() + ', GL ctx: ' + contextHandle + ']: ' + f + '('+a1+', ' + a2 +') -> ' + ret); return ret; }; break;

case 3: glCtx[f] = function webgl_3(a1, a2, a3) { var ret = glCtx[realf](a1, a2, a3); console.error('[Thread ' + threadId() + ', GL ctx: ' + contextHandle + ']: ' + f + '('+a1+', ' + a2 +', ' + a3 +') -> ' + ret); return ret; }; break;

case 4: glCtx[f] = function webgl_4(a1, a2, a3, a4) { var ret = glCtx[realf](a1, a2, a3, a4); console.error('[Thread ' + threadId() + ', GL ctx: ' + contextHandle + ']: ' + f + '('+a1+', ' + a2 +', ' + a3 +', ' + a4 +') -> ' + ret); return ret; }; break;

case 5: glCtx[f] = function webgl_5(a1, a2, a3, a4, a5) { var ret = glCtx[realf](a1, a2, a3, a4, a5); console.error('[Thread ' + threadId() + ', GL ctx: ' + contextHandle + ']: ' + f + '('+a1+', ' + a2 +', ' + a3 +', ' + a4 +', ' + a5 +') -> ' + ret); return ret; }; break;

case 6: glCtx[f] = function webgl_6(a1, a2, a3, a4, a5, a6) { var ret = glCtx[realf](a1, a2, a3, a4, a5, a6); console.error('[Thread ' + threadId() + ', GL ctx: ' + contextHandle + ']: ' + f + '('+a1+', ' + a2 +', ' + a3 +', ' + a4 +', ' + a5 +', ' + a6 +') -> ' + ret); return ret; }; break;

case 7: glCtx[f] = function webgl_7(a1, a2, a3, a4, a5, a6, a7) { var ret = glCtx[realf](a1, a2, a3, a4, a5, a6, a7); console.error('[Thread ' + threadId() + ', GL ctx: ' + contextHandle + ']: ' + f + '('+a1+', ' + a2 +', ' + a3 +', ' + a4 +', ' + a5 +', ' + a6 +', ' + a7 +') -> ' + ret); return ret; }; break;

case 8: glCtx[f] = function webgl_8(a1, a2, a3, a4, a5, a6, a7, a8) { var ret = glCtx[realf](a1, a2, a3, a4, a5, a6, a7, a8); console.error('[Thread ' + threadId() + ', GL ctx: ' + contextHandle + ']: ' + f + '('+a1+', ' + a2 +', ' + a3 +', ' + a4 +', ' + a5 +', ' + a6 +', ' + a7 +', ' + a8 +') -> ' + ret); return ret; }; break;

case 9: glCtx[f] = function webgl_9(a1, a2, a3, a4, a5, a6, a7, a8, a9) { var ret = glCtx[realf](a1, a2, a3, a4, a5, a6, a7, a8, a9); console.error('[Thread ' + threadId() + ', GL ctx: ' + contextHandle + ']: ' + f + '('+a1+', ' + a2 +', ' + a3 +', ' + a4 +', ' + a5 +', ' + a6 +', ' + a7 +', ' + a8 +', ' + a9 +') -> ' + ret); return ret; }; break;

case 10: glCtx[f] = function webgl_10(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10) { var ret = glCtx[realf](a1, a2, a3, a4, a5, a6, a7, a8, a9, a10); console.error('[Thread ' + threadId() + ', GL ctx: ' + contextHandle + ']: ' + f + '('+a1+', ' + a2 +', ' + a3 +', ' + a4 +', ' + a5 +', ' + a6 +', ' + a7 +', ' + a8 +', ' + a9 +', ' + a10 +') -> ' + ret); return ret; }; break;

case 11: glCtx[f] = function webgl_11(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11) { var ret = glCtx[realf](a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11); console.error('[Thread ' + threadId() + ', GL ctx: ' + contextHandle + ']: ' + f + '('+a1+', ' + a2 +', ' + a3 +', ' + a4 +', ' + a5 +', ' + a6 +', ' + a7 +', ' + a8 +', ' + a9 +', ' + a10 +', ' + a11 +') -> ' + ret); return ret; }; break;

default: console.warn('hookWebGL failed! Unexpected length ' + glCtx[realf].length);

}

},

hookWebGL: function(glCtx) {

if (!glCtx) glCtx = this.detectWebGLContext();

if (!glCtx) return;

if (!((typeof WebGLRenderingContext !== 'undefined' && glCtx instanceof WebGLRenderingContext)

|| (typeof WebGL2RenderingContext !== 'undefined' && glCtx instanceof WebGL2RenderingContext))) {

return;

}

if (glCtx.webGlTracerAlreadyHooked) return;

glCtx.webGlTracerAlreadyHooked = true;

// Hot GL functions are ones that you'd expect to find during render loops (render calls, dynamic resource uploads), cold GL functions are load time functions (shader compilation, texture/mesh creation)

// Distinguishing between these two allows pinpointing locations of troublesome GL usage that might cause performance issues.

for (var f in glCtx) {

if (typeof glCtx[f] !== 'function' || f.startsWith('real_')) continue;

this.hookWebGLFunction(f, glCtx);

}

// The above injection won't work for texImage2D and texSubImage2D, which have multiple overloads.

glCtx['texImage2D'] = function(a1, a2, a3, a4, a5, a6, a7, a8, a9) {

var ret = (a7 !== undefined) ? glCtx['real_texImage2D'](a1, a2, a3, a4, a5, a6, a7, a8, a9) : glCtx['real_texImage2D'](a1, a2, a3, a4, a5, a6);

return ret;

};

glCtx['texSubImage2D'] = function(a1, a2, a3, a4, a5, a6, a7, a8, a9) {

var ret = (a8 !== undefined) ? glCtx['real_texSubImage2D'](a1, a2, a3, a4, a5, a6, a7, a8, a9) : glCtx['real_texSubImage2D'](a1, a2, a3, a4, a5, a6, a7);

return ret;

};

glCtx['texSubImage3D'] = function(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11) {

var ret = (a9 !== undefined) ? glCtx['real_texSubImage3D'](a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11) : glCtx['real_texSubImage2D'](a1, a2, a3, a4, a5, a6, a7, a8);

return ret;

};

},

#endif

// Returns the context handle to the new context.

createContext: function(canvas, webGLContextAttributes) {

#if OFFSCREEN_FRAMEBUFFER

// In proxied operation mode, rAF()/setTimeout() functions do not delimit frame boundaries, so can't have WebGL implementation

// try to detect when it's ok to discard contents of the rendered backbuffer.

if (webGLContextAttributes.renderViaOffscreenBackBuffer) webGLContextAttributes['preserveDrawingBuffer'] = true;

#endif

#if GL_TESTING

webGLContextAttributes['preserveDrawingBuffer'] = true;

#endif

#if MIN_SAFARI_VERSION != TARGET_NOT_SUPPORTED && GL_WORKAROUND_SAFARI_GETCONTEXT_BUG

// BUG: Workaround Safari WebGL issue: After successfully acquiring WebGL context on a canvas,

// calling .getContext() will always return that context independent of which 'webgl' or 'webgl2'

// context version was passed. See https://bugs.webkit.org/show_bug.cgi?id=222758 and

// https://github.com/emscripten-core/emscripten/issues/13295.

// TODO: Once the bug is fixed and shipped in Safari, adjust the Safari version field in above check.

if (!canvas.getContextSafariWebGL2Fixed) {

canvas.getContextSafariWebGL2Fixed = canvas.getContext;

canvas.getContext = function(ver, attrs) {

var gl = canvas.getContextSafariWebGL2Fixed(ver, attrs);

return ((ver == 'webgl') == (gl instanceof WebGLRenderingContext)) ? gl : null;

}

}

#endif

#if MAX_WEBGL_VERSION >= 2 && MIN_CHROME_VERSION <= 57

// BUG: Workaround Chrome WebGL 2 issue: the first shipped versions of WebGL 2 in Chrome 57 did not actually implement

// the new garbage free WebGL 2 entry points that take an offset and a length to an existing heap (instead of having to

// create a completely new heap view). In Chrome the entry points only were added in to Chrome 58 and newer. For

// Chrome 57 (and older), disable WebGL 2 support altogether.

function getChromeVersion() {

var chromeVersion = navigator.userAgent.match(/Chrom(e|ium)\/([0-9]+)\./);

if (chromeVersion) return chromeVersion[2]|0;

// If not chrome, fall through to return undefined. (undefined <= integer will yield false)

}

#endif

#if GL_DEBUG

var errorInfo = '?';

function onContextCreationError(event) {

errorInfo = event.statusMessage || errorInfo;

}

canvas.addEventListener('webglcontextcreationerror', onContextCreationError, false);

#endif

#if GL_PREINITIALIZED_CONTEXT

// If WebGL context has already been preinitialized for the page on the JS side, reuse that context instead. This is useful for example when

// the main page precompiles shaders for the application, in which case the WebGL context is created already before any Emscripten compiled

// code has been downloaded.

if (Module['preinitializedWebGLContext']) {

var ctx = Module['preinitializedWebGLContext'];

#if MAX_WEBGL_VERSION >= 2

webGLContextAttributes.majorVersion = (typeof WebGL2RenderingContext !== 'undefined' && ctx instanceof WebGL2RenderingContext) ? 2 : 1;

#else

webGLContextAttributes.majorVersion = 1;

#endif

} else {

#endif

#if MIN_WEBGL_VERSION >= 2

var ctx = canvas.getContext("webgl2", webGLContextAttributes);

#else

var ctx =

#if MAX_WEBGL_VERSION >= 2

(webGLContextAttributes.majorVersion > 1)

?

#if MIN_CHROME_VERSION <= 57

!(getChromeVersion() <= 57) && canvas.getContext("webgl2", webGLContextAttributes)

#else

canvas.getContext("webgl2", webGLContextAttributes)

#endif

:

#endif

(canvas.getContext("webgl", webGLContextAttributes)

// https://caniuse.com/#feat=webgl

#if MIN_IE_VERSION <= 10 || MIN_EDGE_VERSION <= 18 || MIN_FIREFOX_VERSION <= 23 || MIN_CHROME_VERSION <= 32 || MIN_SAFARI_VERSION <= 70101

|| canvas.getContext("experimental-webgl", webGLContextAttributes)

#endif

);

#endif // MAX_WEBGL_VERSION >= 2

#if GL_PREINITIALIZED_CONTEXT

}

#endif

#if GL_DEBUG

canvas.removeEventListener('webglcontextcreationerror', onContextCreationError, false);

if (!ctx) {

err('Could not create canvas: ' + [errorInfo, JSON.stringify(webGLContextAttributes)]);

return 0;

}

#else

if (!ctx) return 0;

#endif

var handle = GL.registerContext(ctx, webGLContextAttributes);

#if TRACE_WEBGL_CALLS

GL.hookWebGL(ctx);

#endif

#if GL_DISABLE_HALF_FLOAT_EXTENSION_IF_BROKEN

function disableHalfFloatExtensionIfBroken(ctx) {

var t = ctx.createTexture();

ctx.bindTexture(0xDE1/*GL_TEXTURE_2D*/, t);

for (var i = 0; i < 8 && ctx.getError(); ++i) /*no-op*/;

var ext = ctx.getExtension('OES_texture_half_float');

if (!ext) return; // no half-float extension - nothing needed to fix.

// Bug on Safari on iOS and macOS: texImage2D() and texSubImage2D() do not allow uploading pixel data to half float textures,

// rendering them useless.

// See https://bugs.webkit.org/show_bug.cgi?id=183321, https://bugs.webkit.org/show_bug.cgi?id=169999,

// https://stackoverflow.com/questions/54248633/cannot-create-half-float-oes-texture-from-uint16array-on-ipad

ctx.texImage2D(0xDE1/*GL_TEXTURE_2D*/, 0, 0x1908/*GL_RGBA*/, 1, 1, 0, 0x1908/*GL_RGBA*/, 0x8d61/*HALF_FLOAT_OES*/, new Uint16Array(4));

var broken = ctx.getError();

ctx.bindTexture(0xDE1/*GL_TEXTURE_2D*/, null);

ctx.deleteTexture(t);

if (broken) {

ctx.realGetSupportedExtensions = ctx.getSupportedExtensions;

ctx.getSupportedExtensions = function() {

#if GL_ASSERTIONS

warnOnce('Removed broken support for half-float textures. See e.g. https://bugs.webkit.org/show_bug.cgi?id=183321');

#endif

// .getSupportedExtensions() can return null if context is lost, so coerce to empty array.

return (this.realGetSupportedExtensions() || []).filter(function(ext) {

return !ext.includes('texture_half_float');

});

}

}

}

disableHalfFloatExtensionIfBroken(ctx);

#endif

return handle;

},

#if OFFSCREEN_FRAMEBUFFER

enableOffscreenFramebufferAttributes: function(webGLContextAttributes) {

webGLContextAttributes.renderViaOffscreenBackBuffer = true;

webGLContextAttributes.preserveDrawingBuffer = true;

},

// If WebGL is being proxied from a pthread to the main thread, we can't directly render to the WebGL default back buffer

// because of WebGL's implicit swap behavior. Therefore in such modes, create an offscreen render target surface to

// which rendering is performed to, and finally flipped to the main screen.

createOffscreenFramebuffer: function(context) {

var gl = context.GLctx;

// Create FBO

var fbo = gl.createFramebuffer();

gl.bindFramebuffer(0x8D40 /*GL_FRAMEBUFFER*/, fbo);

context.defaultFbo = fbo;

#if MAX_WEBGL_VERSION >= 2

context.defaultFboForbidBlitFramebuffer = false;

if (gl.getContextAttributes().antialias) {

context.defaultFboForbidBlitFramebuffer = true;

}

#if MIN_FIREFOX_VERSION < 67

else {

// The WebGL 2 blit path doesn't work in Firefox < 67 (except in fullscreen).

// https://bugzilla.mozilla.org/show_bug.cgi?id=1523030

var firefoxMatch = navigator.userAgent.toLowerCase().match(/firefox\/(\d\d)/);

if (firefoxMatch != null) {

var firefoxVersion = firefoxMatch[1];

context.defaultFboForbidBlitFramebuffer = firefoxVersion < 67;

}

}

#endif

#endif

// Create render targets to the FBO

context.defaultColorTarget = gl.createTexture();

context.defaultDepthTarget = gl.createRenderbuffer();

GL.resizeOffscreenFramebuffer(context); // Size them up correctly (use the same mechanism when resizing on demand)

gl.bindTexture(0xDE1 /*GL_TEXTURE_2D*/, context.defaultColorTarget);

gl.texParameteri(0xDE1 /*GL_TEXTURE_2D*/, 0x2801 /*GL_TEXTURE_MIN_FILTER*/, 0x2600 /*GL_NEAREST*/);

gl.texParameteri(0xDE1 /*GL_TEXTURE_2D*/, 0x2800 /*GL_TEXTURE_MAG_FILTER*/, 0x2600 /*GL_NEAREST*/);

gl.texParameteri(0xDE1 /*GL_TEXTURE_2D*/, 0x2802 /*GL_TEXTURE_WRAP_S*/, 0x812F /*GL_CLAMP_TO_EDGE*/);

gl.texParameteri(0xDE1 /*GL_TEXTURE_2D*/, 0x2803 /*GL_TEXTURE_WRAP_T*/, 0x812F /*GL_CLAMP_TO_EDGE*/);

gl.texImage2D(0xDE1 /*GL_TEXTURE_2D*/, 0, 0x1908 /*GL_RGBA*/, gl.canvas.width, gl.canvas.height, 0, 0x1908 /*GL_RGBA*/, 0x1401 /*GL_UNSIGNED_BYTE*/, null);

gl.framebufferTexture2D(0x8D40 /*GL_FRAMEBUFFER*/, 0x8CE0 /*GL_COLOR_ATTACHMENT0*/, 0xDE1 /*GL_TEXTURE_2D*/, context.defaultColorTarget, 0);

gl.bindTexture(0xDE1 /*GL_TEXTURE_2D*/, null);

// Create depth render target to the FBO

var depthTarget = gl.createRenderbuffer();

gl.bindRenderbuffer(0x8D41 /*GL_RENDERBUFFER*/, context.defaultDepthTarget);

gl.renderbufferStorage(0x8D41 /*GL_RENDERBUFFER*/, 0x81A5 /*GL_DEPTH_COMPONENT16*/, gl.canvas.width, gl.canvas.height);

gl.framebufferRenderbuffer(0x8D40 /*GL_FRAMEBUFFER*/, 0x8D00 /*GL_DEPTH_ATTACHMENT*/, 0x8D41 /*GL_RENDERBUFFER*/, context.defaultDepthTarget);

gl.bindRenderbuffer(0x8D41 /*GL_RENDERBUFFER*/, null);

// Create blitter

var vertices = [

-1, -1,

-1, 1,

1, -1,

1, 1

];

var vb = gl.createBuffer();

gl.bindBuffer(0x8892 /*GL_ARRAY_BUFFER*/, vb);

gl.bufferData(0x8892 /*GL_ARRAY_BUFFER*/, new Float32Array(vertices), 0x88E4 /*GL_STATIC_DRAW*/);

gl.bindBuffer(0x8892 /*GL_ARRAY_BUFFER*/, null);

context.blitVB = vb;

var vsCode =

'attribute vec2 pos;' +

'varying lowp vec2 tex;' +

'void main() { tex = pos * 0.5 + vec2(0.5,0.5); gl_Position = vec4(pos, 0.0, 1.0); }';

var vs = gl.createShader(0x8B31 /*GL_VERTEX_SHADER*/);

gl.shaderSource(vs, vsCode);

gl.compileShader(vs);

var fsCode =

'varying lowp vec2 tex;' +

'uniform sampler2D sampler;' +

'void main() { gl_FragColor = texture2D(sampler, tex); }';

var fs = gl.createShader(0x8B30 /*GL_FRAGMENT_SHADER*/);

gl.shaderSource(fs, fsCode);

gl.compileShader(fs);

var blitProgram = gl.createProgram();

gl.attachShader(blitProgram, vs);

gl.attachShader(blitProgram, fs);

gl.linkProgram(blitProgram);

context.blitProgram = blitProgram;

context.blitPosLoc = gl.getAttribLocation(blitProgram, "pos");

gl.useProgram(blitProgram);

gl.uniform1i(gl.getUniformLocation(blitProgram, "sampler"), 0);

gl.useProgram(null);

context.defaultVao = undefined;

if (gl.createVertexArray) {

context.defaultVao = gl.createVertexArray();

gl.bindVertexArray(context.defaultVao);

gl.enableVertexAttribArray(context.blitPosLoc);

gl.bindVertexArray(null);

}

},

resizeOffscreenFramebuffer: function(context) {

var gl = context.GLctx;

// Resize color buffer

if (context.defaultColorTarget) {

var prevTextureBinding = gl.getParameter(0x8069 /*GL_TEXTURE_BINDING_2D*/);

gl.bindTexture(0xDE1 /*GL_TEXTURE_2D*/, context.defaultColorTarget);

gl.texImage2D(0xDE1 /*GL_TEXTURE_2D*/, 0, 0x1908 /*GL_RGBA*/, gl.drawingBufferWidth, gl.drawingBufferHeight, 0, 0x1908 /*GL_RGBA*/, 0x1401 /*GL_UNSIGNED_BYTE*/, null);

gl.bindTexture(0xDE1 /*GL_TEXTURE_2D*/, prevTextureBinding);

}

// Resize depth buffer

if (context.defaultDepthTarget) {

var prevRenderBufferBinding = gl.getParameter(0x8CA7 /*GL_RENDERBUFFER_BINDING*/);

gl.bindRenderbuffer(0x8D41 /*GL_RENDERBUFFER*/, context.defaultDepthTarget);

gl.renderbufferStorage(0x8D41 /*GL_RENDERBUFFER*/, 0x81A5 /*GL_DEPTH_COMPONENT16*/, gl.drawingBufferWidth, gl.drawingBufferHeight); // TODO: Read context creation parameters for what type of depth and stencil to use

gl.bindRenderbuffer(0x8D41 /*GL_RENDERBUFFER*/, prevRenderBufferBinding);

}

},

// Renders the contents of the offscreen render target onto the visible screen.

blitOffscreenFramebuffer: function(context) {

var gl = context.GLctx;

var prevScissorTest = gl.getParameter(0xC11 /*GL_SCISSOR_TEST*/);

if (prevScissorTest) gl.disable(0xC11 /*GL_SCISSOR_TEST*/);

var prevFbo = gl.getParameter(0x8CA6 /*GL_FRAMEBUFFER_BINDING*/);

#if MAX_WEBGL_VERSION >= 2

if (gl.blitFramebuffer && !context.defaultFboForbidBlitFramebuffer) {

gl.bindFramebuffer(0x8CA8 /*GL_READ_FRAMEBUFFER*/, context.defaultFbo);

gl.bindFramebuffer(0x8CA9 /*GL_DRAW_FRAMEBUFFER*/, null);

gl.blitFramebuffer(0, 0, gl.canvas.width, gl.canvas.height,

0, 0, gl.canvas.width, gl.canvas.height,

0x4000 /*GL_COLOR_BUFFER_BIT*/, 0x2600/*GL_NEAREST*/);

}

else

#endif

{

gl.bindFramebuffer(0x8D40 /*GL_FRAMEBUFFER*/, null);

var prevProgram = gl.getParameter(0x8B8D /*GL_CURRENT_PROGRAM*/);

gl.useProgram(context.blitProgram);

var prevVB = gl.getParameter(0x8894 /*GL_ARRAY_BUFFER_BINDING*/);

gl.bindBuffer(0x8892 /*GL_ARRAY_BUFFER*/, context.blitVB);

var prevActiveTexture = gl.getParameter(0x84E0 /*GL_ACTIVE_TEXTURE*/);

gl.activeTexture(0x84C0 /*GL_TEXTURE0*/);

var prevTextureBinding = gl.getParameter(0x8069 /*GL_TEXTURE_BINDING_2D*/);

gl.bindTexture(0xDE1 /*GL_TEXTURE_2D*/, context.defaultColorTarget);

var prevBlend = gl.getParameter(0xBE2 /*GL_BLEND*/);

if (prevBlend) gl.disable(0xBE2 /*GL_BLEND*/);

var prevCullFace = gl.getParameter(0xB44 /*GL_CULL_FACE*/);

if (prevCullFace) gl.disable(0xB44 /*GL_CULL_FACE*/);

var prevDepthTest = gl.getParameter(0xB71 /*GL_DEPTH_TEST*/);

if (prevDepthTest) gl.disable(0xB71 /*GL_DEPTH_TEST*/);

var prevStencilTest = gl.getParameter(0xB90 /*GL_STENCIL_TEST*/);

if (prevStencilTest) gl.disable(0xB90 /*GL_STENCIL_TEST*/);

function draw() {

gl.vertexAttribPointer(context.blitPosLoc, 2, 0x1406 /*GL_FLOAT*/, false, 0, 0);

gl.drawArrays(5/*GL_TRIANGLE_STRIP*/, 0, 4);

}

#if !OFFSCREEN_FRAMEBUFFER_FORBID_VAO_PATH

if (context.defaultVao) {

// WebGL 2 or OES_vertex_array_object

var prevVAO = gl.getParameter(0x85B5 /*GL_VERTEX_ARRAY_BINDING*/);

gl.bindVertexArray(context.defaultVao);

draw();

gl.bindVertexArray(prevVAO);

}

else

#endif

{

var prevVertexAttribPointer = {

buffer: gl.getVertexAttrib(context.blitPosLoc, 0x889F /*GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING*/),

size: gl.getVertexAttrib(context.blitPosLoc, 0x8623 /*GL_VERTEX_ATTRIB_ARRAY_SIZE*/),

stride: gl.getVertexAttrib(context.blitPosLoc, 0x8624 /*GL_VERTEX_ATTRIB_ARRAY_STRIDE*/),

type: gl.getVertexAttrib(context.blitPosLoc, 0x8625 /*GL_VERTEX_ATTRIB_ARRAY_TYPE*/),

normalized: gl.getVertexAttrib(context.blitPosLoc, 0x886A /*GL_VERTEX_ATTRIB_ARRAY_NORMALIZED*/),

pointer: gl.getVertexAttribOffset(context.blitPosLoc, 0x8645 /*GL_VERTEX_ATTRIB_ARRAY_POINTER*/),

};

var maxVertexAttribs = gl.getParameter(0x8869 /*GL_MAX_VERTEX_ATTRIBS*/);

var prevVertexAttribEnables = [];

for (var i = 0; i < maxVertexAttribs; ++i) {

var prevEnabled = gl.getVertexAttrib(i, 0x8622 /*GL_VERTEX_ATTRIB_ARRAY_ENABLED*/);

var wantEnabled = i == context.blitPosLoc;

if (prevEnabled && !wantEnabled) {

gl.disableVertexAttribArray(i);

}

if (!prevEnabled && wantEnabled) {

gl.enableVertexAttribArray(i);

}

prevVertexAttribEnables[i] = prevEnabled;

}

draw();

for (var i = 0; i < maxVertexAttribs; ++i) {

var prevEnabled = prevVertexAttribEnables[i];

var nowEnabled = i == context.blitPosLoc;

if (prevEnabled && !nowEnabled) {

gl.enableVertexAttribArray(i);

}

if (!prevEnabled && nowEnabled) {

gl.disableVertexAttribArray(i);

}

}

gl.bindBuffer(0x8892 /*GL_ARRAY_BUFFER*/, prevVertexAttribPointer.buffer);

gl.vertexAttribPointer(context.blitPosLoc,

prevVertexAttribPointer.size,

prevVertexAttribPointer.type,

prevVertexAttribPointer.normalized,

prevVertexAttribPointer.stride,

prevVertexAttribPointer.offset);

}

if (prevStencilTest) gl.enable(0xB90 /*GL_STENCIL_TEST*/);

if (prevDepthTest) gl.enable(0xB71 /*GL_DEPTH_TEST*/);

if (prevCullFace) gl.enable(0xB44 /*GL_CULL_FACE*/);

if (prevBlend) gl.enable(0xBE2 /*GL_BLEND*/);

gl.bindTexture(0xDE1 /*GL_TEXTURE_2D*/, prevTextureBinding);

gl.activeTexture(prevActiveTexture);

gl.bindBuffer(0x8892 /*GL_ARRAY_BUFFER*/, prevVB);

gl.useProgram(prevProgram);

}

gl.bindFramebuffer(0x8D40 /*GL_FRAMEBUFFER*/, prevFbo);

if (prevScissorTest) gl.enable(0xC11 /*GL_SCISSOR_TEST*/);

},

#endif

registerContext: function(ctx, webGLContextAttributes) {

#if USE_PTHREADS

// with pthreads a context is a location in memory with some synchronized data between threads

var handle = _malloc(8);

#if GL_ASSERTIONS

assert(handle, 'malloc() failed in GL.registerContext!');

#endif

#if GL_SUPPORT_EXPLICIT_SWAP_CONTROL

{{{ makeSetValue('handle', 0, 'webGLContextAttributes.explicitSwapControl', 'i32')}}}; // explicitSwapControl

#endif

{{{ makeSetValue('handle', 4, '_pthread_self()', 'i32')}}}; // the thread pointer of the thread that owns the control of the context

#else // USE_PTHREADS

// without pthreads a context is just an integer ID

var handle = GL.getNewId(GL.contexts);

#endif // USE_PTHREADS

var context = {

handle: handle,

attributes: webGLContextAttributes,

version: webGLContextAttributes.majorVersion,

GLctx: ctx

};

#if WORKAROUND_OLD_WEBGL_UNIFORM_UPLOAD_IGNORED_OFFSET_BUG

context.cannotHandleOffsetsInUniformArrayViews = (function(g) {

function b(c, t) {

var s = g.createShader(t);

g.shaderSource(s, c);

g.compileShader(s);

return s;

}

try {

var p = g.createProgram(); // Note: we do not delete this program so it stays part of the context we created, but that is ok - it does not do anything and we want to keep this detection size minimal.

g.attachShader(p, b("attribute vec4 p;void main(){gl_Position=p;}", 0x8B31 /*GL_VERTEX_SHADER*/));

g.attachShader(p, b("precision lowp float;uniform vec4 u;void main(){gl_FragColor=u;}", 0x8B30 /*GL_FRAGMENT_SHADER*/));

g.linkProgram(p);

var h = new Float32Array(8);

h[4] = 1;

g.useProgram(p);

var l = g.getUniformLocation(p, "u");

g.uniform4fv(l, h.subarray(4, 8)); // Uploading a 4-vector GL uniform from last four elements of array [0,0,0,0,1,0,0,0], i.e. uploading vec4=(1,0,0,0) at offset=4.

return !g.getUniform(p, l)[0]; // in proper WebGL we expect to read back the vector we just uploaded: (1,0,0,0). On buggy browser would instead have uploaded offset=0 of above array, i.e. vec4=(0,0,0,0)

} catch(e) { return false; } // If we get an exception, we assume we got some other error, and do not trigger this workaround.

})();

#endif