MySceneGraph.js

const DEGREE_TO_RAD = Math.PI / 180;

// Order of the groups in the XML document.
var INITIALS_INDEX = 0;
var VIEWS_INDEX = 1;
var ILLUMINATION_INDEX = 2;
var LIGHTS_INDEX = 3;
var TEXTURES_INDEX = 4;
var SPRITESHEETS_INDEX = 5;
var MATERIALS_INDEX = 6;
var ANIMATIONS_INDEX = 7;
var NODES_INDEX = 8;

/**
 * MySceneGraph class, representing the scene graph.
 */
class MySceneGraph {
    /**
     * Constructor for MySceneGraph class.
     * Initializes necessary variables and starts the XML file reading process.
     * @param {string} filename - File that defines the 3D scene
     * @param {XMLScene} scene
     */
    constructor(filename, scene) {
        this.loadedOk = null;

        // Establish bidirectional references between scene and graph.
        this.scene = scene;

        this.nodes = [];
        this.spriteanims = [];

        this.idRoot = null; // The id of the root element.

        this.axisCoords = [];
        this.axisCoords['x'] = [1, 0, 0];
        this.axisCoords['y'] = [0, 1, 0];
        this.axisCoords['z'] = [0, 0, 1];

        // File reading 
        this.reader = new CGFXMLreader();

        /*
         * Read the contents of the xml file, and refer to this class for loading and error handlers.
         * After the file is read, the reader calls onXMLReady on this object.
         * If any error occurs, the reader calls onXMLError on this object, with an error message
         */
        this.reader.open('scenes/' + filename, this);
    }

    /*
     * Callback to be executed after successful reading
     */
    onXMLReady() {
        this.log("XML Loading finished.");
        var rootElement = this.reader.xmlDoc.documentElement;

        // Here should go the calls for different functions to parse the various blocks
        var error = this.parseXMLFile(rootElement);

        if (error != null) {
            this.onXMLError(error);
            return;
        }

        this.loadedOk = true;

        // As the graph loaded ok, signal the scene so that any additional initialization depending on the graph can take place
        this.scene.onGraphLoaded();
    }

    /*
     * Callback to be executed on any read error, showing an error on the console.
     * @param {string} message
     */
    onXMLError(message) {
        console.error("XML Loading Error: " + message);
        this.loadedOk = false;
    }

    /**
     * Callback to be executed on any minor error, showing a warning on the console.
     * @param {string} message
     */
    onXMLMinorError(message) {
        console.warn("Warning: " + message);
    }

    /**
     * Callback to be executed on any message.
     * @param {string} message
     */
    log(message) {
        console.log("   " + message);
    }

    /**
     * Parses the XML file, processing each block.
     * @param {XML root element} rootElement
     */
    parseXMLFile(rootElement) {
        if (rootElement.nodeName != "lsf")
            return "root tag <lsf> missing";

        var nodes = rootElement.children;

        // Reads the names of the nodes to an auxiliary buffer.
        var nodeNames = [];

        for (var i = 0; i < nodes.length; i++) {
            nodeNames.push(nodes[i].nodeName);
        }

        var error;

        // Processes each node, verifying errors.

        // <initials>
        var index;
        if ((index = nodeNames.indexOf("initials")) == -1)
            return "tag <initials> missing";
        else {
            if (index != INITIALS_INDEX)
                this.onXMLMinorError("tag <initials> out of order " + index);

            //Parse initials block
            if ((error = this.parseInitials(nodes[index])) != null)
                return error;
        }

        // <views>
        if ((index = nodeNames.indexOf("views")) == -1)
            return "tag <views> missing";
        else {
            if (index != VIEWS_INDEX)
                this.onXMLMinorError("tag <views> out of order");

            //Parse views block
            if ((error = this.parseViews(nodes[index])) != null)
                return error;
        }

        // <illumination>
        if ((index = nodeNames.indexOf("illumination")) == -1)
            return "tag <illumination> missing";
        else {
            if (index != ILLUMINATION_INDEX)
                this.onXMLMinorError("tag <illumination> out of order");

            //Parse illumination block
            if ((error = this.parseIllumination(nodes[index])) != null)
                return error;
        }

        // <lights>
        if ((index = nodeNames.indexOf("lights")) == -1)
            return "tag <lights> missing";
        else {
            if (index != LIGHTS_INDEX)
                this.onXMLMinorError("tag <lights> out of order");

            //Parse lights block
            if ((error = this.parseLights(nodes[index])) != null)
                return error;
        }

        // <textures>
        if ((index = nodeNames.indexOf("textures")) == -1)
            return "tag <textures> missing";
        else {
            if (index != TEXTURES_INDEX)
                this.onXMLMinorError("tag <textures> out of order");

            //Parse textures block
            if ((error = this.parseTextures(nodes[index])) != null)
                return error;
        }

        // <spritesheets>
        if ((index = nodeNames.indexOf("spritesheets")) == -1)
            return "tag <spritesheets> missing";
        else {
            if (index != SPRITESHEETS_INDEX)
                this.onXMLMinorError("tag <spritesheets> out of order");

            //Parse textures block
            if ((error = this.parseSpritesheets(nodes[index])) != null)
                return error;
        }

        // <materials>
        if ((index = nodeNames.indexOf("materials")) == -1)
            return "tag <materials> missing";
        else {
            if (index != MATERIALS_INDEX)
                this.onXMLMinorError("tag <materials> out of order");

            //Parse materials block
            if ((error = this.parseMaterials(nodes[index])) != null)
                return error;
        }

        // <animations>
        if ((index = nodeNames.indexOf("animations")) == -1){
            this.onXMLMinorError("tag <animations> missing");
            NODES_INDEX = 6;
        }
        else {
            if (index != ANIMATIONS_INDEX)
                this.onXMLMinorError("tag <animations> out of order");

            //Parse animation block
            if ((error = this.parseAnimations(nodes[index])) != null)
                return error;
        }

        // <nodes>
        if ((index = nodeNames.indexOf("nodes")) == -1)
            return "tag <nodes> missing";
        else {
            if (index != NODES_INDEX)
                this.onXMLMinorError("tag <nodes> out of order");

            //Parse nodes block
            if ((error = this.parseNodes(nodes[index])) != null)
                return error;
        }

        // <game>
        if ((index = nodeNames.indexOf("game")) == -1)
            return "tag <game> missing";
        else {
            //Parse game block
            if ((error = this.parseGame(nodes[index])) != null)
                return error;
        }

        this.log("all parsed");
    }

