📄 `app.js`¶

📊 Analysis Summary¶

Metric	Count
🔧 Functions	13
📊 Variables & Constants	14

📚 Table of Contents¶

Variables & Constants
Functions

🛠️ File Location:¶

📂 editor/js/libs/app.js

Variables & Constants¶

Name	Type	Kind	Value	Exported
`renderer`	`any`	let/var	`new THREE.WebGLRenderer( { antialias: true } )`	✗
`loader`	`any`	let/var	`new THREE.ObjectLoader()`	✗
`camera`	`any`	let/var	`not shown`	✗
`scene`	`any`	let/var	`not shown`	✗
`events`	`{}`	let/var	`{}`	✗
`project`	`any`	let/var	`json.project`	✗
`scriptWrapParams`	`string`	let/var	`'player,renderer,scene,camera'`	✗
`scriptWrapResultObj`	`{}`	let/var	`{}`	✗
`scripts`	`any`	let/var	`json.scripts[ uuid ]`	✗
`script`	`any`	let/var	`scripts[ i ]`	✗
`time`	`any`	let/var	`not shown`	✗
`startTime`	`any`	let/var	`not shown`	✗
`prevTime`	`any`	let/var	`not shown`	✗
`APP`	`{ Player: typeof Player; }`	let/var	`{ Player: function () { var renderer = new THREE.WebGLRenderer( { antialias: ...`	✗

Functions¶

`Player(): void`¶

Returns: void

Calls:

renderer.setPixelRatio
document.createElement
dom.appendChild
this.setScene
loader.parse
this.setCamera
JSON.stringify( scriptWrapResultObj ).replace
scene.getObjectByProperty
console.warn
complex_call_1861
new Function( scriptWrapParams, script.source + '\nreturn ' + scriptWrapResult + ';' ).bind
events[ name ].push
functions[ name ].bind
dispatch
camera.updateProjectionMatrix
renderer.setSize
complex_call_3035
performance.now
console.error
renderer.render
document.addEventListener
renderer.setAnimationLoop
document.removeEventListener
renderer.dispose

Internal Comments:

//

Code

function () {

        var renderer = new THREE.WebGLRenderer( { antialias: true } );
        renderer.setPixelRatio( window.devicePixelRatio ); // TODO: Use player.setPixelRatio()

        var loader = new THREE.ObjectLoader();
        var camera, scene;

        var events = {};

        var dom = document.createElement( 'div' );
        dom.appendChild( renderer.domElement );

        this.dom = dom;
        this.canvas = renderer.domElement;

        this.width = 500;
        this.height = 500;

        this.load = function ( json ) {

            var project = json.project;

            if ( project.shadows !== undefined ) renderer.shadowMap.enabled = project.shadows;
            if ( project.shadowType !== undefined ) renderer.shadowMap.type = project.shadowType;
            if ( project.toneMapping !== undefined ) renderer.toneMapping = project.toneMapping;
            if ( project.toneMappingExposure !== undefined ) renderer.toneMappingExposure = project.toneMappingExposure;

            this.setScene( loader.parse( json.scene ) );
            this.setCamera( loader.parse( json.camera ) );

            events = {
                init: [],
                start: [],
                stop: [],
                keydown: [],
                keyup: [],
                pointerdown: [],
                pointerup: [],
                pointermove: [],
                update: []
            };

            var scriptWrapParams = 'player,renderer,scene,camera';
            var scriptWrapResultObj = {};

            for ( var eventKey in events ) {

                scriptWrapParams += ',' + eventKey;
                scriptWrapResultObj[ eventKey ] = eventKey;

            }

            var scriptWrapResult = JSON.stringify( scriptWrapResultObj ).replace( /\"/g, '' );

            for ( var uuid in json.scripts ) {

                var object = scene.getObjectByProperty( 'uuid', uuid, true );

                if ( object === undefined ) {

                    console.warn( 'APP.Player: Script without object.', uuid );
                    continue;

                }

                var scripts = json.scripts[ uuid ];

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

                    var script = scripts[ i ];

                    var functions = ( new Function( scriptWrapParams, script.source + '\nreturn ' + scriptWrapResult + ';' ).bind( object ) )( this, renderer, scene, camera );

                    for ( var name in functions ) {

                        if ( functions[ name ] === undefined ) continue;

                        if ( events[ name ] === undefined ) {

                            console.warn( 'APP.Player: Event type not supported (', name, ')' );
                            continue;

                        }

                        events[ name ].push( functions[ name ].bind( object ) );

                    }

                }

            }

            dispatch( events.init, arguments );

        };

        this.setCamera = function ( value ) {

            camera = value;
            camera.aspect = this.width / this.height;
            camera.updateProjectionMatrix();

        };

        this.setScene = function ( value ) {

            scene = value;

        };

        this.setPixelRatio = function ( pixelRatio ) {

            renderer.setPixelRatio( pixelRatio );

        };

        this.setSize = function ( width, height ) {

            this.width = width;
            this.height = height;

            if ( camera ) {

                camera.aspect = this.width / this.height;
                camera.updateProjectionMatrix();

            }

            renderer.setSize( width, height );

        };

        function dispatch( array, event ) {

            for ( var i = 0, l = array.length; i < l; i ++ ) {

                array[ i ]( event );

            }

        }

        var time, startTime, prevTime;

        function animate() {

            time = performance.now();

            try {

                dispatch( events.update, { time: time - startTime, delta: time - prevTime } );

            } catch ( e ) {

                console.error( ( e.message || e ), ( e.stack || '' ) );

            }

            renderer.render( scene, camera );

            prevTime = time;

        }

        this.play = function () {

            startTime = prevTime = performance.now();

            document.addEventListener( 'keydown', onKeyDown );
            document.addEventListener( 'keyup', onKeyUp );
            document.addEventListener( 'pointerdown', onPointerDown );
            document.addEventListener( 'pointerup', onPointerUp );
            document.addEventListener( 'pointermove', onPointerMove );

            dispatch( events.start, arguments );

            renderer.setAnimationLoop( animate );

        };

        this.stop = function () {

            document.removeEventListener( 'keydown', onKeyDown );
            document.removeEventListener( 'keyup', onKeyUp );
            document.removeEventListener( 'pointerdown', onPointerDown );
            document.removeEventListener( 'pointerup', onPointerUp );
            document.removeEventListener( 'pointermove', onPointerMove );

            dispatch( events.stop, arguments );

            renderer.setAnimationLoop( null );

        };

        this.render = function ( time ) {

            dispatch( events.update, { time: time * 1000, delta: 0 /* TODO */ } );

            renderer.render( scene, camera );

        };

        this.dispose = function () {

            renderer.dispose();

            camera = undefined;
            scene = undefined;

        };

        //

        function onKeyDown( event ) {

            dispatch( events.keydown, event );

        }

        function onKeyUp( event ) {

            dispatch( events.keyup, event );

        }

        function onPointerDown( event ) {

            dispatch( events.pointerdown, event );

        }

        function onPointerUp( event ) {

            dispatch( events.pointerup, event );

        }

        function onPointerMove( event ) {

            dispatch( events.pointermove, event );

        }

    }

