Datasets:

---

CM

/

codexglue_code2text_javascript

like 12

[ "function", "(", "oldData", ")", "{", "var", "data", "=", "this", ".", "data", ";", "var", "camera", "=", "this", ".", "camera", ";", "// Update properties.", "camera", ".", "aspect", "=", "data", ".", "aspect", "||", "(", "window", ".", "innerWidth", "/", "window", ".", "innerHeight", ")", ";", "camera", ".", "far", "=", "data", ".", "far", ";", "camera", ".", "fov", "=", "data", ".", "fov", ";", "camera", ".", "near", "=", "data", ".", "near", ";", "camera", ".", "zoom", "=", "data", ".", "zoom", ";", "camera", ".", "updateProjectionMatrix", "(", ")", ";", "this", ".", "updateActiveCamera", "(", "oldData", ")", ";", "this", ".", "updateSpectatorCamera", "(", "oldData", ")", ";", "}" ]

[ "Update", "three", ".", "js", "camera", "." ]

[ "function", "(", ")", "{", "var", "data", "=", "this", ".", "data", ";", "this", ".", "updateConfig", "(", ")", ";", "this", ".", "animationIsPlaying", "=", "false", ";", "this", ".", "animation", "=", "anime", "(", "this", ".", "config", ")", ";", "this", ".", "animation", ".", "began", "=", "true", ";", "this", ".", "removeEventListeners", "(", ")", ";", "this", ".", "addEventListeners", "(", ")", ";", "// Wait for start events for animation.", "if", "(", "!", "data", ".", "autoplay", "||", "data", ".", "startEvents", "&&", "data", ".", "startEvents", ".", "length", ")", "{", "return", ";", "}", "// Delay animation.", "if", "(", "data", ".", "delay", ")", "{", "setTimeout", "(", "this", ".", "beginAnimation", ",", "data", ".", "delay", ")", ";", "return", ";", "}", "// Play animation.", "this", ".", "beginAnimation", "(", ")", ";", "}" ]

[ "Start", "animation", "from", "scratch", "." ]

[ "function", "(", ")", "{", "var", "config", "=", "this", ".", "config", ";", "var", "data", "=", "this", ".", "data", ";", "var", "el", "=", "this", ".", "el", ";", "var", "from", ";", "var", "isBoolean", ";", "var", "isNumber", ";", "var", "to", ";", "if", "(", "this", ".", "waitComponentInitRawProperty", "(", "this", ".", "updateConfigForDefault", ")", ")", "{", "return", ";", "}", "if", "(", "data", ".", "from", "===", "''", ")", "{", "// Infer from.", "from", "=", "isRawProperty", "(", "data", ")", "?", "getRawProperty", "(", "el", ",", "data", ".", "property", ")", ":", "getComponentProperty", "(", "el", ",", "data", ".", "property", ")", ";", "}", "else", "{", "// Explicit from.", "from", "=", "data", ".", "from", ";", "}", "to", "=", "data", ".", "to", ";", "isNumber", "=", "!", "isNaN", "(", "from", "||", "to", ")", ";", "if", "(", "isNumber", ")", "{", "from", "=", "parseFloat", "(", "from", ")", ";", "to", "=", "parseFloat", "(", "to", ")", ";", "}", "else", "{", "from", "=", "from", "?", "from", ".", "toString", "(", ")", ":", "from", ";", "to", "=", "to", "?", "to", ".", "toString", "(", ")", ":", "to", ";", "}", "// Convert booleans to integer to allow boolean flipping.", "isBoolean", "=", "data", ".", "to", "===", "'true'", "||", "data", ".", "to", "===", "'false'", "||", "data", ".", "to", "===", "true", "||", "data", ".", "to", "===", "false", ";", "if", "(", "isBoolean", ")", "{", "from", "=", "data", ".", "from", "===", "'true'", "||", "data", ".", "from", "===", "true", "?", "1", ":", "0", ";", "to", "=", "data", ".", "to", "===", "'true'", "||", "data", ".", "to", "===", "true", "?", "1", ":", "0", ";", "}", "this", ".", "targets", ".", "aframeProperty", "=", "from", ";", "config", ".", "targets", "=", "this", ".", "targets", ";", "config", ".", "aframeProperty", "=", "to", ";", "config", ".", "update", "=", "(", "function", "(", ")", "{", "var", "lastValue", ";", "return", "function", "(", "anim", ")", "{", "var", "value", ";", "value", "=", "anim", ".", "animatables", "[", "0", "]", ".", "target", ".", "aframeProperty", ";", "// Need to do a last value check for animation timeline since all the tweening", "// begins simultaenously even if the value has not changed. Also better for perf", "// anyways.", "if", "(", "value", "===", "lastValue", ")", "{", "return", ";", "}", "lastValue", "=", "value", ";", "if", "(", "isBoolean", ")", "{", "value", "=", "value", ">=", "1", ";", "}", "if", "(", "isRawProperty", "(", "data", ")", ")", "{", "setRawProperty", "(", "el", ",", "data", ".", "property", ",", "value", ",", "data", ".", "type", ")", ";", "}", "else", "{", "setComponentProperty", "(", "el", ",", "data", ".", "property", ",", "value", ")", ";", "}", "}", ";", "}", ")", "(", ")", ";", "}" ]

[ "Stuff", "property", "into", "generic", "property", "key", "." ]

[ "function", "(", ")", "{", "var", "propType", ";", "// Route config type.", "propType", "=", "getPropertyType", "(", "this", ".", "el", ",", "this", ".", "data", ".", "property", ")", ";", "if", "(", "isRawProperty", "(", "this", ".", "data", ")", "&&", "this", ".", "data", ".", "type", "===", "TYPE_COLOR", ")", "{", "this", ".", "updateConfigForRawColor", "(", ")", ";", "}", "else", "if", "(", "propType", "===", "'vec2'", "||", "propType", "===", "'vec3'", "||", "propType", "===", "'vec4'", ")", "{", "this", ".", "updateConfigForVector", "(", ")", ";", "}", "else", "{", "this", ".", "updateConfigForDefault", "(", ")", ";", "}", "}" ]

[ "Update", "the", "config", "before", "each", "run", "." ]

[ "function", "(", "cb", ")", "{", "var", "componentName", ";", "var", "data", "=", "this", ".", "data", ";", "var", "el", "=", "this", ".", "el", ";", "var", "self", "=", "this", ";", "if", "(", "data", ".", "from", "!==", "''", ")", "{", "return", "false", ";", "}", "if", "(", "!", "data", ".", "property", ".", "startsWith", "(", "STRING_COMPONENTS", ")", ")", "{", "return", "false", ";", "}", "componentName", "=", "splitDot", "(", "data", ".", "property", ")", "[", "1", "]", ";", "if", "(", "el", ".", "components", "[", "componentName", "]", ")", "{", "return", "false", ";", "}", "el", ".", "addEventListener", "(", "'componentinitialized'", ",", "function", "wait", "(", "evt", ")", "{", "if", "(", "evt", ".", "detail", ".", "name", "!==", "componentName", ")", "{", "return", ";", "}", "cb", "(", ")", ";", "// Since the config was created async, create the animation now since we missed it", "// earlier.", "self", ".", "animation", "=", "anime", "(", "self", ".", "config", ")", ";", "el", ".", "removeEventListener", "(", "'componentinitialized'", ",", "wait", ")", ";", "}", ")", ";", "return", "true", ";", "}" ]

[ "Wait", "for", "component", "to", "initialize", "." ]

[ "function", "getPropertyType", "(", "el", ",", "property", ")", "{", "var", "component", ";", "var", "componentName", ";", "var", "split", ";", "var", "propertyName", ";", "split", "=", "property", ".", "split", "(", "'.'", ")", ";", "componentName", "=", "split", "[", "0", "]", ";", "propertyName", "=", "split", "[", "1", "]", ";", "component", "=", "el", ".", "components", "[", "componentName", "]", "||", "components", "[", "componentName", "]", ";", "// Primitives.", "if", "(", "!", "component", ")", "{", "return", "null", ";", "}", "// Dynamic schema. We only care about vectors anyways.", "if", "(", "propertyName", "&&", "!", "component", ".", "schema", "[", "propertyName", "]", ")", "{", "return", "null", ";", "}", "// Multi-prop.", "if", "(", "propertyName", ")", "{", "return", "component", ".", "schema", "[", "propertyName", "]", ".", "type", ";", "}", "// Single-prop.", "return", "component", ".", "schema", ".", "type", ";", "}" ]

[ "Given", "property", "name", "check", "schema", "to", "see", "what", "type", "we", "are", "animating", ".", "We", "just", "care", "whether", "the", "property", "is", "a", "vector", "." ]

[ "function", "toRadians", "(", "obj", ")", "{", "obj", ".", "x", "=", "THREE", ".", "Math", ".", "degToRad", "(", "obj", ".", "x", ")", ";", "obj", ".", "y", "=", "THREE", ".", "Math", ".", "degToRad", "(", "obj", ".", "y", ")", ";", "obj", ".", "z", "=", "THREE", ".", "Math", ".", "degToRad", "(", "obj", ".", "z", ")", ";", "}" ]

[ "Convert", "object", "to", "radians", "." ]

[ "function", "(", ")", "{", "var", "material", "=", "this", ".", "el", ".", "components", ".", "material", ";", "if", "(", "!", "material", ")", "{", "return", ";", "}", "this", ".", "model", ".", "traverse", "(", "function", "(", "child", ")", "{", "if", "(", "child", "instanceof", "THREE", ".", "Mesh", ")", "{", "child", ".", "material", "=", "material", ".", "material", ";", "}", "}", ")", ";", "}" ]

[ "Apply", "material", "from", "material", "component", "recursively", "." ]

[ "function", "AndroidWakeLock", "(", ")", "{", "var", "video", "=", "document", ".", "createElement", "(", "'video'", ")", ";", "video", ".", "addEventListener", "(", "'ended'", ",", "function", "(", ")", "{", "video", ".", "play", "(", ")", ";", "}", ")", ";", "this", ".", "request", "=", "function", "(", ")", "{", "if", "(", "video", ".", "paused", ")", "{", "// Base64 version of videos_src/no-sleep-60s.webm.", "video", ".", "src", "=", "Util", ".", "base64", "(", "'video/webm'", ",", "'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'", ")", ";", "video", ".", "play", "(", ")", ";", "}", "}", ";", "this", ".", "release", "=", "function", "(", ")", "{", "video", ".", "pause", "(", ")", ";", "video", ".", "src", "=", "''", ";", "}", ";", "}" ]

[ "Android", "and", "iOS", "compatible", "wakelock", "implementation", "." ]

[ "function", "(", "previousHand", ")", "{", "var", "controlConfiguration", ";", "var", "el", "=", "this", ".", "el", ";", "var", "hand", "=", "this", ".", "data", ";", "var", "self", "=", "this", ";", "// Get common configuration to abstract different vendor controls.", "controlConfiguration", "=", "{", "hand", ":", "hand", ",", "model", ":", "false", ",", "orientationOffset", ":", "{", "x", ":", "0", ",", "y", ":", "0", ",", "z", ":", "hand", "===", "'left'", "?", "90", ":", "-", "90", "}", "}", ";", "// Set model.", "if", "(", "hand", "!==", "previousHand", ")", "{", "this", ".", "loader", ".", "load", "(", "MODEL_URLS", "[", "hand", "]", ",", "function", "(", "gltf", ")", "{", "var", "mesh", "=", "gltf", ".", "scene", ".", "children", "[", "0", "]", ";", "mesh", ".", "mixer", "=", "new", "THREE", ".", "AnimationMixer", "(", "mesh", ")", ";", "self", ".", "clips", "=", "gltf", ".", "animations", ";", "el", ".", "setObject3D", "(", "'mesh'", ",", "mesh", ")", ";", "mesh", ".", "position", ".", "set", "(", "0", ",", "0", ",", "0", ")", ";", "mesh", ".", "rotation", ".", "set", "(", "0", ",", "0", ",", "0", ")", ";", "el", ".", "setAttribute", "(", "'vive-controls'", ",", "controlConfiguration", ")", ";", "el", ".", "setAttribute", "(", "'oculus-touch-controls'", ",", "controlConfiguration", ")", ";", "el", ".", "setAttribute", "(", "'windows-motion-controls'", ",", "controlConfiguration", ")", ";", "}", ")", ";", "}", "}" ]

[ "Update", "handler", ".", "More", "like", "the", "init", "handler", "since", "the", "only", "property", "is", "the", "hand", "and", "that", "won", "t", "be", "changing", "much", "." ]

[ "function", "(", "button", ",", "evt", ")", "{", "var", "lastGesture", ";", "var", "isPressed", "=", "evt", "===", "'down'", ";", "var", "isTouched", "=", "evt", "===", "'touchstart'", ";", "// Update objects.", "if", "(", "evt", ".", "indexOf", "(", "'touch'", ")", "===", "0", ")", "{", "// Update touch object.", "if", "(", "isTouched", "===", "this", ".", "touchedButtons", "[", "button", "]", ")", "{", "return", ";", "}", "this", ".", "touchedButtons", "[", "button", "]", "=", "isTouched", ";", "}", "else", "{", "// Update button object.", "if", "(", "isPressed", "===", "this", ".", "pressedButtons", "[", "button", "]", ")", "{", "return", ";", "}", "this", ".", "pressedButtons", "[", "button", "]", "=", "isPressed", ";", "}", "// Determine the gesture.", "lastGesture", "=", "this", ".", "gesture", ";", "this", ".", "gesture", "=", "this", ".", "determineGesture", "(", ")", ";", "// Same gesture.", "if", "(", "this", ".", "gesture", "===", "lastGesture", ")", "{", "return", ";", "}", "// Animate gesture.", "this", ".", "animateGesture", "(", "this", ".", "gesture", ",", "lastGesture", ")", ";", "// Emit events.", "this", ".", "emitGestureEvents", "(", "this", ".", "gesture", ",", "lastGesture", ")", ";", "}" ]

[ "Play", "model", "animation", "based", "on", "which", "button", "was", "pressed", "and", "which", "kind", "of", "event", "." ]

[ "function", "(", ")", "{", "var", "gesture", ";", "var", "isGripActive", "=", "this", ".", "pressedButtons", "[", "'grip'", "]", ";", "var", "isSurfaceActive", "=", "this", ".", "pressedButtons", "[", "'surface'", "]", "||", "this", ".", "touchedButtons", "[", "'surface'", "]", ";", "var", "isTrackpadActive", "=", "this", ".", "pressedButtons", "[", "'trackpad'", "]", "||", "this", ".", "touchedButtons", "[", "'trackpad'", "]", ";", "var", "isTriggerActive", "=", "this", ".", "pressedButtons", "[", "'trigger'", "]", "||", "this", ".", "touchedButtons", "[", "'trigger'", "]", ";", "var", "isABXYActive", "=", "this", ".", "touchedButtons", "[", "'AorX'", "]", "||", "this", ".", "touchedButtons", "[", "'BorY'", "]", ";", "var", "isVive", "=", "isViveController", "(", "this", ".", "el", ".", "components", "[", "'tracked-controls'", "]", ")", ";", "// Works well with Oculus Touch and Windows Motion Controls, but Vive needs tweaks.", "if", "(", "isVive", ")", "{", "if", "(", "isGripActive", "||", "isTriggerActive", ")", "{", "gesture", "=", "ANIMATIONS", ".", "fist", ";", "}", "else", "if", "(", "isTrackpadActive", ")", "{", "gesture", "=", "ANIMATIONS", ".", "point", ";", "}", "}", "else", "{", "if", "(", "isGripActive", ")", "{", "if", "(", "isSurfaceActive", "||", "isABXYActive", "||", "isTrackpadActive", ")", "{", "gesture", "=", "isTriggerActive", "?", "ANIMATIONS", ".", "fist", ":", "ANIMATIONS", ".", "point", ";", "}", "else", "{", "gesture", "=", "isTriggerActive", "?", "ANIMATIONS", ".", "thumbUp", ":", "ANIMATIONS", ".", "pointThumb", ";", "}", "}", "else", "if", "(", "isTriggerActive", ")", "{", "gesture", "=", "ANIMATIONS", ".", "hold", ";", "}", "}", "return", "gesture", ";", "}" ]

[ "Determine", "which", "pose", "hand", "should", "be", "in", "considering", "active", "and", "touched", "buttons", "." ]

