Пример #1
0
bool
EngineBase::deserialize(TinyXML::TiXmlElement &n)
{
	/*
	 * Engine deserialization should ideally
	 * take place BEFORE it has been started.
	 */

	TinyXML::TiXmlElement *l_element;

	l_element = n.FirstChildElement("scenes");

	n.QueryFloatAttribute("fps", &m_fps);
	n.QueryFloatAttribute("ups", &m_ups);

	const char *l_suspendable = n.Attribute("suspendable");
	m_suspendable = (l_suspendable &&
	                (l_suspendable[0] == 't' || l_suspendable[0] == 'T'));

	if (l_element && m_scene_manager)
		m_scene_manager->deserialize(*l_element);
	else if (l_element && !m_scene_manager)
		return(false);
	
	return(true);
}
Пример #2
0
bool
ComponentBase::serialize(TinyXML::TiXmlElement &n) const
{
	n.SetAttribute("id", id().str().c_str());
	n.SetAttribute("type", type().str().c_str());
	return(true);
}
Пример #3
0
void GameElements::ConfigurationLoader::parseWeapons( TinyXML::TiXmlElement * root )
{
	::std::cout<<"-- Loading weapons"<<::std::endl ;
	TinyXML::TiXmlElement * rootWeapons = root->FirstChildElement("weapons") ;
	for(TinyXML::TiXmlElement * element = rootWeapons->FirstChildElement("weapon") ; element!=NULL ; element = element->NextSiblingElement("weapon") )
	{
		::std::cout<<element->Attribute("name")<<::std::endl ;
		m_weaponsArchetypes.addArchetype(element) ;
	}
}
Пример #4
0
void GameElements::ConfigurationLoader::parseMaps( TinyXML::TiXmlElement * root, Ogre::SceneManager * sceneManager )
{
	::std::cout<<"-- Loading maps"<<::std::endl; 
	TinyXML::TiXmlElement * rootUnits = root->FirstChildElement("maps") ;
	for(TinyXML::TiXmlElement * element = rootUnits->FirstChildElement("map") ; element!=NULL ; element = element->NextSiblingElement("map") )
	{
		::std::cout<<element->Attribute("name")<<::std::endl ;
		Map * map = new Map(sceneManager, element) ;
		m_maps.insert(::std::make_pair(map->getName(), map)) ;
	}
}
Пример #5
0
bool
MeshBase::deserialize(TinyXML::TiXmlElement &n)
{
	TinyXML::TiXmlElement *l_child;
	int l_i;

	n.QueryFloatAttribute("rotation", &m_rotation);

	/* color */
	l_child = n.FirstChildElement("color");
	if (l_child) {
		l_child->QueryFloatAttribute("r", &m_color[0]);
		l_child->QueryFloatAttribute("g", &m_color[1]);
		l_child->QueryFloatAttribute("b", &m_color[2]);
		l_child->QueryFloatAttribute("a", &m_color[3]);
	}

	/* texture */
	l_child = n.FirstChildElement("texture");
	if (l_child) {
		const char *l_file = l_child->Attribute("id");
		if (l_file) m_tdata->load(l_file);
	}

	/* texture coordinates */
	for (l_child = n.FirstChildElement("tcoord"), l_i = 0;
	     l_child;
	     l_child = l_child->NextSiblingElement("tcoord")) {
		float l_u, l_v;
		l_child->QueryFloatAttribute("u", &l_u);
		l_child->QueryFloatAttribute("v", &l_v);
		if (!m_tcdata->set(l_i++, l_u, l_v)) {
			MMWARNING1("Failed to assign texture coordinate data.");
			break;
		}
	}

	/* vertexes */
	for (l_child = n.FirstChildElement("vector"), l_i = 0;
	     l_child;
	     l_child = l_child->NextSiblingElement("vector")) {
		float l_x, l_y;
		l_child->QueryFloatAttribute("x", &l_x);
		l_child->QueryFloatAttribute("y", &l_y);
		if (!m_vdata->set(l_i++, l_x, l_y)) {
			MMWARNING1("Failed to assign vertex data.");
			break;
		}
	}

	return(true);
}
Пример #6
0
bool
SceneBase::deserialize(TinyXML::TiXmlElement &n)
{
	TinyXML::TiXmlElement *l_child;
	for (l_child = n.FirstChildElement("layer") ;
	     l_child;
	     l_child = l_child->NextSiblingElement("layer")) {

		const char *l_id   = l_child->Attribute("id");
		const char *l_type = l_child->Attribute("type");

		SharedSceneLayer l_layer =
		    FactoryBase::Instance()->createSceneLayer(l_type, l_id, *this);

		if (!l_layer) {
			MMWARNING("SceneLayer '%s' of type '%s' creation failed", l_id, l_type);
			continue;
		}

		if (!l_layer->deserialize(*l_child)) {
			MMWARNING("SceneLayer '%s' of type '%s' failed deserialization", l_id, l_type);
			continue;
		}

		pushLayer(l_layer);
	}
	
	return(true);
}
Пример #7
0
bool
SceneBase::serialize(TinyXML::TiXmlElement &n) const
{
	n.SetAttribute("id", id().str().c_str());
	n.SetAttribute("type", type().str().c_str());

	SceneLayerList::const_reverse_iterator l_i;
	SceneLayerList::const_reverse_iterator l_c = m_layers.rend();
	for (l_i = m_layers.rbegin(); l_i != l_c; ++l_i) {
		TinyXML::TiXmlElement l_element("layer");
		if ((*l_i)->serialize(l_element))
			n.InsertEndChild(l_element);
	}
	
	return(true);
}
Пример #8
0
bool
EntityBase::deserialize(TinyXML::TiXmlElement &n)
{
	TinyXML::TiXmlElement *l_child;
	for (l_child = n.FirstChildElement("component") ;
	     l_child;
	     l_child = l_child->NextSiblingElement("component")) {

		const char *l_id   = l_child->Attribute("id");
		const char *l_type = l_child->Attribute("type");

		SharedComponent l_component =
		    FactoryBase::Instance()->createComponent(l_type, l_id, *this);

		if (!l_component) {
			MMWARNING("Component '%s' of type '%s' creation failed", l_id, l_type);
			continue;
		}

		if (!l_component->deserialize(*l_child)) {
			MMWARNING("Component '%s' of type '%s' failed deserialization", l_id, l_type);
			continue;
		}

		pushComponent(l_component);
	}

	return(true);
}
Пример #9
0
bool
EntityBase::serialize(TinyXML::TiXmlElement &n) const
{
	n.SetAttribute("id", id().str().c_str());
	n.SetAttribute("type", type().str().c_str());

	ComponentList::const_reverse_iterator l_i;
	ComponentList::const_reverse_iterator l_c = m_components.rend();

	for (l_i = m_components.rbegin(); l_i != l_c; l_i++) {
		TinyXML::TiXmlElement l_element("component");
		if ((*l_i)->serialize(l_element))
			n.InsertEndChild(l_element);
	}
	
	return(true);
}
Пример #10
0
bool
Box2DComponent::serialize(TinyXML::TiXmlElement &n) const
{
    if (!ComponentBase::serialize(n))
        return(false);

    switch (m_body_type) {
    case b2_staticBody:
        n.SetAttribute("body", "static");
        break;
    case b2_kinematicBody:
        n.SetAttribute("body", "kinematic");
        break;
    case b2_dynamicBody:
        n.SetAttribute("body", "dynamic");
        break;
    }

    n.SetDoubleAttribute("width", m_size.width());
    n.SetDoubleAttribute("height", m_size.height());

    n.SetDoubleAttribute("density", m_density);
    n.SetDoubleAttribute("friction", m_friction);

    return(true);
}
Пример #11
0
bool
PositionComponent::deserialize(TinyXML::TiXmlElement &n)
{
	if (!ComponentBase::deserialize(n))
	    return(false);

	n.QueryFloatAttribute("x", &m_position[0]);
	n.QueryFloatAttribute("y", &m_position[1]);
	return(true);
}
Пример #12
0
bool
PositionComponent::serialize(TinyXML::TiXmlElement &n) const
{
	if (!ComponentBase::serialize(n))
	    return(false);

	n.SetDoubleAttribute("x", m_position.x());
	n.SetDoubleAttribute("y", m_position.y());
	return(true);
}
Пример #13
0
bool
EngineBase::serialize(TinyXML::TiXmlElement &n) const
{
	n.SetDoubleAttribute("fps", m_fps);
	n.SetDoubleAttribute("ups", m_ups);
	n.SetAttribute("suspendable", m_suspendable ? "t" : "f");

	if (m_scene_manager) {
		TinyXML::TiXmlElement l_element("scenes");

		if (!m_scene_manager->serialize(l_element)) {
			MMWARNING1("Scene Manager serialization failed");
			return(false);
		}

		n.InsertEndChild(l_element);
	}

	return(true);
}
Пример #14
0
bool
Box2DComponent::deserialize(TinyXML::TiXmlElement &n)
{
    if (!ComponentBase::deserialize(n))
        return(false);

    const char *l_body = n.Attribute("body");

    m_body_type = b2_staticBody;
    if (l_body && l_body[0] == 'k')
        m_body_type = b2_kinematicBody;
    if (l_body && l_body[0] == 'd')
        m_body_type = b2_dynamicBody;

    n.QueryFloatAttribute("width", &m_size[0]);
    n.QueryFloatAttribute("height", &m_size[1]);

    n.QueryFloatAttribute("density", &m_density);
    n.QueryFloatAttribute("friction", &m_friction);

    return(true);
}
Пример #15
0
bool VehicleRenderable::loadSceneNodes(TinyXml::TiXmlElement* ele)
{
	TinyXml::TiXmlElement* nodeEle = ele->FirstChildElement("node");
	while (nodeEle)
	{
		Ogre::String name = getAttrib(nodeEle, "name");
		Ogre::SceneNode* node = NULL;

		if (name.empty())
			node = mAttachNode->createChildSceneNode();
		else
			node = mAttachNode->createChildSceneNode(name);

		mSceneNodes.push_back(node);

		Ogre::LogManager::getSingleton().
			logMessage("VehicleRenderable : parsing <" + name + "> node...");

		//process position
		TinyXml::TiXmlElement* pos = nodeEle->FirstChildElement("position");
		node->setPosition(parseVector3(pos));
		node->setInitialState();

		//process scale
		TinyXml::TiXmlElement* scale = nodeEle->FirstChildElement("scale");
		node->setScale(parseVector3(scale));
		node->setInitialState();

		//process rotate
		TinyXml::TiXmlElement* rotate = nodeEle->FirstChildElement("rotation");
		node->setOrientation(parseQuaternion(rotate));
		node->setInitialState();

		//process entities
		TinyXml::TiXmlElement* entity = nodeEle->FirstChildElement("entity");
		while (entity)
		{
			if (!loadEntity(entity, node))
				return false;

			entity = entity->NextSiblingElement("entity");
		}

		nodeEle = nodeEle->NextSiblingElement("node");
	}

	return true;
}
Пример #16
0
bool
MeshBase::serialize(TinyXML::TiXmlElement &n) const
{
	n.SetAttribute("type", type().str().c_str());
	n.SetDoubleAttribute("rotation", m_rotation);

	/* color */
	TinyXML::TiXmlElement l_color("color");
	l_color.SetDoubleAttribute("r", m_color[0]);
	l_color.SetDoubleAttribute("g", m_color[1]);
	l_color.SetDoubleAttribute("b", m_color[2]);
	l_color.SetDoubleAttribute("a", m_color[3]);
	n.InsertEndChild(l_color);

	/* texture */
	if (m_tdata->isLoaded()) {
		TinyXML::TiXmlElement l_texture("texture");
		l_texture.SetAttribute("id", m_tdata->id().str().c_str());
		n.InsertEndChild(l_texture);
	}

	/* texture coordinates */
	for (int i = 0; i < m_tcdata->count(); ++i) {
		float l_u, l_v;
		if (m_tcdata->get(i, l_u, l_v)) {
			TinyXML::TiXmlElement l_vector("tcoord");
			l_vector.SetDoubleAttribute("u", l_u);
			l_vector.SetDoubleAttribute("v", l_v);
			n.InsertEndChild(l_vector);
		} else MMWARNING("Failed to serialize text coord %d", i);
	}

	/* vertexes */
	for (int i = 0; i < m_vdata->count(); ++i) {
		float l_x, l_y;
		if (m_vdata->get(i, l_x, l_y)) {
			TinyXML::TiXmlElement l_vector("vector");
			l_vector.SetDoubleAttribute("x", l_x);
			l_vector.SetDoubleAttribute("y", l_y);
			n.InsertEndChild(l_vector);
		} else MMWARNING("Failed to serialize vertex %d", i);
	}

	return(true);
}