    /**
     * Parses the <initials> block. 
     * @param {initials block element} initialsNode
     */
    parseInitials(initialsNode) {
        const children = initialsNode.children;
        var nodeNames = [];

        for (var i = 0; i < children.length; i++)
            nodeNames.push(children[i].nodeName);

        var rootIndex = nodeNames.indexOf("root");
        var referenceIndex = nodeNames.indexOf("reference");

        // Get root of the scene.
        if(rootIndex == -1)
            return "No root id defined for scene.";

        var rootNode = children[rootIndex];
        var id = this.reader.getString(rootNode, 'id');
        if (id == null)
            return "No root id defined for scene.";

        this.idRoot = id;

        // Get axis length        
        if(referenceIndex == -1)
            this.onXMLMinorError("no axis_length defined for scene; assuming 'length = 1'");

        var refNode = children[referenceIndex];
        var axis_length = this.reader.getFloat(refNode, 'length');
        if (axis_length == null)
            this.onXMLMinorError("no axis_length defined for scene; assuming 'length = 1'");

        this.referenceLength = axis_length || 1;

        this.log("Parsed initials");

        return null;
    }

    /**
     * Parses the <views> block.
     * @param {view block element} viewsNode
     */
    parseViews(viewsNode) {
        // Boolean used to verify errors and then create a default view
        let errorview = false;

        // Get id of the default view
        this.viewsDefaultID = this.reader.getString(viewsNode, 'default');
        if (this.viewsDefaultID === null) {
            this.onXMLError("No default view ID defined! Creating a default view.");
            errorview = true;
        }

        // Checks if there are child nodes declared
        const children = viewsNode.children;
        if(children.length === 0) {
            this.onXMLError("No views defined! Creating a default view.");
            errorview = true;
        }

        this.views = [];

        for (let i = 0; i < children.length; i++) {
            if (children[i].nodeName !== "perspective" && children[i].nodeName !== "ortho") {
                this.onXMLMinorError("unknown tag <" + children[i].nodeName + ">")
                continue
            }

            // Get id of the current view.
            let viewID = this.reader.getString(children[i], 'id');
            if (viewID == null) {
                this.onXMLMinorError("no ID defined for <" + children[i] + ">");
                continue;
            }

            // Checks for repeated IDs.
            if (this.views[viewID] != null) {
                this.onXMLMinorError("ID must be unique for each view (conflict ID = " + viewID + " )");
                continue;
            }

            // Checks if view is perspective or ortho, gets components and parses errors.
            if (children[i].nodeName === "perspective") {
                const near =  this.reader.getFloat(children[i], 'near');
                const far = this.reader.getFloat(children[i], 'far');
                const angle = this.reader.getFloat(children[i], 'angle');

                if (!this.checkNumber(near) || !this.checkNumber(far) || !this.checkNumber(angle)) {
                    this.onXMLMinorError("Wrong values for view. View ID: " + viewID);
                    errorview = true;
                    continue;
                }

                let from = null;
                let to = null;

                const perspectiveChildren = children[i].children;
                for (let j = 0; j < perspectiveChildren.length; j++) {
                    if (perspectiveChildren[j].nodeName !== "from" && perspectiveChildren[j].nodeName !== "to") {
                        this.onXMLMinorError("unknown tag <" + perspectiveChildren[j].nodeName + ">");
                        continue;
                    }

                    if (perspectiveChildren[j].nodeName === "from") {
                        from = this.parseCoordinates3D(perspectiveChildren[j], "view " + viewID);
                    }
                    else {
                        to = this.parseCoordinates3D(perspectiveChildren[j], "view " + viewID);
                    }
                }

                this.views[viewID] = new CGFcamera(angle * DEGREE_TO_RAD, near, far, vec3.fromValues(from[0], from[1], from[2]), vec3.fromValues(to[0], to[1], to[2]));
            }

            else if (children[i].nodeName === "ortho") {
                const near = this.reader.getFloat(children[i], 'near');
                const far = this.reader.getFloat(children[i], 'far');
                const left = this.reader.getFloat(children[i], 'left');
                const right = this.reader.getFloat(children[i], 'right');
                const top = this.reader.getFloat(children[i], 'top');
                const bottom = this.reader.getFloat(children[i], 'bottom');

                if(!this.checkNumber(near) || !this.checkNumber(far) || !this.checkNumber(left)|| !this.checkNumber(right)|| !this.checkNumber(top)|| !this.checkNumber(bottom)){
                    this.onXMLMinorError("Wrong values for view. View ID: " + viewID);
                    continue;
                }

                let from = null;
                let to = null;
                let up = {
                    x: 0.0,
                    y: 1.0,
                    z: 0.0
                } // optional, default 0,1,0

                const orthoChildren = children[i].children;
                for (let j = 0; j < orthoChildren.length; j++) {
                    if (orthoChildren[j].nodeName !== "from" && orthoChildren[j].nodeName !== "to" && orthoChildren[j].nodeName !== "up") {
                        this.onXMLMinorError("unknown tag <" + orthoChildren[j].nodeName + ">");
                        continue;
                    }

                    if (orthoChildren[j].nodeName === "from") {
                        from = this.parseCoordinates3D(orthoChildren[j], "view with ID: " + viewID);
                    }
                    else if (orthoChildren[j].nodeName === "to") {
                        to = this.parseCoordinates3D(orthoChildren[j], "view with ID: " + viewID);
                    }
                    else {
                        up = this.parseCoordinates3D(orthoChildren[j], "view with ID: " + viewID);
                    }
                }

                this.views[viewID] = new CGFcameraOrtho(left, right, bottom, top, near, far, vec3.fromValues(from[0], from[1], from[2]), vec3.fromValues(to[0], to[1], to[2]), vec3.fromValues(up[0], up[1], up[2]));
            }
        }

        if(this.views[this.viewsDefaultID] === null){
            this.onXMLMinorError("No view IDs correspond to the given defaultViewID! Creating a default view.");
            errorview = true;
        }

        if(errorview === true){
            this.viewsDefaultID = "defaultViewError";
            this.views["defaultViewError"] = new CGFcamera(0.4, 0.1, 500, vec3.fromValues(15, 15, 15), vec3.fromValues(0, 0, 0));
        }

        this.log("Parsed Views.");
        return null;
    }

    /**
     * Parses the <illumination> node.
     * @param {illumination block element} illuminationsNode
     */
    parseIllumination(illuminationsNode) {
        const children = illuminationsNode.children;

        this.ambient = [];
        this.background = [];

        var nodeNames = [];

        for (var i = 0; i < children.length; i++)
            nodeNames.push(children[i].nodeName);

        var ambientIndex = nodeNames.indexOf("ambient");
        var backgroundIndex = nodeNames.indexOf("background");

        var color = this.parseColor(children[ambientIndex], "ambient");
        if (!Array.isArray(color)){
            this.onXMLMinorError("Wrong value on illumination's ambient component. Assuming default");
            this.ambient = [1,0,0,1];
        }
        else
            this.ambient = color;

        color = this.parseColor(children[backgroundIndex], "background");
        if (!Array.isArray(color)){
            this.onXMLMinorError("Wrong value on illumination's background component. Assuming default");
            this.background = [1,0,0,1];
        }
        else
            this.background = color;

        this.log("Parsed Illumination.");
        return null;
    }