`dispatch(array: any, event: any): void`¶

Parameters:

array any
event any

Returns: void

Calls:

complex_call_3035

Code

function dispatch( array, event ) {

            for ( var i = 0, l = array.length; i < l; i ++ ) {

                array[ i ]( event );

            }

        }

`animate(): void`¶

Returns: void

Calls:

performance.now
dispatch
console.error
renderer.render

Code

function animate() {

            time = performance.now();

            try {

                dispatch( events.update, { time: time - startTime, delta: time - prevTime } );

            } catch ( e ) {

                console.error( ( e.message || e ), ( e.stack || '' ) );

            }

            renderer.render( scene, camera );

            prevTime = time;

        }

`onKeyDown(event: any): void`¶

Parameters:

event any

Returns: void

Calls:

dispatch

Code

function onKeyDown( event ) {

            dispatch( events.keydown, event );

        }

`onKeyUp(event: any): void`¶

Parameters:

event any

Returns: void

Calls:

dispatch

Code

function onKeyUp( event ) {

            dispatch( events.keyup, event );

        }

`onPointerDown(event: any): void`¶

Parameters:

event any

Returns: void

Calls:

dispatch

Code

function onPointerDown( event ) {

            dispatch( events.pointerdown, event );

        }

`onPointerUp(event: any): void`¶

Parameters:

event any

Returns: void

Calls:

dispatch

Code

function onPointerUp( event ) {

            dispatch( events.pointerup, event );

        }

`onPointerMove(event: any): void`¶

Parameters:

event any

Returns: void

Calls:

dispatch

Code

function onPointerMove( event ) {

            dispatch( events.pointermove, event );

        }

`Player(): void`¶

Returns: void

Calls:

renderer.setPixelRatio
document.createElement
dom.appendChild
this.setScene
loader.parse
this.setCamera
JSON.stringify( scriptWrapResultObj ).replace
scene.getObjectByProperty
console.warn
complex_call_1861
new Function( scriptWrapParams, script.source + '\nreturn ' + scriptWrapResult + ';' ).bind
events[ name ].push
functions[ name ].bind
dispatch
camera.updateProjectionMatrix
renderer.setSize
complex_call_3035
performance.now
console.error
renderer.render
document.addEventListener
renderer.setAnimationLoop
document.removeEventListener
renderer.dispose

Internal Comments:

//

Code

