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()));
}
}
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 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);
}
}
void renderSolid(Renderer& renderer, const VolumeTest& volume, const Matrix4& localToWorld, bool selected) const
{
if(isModel() && selected)
{
m_renderOrigin.render(renderer, volume, localToWorld);
}
renderer.SetState(m_entity.getEntityClass().m_state_wire, Renderer::eWireframeOnly);
renderer.SetState(m_entity.getEntityClass().m_state_wire, Renderer::eFullMaterials);
if(!m_curveNURBS.m_renderCurve.m_vertices.empty())
{
renderer.addRenderable(m_curveNURBS.m_renderCurve, localToWorld);
}
if(!m_curveCatmullRom.m_renderCurve.m_vertices.empty())
{
renderer.addRenderable(m_curveCatmullRom.m_renderCurve, localToWorld);
}
}
void construct()
{
default_rotation(m_rotation);
m_keyObservers.insert("classname", ClassnameFilter::ClassnameChangedCaller(m_filter));
m_keyObservers.insert(Static<KeyIsName>::instance().m_nameKey, NamedEntity::IdentifierChangedCaller(m_named));
m_keyObservers.insert("model", Doom3Group::ModelChangedCaller(*this));
m_keyObservers.insert("origin", OriginKey::OriginChangedCaller(m_originKey));
m_keyObservers.insert("angle", RotationKey::AngleChangedCaller(m_rotationKey));
m_keyObservers.insert("rotation", RotationKey::RotationChangedCaller(m_rotationKey));
m_keyObservers.insert("name", NameChangedCaller(*this));
m_keyObservers.insert(curve_Nurbs, NURBSCurve::CurveChangedCaller(m_curveNURBS));
m_keyObservers.insert(curve_CatmullRomSpline, CatmullRomSpline::CurveChangedCaller(m_curveCatmullRom));
m_keyObservers.insert("skin", ModelSkinKey::SkinChangedCaller(m_skin));
m_traverseObservers.attach(m_funcStaticOrigin);
m_isModel = false;
m_nameKeys.setKeyIsName(keyIsNameDoom3Doom3Group);
attachTraverse();
m_entity.attach(m_keyObservers);
}
void renderSolid (Renderer& renderer, const VolumeTest& volume, const Matrix4& localToWorld) const
{
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);
renderer.addRenderable(m_aabb_solid, localToWorld);
renderArrow(renderer, volume, localToWorld);
}
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);
}