    /**
     * Parses the <light> node.
     * @param {lights block element} lightsNode
     */
    parseLights(lightsNode) {
        const children = lightsNode.children;

        this.lights = [];
        var numLights = 0;

        var grandChildren = [];
        var nodeNames = [];

        // Any number of lights.
        for (var i = 0; i < children.length; i++) {

            // Storing light information
            var global = [];
            var attributeNames = [];
            var attributeTypes = [];

            //Check type of light
            if (children[i].nodeName != "light") {
                this.onXMLMinorError("unknown tag <" + children[i].nodeName + ">");
                continue;
            }
            else {
                attributeNames.push(...["enable", "position", "ambient", "diffuse", "specular"]);
                attributeTypes.push(...["boolean","position", "color", "color", "color"]);
            }

            // Get id of the current light.
            var lightId = this.reader.getString(children[i], 'id');
            if (lightId == null){
                this.onXMLMinorError("no ID defined for light");
                continue;
            }

            // Checks for repeated IDs.
            if (this.lights[lightId] != null){
                this.onXMLMinorError("ID must be unique for each light (conflict: ID = " + lightId + ")");
                continue;
            }

            grandChildren = children[i].children;
            // Specifications for the current light.

            nodeNames = [];
            for (var j = 0; j < grandChildren.length; j++) {
                nodeNames.push(grandChildren[j].nodeName);
            }

            for (var j = 0; j < attributeNames.length; j++) {
                var attributeIndex = nodeNames.indexOf(attributeNames[j]);

                if (attributeIndex != -1) {
                    if (attributeTypes[j] == "boolean")
                        var aux = this.parseBoolean(grandChildren[attributeIndex], "value", "enabled attribute for light of ID" + lightId);
                    else if (attributeTypes[j] == "position")
                        var aux = this.parseCoordinates4D(grandChildren[attributeIndex], "light position for ID" + lightId);
                    else
                        var aux = this.parseColor(grandChildren[attributeIndex], attributeNames[j] + " illumination for ID" + lightId);

                    if (typeof aux === 'string')
                        return aux;

                    global.push(aux);
                }
                else{
                    this.onXMLMinorError("light " + attributeNames[i] + " undefined for ID = " + lightId);
                    continue;
                }
            }
            this.lights[lightId] = global;
            numLights++;
        }

        if (numLights == 0){
            this.onXMLError("At least one light must be defined. Creating a default one.");
            this.lights["defaultLightError"] = [true, [0,1,0,1], [0,0,0,0], [1,1,1,1], [1,1,1,1]];
        }
        else if (numLights > 8)
            this.onXMLMinorError("too many lights defined; WebGL imposes a limit of 8 lights");

        this.log("Parsed Lights.");
        return null;
    }

    /**
     * Parses the <textures> block. 
     * @param {textures block element} texturesNode
     */
    parseTextures(texturesNode) {
        const children = texturesNode.children;

        this.textures = [];

        // Creates default texture on error
        this.textures["error"] = new CGFtexture(this.scene, "./scenes/images/error.jpg");

        //For each texture in textures block, check ID and file URL

        // Checks if there are child nodes declared
        if(children.length === 0) {
            this.onXMLMinorError("No textures defined!");
            return null;
        }

        for (let i = 0; i < children.length; i++) {
            if (children[i].nodeName != "texture") {
                this.onXMLMinorError("unknown tag <" + children[i].nodeName + ">");
                continue;
            }

            // Get id of the current texture
            const textureID = this.reader.getString(children[i], 'id');
            if (textureID == null){
                this.onXMLMinorError("no ID defined for texture");
                continue;
            }

            // Check for repeated IDs
            if (this.textures[textureID] != null) {
                this.onXMLMinorError("ID must be unique for each texture (conflict: ID = " + textureID + ")");
                continue;
            }

            // Get path
            const file = this.reader.getString(children[i], 'path');
            
            // Check if texture file exists. If so, create texture
            if (this.checkFileExists(file)) {
                this.textures[textureID] = new CGFtexture(this.scene, file);
            }
            else {
                this.onXMLMinorError("Texture file " + file + " doesn't exist");
                continue;
            }
        }
        
        this.log("Parsed Textures.");
        return null;
    }

    /**
     * Parses the <spritesheets> block. 
     * @param {spritesheets block element} spritesheetsNode
     */
    parseSpritesheets(spritesheetsNode) {
        const children = spritesheetsNode.children;

        this.spritesheets = [];

        //For each spritesheet in spritesheet block, check ID and file URL

        // Checks if there are child nodes declared
        if(children.length === 0) {
            this.onXMLMinorError("No spritesheets defined!");
            return null;
        }

        for (let i = 0; i < children.length; i++) {
            if (children[i].nodeName != "spritesheet") {
                this.onXMLMinorError("unknown tag <" + children[i].nodeName + ">");
                continue;
            }

            // Get id of the current spritesheet
            const spritesheetID = this.reader.getString(children[i], 'id');
            if (spritesheetID == null){
                this.onXMLMinorError("no ID defined for spritesheet");
                continue;
            }

            // Check for repeated IDs
            if (this.spritesheets[spritesheetID] != null) {
                this.onXMLMinorError("ID must be unique for each spritesheet (conflict: ID = " + spritesheetID + ")");
                continue;
            }

            // Parse sizeM and check for errors
            const sizeM = this.reader.getFloat(children[i], 'sizeM');
            if (!this.checkPositiveNumber(sizeM)) {
                this.onXMLMinorError("Missing values for sizeM. Spritesheet ID: " + spritesheetID);
                continue;
            }

            // Parse sizeN and check for errors
            const sizeN = this.reader.getFloat(children[i], 'sizeN');
            if (!this.checkPositiveNumber(sizeN)) {
                this.onXMLMinorError("Missing values for sizeN. Spritesheet ID: " + spritesheetID);
                continue;
            }


            // Get path
            const file = this.reader.getString(children[i], 'path');
            
            // Check if spritesheet file exists. If so, create spritesheet
            if (this.checkFileExists(file)) {
                this.spritesheets[spritesheetID] = new MySpritesheet(this.scene, new CGFtexture(this.scene, file), sizeM, sizeN);
            }
            else {
                this.onXMLMinorError("Spritesheet file " + file + " doesn't exist");
                continue;
            }
        }
        
        this.log("Parsed Spritesheets.");
        return null;
    }

