EntityVector GraphicsWorld::VisibleEntities() const
{
EntityVector ret;
for (HashSet<EntityWeakPtr>::ConstIterator i = visibleEntities_.Begin(); i != visibleEntities_.End(); ++i)
{
if (*i)
ret.Push(i->Lock());
}
return ret;
}
EntityVector Serializer::deserialize()
{
EntityVector entities;
QDomNodeList nodes = mDomElement.elementsByTagName(nodeKey);
for (unsigned i = 0; i < nodes.length(); i++)
{
QDomNode node = nodes.at(i);
QDomElement element = node.toElement();
Entity entity = parseNode(element);
entities.push_back(entity);
}
return entities;
}
EntityVector Placeable::Grandchildren(Entity *entity) const
{
EntityVector ret;
if (!entity)
return ret;
if (!entity->Component<Placeable>())
return ret;
EntityVector children = entity->Component<Placeable>()->Children();
foreach(const EntityPtr &e, children)
{
EntityVector grandchildren = Grandchildren(e.Get());
ret.Push(grandchildren);
}
void Game::killDeadEntities(){
EntityVector entities;
for (EntityVector::iterator i = mEntities.begin(); i != mEntities.end(); i++)
{
Entity *entity = *i;
if (entity->isAlive()) {
entities.push_back(entity);
}
else{
delete entity;
}
}
mEntities = entities;
}
stk::topology get_subcell_nodes(const BulkData& mesh, const Entity entity,
EntityRank subcell_rank,
unsigned subcell_identifier,
EntityVector & subcell_nodes)
{
ThrowAssert(subcell_rank <= stk::topology::ELEMENT_RANK);
subcell_nodes.clear();
// get cell topology
stk::topology celltopology = mesh.bucket(entity).topology();
//error checking
{
//no celltopology defined
if(celltopology == stk::topology::INVALID_TOPOLOGY)
{
return celltopology;
}
// valid ranks fall within the dimension of the cell topology
const bool bad_rank = subcell_rank >= celltopology.dimension();
ThrowInvalidArgMsgIf( bad_rank, "subcell_rank is >= celltopology dimension\n");
// subcell_identifier must be less than the subcell count
const bool bad_id = subcell_identifier >= celltopology.num_sub_topology(subcell_rank);
ThrowInvalidArgMsgIf( bad_id, "subcell_id is >= subcell_count\n");
}
// Get the cell topology of the subcell
stk::topology subcell_topology =
celltopology.sub_topology(subcell_rank, subcell_identifier);
const int num_nodes_in_subcell = subcell_topology.num_nodes();
// For the subcell, get it's local nodes ids
std::vector<unsigned> subcell_node_local_ids(num_nodes_in_subcell);
celltopology.sub_topology_node_ordinals(subcell_rank, subcell_identifier, subcell_node_local_ids.begin());
Entity const *node_relations = mesh.begin_nodes(entity);
subcell_nodes.reserve(num_nodes_in_subcell);
for(int i = 0; i < num_nodes_in_subcell; ++i)
{
subcell_nodes.push_back(node_relations[subcell_node_local_ids[i]]);
}
return subcell_topology;
}
EntityVector GraphicsWorld::FrustumQuery(const Urho3D::IntRect &viewrect) const
{
URHO3D_PROFILE(GraphicsWorld_FrustumQuery);
EntityVector ret;
Camera* cameraComp = renderer_->MainCameraComponent();
if (!cameraComp || cameraComp->ParentScene() != scene_)
return ret;
Urho3D::Camera* cam = cameraComp->UrhoCamera();
if (!cam)
return ret;
int width = renderer_->WindowWidth();
int height = renderer_->WindowHeight();
float w = (float)width;
float h = (float)height;
float left = (float)(viewrect.left_) / w, right = (float)(viewrect.right_) / w;
float top = (float)(viewrect.top_) / h, bottom = (float)(viewrect.bottom_) / h;
if (left > right) std::swap(left, right);
if (top > bottom) std::swap(top, bottom);
// don't do selection if box is too small
if ((right - left) * (bottom - top) < 0.0001)
return ret;
Urho3D::Frustum fr;
fr.vertices_[0] = cam->ScreenToWorldPoint(Urho3D::Vector3(right, top, cam->GetNearClip()));
fr.vertices_[1] = cam->ScreenToWorldPoint(Urho3D::Vector3(right, bottom, cam->GetNearClip()));
fr.vertices_[2] = cam->ScreenToWorldPoint(Urho3D::Vector3(left, bottom, cam->GetNearClip()));
fr.vertices_[3] = cam->ScreenToWorldPoint(Urho3D::Vector3(left, top, cam->GetNearClip()));
fr.vertices_[4] = cam->ScreenToWorldPoint(Urho3D::Vector3(right, top, cam->GetFarClip()));
fr.vertices_[5] = cam->ScreenToWorldPoint(Urho3D::Vector3(right, bottom, cam->GetFarClip()));
fr.vertices_[6] = cam->ScreenToWorldPoint(Urho3D::Vector3(left, bottom, cam->GetFarClip()));
fr.vertices_[7] = cam->ScreenToWorldPoint(Urho3D::Vector3(left, top, cam->GetFarClip()));
fr.UpdatePlanes();
Urho3D::PODVector<Urho3D::Drawable*> result;
Urho3D::FrustumOctreeQuery query(result, fr, Urho3D::DRAWABLE_GEOMETRY);
urhoScene_->GetComponent<Urho3D::Octree>()->GetDrawables(query);
for (Urho3D::PODVector<Urho3D::Drawable*>::ConstIterator i = result.Begin(); i != result.End(); ++i)
{
Entity* entity = static_cast<Entity*>((*i)->GetNode()->GetVar(entityLink).GetPtr());
if (entity)
ret.Push(EntityPtr(entity));
}
return ret;
}
bool Placeable::IsGrandparentOf(Entity *entity) const
{
if (!entity)
{
LogError("Placeable::IsGrandParentOf: called with null pointer.");
return false;
}
if (!ParentEntity())
return false;
if (entity == ParentEntity())
return true;
EntityVector allChildren = Grandchildren(ParentEntity());
EntityVector::ConstIterator iter = allChildren.Find(EntityPtr(entity));
return iter != allChildren.End();
}
void Game::removeDeadEntities()
{
//Remove each entity that returns isAlive() = false
EntityVector entities;
for (EntityVector::iterator i = mEntities.begin(); i != mEntities.end(); i++)
{
Entity *entity = *i;
if (entity->isAlive())
{
entities.push_back(entity);
}
else
{
if (entity != ship)
{
delete entity;
}
}
}
mEntities = entities;
}
void System::detach()
{
typedef std::vector< Entity* > EntityVector;
EntityVector entitiesToDetach;
for ( SystemMap::iterator i( theSystemMap.begin() ),
e( theSystemMap.end() );
i != e; ++i )
{
entitiesToDetach.push_back( ( *i ).second );
}
for ( ProcessMap::iterator i( theProcessMap.begin() ),
e( theProcessMap.end() );
i != e; ++i )
{
entitiesToDetach.push_back( ( *i ).second );
}
for ( VariableMap::iterator i( theVariableMap.begin() ),
e( theVariableMap.end() );
i != e; ++i )
{
entitiesToDetach.push_back( ( *i ).second );
}
for ( EntityVector::iterator i( entitiesToDetach.begin() ),
e( entitiesToDetach.end() );
i != e; ++i )
{
( *i )->detach();
}
if ( theStepper )
{
try { theStepper->unregisterSystem( this ); } catch ( NotFound const& ) {}
theStepper = 0;
}
theSizeVariable = 0;
Entity::detach();
}
TEST(UnitTestingOfBulkData, test_other_ghosting_2)
{
//
// testing if modification flags propagate properly for ghosted entities
//
// To test this, we focus on a single node shared on 2 procs, ghosted on others
//
/**
* 1D Mesh (node,owner)--[elem,owner]---(...)
*
* <---(70,0)--[500,0]--(41,1)--[301,1]---(42,2)---[402,2]---(70,0)--->
*
* <---(50,0)--[100,0]--(21,1)--[201,1]---(32,2)---[302,2]---(50,0)--->
*
*/
// elem, node0, node1, owner
EntityId elems_0[][4] = { {100, 21, 50, 0}, {201, 21, 32, 1}, {302, 32, 50, 2},
{500, 41, 70, 0}, {301, 41, 42, 1}, {402, 42, 70, 2} };
// node, owner
EntityId nodes_0[][2] = { {21,1}, {50,0}, {32, 2}, {41, 1}, {42, 1}, {70, 0} };
unsigned nelems = sizeof(elems_0)/4/sizeof(EntityId);
unsigned nnodes = sizeof(nodes_0)/2/sizeof(EntityId);
stk::ParallelMachine pm = MPI_COMM_WORLD;
// Set up meta and bulk data
const unsigned spatial_dim = 2;
std::vector<std::string> entity_rank_names = stk::mesh::entity_rank_names();
entity_rank_names.push_back("FAMILY_TREE");
MetaData meta_data(spatial_dim, entity_rank_names);
//Part & part_tmp = meta_data.declare_part( "temp");
meta_data.commit();
BulkData mesh(meta_data, pm);
//BulkData mesh(MetaData::get_meta_data(meta_data), pm);
int p_rank = mesh.parallel_rank();
int p_size = mesh.parallel_size();
if (p_size != 3) return;
//
// Begin modification cycle so we can create the entities and relations
//
// We're just going to add everything to the universal part
stk::mesh::PartVector empty_parts;
// Create elements
const EntityRank elem_rank = stk::topology::ELEMENT_RANK;
Entity elem = Entity();
mesh.modification_begin();
for (unsigned ielem=0; ielem < nelems; ielem++)
{
if (static_cast<int>(elems_0[ielem][3]) == p_rank)
{
elem = mesh.declare_entity(elem_rank, elems_0[ielem][0], empty_parts);
EntityVector nodes;
// Create node on all procs
nodes.push_back( mesh.declare_entity(NODE_RANK, elems_0[ielem][2], empty_parts) );
nodes.push_back( mesh.declare_entity(NODE_RANK, elems_0[ielem][1], empty_parts) );
// Add relations to nodes
mesh.declare_relation( elem, nodes[0], 0 );
mesh.declare_relation( elem, nodes[1], 1 );
}
}
mesh.modification_end();
Entity node1 = Entity();
// change node owners
mesh.modification_begin();
std::vector<EntityProc> change;
for (unsigned inode=0; inode < nnodes; inode++)
{
node1 = mesh.get_entity(stk::topology::NODE_RANK, nodes_0[inode][0]);
if (mesh.is_valid(node1) && mesh.parallel_owner_rank(node1) == p_rank)
{
int dest = nodes_0[inode][1];
EntityProc eproc(node1, dest);
change.push_back(eproc);
}
}
mesh.change_entity_owner( change );
mesh.modification_end();
checkBuckets(mesh);
MPI_Barrier(MPI_COMM_WORLD);
// attempt to delete a node and its elems but on a ghosted proc
mesh.modification_begin();
if (p_rank == 2)
{
node1 = mesh.get_entity(stk::topology::NODE_RANK, 21);
Entity elem1 = mesh.get_entity(stk::topology::ELEMENT_RANK, 201);
Entity elem2 = mesh.get_entity(stk::topology::ELEMENT_RANK, 100);
bool did_it_elem = mesh.destroy_entity(elem1);
did_it_elem = did_it_elem & mesh.destroy_entity(elem2);
ASSERT_TRUE(did_it_elem);
bool did_it = mesh.destroy_entity(node1);
ASSERT_TRUE(did_it);
}
mesh.modification_end();
checkBuckets(mesh);
// this node should no longer exist anywhere
node1 = mesh.get_entity(stk::topology::NODE_RANK, 21);
// uncomment to force failure of test
// ASSERT_TRUE(node1 == 0);
}
TEST ( UnitTestBulkData_new , testGhostHandleRemainsValidAfterRefresh )
{
//
// Testing if a handle to a ghosted entity remains valid before and after a
// modification cycle in which the ghost is refreshed.
//
// To test this, we focus on a single node shared on 2 procs, ghosted on others
//
//
// 1D Mesh (node,owner)--[elem,owner]---(...)
//
// <---(50,0)--[100,0]--(21,1)--[201,1]---(32,2)---[302,2]---(50,0)--->
//
// elem, node0, node1, owner
EntityId elems_0[][4] = { {100, 21, 50, 0}, {201, 21, 32, 1}, {302, 32, 50, 2} };
// node, owner
EntityId nodes_0[][2] = { {21,1}, {50,0}, {32, 2} };
const unsigned nelems = sizeof(elems_0)/4/sizeof(EntityId);
const unsigned nnodes = sizeof(nodes_0)/2/sizeof(EntityId);
stk::ParallelMachine pm = MPI_COMM_WORLD;
// Set up meta and bulk data
const unsigned spatial_dim = 2;
std::vector<std::string> entity_rank_names = stk::mesh::entity_rank_names();
entity_rank_names.push_back("FAMILY_TREE");
MetaData meta_data(spatial_dim, entity_rank_names);
//Part & part_tmp = meta_data.declare_part( "temp");
meta_data.commit();
unsigned max_bucket_size = 1;
BulkData mesh(meta_data, pm, max_bucket_size);
//BulkData mesh(MetaData::get_meta_data(meta_data), pm);
int p_rank = mesh.parallel_rank();
int p_size = mesh.parallel_size();
if (p_size != 3) return;
//
// Begin modification cycle so we can create the entities and relations
//
{
// We're just going to add everything to the universal part
PartVector empty_parts;
// Create elements
const EntityRank elem_rank = stk::topology::ELEMENT_RANK;
Entity elem = Entity();
mesh.modification_begin();
for (unsigned ielem=0; ielem < nelems; ielem++) {
if (static_cast<int>(elems_0[ielem][3]) == p_rank) {
elem = mesh.declare_entity(elem_rank, elems_0[ielem][0], empty_parts);
EntityVector nodes;
// Create node on all procs
nodes.push_back( mesh.declare_entity(stk::topology::NODE_RANK, elems_0[ielem][2], empty_parts) );
nodes.push_back( mesh.declare_entity(stk::topology::NODE_RANK, elems_0[ielem][1], empty_parts) );
// Add relations to nodes
mesh.declare_relation( elem, nodes[0], 0 );
mesh.declare_relation( elem, nodes[1], 1 );
}
}
mesh.modification_end();
}
// change node owners
{
mesh.modification_begin();
std::vector<EntityProc> change;
for (unsigned inode=0; inode < nnodes; inode++) {
Entity node = mesh.get_entity(stk::topology::NODE_RANK, nodes_0[inode][0]);
if (mesh.is_valid(node) && mesh.parallel_owner_rank(node) == p_rank) {
int dest = nodes_0[inode][1];
EntityProc eproc(node, dest);
change.push_back(eproc);
}
}
mesh.change_entity_owner( change );
mesh.modification_end();
}
// The real test is here
{
Entity node_21_handle_before_elem_deletion = mesh.get_entity(stk::topology::NODE_RANK, 21);
if (p_rank == 2) {
ASSERT_TRUE(mesh.in_receive_ghost(mesh.entity_key(node_21_handle_before_elem_deletion)));
}
// attempt to delete a node and its elems but on a ghosted proc
mesh.modification_begin();
Entity elem = mesh.get_entity(stk::topology::ELEMENT_RANK, 100);
if (mesh.is_valid(elem)) mesh.destroy_entity(elem);
mesh.modification_end();
// Key check is here
if (p_rank == 2) {
ASSERT_TRUE(mesh.is_valid(node_21_handle_before_elem_deletion));
}
}
}