[ "function", "(", "gesture", ")", "{", "var", "clip", ";", "var", "i", ";", "for", "(", "i", "=", "0", ";", "i", "<", "this", ".", "clips", ".", "length", ";", "i", "++", ")", "{", "clip", "=", "this", ".", "clips", "[", "i", "]", ";", "if", "(", "clip", ".", "name", "!==", "gesture", ")", "{", "continue", ";", "}", "return", "clip", ";", "}", "}" ]

[ "Play", "corresponding", "clip", "to", "a", "gesture" ]

[ "function", "(", "gesture", ",", "lastGesture", ")", "{", "if", "(", "gesture", ")", "{", "this", ".", "playAnimation", "(", "gesture", "||", "ANIMATIONS", ".", "open", ",", "lastGesture", ",", "false", ")", ";", "return", ";", "}", "// If no gesture, then reverse the current gesture back to open pose.", "this", ".", "playAnimation", "(", "lastGesture", ",", "lastGesture", ",", "true", ")", ";", "}" ]

[ "Play", "gesture", "animation", "." ]

[ "function", "(", "gesture", ",", "lastGesture", ")", "{", "var", "el", "=", "this", ".", "el", ";", "var", "eventName", ";", "if", "(", "lastGesture", "===", "gesture", ")", "{", "return", ";", "}", "// Emit event for lastGesture not inactive.", "eventName", "=", "getGestureEventName", "(", "lastGesture", ",", "false", ")", ";", "if", "(", "eventName", ")", "{", "el", ".", "emit", "(", "eventName", ")", ";", "}", "// Emit event for current gesture now active.", "eventName", "=", "getGestureEventName", "(", "gesture", ",", "true", ")", ";", "if", "(", "eventName", ")", "{", "el", ".", "emit", "(", "eventName", ")", ";", "}", "}" ]

[ "Emit", "hand", "-", "controls", "-", "specific", "events", "." ]

[ "function", "(", "gesture", ",", "lastGesture", ",", "reverse", ")", "{", "var", "clip", ";", "var", "fromAction", ";", "var", "mesh", "=", "this", ".", "el", ".", "getObject3D", "(", "'mesh'", ")", ";", "var", "toAction", ";", "if", "(", "!", "mesh", ")", "{", "return", ";", "}", "// Stop all current animations.", "mesh", ".", "mixer", ".", "stopAllAction", "(", ")", ";", "// Grab clip action.", "clip", "=", "this", ".", "getClip", "(", "gesture", ")", ";", "toAction", "=", "mesh", ".", "mixer", ".", "clipAction", "(", "clip", ")", ";", "toAction", ".", "clampWhenFinished", "=", "true", ";", "toAction", ".", "loop", "=", "THREE", ".", "LoopRepeat", ";", "toAction", ".", "repetitions", "=", "0", ";", "toAction", ".", "timeScale", "=", "reverse", "?", "-", "1", ":", "1", ";", "toAction", ".", "time", "=", "reverse", "?", "clip", ".", "duration", ":", "0", ";", "toAction", ".", "weight", "=", "1", ";", "// No gesture to gesture or gesture to no gesture.", "if", "(", "!", "lastGesture", "||", "gesture", "===", "lastGesture", ")", "{", "// Stop all current animations.", "mesh", ".", "mixer", ".", "stopAllAction", "(", ")", ";", "// Play animation.", "toAction", ".", "play", "(", ")", ";", "return", ";", "}", "// Animate or crossfade from gesture to gesture.", "clip", "=", "this", ".", "getClip", "(", "lastGesture", ")", ";", "fromAction", "=", "mesh", ".", "mixer", ".", "clipAction", "(", "clip", ")", ";", "fromAction", ".", "weight", "=", "0.15", ";", "fromAction", ".", "play", "(", ")", ";", "toAction", ".", "play", "(", ")", ";", "fromAction", ".", "crossFadeTo", "(", "toAction", ",", "0.15", ",", "true", ")", ";", "}" ]

[ "Play", "hand", "animation", "based", "on", "button", "state", "." ]

[ "function", "getFog", "(", "data", ")", "{", "var", "fog", ";", "if", "(", "data", ".", "type", "===", "'exponential'", ")", "{", "fog", "=", "new", "THREE", ".", "FogExp2", "(", "data", ".", "color", ",", "data", ".", "density", ")", ";", "}", "else", "{", "fog", "=", "new", "THREE", ".", "Fog", "(", "data", ".", "color", ",", "data", ".", "near", ",", "data", ".", "far", ")", ";", "}", "fog", ".", "name", "=", "data", ".", "type", ";", "return", "fog", ";", "}" ]

[ "Creates", "a", "fog", "object", ".", "Sets", "fog", ".", "name", "to", "be", "able", "to", "detect", "fog", "type", "changes", "." ]

[ "function", "(", ")", "{", "var", "clearedIntersectedEls", "=", "this", ".", "clearedIntersectedEls", ";", "var", "el", "=", "this", ".", "el", ";", "var", "data", "=", "this", ".", "data", ";", "var", "i", ";", "var", "intersectedEls", "=", "this", ".", "intersectedEls", ";", "var", "intersection", ";", "var", "intersections", "=", "this", ".", "intersections", ";", "var", "newIntersectedEls", "=", "this", ".", "newIntersectedEls", ";", "var", "newIntersections", "=", "this", ".", "newIntersections", ";", "var", "prevIntersectedEls", "=", "this", ".", "prevIntersectedEls", ";", "var", "rawIntersections", "=", "this", ".", "rawIntersections", ";", "// Refresh the object whitelist if needed.", "if", "(", "this", ".", "dirty", ")", "{", "this", ".", "refreshObjects", "(", ")", ";", "}", "// Store old previously intersected entities.", "copyArray", "(", "this", ".", "prevIntersectedEls", ",", "this", ".", "intersectedEls", ")", ";", "// Raycast.", "this", ".", "updateOriginDirection", "(", ")", ";", "rawIntersections", ".", "length", "=", "0", ";", "this", ".", "raycaster", ".", "intersectObjects", "(", "this", ".", "objects", ",", "true", ",", "rawIntersections", ")", ";", "// Only keep intersections against objects that have a reference to an entity.", "intersections", ".", "length", "=", "0", ";", "intersectedEls", ".", "length", "=", "0", ";", "for", "(", "i", "=", "0", ";", "i", "<", "rawIntersections", ".", "length", ";", "i", "++", ")", "{", "intersection", "=", "rawIntersections", "[", "i", "]", ";", "// Don't intersect with own line.", "if", "(", "data", ".", "showLine", "&&", "intersection", ".", "object", "===", "el", ".", "getObject3D", "(", "'line'", ")", ")", "{", "continue", ";", "}", "if", "(", "intersection", ".", "object", ".", "el", ")", "{", "intersections", ".", "push", "(", "intersection", ")", ";", "intersectedEls", ".", "push", "(", "intersection", ".", "object", ".", "el", ")", ";", "}", "}", "// Get newly intersected entities.", "newIntersections", ".", "length", "=", "0", ";", "newIntersectedEls", ".", "length", "=", "0", ";", "for", "(", "i", "=", "0", ";", "i", "<", "intersections", ".", "length", ";", "i", "++", ")", "{", "if", "(", "prevIntersectedEls", ".", "indexOf", "(", "intersections", "[", "i", "]", ".", "object", ".", "el", ")", "===", "-", "1", ")", "{", "newIntersections", ".", "push", "(", "intersections", "[", "i", "]", ")", ";", "newIntersectedEls", ".", "push", "(", "intersections", "[", "i", "]", ".", "object", ".", "el", ")", ";", "}", "}", "// Emit intersection cleared on both entities per formerly intersected entity.", "clearedIntersectedEls", ".", "length", "=", "0", ";", "for", "(", "i", "=", "0", ";", "i", "<", "prevIntersectedEls", ".", "length", ";", "i", "++", ")", "{", "if", "(", "intersectedEls", ".", "indexOf", "(", "prevIntersectedEls", "[", "i", "]", ")", "!==", "-", "1", ")", "{", "continue", ";", "}", "prevIntersectedEls", "[", "i", "]", ".", "emit", "(", "EVENTS", ".", "INTERSECT_CLEAR", ",", "this", ".", "intersectedClearedDetail", ")", ";", "clearedIntersectedEls", ".", "push", "(", "prevIntersectedEls", "[", "i", "]", ")", ";", "}", "if", "(", "clearedIntersectedEls", ".", "length", ")", "{", "el", ".", "emit", "(", "EVENTS", ".", "INTERSECTION_CLEAR", ",", "this", ".", "intersectionClearedDetail", ")", ";", "}", "// Emit intersected on intersected entity per intersected entity.", "for", "(", "i", "=", "0", ";", "i", "<", "newIntersectedEls", ".", "length", ";", "i", "++", ")", "{", "newIntersectedEls", "[", "i", "]", ".", "emit", "(", "EVENTS", ".", "INTERSECT", ",", "this", ".", "intersectedDetail", ")", ";", "}", "// Emit all intersections at once on raycasting entity.", "if", "(", "newIntersections", ".", "length", ")", "{", "this", ".", "intersectionDetail", ".", "els", "=", "newIntersectedEls", ";", "this", ".", "intersectionDetail", ".", "intersections", "=", "newIntersections", ";", "el", ".", "emit", "(", "EVENTS", ".", "INTERSECTION", ",", "this", ".", "intersectionDetail", ")", ";", "}", "// Update line length.", "setTimeout", "(", "this", ".", "updateLine", ")", ";", "}" ]

[ "Raycast", "for", "intersections", "and", "emit", "events", "for", "current", "and", "cleared", "inersections", "." ]

[ "function", "(", "el", ")", "{", "var", "i", ";", "var", "intersection", ";", "for", "(", "i", "=", "0", ";", "i", "<", "this", ".", "intersections", ".", "length", ";", "i", "++", ")", "{", "intersection", "=", "this", ".", "intersections", "[", "i", "]", ";", "if", "(", "intersection", ".", "object", ".", "el", "===", "el", ")", "{", "return", "intersection", ";", "}", "}", "return", "null", ";", "}" ]

[ "Return", "the", "most", "recent", "intersection", "details", "for", "a", "given", "entity", "if", "any", "." ]

[ "function", "(", "length", ")", "{", "var", "data", "=", "this", ".", "data", ";", "var", "el", "=", "this", ".", "el", ";", "var", "endVec3", ";", "// Switch each time vector so line update triggered and to avoid unnecessary vector clone.", "endVec3", "=", "this", ".", "lineData", ".", "end", "===", "this", ".", "lineEndVec3", "?", "this", ".", "otherLineEndVec3", ":", "this", ".", "lineEndVec3", ";", "// Treat Infinity as 1000m for the line.", "if", "(", "length", "===", "undefined", ")", "{", "length", "=", "data", ".", "far", "===", "Infinity", "?", "1000", ":", "data", ".", "far", ";", "}", "// Update the length of the line if given. `unitLineEndVec3` is the direction", "// given by data.direction, then we apply a scalar to give it a length.", "this", ".", "lineData", ".", "start", "=", "data", ".", "origin", ";", "this", ".", "lineData", ".", "end", "=", "endVec3", ".", "copy", "(", "this", ".", "unitLineEndVec3", ")", ".", "multiplyScalar", "(", "length", ")", ";", "el", ".", "setAttribute", "(", "'line'", ",", "this", ".", "lineData", ")", ";", "}" ]

[ "Create", "or", "update", "line", "to", "give", "raycaster", "visual", "representation", ".", "Customize", "the", "line", "through", "through", "line", "component", ".", "We", "draw", "the", "line", "in", "the", "raycaster", "component", "to", "customize", "the", "line", "to", "the", "raycaster", "s", "origin", "direction", "and", "far", "." ]

[ "function", "processPropertyDefinition", "(", "propDefinition", ",", "componentName", ")", "{", "var", "defaultVal", "=", "propDefinition", ".", "default", ";", "var", "isCustomType", ";", "var", "propType", ";", "var", "typeName", "=", "propDefinition", ".", "type", ";", "// Type inference.", "if", "(", "!", "propDefinition", ".", "type", ")", "{", "if", "(", "defaultVal", "!==", "undefined", "&&", "(", "typeof", "defaultVal", "===", "'boolean'", "||", "typeof", "defaultVal", "===", "'number'", ")", ")", "{", "// Type inference.", "typeName", "=", "typeof", "defaultVal", ";", "}", "else", "if", "(", "Array", ".", "isArray", "(", "defaultVal", ")", ")", "{", "typeName", "=", "'array'", ";", "}", "else", "{", "// Fall back to string.", "typeName", "=", "'string'", ";", "}", "}", "else", "if", "(", "propDefinition", ".", "type", "===", "'bool'", ")", "{", "typeName", "=", "'boolean'", ";", "}", "else", "if", "(", "propDefinition", ".", "type", "===", "'float'", ")", "{", "typeName", "=", "'number'", ";", "}", "propType", "=", "propertyTypes", "[", "typeName", "]", ";", "if", "(", "!", "propType", ")", "{", "warn", "(", "'Unknown property type for component `'", "+", "componentName", "+", "'`: '", "+", "typeName", ")", ";", "}", "// Fill in parse and stringify using property types.", "isCustomType", "=", "!", "!", "propDefinition", ".", "parse", ";", "propDefinition", ".", "parse", "=", "propDefinition", ".", "parse", "||", "propType", ".", "parse", ";", "propDefinition", ".", "stringify", "=", "propDefinition", ".", "stringify", "||", "propType", ".", "stringify", ";", "// Fill in type name.", "propDefinition", ".", "type", "=", "typeName", ";", "// Check that default value exists.", "if", "(", "'default'", "in", "propDefinition", ")", "{", "// Check that default values are valid.", "if", "(", "!", "isCustomType", "&&", "!", "isValidDefaultValue", "(", "typeName", ",", "defaultVal", ")", ")", "{", "warn", "(", "'Default value `'", "+", "defaultVal", "+", "'` does not match type `'", "+", "typeName", "+", "'` in component `'", "+", "componentName", "+", "'`'", ")", ";", "}", "}", "else", "{", "// Fill in default value.", "propDefinition", ".", "default", "=", "propType", ".", "default", ";", "}", "return", "propDefinition", ";", "}" ]

[ "Inject", "default", "value", "parser", "stringifier", "for", "single", "property", "." ]

[ "function", "parseProperty", "(", "value", ",", "propDefinition", ")", "{", "// Use default value if value is falsy.", "if", "(", "value", "===", "undefined", "||", "value", "===", "null", "||", "value", "===", "''", ")", "{", "value", "=", "propDefinition", ".", "default", ";", "if", "(", "Array", ".", "isArray", "(", "value", ")", ")", "{", "value", "=", "value", ".", "slice", "(", ")", ";", "}", "}", "// Invoke property type parser.", "return", "propDefinition", ".", "parse", "(", "value", ",", "propDefinition", ".", "default", ")", ";", "}" ]

[ "Deserialize", "a", "single", "property", "." ]

[ "function", "stringifyProperty", "(", "value", ",", "propDefinition", ")", "{", "// This function stringifies but it's used in a context where", "// there's always second stringification pass. By returning the original", "// value when it's not an object we save one unnecessary call", "// to JSON.stringify.", "if", "(", "typeof", "value", "!==", "'object'", ")", "{", "return", "value", ";", "}", "// if there's no schema for the property we use standar JSON stringify", "if", "(", "!", "propDefinition", "||", "value", "===", "null", ")", "{", "return", "JSON", ".", "stringify", "(", "value", ")", ";", "}", "return", "propDefinition", ".", "stringify", "(", "value", ")", ";", "}" ]

[ "Serialize", "a", "single", "property", "." ]

