void XmlParser::readMeshs(Renderer * renderer ,Scene * scene, XmlNode * meshNode) {
    // Read mesh
    while(meshNode) {
        // Create cube
        glm::mat4 id;
        MeshObject * mesh = new MeshObject(id);
        // Read shaders and init it
        int basicShader = renderer->getDefaultBasicShader();
        int lightShader = renderer->getDefaultLightShader();
        XmlNode * basicShaderNode = meshNode->first_node("basic-shader");
        XmlNode * lightShaderNode = meshNode->first_node("light-shader");
        
        // If there is a basic shader node
        if (basicShaderNode) {
            XmlAttr * vert, * frag;
            xmlAttribute(vert, basicShaderNode);
            xmlAttribute(frag, basicShaderNode);
            // Create new shader
            basicShader = renderer->createShaderProg(vert->value(), frag->value());
        }

        // If there is a light shader node
        if (lightShaderNode) {
            XmlAttr * vert, * frag;
            xmlAttribute(vert, lightShaderNode);
            xmlAttribute(frag, lightShaderNode);
            // Create new shader
            lightShader = renderer->createShaderProg(vert->value(), frag->value());
        }

        // Init mesh
        mesh->init(basicShader, lightShader);

        // Load file (it must exist)
        XmlAttr * file;
        xmlAttribute(file, meshNode);
        mesh->loadFromFile(file->value());
        
        // Try to read model
        readModel(mesh, meshNode->first_node("model"));

        // Add c to scene
        scene->addGameObject(mesh);

        // Set texture
        XmlNode * textureNode = meshNode->first_node("texture");
        if (textureNode) {
            // Get file name
            XmlAttr * file;
            xmlAttribute(file, textureNode);

            // Create texture
            Texture texture(GL_TEXTURE0, std::string(file->value()));

            // Set texture
            mesh->setTexture(texture);
        }

        // Set normal map
        XmlNode * normalMapNode = meshNode->first_node("normal-map");
        if (normalMapNode) {
            // Get file name
            XmlAttr * file;
            xmlAttribute(file, normalMapNode);

            // Create texture
            Texture normalMap(GL_TEXTURE2, std::string(file->value()));

            // Set texture
            mesh->setNormalMap(normalMap);
        }

        // Set material
		XmlNode * material = meshNode->first_node("material");
		if (material) {
			// Create material
			Material * m = new Material();

			// Set emissive
			XmlNode * emissive = material->first_node("emissive");
			if (emissive) {
				XmlAttr * r, *g, *b;
				xmlAttribute(r, emissive);
				xmlAttribute(g, emissive);
				xmlAttribute(b, emissive);
				// Set diffuse
				m->setEmissive(atof(r->value()), atof(g->value()),
						atof(b->value()));
			}

			// Read ambient
			XmlNode * ambient = material->first_node("ambient");
			if (ambient) {
				XmlAttr * r, *g, *b;
				xmlAttribute(r, ambient);
				xmlAttribute(g, ambient);
				xmlAttribute(b, ambient);
				// Set diffuse
				m->setAmbient(atof(r->value()), atof(g->value()),
						atof(b->value()));
			}

			// Read diffuse
			XmlNode * diffuse = material->first_node("diffuse");
			if (diffuse) {
				XmlAttr * r, *g, *b;
				xmlAttribute(r, diffuse);
				xmlAttribute(g, diffuse);
				xmlAttribute(b, diffuse);
				// Set diffuse
				m->setDiffuse(atof(r->value()), atof(g->value()),
						atof(b->value()));
			}

			// Read specular
			XmlNode * specular = material->first_node("specular");
			if (specular) {
				XmlAttr * r, *g, *b;
				xmlAttribute(r, specular);
				xmlAttribute(g, specular);
				xmlAttribute(b, specular);
				// Set diffuse
				m->setSpecular(atof(r->value()), atof(g->value()),
						atof(b->value()));
			}

			// Read specular
			XmlNode * shininess = material->first_node("shininess");
			if (shininess) {
				XmlAttr * value;
				xmlAttribute(value, shininess);
				// Set diffuse
				m->setShininess(atof(value->value()));
			}

			// Set material
			mesh->setMaterial(m);
		}

        // Read Scripts
        XmlNode * scripts = meshNode->first_node("scripts");
        readScripts(scene, mesh, scripts);

        // Get next cube
        meshNode = meshNode->next_sibling("mesh");
    }
}