void SceneSyncState::AddPendingEntity(entity_id_t id) { if (!isServer_) return; if (scene_.expired()) return; ScenePtr scenePtr = scene_.lock(); if (!scenePtr.get()) { LogError("SceneSyncState::FillPendingComponents(id): Scene is null!"); return; } EntityPtr entityPtr = scenePtr->GetEntity(id); if (!entityPtr.get()) { LogError("SceneSyncState::FillPendingComponents(id): Entity is null, cannot fill components!"); return; } if (entityPtr->Components().empty()) return; if (!HasPendingEntity(id)) pendingEntities_.push_back(id); }
void Test::Update(float dt) { switch (DemoToUse) { case(Demo::Pretzel) : PretzelDemo(dt); break; case(Demo::FireBall) : FireBallDemo(dt); break; case Demo::Explosion: ExplosionDemo(200); break; default: break; } // This is wrapped in a try catch block because it's possible the entity acquired by name doesn't have the necessary components. // If that is the case, the try block will encounter and exception, that gets handled by just ignoring the operation and moving on. try { EntityPtr mouse = ENGINE->GetActiveSpace()->GetEntityByName("Mouse"); mouse->GET_COMPONENT(Transform)->position = GETSYS(WindowSDL)->GetMousePosition(); mouse->GET_COMPONENT(Transform)->scale = { 10.f, 10.f }; } catch (...) { } }
vector<EntityPtr> WorldEntityManager::FindEntitiesInRange(unsigned long componentMask, Vector3 center, float range) { SyncRegions(center, m_entityRegionWidth); vector<EntityPtr> results; Rectangle searchArea = Rectangle(center.x - range, center.z - range, range * 2, range * 2); // Filter by position for (auto & entityID : m_quadTree.Find(searchArea)) { EntityPtr entity; if (Find(entityID, entity)) { // Filter by mask if (entity->HasComponents(componentMask)) { results.push_back(entity); } } } return results; /*auto entities = FindEntities(componentMask | ComponentMask("Position")); vector<EntityPtr> finalSet; for (auto & entity : entities) { if (Vector3::Distance(entity->GetComponent<Components::Position>("Position")->Pos, center) <= range) { finalSet.push_back(entity); } } return finalSet;*/ }
void Test::SendMsg(EntityPtr e1, EntityPtr e2, Message::Message message) { EntityPtr camera = ENGINE->GetSpace("Particle Demo")->GetCamera(); switch (message) { case(Message::MV_Up) : camera->GET_COMPONENT(Transform)->position.y += 1000.f * ENGINE->Getdt(); break; case(Message::MV_Down) : camera->GET_COMPONENT(Transform)->position.y -= 1000.f * ENGINE->Getdt(); break; case(Message::MV_Left) : camera->GET_COMPONENT(Transform)->position.x -= 1000.f * ENGINE->Getdt(); break; case(Message::MV_Right) : camera->GET_COMPONENT(Transform)->position.x += 1000.f * ENGINE->Getdt(); break; case(Message::MV_BackButton) : ENGINE->PushGamestate(PauseMenuPtr(new PauseMenu())); break; case(Message::MV_PopGamestate) : ENGINE->PopGamestate(); break; default: break; } }
void EntityPalette::Destroy( EntityPtr entity ) { entity->Remove(); EntityMap::iterator it = mEntites.find(entity->GetName()); if (it != mEntites.end()) mEntites.erase(it); }
void Move::OnUpdate(float elapsedTime) { EntityPtr e = GetEntity(); float ds = 1.0f; Vector2 v(cos(mAngle) * mSpeed * ds , sin(mAngle) * mSpeed * ds); b2Body* body = ((Box2DBody*)e->GetBody())->GetBox2DBody(); //body->SetLinearVelocity(v); v.x *= body->GetMass() * 10; v.y *= body->GetMass() * 10; body->ApplyForce(v, e->GetPosition()); Vector2 cv = body->GetLinearVelocity(); float fv = abs(cv.Length()); if (fv > abs(mSpeed) && fv > 0.00001) { cv.x *= abs(mSpeed) / fv; cv.y *= abs(mSpeed) / fv; body->SetLinearVelocity(cv); } }
void EntityManager::HandlePacket(Packets::Inbound::SpawnGlobalEntityPacket* packet) { EntityId eid = packet->GetEntityId(); EntityPtr entity = std::make_shared<Entity>(eid); m_Entities[eid] = entity; entity->SetPosition(packet->GetPosition()); }
EntityListWidgetItem *ECEditorWindow::AddEntity(entity_id_t entity_id, bool udpate_ui) { EntityListWidgetItem *item = 0; PROFILE(ECEditorWindow_AddEntity); if (entityList) { entityList->blockSignals(true); //If entity don't have EC_Name then entity_name is same as it's id. QString entity_name = QString::number(entity_id); EntityPtr entity = framework->Scene()->MainCameraScene()->GetEntity(entity_id); if (entity && entity->GetComponent<EC_Name>()) entity_name.append(" " + entity->Name()); int row = AddUniqueListItem(entity, entityList, entity_name); item = dynamic_cast<EntityListWidgetItem *>(entityList->item(row)); assert(item); entityList->blockSignals(false); } if (udpate_ui) RefreshPropertyBrowser(); return item; }
AssetClassPtr MeshAssetFactory::Create( const Helium::Path& path ) { Helium::Path assetPath = path; assetPath.ReplaceExtension( TXT( "entity.nrb" ) ); if ( assetPath.Exists() ) { return AssetClass::LoadAssetClass( assetPath ); } EntityPtr entity = new Entity(); entity->SetPath( path.Filename() ); // we're dropping this guy relative to the data file MeshProcessingComponentPtr meshProcessingComponent = new MeshProcessingComponent(); entity->SetComponent( meshProcessingComponent ); try { Reflect::Archive::ToFile( entity, assetPath ); entity->SetSerializationPath( assetPath ); } catch( Helium::Exception& ) { delete entity; return NULL; } return entity; }
/// Create an entity within this slice and store it in the entity list. /// /// @param[in] pType Type of entity to create. /// @param[in] rPosition EntityDefinition position. /// @param[in] rRotation EntityDefinition rotation. /// @param[in] rScale EntityDefinition scale. /// @param[in] pTemplate Template from which to create the entity. /// @param[in] name Object name to assign to the entity, or a null name to automatically generate a /// name based on the entity type. /// @param[in] bAssignInstanceIndex True to assign an instance index to the entity, false to not include an /// instance index. /// /// @return Pointer to the entity instance if created successfully, null if not. /// /// @see DestroyEntity() Entity* Slice::CreateEntity(EntityDefinition *pEntityDefinition, ParameterSet *pParameterSet) { HELIUM_ASSERT( pEntityDefinition ); if( !pEntityDefinition ) { HELIUM_TRACE( TraceLevels::Error, TXT( "Slice::CreateEntity(): EntityDefinition is NULL.\n" ) ); return NULL; } EntityPtr entity = pEntityDefinition->CreateEntity(); HELIUM_ASSERT( entity.Get() ); if (!entity) { HELIUM_TRACE( TraceLevels::Error, TXT( "Slice::CreateEntity(): Call to EntityDefinition::CreateEntity failed.\n" ) ); return NULL; } size_t sliceIndex = m_entities.Push( entity ); HELIUM_ASSERT( IsValid( sliceIndex ) ); entity->SetSliceInfo( this, sliceIndex ); pEntityDefinition->FinalizeEntity(entity, pParameterSet); return entity.Get(); }
bool SceneSyncState::FillRequest(entity_id_t id) { changeRequest_.Reset(id); if (scene_.expired()) return false; ScenePtr scenePtr = scene_.lock(); if (!scenePtr.get()) { LogError("SceneSyncState::FillRequest(id): Scene is null!"); return false; } EntityPtr entityPtr = scenePtr->GetEntity(id); if (!entityPtr.get()) return false; // We trust the SyncManager mechanisms to stop local entities from ever getting here. // Print anyways if something starts to leak so at least we notice it here. if (!entityPtr->IsReplicated()) LogError("SceneSyncState::FillRequest(id): Entity " + QString::number(id) + " should not be replicated!"); changeRequest_.SetEntity(entityPtr.get()); return true; }
static duk_ret_t EntityReference_LookupParent_Entity(duk_context* ctx) { EntityReference* thisObj = GetThisValueObject<EntityReference>(ctx, EntityReference_ID); Entity* entity = GetWeakObject<Entity>(ctx, 0); EntityPtr ret = thisObj->LookupParent(entity); PushWeakObject(ctx, ret.Get()); return 1; }
EntityPtr Entity::clone() const { EntityPtr cloned = this->createCloneInstance(); cloned->copyComponents(this); cloned->copyProperties(this); return cloned; }
static duk_ret_t EntityReference_Lookup_Scene(duk_context* ctx) { EntityReference* thisObj = GetThisValueObject<EntityReference>(ctx, EntityReference_ID); Scene* scene = GetWeakObject<Scene>(ctx, 0); EntityPtr ret = thisObj->Lookup(scene); PushWeakObject(ctx, ret.Get()); return 1; }
void EntityManager::HandlePacket(Packets::Inbound::SpawnMobPacket* packet) { EntityId eid = packet->GetEntityId(); EntityPtr entity = std::make_shared<Entity>(eid); m_Entities[eid] = entity; entity->SetPosition(Vector3d(packet->GetX(), packet->GetY(), packet->GetZ())); NotifyListeners(&EntityListener::OnEntitySpawn, entity); }
EntityItem::EntityItem(const EntityPtr &entity, EntityGroupItem *parentItem) : QTreeWidgetItem(parentItem), ptr(entity), id(entity->Id()) { if (parentItem) parentItem->AddEntityItem(this); SetText(entity.get()); }
EntityItem::EntityItem(const EntityPtr &entity, EntityGroupItem *parent) : ptr(entity), id(entity->Id()), parentItem(parent) { if (parentItem) { parentItem->numberOfEntities++; parentItem->UpdateText(); } SetText(entity.get()); }
void TagManager::remove(EntityPtr e) { std::map<EntityId, TagId>::iterator enti = tag_by_entity_.find(e->get_id()); if( enti != tag_by_entity_.end() ) { tag_by_entity_.erase(e->get_id()); entity_by_tag_.erase(enti->second); } }
void EntityManager::HandlePacket(Packets::Inbound::SpawnObjectPacket* packet) { EntityId eid = packet->GetEntityId(); EntityPtr entity = std::make_shared<Entity>(eid); m_Entities[eid] = entity; entity->SetPosition(ToVector3d(packet->GetPosition())); entity->SetYaw(packet->GetYaw() / 256.0f * TAU); entity->SetPitch(packet->GetPitch() / 256.0f * TAU); NotifyListeners(&EntityListener::OnObjectSpawn, entity); }
void Move::OnDone() { if (mChannel) Engine::GetSingleton()->GetSoundSystem()->StopChannel(mChannel); EntityPtr e = GetEntity(); Vector2 v(0.0f, 0.0f); if (e != 0) e->GetBody()->SetLinearVelocity(v); }
void Entity::Render( float ticks ) throw(std::exception) { DoUpdate(ticks); glPushMatrix(); glMultMatrixf( GetRenderState()->GetMatrix() ); uint32_t flags = GetRenderState()->GetFlags(); int gl_blend_src(0), gl_blend_dst(0); int alpha_enabled; glGetIntegerv(GL_ALPHA_TEST, &alpha_enabled); if (!alpha_enabled && (flags & RenderState::ALPHA_F) ) { glGetIntegerv(GL_BLEND_SRC, &gl_blend_src); glGetIntegerv(GL_BLEND_DST, &gl_blend_dst); glBlendFunc( GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); glEnable(GL_ALPHA_TEST); } else if (alpha_enabled && (flags & RenderState::ALPHA_F) == 0 ) { glDisable(GL_ALPHA_TEST); } int blend_enabled; glGetIntegerv(GL_BLEND, &blend_enabled); if (!blend_enabled && (flags & RenderState::BLEND_F) ) { glEnable(GL_BLEND); } else if ( blend_enabled && (flags & RenderState::BLEND_F) == 0 ) { glDisable(GL_BLEND); } for( auto it = m_RenderList.begin(); it != m_RenderList.end(); ) { EntityPtr entity = *it; if ( entity->AreFlagsSet( Entity::F_ENABLE ) ) { entity->Render( ticks ); } if ( entity->AreFlagsSet( Entity::F_DELETE ) ) { it = m_RenderList.erase( it ); continue; } ++it; } DoRender(); if (!alpha_enabled && (flags & RenderState::ALPHA_F) ) { glBlendFunc( gl_blend_src, gl_blend_dst); } glPopMatrix(); }
Rocket::Core::DecoratorDataHandle DynamicEntityDecorator::GenerateElementData(Rocket::Core::Element* element) { std::string entityName = std::string(element->GetAttribute("entity_name", Rocket::Core::String()).CString()); EntityPtr entity = m_EntityManager->GetEntity(entityName); if (entity) { m_UsedEntities.insert(entity); return (Rocket::Core::DecoratorDataHandle)entity.get(); } return 0; }
void Entity::Render( int pass ) throw(std::exception) { glPushMatrix(); glMultMatrixf( GetRenderState()->GetMatrix() ); uint32_t flags = GetRenderState()->GetFlags(); int glBlendSrc(0), glBlendDst(0); int alphaEnabled; glGetIntegerv(GL_ALPHA_TEST, &alphaEnabled); if (!alphaEnabled && (flags & RenderState::ALPHA_F) ) { glGetIntegerv(GL_BLEND_SRC, &glBlendSrc); glGetIntegerv(GL_BLEND_DST, &glBlendDst); glBlendFunc( GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); glEnable(GL_ALPHA_TEST); } else if (alphaEnabled && (flags & RenderState::ALPHA_F) == 0 ) { glDisable(GL_ALPHA_TEST); } int blendEnabled; glGetIntegerv(GL_BLEND, &blendEnabled); if (!blendEnabled && (flags & RenderState::BLEND_F) ) { glEnable(GL_BLEND); } else if ( blendEnabled && (flags & RenderState::BLEND_F) == 0 ) { glDisable(GL_BLEND); } // render all children for( auto it = m_RenderList.begin(); it != m_RenderList.end(); ) { EntityPtr entity = *it; if ( entity->IsFlagSet( Entity::F_ENABLE|Entity::F_VISIBLE ) && !entity->IsFlagSet( Entity::F_DELETE ) ) { // don't bother rendering if we are marked for deletion entity->Render( pass ); } ++it; } DoRender( pass ); if (!alphaEnabled && (flags & RenderState::ALPHA_F) ) { glBlendFunc( glBlendSrc, glBlendDst); } glPopMatrix(); }
void Entity::CheckDestroy( ) throw(std::exception) { for( auto it = m_RenderList.begin(); it != m_RenderList.end(); ) { EntityPtr entity = *it; // Process children first entity->CheckDestroy(); // removed from list if ( entity->IsFlagSet( Entity::F_DELETE ) ) { it = m_RenderList.erase( it ); continue; } ++it; } }
Light::Light(const EntityPtr &owner, const RenderSystemPtr &render_system, const std::string &name) : Component(owner, name) , render_system(render_system) { world_matrix_property = owner->add(GM_PROPERTY_WORLD_MATRIX, glm::mat4(1)); radius_property = owner->add(GM_PROPERTY_RADIUS, 0.0f); material_color_diffuse_property = owner->add(GM_PROPERTY_MATERIAL_COLOR_DIFFUSE, glm::vec3(1)); material_color_specular_property = owner->add(GM_PROPERTY_MATERIAL_COLOR_SPECULAR, glm::vec3(1)); material_color_ambient_property = owner->add(GM_PROPERTY_MATERIAL_COLOR_AMBIENT, glm::vec3(1)); activated_property = owner->add<bool>(GM_PROPERTY_ACTIVATED, true); shadow_caster_property = owner->add<bool>(GM_PROPERTY_SHADOW_CASTER, false); render_system->add_light(this); }
void Buffered::Render( float ticks ) { // backup viewport GLint vp[4]; glGetIntegerv( GL_VIEWPORT, vp ); GLfloat depth[2]; glGetFloatv( GL_DEPTH_RANGE, depth ); // backup projection matrix for internal storage Matrix modelview; glGetFloatv( GL_MODELVIEW_MATRIX, (float*)modelview ); Matrix projection; glGetFloatv( GL_PROJECTION_MATRIX, (float*)projection ); m_FrameBuffer.Enable(); // background color glClearColor( 1,1,1,1 ); // clear buffer glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT ); for( auto it = m_RenderList.begin(); it != m_RenderList.end(); ) { EntityPtr entity = *it; if ( entity->AreFlagsSet( Entity::F_ENABLE ) ) { entity->Render(ticks); } if ( entity->AreFlagsSet( Entity::F_DELETE ) ) { it = m_RenderList.erase( it ); continue; } ++it; } m_FrameBuffer.Disable(); // restore view port glViewport( vp[0], vp[1], vp[2], vp[3]); glMatrixMode(GL_PROJECTION); glLoadMatrixf( projection ); glMatrixMode(GL_MODELVIEW); glLoadMatrixf( modelview ); DoUpdate( ticks ); // render local list into texture glPushMatrix(); glMultMatrixf(GetRenderState()->GetMatrix()); Cube::DoRender(); glPopMatrix(); }
void EntityManager::RegisterEntity(EntityPtr _entity) { _entity->SetID(m_id_count); m_entities.push_back(_entity); m_id_count++; }
bool frts::HarvestJob::checkSpecialRequirements(const EntityPtr& entity, const SharedManagerPtr& shared) const { assert(entity != nullptr); assert(shared != nullptr); // Is the entity movable? if (!entity->hasComponent(shared->makeId(ComponentIds::movable()))) { return false; } // Does a free neighbor exist? auto rm = getDataValue<RegionManager>(shared, ModelIds::regionManager()); auto pos = rm->getPos(toHarvest, shared); // Null means that toHarvest is already removed. This is handled in the execution so let's just // go there. if (pos != nullptr) { auto blockedBy = getComponent<BlockedBy>(shared->makeId(ComponentIds::blockedBy()), entity); if(rm->findFreeNeighbors(pos, blockedBy, true, shared).empty()) { return false; } } // Nope everything ok. return true; }
void World::addEntity(EntityPtr entity) { assert(entity != nullptr); assert(entity->getWorld() == nullptr); assert(std::find(newEntityList.begin(), newEntityList.end(), entity) == newEntityList.end() && "This entity is being added (queued)!"); assert(std::find(activeEntityList.begin(), activeEntityList.end(), entity) == activeEntityList.end() && "This entity has already been added!"); newEntityList.push_back(entity); }
void World::removeEntity(EntityPtr entity) { assert(entity != nullptr); assert(entity->getWorld() == shared_from_this()); assert(std::find(deadEntityList.begin(), deadEntityList.end(), entity) == deadEntityList.end() && "This entity is being removed (queued)!"); assert(std::find(activeEntityList.begin(), activeEntityList.end(), entity) != activeEntityList.end() && "This entity doesn't exist in this world!"); deadEntityList.push_back(entity); }