C++ EntityKeyValues类代码示例

scene::INodePtr Quake3MapReader::createEntity(const EntityKeyValues& keyValues)
{
    // Get the classname from the EntityKeyValues
    EntityKeyValues::const_iterator found = keyValues.find("classname");

    if (found == keyValues.end())
	{
		throw FailureException("Quake3MapReader::createEntity(): could not find classname.");
    }

    // Otherwise create the entity and add all of the properties
    std::string className = found->second;
	IEntityClassPtr classPtr = GlobalEntityClassManager().findClass(className);

	if (classPtr == NULL)
	{
		rError() << "[mapdoom3]: Could not find entity class: "
			<< className << std::endl;

		// greebo: EntityClass not found, insert a brush-based one
		classPtr = GlobalEntityClassManager().findOrInsert(className, true);
	}

	// Create the actual entity node
    IEntityNodePtr node(GlobalEntityCreator().createEntity(classPtr));

    for (EntityKeyValues::const_iterator i = keyValues.begin();
         i != keyValues.end();
         ++i)
    {
        node->getEntity().setKeyValue(i->first, i->second);
    }

    return node;
}

void Quake3MapReader::parseEntity(parser::DefTokeniser& tok)
{
    // Map of keyvalues for this entity
    EntityKeyValues keyValues;

    // The actual entity. This is initially null, and will be created when
    // primitives start or the end of the entity is reached
    scene::INodePtr entity;

	// Start parsing, first token must be an open brace
	tok.assertNextToken("{");

	std::string token = tok.nextToken();

	// Reset the primitive counter, we're starting a new entity
	_primitiveCount = 0;

	while (true)
	{
	    // Token must be either a key, a "{" to indicate the start of a
	    // primitive, or a "}" to indicate the end of the entity

	    if (token == "{") // PRIMITIVE
		{ 
			// Create the entity right now, if not yet done
			if (entity == NULL)
			{
				entity = createEntity(keyValues);
			}

			// Parse the primitive block, and pass the parent entity
			parsePrimitive(tok, entity);
	    }
	    else if (token == "}") // END OF ENTITY
		{
            // Create the entity if necessary and return it
	        if (entity == NULL)
			{
	            entity = createEntity(keyValues);
	        }

			break;
	    }
	    else // KEY
		{ 
	        std::string value = tok.nextToken();

	        // Sanity check (invalid number of tokens will get us out of sync)
	        if (value == "{" || value == "}")
			{
				std::string text = (boost::format(_("Parsed invalid value '%s' for key '%s'")) % value % token).str();
	            throw FailureException(text);
	        }

	        // Otherwise add the keyvalue pair to our map
	        keyValues.insert(EntityKeyValues::value_type(token, value));
	    }

	    // Get the next token
	    token = tok.nextToken();
	}

	// Insert the entity
	_importFilter.addEntity(entity);
}

		void instanceDetach (const scene::Path& path)
		{
			if (--m_instanceCounter.m_count == 0) {
				m_entity.detach(m_keyObservers);
				m_entity.instanceDetach(path_find_mapfile(path.begin(), path.end()));
			}
		}

		void instanceAttach (const scene::Path& path)
		{
			if (++m_instanceCounter.m_count == 1) {
				m_entity.instanceAttach(path_find_mapfile(path.begin(), path.end()));
				m_traverse.instanceAttach(path_find_mapfile(path.begin(), path.end()));
				m_entity.attach(m_keyObservers);
			}
		}

		void renderSolid (Renderer& renderer, const VolumeTest& volume, const Matrix4& localToWorld, bool selected) const
		{
			if (selected) {
				m_renderOrigin.render(renderer, volume, localToWorld);
			}

			ASSERT_NOTNULL(m_entity.getEntityClass().m_state_wire);
			renderer.SetState(m_entity.getEntityClass().m_state_wire, Renderer::eWireframeOnly);
		}

		void renderSolid (Renderer& renderer, const VolumeTest& volume, const Matrix4& localToWorld) const
		{
			renderer.SetState(m_entity.getEntityClass().m_state_fill, Renderer::eFullMaterials);
			if (m_particle == NULL || !m_particle->getImage().empty())
				renderer.addRenderable(m_renderParticle, localToWorld);
			else
				renderer.addRenderable(m_renderAABBSolid, localToWorld);
		}

		void construct ()
		{
			read_aabb(m_aabb_local, m_entity.getEntityClass());

			m_keyObservers.insert("targetname", NamedEntity::IdentifierChangedCaller(m_named));
			m_keyObservers.insert("origin", OriginKey::OriginChangedCaller(m_originKey));
			m_keyObservers.insert("particle", ParticleChangedCaller(*this));
		}

		void renderWireframe (Renderer& renderer, const VolumeTest& volume, const Matrix4& localToWorld) const
		{
			renderer.SetState(m_entity.getEntityClass().m_state_wire, Renderer::eWireframeOnly);
			renderer.addRenderable(m_renderAABBWire, localToWorld);
			renderArrow(renderer, volume, localToWorld);
			if (GlobalRegistry().get("user/ui/xyview/showEntityNames") == "1") {
				renderer.addRenderable(m_renderName, localToWorld);
			}
		}

 void renderWireframe(Renderer& renderer, const VolumeTest& volume, const Matrix4& localToWorld) const
 {
   renderer.SetState(m_entity.getEntityClass().m_state_wire, Renderer::eWireframeOnly);
   renderer.addRenderable(m_aabb_wire, localToWorld);
   renderArrow(renderer, volume, localToWorld);
   if(g_showNames)
   {
     renderer.addRenderable(m_renderName, localToWorld);
   }
 }

  void construct()
  {
    read_aabb(m_aabb_local, m_entity.getEntityClass());

    m_keyObservers.insert("classname", ClassnameFilter::ClassnameChangedCaller(m_filter));
    m_keyObservers.insert(Static<KeyIsName>::instance().m_nameKey, NamedEntity::IdentifierChangedCaller(m_named));
    m_keyObservers.insert("angle", AnglesKey::AngleChangedCaller(m_anglesKey));
    m_keyObservers.insert("angles", AnglesKey::AnglesChangedCaller(m_anglesKey));
    m_keyObservers.insert("origin", OriginKey::OriginChangedCaller(m_originKey));
  }

		void renderSolid (Renderer& renderer, const VolumeTest& volume, const Matrix4& localToWorld, bool selected) const
		{
			renderer.SetState(m_entity.getEntityClass().m_state_wire, Renderer::eWireframeOnly);
			renderer.SetState(m_colour.state(), Renderer::eFullMaterials);
			renderer.addRenderable(*this, localToWorld);

			if ((entity::EntitySettings::Instance().showAllLightRadii() || (selected
					&& entity::EntitySettings::Instance().showSelectedLightRadii()))
					&& m_entity.getKeyValue("target").empty()) {
				if (renderer.getStyle() == Renderer::eFullMaterials) {
					renderer.SetState(RenderLightRadiiFill::m_state, Renderer::eFullMaterials);
					renderer.Highlight(Renderer::ePrimitive, false);
					renderer.addRenderable(m_radii_fill, localToWorld);
				} else {
					renderer.addRenderable(m_radii_wire, localToWorld);
				}
			}

			renderer.SetState(m_entity.getEntityClass().m_state_wire, Renderer::eFullMaterials);
		}

  void instanceDetach(const scene::Path& path)
  {
    if(--m_instanceCounter.m_count == 0)
    {
      m_funcStaticOrigin.disable();

      m_traverse.instanceDetach(path_find_mapfile(path.begin(), path.end()));
      m_entity.instanceDetach(path_find_mapfile(path.begin(), path.end()));
      m_filter.instanceDetach();
    }
  }

		void construct ()
		{
			read_aabb(m_aabb_local, m_entity.getEntityClass());
			m_ray.origin = m_aabb_local.origin;
			m_ray.direction[0] = 1;
			m_ray.direction[1] = 0;
			m_ray.direction[2] = 0;

			m_keyObservers.insert("targetname", NamedEntity::IdentifierChangedCaller(m_named));
			m_keyObservers.insert("angle", AngleKey::AngleChangedCaller(m_angleKey));
			m_keyObservers.insert("origin", OriginKey::OriginChangedCaller(m_originKey));
		}

  void destroy()
  {
    m_entity.detach(m_keyObservers);

    if(isModel())
    {
      detachModel();
    }
    else
    {
      detachTraverse();
    }

    m_traverseObservers.detach(m_funcStaticOrigin);
  }

		void renderWireframe (Renderer& renderer, const VolumeTest& volume, const Matrix4& localToWorld,
				const AABB& childBounds) const
		{
			renderSolid(renderer, volume, localToWorld);

			if (GlobalRegistry().get("user/ui/xyview/showEntityNames") == "1") {
				// don't draw the name for worldspawn
				if (m_entity.getEntityClass().name() == "worldspawn")
					return;

				// place name in the middle of the "children cloud"
				m_name_origin = childBounds.origin;

				renderer.addRenderable(m_renderName, localToWorld);
			}
		}