docs: function handle_children( parent, children ) {
  
  		for ( var dd in children ) {
  
  			// check by id if child has already been handled,
  			// if not, create new object
  
  			if ( result.objects[ dd ] === undefined ) {
  
  				var o = children[ dd ];
  
  				var object = null;
  
  				// meshes
  
  				if ( o.type && ( o.type in scope.hierarchyHandlerMap ) && o.loading === undefined ) {
  
  					var loaderParameters = {};
  
  					for ( var parType in g ) {
  
  						if ( parType !== "type" && parType !== "url" ) {
  
  							loaderParameters[ parType ] = g[ parType ];
  
  						}
  
  					}
  
  					material = result.materials[ o.material ];
  
  					o.loading = true;
  
  					var loader = scope.hierarchyHandlerMap[ o.type ][ "loaderObject" ];
  
  					// OBJLoader
  
  					if ( loader.addEventListener ) {
  
  						loader.addEventListener( 'load', create_callback_hierachy( dd, parent, material, o ) );
  						loader.load( get_url( o.url, data.urlBaseType ) );
  
  					} else {
  
  						// ColladaLoader
  
  						if ( loader.options ) {
  
  							loader.load( get_url( o.url, data.urlBaseType ), create_callback_hierachy( dd, parent, material, o ) );
  
  						// UTF8Loader
  
  						} else {
  
  							loader.load( get_url( o.url, data.urlBaseType ), create_callback_hierachy( dd, parent, material, o ), loaderParameters );
  
  						}
  
  					}
  
  				} else if ( o.geometry !== undefined ) {
  
  					geometry = result.geometries[ o.geometry ];
  
  					// geometry already loaded
  
  					if ( geometry ) {
  
  						var needsTangents = false;
  
  						material = result.materials[ o.material ];
  						needsTangents = material instanceof THREE.ShaderMaterial;
  
  						p = o.position;
  						r = o.rotation;
  						q = o.quaternion;
  						s = o.scale;
  						m = o.matrix;
  
  						// turn off quaternions, for the moment
  
  						q = 0;
  
  						// use materials from the model file
  						// if there is no material specified in the object
  
  						if ( ! o.material ) {
  
  							material = new THREE.MeshFaceMaterial( result.face_materials[ o.geometry ] );
  
  						}
  
  						// use materials from the model file
  						// if there is just empty face material
  						// (must create new material as each model has its own face material)
  
  						if ( ( material instanceof THREE.MeshFaceMaterial ) && material.materials.length === 0 ) {
  
  							material = new THREE.MeshFaceMaterial( result.face_materials[ o.geometry ] );
  
  						}
  
  						if ( material instanceof THREE.MeshFaceMaterial ) {
  
  							for ( var i = 0; i < material.materials.length; i ++ ) {
  
  								needsTangents = needsTangents || ( material.materials[ i ] instanceof THREE.ShaderMaterial );
  
  							}
  
  						}
  
  						if ( needsTangents ) {
  
  							geometry.computeTangents();
  
  						}
  
  						if ( o.skin ) {
  
  							object = new THREE.SkinnedMesh( geometry, material );
  
  						} else if ( o.morph ) {
  
  							object = new THREE.MorphAnimMesh( geometry, material );
  
  							if ( o.duration !== undefined ) {
  
  								object.duration = o.duration;
  
  							}
  
  							if ( o.time !== undefined ) {
  
  								object.time = o.time;
  
  							}
  
  							if ( o.mirroredLoop !== undefined ) {
  
  								object.mirroredLoop = o.mirroredLoop;
  
  							}
  
  							if ( material.morphNormals ) {
  
  								geometry.computeMorphNormals();
  
  							}
  
  						} else {
  
  							object = new THREE.Mesh( geometry, material );
  
  						}
  
  						object.name = dd;
  
  						if ( m ) {
  
  							object.matrixAutoUpdate = false;
  							object.matrix.set(
  								m[0], m[1], m[2], m[3],
  								m[4], m[5], m[6], m[7],
  								m[8], m[9], m[10], m[11],
  								m[12], m[13], m[14], m[15]
  							);
  
  						} else {
  
  							object.position.set( p[0], p[1], p[2] );
  
  							if ( q ) {
  
  								object.quaternion.set( q[0], q[1], q[2], q[3] );
  								object.useQuaternion = true;
  
  							} else {
  
  								object.rotation.set( r[0], r[1], r[2] );
  
  							}
  
  							object.scale.set( s[0], s[1], s[2] );
  
  						}
  
  						object.visible = o.visible;
  						object.castShadow = o.castShadow;
  						object.receiveShadow = o.receiveShadow;
  
  						parent.add( object );
  
  						result.objects[ dd ] = object;
  
  					}
  
  				// lights
  
  				} else if ( o.type === "DirectionalLight" || o.type === "PointLight" || o.type === "AmbientLight" ) {
  
  					hex = ( o.color !== undefined ) ? o.color : 0xffffff;
  					intensity = ( o.intensity !== undefined ) ? o.intensity : 1;
  
  					if ( o.type === "DirectionalLight" ) {
  
  						p = o.direction;
  
  						light = new THREE.DirectionalLight( hex, intensity );
  						light.position.set( p[0], p[1], p[2] );
  
  						if ( o.target ) {
  
  							target_array.push( { "object": light, "targetName" : o.target } );
  
  							// kill existing default target
  							// otherwise it gets added to scene when parent gets added
  
  							light.target = null;
  
  						}
  
  					} else if ( o.type === "PointLight" ) {
  
  						p = o.position;
  						d = o.distance;
  
  						light = new THREE.PointLight( hex, intensity, d );
  						light.position.set( p[0], p[1], p[2] );
  
  					} else if ( o.type === "AmbientLight" ) {
  
  						light = new THREE.AmbientLight( hex );
  
  					}
  
  					parent.add( light );
  
  					light.name = dd;
  					result.lights[ dd ] = light;
  					result.objects[ dd ] = light;
  
  				// cameras
  
  				} else if ( o.type === "PerspectiveCamera" || o.type === "OrthographicCamera" ) {
  
  					if ( o.type === "PerspectiveCamera" ) {
  
  						camera = new THREE.PerspectiveCamera( o.fov, o.aspect, o.near, o.far );
  
  					} else if ( o.type === "OrthographicCamera" ) {
  
  						camera = new THREE.OrthographicCamera( c.left, c.right, c.top, c.bottom, c.near, c.far );
  
  					}
  
  					p = o.position;
  					camera.position.set( p[0], p[1], p[2] );
  					parent.add( camera );
  
  					camera.name = dd;
  					result.cameras[ dd ] = camera;
  					result.objects[ dd ] = camera;
  
  				// pure Object3D
  
  				} else {
  
  					p = o.position;
  					r = o.rotation;
  					q = o.quaternion;
  					s = o.scale;
  
  					// turn off quaternions, for the moment
  
  					q = 0;
  
  					object = new THREE.Object3D();
  					object.name = dd;
  					object.position.set( p[0], p[1], p[2] );
  
  					if ( q ) {
  
  						object.quaternion.set( q[0], q[1], q[2], q[3] );
  						object.useQuaternion = true;
  
  					} else {
  
  						object.rotation.set( r[0], r[1], r[2] );
  
  					}
  
  					object.scale.set( s[0], s[1], s[2] );
  					object.visible = ( o.visible !== undefined ) ? o.visible : false;
  
  					parent.add( object );
  
  					result.objects[ dd ] = object;
  					result.empties[ dd ] = object;
  
  				}
  
  				if ( object ) {
  
  					if ( o.properties !== undefined )  {
  
  						for ( var key in o.properties ) {
  
  							var value = o.properties[ key ];
  							object.properties[ key ] = value;
  
  						}
  
  					}
  
  					if ( o.children !== undefined ) {
  
  						handle_children( object, o.children );
  
  					}
  
  				}
  
  			}
  
  		}
  
  	}