if (this.parentEntity === data.entity) {
    console.log('Entity FSDemo Loaded');
} else {
    return;
}

/**
 * Images
 */
this.imageSpoon 		= GameLib.EntityManager.Instance.findComponentById('g6oggbsg5k');
this.imageEarth			= GameLib.EntityManager.Instance.findComponentById('fo1einfper');

this.images = [
    this.imageSpoon,
    this.imageEarth
];

/**
 * Meshes
 */
this.meshBox			= GameLib.EntityManager.Instance.findComponentById('2ehdod2g2a');
this.meshImageGrid		= GameLib.EntityManager.Instance.findComponentById('9qkka13nor');

/**
 * Camera
 */
this.camera				= GameLib.EntityManager.Instance.findComponentById('j36eiamn0s');

/**
 * Geometry
 */
this.instancedGeometry	= GameLib.EntityManager.Instance.findComponentById('s5dfh75zza');
this.boxGeometry		= GameLib.EntityManager.Instance.findComponentById('pwzyukkviy');

/**
 * Textures
 */
this.textureWhite 		= GameLib.EntityManager.Instance.findComponentById('642tyh30uo');

/**
 * Materials
 */
this.materialRawPhong	= GameLib.EntityManager.Instance.findComponentById('r153c4450d');

/**
 * Custom Code Components
 */
this.beforeRender 	= GameLib.EntityManager.Instance.findComponentById('wlw063ovw9');
this.keyUp 			= GameLib.EntityManager.Instance.findComponentById('ip0443a52d');

/**
 * Program parameters
 */
this.attributeData		= null;
this.updateInformation	= [];
this.currentIndex		= 0;
this.maxIndex			= this.images.length - 1;

/**
 * Attributes
 */
this.offsetAttribute = null;
this.scaleAttribute = null;

/**
 * Generates new Attribute Data based on the image index according to 'width' and 'height'
 */
GameLib.CustomCode.prototype.generateAttributeData = function(index, width, height) {

    var heightData = this.images[index].getHeightData();

    var offsets			= [];
    var scales			= [];
    var orientations	= [];

    var x, y, z, scale = 0;

    for (x = 0; x < width; x++) {
        for (y = 0; y < height; y++) {
            z	= heightData[(y * width) + x] * 10;
            scale = z * 0.19;
            offsets.push((x - 64) * 2, (64 - y) * 2, z);
            orientations.push(0, 0, 0, 1);
            scales.push(scale, scale, scale);
        }
    }

    return {
        offsets			: offsets,
        scales			: scales,
        orientations	: orientations
    };

}.bind(this);

/**
 * Builds our instanced geometry
 */
GameLib.CustomCode.prototype.buildInstancedGeometry = function(index) {

    this.attributeData = this.generateAttributeData(index, 128, 128);

    var uniforms = Object.assign(
        THREE.UniformsLib['lights'],
        THREE.UniformsLib['common'],
        {
            map : {
                value : this.textureWhite.instance
            }
        }
    );

    uniforms.diffuse.value.r = 0.47;
    uniforms.diffuse.value.g = 0.72;
    uniforms.diffuse.value.b = 1.0;

    this.materialRawPhong.instance.uniforms = uniforms;

    this.instancedGeometry.instance.index 				= this.boxGeometry.instance.index;
    this.instancedGeometry.instance.groups 				= this.boxGeometry.instance.groups;
    this.instancedGeometry.instance.attributes.position = this.boxGeometry.instance.attributes.position;
    this.instancedGeometry.instance.attributes.normal   = this.boxGeometry.instance.attributes.normal;
    this.instancedGeometry.instance.attributes.uv 		= this.boxGeometry.instance.attributes.uv;

    this.offsetAttribute = new THREE.InstancedBufferAttribute(
        new Float32Array(this.attributeData.offsets),
        3
    ).setDynamic(true);

    var orientationAttribute = new THREE.InstancedBufferAttribute(
        new Float32Array(this.attributeData.orientations),
        4
    );

    this.scaleAttribute = new THREE.InstancedBufferAttribute(
        new Float32Array(this.attributeData.scales),
        3
    ).setDynamic(true);

    this.instancedGeometry.instance.addAttribute('offset', 		this.offsetAttribute);
    this.instancedGeometry.instance.addAttribute('orientation', orientationAttribute);
    this.instancedGeometry.instance.addAttribute('scale', 		this.scaleAttribute);

}.bind(this);

/**
 * Builds update information holding our current position and scale, and our target position and scale
 */
GameLib.CustomCode.prototype.generateAnimationVectors = function(attributeData) {

    if (!attributeData) {
        console.warn('animation not ready');
    }

    var i;

    this.updateInformation = [];

    for (i = 0; i < this.offsetAttribute.count; i++) {

        this.updateInformation.push(
            {
                offset : {
                    current : new THREE.Vector3(
                        this.offsetAttribute.array[i+0],
                        this.offsetAttribute.array[i+1],
                        this.offsetAttribute.array[i+2]
                    ),
                    target : new THREE.Vector3(
                        attributeData.offsets[i+0],
                        attributeData.offsets[i+1],
                        attributeData.offsets[i+2]
                    )
                },
                scale : {
                    current : new THREE.Vector3(
                        this.scaleAttribute.array[i+0],
                        this.scaleAttribute.array[i+1],
                        this.scaleAttribute.array[i+2]
                    ),
                    target : new THREE.Vector3(
                        attributeData.scales[i+0],
                        attributeData.scales[i+1],
                        attributeData.scales[i+2]
                    )
                }
            }
        );

    }
}.bind(this);

/**
 * Load the next animation
 */
GameLib.CustomCode.prototype.loadNext = function() {

    this.currentIndex++

    if (this.currentIndex > this.maxIndex) {
        this.currentIndex = 0;
    }

    var attributeData = this.generateAttributeData(this.currentIndex, 128, 128);

    this.generateAnimationVectors(attributeData);

    /**
     * Notify our render component that we are ready to start animating
     */
    this.beforeRender.startAnimation = true;

}.bind(this);

/**
 * Performs the actual update to our instanced geometry
 */
GameLib.CustomCode.prototype.updateAttributeArrays = function(alpha) {

    console.log('animation : ' + alpha);

    var i, offset, scale;

	var offsets = [];
	var scales = [];
	
    for (i = 0; i < this.updateInformation.length; i++) {

        offset 	= this.updateInformation[i].offset;
        scale 	= this.updateInformation[i].scale;
		
		offset.current.lerp(
            offset.target,
            alpha
        );
		
		offsets.push(offset.x, offset.y, offset.z);

		scale.current.lerp(
            scale.target,
            alpha
        );
		
		scales.push(scale.x, scale.y, scale.z);
    }

	this.offsetAttribute.setArray(new Float32Array(offsets));
	this.scaleAttribute.setArray(new Float32Array(scales));
	
	this.offsetAttribute.needsUpdate = true;
	this.scaleAttribute.needsUpdate = true;
	
}.bind(this);


this.buildInstancedGeometry(0);

this.beforeRender.entityLoaded 	    = this;
this.keyUp.entityLoaded 			= this;

//@ sourceURL=entityLoaded.js