function () {

        var renderer = new THREE.WebGLRenderer( { antialias: true } );
        renderer.setPixelRatio( window.devicePixelRatio ); // TODO: Use player.setPixelRatio()

        var loader = new THREE.ObjectLoader();
        var camera, scene;

        var events = {};

        var dom = document.createElement( 'div' );
        dom.appendChild( renderer.domElement );

        this.dom = dom;
        this.canvas = renderer.domElement;

        this.width = 500;
        this.height = 500;

        this.load = function ( json ) {

            var project = json.project;

            if ( project.shadows !== undefined ) renderer.shadowMap.enabled = project.shadows;
            if ( project.shadowType !== undefined ) renderer.shadowMap.type = project.shadowType;
            if ( project.toneMapping !== undefined ) renderer.toneMapping = project.toneMapping;
            if ( project.toneMappingExposure !== undefined ) renderer.toneMappingExposure = project.toneMappingExposure;

            this.setScene( loader.parse( json.scene ) );
            this.setCamera( loader.parse( json.camera ) );

            events = {
                init: [],
                start: [],
                stop: [],
                keydown: [],
                keyup: [],
                pointerdown: [],
                pointerup: [],
                pointermove: [],
                update: []
            };

            var scriptWrapParams = 'player,renderer,scene,camera';
            var scriptWrapResultObj = {};

            for ( var eventKey in events ) {

                scriptWrapParams += ',' + eventKey;
                scriptWrapResultObj[ eventKey ] = eventKey;

            }

            var scriptWrapResult = JSON.stringify( scriptWrapResultObj ).replace( /\"/g, '' );

            for ( var uuid in json.scripts ) {

                var object = scene.getObjectByProperty( 'uuid', uuid, true );

                if ( object === undefined ) {

                    console.warn( 'APP.Player: Script without object.', uuid );
                    continue;

                }

                var scripts = json.scripts[ uuid ];

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

                    var script = scripts[ i ];

                    var functions = ( new Function( scriptWrapParams, script.source + '\nreturn ' + scriptWrapResult + ';' ).bind( object ) )( this, renderer, scene, camera );

                    for ( var name in functions ) {

                        if ( functions[ name ] === undefined ) continue;

                        if ( events[ name ] === undefined ) {

                            console.warn( 'APP.Player: Event type not supported (', name, ')' );
                            continue;

                        }

                        events[ name ].push( functions[ name ].bind( object ) );

                    }

                }

            }

            dispatch( events.init, arguments );

        };

        this.setCamera = function ( value ) {

            camera = value;
            camera.aspect = this.width / this.height;
            camera.updateProjectionMatrix();

        };

        this.setScene = function ( value ) {

            scene = value;

        };

        this.setPixelRatio = function ( pixelRatio ) {

            renderer.setPixelRatio( pixelRatio );

        };

        this.setSize = function ( width, height ) {

            this.width = width;
            this.height = height;

            if ( camera ) {

                camera.aspect = this.width / this.height;
                camera.updateProjectionMatrix();

            }

            renderer.setSize( width, height );

        };

        function dispatch( array, event ) {

            for ( var i = 0, l = array.length; i < l; i ++ ) {

                array[ i ]( event );

            }

        }

        var time, startTime, prevTime;

        function animate() {

            time = performance.now();

            try {

                dispatch( events.update, { time: time - startTime, delta: time - prevTime } );

            } catch ( e ) {

                console.error( ( e.message || e ), ( e.stack || '' ) );

            }

            renderer.render( scene, camera );

            prevTime = time;

        }

        this.play = function () {

            startTime = prevTime = performance.now();

            document.addEventListener( 'keydown', onKeyDown );
            document.addEventListener( 'keyup', onKeyUp );
            document.addEventListener( 'pointerdown', onPointerDown );
            document.addEventListener( 'pointerup', onPointerUp );
            document.addEventListener( 'pointermove', onPointerMove );

            dispatch( events.start, arguments );

            renderer.setAnimationLoop( animate );

        };

        this.stop = function () {

            document.removeEventListener( 'keydown', onKeyDown );
            document.removeEventListener( 'keyup', onKeyUp );
            document.removeEventListener( 'pointerdown', onPointerDown );
            document.removeEventListener( 'pointerup', onPointerUp );
            document.removeEventListener( 'pointermove', onPointerMove );

            dispatch( events.stop, arguments );

            renderer.setAnimationLoop( null );

        };

        this.render = function ( time ) {

            dispatch( events.update, { time: time * 1000, delta: 0 /* TODO */ } );

            renderer.render( scene, camera );

        };

        this.dispose = function () {

            renderer.dispose();

            camera = undefined;
            scene = undefined;

        };

        //

        function onKeyDown( event ) {

            dispatch( events.keydown, event );

        }

        function onKeyUp( event ) {

            dispatch( events.keyup, event );

        }

        function onPointerDown( event ) {

            dispatch( events.pointerdown, event );

        }

        function onPointerUp( event ) {

            dispatch( events.pointerup, event );

        }

        function onPointerMove( event ) {

            dispatch( events.pointermove, event );

        }

    }