    /**
     * Parses the <materials> node.
     * @param {materials block element} materialsNode
     */
    parseMaterials(materialsNode) {
        const children = materialsNode.children;

        this.materials = [];

        var grandChildren = [];

        // Creates default material on error
        this.materials["error"] = new CGFappearance(this.scene);
        this.materials["error"].setShininess(1);
        this.materials["error"].setEmission(1, 0, 0, 1);
        this.materials["error"].setAmbient(1, 0, 0, 1);
        this.materials["error"].setDiffuse(1, 0, 0, 1);
        this.materials["error"].setSpecular(1, 0, 0, 1);

        // Checks if there are child nodes declared
        if(children.length === 0) {
            this.onXMLMinorError("No materials defined!");
            return null;
        }

        // Any number of materials.
        for (var i = 0; i < children.length; i++) {

            if (children[i].nodeName != "material") {
                this.onXMLMinorError("unknown tag <" + children[i].nodeName + ">");
                continue;
            }

            // Get id of the current material.
            var materialID = this.reader.getString(children[i], 'id');
            if (materialID == null){
                this.onXMLMinorError("no ID defined for material");
                continue;
            }

            // Checks for repeated IDs.
            if (this.materials[materialID] != null){
                this.onXMLMinorError("ID must be unique for each material (conflict: ID = " + materialID + ")");
                continue;
            }

            //Parsing
            grandChildren = children[i].children;

            let nodeNames = [];
            for (let j = 0; j < grandChildren.length; j++) {
                nodeNames.push(grandChildren[j].nodeName);
            }

            // Get index on XML
            const shininessIndex = nodeNames.indexOf("shininess");
            const ambientIndex = nodeNames.indexOf("ambient");
            const diffuseIndex = nodeNames.indexOf("diffuse");
            const specularIndex = nodeNames.indexOf("specular");
            const emissiveIndex = nodeNames.indexOf("emissive");

            // Checks if all material components are declared.
            if (shininessIndex === -1 || emissiveIndex === -1 || ambientIndex === -1 || diffuseIndex === -1 || specularIndex === -1 || emissiveIndex === -1 ) {
                this.onXMLMinorError("Missing components for material. Material ID: " + materialID);
                continue;
            }

            // Checks if shininess has wrong value or is bellow 1, defining 1 as default.
            let shininess = this.reader.getFloat(grandChildren[shininessIndex], "value");
            if (!this.checkNumber(shininess)) {
                this.onXMLMinorError("Wrong value for shininess. Material ID: " + materialID);
                shininess = 1;
            }
            if (shininess < 1) {
                this.onXMLMinorError("Shininess value must be 1 or above, provided (" + shininess + "). Assuming 1 as default. Material ID: " + materialID);
                shininess = 1;
            }

            // Parses the rest of the material components.
            const ambient = this.parseColor(grandChildren[ambientIndex], "ambient component of material. Material ID: " + materialID);
            const diffuse = this.parseColor(grandChildren[diffuseIndex], "diffuse component of material. Material ID: " + materialID);
            const specular = this.parseColor(grandChildren[specularIndex], "specular component of material. Material ID: " + materialID);
            const emissive = this.parseColor(grandChildren[emissiveIndex], "emissive component of material. Material ID: " + materialID);

            // Creates a new material and sets parsed components.
            this.materials[materialID] = new CGFappearance(this.scene);
            this.materials[materialID].setShininess(shininess);
            this.materials[materialID].setEmission(emissive[0], emissive[1], emissive[2], emissive[3]);
            this.materials[materialID].setAmbient(ambient[0], ambient[1], ambient[2], ambient[3]);
            this.materials[materialID].setDiffuse(diffuse[0], diffuse[1], diffuse[2], diffuse[3]);
            this.materials[materialID].setSpecular(specular[0], specular[1], specular[2], specular[3]);
        }        

        this.log("Parsed Materials.");
        return null;
    }

    /**
     * Parses the <animaions> block. 
     * @param {animations block element} animationsNode
     */
    parseAnimations(animationsNode) {
        const children = animationsNode.children;

        this.animations = [];

        var keyframesNode = [];
        var transformationsNode = [];

        // Checks if there are child nodes declared
        if(children.length === 0) {
            this.onXMLMinorError("No animatons defined!");
            return null;
        }

        for (let i = 0; i < children.length; i++) {
            if (children[i].nodeName != "animation") {
                this.onXMLMinorError("unknown tag <" + children[i].nodeName + ">");
                continue;
            }

            // Get id of the current animation.
            var animationID = this.reader.getString(children[i], 'id');
            if (animationID == null){
                this.onXMLMinorError("no ID defined for material");
                continue;
            }

            // Checks for repeated IDs.
            if (this.animations[animationID] != null){
                this.onXMLMinorError("ID must be unique for each material (conflict: ID = " + animationID + ")");
                continue;
            }

            //Parsing
            let keyframes = [];
            keyframesNode = children[i].children;

            if(keyframesNode.length == 0){
                this.onXMLMinorError("No keyframe defined! Animation ID: " + animationID);
                continue;
            }
            for (let j = 0; j < keyframesNode.length; j++) {
                let instant = this.reader.getString(keyframesNode[j], "instant");
                if(instant == null){
                    this.onXMLMinorError("Instant not defined for keyframe. Animation ID: " + animationID);
                }

                let transformations = [];

                transformationsNode = keyframesNode[j].children;
                if(transformationsNode.length == 0){
                    this.onXMLMinorError("No transformations defined! Keyframe instant:" + instant + ", Animation ID: " + animationID);
                    continue;
                }
                
                for (let k = 0; k < transformationsNode.length; k++){
                    // Check transformation
                    switch (transformationsNode[k].nodeName) {
                        case ("translation") :
                            if(k!==0) this.onXMLMinorError("Transformation out of order. Keyframe instant:" + instant + ", Animation ID: " + animationID);
                            let xyz = null;

                            //Gets values
                            xyz = this.parseCoordinates3D(transformationsNode[k], "animation with ID: " + animationID);

                            if(!Array.isArray(xyz)){
                                this.onXMLMinorError("Wrong value on translation. Keyframe instant:" + instant + ", Aniamation ID: " + animationID);
                                continue;
                            }

                            //Multiplies new translation matrix
                            transformations[0] = xyz;
                            break;

                        case ("rotation"):
                            //Gets values
                            const axis = this.reader.getString(transformationsNode[k], 'axis');
                            const angle = this.reader.getFloat(transformationsNode[k], 'angle');

                            //Checks for errors
                            if (axis == null || (axis !== "x" && axis !== "y" && axis !== "z")) {
                                this.onXMLMinorError("Wrong value for axis on rotation. Keyframe instant:" + instant + ", Aniamation ID: " + animationID);
                                continue;
                            }
                            if (!this.checkNumber(angle)) {
                                this.onXMLMinorError("Wrong value for angle on rotation. Keyframe instant:" + instant + ", Aniamation ID: " + animationID);
                                continue;
                            }

                            if(axis==="x"){
                                if(k!==1) this.onXMLMinorError("X Rotation out of order. Keyframe instant:" + instant + ", Animation ID: " + animationID);
                                transformations[1] = angle * DEGREE_TO_RAD;
                            }
                            else if(axis==="y"){
                                if(k!==2) this.onXMLMinorError("Y Rotation out of order. Keyframe instant:" + instant + ", Animation ID: " + animationID);
                                transformations[2] = angle * DEGREE_TO_RAD;
                            }
                            else if(axis==="z"){
                                if(k!==3) this.onXMLMinorError("Z Rotation out of order. Keyframe instant:" + instant + ", Animation ID: " + animationID);
                                transformations[3] = angle * DEGREE_TO_RAD;
                            }

                            break;

                        case ("scale"):
                            if(k !== 4) this.onXMLMinorError("Scale out of order. Keyframe instant:" + instant + ", Animation ID: " + animationID);
                            //Gets values
                            const sx = this.reader.getFloat(transformationsNode[k], "sx");
                            const sy = this.reader.getFloat(transformationsNode[k], "sy");
                            const sz = this.reader.getFloat(transformationsNode[k], "sz");

                            //Checks for errors
                            if (!this.checkNumber(sx) || !this.checkNumber(sy) || !this.checkNumber(sz)) {
                                this.onXMLMinorError("Wrong values for scale. Keyframe instant:" + instant + ", Animation ID: " + animationID);
                                continue;
                            }

                            //Multiplies new scale matrix
                            transformations[4] = [sx, sy, sz];
                            break;
                        default:
                            break;
                    }
                }

                keyframes.push({instant: instant, transformations: transformations});
            }

            keyframes.sort(function(a,b){return a.instant - b.instant});
            let keyframeAnimation = new MyKeyframeAnimation(keyframes);
            this.animations[animationID] = keyframeAnimation;
        }

        this.log("Parsed Animations.");
        return null;
    }

