bool Entity::addComponent( const ComponentPtr& component ) { if( !component ) return false; Class* type = component->getType(); if( componentsMap.Find(type) != componentsMap.End() ) { LogWarn( "Component '%s' already exists in '%s'", type->name, name.CString() ); return false; } componentsMap[type] = component; component->setEntity(this); onComponentAdded(component); sendEvents(); if( IsGroup(parent) ) { Group* group = (Group*) parent; group->onEntityComponentAdded(component); } components.Push(component); return true; }
bool ComponentCollection::ValidateComponent( const ComponentPtr &component, tstring& error ) const { HELIUM_ASSERT( component->GetSlot() != Reflect::ReservedTypes::Invalid ); // Check for duplicates. if ( ContainsComponent( component->GetSlot() ) ) { error = tstring( TXT( "The component '" ) )+ component->GetClass()->m_UIName + TXT( "' is a duplicate (a component already occupies that slot in the collection)." ); return false; } // Check to make sure this type of collection accepts this type of component. if ( !ValidateCompatible( component, error ) ) { return false; } // Check to make sure that each component already within the collection is valid with the new one. M_Component::const_iterator itr = m_Components.begin(); M_Component::const_iterator end = m_Components.end(); for ( ; itr != end; ++itr ) { // Check both directions so that the validation rule only has to be implemented in one place. if ( !itr->second->ValidateSibling( component, error ) || !component->ValidateSibling( itr->second.Ptr(), error ) ) { return false; } } return true; }
void ElementGroup::ProcessComponent(const ComponentPtr& component, bool removable) { bool added = AddInspector(component, component->GetType(), removable); // If there wasn't a specific inspector for the given type, try adding interface inspectors if (!added) { // Make sure the transform inspector is at the top const auto& actualInterfaces = component->GetInterfaces(); auto entry = actualInterfaces.find("ITransform"); if (entry == actualInterfaces.end()) { for (auto it = actualInterfaces.begin(), end = actualInterfaces.end(); it != end; ++it) added |= AddInspector(component, *it, removable); } else { AddInspector(component, "ITransform", false); std::set<std::string> interfacesMinusTransform = actualInterfaces; interfacesMinusTransform.erase("ITransform"); for (auto it = interfacesMinusTransform.begin(), end = interfacesMinusTransform.end(); it != end; ++it) added |= AddInspector(component, *it, removable); } } if (!added) SendToConsole("No inspector for component type: " + component->GetType()); }
ComponentCollection::ComponentCollection( const ComponentPtr& component ) { HELIUM_ASSERT( component->GetSlot() != Reflect::ReservedTypes::Invalid ); m_Components.insert( M_Component::value_type( component->GetSlot(), component ) ); component->AddChangedListener( ElementChangeSignature::Delegate::Create<ComponentCollection, void (ComponentCollection::*)( const Reflect::ElementChangeArgs& )> ( this, &ComponentCollection::ComponentChanged ) ); m_Modified = true; }
ComponentCollection::ComponentCollection( const ComponentPtr& component ) { HELIUM_ASSERT( component->GetSlot() != NULL ); m_Components.insert( M_Component::value_type( component->GetSlot(), component ) ); component->e_Changed.Add( ObjectChangeSignature::Delegate::Create<ComponentCollection, void (ComponentCollection::*)( const Reflect::ObjectChangeArgs& )> ( this, &ComponentCollection::ComponentChanged ) ); m_Modified = true; }
gluit::Size GridTransformerRendererLayout::layout(ComponentPtr component) { GridTransformerRenderer::Ptr renderer = boost::static_pointer_cast<GridTransformerRenderer>(component); const Rectangle& bounds = renderer->inputBounds; return gluit::Size::fromDouble(bounds.getWidth(), bounds.getHeight()).shrinkToFitIn( component->getMaximumSize().shrink(component->getInsets())).grow(component->getInsets()); }
bool ComponentGroup::AddComponent(ComponentPtr comp) { PROFILE(ComponentGroup_AddComponent); //Check if the component have already added to component group or it's name or type are different for the component group. if(ContainsComponent(comp) || comp->Name() != name_ || comp->TypeName() != typeName_) return false; components_.push_back(ComponentWeakPtr(comp)); editor_->AddNewComponent(comp); return true; }
ComponentPtr ComponentManager::CreateComponent(const QString &type_name, const QString &name) { ComponentFactoryMap::const_iterator iter = factories_.find(type_name); if (iter == factories_.end()) return ComponentPtr(); ComponentPtr component = (*iter->second.get())(); component->SetName(name); return component; }
ComponentItem::ComponentItem(const ComponentPtr &comp, EntityItem *parent) : QTreeWidgetItem(parent), parentItem(parent), ptr(comp), typeId(comp->TypeId()), typeName(comp->TypeName()), name(comp->Name()) { SetText(comp.get()); }
void Entity::AddComponent(component_id_t id, const ComponentPtr &component, AttributeChange::Type change) { // Must exist and be free if (component && component->ParentEntity() == 0) { if (!id) { bool authority = true; if (scene_) authority = scene_->IsAuthority(); // Loop until we find a free ID for (;;) { if (authority) id = component->IsReplicated() ? idGenerator_.AllocateReplicated() : idGenerator_.AllocateLocal(); else id = component->IsReplicated() ? idGenerator_.AllocateUnacked() : idGenerator_.AllocateLocal(); if (components_.find(id) == components_.end()) break; } } else { component->SetReplicated(id < UniqueIdGenerator::FIRST_LOCAL_ID); // If component ID is specified manually, but it already exists, it is an error. Do not add the component in that case. if (components_.find(id) != components_.end()) { LogError("Can not add component: a component with id " + QString::number(id) + " already exists in entity " + ToString()); return; } // Whenever a manual replicated ID is assigned, reset the ID generator to the highest value to avoid unnecessary free ID probing in the future if (id < UniqueIdGenerator::FIRST_LOCAL_ID) idGenerator_.ResetReplicatedId(std::max(id, idGenerator_.id)); } QString componentTypeName = component->TypeName(); componentTypeName.replace(0, 3, ""); componentTypeName = componentTypeName.toLower(); // We already have 'name' property in Entity, so ignore "EC_Name" ("name") here. if (componentTypeName != "name" && !property(componentTypeName.toStdString().c_str()).isValid()) { QVariant var = QVariant::fromValue<QObject*>(component.get()); setProperty(componentTypeName.toStdString().c_str(), var); } component->SetNewId(id); component->SetParentEntity(this); components_[id] = component; if (change != AttributeChange::Disconnected) emit ComponentAdded(component.get(), change == AttributeChange::Default ? component->UpdateMode() : change); if (scene_) scene_->EmitComponentAdded(this, component.get(), change); } }
bool ComponentCollection::ValidateCompatible( const ComponentPtr& component, tstring& error ) const { HELIUM_ASSERT( component->GetSlot() != Reflect::ReservedTypes::Invalid ); if ( component->GetComponentBehavior() == ComponentBehaviors::Exclusive ) { error = component->GetClass()->m_UIName + TXT( " cannot be added to a(n) " ) + GetClass()->m_UIName + TXT( " because it is an exclusive component." ); return false; } return true; }
bool ComponentGroup::ContainsAttribute(const QString &name) const { if(components_.empty()) return false; for(uint i = 0; i < components_.size(); i++) { ComponentPtr comp = components_[i].lock(); if(comp && comp->GetAttribute(name)) return true; } return false; }
ComponentGroup::ComponentGroup(ComponentPtr component, ECComponentEditor *editor, bool isDynamic): editor_(editor), isDynamic_(isDynamic) { assert(component); // No point to add component to editor cause it's already added in ECBrowser's AddNewComponentToGroup mehtod. if(component) { components_.push_back(ComponentWeakPtr(component)); name_ = component->Name(); typeName_ = component->TypeName(); } }
bool ComponentCollection::ValidateCompatible( const ComponentPtr& component, std::string& error ) const { HELIUM_ASSERT( component->GetSlot() != NULL ); if ( component->GetComponentBehavior() == ComponentBehaviors::Exclusive ) { error = *component->GetMetaClass()->m_Name; error += TXT( " cannot be added to a(n) " ); error += *GetMetaClass()->m_Name; error += TXT( " because it is an exclusive component." ); return false; } return true; }
void Entity::RemoveComponent(const ComponentPtr &component, AttributeChange::Type change) { if (component) { ComponentMap::iterator iter = components_.find(component->Id()); if (iter != components_.end()) { RemoveComponent(iter, change); } else { LogWarning("Failed to remove component: " + component->TypeName() + " from entity: " + QString::number(Id())); } } }
bool ComponentCollection::ValidatePersistent( const ComponentPtr& component ) const { HELIUM_ASSERT( component->GetSlot() != NULL ); // by default, all attributes are persistent return true; }
bool ExecuteComponentCallbackImpl::OnComponentExecError(const ComponentPtr& component, std::exception& ex) { ::InterlockedIncrement(& errors); std::wcout << std::endl << L"Error executing '" << component->id << L"' (" << component->GetDisplayName() << L"):" << DVLib::string2wstring(ex.what()); return true; }
bool ComponentCollection::ValidatePersistent( const ComponentPtr& component ) const { HELIUM_ASSERT( component->GetSlot() != Reflect::ReservedTypes::Invalid ); // by default, all attributes are persistent return true; }
bool Entity::removeComponent(const ComponentPtr& component) { if (!component) return false; Class* type = component->getType(); ComponentMap::Iterator it = componentsMap.Find(type); if( it == componentsMap.End() ) return false; componentsMap.Erase(it); onComponentRemoved(component); sendEvents(); if (IsGroup(parent)) { Group* group = (Group*) parent; group->onEntityComponentRemoved(component); } if (type->inherits(GeometryGetType())) getTransform()->markBoundingVolumeDirty(); return true; }
void Entity::AddComponent(ComponentPtr _pComponent) { const Key uSignature = _pComponent->GetSignature(); if (m_mComponents.end() == m_mComponents.find(uSignature)) { m_mComponents[uSignature] = _pComponent; } }
void CLRenderWorld::OnActivation(const ComponentPtr& component) { if (component->GetType() == "CLSprite") { auto sprite = boost::dynamic_pointer_cast<CLSprite>(component); if (sprite) { FSN_ASSERT(std::find(m_Drawables.begin(), m_Drawables.end(), sprite) == m_Drawables.end()); m_Drawables.push_back(sprite); m_Sprites.push_back(sprite); } } if (component->GetType() == "StreamingCamera") { if (auto camComponent = boost::dynamic_pointer_cast<StreamingCamera>(component)) { const bool shared = camComponent->GetSyncType() == ICamera::Shared; const bool synced = camComponent->GetParent()->IsSyncedEntity(); if (synced) { // Shared cameras have no owner const PlayerID owner = shared ? 0 : camComponent->GetParent()->GetOwnerID(); camComponent->m_Camera = m_CameraManager->GetCamera(camComponent->GetParent()->GetID(), owner); } else { // Attached to a pseudo-entity: create an un-synchronised camera camComponent->m_Camera = std::make_shared<Camera>(); // Unsynchronised cameras are only useful for creating viewports at the moment SendToConsole("Warning: unsynchronised camera created: cameras attached to unsynchronised entities won't cause the map to load."); } if (shared || PlayerRegistry::IsLocal(camComponent->GetParent()->GetOwnerID()) || !synced) { if (camComponent->m_ViewportEnabled) { camComponent->m_Viewport = std::make_shared<Viewport>(camComponent->m_ViewportRect, camComponent->m_Camera); AddViewport(camComponent->m_Viewport); } } m_Cameras.push_back(camComponent); } } }
QScriptValue toScriptValueComponentVector(QScriptEngine *engine, const Entity::ComponentVector &components) { QScriptValue obj = engine->newArray(); Entity::ComponentVector::const_iterator iter = components.begin(); quint32 i = 0; while(iter != components.end()) { ComponentPtr comp = (*iter); if (comp.get()) { obj.setProperty(i, engine->newQObject(comp.get())); i++; } ++iter; } return obj; }
ComponentPtr ComponentManager::CloneComponent(const ComponentPtr &component) { ComponentFactoryMap::const_iterator iter = factories_.find(component->TypeName()); if (iter == factories_.end()) return ComponentPtr(); ComponentPtr newComponent = (*iter->second.get())(component); return newComponent; }
void ComponentCollection::CopyTo(const Reflect::ElementPtr& destination) { __super::CopyTo( destination ); ComponentCollection* destCollection = Reflect::ObjectCast< ComponentCollection >( destination ); if ( destCollection ) { // Remove all attributes, we're going to bring them over manually destCollection->Clear(); // For each component in this component collection Reflect::Registry* registry = Reflect::Registry::GetInstance(); M_Component::const_iterator attrItr = m_Components.begin(); M_Component::const_iterator attrEnd = m_Components.end(); for ( ; attrItr != attrEnd; ++attrItr ) { // Create a new copy of the component and try to add it to the destination const ComponentPtr& attrib = attrItr->second; ComponentPtr destAttrib = Reflect::AssertCast< ComponentBase >( registry->CreateInstance( attrib->GetClass() ) ); if ( !CopyComponentTo( *destCollection, destAttrib, attrib ) ) { // Component could not be added to the destination collection, check sibling classes const std::set<tstring>& derived = ( registry->GetClass( attrib->GetClass()->m_Base ) )->m_Derived; std::set<tstring>::const_iterator derivedItr = derived.begin(); std::set<tstring>::const_iterator derivedEnd = derived.end(); for ( ; derivedItr != derivedEnd; ++derivedItr ) { const Reflect::Class* currentType = Reflect::Registry::GetInstance()->GetClass(*derivedItr); if ( currentType->m_TypeID != attrib->GetType() ) { destAttrib = Reflect::AssertCast< ComponentBase >( registry->CreateInstance( currentType ) ); if ( destAttrib.ReferencesObject() ) { if ( CopyComponentTo( *destCollection, destAttrib, attrib ) ) { break; } } } } } } } }
bool ComponentCollection::SetComponent(const ComponentPtr& component, bool validate, std::string* error ) { HELIUM_ASSERT( component->GetSlot() != NULL ); M_Component::const_iterator found = m_Components.find( component->GetSlot() ); if (found != m_Components.end() && found->second == component) { return true; // nothing to do, this is already in the collection } std::string errorMessage; if ( validate && !ValidateComponent( component, errorMessage ) ) { if ( error ) { std::string componentName; Helium::ConvertString( component->GetMetaClass()->m_Name, componentName ); std::string collectionName; Helium::ConvertString( GetMetaClass()->m_Name, collectionName ); *error = std::string( TXT( "Component '" ) ) + componentName + TXT( "' is not valid for collection '" ) + collectionName + TXT( "': " ) + errorMessage; } return false; } // Event args ComponentCollectionChanged args ( this, component ); // Set the component and connect the collection m_Components[ component->GetSlot() ] = component; component->SetCollection( this ); // Start caring about change to the component component->e_Changed.Add( ObjectChangeSignature::Delegate::Create<ComponentCollection, void (ComponentCollection::*)( const Reflect::ObjectChangeArgs& )> ( this, &ComponentCollection::ComponentChanged ) ); // Raise event m_Modified = true; m_ComponentAdded.Raise( args ); return true; }
bool ComponentGroup::ContainsComponent(ComponentPtr component) const { for(uint i = 0; i < components_.size(); i++) { if(components_[i].expired()) continue; if(components_[i].lock().get() == component.get()) return true; } return false; }
void I18nContext::addChild(const ComponentPtr theChild) { Container::addChild(theChild); I18nItemPtr myChild = boost::dynamic_pointer_cast<I18nItem>(theChild); if (!myChild) { throw I18nItemNotFoundException("adding child " + theChild->getName() + " to I18nContext " + getName() + " does not work because theChild is not an I18nItem", PLUS_FILE_LINE); } if (language_ != NO_LANGUAGE) { myChild->switchLanguage(language_); } }
void EC_Mesh::SetPlaceable(ComponentPtr placeable) { if (placeable && !dynamic_cast<EC_Placeable*>(placeable.get())) { LogError("Attempted to set placeable which is not " + EC_Placeable::TypeNameStatic()); return; } DetachEntity(); placeable_ = placeable; AttachEntity(); }
void Actor::AddComponent(ComponentPtr component, Component::UpdateType update) { component->Register(); if (update == Component::PostTick) { mPostTickComponents.emplace(component); } else { mPreTickComponents.emplace(component); } }
void InstallerWindow::AddComponent(const ComponentPtr& component) { htmlayout::dom::element opt = htmlayout::dom::element::create("widget", component->description.c_str()); opt["type"] = L"checkbox"; opt["id"] = component->id.GetValue().c_str(); opt["component_ptr"] = DVLib::towstring(get(component)).c_str(); if (component->checked) opt["checked"] = L"true"; if (component->disabled) opt["disabled"] = L"true"; opt["installed"] = (component->installed ? L"true" : L"false"); opt["required"] = (component->IsRequired() ? L"true" : L"false"); htmlayout::queue::push(new html_insert_task(& components, opt, html_insert_task::last), HtmlWindow::s_hwnd); }