`Player(): void`¶

Returns: void

Calls:

renderer.setPixelRatio
document.createElement
dom.appendChild
this.setScene
loader.parse
this.setCamera
JSON.stringify( scriptWrapResultObj ).replace
scene.getObjectByProperty
console.warn
complex_call_1861
new Function( scriptWrapParams, script.source + '\nreturn ' + scriptWrapResult + ';' ).bind
events[ name ].push
functions[ name ].bind
dispatch
camera.updateProjectionMatrix
renderer.setSize
complex_call_3035
performance.now
console.error
renderer.render
document.addEventListener
renderer.setAnimationLoop
document.removeEventListener
renderer.dispose

Internal Comments:

//

Code

function () {

        var renderer = new THREE.WebGLRenderer( { antialias: true } );
        renderer.setPixelRatio( window.devicePixelRatio ); // TODO: Use player.setPixelRatio()

        var loader = new THREE.ObjectLoader();
        var camera, scene;

        var events = {};

        var dom = document.createElement( 'div' );
        dom.appendChild( renderer.domElement );

        this.dom = dom;
        this.canvas = renderer.domElement;

        this.width = 500;
        this.height = 500;

        this.load = function ( json ) {

            var project = json.project;

            if ( project.shadows !== undefined ) renderer.shadowMap.enabled = project.shadows;
            if ( project.shadowType !== undefined ) renderer.shadowMap.type = project.shadowType;
            if ( project.toneMapping !== undefined ) renderer.toneMapping = project.toneMapping;
            if ( project.toneMappingExposure !== undefined ) renderer.toneMappingExposure = project.toneMappingExposure;

            this.setScene( loader.parse( json.scene ) );
            this.setCamera( loader.parse( json.camera ) );

            events = {
                init: [],
                start: [],
                stop: [],
                keydown: [],
                keyup: [],
                pointerdown: [],
                pointerup: [],
                pointermove: [],
                update: []
            };

            var scriptWrapParams = 'player,renderer,scene,camera';
            var scriptWrapResultObj = {};

            for ( var eventKey in events ) {

                scriptWrapParams += ',' + eventKey;
                scriptWrapResultObj[ eventKey ] = eventKey;

            }

            var scriptWrapResult = JSON.stringify( scriptWrapResultObj ).replace( /\"/g, '' );

            for ( var uuid in json.scripts ) {

                var object = scene.getObjectByProperty( 'uuid', uuid, true );

                if ( object === undefined ) {

                    console.warn( 'APP.Player: Script without object.', uuid );
                    continue;

                }

                var scripts = json.scripts[ uuid ];

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

                    var script = scripts[ i ];

                    var functions = ( new Function( scriptWrapParams, script.source + '\nreturn ' + scriptWrapResult + ';' ).bind( object ) )( this, renderer, scene, camera );

                    for ( var name in functions ) {

                        if ( functions[ name ] === undefined ) continue;

                        if ( events[ name ] === undefined ) {

                            console.warn( 'APP.Player: Event type not supported (', name, ')' );
                            continue;

                        }

                        events[ name ].push( functions[ name ].bind( object ) );

                    }

                }

            }

            dispatch( events.init, arguments );

        };

        this.setCamera = function ( value ) {

            camera = value;
            camera.aspect = this.width / this.height;
            camera.updateProjectionMatrix();

        };

        this.setScene = function ( value ) {

            scene = value;

        };

        this.setPixelRatio = function ( pixelRatio ) {

            renderer.setPixelRatio( pixelRatio );

        };

        this.setSize = function ( width, height ) {

            this.width = width;
            this.height = height;

            if ( camera ) {

                camera.aspect = this.width / this.height;
                camera.updateProjectionMatrix();

            }

            renderer.setSize( width, height );

        };

        function dispatch( array, event ) {

            for ( var i = 0, l = array.length; i < l; i ++ ) {

                array[ i ]( event );

            }

        }

        var time, startTime, prevTime;

        function animate() {

            time = performance.now();

            try {

                dispatch( events.update, { time: time - startTime, delta: time - prevTime } );

            } catch ( e ) {

                console.error( ( e.message || e ), ( e.stack || '' ) );

            }

            renderer.render( scene, camera );

            prevTime = time;

        }

        this.play = function () {

            startTime = prevTime = performance.now();

            document.addEventListener( 'keydown', onKeyDown );
            document.addEventListener( 'keyup', onKeyUp );
            document.addEventListener( 'pointerdown', onPointerDown );
            document.addEventListener( 'pointerup', onPointerUp );
            document.addEventListener( 'pointermove', onPointerMove );

            dispatch( events.start, arguments );

            renderer.setAnimationLoop( animate );

        };

        this.stop = function () {

            document.removeEventListener( 'keydown', onKeyDown );
            document.removeEventListener( 'keyup', onKeyUp );
            document.removeEventListener( 'pointerdown', onPointerDown );
            document.removeEventListener( 'pointerup', onPointerUp );
            document.removeEventListener( 'pointermove', onPointerMove );

            dispatch( events.stop, arguments );

            renderer.setAnimationLoop( null );

        };

        this.render = function ( time ) {

            dispatch( events.update, { time: time * 1000, delta: 0 /* TODO */ } );

            renderer.render( scene, camera );

        };

        this.dispose = function () {

            renderer.dispose();

            camera = undefined;
            scene = undefined;

        };

        //

        function onKeyDown( event ) {

            dispatch( events.keydown, event );

        }

        function onKeyUp( event ) {

            dispatch( events.keyup, event );

        }

        function onPointerDown( event ) {

            dispatch( events.pointerdown, event );

        }

        function onPointerUp( event ) {

            dispatch( events.pointerup, event );

        }

        function onPointerMove( event ) {

            dispatch( events.pointermove, event );

        }

    }