    /**
     * Parses the <nodes> block.
     * @param {nodes block element} nodesNode
     */
    parseNodes(nodesNode) {
        const children = nodesNode.children;

        // Checks if there are child nodes declared
        if(children.length === 0) {
            this.onXMLError("No nodes defined!");
            return null;
        }

        this.nodes = [];

        var grandChildren = [];

        // Any number of nodes.
        for (var i = 0; i < children.length; i++) {

            if (children[i].nodeName != "node") {
                this.onXMLMinorError("unknown tag <" + children[i].nodeName + ">");
                continue;
            }

            // Get id of the current node.
            var nodeID = this.reader.getString(children[i], 'id');
            if (nodeID == null){
                this.onXMLMinorError("no ID defined for node");
                continue;
            }

            // Checks for repeated IDs.
            if (this.nodes[nodeID] != null){
                this.onXMLMinorError("ID must be unique for each node (conflict: ID = " + nodeID + ")");
                continue;
            }

            grandChildren = children[i].children;

            let nodeNames = [];
            for (let j = 0; j < grandChildren.length; j++) {
                nodeNames.push(grandChildren[j].nodeName);
            }

            //Get index on XML
            var transformationsIndex = nodeNames.indexOf("transformations");
            var animationIndex = nodeNames.indexOf("animationref");
            var materialIndex = nodeNames.indexOf("material");
            var textureIndex = nodeNames.indexOf("texture");
            var descendantsIndex = nodeNames.indexOf("descendants");

            // If descendants node is not defined ignore node and parse next
            if (descendantsIndex == -1) {
                this.onXMLMinorError("No <descendants> node declared. Node ID: " + nodeID);
                continue;
            }

            // TRANSFORMATIONS
            let transformationsMatrix = mat4.create(); //Base matrix

            if (transformationsIndex == -1) {
                // If transformations node is not defined transformationsMatrix is identity matrix
                this.onXMLMinorError("No <transformations> node declared. Assuming no transformations for this node. Node ID: " + nodeID);
            }
            else {
                // Parse transformations if defined
                const transformationsNode = grandChildren[transformationsIndex].children;
                for (let j = 0; j < transformationsNode.length; j++){
                    // Check transformation
                    switch (transformationsNode[j].nodeName) {
                        case ("translation") :
                            let xyz = null;

                            //Gets values
                            xyz = this.parseCoordinates3D(transformationsNode[j], "node with ID: " + nodeID);

                            if(!Array.isArray(xyz)){
                                this.onXMLMinorError("Wrong value on translation. Node ID: " + nodeID);
                                continue;
                            }

                            //Multiplies new translation matrix
                            mat4.translate(transformationsMatrix, transformationsMatrix, xyz);
                            break;

                        case ("rotation"):
                            //Gets values
                            const axis = this.reader.getString(transformationsNode[j], 'axis');
                            const angle = this.reader.getFloat(transformationsNode[j], 'angle');

                            //Checks for errors
                            if (axis == null || (axis !== "x" && axis !== "y" && axis !== "z")) {
                                this.onXMLMinorError("Wrong value for axis on rotation. Node ID: " + nodeID);
                                continue;
                            }
                            if (!this.checkNumber(angle)) {
                                this.onXMLMinorError("Wrong value for angle on rotation. Node ID: " + nodeID);
                                continue;
                            }

                            //Multiplies new rotation matrix
                            mat4.rotate(transformationsMatrix, transformationsMatrix, angle*DEGREE_TO_RAD, this.axisCoords[axis]);
                            break;

                        case ("scale"):
                            //Gets values
                            const sx = this.reader.getFloat(transformationsNode[j], "sx");
                            const sy = this.reader.getFloat(transformationsNode[j], "sy");
                            const sz = this.reader.getFloat(transformationsNode[j], "sz");

                            //Checks for errors
                            if (!this.checkNumber(sx) || !this.checkNumber(sy) || !this.checkNumber(sz)) {
                                this.onXMLMinorError("Wrong values for scale. Node ID: " + nodeID);
                                continue;
                            }

                            //Multiplies new scale matrix
                            mat4.scale(transformationsMatrix, transformationsMatrix, [sx, sy, sz]);
                            break;
                        default:
                            break;
                    }
                }
            }

            // ANIMATION
            let animationID = null

            // Parse if animations node is defined
            if(animationIndex != -1){
                animationID = this.reader.getString(grandChildren[animationIndex], "id");

                if (animationID == null) {
                    this.onXMLMinorError("Animation ID not defined. Node ID: " + nodeID);
                }

                // Check if parsed animationID is in animations map
                if (this.animations[animationID] == null) {
                    this.onXMLMinorError("Animation with ID: " + animationID + " does not exist. Error on node ID: " + nodeID);
                }
            }

            // MATERIAL
            let materialID = null;

            if (materialIndex == -1) {
                // If material node is not defined defaults materialID to error
                this.onXMLMinorError("No <material> node declared. Node ID: " + nodeID);
                materialID = "error";
            }
            else {
                // Parse material if defined
                materialID= this.reader.getString(grandChildren[materialIndex], "id");

                if (materialID == null) {
                    this.onXMLMinorError("Material ID not defined. Node ID: " + nodeID);
                    materialID = "error";
                }

                // Check if parsed materialID is in materials map
                if (materialID !== "null") {
                    if (this.materials[materialID] == null) {
                        this.onXMLMinorError("Material with ID: " + materialID + " does not exist. Error on node ID: " + nodeID);
                        materialID= "error";
                    }
                }
            }

            // TEXTURE
            let textureID = null;
            let amplification = {
                afs: 1,
                aft: 1
            }

            if (textureIndex == -1) {
                // If texture node is not defined defaults textureID to error
                this.onXMLMinorError("No <texture> node declared. Node ID: " + nodeID);
                textureID = "error";
            }
            else {
                // Parse texture if defined
                textureID = this.reader.getString(grandChildren[textureIndex], "id");

                if (textureID == null) {
                    this.onXMLMinorError("Texture ID not defined. Node ID: " + nodeID);
                    textureID = "error";
                }

                // Check if parsed textureID is in textures map
                if (textureID !== "null" && textureID !== "clear") {
                    if (this.textures[textureID] == null) {
                        this.onXMLMinorError("Texture with ID: " + textureID + " does not exist. Node ID: " + nodeID);
                        textureID = "error";
                    }
                }
                
                // If textureID isn't "clear" parse amplification
                if (textureID !== "clear") {
                    const amplificationNode = grandChildren[textureIndex].children;
                    if(amplificationNode.length == 0){
                        this.onXMLMinorError("Amplification tag missing, assuming 1.0. Node ID: " + nodeID);
                    }
                    else{
                        for (let j = 0; j < amplificationNode.length; j++) {
                            if (amplificationNode[j].nodeName === "amplification") {
                                const afs = this.reader.getFloat(amplificationNode[j], 'afs');
                                const aft = this.reader.getFloat(amplificationNode[j], 'aft');
                                if (!this.checkPositiveNumber(afs) || !this.checkPositiveNumber(aft)) {
                                    this.onXMLMinorError("Amplification values not valid, assuming 1.0. Node ID: " + nodeID);
                                }
                                else {
                                    amplification = {
                                        afs: afs,
                                        aft: aft
                                    }
                                }
                            }
                        }
                    }
                }
            }

            // DESCENDANTS

            const descendantsNodes = grandChildren[descendantsIndex].children;

            // If no child nodes declared inside descendant nodes ignore and parse next
            if (descendantsNodes.length === 0) {
                this.onXMLMinorError("No descendants defined! Node ID: " + nodeID);
                continue;
            }

            const childNodesID = [];
            const leafs = [];
            
            for (let j = 0; j < descendantsNodes.length; j++) {
                if (descendantsNodes[j].nodeName === "noderef") {
                    const descendantID = this.reader.getString(descendantsNodes[j], "id");

                    if (descendantID == null){
                        this.onXMLMinorError("Undefined ID for descendant. Node ID: " + nodeID);
                        continue;
                    }

                    // Ignore if descendant is parent, avoids cycles
                    else if (descendantID === nodeID){
                        this.onXMLMinorError("Descendant with the same parent's ID. Node ID: " + nodeID);
                        continue
                    }

                    // Check for duplicated descendant, ignores if so
                    else if(childNodesID.includes(descendantID)){
                        this.onXMLMinorError("Duplicated descendant ID (" + descendantID + "). Node ID: " + nodeID);
                        continue
                    }

                    childNodesID.push(descendantID);
                }
                else if (descendantsNodes[j].nodeName === "leaf") {
                    const type = this.reader.getString(descendantsNodes[j], "type");
                    // Check leaf type, get values and create primitive object
                    switch (type) {
                        case ("rectangle"): {
                            const x1 = this.reader.getFloat(descendantsNodes[j], 'x1');
                            const y1 = this.reader.getFloat(descendantsNodes[j], 'y1');
                            const x2 = this.reader.getFloat(descendantsNodes[j], 'x2');
                            const y2 = this.reader.getFloat(descendantsNodes[j], 'y2');

                            if (!this.checkNumber(x1) || !this.checkNumber(x2) || !this.checkNumber(y1) || !this.checkNumber(y2)) {
                                this.onXMLMinorError("Wrong values for rectangle leaf. Node ID: " + nodeID);
                                break;
                            }

                            const rect = new MyRectangle(this.scene, x1, y1, x2, y2);
                            rect.applyTextures(amplification.afs, amplification.aft);

                            leafs.push(rect);
                            break;
                        }
                        case ("triangle"): {
                            const x1 = this.reader.getFloat(descendantsNodes[j], 'x1');
                            const y1 = this.reader.getFloat(descendantsNodes[j], 'y1');
                            const x2 = this.reader.getFloat(descendantsNodes[j], 'x2');
                            const y2 = this.reader.getFloat(descendantsNodes[j], 'y2');
                            const x3 = this.reader.getFloat(descendantsNodes[j], 'x3');
                            const y3 = this.reader.getFloat(descendantsNodes[j], 'y3');

                            if (!this.checkNumber(x1) || !this.checkNumber(x2) || !this.checkNumber(y1) || !this.checkNumber(y2) || !this.checkNumber(x3) || !this.checkNumber(y3)) {
                                this.onXMLMinorError("Wrong values for triangle leaf. Node ID: " + nodeID);
                                break;
                            }

                            const triangle = new MyTriangle(this.scene, x1, y1, x2, y2, x3, y3);
                            triangle.applyTextures(amplification.afs, amplification.aft);

                            leafs.push(triangle);
                            break;
                        }
                        case ("cylinder"): {
                            const height = this.reader.getFloat(descendantsNodes[j],'height');
                            const topRadius = this.reader.getFloat(descendantsNodes[j],'topRadius');
                            const bottomRadius = this.reader.getFloat(descendantsNodes[j],'bottomRadius');
                            const stacks = this.reader.getInteger(descendantsNodes[j],'stacks');
                            const slices = this.reader.getInteger(descendantsNodes[j],'slices');

                            if (!this.checkPositiveNumber(height) || !this.checkPositiveNumber(topRadius) || !this.checkPositiveNumber(bottomRadius) || !this.checkPositiveNumber(stacks) || !this.checkPositiveNumber(slices)) {
                                this.onXMLMinorError("Wrong values for cylinder leaf. Node ID: " + nodeID);
                                break;
                            }

                            leafs.push(new MyCylinder(this.scene, height, topRadius, bottomRadius, stacks, slices));
                            break;
                        }
                        case ("sphere"): {
                            const radius = this.reader.getFloat(descendantsNodes[j], 'radius');
                            const slices = this.reader.getInteger(descendantsNodes[j], 'slices');
                            const stacks = this.reader.getInteger(descendantsNodes[j], 'stacks');

                            if (!this.checkPositiveNumber(radius) || !this.checkPositiveNumber(slices) || !this.checkPositiveNumber(stacks)){
                                this.onXMLMinorError("Wrong values for sphere leaf. Node ID: " + nodeID);
                                break;
                            }

                            leafs.push(new MySphere(this.scene, radius, slices, stacks));
                            break;
                        }
                        case ("torus"): {
                            const inner = this.reader.getFloat(descendantsNodes[j],'inner');
                            const outer = this.reader.getFloat(descendantsNodes[j],'outer');
                            const loops = this.reader.getInteger(descendantsNodes[j],'loops');
                            const slices = this.reader.getInteger(descendantsNodes[j],'slices');

                            if (!this.checkPositiveNumber(inner) || !this.checkPositiveNumber(outer) || !this.checkPositiveNumber(loops) || !this.checkPositiveNumber(slices)){
                                this.onXMLMinorError("Wrong values for torus leaf. Node ID: " + nodeID);
                                break;
                            }

                            leafs.push(new MyTorus(this.scene, inner, outer, slices, loops));
                            break;
                        }
                        case ("spritetext"): {
                            const text = this.reader.getString(descendantsNodes[j],'text');

                            if(text == null){
                                this.onXMLMinorError("Undefined text for spritesheet. Node ID: " + nodeID);
                                break;
                            }

                            leafs.push(new MySpriteText(this.scene, text));
                            break;
                        }
                        case ("spriteanim"): {
                            const ssid = this.reader.getString(descendantsNodes[j],'ssid');
                            if(ssid == null) {
                                this.onXMLMinorError("ssid of spriteanim not defined. Node ID: " + nodeID);
                                break;
                            }
                            if(this.spritesheets[ssid] == null){
                                this.onXMLMinorError("Spritesheet with given ssid: " + ssid + " does not exist. Node ID: " + nodeID);
                                break;
                            }

                            const startCell = this.reader.getInteger(descendantsNodes[j],'startCell');
                            if(!this.checkPositiveNumber(startCell)){
                                this.onXMLMinorError("Wrong values for spriteanim starCell. Node ID: " + nodeID);
                                break;
                            }

                            const endCell = this.reader.getInteger(descendantsNodes[j],'endCell');
                            if(!this.checkPositiveNumber(endCell)){
                                this.onXMLMinorError("Wrong values for spriteanim endCell. Node ID: " + nodeID);
                                break;
                            }

                            const duration = this.reader.getFloat(descendantsNodes[j],'duration');
                            if(!this.checkPositiveNumber(duration)){
                                this.onXMLMinorError("Wrong values for spriteanim duration. Node ID: " + nodeID);
                                break;
                            }

                            let spriteanim = new MySpriteAnimation(this.scene, this.spritesheets[ssid], startCell, endCell, duration);
                            this.spriteanims.push(spriteanim);
                            leafs.push(spriteanim);
                            break;
                        }
                        case ("plane"): {
                            const npartsU = this.reader.getInteger(descendantsNodes[j],'npartsU');
                            if(!this.checkPositiveNumber(npartsU)){
                                this.onXMLMinorError("Wrong values for plane npartsU. Node ID: " + nodeID);
                                break;
                            }

                            const npartsV = this.reader.getInteger(descendantsNodes[j],'npartsV');
                            if(!this.checkPositiveNumber(npartsV)){
                                this.onXMLMinorError("Wrong values for plane npartsV. Node ID: " + nodeID);
                                break;
                            }
                            
                            leafs.push(new MyPlane(this.scene, npartsU, npartsV));
                            break;
                        }
                        case ("patch"): {
                            const npartsU = this.reader.getInteger(descendantsNodes[j],'npartsU');
                            if(!this.checkPositiveNumber(npartsU)){
                                this.onXMLMinorError("Wrong values for patch npartsU. Node ID: " + nodeID);
                                break;
                            }

                            const npartsV = this.reader.getInteger(descendantsNodes[j],'npartsV');
                            if(!this.checkPositiveNumber(npartsV)){
                                this.onXMLMinorError("Wrong values for patch npartsV. Node ID: " + nodeID);
                                break;
                            }

                            const npointsU = this.reader.getInteger(descendantsNodes[j],'npointsU');
                            if(!this.checkPositiveNumber(npointsU)){
                                this.onXMLMinorError("Wrong values for patch npartsU. Node ID: " + nodeID);
                                break;
                            }

                            const npointsV = this.reader.getInteger(descendantsNodes[j],'npointsV');
                            if(!this.checkPositiveNumber(npointsV)){
                                this.onXMLMinorError("Wrong values for patch npointsV. Node ID: " + nodeID);
                                break;
                            }

                            const controlPointsNodes = descendantsNodes[j].children;
                            if (controlPointsNodes.length === 0) {
                                this.onXMLMinorError("No control points defined for patch! Node ID: " + nodeID);
                                continue;
                            }

                            const controlPointsNum = npointsU*npointsV;
                            if(controlPointsNodes.length !== controlPointsNum) {
                                this.onXMLMinorError("Wrong number of control points provided for patch! (required " + controlPointsNum + "). Node ID: " + nodeID);
                                continue;
                            }

                            let controlPoints = [];
                            let index = 0;
                            let error = false;

                            f:
                            for(let u = 0; u < npointsU; u++){
                                let uList = [];
                                
                                for(let v = 0; v < npointsV; v++, index++){
                                    let xyz = this.parseCoordinates3D(controlPointsNodes[index], "patch control points. Node ID: " + nodeID);
                                    if(!Array.isArray(xyz)){
                                        this.onXMLMinorError("Wrong value on patch control points. Node ID: " + nodeID);
                                        error = true;
                                        break f;
                                    }

                                    uList.push([xyz[0], xyz[1], xyz[2], 1]);
                                }

                                controlPoints.push(uList);
                            }

                            if(error) break;

                            leafs.push(new MyPatch(this.scene, npartsU, npartsV, npointsU, npointsV, controlPoints));
                            break;
                        }
                        case ("defbarrel"): {
                            const base = this.reader.getFloat(descendantsNodes[j], 'base');
                            if(!this.checkPositiveNumber(base)){
                                this.onXMLMinorError("Wrong values for defbarrel base. Node ID: " + nodeID);
                                break;
                            
                            }
                            const middle = this.reader.getFloat(descendantsNodes[j], 'middle');
                            if(!this.checkPositiveNumber(middle)){
                                this.onXMLMinorError("Wrong values for defbarrel middle. Node ID: " + nodeID);
                                break;
                            }

                            const height = this.reader.getFloat(descendantsNodes[j], 'height');
                            if(!this.checkPositiveNumber(height)){
                                this.onXMLMinorError("Wrong values for defbarrel height. Node ID: " + nodeID);
                                break;
                            }
                            
                            const slices = this.reader.getInteger(descendantsNodes[j], 'slices');
                            if(!this.checkPositiveNumber(slices)){
                                this.onXMLMinorError("Wrong values for defbarrel slices. Node ID: " + nodeID);
                                break;
                            }

                            const stacks = this.reader.getInteger(descendantsNodes[j], 'stacks');
                            if(!this.checkPositiveNumber(stacks)){
                                this.onXMLMinorError("Wrong values for defbarrel stacks. Node ID: " + nodeID);
                                break;
                            }

                            leafs.push(new MyDefbarrel(this.scene, base, middle, height, slices, stacks));
                            break;
                        }
                        default:
                            this.onXMLMinorError("Undefined leaf type: " + type + ". Node ID: " + nodeID);
                            break;
                    }
                }
            }

            // Puts created node in nodes
            this.nodes[nodeID] = new MySceneGraphNode(this.scene, nodeID, childNodesID, leafs, transformationsMatrix, this.materials[materialID], this.textures[textureID], textureID, this.animations[animationID]);
        }

        // Pre-process all nodes adding its child nodes objects
        for (const [nodeID, node] of Object.entries(this.nodes)) {
            for (const childID of node.childNodesID) {
                if (this.nodes.hasOwnProperty(childID)) {
                    node.addChildNode(this.nodes[childID]);
                }
                else {
                    this.onXMLMinorError("Child node not defined. Child ID: " + childID);
                }
            }
        }

        this.log("Parsed Nodes.");
        return null;
    }

