var LibrarySDL = {

$SDL_unicode__docs: '/** @suppress{missingProperties} */',

$SDL_unicode: function() { return SDL.unicode; },

$SDL_ttfContext__docs: '/** @suppress{missingProperties} */',

$SDL_ttfContext: function() { return SDL.ttfContext; },

$SDL_audio__docs: '/** @suppress{missingProperties} */',

$SDL_audio: function() { return SDL.audio; },

$SDL__deps: [

#if FILESYSTEM

'$FS',

#endif

'$PATH', '$Browser', 'SDL_GetTicks', 'SDL_LockSurface',

'$SDL_unicode', '$SDL_ttfContext', '$SDL_audio'

],

$SDL: {

defaults: {

width: 320,

height: 200,

// If true, SDL_LockSurface will copy the contents of each surface back to the Emscripten HEAP so that C code can access it. If false,

// the surface contents are captured only back to JS code.

copyOnLock: true,

// If true, SDL_LockSurface will discard the contents of each surface when SDL_LockSurface() is called. This greatly improves performance

// of SDL_LockSurface(). If discardOnLock is true, copyOnLock is ignored.

discardOnLock: false,

// If true, emulate compatibility with desktop SDL by ignoring alpha on the screen frontbuffer canvas. Setting this to false will improve

// performance considerably and enables alpha-blending on the frontbuffer, so be sure to properly write 0xFF alpha for opaque pixels

// if you set this to false!

opaqueFrontBuffer: true

},

version: null,

surfaces: {},

// A pool of freed canvas elements. Reusing them avoids GC pauses.

canvasPool: [],

events: [],

fonts: [null],

// The currently preloaded audio elements ready to be played

audios: [null],

rwops: [null],

// The currently playing audio element. There's only one music track.

music: {

audio: null,

volume: 1.0

},

mixerFrequency: 22050,

mixerFormat: {{{ cDefs.AUDIO_S16LSB }}},

mixerNumChannels: 2,

mixerChunkSize: 1024,

channelMinimumNumber: 0,

GL: false, // Set to true if we call SDL_SetVideoMode with SDL_OPENGL, and if so, we do not create 2D canvases&contexts for blitting

// Note that images loaded before SDL_SetVideoMode will not get this optimization

// all possible GL attributes, with their default value

glAttributes: {

0: 3, /* SDL_GL_RED_SIZE */

1: 3, /* SDL_GL_GREEN_SIZE */

2: 2, /* SDL_GL_BLUE_SIZE */

3: 0, /* SDL_GL_ALPHA_SIZE */

4: 0, /* SDL_GL_BUFFER_SIZE */

5: 1, /* SDL_GL_DOUBLEBUFFER */

6: 16, /* SDL_GL_DEPTH_SIZE */

7: 0, /* SDL_GL_STENCIL_SIZE */

8: 0, /* SDL_GL_ACCUM_RED_SIZE */

9: 0, /* SDL_GL_ACCUM_GREEN_SIZE */

10: 0, /* SDL_GL_ACCUM_BLUE_SIZE */

11: 0, /* SDL_GL_ACCUM_ALPHA_SIZE */

12: 0, /* SDL_GL_STEREO */

13: 0, /* SDL_GL_MULTISAMPLEBUFFERS */

14: 0, /* SDL_GL_MULTISAMPLESAMPLES */

15: 1, /* SDL_GL_ACCELERATED_VISUAL */

16: 0, /* SDL_GL_RETAINED_BACKING */

17: 0, /* SDL_GL_CONTEXT_MAJOR_VERSION */

18: 0 /* SDL_GL_CONTEXT_MINOR_VERSION */

},

keyboardState: null,

keyboardMap: {},

canRequestFullscreen: false,

isRequestingFullscreen: false,

textInput: false,

startTime: null,

initFlags: 0, // The flags passed to SDL_Init

buttonState: 0,

modState: 0,

DOMButtons: [0, 0, 0],

DOMEventToSDLEvent: {},

TOUCH_DEFAULT_ID: 0, // Our default deviceID for touch events (we get nothing from the browser)

eventHandler: null,

eventHandlerContext: null,

eventHandlerTemp: 0,

keyCodes: { // DOM code ==> SDL code. See https://developer.mozilla.org/en/Document_Object_Model_%28DOM%29/KeyboardEvent and SDL_keycode.h

// For keys that don't have unicode value, we map DOM codes with the corresponding scan codes + 1024 (using "| 1 << 10")

16: 225 | 1<<10, // shift

17: 224 | 1<<10, // control (right, or left)

18: 226 | 1<<10, // alt

20: 57 | 1<<10, // caps lock

33: 75 | 1<<10, // pagedup

34: 78 | 1<<10, // pagedown

35: 77 | 1<<10, // end

36: 74 | 1<<10, // home

37: 80 | 1<<10, // left arrow

38: 82 | 1<<10, // up arrow

39: 79 | 1<<10, // right arrow

40: 81 | 1<<10, // down arrow

44: 316, // print screen

45: 73 | 1<<10, // insert

46: 127, // SDLK_DEL == '\177'

91: 227 | 1<<10, // windows key or super key on linux (doesn't work on Mac)

93: 101 | 1<<10, // application

96: 98 | 1<<10, // keypad 0

97: 89 | 1<<10, // keypad 1

98: 90 | 1<<10, // keypad 2

99: 91 | 1<<10, // keypad 3

100: 92 | 1<<10, // keypad 4

101: 93 | 1<<10, // keypad 5

102: 94 | 1<<10, // keypad 6

103: 95 | 1<<10, // keypad 7

104: 96 | 1<<10, // keypad 8

105: 97 | 1<<10, // keypad 9

106: 85 | 1<<10, // keypad multiply

107: 87 | 1<<10, // keypad plus

109: 86 | 1<<10, // keypad minus

110: 99 | 1<<10, // keypad decimal point

111: 84 | 1<<10, // keypad divide

112: 58 | 1<<10, // F1

113: 59 | 1<<10, // F2

114: 60 | 1<<10, // F3

115: 61 | 1<<10, // F4

116: 62 | 1<<10, // F5

117: 63 | 1<<10, // F6

118: 64 | 1<<10, // F7

119: 65 | 1<<10, // F8

120: 66 | 1<<10, // F9

121: 67 | 1<<10, // F10

122: 68 | 1<<10, // F11

123: 69 | 1<<10, // F12

124: 104 | 1<<10, // F13

125: 105 | 1<<10, // F14

126: 106 | 1<<10, // F15

127: 107 | 1<<10, // F16

128: 108 | 1<<10, // F17

129: 109 | 1<<10, // F18

130: 110 | 1<<10, // F19

131: 111 | 1<<10, // F20

132: 112 | 1<<10, // F21

133: 113 | 1<<10, // F22

134: 114 | 1<<10, // F23

135: 115 | 1<<10, // F24

144: 83 | 1<<10, // keypad num lock

160: 94, // caret

161: 33, // exclaim

162: 34, // double quote

163: 35, // hash

164: 36, // dollar

165: 37, // percent

166: 38, // ampersand

167: 95, // underscore

168: 40, // open parenthesis

169: 41, // close parenthesis

170: 42, // asterix

171: 43, // plus

172: 124, // pipe

173: 45, // minus

174: 123, // open curly bracket

175: 125, // close curly bracket

176: 126, // tilde

181: 127, // audio mute

182: 129, // audio volume down

183: 128, // audio volume up

188: 44, // comma

190: 46, // period

191: 47, // slash (/)

192: 96, // backtick/backquote (`)

219: 91, // open square bracket

220: 92, // back slash

221: 93, // close square bracket

222: 39, // quote

224: 227 | 1<<10, // meta (command/windows)

},

scanCodes: { // SDL keycode ==> SDL scancode. See SDL_scancode.h

8: 42, // backspace

9: 43, // tab

13: 40, // return

27: 41, // escape

32: 44, // space

35: 204, // hash

39: 53, // grave

44: 54, // comma

46: 55, // period

47: 56, // slash

48: 39, // 0

49: 30, // 1

50: 31, // 2

51: 32, // 3

52: 33, // 4

53: 34, // 5

54: 35, // 6

55: 36, // 7

56: 37, // 8

57: 38, // 9

58: 203, // colon

59: 51, // semicolon

61: 46, // equals

91: 47, // left bracket

92: 49, // backslash

93: 48, // right bracket

96: 52, // apostrophe

97: 4, // A

98: 5, // B

99: 6, // C

100: 7, // D

101: 8, // E

102: 9, // F

103: 10, // G

104: 11, // H

105: 12, // I

106: 13, // J

107: 14, // K

108: 15, // L

109: 16, // M

110: 17, // N

111: 18, // O

112: 19, // P

113: 20, // Q

114: 21, // R

115: 22, // S

116: 23, // T

117: 24, // U

118: 25, // V

119: 26, // W

120: 27, // X

121: 28, // Y

122: 29, // Z

127: 76, // delete

305: 224, // ctrl

308: 226, // alt

316: 70, // print screen

},

loadRect: function(rect) {

return {

x: {{{ makeGetValue('rect + ' + C_STRUCTS.SDL_Rect.x, '0', 'i32') }}},

y: {{{ makeGetValue('rect + ' + C_STRUCTS.SDL_Rect.y, '0', 'i32') }}},

w: {{{ makeGetValue('rect + ' + C_STRUCTS.SDL_Rect.w, '0', 'i32') }}},

h: {{{ makeGetValue('rect + ' + C_STRUCTS.SDL_Rect.h, '0', 'i32') }}}

};

},

updateRect: function(rect, r) {

{{{ makeSetValue('rect', C_STRUCTS.SDL_Rect.x, 'r.x', 'i32') }}};

{{{ makeSetValue('rect', C_STRUCTS.SDL_Rect.y, 'r.y', 'i32') }}};

{{{ makeSetValue('rect', C_STRUCTS.SDL_Rect.w, 'r.w', 'i32') }}};

{{{ makeSetValue('rect', C_STRUCTS.SDL_Rect.h, 'r.h', 'i32') }}};

},

intersectionOfRects: function(first, second) {

var leftX = Math.max(first.x, second.x);

var leftY = Math.max(first.y, second.y);

var rightX = Math.min(first.x + first.w, second.x + second.w);

var rightY = Math.min(first.y + first.h, second.y + second.h);

return {

x: leftX,

y: leftY,

w: Math.max(leftX, rightX) - leftX,

h: Math.max(leftY, rightY) - leftY

}

},

checkPixelFormat: function(fmt) {

#if ASSERTIONS

// Canvas screens are always RGBA.

var format = {{{ makeGetValue('fmt', C_STRUCTS.SDL_PixelFormat.format, 'i32') }}};

if (format != {{{ cDefs.SDL_PIXELFORMAT_RGBA8888 }}}) {

warnOnce('Unsupported pixel format!');

}

#endif

},

// Load SDL color into a CSS-style color specification

loadColorToCSSRGB: function(color) {

var rgba = {{{ makeGetValue('color', '0', 'i32') }}};

return 'rgb(' + (rgba&255) + ',' + ((rgba >> 8)&255) + ',' + ((rgba >> 16)&255) + ')';

},

loadColorToCSSRGBA: function(color) {

var rgba = {{{ makeGetValue('color', '0', 'i32') }}};

return 'rgba(' + (rgba&255) + ',' + ((rgba >> 8)&255) + ',' + ((rgba >> 16)&255) + ',' + (((rgba >> 24)&255)/255) + ')';

},

translateColorToCSSRGBA: function(rgba) {

return 'rgba(' + (rgba&0xff) + ',' + (rgba>>8 & 0xff) + ',' + (rgba>>16 & 0xff) + ',' + (rgba>>>24)/0xff + ')';

},

translateRGBAToCSSRGBA: function(r, g, b, a) {

return 'rgba(' + (r&0xff) + ',' + (g&0xff) + ',' + (b&0xff) + ',' + (a&0xff)/255 + ')';

},

translateRGBAToColor: function(r, g, b, a) {

return r | g << 8 | b << 16 | a << 24;

},

makeSurface: function(width, height, flags, usePageCanvas, source, rmask, gmask, bmask, amask) {

var is_SDL_HWSURFACE = flags & 0x00000001;

var is_SDL_HWPALETTE = flags & 0x00200000;

var is_SDL_OPENGL = flags & 0x04000000;

var surf = _malloc({{{ C_STRUCTS.SDL_Surface.__size__ }}});

var pixelFormat = _malloc({{{ C_STRUCTS.SDL_PixelFormat.__size__ }}});

//surface with SDL_HWPALETTE flag is 8bpp surface (1 byte)

var bpp = is_SDL_HWPALETTE ? 1 : 4;

var buffer = 0;

// preemptively initialize this for software surfaces,

// otherwise it will be lazily initialized inside of SDL_LockSurface

if (!is_SDL_HWSURFACE && !is_SDL_OPENGL) {

buffer = _malloc(width * height * 4);

}

{{{ makeSetValue('surf', C_STRUCTS.SDL_Surface.flags, 'flags', 'i32') }}};

{{{ makeSetValue('surf', C_STRUCTS.SDL_Surface.format, 'pixelFormat', POINTER_TYPE) }}};

{{{ makeSetValue('surf', C_STRUCTS.SDL_Surface.w, 'width', 'i32') }}};

{{{ makeSetValue('surf', C_STRUCTS.SDL_Surface.h, 'height', 'i32') }}};

{{{ makeSetValue('surf', C_STRUCTS.SDL_Surface.pitch, 'width * bpp', 'i32') }}}; // assuming RGBA or indexed for now,

// since that is what ImageData gives us in browsers

{{{ makeSetValue('surf', C_STRUCTS.SDL_Surface.pixels, 'buffer', POINTER_TYPE) }}};

{{{ makeSetValue('surf', C_STRUCTS.SDL_Surface.clip_rect+C_STRUCTS.SDL_Rect.x, '0', 'i32') }}};

{{{ makeSetValue('surf', C_STRUCTS.SDL_Surface.clip_rect+C_STRUCTS.SDL_Rect.y, '0', 'i32') }}};

{{{ makeSetValue('surf', C_STRUCTS.SDL_Surface.clip_rect+C_STRUCTS.SDL_Rect.w, 'Module["canvas"].width', 'i32') }}};

{{{ makeSetValue('surf', C_STRUCTS.SDL_Surface.clip_rect+C_STRUCTS.SDL_Rect.h, 'Module["canvas"].height', 'i32') }}};

{{{ makeSetValue('surf', C_STRUCTS.SDL_Surface.refcount, '1', 'i32') }}};

{{{ makeSetValue('pixelFormat', C_STRUCTS.SDL_PixelFormat.format, cDefs.SDL_PIXELFORMAT_RGBA8888, 'i32') }}};

{{{ makeSetValue('pixelFormat', C_STRUCTS.SDL_PixelFormat.palette, '0', 'i32') }}};// TODO

{{{ makeSetValue('pixelFormat', C_STRUCTS.SDL_PixelFormat.BitsPerPixel, 'bpp * 8', 'i8') }}};

{{{ makeSetValue('pixelFormat', C_STRUCTS.SDL_PixelFormat.BytesPerPixel, 'bpp', 'i8') }}};

{{{ makeSetValue('pixelFormat', C_STRUCTS.SDL_PixelFormat.Rmask, 'rmask || 0x000000ff', 'i32') }}};

{{{ makeSetValue('pixelFormat', C_STRUCTS.SDL_PixelFormat.Gmask, 'gmask || 0x0000ff00', 'i32') }}};

{{{ makeSetValue('pixelFormat', C_STRUCTS.SDL_PixelFormat.Bmask, 'bmask || 0x00ff0000', 'i32') }}};

{{{ makeSetValue('pixelFormat', C_STRUCTS.SDL_PixelFormat.Amask, 'amask || 0xff000000', 'i32') }}};

// Decide if we want to use WebGL or not

SDL.GL = SDL.GL || is_SDL_OPENGL;

var canvas;

if (!usePageCanvas) {

if (SDL.canvasPool.length > 0) {

canvas = SDL.canvasPool.pop();

} else {

canvas = document.createElement('canvas');

}

canvas.width = width;

canvas.height = height;

} else {

canvas = Module['canvas'];

}

var webGLContextAttributes = {

antialias: ((SDL.glAttributes[13 /*SDL_GL_MULTISAMPLEBUFFERS*/] != 0) && (SDL.glAttributes[14 /*SDL_GL_MULTISAMPLESAMPLES*/] > 1)),

depth: (SDL.glAttributes[6 /*SDL_GL_DEPTH_SIZE*/] > 0),

stencil: (SDL.glAttributes[7 /*SDL_GL_STENCIL_SIZE*/] > 0),

alpha: (SDL.glAttributes[3 /*SDL_GL_ALPHA_SIZE*/] > 0)

};

#if OFFSCREEN_FRAMEBUFFER

// TODO: Make SDL explicitly aware of whether it is being proxied or not, and set these to true only when proxying is being performed.

GL.enableOffscreenFramebufferAttributes(webGLContextAttributes);

#endif

var ctx = Browser.createContext(canvas, is_SDL_OPENGL, usePageCanvas, webGLContextAttributes);

SDL.surfaces[surf] = {

width: width,

height: height,

canvas: canvas,

ctx: ctx,

surf: surf,

buffer: buffer,

pixelFormat: pixelFormat,

alpha: 255,

flags: flags,

locked: 0,

usePageCanvas: usePageCanvas,

source: source,

isFlagSet: function(flag) {

return flags & flag;

}

};

return surf;

},

// Copy data from the C++-accessible storage to the canvas backing

// for surface with HWPALETTE flag(8bpp depth)

copyIndexedColorData: function(surfData, rX, rY, rW, rH) {

// HWPALETTE works with palette

// setted by SDL_SetColors

if (!surfData.colors) {

return;

}

var fullWidth = Module['canvas'].width;

var fullHeight = Module['canvas'].height;

var startX = rX || 0;

var startY = rY || 0;

var endX = (rW || (fullWidth - startX)) + startX;

var endY = (rH || (fullHeight - startY)) + startY;

var buffer = surfData.buffer;

if (!surfData.image.data32) {

surfData.image.data32 = new Uint32Array(surfData.image.data.buffer);

}

var data32 = surfData.image.data32;

var colors32 = surfData.colors32;

for (var y = startY; y < endY; ++y) {

var base = y * fullWidth;

for (var x = startX; x < endX; ++x) {

data32[base + x] = colors32[{{{ makeGetValue('buffer + base + x', '0', 'u8') }}}];

}

}

},

freeSurface: function(surf) {

var refcountPointer = surf + {{{ C_STRUCTS.SDL_Surface.refcount }}};

var refcount = {{{ makeGetValue('refcountPointer', '0', 'i32') }}};

if (refcount > 1) {

{{{ makeSetValue('refcountPointer', '0', 'refcount - 1', 'i32') }}};

return;

}

var info = SDL.surfaces[surf];

if (!info.usePageCanvas && info.canvas) SDL.canvasPool.push(info.canvas);

if (info.buffer) _free(info.buffer);

_free(info.pixelFormat);

_free(surf);

SDL.surfaces[surf] = null;

if (surf === SDL.screen) {

SDL.screen = null;

}

},

blitSurface: function(src, srcrect, dst, dstrect, scale) {

var srcData = SDL.surfaces[src];

var dstData = SDL.surfaces[dst];

var sr, dr;

if (srcrect) {

sr = SDL.loadRect(srcrect);

} else {

sr = { x: 0, y: 0, w: srcData.width, h: srcData.height };

}

if (dstrect) {

dr = SDL.loadRect(dstrect);

} else {

dr = { x: 0, y: 0, w: srcData.width, h: srcData.height };

}

if (dstData.clipRect) {

var widthScale = (!scale || sr.w === 0) ? 1 : sr.w / dr.w;

var heightScale = (!scale || sr.h === 0) ? 1 : sr.h / dr.h;

dr = SDL.intersectionOfRects(dstData.clipRect, dr);

sr.w = dr.w * widthScale;

sr.h = dr.h * heightScale;

if (dstrect) {

SDL.updateRect(dstrect, dr);

}

}

var blitw, blith;

if (scale) {

blitw = dr.w; blith = dr.h;

} else {

blitw = sr.w; blith = sr.h;

}

if (sr.w === 0 || sr.h === 0 || blitw === 0 || blith === 0) {

return 0;

}

var oldAlpha = dstData.ctx.globalAlpha;

dstData.ctx.globalAlpha = srcData.alpha/255;

dstData.ctx.drawImage(srcData.canvas, sr.x, sr.y, sr.w, sr.h, dr.x, dr.y, blitw, blith);

dstData.ctx.globalAlpha = oldAlpha;

if (dst != SDL.screen) {

// XXX As in IMG_Load, for compatibility we write out |pixels|

warnOnce('WARNING: copying canvas data to memory for compatibility');

_SDL_LockSurface(dst);

dstData.locked--; // The surface is not actually locked in this hack

}

return 0;

},

// the browser sends out touchstart events with the whole group of touches

// even if we received a previous touchstart for a specific touch identifier.

// You can test this by pressing one finger to the screen, then another. You'll

// receive two touchstart events, the first with a touches count of 1 the second

// with a touches count of two.

// SDL sends out a new touchstart event for only each newly started touch so to

// emulate this, we keep track of previously started touches.

downFingers: {},

savedKeydown: null,

receiveEvent: function(event) {

function unpressAllPressedKeys() {

};

switch (event.type) {

case 'touchstart': case 'touchmove': {

event.preventDefault();

var touches = [];

// Clear out any touchstart events that we've already processed

if (event.type === 'touchstart') {

for (var i = 0; i < event.touches.length; i++) {

var touch = event.touches[i];

if (SDL.downFingers[touch.identifier] != true) {

SDL.downFingers[touch.identifier] = true;

touches.push(touch);

}

}

} else {

touches = event.touches;

}

var firstTouch = touches[0];

if (firstTouch) {

if (event.type == 'touchstart') {

SDL.DOMButtons[0] = 1;

}

var mouseEventType;

switch (event.type) {

case 'touchstart': mouseEventType = 'mousedown'; break;

case 'touchmove': mouseEventType = 'mousemove'; break;

}

var mouseEvent = {

type: mouseEventType,

button: 0,

pageX: firstTouch.clientX,

pageY: firstTouch.clientY

};

SDL.events.push(mouseEvent);

}

for (var i = 0; i < touches.length; i++) {

var touch = touches[i];

SDL.events.push({

type: event.type,

touch: touch

});

};

break;

}

case 'touchend': {

event.preventDefault();

// Remove the entry in the SDL.downFingers hash

// because the finger is no longer down.

for (var i = 0; i < event.changedTouches.length; i++) {

var touch = event.changedTouches[i];

if (SDL.downFingers[touch.identifier] === true) {

delete SDL.downFingers[touch.identifier];

}

}

var mouseEvent = {

type: 'mouseup',

button: 0,

pageX: event.changedTouches[0].clientX,

pageY: event.changedTouches[0].clientY

};

SDL.DOMButtons[0] = 0;

SDL.events.push(mouseEvent);

for (var i = 0; i < event.changedTouches.length; i++) {

var touch = event.changedTouches[i];

SDL.events.push({

type: 'touchend',

touch: touch

});

};

break;

}

case 'DOMMouseScroll': case 'mousewheel': case 'wheel':

var delta = -Browser.getMouseWheelDelta(event); // Flip the wheel direction to translate from browser wheel direction (+:down) to SDL direction (+:up)

delta = (delta == 0) ? 0 : (delta > 0 ? Math.max(delta, 1) : Math.min(delta, -1)); // Quantize to integer so that minimum scroll is at least +/- 1.

// Simulate old-style SDL events representing mouse wheel input as buttons

var button = delta > 0 ? 3 /*SDL_BUTTON_WHEELUP-1*/ : 4 /*SDL_BUTTON_WHEELDOWN-1*/; // Subtract one since JS->C marshalling is defined to add one back.

SDL.events.push({ type: 'mousedown', button: button, pageX: event.pageX, pageY: event.pageY });

SDL.events.push({ type: 'mouseup', button: button, pageX: event.pageX, pageY: event.pageY });

// Pass a delta motion event.

SDL.events.push({ type: 'wheel', deltaX: 0, deltaY: delta });

event.preventDefault(); // If we don't prevent this, then 'wheel' event will be sent again by the browser as 'DOMMouseScroll' and we will receive this same event the second time.

break;

case 'mousemove':

if (SDL.DOMButtons[0] === 1) {

SDL.events.push({

type: 'touchmove',

touch: {

identifier: 0,

deviceID: {{{ cDefs.SDL_TOUCH_MOUSEID }}},

pageX: event.pageX,

pageY: event.pageY

}

});

}

if (Browser.pointerLock) {

// workaround for firefox bug 750111

if ('mozMovementX' in event) {

event['movementX'] = event['mozMovementX'];

event['movementY'] = event['mozMovementY'];

}

// workaround for Firefox bug 782777

if (event['movementX'] == 0 && event['movementY'] == 0) {

// ignore a mousemove event if it doesn't contain any movement info

// (without pointer lock, we infer movement from pageX/pageY, so this check is unnecessary)

event.preventDefault();

return;

}

}

// fall through

case 'keydown': case 'keyup': case 'keypress': case 'mousedown': case 'mouseup':

// If we preventDefault on keydown events, the subsequent keypress events

// won't fire. However, it's fine (and in some cases necessary) to

// preventDefault for keys that don't generate a character. Otherwise,

// preventDefault is the right thing to do in general.

if (event.type !== 'keydown' || (!SDL_unicode() && !SDL.textInput) || (event.keyCode === 8 /* backspace */ || event.keyCode === 9 /* tab */)) {

event.preventDefault();

}

if (event.type == 'mousedown') {

SDL.DOMButtons[event.button] = 1;

SDL.events.push({

type: 'touchstart',

touch: {

identifier: 0,

deviceID: {{{ cDefs.SDL_TOUCH_MOUSEID }}},

pageX: event.pageX,

pageY: event.pageY

}

});

} else if (event.type == 'mouseup') {

// ignore extra ups, can happen if we leave the canvas while pressing down, then return,

// since we add a mouseup in that case

if (!SDL.DOMButtons[event.button]) {

return;

}

SDL.events.push({