[ "function", "mediaElementLoaded", "(", "el", ")", "{", "if", "(", "!", "el", ".", "hasAttribute", "(", "'autoplay'", ")", "&&", "el", ".", "getAttribute", "(", "'preload'", ")", "!==", "'auto'", ")", "{", "return", ";", "}", "// If media specifies autoplay or preload, wait until media is completely buffered.", "return", "new", "Promise", "(", "function", "(", "resolve", ",", "reject", ")", "{", "if", "(", "el", ".", "readyState", "===", "4", ")", "{", "return", "resolve", "(", ")", ";", "}", "// Already loaded.", "if", "(", "el", ".", "error", ")", "{", "return", "reject", "(", ")", ";", "}", "// Error.", "el", ".", "addEventListener", "(", "'loadeddata'", ",", "checkProgress", ",", "false", ")", ";", "el", ".", "addEventListener", "(", "'progress'", ",", "checkProgress", ",", "false", ")", ";", "el", ".", "addEventListener", "(", "'error'", ",", "reject", ",", "false", ")", ";", "function", "checkProgress", "(", ")", "{", "// Add up the seconds buffered.", "var", "secondsBuffered", "=", "0", ";", "for", "(", "var", "i", "=", "0", ";", "i", "<", "el", ".", "buffered", ".", "length", ";", "i", "++", ")", "{", "secondsBuffered", "+=", "el", ".", "buffered", ".", "end", "(", "i", ")", "-", "el", ".", "buffered", ".", "start", "(", "i", ")", ";", "}", "// Compare seconds buffered to media duration.", "if", "(", "secondsBuffered", ">=", "el", ".", "duration", ")", "{", "// Set in cache because we won't be needing to call three.js loader if we have.", "// a loaded media element.", "// Store video elements only. three.js loader is used for audio elements.", "// See assetParse too.", "if", "(", "el", ".", "tagName", "===", "'VIDEO'", ")", "{", "THREE", ".", "Cache", ".", "files", "[", "el", ".", "getAttribute", "(", "'src'", ")", "]", "=", "el", ";", "}", "resolve", "(", ")", ";", "}", "}", "}", ")", ";", "}" ]

[ "Create", "a", "Promise", "that", "resolves", "once", "the", "media", "element", "has", "finished", "buffering", "." ]

[ "function", "fixUpMediaElement", "(", "mediaEl", ")", "{", "// Cross-origin.", "var", "newMediaEl", "=", "setCrossOrigin", "(", "mediaEl", ")", ";", "// Plays inline for mobile.", "if", "(", "newMediaEl", ".", "tagName", "&&", "newMediaEl", ".", "tagName", ".", "toLowerCase", "(", ")", "===", "'video'", ")", "{", "newMediaEl", ".", "setAttribute", "(", "'playsinline'", ",", "''", ")", ";", "newMediaEl", ".", "setAttribute", "(", "'webkit-playsinline'", ",", "''", ")", ";", "}", "if", "(", "newMediaEl", "!==", "mediaEl", ")", "{", "mediaEl", ".", "parentNode", ".", "appendChild", "(", "newMediaEl", ")", ";", "mediaEl", ".", "parentNode", ".", "removeChild", "(", "mediaEl", ")", ";", "}", "return", "newMediaEl", ";", "}" ]

[ "Automatically", "add", "attributes", "to", "media", "elements", "where", "convenient", ".", "crossorigin", "playsinline", "." ]

[ "function", "extractDomain", "(", "url", ")", "{", "// Find and remove protocol (e.g., http, ftp, etc.) to get domain.", "var", "domain", "=", "url", ".", "indexOf", "(", "'://'", ")", ">", "-", "1", "?", "url", ".", "split", "(", "'/'", ")", "[", "2", "]", ":", "url", ".", "split", "(", "'/'", ")", "[", "0", "]", ";", "// Find and remove port number.", "return", "domain", ".", "substring", "(", "0", ",", "domain", ".", "indexOf", "(", "':'", ")", ")", ";", "}" ]

[ "Extract", "domain", "out", "of", "URL", "." ]

[ "function", "(", "evt", ")", "{", "// Raycast again for touch.", "if", "(", "this", ".", "data", ".", "rayOrigin", "===", "'mouse'", "&&", "evt", ".", "type", "===", "'touchstart'", ")", "{", "this", ".", "onMouseMove", "(", "evt", ")", ";", "this", ".", "el", ".", "components", ".", "raycaster", ".", "checkIntersections", "(", ")", ";", "evt", ".", "preventDefault", "(", ")", ";", "}", "this", ".", "twoWayEmit", "(", "EVENTS", ".", "MOUSEDOWN", ")", ";", "this", ".", "cursorDownEl", "=", "this", ".", "intersectedEl", ";", "}" ]

[ "Trigger", "mousedown", "and", "keep", "track", "of", "the", "mousedowned", "entity", "." ]

[ "function", "(", "evt", ")", "{", "var", "currentIntersection", ";", "var", "cursorEl", "=", "this", ".", "el", ";", "var", "index", ";", "var", "intersectedEl", ";", "var", "intersection", ";", "// Select closest object, excluding the cursor.", "index", "=", "evt", ".", "detail", ".", "els", "[", "0", "]", "===", "cursorEl", "?", "1", ":", "0", ";", "intersection", "=", "evt", ".", "detail", ".", "intersections", "[", "index", "]", ";", "intersectedEl", "=", "evt", ".", "detail", ".", "els", "[", "index", "]", ";", "// If cursor is the only intersected object, ignore the event.", "if", "(", "!", "intersectedEl", ")", "{", "return", ";", "}", "// Already intersecting this entity.", "if", "(", "this", ".", "intersectedEl", "===", "intersectedEl", ")", "{", "return", ";", "}", "// Ignore events further away than active intersection.", "if", "(", "this", ".", "intersectedEl", ")", "{", "currentIntersection", "=", "this", ".", "el", ".", "components", ".", "raycaster", ".", "getIntersection", "(", "this", ".", "intersectedEl", ")", ";", "if", "(", "currentIntersection", "&&", "currentIntersection", ".", "distance", "<=", "intersection", ".", "distance", ")", "{", "return", ";", "}", "}", "// Unset current intersection.", "this", ".", "clearCurrentIntersection", "(", "true", ")", ";", "this", ".", "setIntersection", "(", "intersectedEl", ",", "intersection", ")", ";", "}" ]

[ "Handle", "intersection", "." ]

[ "function", "(", "data", ")", "{", "this", ".", "attributes", "=", "this", ".", "initVariables", "(", "data", ",", "'attribute'", ")", ";", "this", ".", "uniforms", "=", "this", ".", "initVariables", "(", "data", ",", "'uniform'", ")", ";", "this", ".", "material", "=", "new", "(", "this", ".", "raw", "?", "THREE", ".", "RawShaderMaterial", ":", "THREE", ".", "ShaderMaterial", ")", "(", "{", "// attributes: this.attributes,", "uniforms", ":", "this", ".", "uniforms", ",", "vertexShader", ":", "this", ".", "vertexShader", ",", "fragmentShader", ":", "this", ".", "fragmentShader", "}", ")", ";", "return", "this", ".", "material", ";", "}" ]

[ "Init", "handler", ".", "Similar", "to", "attachedCallback", ".", "Called", "during", "shader", "initialization", "and", "is", "only", "run", "once", "." ]

[ "function", "extend", "(", "base", ",", "extension", ")", "{", "if", "(", "isUndefined", "(", "base", ")", ")", "{", "return", "copy", "(", "extension", ")", ";", "}", "if", "(", "isUndefined", "(", "extension", ")", ")", "{", "return", "copy", "(", "base", ")", ";", "}", "if", "(", "isPureObject", "(", "base", ")", "&&", "isPureObject", "(", "extension", ")", ")", "{", "return", "utils", ".", "extendDeep", "(", "base", ",", "extension", ")", ";", "}", "return", "copy", "(", "extension", ")", ";", "}" ]

[ "For", "the", "base", "to", "be", "extensible", "both", "objects", "must", "be", "pure", "JavaScript", "objects", ".", "The", "function", "assumes", "that", "base", "is", "undefined", "or", "null", "or", "a", "pure", "object", "." ]

[ "function", "addComponentMapping", "(", "componentName", ",", "mappings", ")", "{", "var", "schema", "=", "components", "[", "componentName", "]", ".", "schema", ";", "Object", ".", "keys", "(", "schema", ")", ".", "map", "(", "function", "(", "prop", ")", "{", "// Hyphenate where there is camelCase.", "var", "attrName", "=", "prop", ".", "replace", "(", "/", "([a-z])([A-Z])", "/", "g", ",", "'$1-$2'", ")", ".", "toLowerCase", "(", ")", ";", "// If there is a mapping collision, prefix with component name and hyphen.", "if", "(", "mappings", "[", "attrName", "]", "!==", "undefined", ")", "{", "attrName", "=", "componentName", "+", "'-'", "+", "prop", ";", "}", "mappings", "[", "attrName", "]", "=", "componentName", "+", "'.'", "+", "prop", ";", "}", ")", ";", "}" ]

[ "Add", "component", "mappings", "using", "schema", "." ]

[ "function", "definePrimitive", "(", "tagName", ",", "defaultComponents", ",", "mappings", ")", "{", "// If no initial mappings provided, start from empty map.", "mappings", "=", "mappings", "||", "{", "}", ";", "// From the default components, add mapping automagically.", "Object", ".", "keys", "(", "defaultComponents", ")", ".", "map", "(", "function", "buildMappings", "(", "componentName", ")", "{", "addComponentMapping", "(", "componentName", ",", "mappings", ")", ";", "}", ")", ";", "// Register the primitive.", "module", ".", "exports", ".", "registerPrimitive", "(", "tagName", ",", "utils", ".", "extendDeep", "(", "{", "}", ",", "null", ",", "{", "defaultComponents", ":", "defaultComponents", ",", "mappings", ":", "mappings", "}", ")", ")", ";", "}" ]

[ "Helper", "to", "define", "a", "primitive", "building", "mappings", "using", "a", "component", "schema", "." ]

[ "function", "registerPropertyType", "(", "type", ",", "defaultValue", ",", "parse", ",", "stringify", ")", "{", "if", "(", "'type'", "in", "propertyTypes", ")", "{", "error", "(", "'Property type '", "+", "type", "+", "' is already registered.'", ")", ";", "return", ";", "}", "propertyTypes", "[", "type", "]", "=", "{", "default", ":", "defaultValue", ",", "parse", ":", "parse", "||", "defaultParse", ",", "stringify", ":", "stringify", "||", "defaultStringify", "}", ";", "}" ]

[ "Register", "a", "parser", "for", "re", "-", "use", "such", "that", "when", "someone", "uses", "type", "in", "the", "schema", "schema", ".", "process", "will", "set", "the", "property", "parse", "and", "stringify", "." ]

[ "function", "assetParse", "(", "value", ")", "{", "var", "el", ";", "var", "parsedUrl", ";", "// If an element was provided (e.g. canvas or video), just return it.", "if", "(", "typeof", "value", "!==", "'string'", ")", "{", "return", "value", ";", "}", "// Wrapped `url()` in case of data URI.", "parsedUrl", "=", "value", ".", "match", "(", "urlRegex", ")", ";", "if", "(", "parsedUrl", ")", "{", "return", "parsedUrl", "[", "1", "]", ";", "}", "// ID.", "if", "(", "value", ".", "charAt", "(", "0", ")", "===", "'#'", ")", "{", "el", "=", "document", ".", "getElementById", "(", "value", ".", "substring", "(", "1", ")", ")", ";", "if", "(", "el", ")", "{", "// Pass through media elements. If we have the elements, we don't have to call", "// three.js loaders which would re-request the assets.", "if", "(", "el", ".", "tagName", "===", "'CANVAS'", "||", "el", ".", "tagName", "===", "'VIDEO'", "||", "el", ".", "tagName", "===", "'IMG'", ")", "{", "return", "el", ";", "}", "return", "el", ".", "getAttribute", "(", "'src'", ")", ";", "}", "warn", "(", "'\"'", "+", "value", "+", "'\" asset not found.'", ")", ";", "return", ";", "}", "// Non-wrapped url().", "return", "value", ";", "}" ]

[ "For", "general", "assets", "." ]

[ "function", "isValidDefaultValue", "(", "type", ",", "defaultVal", ")", "{", "if", "(", "type", "===", "'audio'", "&&", "typeof", "defaultVal", "!==", "'string'", ")", "{", "return", "false", ";", "}", "if", "(", "type", "===", "'array'", "&&", "!", "Array", ".", "isArray", "(", "defaultVal", ")", ")", "{", "return", "false", ";", "}", "if", "(", "type", "===", "'asset'", "&&", "typeof", "defaultVal", "!==", "'string'", ")", "{", "return", "false", ";", "}", "if", "(", "type", "===", "'boolean'", "&&", "typeof", "defaultVal", "!==", "'boolean'", ")", "{", "return", "false", ";", "}", "if", "(", "type", "===", "'color'", "&&", "typeof", "defaultVal", "!==", "'string'", ")", "{", "return", "false", ";", "}", "if", "(", "type", "===", "'int'", "&&", "typeof", "defaultVal", "!==", "'number'", ")", "{", "return", "false", ";", "}", "if", "(", "type", "===", "'number'", "&&", "typeof", "defaultVal", "!==", "'number'", ")", "{", "return", "false", ";", "}", "if", "(", "type", "===", "'map'", "&&", "typeof", "defaultVal", "!==", "'string'", ")", "{", "return", "false", ";", "}", "if", "(", "type", "===", "'model'", "&&", "typeof", "defaultVal", "!==", "'string'", ")", "{", "return", "false", ";", "}", "if", "(", "type", "===", "'selector'", "&&", "typeof", "defaultVal", "!==", "'string'", "&&", "defaultVal", "!==", "null", ")", "{", "return", "false", ";", "}", "if", "(", "type", "===", "'selectorAll'", "&&", "typeof", "defaultVal", "!==", "'string'", "&&", "defaultVal", "!==", "null", ")", "{", "return", "false", ";", "}", "if", "(", "type", "===", "'src'", "&&", "typeof", "defaultVal", "!==", "'string'", ")", "{", "return", "false", ";", "}", "if", "(", "type", "===", "'string'", "&&", "typeof", "defaultVal", "!==", "'string'", ")", "{", "return", "false", ";", "}", "if", "(", "type", "===", "'time'", "&&", "typeof", "defaultVal", "!==", "'number'", ")", "{", "return", "false", ";", "}", "if", "(", "type", "===", "'vec2'", ")", "{", "return", "isValidDefaultCoordinate", "(", "defaultVal", ",", "2", ")", ";", "}", "if", "(", "type", "===", "'vec3'", ")", "{", "return", "isValidDefaultCoordinate", "(", "defaultVal", ",", "3", ")", ";", "}", "if", "(", "type", "===", "'vec4'", ")", "{", "return", "isValidDefaultCoordinate", "(", "defaultVal", ",", "4", ")", ";", "}", "return", "true", ";", "}" ]

[ "Validate", "the", "default", "values", "in", "a", "schema", "to", "match", "their", "type", "." ]

[ "function", "isValidDefaultCoordinate", "(", "possibleCoordinates", ",", "dimensions", ")", "{", "if", "(", "possibleCoordinates", "===", "null", ")", "{", "return", "true", ";", "}", "if", "(", "typeof", "possibleCoordinates", "!==", "'object'", ")", "{", "return", "false", ";", "}", "if", "(", "Object", ".", "keys", "(", "possibleCoordinates", ")", ".", "length", "!==", "dimensions", ")", "{", "return", "false", ";", "}", "else", "{", "var", "x", "=", "possibleCoordinates", ".", "x", ";", "var", "y", "=", "possibleCoordinates", ".", "y", ";", "var", "z", "=", "possibleCoordinates", ".", "z", ";", "var", "w", "=", "possibleCoordinates", ".", "w", ";", "if", "(", "typeof", "x", "!==", "'number'", "||", "typeof", "y", "!==", "'number'", ")", "{", "return", "false", ";", "}", "if", "(", "dimensions", ">", "2", "&&", "typeof", "z", "!==", "'number'", ")", "{", "return", "false", ";", "}", "if", "(", "dimensions", ">", "3", "&&", "typeof", "w", "!==", "'number'", ")", "{", "return", "false", ";", "}", "}", "return", "true", ";", "}" ]

[ "Checks", "if", "default", "coordinates", "are", "valid", "." ]

[ "function", "(", ")", "{", "var", "controllers", "=", "this", ".", "controllers", ";", "var", "gamepad", ";", "var", "gamepads", ";", "var", "i", ";", "var", "prevCount", ";", "gamepads", "=", "navigator", ".", "getGamepads", "&&", "navigator", ".", "getGamepads", "(", ")", ";", "if", "(", "!", "gamepads", ")", "{", "return", ";", "}", "prevCount", "=", "controllers", ".", "length", ";", "controllers", ".", "length", "=", "0", ";", "for", "(", "i", "=", "0", ";", "i", "<", "gamepads", ".", "length", ";", "++", "i", ")", "{", "gamepad", "=", "gamepads", "[", "i", "]", ";", "if", "(", "gamepad", "&&", "gamepad", ".", "pose", ")", "{", "controllers", ".", "push", "(", "gamepad", ")", ";", "}", "}", "if", "(", "controllers", ".", "length", "!==", "prevCount", ")", "{", "this", ".", "el", ".", "emit", "(", "'controllersupdated'", ",", "undefined", ",", "false", ")", ";", "}", "}" ]