    parseGame(gameNode){
        const children = gameNode.children;
        this.gameProperties = [];

        // Checks if there are child nodes declared
        if(children.length === 0) {
            this.onXMLMinorError("No game related defined!");
            return null;
        }

        for (let grandChildren of children) {
            if (grandChildren.nodeName == "piecetype") {
                const id = this.reader.getString(grandChildren, "id");

                //Parse Geometry
                const geometry = this.reader.getString(grandChildren, "geometry");
                let obj = null;
                switch (geometry){
                    case ("cylinder"):
                        obj = new MyCylinder(this.scene, 0.2, 0.4, 0.4, 5, 30);
                        break;
                    case ("pyramid"):
                        obj = new MyPyramid(this.scene, 0.6, 0.4, 0.6, 4, 10);
                        break;
                    case ("cone"):
                        obj = new MyCone(this.scene, 0.45, 0.4, 0.45, 30, 10);
                        break;
                    default:
                        break;
                }

                this.gameProperties[id] = {
                    geometry: obj,
                    material: this.parseMaterialIDSimple(grandChildren)
                };
            }
            else if (grandChildren.nodeName == "boards"){
                const xyz = this.parseCoordinates3D(grandChildren, "gameboard position");

                if(!Array.isArray(xyz)){
                    this.onXMLMinorError("Wrong value on Gameboard position");
                    continue;
                }

                this.gameProperties["boards"] = {
                    position: xyz,
                    material: this.parseMaterialIDSimple(grandChildren),
                    texture: this.parseTextureIDSimple(grandChildren)
                }
            }
            else if (grandChildren.nodeName == "tiles"){
                this.gameProperties["tiles"] = {
                    material: this.parseMaterialIDSimple(grandChildren),
                    texture: this.parseTextureIDSimple(grandChildren)
                }
            }
        }

        this.log("Parsed Game.");
        return null;
    }