`Player(): void`¶

Returns: void

Calls:

renderer.setPixelRatio
document.createElement
dom.appendChild
this.setScene
loader.parse
this.setCamera
JSON.stringify( scriptWrapResultObj ).replace
scene.getObjectByProperty
console.warn
complex_call_1861
new Function( scriptWrapParams, script.source + '\nreturn ' + scriptWrapResult + ';' ).bind
events[ name ].push
functions[ name ].bind
dispatch
camera.updateProjectionMatrix
renderer.setSize
complex_call_3035
performance.now
console.error
renderer.render
document.addEventListener
renderer.setAnimationLoop
document.removeEventListener
renderer.dispose

Internal Comments:

//

Code

function () {

        var renderer = new THREE.WebGLRenderer( { antialias: true } );
        renderer.setPixelRatio( window.devicePixelRatio ); // TODO: Use player.setPixelRatio()

        var loader = new THREE.ObjectLoader();
        var camera, scene;

        var events = {};

        var dom = document.createElement( 'div' );
        dom.appendChild( renderer.domElement );

        this.dom = dom;
        this.canvas = renderer.domElement;

        this.width = 500;
        this.height = 500;

        this.load = function ( json ) {

            var project = json.project;

            if ( project.shadows !== undefined ) renderer.shadowMap.enabled = project.shadows;
            if ( project.shadowType !== undefined ) renderer.shadowMap.type = project.shadowType;
            if ( project.toneMapping !== undefined ) renderer.toneMapping = project.toneMapping;
            if ( project.toneMappingExposure !== undefined ) renderer.toneMappingExposure = project.toneMappingExposure;

            this.setScene( loader.parse( json.scene ) );
            this.setCamera( loader.parse( json.camera ) );

            events = {
                init: [],
                start: [],
                stop: [],
                keydown: [],
                keyup: [],
                pointerdown: [],
                pointerup: [],
                pointermove: [],
                update: []
            };

            var scriptWrapParams = 'player,renderer,scene,camera';
            var scriptWrapResultObj = {};

            for ( var eventKey in events ) {

                scriptWrapParams += ',' + eventKey;
                scriptWrapResultObj[ eventKey ] = eventKey;

            }

            var scriptWrapResult = JSON.stringify( scriptWrapResultObj ).replace( /\"/g, '' );

            for ( var uuid in json.scripts ) {

                var object = scene.getObjectByProperty( 'uuid', uuid, true );

                if ( object === undefined ) {

                    console.warn( 'APP.Player: Script without object.', uuid );
                    continue;

                }

                var scripts = json.scripts[ uuid ];

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

                    var script = scripts[ i ];

                    var functions = ( new Function( scriptWrapParams, script.source + '\nreturn ' + scriptWrapResult + ';' ).bind( object ) )( this, renderer, scene, camera );

                    for ( var name in functions ) {

                        if ( functions[ name ] === undefined ) continue;

                        if ( events[ name ] === undefined ) {

                            console.warn( 'APP.Player: Event type not supported (', name, ')' );
                            continue;

                        }

                        events[ name ].push( functions[ name ].bind( object ) );

                    }

                }

            }

            dispatch( events.init, arguments );

        };

        this.setCamera = function ( value ) {

            camera = value;
            camera.aspect = this.width / this.height;
            camera.updateProjectionMatrix();

        };

        this.setScene = function ( value ) {

            scene = value;

        };

        this.setPixelRatio = function ( pixelRatio ) {

            renderer.setPixelRatio( pixelRatio );

        };

        this.setSize = function ( width, height ) {

            this.width = width;
            this.height = height;

            if ( camera ) {

                camera.aspect = this.width / this.height;
                camera.updateProjectionMatrix();

            }

            renderer.setSize( width, height );

        };

        function dispatch( array, event ) {

            for ( var i = 0, l = array.length; i < l; i ++ ) {

                array[ i ]( event );

            }

        }

        var time, startTime, prevTime;

        function animate() {

            time = performance.now();

            try {

                dispatch( events.update, { time: time - startTime, delta: time - prevTime } );

            } catch ( e ) {

                console.error( ( e.message || e ), ( e.stack || '' ) );

            }

            renderer.render( scene, camera );

            prevTime = time;

        }

        this.play = function () {

            startTime = prevTime = performance.now();

            document.addEventListener( 'keydown', onKeyDown );
            document.addEventListener( 'keyup', onKeyUp );
            document.addEventListener( 'pointerdown', onPointerDown );
            document.addEventListener( 'pointerup', onPointerUp );
            document.addEventListener( 'pointermove', onPointerMove );

            dispatch( events.start, arguments );

            renderer.setAnimationLoop( animate );

        };

        this.stop = function () {

            document.removeEventListener( 'keydown', onKeyDown );
            document.removeEventListener( 'keyup', onKeyUp );
            document.removeEventListener( 'pointerdown', onPointerDown );
            document.removeEventListener( 'pointerup', onPointerUp );
            document.removeEventListener( 'pointermove', onPointerMove );

            dispatch( events.stop, arguments );

            renderer.setAnimationLoop( null );

        };

        this.render = function ( time ) {

            dispatch( events.update, { time: time * 1000, delta: 0 /* TODO */ } );

            renderer.render( scene, camera );

        };

        this.dispose = function () {

            renderer.dispose();

            camera = undefined;
            scene = undefined;

        };

        //

        function onKeyDown( event ) {

            dispatch( events.keydown, event );

        }

        function onKeyUp( event ) {

            dispatch( events.keyup, event );

        }

        function onPointerDown( event ) {

            dispatch( events.pointerdown, event );

        }

        function onPointerUp( event ) {

            dispatch( events.pointerup, event );

        }

        function onPointerMove( event ) {

            dispatch( events.pointermove, event );

        }

    }

