void SpritePackerHelper::EnumerateSpritesForParticleEmitter(ParticleEmitter* emitter, Map<String, Sprite *> &sprites) { if (!emitter) { return; } Vector<ParticleLayer*> & layers = emitter->GetLayers(); int32 layersCount = layers.size(); for (int il = 0; il < layersCount; ++il) { ParticleLayer* curLayer = layers[il]; Sprite *sprite = curLayer->GetSprite(); if (sprite) { sprites[sprite->GetRelativePathname().GetAbsolutePathname()] = sprite; } // Superemitter layers might have inner emitter with its own sprites. if (curLayer->GetInnerEmitter()) { EnumerateSpritesForParticleEmitter(curLayer->GetInnerEmitter(), sprites); } } }
void ParticlesEditorController::RemoveParticleForceNode(ForceParticleEditorNode* forceNode) { if (!forceNode || !forceNode->GetLayerEditorNode()) { return; } LayerParticleEditorNode* layerNode = forceNode->GetLayerEditorNode(); ParticleLayer* layer = layerNode->GetLayer(); if (!layer) { return; } // If the selected node is one to be removed - clean it up. CleanupSelectedNodeIfDeleting(forceNode); // Remove the force from the emitter... int forceIndex = forceNode->GetForceIndex(); layer->RemoveForce(forceIndex); // ...and from the tree. layerNode->RemoveChildNode(forceNode); // Done removing, recalculate the indices and names. layerNode->UpdateForcesIndices(); }
ForceParticleEditorNode* ParticlesEditorController::AddParticleForceToNode(LayerParticleEditorNode* layerNode) { if (!layerNode) { return NULL; } ParticleLayer* layer = layerNode->GetLayer(); if (!layer) { return NULL; } // Add the new Force to the Layer. ParticleForce* newForce = new ParticleForce(RefPtr<PropertyLine<Vector3> >(new PropertyLineValue<Vector3>(Vector3(0, 0, 0))), RefPtr<PropertyLine<Vector3> >(NULL), RefPtr<PropertyLine<float32> >(NULL)); layer->AddForce(newForce); // Create the node for the new layer. int newLayerIndex = layer->forces.size() - 1; ForceParticleEditorNode* forceNode = new ForceParticleEditorNode(layerNode, newLayerIndex); layerNode->AddChildNode(forceNode); // Update the names for the forces. layerNode->UpdateForcesIndices(); return forceNode; }
void ParticleEmitter::LoadParticleLayerFromYaml(YamlNode* yamlNode, bool isLong) { ParticleLayer* layer = new ParticleLayer(); AddLayer(layer); layer->LoadFromYaml(configPath, yamlNode); SafeRelease(layer); }
void ParticleEmitter3D::LoadParticleLayerFromYaml(YamlNode* yamlNode, bool isLong) { ParticleLayer* layer = NULL; if (isLong) { layer = new ParticleLayerLong(); } else { layer = new ParticleLayer3D(); } AddLayer(layer); layer->LoadFromYaml(configPath, yamlNode); SafeRelease(layer); }
void ParticlesEditorSceneModelHelper::SynchronizeInnerEmitterNode(LayerParticleEditorNode* node, SceneGraphItem* layerNodeItem, SceneGraphModel* sceneGraphModel) { if (!node) { return; } ParticleLayer* layer = node->GetLayer(); if (!layer) { return; } ParticleEmitter* innerEmitter = layer->GetInnerEmitter(); int32 innerEmittersCountInLayerNode = node->GetInnerEmittersCount(); bool needAddInnerEmitter = ((layer->type == ParticleLayer::TYPE_SUPEREMITTER_PARTICLES) && innerEmitter && (innerEmittersCountInLayerNode == 0)); if (needAddInnerEmitter) { // There is inner emitter defined, but it doesn't exist in the Layer. // Need to add it. InnerEmitterParticleEditorNode* innerEmitterEditorNode = new InnerEmitterParticleEditorNode(node); node->AddNode(innerEmitterEditorNode); // Also update the Scene Graph, if requested. if (layerNodeItem && sceneGraphModel) { SceneGraphItem* childItem = new SceneGraphItem(); childItem->SetExtraUserData(innerEmitterEditorNode); sceneGraphModel->AddNodeToTree(layerNodeItem, childItem); } return; } bool needRemoveInnerEmitter = ((layer->type != ParticleLayer::TYPE_SUPEREMITTER_PARTICLES && innerEmittersCountInLayerNode > 0)); if (needRemoveInnerEmitter) { // Update the Scene Graph, if needed. if (layerNodeItem && sceneGraphModel) { int childrenCount = layerNodeItem->ChildrenCount(); List<GraphItem*> childItemsToRemove; // Two-step pass is needed - first one is to find all the children to remove, // second one is to do actual remove. for (int i = 0; i < childrenCount; i ++) { GraphItem* childItem = layerNodeItem->Child(i); SceneGraphItem* childSceneGraphItem = dynamic_cast<SceneGraphItem*>(childItem); ExtraUserData* extraUserData = childSceneGraphItem->GetExtraUserData(); if (childSceneGraphItem && extraUserData && dynamic_cast<InnerEmitterParticleEditorNode*>(extraUserData)) { childItemsToRemove.push_back(childItem); } } for (List<GraphItem*>::iterator iter = childItemsToRemove.begin(); iter != childItemsToRemove.end(); iter ++) { GraphItem* childItem = (*iter); sceneGraphModel->RemoveNodeFromTree(layerNodeItem, childItem); } } // AFTER the Scene Graph was updated - do the actual remove. BaseParticleEditorNode::PARTICLEEDITORNODESLIST nodesToRemove; for (BaseParticleEditorNode::PARTICLEEDITORNODESLIST::const_iterator iter = node->GetChildren().begin(); iter != node->GetChildren().end(); iter ++) { if (dynamic_cast<InnerEmitterParticleEditorNode*>(*iter)) { nodesToRemove.push_back(*iter); } } for (BaseParticleEditorNode::PARTICLEEDITORNODESLIST::iterator removeIter = nodesToRemove.begin(); removeIter != nodesToRemove.end(); removeIter ++) { node->RemoveNode(*removeIter); } } }