    /**
     * Check if file name given exists in workspace
     * @param {string} file
     */
    checkFileExists(file) {
        let http = new XMLHttpRequest();
        http.open('HEAD', file, false);
        http.send();
        return (http.status === 200);
    }

    parseBoolean(node, name, messageError) {
        var boolVal = this.reader.getBoolean(node, name);
        if (!(boolVal != null && !isNaN(boolVal) && (boolVal == true || boolVal == false))) {
           this.onXMLMinorError("unable to parse value component " + messageError + "; assuming 'value = 1'");
           return true;
        }
        return boolVal;
    }
    /**
     * Parse the coordinates from a node with ID = id
     * @param {block element} node
     * @param {message to be displayed in case of error} messageError
     */
    parseCoordinates3D(node, messageError) {
        var position = [];

        // x
        var x = this.reader.getFloat(node, 'x');
        if (!(x != null && !isNaN(x)))
            return "unable to parse x-coordinate of the " + messageError;

        // y
        var y = this.reader.getFloat(node, 'y');
        if (!(y != null && !isNaN(y)))
            return "unable to parse y-coordinate of the " + messageError;

        // z
        var z = this.reader.getFloat(node, 'z');
        if (!(z != null && !isNaN(z)))
            return "unable to parse z-coordinate of the " + messageError;

        position.push(...[x, y, z]);

        return position;
    }