[ "Update", "controller", "list", "." ]

[ "function", "validateSrc", "(", "src", ",", "isImageCb", ",", "isVideoCb", ")", "{", "checkIsImage", "(", "src", ",", "function", "isAnImageUrl", "(", "isImage", ")", "{", "if", "(", "isImage", ")", "{", "isImageCb", "(", "src", ")", ";", "return", ";", "}", "isVideoCb", "(", "src", ")", ";", "}", ")", ";", "}" ]

[ "Validate", "a", "texture", "either", "as", "a", "selector", "or", "as", "a", "URL", ".", "Detects", "whether", "src", "is", "pointing", "to", "an", "image", "or", "video", "and", "invokes", "the", "appropriate", "callback", "." ]

[ "function", "validateCubemapSrc", "(", "src", ",", "cb", ")", "{", "var", "aCubemap", ";", "var", "cubemapSrcRegex", "=", "''", ";", "var", "i", ";", "var", "urls", ";", "var", "validatedUrls", "=", "[", "]", ";", "for", "(", "i", "=", "0", ";", "i", "<", "5", ";", "i", "++", ")", "{", "cubemapSrcRegex", "+=", "'(url\\\\((?:[^\\\\)]+)\\\\),\\\\s*)'", ";", "}", "cubemapSrcRegex", "+=", "'(url\\\\((?:[^\\\\)]+)\\\\)\\\\s*)'", ";", "urls", "=", "src", ".", "match", "(", "new", "RegExp", "(", "cubemapSrcRegex", ")", ")", ";", "// `src` is a comma-separated list of URLs.", "// In this case, re-use validateSrc for each side of the cube.", "function", "isImageCb", "(", "url", ")", "{", "validatedUrls", ".", "push", "(", "url", ")", ";", "if", "(", "validatedUrls", ".", "length", "===", "6", ")", "{", "cb", "(", "validatedUrls", ")", ";", "}", "}", "if", "(", "urls", ")", "{", "for", "(", "i", "=", "1", ";", "i", "<", "7", ";", "i", "++", ")", "{", "validateSrc", "(", "parseUrl", "(", "urls", "[", "i", "]", ")", ",", "isImageCb", ")", ";", "}", "return", ";", "}", "// `src` is a query selector to <a-cubemap> containing six $([src])s.", "aCubemap", "=", "validateAndGetQuerySelector", "(", "src", ")", ";", "if", "(", "!", "aCubemap", ")", "{", "return", ";", "}", "if", "(", "aCubemap", ".", "tagName", "===", "'A-CUBEMAP'", "&&", "aCubemap", ".", "srcs", ")", "{", "return", "cb", "(", "aCubemap", ".", "srcs", ")", ";", "}", "// Else if aCubeMap is not a <a-cubemap>.", "warn", "(", "'Selector \"%s\" does not point to <a-cubemap>'", ",", "src", ")", ";", "}" ]

[ "Validates", "six", "images", "as", "a", "cubemap", "either", "as", "selector", "or", "comma", "-", "separated", "URLs", "." ]

[ "function", "checkIsImage", "(", "src", ",", "onResult", ")", "{", "var", "request", ";", "if", "(", "src", ".", "tagName", ")", "{", "onResult", "(", "src", ".", "tagName", "===", "'IMG'", ")", ";", "return", ";", "}", "request", "=", "new", "XMLHttpRequest", "(", ")", ";", "// Try to send HEAD request to check if image first.", "request", ".", "open", "(", "'HEAD'", ",", "src", ")", ";", "request", ".", "addEventListener", "(", "'load'", ",", "function", "(", "event", ")", "{", "var", "contentType", ";", "if", "(", "request", ".", "status", ">=", "200", "&&", "request", ".", "status", "<", "300", ")", "{", "contentType", "=", "request", ".", "getResponseHeader", "(", "'Content-Type'", ")", ";", "if", "(", "contentType", "==", "null", ")", "{", "checkIsImageFallback", "(", "src", ",", "onResult", ")", ";", "}", "else", "{", "if", "(", "contentType", ".", "startsWith", "(", "'image'", ")", ")", "{", "onResult", "(", "true", ")", ";", "}", "else", "{", "onResult", "(", "false", ")", ";", "}", "}", "}", "else", "{", "checkIsImageFallback", "(", "src", ",", "onResult", ")", ";", "}", "request", ".", "abort", "(", ")", ";", "}", ")", ";", "request", ".", "send", "(", ")", ";", "}" ]

[ "Call", "back", "whether", "src", "is", "an", "image", "." ]

[ "function", "validateAndGetQuerySelector", "(", "selector", ")", "{", "try", "{", "var", "el", "=", "document", ".", "querySelector", "(", "selector", ")", ";", "if", "(", "!", "el", ")", "{", "warn", "(", "'No element was found matching the selector: \"%s\"'", ",", "selector", ")", ";", "}", "return", "el", ";", "}", "catch", "(", "e", ")", "{", "// Capture exception if it's not a valid selector.", "warn", "(", "'\"%s\" is not a valid selector'", ",", "selector", ")", ";", "return", "undefined", ";", "}", "}" ]

[ "Query", "and", "validate", "a", "query", "selector" ]

[ "function", "(", "src", ",", "data", ",", "cb", ")", "{", "var", "self", "=", "this", ";", "// Canvas.", "if", "(", "src", ".", "tagName", "===", "'CANVAS'", ")", "{", "this", ".", "loadCanvas", "(", "src", ",", "data", ",", "cb", ")", ";", "return", ";", "}", "// Video element.", "if", "(", "src", ".", "tagName", "===", "'VIDEO'", ")", "{", "if", "(", "!", "src", ".", "src", "&&", "!", "src", ".", "srcObject", "&&", "!", "src", ".", "childElementCount", ")", "{", "warn", "(", "'Video element was defined with neither `source` elements nor `src` / `srcObject` attributes.'", ")", ";", "}", "this", ".", "loadVideo", "(", "src", ",", "data", ",", "cb", ")", ";", "return", ";", "}", "utils", ".", "srcLoader", ".", "validateSrc", "(", "src", ",", "loadImageCb", ",", "loadVideoCb", ")", ";", "function", "loadImageCb", "(", "src", ")", "{", "self", ".", "loadImage", "(", "src", ",", "data", ",", "cb", ")", ";", "}", "function", "loadVideoCb", "(", "src", ")", "{", "self", ".", "loadVideo", "(", "src", ",", "data", ",", "cb", ")", ";", "}", "}" ]

[ "Determine", "whether", "src", "is", "a", "image", "or", "video", ".", "Then", "try", "to", "load", "the", "asset", "then", "call", "back", "." ]

[ "function", "(", "data", ")", "{", "if", "(", "data", ".", "src", ".", "tagName", ")", "{", "// Since `data.src` can be an element, parse out the string if necessary for the hash.", "data", "=", "utils", ".", "extendDeep", "(", "{", "}", ",", "data", ")", ";", "data", ".", "src", "=", "data", ".", "src", ".", "src", ";", "}", "return", "JSON", ".", "stringify", "(", "data", ")", ";", "}" ]

[ "Create", "a", "hash", "of", "the", "material", "properties", "for", "texture", "cache", "key", "." ]

[ "function", "(", "material", ")", "{", "delete", "this", ".", "materials", "[", "material", ".", "uuid", "]", ";", "// If any textures on this material are no longer in use, dispose of them.", "var", "textureCounts", "=", "this", ".", "textureCounts", ";", "Object", ".", "keys", "(", "material", ")", ".", "filter", "(", "function", "(", "propName", ")", "{", "return", "material", "[", "propName", "]", "&&", "material", "[", "propName", "]", ".", "isTexture", ";", "}", ")", ".", "forEach", "(", "function", "(", "mapName", ")", "{", "textureCounts", "[", "material", "[", "mapName", "]", ".", "uuid", "]", "--", ";", "if", "(", "textureCounts", "[", "material", "[", "mapName", "]", ".", "uuid", "]", "<=", "0", ")", "{", "material", "[", "mapName", "]", ".", "dispose", "(", ")", ";", "}", "}", ")", ";", "}" ]

[ "Stop", "tracking", "material", "and", "dispose", "of", "any", "textures", "not", "being", "used", "by", "another", "material", "component", "." ]

[ "function", "(", "material", ")", "{", "var", "materials", "=", "this", ".", "materials", ";", "Object", ".", "keys", "(", "materials", ")", ".", "forEach", "(", "function", "(", "uuid", ")", "{", "materials", "[", "uuid", "]", ".", "needsUpdate", "=", "true", ";", "}", ")", ";", "}" ]

[ "Trigger", "update", "to", "all", "registered", "materials", "." ]

[ "function", "loadImageTexture", "(", "src", ",", "data", ")", "{", "return", "new", "Promise", "(", "doLoadImageTexture", ")", ";", "function", "doLoadImageTexture", "(", "resolve", ",", "reject", ")", "{", "var", "isEl", "=", "typeof", "src", "!==", "'string'", ";", "function", "resolveTexture", "(", "texture", ")", "{", "setTextureProperties", "(", "texture", ",", "data", ")", ";", "texture", ".", "needsUpdate", "=", "true", ";", "resolve", "(", "texture", ")", ";", "}", "// Create texture from an element.", "if", "(", "isEl", ")", "{", "resolveTexture", "(", "new", "THREE", ".", "Texture", "(", "src", ")", ")", ";", "return", ";", "}", "// Request and load texture from src string. THREE will create underlying element.", "// Use THREE.TextureLoader (src, onLoad, onProgress, onError) to load texture.", "TextureLoader", ".", "load", "(", "src", ",", "resolveTexture", ",", "function", "(", ")", "{", "/* no-op */", "}", ",", "function", "(", "xhr", ")", "{", "error", "(", "'`$s` could not be fetched (Error code: %s; Response: %s)'", ",", "xhr", ".", "status", ",", "xhr", ".", "statusText", ")", ";", "}", ")", ";", "}", "}" ]

[ "Load", "image", "texture", "." ]

[ "function", "setTextureProperties", "(", "texture", ",", "data", ")", "{", "var", "offset", "=", "data", ".", "offset", "||", "{", "x", ":", "0", ",", "y", ":", "0", "}", ";", "var", "repeat", "=", "data", ".", "repeat", "||", "{", "x", ":", "1", ",", "y", ":", "1", "}", ";", "var", "npot", "=", "data", ".", "npot", "||", "false", ";", "// To support NPOT textures, wrap must be ClampToEdge (not Repeat),", "// and filters must not use mipmaps (i.e. Nearest or Linear).", "if", "(", "npot", ")", "{", "texture", ".", "wrapS", "=", "THREE", ".", "ClampToEdgeWrapping", ";", "texture", ".", "wrapT", "=", "THREE", ".", "ClampToEdgeWrapping", ";", "texture", ".", "magFilter", "=", "THREE", ".", "LinearFilter", ";", "texture", ".", "minFilter", "=", "THREE", ".", "LinearFilter", ";", "}", "// Don't bother setting repeat if it is 1/1. Power-of-two is required to repeat.", "if", "(", "repeat", ".", "x", "!==", "1", "||", "repeat", ".", "y", "!==", "1", ")", "{", "texture", ".", "wrapS", "=", "THREE", ".", "RepeatWrapping", ";", "texture", ".", "wrapT", "=", "THREE", ".", "RepeatWrapping", ";", "texture", ".", "repeat", ".", "set", "(", "repeat", ".", "x", ",", "repeat", ".", "y", ")", ";", "}", "// Don't bother setting offset if it is 0/0.", "if", "(", "offset", ".", "x", "!==", "0", "||", "offset", ".", "y", "!==", "0", ")", "{", "texture", ".", "offset", ".", "set", "(", "offset", ".", "x", ",", "offset", ".", "y", ")", ";", "}", "}" ]

[ "Set", "texture", "properties", "such", "as", "repeat", "and", "offset", "." ]

[ "function", "createVideoEl", "(", "src", ",", "width", ",", "height", ")", "{", "var", "videoEl", "=", "document", ".", "createElement", "(", "'video'", ")", ";", "videoEl", ".", "width", "=", "width", ";", "videoEl", ".", "height", "=", "height", ";", "// Support inline videos for iOS webviews.", "videoEl", ".", "setAttribute", "(", "'playsinline'", ",", "''", ")", ";", "videoEl", ".", "setAttribute", "(", "'webkit-playsinline'", ",", "''", ")", ";", "videoEl", ".", "autoplay", "=", "true", ";", "videoEl", ".", "loop", "=", "true", ";", "videoEl", ".", "crossOrigin", "=", "'anonymous'", ";", "videoEl", ".", "addEventListener", "(", "'error'", ",", "function", "(", ")", "{", "warn", "(", "'`$s` is not a valid video'", ",", "src", ")", ";", "}", ",", "true", ")", ";", "videoEl", ".", "src", "=", "src", ";", "return", "videoEl", ";", "}" ]

[ "Create", "video", "element", "to", "be", "used", "as", "a", "texture", "." ]

[ "function", "fixVideoAttributes", "(", "videoEl", ")", "{", "videoEl", ".", "autoplay", "=", "videoEl", ".", "hasAttribute", "(", "'autoplay'", ")", "&&", "videoEl", ".", "getAttribute", "(", "'autoplay'", ")", "!==", "'false'", ";", "videoEl", ".", "controls", "=", "videoEl", ".", "hasAttribute", "(", "'controls'", ")", "&&", "videoEl", ".", "getAttribute", "(", "'controls'", ")", "!==", "'false'", ";", "if", "(", "videoEl", ".", "getAttribute", "(", "'loop'", ")", "===", "'false'", ")", "{", "videoEl", ".", "removeAttribute", "(", "'loop'", ")", ";", "}", "if", "(", "videoEl", ".", "getAttribute", "(", "'preload'", ")", "===", "'false'", ")", "{", "videoEl", ".", "preload", "=", "'none'", ";", "}", "videoEl", ".", "crossOrigin", "=", "videoEl", ".", "crossOrigin", "||", "'anonymous'", ";", "// To support inline videos in iOS webviews.", "videoEl", ".", "setAttribute", "(", "'playsinline'", ",", "''", ")", ";", "videoEl", ".", "setAttribute", "(", "'webkit-playsinline'", ",", "''", ")", ";", "return", "videoEl", ";", "}" ]

[ "Fixes", "a", "video", "element", "s", "attributes", "to", "prevent", "developers", "from", "accidentally", "passing", "the", "wrong", "attribute", "values", "to", "commonly", "misused", "video", "attributes", "." ]

[ "function", "(", "oldEvt", ")", "{", "var", "el", "=", "this", ".", "el", ";", "if", "(", "oldEvt", ")", "{", "el", ".", "removeEventListener", "(", "oldEvt", ",", "this", ".", "playSoundBound", ")", ";", "}", "el", ".", "addEventListener", "(", "this", ".", "data", ".", "on", ",", "this", ".", "playSoundBound", ")", ";", "}" ]

[ "Update", "listener", "attached", "to", "the", "user", "defined", "on", "event", "." ]

