/**

* @license

* Copyright 2010 The Emscripten Authors

* SPDX-License-Identifier: MIT

*/

var LibraryGLEmulation = {

// GL emulation: provides misc. functionality not present in OpenGL ES 2.0 or WebGL

$GLEmulation__deps: ['$GLImmediateSetup', 'glEnable', 'glDisable', 'glIsEnabled', 'glGetBooleanv', 'glGetIntegerv', 'glGetString', 'glCreateShader', 'glShaderSource', 'glCompileShader', 'glAttachShader', 'glDetachShader', 'glUseProgram', 'glDeleteProgram', 'glBindAttribLocation', 'glLinkProgram', 'glBindBuffer', 'glGetFloatv', 'glHint', 'glEnableVertexAttribArray', 'glDisableVertexAttribArray', 'glVertexAttribPointer', 'glActiveTexture', '$stringToNewUTF8'],

$GLEmulation__postset:

#if USE_CLOSURE_COMPILER

// Forward declare GL functions that are overridden by GLEmulation here to appease Closure compiler.

'/**@suppress {duplicate, undefinedVars}*/var _emscripten_glDrawArrays;' +

'/**@suppress {duplicate, undefinedVars}*/var _emscripten_glDrawElements;' +

'/**@suppress {duplicate, undefinedVars}*/var _emscripten_glActiveTexture;' +

'/**@suppress {duplicate, undefinedVars}*/var _emscripten_glEnable;' +

'/**@suppress {duplicate, undefinedVars}*/var _emscripten_glDisable;' +

'/**@suppress {duplicate, undefinedVars}*/var _emscripten_glTexEnvf;' +

'/**@suppress {duplicate, undefinedVars}*/var _emscripten_glTexEnvi;' +

'/**@suppress {duplicate, undefinedVars}*/var _emscripten_glTexEnvfv;' +

'/**@suppress {duplicate, undefinedVars}*/var _emscripten_glGetIntegerv;' +

'/**@suppress {duplicate, undefinedVars}*/var _emscripten_glIsEnabled;' +

'/**@suppress {duplicate, undefinedVars}*/var _emscripten_glGetBooleanv;' +

'/**@suppress {duplicate, undefinedVars}*/var _emscripten_glGetString;' +

'/**@suppress {duplicate, undefinedVars}*/var _emscripten_glCreateShader;' +

'/**@suppress {duplicate, undefinedVars}*/var _emscripten_glShaderSource;' +

'/**@suppress {duplicate, undefinedVars}*/var _emscripten_glCompileShader;' +

'/**@suppress {duplicate, undefinedVars}*/var _emscripten_glAttachShader;' +

'/**@suppress {duplicate, undefinedVars}*/var _emscripten_glDetachShader;' +

'/**@suppress {duplicate, undefinedVars}*/var _emscripten_glUseProgram;' +

'/**@suppress {duplicate, undefinedVars}*/var _emscripten_glDeleteProgram;' +

'/**@suppress {duplicate, undefinedVars}*/var _emscripten_glBindAttribLocation;' +

'/**@suppress {duplicate, undefinedVars}*/var _emscripten_glLinkProgram;' +

'/**@suppress {duplicate, undefinedVars}*/var _emscripten_glBindBuffer;' +

'/**@suppress {duplicate, undefinedVars}*/var _emscripten_glGetFloatv;' +

'/**@suppress {duplicate, undefinedVars}*/var _emscripten_glHint;' +

'/**@suppress {duplicate, undefinedVars}*/var _emscripten_glEnableVertexAttribArray;' +

'/**@suppress {duplicate, undefinedVars}*/var _emscripten_glDisableVertexAttribArray;' +

'/**@suppress {duplicate, undefinedVars}*/var _emscripten_glVertexAttribPointer;' +

'/**@suppress {duplicate, undefinedVars}*/var _glTexEnvf;' +

'/**@suppress {duplicate, undefinedVars}*/var _glTexEnvi;' +

'/**@suppress {duplicate, undefinedVars}*/var _glTexEnvfv;' +

'/**@suppress {duplicate, undefinedVars}*/var _glGetTexEnviv;' +

'/**@suppress {duplicate, undefinedVars}*/var _glGetTexEnvfv;' +

#endif

'GLEmulation.init();',

$GLEmulation: {

// Fog support. Partial, we assume shaders are used that implement fog. We just pass them uniforms

fogStart: 0,

fogEnd: 1,

fogDensity: 1.0,

fogColor: null,

fogMode: 0x800, // GL_EXP

fogEnabled: false,

// GL_CLIP_PLANE support

MAX_CLIP_PLANES: 6,

clipPlaneEnabled: [false, false, false, false, false, false],

clipPlaneEquation: [],

// GL_LIGHTING support

lightingEnabled: false,

lightModelAmbient: null,

lightModelLocalViewer: false,

lightModelTwoSide: false,

materialAmbient: null,

materialDiffuse: null,

materialSpecular: null,

materialShininess: null,

materialEmission: null,

MAX_LIGHTS: 8,

lightEnabled: [false, false, false, false, false, false, false, false],

lightAmbient: [],

lightDiffuse: [],

lightSpecular: [],

lightPosition: [],

// TODO attenuation modes of lights

// GL_POINTS support.

pointSize: 1.0,

// VAO support

vaos: [],

currentVao: null,

enabledVertexAttribArrays: {}, // helps with vao cleanups

hasRunInit: false,

// Find a token in a shader source string

findToken: function(source, token) {

function isIdentChar(ch) {

if (ch >= 48 && ch <= 57) // 0-9

return true;

if (ch >= 65 && ch <= 90) // A-Z

return true;

if (ch >= 97 && ch <= 122) // a-z

return true;

return false;

}

var i = -1;

do {

i = source.indexOf(token, i + 1);

if (i < 0) {

break;

}

if (i > 0 && isIdentChar(source[i - 1])) {

continue;

}

i += token.length;

if (i < source.length - 1 && isIdentChar(source[i + 1])) {

continue;

}

return true;

} while (true);

return false;

},

init: function() {

// Do not activate immediate/emulation code (e.g. replace glDrawElements) when in FULL_ES2 mode.

// We do not need full emulation, we instead emulate client-side arrays etc. in FULL_ES2 code in

// a straightforward manner, and avoid not having a bound buffer be ambiguous between es2 emulation

// code and legacy gl emulation code.

#if FULL_ES2

return;

#endif

if (GLEmulation.hasRunInit) {

return;

}

GLEmulation.hasRunInit = true;

GLEmulation.fogColor = new Float32Array(4);

for (var clipPlaneId = 0; clipPlaneId < GLEmulation.MAX_CLIP_PLANES; clipPlaneId++) {

GLEmulation.clipPlaneEquation[clipPlaneId] = new Float32Array(4);

}

// set defaults for GL_LIGHTING

GLEmulation.lightModelAmbient = new Float32Array([0.2, 0.2, 0.2, 1.0]);

GLEmulation.materialAmbient = new Float32Array([0.2, 0.2, 0.2, 1.0]);

GLEmulation.materialDiffuse = new Float32Array([0.8, 0.8, 0.8, 1.0]);

GLEmulation.materialSpecular = new Float32Array([0.0, 0.0, 0.0, 1.0]);

GLEmulation.materialShininess = new Float32Array([0.0]);

GLEmulation.materialEmission = new Float32Array([0.0, 0.0, 0.0, 1.0]);

for (var lightId = 0; lightId < GLEmulation.MAX_LIGHTS; lightId++) {

GLEmulation.lightAmbient[lightId] = new Float32Array([0.0, 0.0, 0.0, 1.0]);

GLEmulation.lightDiffuse[lightId] = lightId ? new Float32Array([0.0, 0.0, 0.0, 1.0]) : new Float32Array([1.0, 1.0, 1.0, 1.0]);

GLEmulation.lightSpecular[lightId] = lightId ? new Float32Array([0.0, 0.0, 0.0, 1.0]) : new Float32Array([1.0, 1.0, 1.0, 1.0]);

GLEmulation.lightPosition[lightId] = new Float32Array([0.0, 0.0, 1.0, 0.0]);

}

// Add some emulation workarounds

err('WARNING: using emscripten GL emulation. This is a collection of limited workarounds, do not expect it to work.');

#if GL_UNSAFE_OPTS == 1

err('WARNING: using emscripten GL emulation unsafe opts. If weirdness happens, try -s GL_UNSAFE_OPTS=0');

#endif

// XXX some of the capabilities we don't support may lead to incorrect rendering, if we do not emulate them in shaders

var validCapabilities = {

0xB44: 1, // GL_CULL_FACE

0xBE2: 1, // GL_BLEND

0xBD0: 1, // GL_DITHER,

0xB90: 1, // GL_STENCIL_TEST

0xB71: 1, // GL_DEPTH_TEST

0xC11: 1, // GL_SCISSOR_TEST

0x8037: 1, // GL_POLYGON_OFFSET_FILL

0x809E: 1, // GL_SAMPLE_ALPHA_TO_COVERAGE

0x80A0: 1 // GL_SAMPLE_COVERAGE

};

#if RELOCATABLE

{{{

(updateExport = function(name) {

var name = '_' + name;

var exported = 'Module["' + name + '"]';

// make sure we write to an existing export, and are not repeating ourselves

return 'assert(' + exported + ' !== ' + name + '); ' + exported + ' = ' + name + ';';

}, '')

}}}

#else

{{{ (updateExport = function(){ return '' }, '') }}}

#endif

var glEnable = _glEnable;

_glEnable = _emscripten_glEnable = function _glEnable(cap) {

// Clean up the renderer on any change to the rendering state. The optimization of

// skipping renderer setup is aimed at the case of multiple glDraw* right after each other

if (GLImmediate.lastRenderer) GLImmediate.lastRenderer.cleanup();

if (cap == 0xB60 /* GL_FOG */) {

if (GLEmulation.fogEnabled != true) {

GLImmediate.currentRenderer = null; // Fog parameter is part of the FFP shader state, we must re-lookup the renderer to use.

GLEmulation.fogEnabled = true;

}

return;

} else if ((cap >= 0x3000) && (cap < 0x3006) /* GL_CLIP_PLANE0 to GL_CLIP_PLANE5 */) {

var clipPlaneId = cap - 0x3000;

if (GLEmulation.clipPlaneEnabled[clipPlaneId] != true) {

GLImmediate.currentRenderer = null; // clip plane parameter is part of the FFP shader state, we must re-lookup the renderer to use.

GLEmulation.clipPlaneEnabled[clipPlaneId] = true;

}

return;

} else if ((cap >= 0x4000) && (cap < 0x4008) /* GL_LIGHT0 to GL_LIGHT7 */) {

var lightId = cap - 0x4000;

if (GLEmulation.lightEnabled[lightId] != true) {

GLImmediate.currentRenderer = null; // light parameter is part of the FFP shader state, we must re-lookup the renderer to use.

GLEmulation.lightEnabled[lightId] = true;

}

return;

} else if (cap == 0xB50 /* GL_LIGHTING */) {

if (GLEmulation.lightingEnabled != true) {

GLImmediate.currentRenderer = null; // light parameter is part of the FFP shader state, we must re-lookup the renderer to use.

GLEmulation.lightingEnabled = true;

}

return;

} else if (cap == 0xDE1 /* GL_TEXTURE_2D */) {

// XXX not according to spec, and not in desktop GL, but works in some GLES1.x apparently, so support

// it by forwarding to glEnableClientState

/* Actually, let's not, for now. (This sounds exceedingly broken)

* This is in gl_ps_workaround2.c.

_glEnableClientState(cap);

*/

return;

} else if (!(cap in validCapabilities)) {

return;

}

glEnable(cap);

};

{{{ updateExport('glEnable') }}}

var glDisable = _glDisable;

_glDisable = _emscripten_glDisable = function _glDisable(cap) {

if (GLImmediate.lastRenderer) GLImmediate.lastRenderer.cleanup();

if (cap == 0xB60 /* GL_FOG */) {

if (GLEmulation.fogEnabled != false) {

GLImmediate.currentRenderer = null; // Fog parameter is part of the FFP shader state, we must re-lookup the renderer to use.

GLEmulation.fogEnabled = false;

}

return;

} else if ((cap >= 0x3000) && (cap < 0x3006) /* GL_CLIP_PLANE0 to GL_CLIP_PLANE5 */) {

var clipPlaneId = cap - 0x3000;

if (GLEmulation.clipPlaneEnabled[clipPlaneId] != false) {

GLImmediate.currentRenderer = null; // clip plane parameter is part of the FFP shader state, we must re-lookup the renderer to use.

GLEmulation.clipPlaneEnabled[clipPlaneId] = false;

}

return;

} else if ((cap >= 0x4000) && (cap < 0x4008) /* GL_LIGHT0 to GL_LIGHT7 */) {

var lightId = cap - 0x4000;

if (GLEmulation.lightEnabled[lightId] != false) {

GLImmediate.currentRenderer = null; // light parameter is part of the FFP shader state, we must re-lookup the renderer to use.

GLEmulation.lightEnabled[lightId] = false;

}

return;

} else if (cap == 0xB50 /* GL_LIGHTING */) {

if (GLEmulation.lightingEnabled != false) {

GLImmediate.currentRenderer = null; // Fog parameter is part of the FFP shader state, we must re-lookup the renderer to use.

GLEmulation.lightingEnabled = false;

}

return;

} else if (cap == 0xDE1 /* GL_TEXTURE_2D */) {

// XXX not according to spec, and not in desktop GL, but works in some GLES1.x apparently, so support

// it by forwarding to glDisableClientState

/* Actually, let's not, for now. (This sounds exceedingly broken)

* This is in gl_ps_workaround2.c.

_glDisableClientState(cap);

*/

return;

} else if (!(cap in validCapabilities)) {

return;

}

glDisable(cap);

};

{{{ updateExport('glDisable') }}}

_glIsEnabled = _emscripten_glIsEnabled = function _glIsEnabled(cap) {

if (cap == 0xB60 /* GL_FOG */) {

return GLEmulation.fogEnabled ? 1 : 0;

} else if ((cap >= 0x3000) && (cap < 0x3006) /* GL_CLIP_PLANE0 to GL_CLIP_PLANE5 */) {

var clipPlaneId = cap - 0x3000;

return GLEmulation.clipPlaneEnabled[clipPlaneId] ? 1 : 0;

} else if ((cap >= 0x4000) && (cap < 0x4008) /* GL_LIGHT0 to GL_LIGHT7 */) {

var lightId = cap - 0x4000;

return GLEmulation.lightEnabled[lightId] ? 1 : 0;

} else if (cap == 0xB50 /* GL_LIGHTING */) {

return GLEmulation.lightingEnabled ? 1 : 0;

} else if (!(cap in validCapabilities)) {

return 0;

}

return GLctx.isEnabled(cap);

};

{{{ updateExport('glIsEnabled') }}}

var glGetBooleanv = _glGetBooleanv;

_glGetBooleanv = _emscripten_glGetBooleanv = function _glGetBooleanv(pname, p) {

var attrib = GLEmulation.getAttributeFromCapability(pname);

if (attrib !== null) {

var result = GLImmediate.enabledClientAttributes[attrib];

{{{ makeSetValue('p', '0', 'result === true ? 1 : 0', 'i8') }}};

return;

}

glGetBooleanv(pname, p);

};

{{{ updateExport('glGetBooleanv') }}}

var glGetIntegerv = _glGetIntegerv;

_glGetIntegerv = _emscripten_glGetIntegerv = function _glGetIntegerv(pname, params) {

switch (pname) {

case 0x84E2: pname = GLctx.MAX_TEXTURE_IMAGE_UNITS /* fake it */; break; // GL_MAX_TEXTURE_UNITS

case 0x8B4A: { // GL_MAX_VERTEX_UNIFORM_COMPONENTS_ARB

var result = GLctx.getParameter(GLctx.MAX_VERTEX_UNIFORM_VECTORS);

{{{ makeSetValue('params', '0', 'result*4', 'i32') }}}; // GLES gives num of 4-element vectors, GL wants individual components, so multiply

return;

}

case 0x8B49: { // GL_MAX_FRAGMENT_UNIFORM_COMPONENTS_ARB

var result = GLctx.getParameter(GLctx.MAX_FRAGMENT_UNIFORM_VECTORS);

{{{ makeSetValue('params', '0', 'result*4', 'i32') }}}; // GLES gives num of 4-element vectors, GL wants individual components, so multiply

return;

}

case 0x8B4B: { // GL_MAX_VARYING_FLOATS_ARB

var result = GLctx.getParameter(GLctx.MAX_VARYING_VECTORS);

{{{ makeSetValue('params', '0', 'result*4', 'i32') }}}; // GLES gives num of 4-element vectors, GL wants individual components, so multiply

return;

}

case 0x8871: pname = GLctx.MAX_COMBINED_TEXTURE_IMAGE_UNITS /* close enough */; break; // GL_MAX_TEXTURE_COORDS

case 0x807A: { // GL_VERTEX_ARRAY_SIZE

var attribute = GLImmediate.clientAttributes[GLImmediate.VERTEX];

{{{ makeSetValue('params', '0', 'attribute ? attribute.size : 0', 'i32') }}};

return;

}

case 0x807B: { // GL_VERTEX_ARRAY_TYPE

var attribute = GLImmediate.clientAttributes[GLImmediate.VERTEX];

{{{ makeSetValue('params', '0', 'attribute ? attribute.type : 0', 'i32') }}};

return;

}

case 0x807C: { // GL_VERTEX_ARRAY_STRIDE

var attribute = GLImmediate.clientAttributes[GLImmediate.VERTEX];

{{{ makeSetValue('params', '0', 'attribute ? attribute.stride : 0', 'i32') }}};

return;

}

case 0x8081: { // GL_COLOR_ARRAY_SIZE

var attribute = GLImmediate.clientAttributes[GLImmediate.COLOR];

{{{ makeSetValue('params', '0', 'attribute ? attribute.size : 0', 'i32') }}};

return;

}

case 0x8082: { // GL_COLOR_ARRAY_TYPE

var attribute = GLImmediate.clientAttributes[GLImmediate.COLOR];

{{{ makeSetValue('params', '0', 'attribute ? attribute.type : 0', 'i32') }}};

return;

}

case 0x8083: { // GL_COLOR_ARRAY_STRIDE

var attribute = GLImmediate.clientAttributes[GLImmediate.COLOR];

{{{ makeSetValue('params', '0', 'attribute ? attribute.stride : 0', 'i32') }}};

return;

}

case 0x8088: { // GL_TEXTURE_COORD_ARRAY_SIZE

var attribute = GLImmediate.clientAttributes[GLImmediate.TEXTURE0 + GLImmediate.clientActiveTexture];

{{{ makeSetValue('params', '0', 'attribute ? attribute.size : 0', 'i32') }}};

return;

}

case 0x8089: { // GL_TEXTURE_COORD_ARRAY_TYPE

var attribute = GLImmediate.clientAttributes[GLImmediate.TEXTURE0 + GLImmediate.clientActiveTexture];

{{{ makeSetValue('params', '0', 'attribute ? attribute.type : 0', 'i32') }}};

return;

}

case 0x808A: { // GL_TEXTURE_COORD_ARRAY_STRIDE

var attribute = GLImmediate.clientAttributes[GLImmediate.TEXTURE0 + GLImmediate.clientActiveTexture];

{{{ makeSetValue('params', '0', 'attribute ? attribute.stride : 0', 'i32') }}};

return;

}

case 0x0D32: { // GL_MAX_CLIP_PLANES

{{{ makeSetValue('params', '0', 'GLEmulation.MAX_CLIP_PLANES', 'i32') }}}; // all implementations need to support atleast 6

return;

}

case 0x0BA0: { // GL_MATRIX_MODE

{{{ makeSetValue('params', '0', 'GLImmediate.currentMatrix + 0x1700', 'i32') }}};

return;

}

}

glGetIntegerv(pname, params);

};

{{{ updateExport('glGetIntegerv') }}}

var glGetString = _glGetString;

_glGetString = _emscripten_glGetString = function _glGetString(name_) {

if (GL.stringCache[name_]) return GL.stringCache[name_];

switch (name_) {

case 0x1F03 /* GL_EXTENSIONS */: // Add various extensions that we can support

var ret = stringToNewUTF8((GLctx.getSupportedExtensions() || []).join(' ') +

' GL_EXT_texture_env_combine GL_ARB_texture_env_crossbar GL_ATI_texture_env_combine3 GL_NV_texture_env_combine4 GL_EXT_texture_env_dot3 GL_ARB_multitexture GL_ARB_vertex_buffer_object GL_EXT_framebuffer_object GL_ARB_vertex_program GL_ARB_fragment_program GL_ARB_shading_language_100 GL_ARB_shader_objects GL_ARB_vertex_shader GL_ARB_fragment_shader GL_ARB_texture_cube_map GL_EXT_draw_range_elements' +

(GL.currentContext.compressionExt ? ' GL_ARB_texture_compression GL_EXT_texture_compression_s3tc' : '') +

(GL.currentContext.anisotropicExt ? ' GL_EXT_texture_filter_anisotropic' : '')

);

GL.stringCache[name_] = ret;

return ret;

}

return glGetString(name_);

};

{{{ updateExport('glGetString') }}}

// Do some automatic rewriting to work around GLSL differences. Note that this must be done in

// tandem with the rest of the program, by itself it cannot suffice.

// Note that we need to remember shader types for this rewriting, saving sources makes it easier to debug.

GL.shaderInfos = {};

#if GL_DEBUG

GL.shaderSources = {};

GL.shaderOriginalSources = {};

#endif

var glCreateShader = _glCreateShader;

_glCreateShader = _emscripten_glCreateShader = function _glCreateShader(shaderType) {

var id = glCreateShader(shaderType);

GL.shaderInfos[id] = {

type: shaderType,

ftransform: false

};

return id;

};

{{{ updateExport('glCreateShader') }}}

function ensurePrecision(source) {

if (!/precision +(low|medium|high)p +float *;/.test(source)) {

source = '#ifdef GL_FRAGMENT_PRECISION_HIGH\nprecision highp float;\n#else\nprecision mediump float;\n#endif\n' + source;

}

return source;

}

var glShaderSource = _glShaderSource;

_glShaderSource = _emscripten_glShaderSource = function _glShaderSource(shader, count, string, length) {

var source = GL.getSource(shader, count, string, length);

#if GL_DEBUG

console.log("glShaderSource: Input: \n" + source);

GL.shaderOriginalSources[shader] = source;

#endif

// XXX We add attributes and uniforms to shaders. The program can ask for the # of them, and see the

// ones we generated, potentially confusing it? Perhaps we should hide them.

if (GL.shaderInfos[shader].type == GLctx.VERTEX_SHADER) {

// Replace ftransform() with explicit project/modelview transforms, and add position and matrix info.

var has_pm = source.search(/u_projection/) >= 0;

var has_mm = source.search(/u_modelView/) >= 0;

var has_pv = source.search(/a_position/) >= 0;

var need_pm = 0, need_mm = 0, need_pv = 0;

var old = source;

source = source.replace(/ftransform\(\)/g, '(u_projection * u_modelView * a_position)');

if (old != source) need_pm = need_mm = need_pv = 1;

old = source;

source = source.replace(/gl_ProjectionMatrix/g, 'u_projection');

if (old != source) need_pm = 1;

old = source;

source = source.replace(/gl_ModelViewMatrixTranspose\[2\]/g, 'vec4(u_modelView[0][2], u_modelView[1][2], u_modelView[2][2], u_modelView[3][2])'); // XXX extremely inefficient

if (old != source) need_mm = 1;

old = source;

source = source.replace(/gl_ModelViewMatrix/g, 'u_modelView');

if (old != source) need_mm = 1;

old = source;

source = source.replace(/gl_Vertex/g, 'a_position');

if (old != source) need_pv = 1;

old = source;

source = source.replace(/gl_ModelViewProjectionMatrix/g, '(u_projection * u_modelView)');

if (old != source) need_pm = need_mm = 1;

if (need_pv && !has_pv) source = 'attribute vec4 a_position; \n' + source;

if (need_mm && !has_mm) source = 'uniform mat4 u_modelView; \n' + source;

if (need_pm && !has_pm) source = 'uniform mat4 u_projection; \n' + source;

GL.shaderInfos[shader].ftransform = need_pm || need_mm || need_pv; // we will need to provide the fixed function stuff as attributes and uniforms

for (var i = 0; i < GLImmediate.MAX_TEXTURES; i++) {

// XXX To handle both regular texture mapping and cube mapping, we use vec4 for tex coordinates.

old = source;

var need_vtc = source.search('v_texCoord' + i) == -1;

source = source.replace(new RegExp('gl_TexCoord\\[' + i + '\\]', 'g'), 'v_texCoord' + i)

.replace(new RegExp('gl_MultiTexCoord' + i, 'g'), 'a_texCoord' + i);

if (source != old) {

source = 'attribute vec4 a_texCoord' + i + '; \n' + source;

if (need_vtc) {

source = 'varying vec4 v_texCoord' + i + '; \n' + source;

}

}

old = source;

source = source.replace(new RegExp('gl_TextureMatrix\\[' + i + '\\]', 'g'), 'u_textureMatrix' + i);

if (source != old) {

source = 'uniform mat4 u_textureMatrix' + i + '; \n' + source;

}

}

if (source.includes('gl_FrontColor')) {

source = 'varying vec4 v_color; \n' +

source.replace(/gl_FrontColor/g, 'v_color');

}

if (source.includes('gl_Color')) {

source = 'attribute vec4 a_color; \n' +

source.replace(/gl_Color/g, 'a_color');

}

if (source.includes('gl_Normal')) {

source = 'attribute vec3 a_normal; \n' +

source.replace(/gl_Normal/g, 'a_normal');

}

// fog

if (source.includes('gl_FogFragCoord')) {

source = 'varying float v_fogFragCoord; \n' +

source.replace(/gl_FogFragCoord/g, 'v_fogFragCoord');

}

} else { // Fragment shader

for (i = 0; i < GLImmediate.MAX_TEXTURES; i++) {

old = source;

source = source.replace(new RegExp('gl_TexCoord\\[' + i + '\\]', 'g'), 'v_texCoord' + i);

if (source != old) {

source = 'varying vec4 v_texCoord' + i + '; \n' + source;

}

}

if (source.includes('gl_Color')) {

source = 'varying vec4 v_color; \n' + source.replace(/gl_Color/g, 'v_color');

}

if (source.includes('gl_Fog.color')) {

source = 'uniform vec4 u_fogColor; \n' +

source.replace(/gl_Fog.color/g, 'u_fogColor');

}

if (source.includes('gl_Fog.end')) {

source = 'uniform float u_fogEnd; \n' +

source.replace(/gl_Fog.end/g, 'u_fogEnd');

}

if (source.includes('gl_Fog.scale')) {

source = 'uniform float u_fogScale; \n' +

source.replace(/gl_Fog.scale/g, 'u_fogScale');

}

if (source.includes('gl_Fog.density')) {

source = 'uniform float u_fogDensity; \n' +

source.replace(/gl_Fog.density/g, 'u_fogDensity');

}

if (source.includes('gl_FogFragCoord')) {

source = 'varying float v_fogFragCoord; \n' +

source.replace(/gl_FogFragCoord/g, 'v_fogFragCoord');

}

source = ensurePrecision(source);

}

#if GL_DEBUG

GL.shaderSources[shader] = source;

console.log("glShaderSource: Output: \n" + source);

#endif

GLctx.shaderSource(GL.shaders[shader], source);

};

{{{ updateExport('glShaderSource') }}}

var glCompileShader = _glCompileShader;

_glCompileShader = _emscripten_glCompileShader = function _glCompileShader(shader) {

GLctx.compileShader(GL.shaders[shader]);

#if GL_DEBUG

if (!GLctx.getShaderParameter(GL.shaders[shader], GLctx.COMPILE_STATUS)) {

err('Failed to compile shader: ' + GLctx.getShaderInfoLog(GL.shaders[shader]));

err('Info: ' + JSON.stringify(GL.shaderInfos[shader]));

err('Original source: ' + GL.shaderOriginalSources[shader]);

err('Source: ' + GL.shaderSources[shader]);

throw 'Shader compilation halt';

}

#endif

};

{{{ updateExport('glCompileShader') }}}

GL.programShaders = {};

var glAttachShader = _glAttachShader;

_glAttachShader = _emscripten_glAttachShader = function _glAttachShader(program, shader) {

if (!GL.programShaders[program]) GL.programShaders[program] = [];

GL.programShaders[program].push(shader);

glAttachShader(program, shader);

};

{{{ updateExport('glAttachShader') }}}

var glDetachShader = _glDetachShader;

_glDetachShader = _emscripten_glDetachShader = function _glDetachShader(program, shader) {

var programShader = GL.programShaders[program];

if (!programShader) {

err('WARNING: _glDetachShader received invalid program: ' + program);

return;

}

var index = programShader.indexOf(shader);

programShader.splice(index, 1);

glDetachShader(program, shader);

};

{{{ updateExport('glDetachShader') }}}

var glUseProgram = _glUseProgram;

_glUseProgram = _emscripten_glUseProgram = function _glUseProgram(program) {

#if GL_DEBUG

if (GL.debug) {

err('[using program with shaders]');

if (program) {

GL.programShaders[program].forEach(function(shader) {

err(' shader ' + shader + ', original source: ' + GL.shaderOriginalSources[shader]);

err(' Source: ' + GL.shaderSources[shader]);

});

}

}

#endif

if (GL.currProgram != program) {

GLImmediate.currentRenderer = null; // This changes the FFP emulation shader program, need to recompute that.

GL.currProgram = program;

GLImmediate.fixedFunctionProgram = 0;

glUseProgram(program);

}

}

{{{ updateExport('glUseProgram') }}}

var glDeleteProgram = _glDeleteProgram;

_glDeleteProgram = _emscripten_glDeleteProgram = function _glDeleteProgram(program) {

glDeleteProgram(program);

if (program == GL.currProgram) {

GLImmediate.currentRenderer = null; // This changes the FFP emulation shader program, need to recompute that.

GL.currProgram = 0;

}

};

{{{ updateExport('glDeleteProgram') }}}

// If attribute 0 was not bound, bind it to 0 for WebGL performance reasons. Track if 0 is free for that.

var zeroUsedPrograms = {};

var glBindAttribLocation = _glBindAttribLocation;

_glBindAttribLocation = _emscripten_glBindAttribLocation = function _glBindAttribLocation(program, index, name) {

if (index == 0) zeroUsedPrograms[program] = true;

glBindAttribLocation(program, index, name);

};

{{{ updateExport('glBindAttribLocation') }}}

var glLinkProgram = _glLinkProgram;

_glLinkProgram = _emscripten_glLinkProgram = function _glLinkProgram(program) {

if (!(program in zeroUsedPrograms)) {

GLctx.bindAttribLocation(GL.programs[program], 0, 'a_position');

}

glLinkProgram(program);

};

{{{ updateExport('glLinkProgram') }}}

var glBindBuffer = _glBindBuffer;

_glBindBuffer = _emscripten_glBindBuffer = function _glBindBuffer(target, buffer) {

glBindBuffer(target, buffer);

if (target == GLctx.ARRAY_BUFFER) {

if (GLEmulation.currentVao) {

#if ASSERTIONS

assert(GLEmulation.currentVao.arrayBuffer == buffer || GLEmulation.currentVao.arrayBuffer == 0 || buffer == 0, 'TODO: support for multiple array buffers in vao');

#endif

GLEmulation.currentVao.arrayBuffer = buffer;

}

} else if (target == GLctx.ELEMENT_ARRAY_BUFFER) {

if (GLEmulation.currentVao) GLEmulation.currentVao.elementArrayBuffer = buffer;

}

};

{{{ updateExport('glBindBuffer') }}}

var glGetFloatv = _glGetFloatv;

_glGetFloatv = _emscripten_glGetFloatv = function _glGetFloatv(pname, params) {

if (pname == 0xBA6) { // GL_MODELVIEW_MATRIX

HEAPF32.set(GLImmediate.matrix[0/*m*/], params >> 2);

} else if (pname == 0xBA7) { // GL_PROJECTION_MATRIX

HEAPF32.set(GLImmediate.matrix[1/*p*/], params >> 2);

} else if (pname == 0xBA8) { // GL_TEXTURE_MATRIX

HEAPF32.set(GLImmediate.matrix[2/*t*/ + GLImmediate.clientActiveTexture], params >> 2);

} else if (pname == 0xB66) { // GL_FOG_COLOR

HEAPF32.set(GLEmulation.fogColor, params >> 2);

} else if (pname == 0xB63) { // GL_FOG_START

{{{ makeSetValue('params', '0', 'GLEmulation.fogStart', 'float') }}};

} else if (pname == 0xB64) { // GL_FOG_END

{{{ makeSetValue('params', '0', 'GLEmulation.fogEnd', 'float') }}};

} else if (pname == 0xB62) { // GL_FOG_DENSITY

{{{ makeSetValue('params', '0', 'GLEmulation.fogDensity', 'float') }}};

} else if (pname == 0xB65) { // GL_FOG_MODE

{{{ makeSetValue('params', '0', 'GLEmulation.fogMode', 'float') }}};

} else if (pname == 0xB53) { // GL_LIGHT_MODEL_AMBIENT

{{{ makeSetValue('params', '0', 'GLEmulation.lightModelAmbient[0]', 'float') }}};

{{{ makeSetValue('params', '4', 'GLEmulation.lightModelAmbient[1]', 'float') }}};

{{{ makeSetValue('params', '8', 'GLEmulation.lightModelAmbient[2]', 'float') }}};

{{{ makeSetValue('params', '12', 'GLEmulation.lightModelAmbient[3]', 'float') }}};

} else {

glGetFloatv(pname, params);

}

};

{{{ updateExport('glGetFloatv') }}}

var glHint = _glHint;

_glHint = _emscripten_glHint = function _glHint(target, mode) {

if (target == 0x84EF) { // GL_TEXTURE_COMPRESSION_HINT

return;

}

glHint(target, mode);

};

{{{ updateExport('glHint') }}}

var glEnableVertexAttribArray = _glEnableVertexAttribArray;

_glEnableVertexAttribArray = _emscripten_glEnableVertexAttribArray = function _glEnableVertexAttribArray(index) {

glEnableVertexAttribArray(index);

GLEmulation.enabledVertexAttribArrays[index] = 1;

if (GLEmulation.currentVao) GLEmulation.currentVao.enabledVertexAttribArrays[index] = 1;

};

{{{ updateExport('glEnableVertexAttribArray') }}}

var glDisableVertexAttribArray = _glDisableVertexAttribArray;

_glDisableVertexAttribArray = _emscripten_glDisableVertexAttribArray = function _glDisableVertexAttribArray(index) {

glDisableVertexAttribArray(index);

delete GLEmulation.enabledVertexAttribArrays[index];

if (GLEmulation.currentVao) delete GLEmulation.currentVao.enabledVertexAttribArrays[index];

};

{{{ updateExport('glDisableVertexAttribArray') }}}

var glVertexAttribPointer = _glVertexAttribPointer;

_glVertexAttribPointer = _emscripten_glVertexAttribPointer = function _glVertexAttribPointer(index, size, type, normalized, stride, pointer) {

glVertexAttribPointer(index, size, type, normalized, stride, pointer);

if (GLEmulation.currentVao) { // TODO: avoid object creation here? likely not hot though

GLEmulation.currentVao.vertexAttribPointers[index] = [index, size, type, normalized, stride, pointer];

}

};

{{{ updateExport('glVertexAttribPointer') }}}

},

getAttributeFromCapability: function(cap) {

var attrib = null;

switch (cap) {

case 0xDE1: // GL_TEXTURE_2D - XXX not according to spec, and not in desktop GL, but works in some GLES1.x apparently, so support it

#if ASSERTIONS

abort("GL_TEXTURE_2D is not a spec-defined capability for gl{Enable,Disable}ClientState.");

#endif

// Fall through:

case 0x8078: // GL_TEXTURE_COORD_ARRAY

attrib = GLImmediate.TEXTURE0 + GLImmediate.clientActiveTexture; break;

case 0x8074: // GL_VERTEX_ARRAY

attrib = GLImmediate.VERTEX; break;

case 0x8075: // GL_NORMAL_ARRAY

attrib = GLImmediate.NORMAL; break;

case 0x8076: // GL_COLOR_ARRAY

attrib = GLImmediate.COLOR; break;

}

return attrib;

},

},

glDeleteObject__deps: ['glDeleteProgram', 'glDeleteShader'],

glDeleteObject__sig: 'vi',

glDeleteObject: function(id) {

if (GL.programs[id]) {

_glDeleteProgram(id);

} else if (GL.shaders[id]) {

_glDeleteShader(id);

} else {

err('WARNING: deleteObject received invalid id: ' + id);

}

},

glDeleteObjectARB: 'glDeleteObject',

glGetObjectParameteriv__sig: 'viii',

glGetObjectParameteriv__deps: ['glGetProgramiv', 'glGetShaderiv'],

glGetObjectParameteriv: function(id, type, result) {

if (GL.programs[id]) {

if (type == 0x8B84) { // GL_OBJECT_INFO_LOG_LENGTH_ARB

var log = GLctx.getProgramInfoLog(GL.programs[id]);

if (log === null) log = '(unknown error)';

{{{ makeSetValue('result', '0', 'log.length', 'i32') }}};

return;

}

_glGetProgramiv(id, type, result);

} else if (GL.shaders[id]) {

if (type == 0x8B84) { // GL_OBJECT_INFO_LOG_LENGTH_ARB

var log = GLctx.getShaderInfoLog(GL.shaders[id]);

if (log === null) log = '(unknown error)';

{{{ makeSetValue('result', '0', 'log.length', 'i32') }}};

return;

} else if (type == 0x8B88) { // GL_OBJECT_SHADER_SOURCE_LENGTH_ARB

var source = GLctx.getShaderSource(GL.shaders[id]);

if (source === null) return; // If an error occurs, nothing will be written to result

{{{ makeSetValue('result', '0', 'source.length', 'i32') }}};

return;

}

_glGetShaderiv(id, type, result);

} else {

err('WARNING: getObjectParameteriv received invalid id: ' + id);

}

},

glGetObjectParameterivARB: 'glGetObjectParameteriv',

glGetInfoLog__deps: ['glGetProgramInfoLog', 'glGetShaderInfoLog'],

glGetInfoLog__sig: 'viiii',

glGetInfoLog: function(id, maxLength, length, infoLog) {

if (GL.programs[id]) {

_glGetProgramInfoLog(id, maxLength, length, infoLog);

} else if (GL.shaders[id]) {

_glGetShaderInfoLog(id, maxLength, length, infoLog);

} else {

err('WARNING: glGetInfoLog received invalid id: ' + id);

}

},

glGetInfoLogARB: 'glGetInfoLog',

glBindProgram__sig: 'vii',

glBindProgram: function(type, id) {

#if ASSERTIONS

assert(id == 0);

#endif

},

glBindProgramARB: 'glBindProgram',

glGetPointerv: function(name, p) {

var attribute;

switch (name) {

case 0x808E: // GL_VERTEX_ARRAY_POINTER

attribute = GLImmediate.clientAttributes[GLImmediate.VERTEX]; break;

case 0x8090: // GL_COLOR_ARRAY_POINTER

attribute = GLImmediate.clientAttributes[GLImmediate.COLOR]; break;

case 0x8092: // GL_TEXTURE_COORD_ARRAY_POINTER

attribute = GLImmediate.clientAttributes[GLImmediate.TEXTURE0 + GLImmediate.clientActiveTexture]; break;

default:

GL.recordError(0x500/*GL_INVALID_ENUM*/);

#if GL_ASSERTIONS

err('GL_INVALID_ENUM in glGetPointerv: Unsupported name ' + name + '!');

#endif

return;

}

{{{ makeSetValue('p', '0', 'attribute ? attribute.pointer : 0', 'i32') }}};

},

// GL Immediate mode

// See comment in GLEmulation.init()

#if !FULL_ES2

$GLImmediate__postset: 'GLImmediate.setupFuncs(); Browser.moduleContextCreatedCallbacks.push(function() { GLImmediate.init() });',

#endif

$GLImmediate__deps: ['$Browser', '$GL', '$GLEmulation'],

$GLImmediate: {

MapTreeLib: null,

spawnMapTreeLib: function() {

/* A naive implementation of a map backed by an array, and accessed by

* naive iteration along the array. (hashmap with only one bucket)

*/

function CNaiveListMap() {

var list = [];

this.insert = function CNaiveListMap_insert(key, val) {

if (this.contains(key|0)) return false;

list.push([key, val]);

return true;

};

var __contains_i;

this.contains = function CNaiveListMap_contains(key) {

for (__contains_i = 0; __contains_i < list.length; ++__contains_i) {

if (list[__contains_i][0] === key) return true;

}

return false;

};

var __get_i;

this.get = function CNaiveListMap_get(key) {

for (__get_i = 0; __get_i < list.length; ++__get_i) {

if (list[__get_i][0] === key) return list[__get_i][1];

}

return undefined;

};

};

/* A tree of map nodes.

Uses `KeyView`s to allow descending the tree without garbage.

Example: {

// Create our map object.

var map = new ObjTreeMap();

// Grab the static keyView for the map.

var keyView = map.GetStaticKeyView();

// Let's make a map for:

// root: <undefined>

// 1: <undefined>

// 2: <undefined>

// 5: "Three, sir!"

// 3: "Three!"

// Note how we can chain together `Reset` and `Next` to

// easily descend based on multiple key fragments.

keyView.Reset().Next(1).Next(2).Next(5).Set("Three, sir!");

keyView.Reset().Next(1).Next(2).Next(3).Set("Three!");

}

*/

function CMapTree() {

function CNLNode() {

var map = new CNaiveListMap();

this.child = function CNLNode_child(keyFrag) {

if (!map.contains(keyFrag|0)) {

map.insert(keyFrag|0, new CNLNode());

}

return map.get(keyFrag|0);

};

this.value = undefined;

this.get = function CNLNode_get() {

return this.value;

};

this.set = function CNLNode_set(val) {

this.value = val;

};

}

function CKeyView(root) {

var cur;

this.reset = function CKeyView_reset() {

cur = root;

return this;

};

this.reset();

this.next = function CKeyView_next(keyFrag) {

cur = cur.child(keyFrag);

return this;

};

this.get = function CKeyView_get() {

return cur.get();

};

this.set = function CKeyView_set(val) {

cur.set(val);

};

};

var root;

var staticKeyView;

this.createKeyView = function CNLNode_createKeyView() {

return new CKeyView(root);

}

this.clear = function CNLNode_clear() {

root = new CNLNode();

staticKeyView = this.createKeyView();

};

this.clear();

this.getStaticKeyView = function CNLNode_getStaticKeyView() {

staticKeyView.reset();

return staticKeyView;

};

};

// Exports:

return {

create: function() {

return new CMapTree();

},

};

},

TexEnvJIT: null,

spawnTexEnvJIT: function() {

// GL defs:

var GL_TEXTURE0 = 0x84C0;

var GL_TEXTURE_1D = 0xDE0;

var GL_TEXTURE_2D = 0xDE1;

var GL_TEXTURE_3D = 0x806f;

var GL_TEXTURE_CUBE_MAP = 0x8513;

var GL_TEXTURE_ENV = 0x2300;

var GL_TEXTURE_ENV_MODE = 0x2200;

var GL_TEXTURE_ENV_COLOR = 0x2201;

var GL_TEXTURE_CUBE_MAP_POSITIVE_X = 0x8515;

var GL_TEXTURE_CUBE_MAP_NEGATIVE_X = 0x8516;

var GL_TEXTURE_CUBE_MAP_POSITIVE_Y = 0x8517;

var GL_TEXTURE_CUBE_MAP_NEGATIVE_Y = 0x8518;

var GL_TEXTURE_CUBE_MAP_POSITIVE_Z = 0x8519;

var GL_TEXTURE_CUBE_MAP_NEGATIVE_Z = 0x851A;

var GL_SRC0_RGB = 0x8580;

var GL_SRC1_RGB = 0x8581;

var GL_SRC2_RGB = 0x8582;

var GL_SRC0_ALPHA = 0x8588;

var GL_SRC1_ALPHA = 0x8589;

var GL_SRC2_ALPHA = 0x858A;

var GL_OPERAND0_RGB = 0x8590;

var GL_OPERAND1_RGB = 0x8591;

var GL_OPERAND2_RGB = 0x8592;

var GL_OPERAND0_ALPHA = 0x8598;

var GL_OPERAND1_ALPHA = 0x8599;

var GL_OPERAND2_ALPHA = 0x859A;

var GL_COMBINE_RGB = 0x8571;

var GL_COMBINE_ALPHA = 0x8572;

var GL_RGB_SCALE = 0x8573;

var GL_ALPHA_SCALE = 0xD1C;

// env.mode

var GL_ADD = 0x104;

var GL_BLEND = 0xBE2;

var GL_REPLACE = 0x1E01;

var GL_MODULATE = 0x2100;

var GL_DECAL = 0x2101;

var GL_COMBINE = 0x8570;

// env.color/alphaCombiner

//var GL_ADD = 0x104;

//var GL_REPLACE = 0x1E01;

//var GL_MODULATE = 0x2100;

var GL_SUBTRACT = 0x84E7;

var GL_INTERPOLATE = 0x8575;