    /**
     * Parse the coordinates from a node with ID = id
     * @param {block element} node
     * @param {message to be displayed in case of error} messageError
     */
    parseCoordinates4D(node, messageError) {
        var position = [];

        //Get x, y, z
        position = this.parseCoordinates3D(node, messageError);

        if (!Array.isArray(position))
            return position;


        // w
        var w = this.reader.getFloat(node, 'w');
        if (!(w != null && !isNaN(w)))
            return "unable to parse w-coordinate of the " + messageError;

        position.push(w);

        return position;
    }

    /**
     * Parse the color components from a node
     * @param {block element} node
     * @param {message to be displayed in case of error} messageError
     */
    parseColor(node, messageError) {
        var color = [];

        // R
        var r = this.reader.getFloat(node, 'r');
        if (!(r != null && !isNaN(r) && r >= 0 && r <= 1))
            return "unable to parse R component of the " + messageError;

        // G
        var g = this.reader.getFloat(node, 'g');
        if (!(g != null && !isNaN(g) && g >= 0 && g <= 1))
            return "unable to parse G component of the " + messageError;

        // B
        var b = this.reader.getFloat(node, 'b');
        if (!(b != null && !isNaN(b) && b >= 0 && b <= 1))
            return "unable to parse B component of the " + messageError;

        // A
        var a = this.reader.getFloat(node, 'a');
        if (!(a != null && !isNaN(a) && a >= 0 && a <= 1))
            return "unable to parse A component of the " + messageError;

        color.push(...[r, g, b, a]);

        return color;
    }

    parseMaterialIDSimple(node){
        let materialID = null;

        materialID = this.reader.getString(node, "material");

        if (materialID == null) {
            materialID = "error";
        }

        // Check if parsed materialID is in materials map
        if (this.materials[materialID] == null) {
            materialID= "error";
        }

        return this.materials[materialID];
    }

    parseTextureIDSimple(node){
        let textureID = null;

        textureID = this.reader.getString(node, "texture");

        if (textureID == null) {
            textureID = "error";
        }

        // Check if parsed textureID is in materials map
        if (this.textures[textureID] == null) {
            textureID= "error";
        }

        return this.textures[textureID];
    }

    /**
     * Check if number argument isn't null or not a number
     * @param {number} number
     */
    checkNumber(number){
        return (number != null && !isNaN(number));
    }

    /**
     * Check if number argument isn't null or not a number, and is positive
     * @param {number} number
     */
    checkPositiveNumber(number){
        return (this.checkNumber(number) && number>=0);
    }

    /**
     * Displays the scene, processing each node, starting in the root node.
     */
    displayScene() {
        if(this.nodes[this.idRoot] != null)
            this.nodes[this.idRoot].display(this.nodes[this.idRoot].material, this.nodes[this.idRoot].texture);
    }
}