[ "function", "(", ")", "{", "var", "el", "=", "this", ".", "el", ";", "var", "i", ";", "var", "sceneEl", "=", "el", ".", "sceneEl", ";", "var", "self", "=", "this", ";", "var", "sound", ";", "if", "(", "this", ".", "pool", ".", "children", ".", "length", ">", "0", ")", "{", "this", ".", "stopSound", "(", ")", ";", "el", ".", "removeObject3D", "(", "'sound'", ")", ";", "}", "// Only want one AudioListener. Cache it on the scene.", "var", "listener", "=", "this", ".", "listener", "=", "sceneEl", ".", "audioListener", "||", "new", "THREE", ".", "AudioListener", "(", ")", ";", "sceneEl", ".", "audioListener", "=", "listener", ";", "if", "(", "sceneEl", ".", "camera", ")", "{", "sceneEl", ".", "camera", ".", "add", "(", "listener", ")", ";", "}", "// Wait for camera if necessary.", "sceneEl", ".", "addEventListener", "(", "'camera-set-active'", ",", "function", "(", "evt", ")", "{", "evt", ".", "detail", ".", "cameraEl", ".", "getObject3D", "(", "'camera'", ")", ".", "add", "(", "listener", ")", ";", "}", ")", ";", "// Create [poolSize] audio instances and attach them to pool", "this", ".", "pool", "=", "new", "THREE", ".", "Group", "(", ")", ";", "for", "(", "i", "=", "0", ";", "i", "<", "this", ".", "data", ".", "poolSize", ";", "i", "++", ")", "{", "sound", "=", "this", ".", "data", ".", "positional", "?", "new", "THREE", ".", "PositionalAudio", "(", "listener", ")", ":", "new", "THREE", ".", "Audio", "(", "listener", ")", ";", "this", ".", "pool", ".", "add", "(", "sound", ")", ";", "}", "el", ".", "setObject3D", "(", "this", ".", "attrName", ",", "this", ".", "pool", ")", ";", "for", "(", "i", "=", "0", ";", "i", "<", "this", ".", "pool", ".", "children", ".", "length", ";", "i", "++", ")", "{", "sound", "=", "this", ".", "pool", ".", "children", "[", "i", "]", ";", "sound", ".", "onEnded", "=", "function", "(", ")", "{", "this", ".", "isPlaying", "=", "false", ";", "self", ".", "el", ".", "emit", "(", "'sound-ended'", ",", "self", ".", "evtDetail", ",", "false", ")", ";", "}", ";", "}", "}" ]

[ "Removes", "current", "sound", "object", "creates", "new", "sound", "object", "adds", "to", "entity", "." ]

[ "function", "(", ")", "{", "var", "i", ";", "var", "sound", ";", "this", ".", "isPlaying", "=", "false", ";", "for", "(", "i", "=", "0", ";", "i", "<", "this", ".", "pool", ".", "children", ".", "length", ";", "i", "++", ")", "{", "sound", "=", "this", ".", "pool", ".", "children", "[", "i", "]", ";", "if", "(", "!", "sound", ".", "source", "||", "!", "sound", ".", "source", ".", "buffer", "||", "!", "sound", ".", "isPlaying", "||", "sound", ".", "isPaused", ")", "{", "continue", ";", "}", "sound", ".", "isPaused", "=", "true", ";", "sound", ".", "pause", "(", ")", ";", "}", "}" ]

[ "Pause", "all", "the", "sounds", "in", "the", "pool", "." ]

[ "function", "(", "processSound", ")", "{", "var", "found", ";", "var", "i", ";", "var", "sound", ";", "if", "(", "!", "this", ".", "loaded", ")", "{", "warn", "(", "'Sound not loaded yet. It will be played once it finished loading'", ")", ";", "this", ".", "mustPlay", "=", "true", ";", "return", ";", "}", "found", "=", "false", ";", "this", ".", "isPlaying", "=", "true", ";", "for", "(", "i", "=", "0", ";", "i", "<", "this", ".", "pool", ".", "children", ".", "length", ";", "i", "++", ")", "{", "sound", "=", "this", ".", "pool", ".", "children", "[", "i", "]", ";", "if", "(", "!", "sound", ".", "isPlaying", "&&", "sound", ".", "buffer", "&&", "!", "found", ")", "{", "if", "(", "processSound", ")", "{", "processSound", "(", "sound", ")", ";", "}", "sound", ".", "play", "(", ")", ";", "sound", ".", "isPaused", "=", "false", ";", "found", "=", "true", ";", "continue", ";", "}", "}", "if", "(", "!", "found", ")", "{", "warn", "(", "'All the sounds are playing. If you need to play more sounds simultaneously '", "+", "'consider increasing the size of pool with the `poolSize` attribute.'", ",", "this", ".", "el", ")", ";", "return", ";", "}", "this", ".", "mustPlay", "=", "false", ";", "}" ]

[ "Look", "for", "an", "unused", "sound", "in", "the", "pool", "and", "play", "it", "if", "found", "." ]

[ "function", "(", ")", "{", "var", "i", ";", "var", "sound", ";", "this", ".", "isPlaying", "=", "false", ";", "for", "(", "i", "=", "0", ";", "i", "<", "this", ".", "pool", ".", "children", ".", "length", ";", "i", "++", ")", "{", "sound", "=", "this", ".", "pool", ".", "children", "[", "i", "]", ";", "if", "(", "!", "sound", ".", "source", "||", "!", "sound", ".", "source", ".", "buffer", ")", "{", "return", ";", "}", "sound", ".", "stop", "(", ")", ";", "}", "}" ]

[ "Stop", "all", "the", "sounds", "in", "the", "pool", "." ]

[ "function", "(", "evt", ")", "{", "var", "button", "=", "this", ".", "mapping", ".", "buttons", "[", "evt", ".", "detail", ".", "id", "]", ";", "var", "buttonMeshes", "=", "this", ".", "buttonMeshes", ";", "var", "analogValue", ";", "if", "(", "!", "button", ")", "{", "return", ";", "}", "if", "(", "button", "===", "'trigger'", ")", "{", "analogValue", "=", "evt", ".", "detail", ".", "state", ".", "value", ";", "// Update trigger rotation depending on button value.", "if", "(", "buttonMeshes", "&&", "buttonMeshes", ".", "trigger", ")", "{", "buttonMeshes", ".", "trigger", ".", "rotation", ".", "x", "=", "-", "analogValue", "*", "(", "Math", ".", "PI", "/", "12", ")", ";", "}", "}", "// Pass along changed event with button state, using button mapping for convenience.", "this", ".", "el", ".", "emit", "(", "button", "+", "'changed'", ",", "evt", ".", "detail", ".", "state", ")", ";", "}" ]

[ "Rotate", "the", "trigger", "button", "based", "on", "how", "hard", "the", "trigger", "is", "pressed", "." ]

[ "function", "wrapANodeMethods", "(", "obj", ")", "{", "var", "newObj", "=", "{", "}", ";", "var", "ANodeMethods", "=", "[", "'attachedCallback'", ",", "'attributeChangedCallback'", ",", "'createdCallback'", ",", "'detachedCallback'", "]", ";", "wrapMethods", "(", "newObj", ",", "ANodeMethods", ",", "obj", ",", "ANode", ".", "prototype", ")", ";", "copyProperties", "(", "obj", ",", "newObj", ")", ";", "return", "newObj", ";", "}" ]

[ "Wrap", "some", "obj", "methods", "to", "call", "those", "on", "ANode", "base", "prototype", "." ]

[ "function", "wrapAEntityMethods", "(", "obj", ")", "{", "var", "newObj", "=", "{", "}", ";", "var", "ANodeMethods", "=", "[", "'attachedCallback'", ",", "'attributeChangedCallback'", ",", "'createdCallback'", ",", "'detachedCallback'", "]", ";", "var", "AEntityMethods", "=", "[", "'attachedCallback'", ",", "'attributeChangedCallback'", ",", "'createdCallback'", ",", "'detachedCallback'", "]", ";", "wrapMethods", "(", "newObj", ",", "ANodeMethods", ",", "obj", ",", "ANode", ".", "prototype", ")", ";", "wrapMethods", "(", "newObj", ",", "AEntityMethods", ",", "obj", ",", "AEntity", ".", "prototype", ")", ";", "// Copies the remaining properties into the new object.", "copyProperties", "(", "obj", ",", "newObj", ")", ";", "return", "newObj", ";", "}" ]

[ "This", "wraps", "some", "of", "the", "obj", "methods", "to", "call", "those", "on", "AEntity", "base", "prototype", "." ]

[ "function", "wrapMethods", "(", "targetObj", ",", "methodList", ",", "derivedObj", ",", "baseObj", ")", "{", "methodList", ".", "forEach", "(", "function", "(", "methodName", ")", "{", "wrapMethod", "(", "targetObj", ",", "methodName", ",", "derivedObj", ",", "baseObj", ")", ";", "}", ")", ";", "}" ]

[ "Wrap", "a", "list", "a", "methods", "to", "ensure", "that", "those", "in", "the", "base", "prototype", "are", "called", "before", "the", "derived", "one", "." ]

[ "function", "wrapMethod", "(", "obj", ",", "methodName", ",", "derivedObj", ",", "baseObj", ")", "{", "var", "derivedMethod", "=", "derivedObj", "[", "methodName", "]", ";", "var", "baseMethod", "=", "baseObj", "[", "methodName", "]", ";", "// Derived prototype does not define method, no need to wrap.", "if", "(", "!", "derivedMethod", "||", "!", "baseMethod", ")", "{", "return", ";", "}", "// Derived prototype doesn't override the one in the base one, no need to wrap.", "if", "(", "derivedMethod", "===", "baseMethod", ")", "{", "return", ";", "}", "// Wrap to ensure the base method is called before the one in the derived prototype.", "obj", "[", "methodName", "]", "=", "{", "value", ":", "function", "wrappedMethod", "(", ")", "{", "baseMethod", ".", "apply", "(", "this", ",", "arguments", ")", ";", "return", "derivedMethod", ".", "apply", "(", "this", ",", "arguments", ")", ";", "}", ",", "writable", ":", "window", ".", "debug", "}", ";", "}" ]

[ "Wrap", "one", "method", "to", "ensure", "that", "the", "one", "in", "the", "base", "prototype", "is", "called", "before", "the", "one", "in", "the", "derived", "one", "." ]

[ "function", "copyProperties", "(", "source", ",", "destination", ")", "{", "var", "props", "=", "Object", ".", "getOwnPropertyNames", "(", "source", ")", ";", "props", ".", "forEach", "(", "function", "(", "prop", ")", "{", "var", "desc", ";", "if", "(", "!", "destination", "[", "prop", "]", ")", "{", "desc", "=", "Object", ".", "getOwnPropertyDescriptor", "(", "source", ",", "prop", ")", ";", "destination", "[", "prop", "]", "=", "{", "value", ":", "source", "[", "prop", "]", ",", "writable", ":", "desc", ".", "writable", "}", ";", "}", "}", ")", ";", "}" ]

[ "It", "copies", "the", "properties", "from", "source", "to", "destination", "object", "if", "they", "don", "t", "exist", "already", "." ]

[ "function", "(", ")", "{", "var", "cameraEls", ";", "var", "i", ";", "var", "sceneEl", "=", "this", ".", "sceneEl", ";", "var", "self", "=", "this", ";", "// Camera already defined or the one defined it is an spectator one.", "if", "(", "sceneEl", ".", "camera", "&&", "!", "sceneEl", ".", "camera", ".", "el", ".", "getAttribute", "(", "'camera'", ")", ".", "spectator", ")", "{", "sceneEl", ".", "emit", "(", "'cameraready'", ",", "{", "cameraEl", ":", "sceneEl", ".", "camera", ".", "el", "}", ")", ";", "return", ";", "}", "// Search for initial user-defined camera.", "cameraEls", "=", "sceneEl", ".", "querySelectorAll", "(", "'a-camera, [camera]'", ")", ";", "// No user cameras, create default one.", "if", "(", "!", "cameraEls", ".", "length", ")", "{", "this", ".", "createDefaultCamera", "(", ")", ";", "return", ";", "}", "this", ".", "numUserCameras", "=", "cameraEls", ".", "length", ";", "for", "(", "i", "=", "0", ";", "i", "<", "cameraEls", ".", "length", ";", "i", "++", ")", "{", "cameraEls", "[", "i", "]", ".", "addEventListener", "(", "'object3dset'", ",", "function", "(", "evt", ")", "{", "if", "(", "evt", ".", "detail", ".", "type", "!==", "'camera'", ")", "{", "return", ";", "}", "self", ".", "checkUserCamera", "(", "this", ")", ";", "}", ")", ";", "// Load camera and wait for camera to initialize.", "if", "(", "cameraEls", "[", "i", "]", ".", "isNode", ")", "{", "cameraEls", "[", "i", "]", ".", "load", "(", ")", ";", "}", "else", "{", "cameraEls", "[", "i", "]", ".", "addEventListener", "(", "'nodeready'", ",", "function", "(", ")", "{", "this", ".", "load", "(", ")", ";", "}", ")", ";", "}", "}", "}" ]

[ "Setup", "initial", "camera", "either", "searching", "for", "camera", "or", "creating", "a", "default", "camera", "if", "user", "has", "not", "added", "one", "during", "the", "initial", "scene", "traversal", ".", "We", "want", "sceneEl", ".", "camera", "to", "be", "ready", "set", "and", "initialized", "before", "the", "rest", "of", "the", "scene", "loads", "." ]

[ "function", "(", "newCameraEl", ")", "{", "var", "newCamera", ";", "var", "previousCamera", "=", "this", ".", "spectatorCameraEl", ";", "var", "sceneEl", "=", "this", ".", "sceneEl", ";", "var", "spectatorCameraEl", ";", "// Same camera.", "newCamera", "=", "newCameraEl", ".", "getObject3D", "(", "'camera'", ")", ";", "if", "(", "!", "newCamera", "||", "newCameraEl", "===", "this", ".", "spectatorCameraEl", ")", "{", "return", ";", "}", "// Disable current camera", "if", "(", "previousCamera", ")", "{", "previousCamera", ".", "setAttribute", "(", "'camera'", ",", "'spectator'", ",", "false", ")", ";", "}", "spectatorCameraEl", "=", "this", ".", "spectatorCameraEl", "=", "newCameraEl", ";", "sceneEl", ".", "addEventListener", "(", "'enter-vr'", ",", "this", ".", "wrapRender", ")", ";", "sceneEl", ".", "addEventListener", "(", "'exit-vr'", ",", "this", ".", "unwrapRender", ")", ";", "spectatorCameraEl", ".", "setAttribute", "(", "'camera'", ",", "'active'", ",", "false", ")", ";", "spectatorCameraEl", ".", "play", "(", ")", ";", "sceneEl", ".", "emit", "(", "'camera-set-spectator'", ",", "{", "cameraEl", ":", "newCameraEl", "}", ")", ";", "}" ]

[ "Set", "spectator", "camera", "to", "render", "the", "scene", "on", "a", "2D", "display", "." ]

[ "function", "removeDefaultCamera", "(", "sceneEl", ")", "{", "var", "defaultCamera", ";", "var", "camera", "=", "sceneEl", ".", "camera", ";", "if", "(", "!", "camera", ")", "{", "return", ";", "}", "// Remove default camera if present.", "defaultCamera", "=", "sceneEl", ".", "querySelector", "(", "'['", "+", "DEFAULT_CAMERA_ATTR", "+", "']'", ")", ";", "if", "(", "!", "defaultCamera", ")", "{", "return", ";", "}", "sceneEl", ".", "removeChild", "(", "defaultCamera", ")", ";", "}" ]

[ "Remove", "injected", "default", "camera", "from", "scene", "if", "present", "." ]

[ "function", "(", ")", "{", "this", ".", "mouseDown", "=", "false", ";", "this", ".", "pitchObject", "=", "new", "THREE", ".", "Object3D", "(", ")", ";", "this", ".", "yawObject", "=", "new", "THREE", ".", "Object3D", "(", ")", ";", "this", ".", "yawObject", ".", "position", ".", "y", "=", "10", ";", "this", ".", "yawObject", ".", "add", "(", "this", ".", "pitchObject", ")", ";", "}" ]

[ "Set", "up", "states", "and", "Object3Ds", "needed", "to", "store", "rotation", "data", "." ]