`Player(): void`¶

Returns: void

Calls:

renderer.setPixelRatio
document.createElement
dom.appendChild
this.setScene
loader.parse
this.setCamera
JSON.stringify( scriptWrapResultObj ).replace
scene.getObjectByProperty
console.warn
complex_call_1861
new Function( scriptWrapParams, script.source + '\nreturn ' + scriptWrapResult + ';' ).bind
events[ name ].push
functions[ name ].bind
dispatch
camera.updateProjectionMatrix
renderer.setSize
complex_call_3035
performance.now
console.error
renderer.render
document.addEventListener
renderer.setAnimationLoop
document.removeEventListener
renderer.dispose

Internal Comments:

//

Code

function () {

        var renderer = new THREE.WebGLRenderer( { antialias: true } );
        renderer.setPixelRatio( window.devicePixelRatio ); // TODO: Use player.setPixelRatio()

        var loader = new THREE.ObjectLoader();
        var camera, scene;

        var events = {};

        var dom = document.createElement( 'div' );
        dom.appendChild( renderer.domElement );

        this.dom = dom;
        this.canvas = renderer.domElement;

        this.width = 500;
        this.height = 500;

        this.load = function ( json ) {

            var project = json.project;

            if ( project.shadows !== undefined ) renderer.shadowMap.enabled = project.shadows;
            if ( project.shadowType !== undefined ) renderer.shadowMap.type = project.shadowType;
            if ( project.toneMapping !== undefined ) renderer.toneMapping = project.toneMapping;
            if ( project.toneMappingExposure !== undefined ) renderer.toneMappingExposure = project.toneMappingExposure;

            this.setScene( loader.parse( json.scene ) );
            this.setCamera( loader.parse( json.camera ) );

            events = {
                init: [],
                start: [],
                stop: [],
                keydown: [],
                keyup: [],
                pointerdown: [],
                pointerup: [],
                pointermove: [],
                update: []
            };

            var scriptWrapParams = 'player,renderer,scene,camera';
            var scriptWrapResultObj = {};

            for ( var eventKey in events ) {

                scriptWrapParams += ',' + eventKey;
                scriptWrapResultObj[ eventKey ] = eventKey;

            }

            var scriptWrapResult = JSON.stringify( scriptWrapResultObj ).replace( /\"/g, '' );

            for ( var uuid in json.scripts ) {

                var object = scene.getObjectByProperty( 'uuid', uuid, true );

                if ( object === undefined ) {

                    console.warn( 'APP.Player: Script without object.', uuid );
                    continue;

                }

                var scripts = json.scripts[ uuid ];

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

                    var script = scripts[ i ];

                    var functions = ( new Function( scriptWrapParams, script.source + '\nreturn ' + scriptWrapResult + ';' ).bind( object ) )( this, renderer, scene, camera );

                    for ( var name in functions ) {

                        if ( functions[ name ] === undefined ) continue;

                        if ( events[ name ] === undefined ) {

                            console.warn( 'APP.Player: Event type not supported (', name, ')' );
                            continue;

                        }

                        events[ name ].push( functions[ name ].bind( object ) );

                    }

                }

            }

            dispatch( events.init, arguments );

        };

        this.setCamera = function ( value ) {

            camera = value;
            camera.aspect = this.width / this.height;
            camera.updateProjectionMatrix();

        };

        this.setScene = function ( value ) {

            scene = value;

        };

        this.setPixelRatio = function ( pixelRatio ) {

            renderer.setPixelRatio( pixelRatio );

        };

        this.setSize = function ( width, height ) {

            this.width = width;
            this.height = height;

            if ( camera ) {

                camera.aspect = this.width / this.height;
                camera.updateProjectionMatrix();

            }

            renderer.setSize( width, height );

        };

        function dispatch( array, event ) {

            for ( var i = 0, l = array.length; i < l; i ++ ) {

                array[ i ]( event );

            }

        }

        var time, startTime, prevTime;

        function animate() {

            time = performance.now();

            try {

                dispatch( events.update, { time: time - startTime, delta: time - prevTime } );

            } catch ( e ) {

                console.error( ( e.message || e ), ( e.stack || '' ) );

            }

            renderer.render( scene, camera );

            prevTime = time;

        }

        this.play = function () {

            startTime = prevTime = performance.now();

            document.addEventListener( 'keydown', onKeyDown );
            document.addEventListener( 'keyup', onKeyUp );
            document.addEventListener( 'pointerdown', onPointerDown );
            document.addEventListener( 'pointerup', onPointerUp );
            document.addEventListener( 'pointermove', onPointerMove );

            dispatch( events.start, arguments );

            renderer.setAnimationLoop( animate );

        };

        this.stop = function () {

            document.removeEventListener( 'keydown', onKeyDown );
            document.removeEventListener( 'keyup', onKeyUp );
            document.removeEventListener( 'pointerdown', onPointerDown );
            document.removeEventListener( 'pointerup', onPointerUp );
            document.removeEventListener( 'pointermove', onPointerMove );

            dispatch( events.stop, arguments );

            renderer.setAnimationLoop( null );

        };

        this.render = function ( time ) {

            dispatch( events.update, { time: time * 1000, delta: 0 /* TODO */ } );

            renderer.render( scene, camera );

        };

        this.dispose = function () {

            renderer.dispose();

            camera = undefined;
            scene = undefined;

        };

        //

        function onKeyDown( event ) {

            dispatch( events.keydown, event );

        }

        function onKeyUp( event ) {

            dispatch( events.keyup, event );

        }

        function onPointerDown( event ) {

            dispatch( events.pointerdown, event );

        }

        function onPointerUp( event ) {

            dispatch( events.pointerup, event );

        }

        function onPointerMove( event ) {

            dispatch( events.pointermove, event );

        }

    }