[ "function", "(", ")", "{", "var", "sceneEl", "=", "this", ".", "el", ".", "sceneEl", ";", "var", "canvasEl", "=", "sceneEl", ".", "canvas", ";", "// Wait for canvas to load.", "if", "(", "!", "canvasEl", ")", "{", "sceneEl", ".", "addEventListener", "(", "'render-target-loaded'", ",", "bind", "(", "this", ".", "addEventListeners", ",", "this", ")", ")", ";", "return", ";", "}", "// Mouse events.", "canvasEl", ".", "addEventListener", "(", "'mousedown'", ",", "this", ".", "onMouseDown", ",", "false", ")", ";", "window", ".", "addEventListener", "(", "'mousemove'", ",", "this", ".", "onMouseMove", ",", "false", ")", ";", "window", ".", "addEventListener", "(", "'mouseup'", ",", "this", ".", "onMouseUp", ",", "false", ")", ";", "// Touch events.", "canvasEl", ".", "addEventListener", "(", "'touchstart'", ",", "this", ".", "onTouchStart", ")", ";", "window", ".", "addEventListener", "(", "'touchmove'", ",", "this", ".", "onTouchMove", ")", ";", "window", ".", "addEventListener", "(", "'touchend'", ",", "this", ".", "onTouchEnd", ")", ";", "// sceneEl events.", "sceneEl", ".", "addEventListener", "(", "'enter-vr'", ",", "this", ".", "onEnterVR", ")", ";", "sceneEl", ".", "addEventListener", "(", "'exit-vr'", ",", "this", ".", "onExitVR", ")", ";", "// Pointer Lock events.", "if", "(", "this", ".", "data", ".", "pointerLockEnabled", ")", "{", "document", ".", "addEventListener", "(", "'pointerlockchange'", ",", "this", ".", "onPointerLockChange", ",", "false", ")", ";", "document", ".", "addEventListener", "(", "'mozpointerlockchange'", ",", "this", ".", "onPointerLockChange", ",", "false", ")", ";", "document", ".", "addEventListener", "(", "'pointerlockerror'", ",", "this", ".", "onPointerLockError", ",", "false", ")", ";", "}", "}" ]

[ "Add", "mouse", "and", "touch", "event", "listeners", "to", "canvas", "." ]

[ "function", "(", ")", "{", "var", "sceneEl", "=", "this", ".", "el", ".", "sceneEl", ";", "var", "canvasEl", "=", "sceneEl", "&&", "sceneEl", ".", "canvas", ";", "if", "(", "!", "canvasEl", ")", "{", "return", ";", "}", "// Mouse events.", "canvasEl", ".", "removeEventListener", "(", "'mousedown'", ",", "this", ".", "onMouseDown", ")", ";", "window", ".", "removeEventListener", "(", "'mousemove'", ",", "this", ".", "onMouseMove", ")", ";", "window", ".", "removeEventListener", "(", "'mouseup'", ",", "this", ".", "onMouseUp", ")", ";", "// Touch events.", "canvasEl", ".", "removeEventListener", "(", "'touchstart'", ",", "this", ".", "onTouchStart", ")", ";", "window", ".", "removeEventListener", "(", "'touchmove'", ",", "this", ".", "onTouchMove", ")", ";", "window", ".", "removeEventListener", "(", "'touchend'", ",", "this", ".", "onTouchEnd", ")", ";", "// sceneEl events.", "sceneEl", ".", "removeEventListener", "(", "'enter-vr'", ",", "this", ".", "onEnterVR", ")", ";", "sceneEl", ".", "removeEventListener", "(", "'exit-vr'", ",", "this", ".", "onExitVR", ")", ";", "// Pointer Lock events.", "document", ".", "removeEventListener", "(", "'pointerlockchange'", ",", "this", ".", "onPointerLockChange", ",", "false", ")", ";", "document", ".", "removeEventListener", "(", "'mozpointerlockchange'", ",", "this", ".", "onPointerLockChange", ",", "false", ")", ";", "document", ".", "removeEventListener", "(", "'pointerlockerror'", ",", "this", ".", "onPointerLockError", ",", "false", ")", ";", "}" ]

[ "Remove", "mouse", "and", "touch", "event", "listeners", "from", "canvas", "." ]

[ "function", "(", "event", ")", "{", "var", "direction", ";", "var", "movementX", ";", "var", "movementY", ";", "var", "pitchObject", "=", "this", ".", "pitchObject", ";", "var", "previousMouseEvent", "=", "this", ".", "previousMouseEvent", ";", "var", "yawObject", "=", "this", ".", "yawObject", ";", "// Not dragging or not enabled.", "if", "(", "!", "this", ".", "data", ".", "enabled", "||", "(", "!", "this", ".", "mouseDown", "&&", "!", "this", ".", "pointerLocked", ")", ")", "{", "return", ";", "}", "// Calculate delta.", "if", "(", "this", ".", "pointerLocked", ")", "{", "movementX", "=", "event", ".", "movementX", "||", "event", ".", "mozMovementX", "||", "0", ";", "movementY", "=", "event", ".", "movementY", "||", "event", ".", "mozMovementY", "||", "0", ";", "}", "else", "{", "movementX", "=", "event", ".", "screenX", "-", "previousMouseEvent", ".", "screenX", ";", "movementY", "=", "event", ".", "screenY", "-", "previousMouseEvent", ".", "screenY", ";", "}", "this", ".", "previousMouseEvent", "=", "event", ";", "// Calculate rotation.", "direction", "=", "this", ".", "data", ".", "reverseMouseDrag", "?", "1", ":", "-", "1", ";", "yawObject", ".", "rotation", ".", "y", "+=", "movementX", "*", "0.002", "*", "direction", ";", "pitchObject", ".", "rotation", ".", "x", "+=", "movementY", "*", "0.002", "*", "direction", ";", "pitchObject", ".", "rotation", ".", "x", "=", "Math", ".", "max", "(", "-", "PI_2", ",", "Math", ".", "min", "(", "PI_2", ",", "pitchObject", ".", "rotation", ".", "x", ")", ")", ";", "}" ]

[ "Translate", "mouse", "drag", "into", "rotation", "." ]

[ "function", "(", "evt", ")", "{", "if", "(", "!", "this", ".", "data", ".", "enabled", ")", "{", "return", ";", "}", "// Handle only primary button.", "if", "(", "evt", ".", "button", "!==", "0", ")", "{", "return", ";", "}", "var", "sceneEl", "=", "this", ".", "el", ".", "sceneEl", ";", "var", "canvasEl", "=", "sceneEl", "&&", "sceneEl", ".", "canvas", ";", "this", ".", "mouseDown", "=", "true", ";", "this", ".", "previousMouseEvent", "=", "evt", ";", "this", ".", "showGrabbingCursor", "(", ")", ";", "if", "(", "this", ".", "data", ".", "pointerLockEnabled", "&&", "!", "this", ".", "pointerLocked", ")", "{", "if", "(", "canvasEl", ".", "requestPointerLock", ")", "{", "canvasEl", ".", "requestPointerLock", "(", ")", ";", "}", "else", "if", "(", "canvasEl", ".", "mozRequestPointerLock", ")", "{", "canvasEl", ".", "mozRequestPointerLock", "(", ")", ";", "}", "}", "}" ]

[ "Register", "mouse", "down", "to", "detect", "mouse", "drag", "." ]

[ "function", "(", "evt", ")", "{", "if", "(", "evt", ".", "touches", ".", "length", "!==", "1", "||", "!", "this", ".", "data", ".", "touchEnabled", ")", "{", "return", ";", "}", "this", ".", "touchStart", "=", "{", "x", ":", "evt", ".", "touches", "[", "0", "]", ".", "pageX", ",", "y", ":", "evt", ".", "touches", "[", "0", "]", ".", "pageY", "}", ";", "this", ".", "touchStarted", "=", "true", ";", "}" ]

[ "Register", "touch", "down", "to", "detect", "touch", "drag", "." ]

[ "function", "(", "evt", ")", "{", "var", "direction", ";", "var", "canvas", "=", "this", ".", "el", ".", "sceneEl", ".", "canvas", ";", "var", "deltaY", ";", "var", "yawObject", "=", "this", ".", "yawObject", ";", "if", "(", "!", "this", ".", "touchStarted", "||", "!", "this", ".", "data", ".", "touchEnabled", ")", "{", "return", ";", "}", "deltaY", "=", "2", "*", "Math", ".", "PI", "*", "(", "evt", ".", "touches", "[", "0", "]", ".", "pageX", "-", "this", ".", "touchStart", ".", "x", ")", "/", "canvas", ".", "clientWidth", ";", "direction", "=", "this", ".", "data", ".", "reverseTouchDrag", "?", "1", ":", "-", "1", ";", "// Limit touch orientaion to to yaw (y axis).", "yawObject", ".", "rotation", ".", "y", "-=", "deltaY", "*", "0.5", "*", "direction", ";", "this", ".", "touchStart", "=", "{", "x", ":", "evt", ".", "touches", "[", "0", "]", ".", "pageX", ",", "y", ":", "evt", ".", "touches", "[", "0", "]", ".", "pageY", "}", ";", "}" ]

[ "Translate", "touch", "move", "to", "Y", "-", "axis", "rotation", "." ]

[ "function", "(", ")", "{", "if", "(", "!", "this", ".", "el", ".", "sceneEl", ".", "checkHeadsetConnected", "(", ")", ")", "{", "return", ";", "}", "this", ".", "saveCameraPose", "(", ")", ";", "this", ".", "el", ".", "object3D", ".", "position", ".", "set", "(", "0", ",", "0", ",", "0", ")", ";", "this", ".", "el", ".", "object3D", ".", "updateMatrix", "(", ")", ";", "}" ]

[ "Save", "pose", "." ]

[ "function", "(", ")", "{", "var", "el", "=", "this", ".", "el", ";", "this", ".", "savedPose", ".", "position", ".", "copy", "(", "el", ".", "object3D", ".", "position", ")", ";", "this", ".", "savedPose", ".", "rotation", ".", "copy", "(", "el", ".", "object3D", ".", "rotation", ")", ";", "this", ".", "hasSavedPose", "=", "true", ";", "}" ]

[ "Save", "camera", "pose", "before", "entering", "VR", "to", "restore", "later", "if", "exiting", "." ]

[ "function", "(", ")", "{", "var", "el", "=", "this", ".", "el", ";", "var", "savedPose", "=", "this", ".", "savedPose", ";", "if", "(", "!", "this", ".", "hasSavedPose", ")", "{", "return", ";", "}", "// Reset camera orientation.", "el", ".", "object3D", ".", "position", ".", "copy", "(", "savedPose", ".", "position", ")", ";", "el", ".", "object3D", ".", "rotation", ".", "copy", "(", "savedPose", ".", "rotation", ")", ";", "this", ".", "hasSavedPose", "=", "false", ";", "}" ]

[ "Reset", "camera", "pose", "to", "before", "entering", "VR", "." ]

[ "function", "createEnterVRButton", "(", "onClick", ")", "{", "var", "vrButton", ";", "var", "wrapper", ";", "// Create elements.", "wrapper", "=", "document", ".", "createElement", "(", "'div'", ")", ";", "wrapper", ".", "classList", ".", "add", "(", "ENTER_VR_CLASS", ")", ";", "wrapper", ".", "setAttribute", "(", "constants", ".", "AFRAME_INJECTED", ",", "''", ")", ";", "vrButton", "=", "document", ".", "createElement", "(", "'button'", ")", ";", "vrButton", ".", "className", "=", "ENTER_VR_BTN_CLASS", ";", "vrButton", ".", "setAttribute", "(", "'title'", ",", "'Enter VR mode with a headset or fullscreen mode on a desktop. '", "+", "'Visit https://webvr.rocks or https://webvr.info for more information.'", ")", ";", "vrButton", ".", "setAttribute", "(", "constants", ".", "AFRAME_INJECTED", ",", "''", ")", ";", "// Insert elements.", "wrapper", ".", "appendChild", "(", "vrButton", ")", ";", "vrButton", ".", "addEventListener", "(", "'click'", ",", "function", "(", "evt", ")", "{", "onClick", "(", ")", ";", "evt", ".", "stopPropagation", "(", ")", ";", "}", ")", ";", "return", "wrapper", ";", "}" ]

[ "Create", "a", "button", "that", "when", "clicked", "will", "enter", "into", "stereo", "-", "rendering", "mode", "for", "VR", "." ]

[ "function", "createOrientationModal", "(", "onClick", ")", "{", "var", "modal", "=", "document", ".", "createElement", "(", "'div'", ")", ";", "modal", ".", "className", "=", "ORIENTATION_MODAL_CLASS", ";", "modal", ".", "classList", ".", "add", "(", "HIDDEN_CLASS", ")", ";", "modal", ".", "setAttribute", "(", "constants", ".", "AFRAME_INJECTED", ",", "''", ")", ";", "var", "exit", "=", "document", ".", "createElement", "(", "'button'", ")", ";", "exit", ".", "setAttribute", "(", "constants", ".", "AFRAME_INJECTED", ",", "''", ")", ";", "exit", ".", "innerHTML", "=", "'Exit VR'", ";", "// Exit VR on close.", "exit", ".", "addEventListener", "(", "'click'", ",", "onClick", ")", ";", "modal", ".", "appendChild", "(", "exit", ")", ";", "return", "modal", ";", "}" ]

[ "Creates", "a", "modal", "dialog", "to", "request", "the", "user", "to", "switch", "to", "landscape", "orientation", "." ]

[ "function", "(", ")", "{", "this", ".", "geometry", ".", "dispose", "(", ")", ";", "this", ".", "geometry", "=", "null", ";", "this", ".", "el", ".", "removeObject3D", "(", "this", ".", "attrName", ")", ";", "this", ".", "material", ".", "dispose", "(", ")", ";", "this", ".", "material", "=", "null", ";", "this", ".", "texture", ".", "dispose", "(", ")", ";", "this", ".", "texture", "=", "null", ";", "if", "(", "this", ".", "shaderObject", ")", "{", "delete", "this", ".", "shaderObject", ";", "}", "}" ]

[ "Clean", "up", "geometry", "material", "texture", "mesh", "objects", "." ]

[ "function", "(", ")", "{", "var", "data", "=", "this", ".", "data", ";", "var", "hasChangedShader", ";", "var", "material", "=", "this", ".", "material", ";", "var", "NewShader", ";", "var", "shaderData", "=", "this", ".", "shaderData", ";", "var", "shaderName", ";", "// Infer shader if using a stock font (or from `-msdf` filename convention).", "shaderName", "=", "data", ".", "shader", ";", "if", "(", "MSDF_FONTS", ".", "indexOf", "(", "data", ".", "font", ")", "!==", "-", "1", "||", "data", ".", "font", ".", "indexOf", "(", "'-msdf.'", ")", ">=", "0", ")", "{", "shaderName", "=", "'msdf'", ";", "}", "else", "if", "(", "data", ".", "font", "in", "FONTS", "&&", "MSDF_FONTS", ".", "indexOf", "(", "data", ".", "font", ")", "===", "-", "1", ")", "{", "shaderName", "=", "'sdf'", ";", "}", "hasChangedShader", "=", "(", "this", ".", "shaderObject", "&&", "this", ".", "shaderObject", ".", "name", ")", "!==", "shaderName", ";", "shaderData", ".", "alphaTest", "=", "data", ".", "alphaTest", ";", "shaderData", ".", "color", "=", "data", ".", "color", ";", "shaderData", ".", "map", "=", "this", ".", "texture", ";", "shaderData", ".", "opacity", "=", "data", ".", "opacity", ";", "shaderData", ".", "side", "=", "parseSide", "(", "data", ".", "side", ")", ";", "shaderData", ".", "transparent", "=", "data", ".", "transparent", ";", "shaderData", ".", "negate", "=", "data", ".", "negate", ";", "// Shader has not changed, do an update.", "if", "(", "!", "hasChangedShader", ")", "{", "// Update shader material.", "this", ".", "shaderObject", ".", "update", "(", "shaderData", ")", ";", "// Apparently, was not set on `init` nor `update`.", "material", ".", "transparent", "=", "shaderData", ".", "transparent", ";", "material", ".", "side", "=", "shaderData", ".", "side", ";", "return", ";", "}", "// Shader has changed. Create a shader material.", "NewShader", "=", "createShader", "(", "this", ".", "el", ",", "shaderName", ",", "shaderData", ")", ";", "this", ".", "material", "=", "NewShader", ".", "material", ";", "this", ".", "shaderObject", "=", "NewShader", ".", "shader", ";", "// Set new shader material.", "this", ".", "material", ".", "side", "=", "shaderData", ".", "side", ";", "if", "(", "this", ".", "mesh", ")", "{", "this", ".", "mesh", ".", "material", "=", "this", ".", "material", ";", "}", "}" ]

[ "Update", "the", "shader", "of", "the", "material", "." ]

[ "function", "(", ")", "{", "var", "data", "=", "this", ".", "data", ";", "var", "el", "=", "this", ".", "el", ";", "var", "fontSrc", ";", "var", "geometry", "=", "this", ".", "geometry", ";", "var", "self", "=", "this", ";", "if", "(", "!", "data", ".", "font", ")", "{", "warn", "(", "'No font specified. Using the default font.'", ")", ";", "}", "// Make invisible during font swap.", "this", ".", "mesh", ".", "visible", "=", "false", ";", "// Look up font URL to use, and perform cached load.", "fontSrc", "=", "this", ".", "lookupFont", "(", "data", ".", "font", "||", "DEFAULT_FONT", ")", "||", "data", ".", "font", ";", "cache", ".", "get", "(", "fontSrc", ",", "function", "doLoadFont", "(", ")", "{", "return", "loadFont", "(", "fontSrc", ",", "data", ".", "yOffset", ")", ";", "}", ")", ".", "then", "(", "function", "setFont", "(", "font", ")", "{", "var", "fontImgSrc", ";", "if", "(", "font", ".", "pages", ".", "length", "!==", "1", ")", "{", "throw", "new", "Error", "(", "'Currently only single-page bitmap fonts are supported.'", ")", ";", "}", "if", "(", "!", "fontWidthFactors", "[", "fontSrc", "]", ")", "{", "font", ".", "widthFactor", "=", "fontWidthFactors", "[", "font", "]", "=", "computeFontWidthFactor", "(", "font", ")", ";", "}", "// Update geometry given font metrics.", "self", ".", "updateGeometry", "(", "geometry", ",", "font", ")", ";", "// Set font and update layout.", "self", ".", "currentFont", "=", "font", ";", "self", ".", "updateLayout", "(", ")", ";", "// Look up font image URL to use, and perform cached load.", "fontImgSrc", "=", "self", ".", "getFontImageSrc", "(", ")", ";", "cache", ".", "get", "(", "fontImgSrc", ",", "function", "(", ")", "{", "return", "loadTexture", "(", "fontImgSrc", ")", ";", "}", ")", ".", "then", "(", "function", "(", "image", ")", "{", "// Make mesh visible and apply font image as texture.", "var", "texture", "=", "self", ".", "texture", ";", "texture", ".", "image", "=", "image", ";", "texture", ".", "needsUpdate", "=", "true", ";", "textures", "[", "data", ".", "font", "]", "=", "texture", ";", "self", ".", "texture", "=", "texture", ";", "self", ".", "mesh", ".", "visible", "=", "true", ";", "el", ".", "emit", "(", "'textfontset'", ",", "{", "font", ":", "data", ".", "font", ",", "fontObj", ":", "font", "}", ")", ";", "}", ")", ".", "catch", "(", "function", "(", "err", ")", "{", "error", "(", "err", ".", "message", ")", ";", "error", "(", "err", ".", "stack", ")", ";", "}", ")", ";", "}", ")", ".", "catch", "(", "function", "(", "err", ")", "{", "error", "(", "err", ".", "message", ")", ";", "error", "(", "err", ".", "stack", ")", ";", "}", ")", ";", "}" ]

[ "Load", "font", "for", "geometry", "load", "font", "image", "for", "material", "and", "apply", "." ]

[ "function", "(", ")", "{", "var", "anchor", ";", "var", "baseline", ";", "var", "el", "=", "this", ".", "el", ";", "var", "data", "=", "this", ".", "data", ";", "var", "geometry", "=", "this", ".", "geometry", ";", "var", "geometryComponent", ";", "var", "height", ";", "var", "layout", ";", "var", "mesh", "=", "this", ".", "mesh", ";", "var", "textRenderWidth", ";", "var", "textScale", ";", "var", "width", ";", "var", "x", ";", "var", "y", ";", "if", "(", "!", "geometry", ".", "layout", ")", "{", "return", ";", "}", "// Determine width to use (defined width, geometry's width, or default width).", "geometryComponent", "=", "el", ".", "getAttribute", "(", "'geometry'", ")", ";", "width", "=", "data", ".", "width", "||", "(", "geometryComponent", "&&", "geometryComponent", ".", "width", ")", "||", "DEFAULT_WIDTH", ";", "// Determine wrap pixel count. Either specified or by experimental fudge factor.", "// Note that experimental factor will never be correct for variable width fonts.", "textRenderWidth", "=", "computeWidth", "(", "data", ".", "wrapPixels", ",", "data", ".", "wrapCount", ",", "this", ".", "currentFont", ".", "widthFactor", ")", ";", "textScale", "=", "width", "/", "textRenderWidth", ";", "// Determine height to use.", "layout", "=", "geometry", ".", "layout", ";", "height", "=", "textScale", "*", "(", "layout", ".", "height", "+", "layout", ".", "descender", ")", ";", "// Update geometry dimensions to match text layout if width and height are set to 0.", "// For example, scales a plane to fit text.", "if", "(", "geometryComponent", "&&", "geometryComponent", ".", "primitive", "===", "'plane'", ")", "{", "if", "(", "!", "geometryComponent", ".", "width", ")", "{", "el", ".", "setAttribute", "(", "'geometry'", ",", "'width'", ",", "width", ")", ";", "}", "if", "(", "!", "geometryComponent", ".", "height", ")", "{", "el", ".", "setAttribute", "(", "'geometry'", ",", "'height'", ",", "height", ")", ";", "}", "}", "// Calculate X position to anchor text left, center, or right.", "anchor", "=", "data", ".", "anchor", "===", "'align'", "?", "data", ".", "align", ":", "data", ".", "anchor", ";", "if", "(", "anchor", "===", "'left'", ")", "{", "x", "=", "0", ";", "}", "else", "if", "(", "anchor", "===", "'right'", ")", "{", "x", "=", "-", "1", "*", "layout", ".", "width", ";", "}", "else", "if", "(", "anchor", "===", "'center'", ")", "{", "x", "=", "-", "1", "*", "layout", ".", "width", "/", "2", ";", "}", "else", "{", "throw", "new", "TypeError", "(", "'Invalid text.anchor property value'", ",", "anchor", ")", ";", "}", "// Calculate Y position to anchor text top, center, or bottom.", "baseline", "=", "data", ".", "baseline", ";", "if", "(", "baseline", "===", "'bottom'", ")", "{", "y", "=", "0", ";", "}", "else", "if", "(", "baseline", "===", "'top'", ")", "{", "y", "=", "-", "1", "*", "layout", ".", "height", "+", "layout", ".", "ascender", ";", "}", "else", "if", "(", "baseline", "===", "'center'", ")", "{", "y", "=", "-", "1", "*", "layout", ".", "height", "/", "2", ";", "}", "else", "{", "throw", "new", "TypeError", "(", "'Invalid text.baseline property value'", ",", "baseline", ")", ";", "}", "// Position and scale mesh to apply layout.", "mesh", ".", "position", ".", "x", "=", "x", "*", "textScale", "+", "data", ".", "xOffset", ";", "mesh", ".", "position", ".", "y", "=", "y", "*", "textScale", ";", "// Place text slightly in front to avoid Z-fighting.", "mesh", ".", "position", ".", "z", "=", "data", ".", "zOffset", ";", "mesh", ".", "scale", ".", "set", "(", "textScale", ",", "-", "1", "*", "textScale", ",", "textScale", ")", ";", "}" ]

[ "Update", "layout", "with", "anchor", "alignment", "baseline", "and", "considering", "any", "meshes", "." ]

[ "function", "computeFontWidthFactor", "(", "font", ")", "{", "var", "sum", "=", "0", ";", "var", "digitsum", "=", "0", ";", "var", "digits", "=", "0", ";", "font", ".", "chars", ".", "map", "(", "function", "(", "ch", ")", "{", "sum", "+=", "ch", ".", "xadvance", ";", "if", "(", "ch", ".", "id", ">=", "48", "&&", "ch", ".", "id", "<=", "57", ")", "{", "digits", "++", ";", "digitsum", "+=", "ch", ".", "xadvance", ";", "}", "}", ")", ";", "return", "digits", "?", "digitsum", "/", "digits", ":", "sum", "/", "font", ".", "chars", ".", "length", ";", "}" ]

[ "Compute", "default", "font", "width", "factor", "to", "use", "." ]

[ "function", "PromiseCache", "(", ")", "{", "var", "cache", "=", "this", ".", "cache", "=", "{", "}", ";", "this", ".", "get", "=", "function", "(", "key", ",", "promiseGenerator", ")", "{", "if", "(", "key", "in", "cache", ")", "{", "return", "cache", "[", "key", "]", ";", "}", "cache", "[", "key", "]", "=", "promiseGenerator", "(", ")", ";", "return", "cache", "[", "key", "]", ";", "}", ";", "}" ]

[ "Get", "or", "create", "a", "promise", "given", "a", "key", "and", "promise", "generator", "." ]

[ "function", "findMatchingControllerWebVR", "(", "controllers", ",", "filterIdExact", ",", "filterIdPrefix", ",", "filterHand", ",", "filterControllerIndex", ")", "{", "var", "controller", ";", "var", "i", ";", "var", "matchingControllerOccurence", "=", "0", ";", "var", "targetControllerMatch", "=", "filterControllerIndex", "||", "0", ";", "for", "(", "i", "=", "0", ";", "i", "<", "controllers", ".", "length", ";", "i", "++", ")", "{", "controller", "=", "controllers", "[", "i", "]", ";", "// Determine if the controller ID matches our criteria.", "if", "(", "filterIdPrefix", "&&", "!", "controller", ".", "id", ".", "startsWith", "(", "filterIdPrefix", ")", ")", "{", "continue", ";", "}", "if", "(", "!", "filterIdPrefix", "&&", "controller", ".", "id", "!==", "filterIdExact", ")", "{", "continue", ";", "}", "// If the hand filter and controller handedness are defined we compare them.", "if", "(", "filterHand", "&&", "controller", ".", "hand", "&&", "filterHand", "!==", "controller", ".", "hand", ")", "{", "continue", ";", "}", "// If we have detected an unhanded controller and the component was asking", "// for a particular hand, we need to treat the controllers in the array as", "// pairs of controllers. This effectively means that we need to skip", "// NUM_HANDS matches for each controller number, instead of 1.", "if", "(", "filterHand", "&&", "!", "controller", ".", "hand", ")", "{", "targetControllerMatch", "=", "NUM_HANDS", "*", "filterControllerIndex", "+", "(", "(", "filterHand", "===", "DEFAULT_HANDEDNESS", ")", "?", "0", ":", "1", ")", ";", "}", "// We are looking for the nth occurence of a matching controller", "// (n equals targetControllerMatch).", "if", "(", "matchingControllerOccurence", "===", "targetControllerMatch", ")", "{", "return", "controller", ";", "}", "++", "matchingControllerOccurence", ";", "}", "return", "undefined", ";", "}" ]

[ "Walk", "through", "the", "given", "controllers", "to", "find", "any", "where", "the", "device", "ID", "equals", "filterIdExact", "or", "startsWith", "filterIdPrefix", ".", "A", "controller", "where", "this", "considered", "true", "is", "considered", "a", "match", "." ]

[ "function", "(", "controllerPosition", ")", "{", "// Use controllerPosition and deltaControllerPosition to avoid creating variables.", "var", "controller", "=", "this", ".", "controller", ";", "var", "controllerEuler", "=", "this", ".", "controllerEuler", ";", "var", "controllerQuaternion", "=", "this", ".", "controllerQuaternion", ";", "var", "deltaControllerPosition", "=", "this", ".", "deltaControllerPosition", ";", "var", "hand", ";", "var", "headEl", ";", "var", "headObject3D", ";", "var", "pose", ";", "var", "userHeight", ";", "headEl", "=", "this", ".", "getHeadElement", "(", ")", ";", "headObject3D", "=", "headEl", ".", "object3D", ";", "userHeight", "=", "this", ".", "defaultUserHeight", "(", ")", ";", "pose", "=", "controller", ".", "pose", ";", "hand", "=", "(", "controller", "?", "controller", ".", "hand", ":", "undefined", ")", "||", "DEFAULT_HANDEDNESS", ";", "// Use camera position as head position.", "controllerPosition", ".", "copy", "(", "headObject3D", ".", "position", ")", ";", "// Set offset for degenerate \"arm model\" to elbow.", "deltaControllerPosition", ".", "set", "(", "EYES_TO_ELBOW", ".", "x", "*", "(", "hand", "===", "'left'", "?", "-", "1", ":", "hand", "===", "'right'", "?", "1", ":", "0", ")", ",", "EYES_TO_ELBOW", ".", "y", ",", "// Lower than our eyes.", "EYES_TO_ELBOW", ".", "z", ")", ";", "// Slightly out in front.", "// Scale offset by user height.", "deltaControllerPosition", ".", "multiplyScalar", "(", "userHeight", ")", ";", "// Apply camera Y rotation (not X or Z, so you can look down at your hand).", "deltaControllerPosition", ".", "applyAxisAngle", "(", "headObject3D", ".", "up", ",", "headObject3D", ".", "rotation", ".", "y", ")", ";", "// Apply rotated offset to position.", "controllerPosition", ".", "add", "(", "deltaControllerPosition", ")", ";", "// Set offset for degenerate \"arm model\" forearm. Forearm sticking out from elbow.", "deltaControllerPosition", ".", "set", "(", "FOREARM", ".", "x", ",", "FOREARM", ".", "y", ",", "FOREARM", ".", "z", ")", ";", "// Scale offset by user height.", "deltaControllerPosition", ".", "multiplyScalar", "(", "userHeight", ")", ";", "// Apply controller X/Y rotation (tilting up/down/left/right is usually moving the arm).", "if", "(", "pose", ".", "orientation", ")", "{", "controllerQuaternion", ".", "fromArray", "(", "pose", ".", "orientation", ")", ";", "}", "else", "{", "controllerQuaternion", ".", "copy", "(", "headObject3D", ".", "quaternion", ")", ";", "}", "controllerEuler", ".", "setFromQuaternion", "(", "controllerQuaternion", ")", ";", "controllerEuler", ".", "set", "(", "controllerEuler", ".", "x", ",", "controllerEuler", ".", "y", ",", "0", ")", ";", "deltaControllerPosition", ".", "applyEuler", "(", "controllerEuler", ")", ";", "// Apply rotated offset to position.", "controllerPosition", ".", "add", "(", "deltaControllerPosition", ")", ";", "}" ]

[ "Applies", "an", "artificial", "arm", "model", "to", "simulate", "elbow", "to", "wrist", "positioning", "based", "on", "the", "orientation", "of", "the", "controller", "." ]

[ "function", "(", ")", "{", "var", "buttonState", ";", "var", "controller", "=", "this", ".", "controller", ";", "var", "id", ";", "if", "(", "!", "controller", ")", "{", "return", ";", "}", "// Check every button.", "for", "(", "id", "=", "0", ";", "id", "<", "controller", ".", "buttons", ".", "length", ";", "++", "id", ")", "{", "// Initialize button state.", "if", "(", "!", "this", ".", "buttonStates", "[", "id", "]", ")", "{", "this", ".", "buttonStates", "[", "id", "]", "=", "{", "pressed", ":", "false", ",", "touched", ":", "false", ",", "value", ":", "0", "}", ";", "}", "if", "(", "!", "this", ".", "buttonEventDetails", "[", "id", "]", ")", "{", "this", ".", "buttonEventDetails", "[", "id", "]", "=", "{", "id", ":", "id", ",", "state", ":", "this", ".", "buttonStates", "[", "id", "]", "}", ";", "}", "buttonState", "=", "controller", ".", "buttons", "[", "id", "]", ";", "this", ".", "handleButton", "(", "id", ",", "buttonState", ")", ";", "}", "// Check axes.", "this", ".", "handleAxes", "(", ")", ";", "}" ]

[ "Handle", "button", "changes", "including", "axes", "presses", "touches", "values", "." ]

[ "function", "(", "id", ",", "buttonState", ")", "{", "var", "changed", ";", "changed", "=", "this", ".", "handlePress", "(", "id", ",", "buttonState", ")", "|", "this", ".", "handleTouch", "(", "id", ",", "buttonState", ")", "|", "this", ".", "handleValue", "(", "id", ",", "buttonState", ")", ";", "if", "(", "!", "changed", ")", "{", "return", "false", ";", "}", "this", ".", "el", ".", "emit", "(", "EVENTS", ".", "BUTTONCHANGED", ",", "this", ".", "buttonEventDetails", "[", "id", "]", ",", "false", ")", ";", "return", "true", ";", "}" ]

[ "Handle", "presses", "and", "touches", "for", "a", "single", "button", "." ]