`Player(): void`¶

Returns: void

Calls:

renderer.setPixelRatio
document.createElement
dom.appendChild
this.setScene
loader.parse
this.setCamera
JSON.stringify( scriptWrapResultObj ).replace
scene.getObjectByProperty
console.warn
complex_call_1861
new Function( scriptWrapParams, script.source + '\nreturn ' + scriptWrapResult + ';' ).bind
events[ name ].push
functions[ name ].bind
dispatch
camera.updateProjectionMatrix
renderer.setSize
complex_call_3035
performance.now
console.error
renderer.render
document.addEventListener
renderer.setAnimationLoop
document.removeEventListener
renderer.dispose

Internal Comments:

//

Code

function () {

        var renderer = new THREE.WebGLRenderer( { antialias: true } );
        renderer.setPixelRatio( window.devicePixelRatio ); // TODO: Use player.setPixelRatio()

        var loader = new THREE.ObjectLoader();
        var camera, scene;

        var events = {};

        var dom = document.createElement( 'div' );
        dom.appendChild( renderer.domElement );

        this.dom = dom;
        this.canvas = renderer.domElement;

        this.width = 500;
        this.height = 500;

        this.load = function ( json ) {

            var project = json.project;

            if ( project.shadows !== undefined ) renderer.shadowMap.enabled = project.shadows;
            if ( project.shadowType !== undefined ) renderer.shadowMap.type = project.shadowType;
            if ( project.toneMapping !== undefined ) renderer.toneMapping = project.toneMapping;
            if ( project.toneMappingExposure !== undefined ) renderer.toneMappingExposure = project.toneMappingExposure;

            this.setScene( loader.parse( json.scene ) );
            this.setCamera( loader.parse( json.camera ) );

            events = {
                init: [],
                start: [],
                stop: [],
                keydown: [],
                keyup: [],
                pointerdown: [],
                pointerup: [],
                pointermove: [],
                update: []
            };

            var scriptWrapParams = 'player,renderer,scene,camera';
            var scriptWrapResultObj = {};

            for ( var eventKey in events ) {

                scriptWrapParams += ',' + eventKey;
                scriptWrapResultObj[ eventKey ] = eventKey;

            }

            var scriptWrapResult = JSON.stringify( scriptWrapResultObj ).replace( /\"/g, '' );

            for ( var uuid in json.scripts ) {

                var object = scene.getObjectByProperty( 'uuid', uuid, true );

                if ( object === undefined ) {

                    console.warn( 'APP.Player: Script without object.', uuid );
                    continue;

                }

                var scripts = json.scripts[ uuid ];

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

                    var script = scripts[ i ];

                    var functions = ( new Function( scriptWrapParams, script.source + '\nreturn ' + scriptWrapResult + ';' ).bind( object ) )( this, renderer, scene, camera );

                    for ( var name in functions ) {

                        if ( functions[ name ] === undefined ) continue;

                        if ( events[ name ] === undefined ) {

                            console.warn( 'APP.Player: Event type not supported (', name, ')' );
                            continue;

                        }

                        events[ name ].push( functions[ name ].bind( object ) );

                    }

                }

            }

            dispatch( events.init, arguments );

        };

        this.setCamera = function ( value ) {

            camera = value;
            camera.aspect = this.width / this.height;
            camera.updateProjectionMatrix();

        };

        this.setScene = function ( value ) {

            scene = value;

        };

        this.setPixelRatio = function ( pixelRatio ) {

            renderer.setPixelRatio( pixelRatio );

        };

        this.setSize = function ( width, height ) {

            this.width = width;
            this.height = height;

            if ( camera ) {

                camera.aspect = this.width / this.height;
                camera.updateProjectionMatrix();

            }

            renderer.setSize( width, height );

        };

        function dispatch( array, event ) {

            for ( var i = 0, l = array.length; i < l; i ++ ) {

                array[ i ]( event );

            }

        }

        var time, startTime, prevTime;

        function animate() {

            time = performance.now();

            try {

                dispatch( events.update, { time: time - startTime, delta: time - prevTime } );

            } catch ( e ) {

                console.error( ( e.message || e ), ( e.stack || '' ) );

            }

            renderer.render( scene, camera );

            prevTime = time;

        }

        this.play = function () {

            startTime = prevTime = performance.now();

            document.addEventListener( 'keydown', onKeyDown );
            document.addEventListener( 'keyup', onKeyUp );
            document.addEventListener( 'pointerdown', onPointerDown );
            document.addEventListener( 'pointerup', onPointerUp );
            document.addEventListener( 'pointermove', onPointerMove );

            dispatch( events.start, arguments );

            renderer.setAnimationLoop( animate );

        };

        this.stop = function () {

            document.removeEventListener( 'keydown', onKeyDown );
            document.removeEventListener( 'keyup', onKeyUp );
            document.removeEventListener( 'pointerdown', onPointerDown );
            document.removeEventListener( 'pointerup', onPointerUp );
            document.removeEventListener( 'pointermove', onPointerMove );

            dispatch( events.stop, arguments );

            renderer.setAnimationLoop( null );

        };

        this.render = function ( time ) {

            dispatch( events.update, { time: time * 1000, delta: 0 /* TODO */ } );

            renderer.render( scene, camera );

        };

        this.dispose = function () {

            renderer.dispose();

            camera = undefined;
            scene = undefined;

        };

        //

        function onKeyDown( event ) {

            dispatch( events.keydown, event );

        }

        function onKeyUp( event ) {

            dispatch( events.keyup, event );

        }

        function onPointerDown( event ) {

            dispatch( events.pointerdown, event );

        }

        function onPointerUp( event ) {

            dispatch( events.pointerup, event );

        }

        function onPointerMove( event ) {

            dispatch( events.pointermove, event );

        }

    }

📄 app.js¶

📊 Analysis Summary¶

📚 Table of Contents¶

🛠️ File Location:¶

Variables & Constants¶

Functions¶

Player(): void¶

dispatch(array: any, event: any): void¶

animate(): void¶

onKeyDown(event: any): void¶

onKeyUp(event: any): void¶

onPointerDown(event: any): void¶

onPointerUp(event: any): void¶

onPointerMove(event: any): void¶

Player(): void¶

Player(): void¶

Player(): void¶

Player(): void¶

Player(): void¶

📄 `app.js`¶

`Player(): void`¶

`dispatch(array: any, event: any): void`¶

`animate(): void`¶

`onKeyDown(event: any): void`¶

`onKeyUp(event: any): void`¶

`onPointerDown(event: any): void`¶

`onPointerUp(event: any): void`¶

`onPointerMove(event: any): void`¶

`Player(): void`¶

`Player(): void`¶

`Player(): void`¶

`Player(): void`¶

`Player(): void`¶