[ "function", "(", "projection", ")", "{", "var", "el", "=", "this", ".", "el", ";", "var", "size", ";", "var", "camera", ";", "var", "cubeCamera", ";", "// Configure camera.", "if", "(", "projection", "===", "'perspective'", ")", "{", "// Quad is only used in equirectangular mode. Hide it in this case.", "this", ".", "quad", ".", "visible", "=", "false", ";", "// Use scene camera.", "camera", "=", "(", "this", ".", "data", ".", "camera", "&&", "this", ".", "data", ".", "camera", ".", "components", ".", "camera", ".", "camera", ")", "||", "el", ".", "camera", ";", "size", "=", "{", "width", ":", "this", ".", "data", ".", "width", ",", "height", ":", "this", ".", "data", ".", "height", "}", ";", "}", "else", "{", "// Use ortho camera.", "camera", "=", "this", ".", "camera", ";", "// Create cube camera and copy position from scene camera.", "cubeCamera", "=", "new", "THREE", ".", "CubeCamera", "(", "el", ".", "camera", ".", "near", ",", "el", ".", "camera", ".", "far", ",", "Math", ".", "min", "(", "this", ".", "cubeMapSize", ",", "2048", ")", ")", ";", "// Copy camera position into cube camera;", "el", ".", "camera", ".", "getWorldPosition", "(", "cubeCamera", ".", "position", ")", ";", "el", ".", "camera", ".", "getWorldQuaternion", "(", "cubeCamera", ".", "quaternion", ")", ";", "// Render scene with cube camera.", "cubeCamera", ".", "update", "(", "el", ".", "renderer", ",", "el", ".", "object3D", ")", ";", "this", ".", "quad", ".", "material", ".", "uniforms", ".", "map", ".", "value", "=", "cubeCamera", ".", "renderTarget", ".", "texture", ";", "size", "=", "{", "width", ":", "this", ".", "data", ".", "width", ",", "height", ":", "this", ".", "data", ".", "height", "}", ";", "// Use quad to project image taken by the cube camera.", "this", ".", "quad", ".", "visible", "=", "true", ";", "}", "return", "{", "camera", ":", "camera", ",", "size", ":", "size", ",", "projection", ":", "projection", "}", ";", "}" ]

[ "Capture", "a", "screenshot", "of", "the", "scene", "." ]

[ "function", "(", "projection", ")", "{", "var", "isVREnabled", "=", "this", ".", "el", ".", "renderer", ".", "vr", ".", "enabled", ";", "var", "renderer", "=", "this", ".", "el", ".", "renderer", ";", "var", "params", ";", "// Disable VR.", "renderer", ".", "vr", ".", "enabled", "=", "false", ";", "params", "=", "this", ".", "setCapture", "(", "projection", ")", ";", "this", ".", "renderCapture", "(", "params", ".", "camera", ",", "params", ".", "size", ",", "params", ".", "projection", ")", ";", "// Trigger file download.", "this", ".", "saveCapture", "(", ")", ";", "// Restore VR.", "renderer", ".", "vr", ".", "enabled", "=", "isVREnabled", ";", "}" ]

[ "Maintained", "for", "backwards", "compatibility", "." ]

[ "function", "(", ")", "{", "this", ".", "canvas", ".", "toBlob", "(", "function", "(", "blob", ")", "{", "var", "fileName", "=", "'screenshot-'", "+", "document", ".", "title", ".", "toLowerCase", "(", ")", "+", "'-'", "+", "Date", ".", "now", "(", ")", "+", "'.png'", ";", "var", "linkEl", "=", "document", ".", "createElement", "(", "'a'", ")", ";", "var", "url", "=", "URL", ".", "createObjectURL", "(", "blob", ")", ";", "linkEl", ".", "href", "=", "url", ";", "linkEl", ".", "setAttribute", "(", "'download'", ",", "fileName", ")", ";", "linkEl", ".", "innerHTML", "=", "'downloading...'", ";", "linkEl", ".", "style", ".", "display", "=", "'none'", ";", "document", ".", "body", ".", "appendChild", "(", "linkEl", ")", ";", "setTimeout", "(", "function", "(", ")", "{", "linkEl", ".", "click", "(", ")", ";", "document", ".", "body", ".", "removeChild", "(", "linkEl", ")", ";", "}", ",", "1", ")", ";", "}", ",", "'image/png'", ")", ";", "}" ]

[ "Download", "capture", "to", "file", "." ]

[ "function", "styleParse", "(", "str", ",", "obj", ")", "{", "var", "chunks", ";", "var", "i", ";", "var", "item", ";", "var", "pos", ";", "var", "key", ";", "var", "val", ";", "obj", "=", "obj", "||", "{", "}", ";", "chunks", "=", "getKeyValueChunks", "(", "str", ")", ";", "for", "(", "i", "=", "0", ";", "i", "<", "chunks", ".", "length", ";", "i", "++", ")", "{", "item", "=", "chunks", "[", "i", "]", ";", "if", "(", "!", "item", ")", "{", "continue", ";", "}", "// Split with `.indexOf` rather than `.split` because the value may also contain colons.", "pos", "=", "item", ".", "indexOf", "(", "':'", ")", ";", "key", "=", "item", ".", "substr", "(", "0", ",", "pos", ")", ".", "trim", "(", ")", ";", "val", "=", "item", ".", "substr", "(", "pos", "+", "1", ")", ".", "trim", "(", ")", ";", "obj", "[", "key", "]", "=", "val", ";", "}", "return", "obj", ";", "}" ]

[ "Convert", "a", "style", "attribute", "string", "to", "an", "object", "." ]

[ "function", "styleStringify", "(", "obj", ")", "{", "var", "key", ";", "var", "keyCount", "=", "0", ";", "var", "i", "=", "0", ";", "var", "str", "=", "''", ";", "for", "(", "key", "in", "obj", ")", "{", "keyCount", "++", ";", "}", "for", "(", "key", "in", "obj", ")", "{", "str", "+=", "(", "key", "+", "': '", "+", "obj", "[", "key", "]", ")", ";", "if", "(", "i", "<", "keyCount", "-", "1", ")", "{", "str", "+=", "'; '", ";", "}", "i", "++", ";", "}", "return", "str", ";", "}" ]

[ "Convert", "an", "object", "into", "an", "attribute", "string" ]

[ "function", "deindent", "(", "html", ")", "{", "var", "lines", "=", "html", ".", "split", "(", "'\\n'", ")", "if", "(", "lines", "[", "0", "]", ".", "substring", "(", "0", ",", "2", ")", "===", "\" \"", ")", "{", "for", "(", "var", "i", "=", "0", ";", "i", "<", "lines", ".", "length", ";", "i", "++", ")", "{", "if", "(", "lines", "[", "i", "]", ".", "substring", "(", "0", ",", "2", ")", "===", "\" \"", ")", "{", "lines", "[", "i", "]", "=", "lines", "[", "i", "]", ".", "slice", "(", "2", ")", "}", "}", ";", "}", "return", "lines", ".", "join", "(", "'\\n'", ")", "}" ]

[ "the", "generated", "HOCR", "is", "excessively", "indented", "so", "we", "get", "rid", "of", "that", "indentation" ]

[ "function", "init", "(", ")", "{", "// In development, we need to open a socket to listen for changes to data", "if", "(", "process", ".", "env", ".", "REACT_STATIC_ENV", "===", "'development'", ")", "{", "const", "io", "=", "require", "(", "'socket.io-client'", ")", "const", "run", "=", "async", "(", ")", "=>", "{", "try", "{", "const", "{", "data", ":", "{", "port", "}", ",", "}", "=", "await", "axios", ".", "get", "(", "'/__react-static__/getMessagePort'", ")", "const", "socket", "=", "io", "(", "`", "${", "port", "}", "`", ")", "socket", ".", "on", "(", "'connect'", ",", "(", ")", "=>", "{", "// Do nothing", "}", ")", "socket", ".", "on", "(", "'message'", ",", "(", "{", "type", "}", ")", "=>", "{", "if", "(", "type", "===", "'reloadClientData'", ")", "{", "reloadClientData", "(", ")", "}", "}", ")", "}", "catch", "(", "err", ")", "{", "console", ".", "log", "(", "'React-Static data hot-loader websocket encountered the following error:'", ")", "console", ".", "error", "(", "err", ")", "}", "}", "run", "(", ")", "}", "if", "(", "process", ".", "env", ".", "REACT_STATIC_DISABLE_PRELOAD", "===", "'false'", ")", "{", "startPreloader", "(", ")", "}", "}" ]

[ "When", "in", "development", "init", "a", "socket", "to", "listen", "for", "data", "changes", "When", "the", "data", "changes", "we", "invalidate", "and", "reload", "all", "of", "the", "route", "data" ]

[ "function", "pad", "(", "str", ")", "{", "if", "(", "str", ".", "length", "<", "max", ")", "{", "return", "str", "+", "' '", ".", "repeat", "(", "max", "-", "str", ".", "length", ")", ";", "}", "return", "str", ";", "}" ]

[ "Apply", "whitespaces", "based", "on", "the", "length" ]

[ "function", "print", "(", "type", ",", "msg", ",", "obj", ",", "colors", ")", "{", "if", "(", "typeof", "type", "===", "'number'", ")", "{", "type", "=", "calculateLevel", "(", "type", ")", ";", "}", "const", "finalMessage", "=", "fillInMsgTemplate", "(", "msg", ",", "obj", ",", "colors", ")", ";", "const", "subsystems", "=", "[", "{", "in", ":", "green", "(", "'<--'", ")", ",", "out", ":", "yellow", "(", "'-->'", ")", ",", "fs", ":", "black", "(", "'-=-'", ")", ",", "default", ":", "blue", "(", "'---'", ")", ",", "}", ",", "{", "in", ":", "'<--'", ",", "out", ":", "'-->'", ",", "fs", ":", "'-=-'", ",", "default", ":", "'---'", ",", "}", ",", "]", ";", "const", "sub", "=", "subsystems", "[", "colors", "?", "0", ":", "1", "]", "[", "obj", ".", "sub", "]", "||", "subsystems", "[", "+", "!", "colors", "]", ".", "default", ";", "if", "(", "colors", ")", "{", "return", "`", "${", "levels", "[", "type", "]", "(", "pad", "(", "type", ")", ")", "}", "${", "white", "(", "`", "${", "sub", "}", "${", "finalMessage", "}", "`", ")", "}", "`", ";", "}", "else", "{", "return", "`", "${", "pad", "(", "type", ")", "}", "${", "sub", "}", "${", "finalMessage", "}", "`", ";", "}", "}" ]

[ "Apply", "colors", "to", "a", "string", "based", "on", "level", "parameters", "." ]

[ "function", "animate", "(", "from", ",", "to", ",", "{", "duration", ",", "easingFunction", ",", "horizontal", "}", ")", "{", "for", "(", "const", "element", "of", "[", "from", ",", "to", "]", ")", "{", "element", ".", "style", ".", "pointerEvents", "=", "'none'", ";", "}", "if", "(", "horizontal", ")", "{", "const", "width", "=", "from", ".", "offsetWidth", ";", "from", ".", "style", ".", "transform", "=", "`", "${", "width", "}", "`", ";", "to", ".", "style", ".", "transform", "=", "`", "${", "width", "}", "`", ";", "}", "else", "{", "const", "height", "=", "from", ".", "offsetHeight", ";", "from", ".", "style", ".", "transform", "=", "`", "${", "height", "}", "`", ";", "to", ".", "style", ".", "transform", "=", "`", "${", "height", "}", "`", ";", "}", "requestAnimationFrame", "(", "(", ")", "=>", "{", "for", "(", "const", "element", "of", "[", "from", ",", "to", "]", ")", "{", "element", ".", "addEventListener", "(", "'transitionend'", ",", "resetElementOnTransitionEnd", ")", ";", "element", ".", "style", ".", "transition", "=", "`", "${", "duration", "}", "${", "easingFunction", "}", "`", ";", "element", ".", "style", ".", "transform", "=", "''", ";", "}", "}", ")", ";", "}" ]

[ "Animates", "two", "elements" ]

[ "function", "resetElementOnTransitionEnd", "(", "event", ")", "{", "event", ".", "target", ".", "style", ".", "transition", "=", "''", ";", "event", ".", "target", ".", "style", ".", "pointerEvents", "=", "''", ";", "event", ".", "target", ".", "removeEventListener", "(", "'transitionend'", ",", "resetElementOnTransitionEnd", ")", ";", "}" ]

[ "Resets", "animation", "style", "properties", "after", "animation", "has", "completed" ]

[ "function", "onDroppableReturnedDefaultAnnouncement", "(", "{", "dragEvent", ",", "dropzone", "}", ")", "{", "const", "sourceText", "=", "dragEvent", ".", "source", ".", "textContent", ".", "trim", "(", ")", "||", "dragEvent", ".", "source", ".", "id", "||", "'draggable element'", ";", "const", "dropzoneText", "=", "dropzone", ".", "textContent", ".", "trim", "(", ")", "||", "dropzone", ".", "id", "||", "'droppable element'", ";", "return", "`", "${", "sourceText", "}", "${", "dropzoneText", "}", "`", ";", "}" ]

[ "Returns", "an", "announcement", "message", "when", "the", "Draggable", "element", "has", "returned", "to", "its", "original", "dropzone", "element" ]

[ "function", "onSortableSortedDefaultAnnouncement", "(", "{", "dragEvent", "}", ")", "{", "const", "sourceText", "=", "dragEvent", ".", "source", ".", "textContent", ".", "trim", "(", ")", "||", "dragEvent", ".", "source", ".", "id", "||", "'sortable element'", ";", "if", "(", "dragEvent", ".", "over", ")", "{", "const", "overText", "=", "dragEvent", ".", "over", ".", "textContent", ".", "trim", "(", ")", "||", "dragEvent", ".", "over", ".", "id", "||", "'sortable element'", ";", "const", "isFollowing", "=", "dragEvent", ".", "source", ".", "compareDocumentPosition", "(", "dragEvent", ".", "over", ")", "&", "Node", ".", "DOCUMENT_POSITION_FOLLOWING", ";", "if", "(", "isFollowing", ")", "{", "return", "`", "${", "sourceText", "}", "${", "overText", "}", "`", ";", "}", "else", "{", "return", "`", "${", "sourceText", "}", "${", "overText", "}", "`", ";", "}", "}", "else", "{", "// need to figure out how to compute container name", "return", "`", "${", "sourceText", "}", "`", ";", "}", "}" ]

[ "Returns", "announcement", "message", "when", "a", "Draggable", "element", "has", "been", "sorted", "with", "another", "Draggable", "element", "or", "moved", "into", "a", "new", "container" ]

[ "function", "hasOverflow", "(", "element", ")", "{", "const", "overflowRegex", "=", "/", "(auto|scroll)", "/", ";", "const", "computedStyles", "=", "getComputedStyle", "(", "element", ",", "null", ")", ";", "const", "overflow", "=", "computedStyles", ".", "getPropertyValue", "(", "'overflow'", ")", "+", "computedStyles", ".", "getPropertyValue", "(", "'overflow-y'", ")", "+", "computedStyles", ".", "getPropertyValue", "(", "'overflow-x'", ")", ";", "return", "overflowRegex", ".", "test", "(", "overflow", ")", ";", "}" ]

[ "Returns", "true", "if", "the", "passed", "element", "has", "overflow" ]

[ "function", "closestScrollableElement", "(", "element", ")", "{", "if", "(", "!", "element", ")", "{", "return", "getDocumentScrollingElement", "(", ")", ";", "}", "const", "position", "=", "getComputedStyle", "(", "element", ")", ".", "getPropertyValue", "(", "'position'", ")", ";", "const", "excludeStaticParents", "=", "position", "===", "'absolute'", ";", "const", "scrollableElement", "=", "closest", "(", "element", ",", "(", "parent", ")", "=>", "{", "if", "(", "excludeStaticParents", "&&", "isStaticallyPositioned", "(", "parent", ")", ")", "{", "return", "false", ";", "}", "return", "hasOverflow", "(", "parent", ")", ";", "}", ")", ";", "if", "(", "position", "===", "'fixed'", "||", "!", "scrollableElement", ")", "{", "return", "getDocumentScrollingElement", "(", ")", ";", "}", "else", "{", "return", "scrollableElement", ";", "}", "}" ]

[ "Finds", "closest", "scrollable", "element" ]