void ParticleEffectComponent::Restart()
{
int32 childrenCount = entity->GetChildrenCount();
for (int32 i = 0; i < childrenCount; i ++)
{
RenderComponent * component = static_cast<RenderComponent*>(entity->GetChild(i)->GetComponent(Component::RENDER_COMPONENT));
if(component && component->GetRenderObject() && component->GetRenderObject()->GetType() == RenderObject::TYPE_PARTICLE_EMTITTER)
{
ParticleEmitter * emitter = static_cast<ParticleEmitter*>(component->GetRenderObject());
emitter->Restart();
}
}
}
void ParticleEffectComponent::UpdateDurationForChildNodes(float32 newEmitterLifeTime)
{
int32 childrenCount = entity->GetChildrenCount();
for (int32 i = 0; i < childrenCount; i ++)
{
RenderComponent * component = static_cast<RenderComponent*>(entity->GetChild(i)->GetComponent(Component::RENDER_COMPONENT));
if(component && component->GetRenderObject() && component->GetRenderObject()->GetType() == RenderObject::TYPE_PARTICLE_EMTITTER)
{
ParticleEmitter * emitter = static_cast<ParticleEmitter*>(component->GetRenderObject());
emitter->SetLifeTime(newEmitterLifeTime);
}
}
}
LandscapeNode* LandscapePropertyControl::GetLandscape() const
{
RenderComponent* component = cast_if_equal<RenderComponent*>(currentSceneNode->GetComponent(Component::RENDER_COMPONENT));
LandscapeNode *landscape = dynamic_cast<LandscapeNode*> (component->GetRenderObject());
DVASSERT(landscape);
return landscape;
}
void ParticleEffectComponent::EffectUpdate(float32 timeElapsed)
{
int32 childrenCount = entity->GetChildrenCount();
for (int32 i = 0; i < childrenCount; i ++)
{
RenderComponent * component = static_cast<RenderComponent*>(entity->GetChild(i)->GetComponent(Component::RENDER_COMPONENT));
if(component && component->GetRenderObject() && component->GetRenderObject()->GetType() == RenderObject::TYPE_PARTICLE_EMTITTER)
{
ParticleEmitter * emitter = static_cast<ParticleEmitter*>(component->GetRenderObject());
if (IsStopEmitter(emitter))
{
emitter->Stop();
this->emittersCurrentlyStopped++;
// Are all the emitters finished playback? Notify user if yes.
CheckPlaybackComplete();
}
}
}
}
RenderObject * GetRenderObject(const Entity * fromEntity)
{
RenderObject * object = 0;
if(NULL != fromEntity)
{
RenderComponent * component = static_cast<RenderComponent*>(fromEntity->GetComponent(Component::RENDER_COMPONENT));
if(component)
{
object = component->GetRenderObject();
}
}
return object;
}
PropertyControlCreator::ePropertyControlIDs PropertyControlCreator::DetectNodeType(SceneNode *node)
{
if(node->GetComponent(Component::LIGHT_COMPONENT))
{
return EPCID_LIGHT;
}
if(node->GetComponent(Component::CAMERA_COMPONENT))
{
return EPCID_CAMERA;
}
if(node->GetComponent(Component::SWITCH_COMPONENT))
{
return EPCID_SWITCH;
}
if(GetEmitter(node))
{
return EPCID_PARTICLE_EMITTER;
}
if(node->GetComponent(Component::PARTICLE_EFFECT_COMPONENT))
{
return EPCID_PARTICLE_EFFECT;
}
if(node->GetComponent(Component::LOD_COMPONENT))
{
return EPCID_LODNODE;
}
RenderComponent *rc = static_cast<RenderComponent *>(node->GetComponent(Component::RENDER_COMPONENT));
if(rc)
{
RenderObject *ro = rc->GetRenderObject();
if(dynamic_cast<LandscapeNode *>(ro))
{
return EPCID_LANDSCAPE;
}
}
return EPCID_NODE;
}
inline Landscape* Test::GetLandscape()
{
SettingsManager* settings = SettingsManager::Instance();
Entity* landscapeNode = GetScene()->FindByName(settings->GetLandscapeNodeName());
Landscape* landscape = NULL;
if (landscapeNode)
{
RenderComponent* renderComponent = cast_if_equal<RenderComponent*>(landscapeNode->GetComponent(Component::RENDER_COMPONENT));
if (renderComponent)
{
landscape = dynamic_cast<Landscape*>(renderComponent->GetRenderObject());
}
}
return landscape;
}
void RecursiveProcessMeshNode(Entity * curr, void * userData, void(*process)(Entity*, void *))
{
RenderComponent * comp = (RenderComponent*)curr->GetComponent(Component::RENDER_COMPONENT);
if (comp)
{
RenderObject * renderObject = comp->GetRenderObject();
if (renderObject->GetType() == RenderObject::TYPE_MESH)
{
process(curr, userData);
}
}
else
{
for (int32 i = 0; i < curr->GetChildrenCount(); i++)
RecursiveProcessMeshNode(curr->GetChild(i), userData, process);
}
}
void TextureHelper::EnumerateTextures(DAVA::Entity *forNode, Map<String, Texture *> &textures)
{
if(!forNode) return;
Vector<Entity *> nodes;
forNode->GetChildNodes(nodes);
nodes.push_back(forNode);
for(int32 n = 0; n < (int32)nodes.size(); ++n)
{
RenderComponent *rc = static_cast<RenderComponent *>(nodes[n]->GetComponent(Component::RENDER_COMPONENT));
if(!rc) continue;
RenderObject *ro = rc->GetRenderObject();
if(!ro) continue;
uint32 count = ro->GetRenderBatchCount();
for(uint32 b = 0; b < count; ++b)
{
RenderBatch *renderBatch = ro->GetRenderBatch(b);
NMaterial *material = renderBatch->GetMaterial();
if(material)
{
for(int32 t = 0; t < material->GetTextureCount(); ++t)
{
Texture* tx = material->GetTexture(t);
CollectTexture(textures, tx->GetPathname(), tx);
}
}
/*InstanceMaterialState *instanceMaterial = renderBatch->GetMaterialInstance();
if(instanceMaterial)
{
CollectTexture(textures, instanceMaterial->GetLightmapName(), instanceMaterial->GetLightmap());
}*/
}
Landscape *land = dynamic_cast<Landscape *>(ro);
if(land)
{
CollectLandscapeTextures(textures, land);
}
}
}
void SceneHelper::EnumerateDescriptors(DAVA::Entity *forNode, DAVA::Set<DAVA::FilePath> &descriptors)
{
if(!forNode) return;
Vector<Entity *> nodes;
forNode->GetChildNodes(nodes);
nodes.push_back(forNode);
for(int32 n = 0; n < (int32)nodes.size(); ++n)
{
RenderComponent *rc = static_cast<RenderComponent *>(nodes[n]->GetComponent(Component::RENDER_COMPONENT));
if(!rc) continue;
RenderObject *ro = rc->GetRenderObject();
if(!ro) continue;
uint32 count = ro->GetRenderBatchCount();
for(uint32 b = 0; b < count; ++b)
{
RenderBatch *renderBatch = ro->GetRenderBatch(b);
Material *material = renderBatch->GetMaterial();
if(material)
{
for(int32 t = 0; t < Material::TEXTURE_COUNT; ++t)
{
CollectDescriptors(descriptors, material->GetTextureName((DAVA::Material::eTextureLevel)t));
}
}
InstanceMaterialState *instanceMaterial = renderBatch->GetMaterialInstance();
if(instanceMaterial)
{
CollectDescriptors(descriptors, instanceMaterial->GetLightmapName());
}
}
Landscape *land = dynamic_cast<Landscape *>(ro);
if(land)
{
CollectLandscapeDescriptors(descriptors, land);
}
}
}
void SceneValidator::ValidateRenderComponent(Entity *ownerNode, Set<String> &errorsLog)
{
RenderComponent *rc = static_cast<RenderComponent *>(ownerNode->GetComponent(Component::RENDER_COMPONENT));
if(!rc) return;
RenderObject *ro = rc->GetRenderObject();
if(!ro) return;
uint32 count = ro->GetRenderBatchCount();
for(uint32 b = 0; b < count; ++b)
{
RenderBatch *renderBatch = ro->GetRenderBatch(b);
ValidateRenderBatch(ownerNode, renderBatch, errorsLog);
}
if(ro->GetType() == RenderObject::TYPE_LANDSCAPE)
{
Landscape *landscape = static_cast<Landscape *>(ro);
ValidateLandscape(landscape, errorsLog);
ValidateCustomColorsTexture(ownerNode, errorsLog);
}
}
void SkyboxSystem::Reload()
{
if(skyboxEntity)
{
RenderComponent* renderComponent = static_cast<RenderComponent*>(skyboxEntity->GetComponent(Component::RENDER_COMPONENT));
SkyboxRenderObject* renderObj = cast_if_equal<SkyboxRenderObject*>(renderComponent->GetRenderObject());
if(renderObj &&
renderObj->GetRenderBatchCount() > 0)
{
RenderBatch* renderBatch = renderObj->GetRenderBatch(0);
Material* material = renderBatch->GetMaterial();
if(material)
{
Texture* texture = material->GetTexture(Material::TEXTURE_DIFFUSE);
if(texture)
{
texture->Reload();
}
}
}
}
}
bool SwitchToRenerObjectConverter::MergeSwitch(Entity * entity)
{
Vector<Entity*> entitiesToRemove;
SwitchComponent * sw = GetSwitchComponent(entity);
if(sw)
{
RenderComponent * rc = GetRenderComponent(entity);
RenderObject * ro = 0;
if(!rc)
{
ro = new Mesh();
rc = new RenderComponent(ro);
ro->Release();
ro->SetAABBox(AABBox3(Vector3(0, 0, 0), Vector3(0, 0, 0)));
entity->AddComponent(rc);
}
else
{
ro = rc->GetRenderObject();
}
DVASSERT(ro);
int32 size = entity->GetChildrenCount();
for(int32 i = 0; i < size; ++i)
{
Entity * sourceEntity = entity->GetChild(i);
RenderObject * sourceRenderObject = GetRenderObject(sourceEntity);
//workaround for custom properties for crashed model
if(1 == i) // crash model
{
KeyedArchive *childProps = GetCustomPropertiesArchieve(sourceEntity);
if(childProps && childProps->IsKeyExists("CollisionType"))
{
KeyedArchive *entityProps = GetOrCreateCustomProperties(entity)->GetArchive();
entityProps->SetInt32("CollisionTypeCrashed", childProps->GetInt32("CollisionType", 0));
}
}
//end of custom properties
Vector<std::pair<Entity*, RenderObject*> > renderPairs;
if(sourceRenderObject)
{
renderPairs.push_back(std::make_pair(sourceEntity, sourceRenderObject));
}
else
{
FindRenderObjectsRecursive(sourceEntity, renderPairs);
DVASSERT(renderPairs.size() == 1);
sourceRenderObject = renderPairs[0].second;
}
if(sourceRenderObject)
{
TransformComponent * sourceTransform = GetTransformComponent(sourceEntity);
if (sourceTransform->GetLocalTransform() != Matrix4::IDENTITY)
{
PolygonGroup * pg = sourceRenderObject->GetRenderBatchCount() > 0 ? sourceRenderObject->GetRenderBatch(0)->GetPolygonGroup() : 0;
if(pg && bakedPolygonGroups.end() == bakedPolygonGroups.find(pg))
{
sourceRenderObject->BakeGeometry(sourceTransform->GetLocalTransform());
bakedPolygonGroups.insert(pg);
}
}
uint32 sourceSize = sourceRenderObject->GetRenderBatchCount();
while(sourceSize)
{
int32 lodIndex, switchIndex;
RenderBatch * sourceRenderBatch = sourceRenderObject->GetRenderBatch(0, lodIndex, switchIndex);
sourceRenderBatch->Retain();
sourceRenderObject->RemoveRenderBatch(sourceRenderBatch);
ro->AddRenderBatch(sourceRenderBatch, lodIndex, i);
sourceRenderBatch->Release();
sourceSize--;
}
}
renderPairs[0].first->RemoveComponent(Component::RENDER_COMPONENT);
LodComponent * lc = GetLodComponent(sourceEntity);
if((0 != lc) && (0 == GetLodComponent(entity)))
{
LodComponent * newLod = (LodComponent*)lc->Clone(entity);
entity->AddComponent(newLod);
}
renderPairs[0].first->RemoveComponent(Component::LOD_COMPONENT);
if(sourceEntity->GetChildrenCount() == 0)
{
entitiesToRemove.push_back(sourceEntity);
}
}
}
uint32 entitiesToRemoveCount = entitiesToRemove.size();
for(uint32 i = 0; i < entitiesToRemoveCount; ++i)
{
entitiesToRemove[i]->GetParent()->RemoveNode(entitiesToRemove[i]);
}
return false;
}
void EditorScene::CheckNodes(Entity * curr)
{
if(NULL != curr)
{
bool newDebugComp = false;
DebugRenderComponent *dbgComp = NULL;
BaseObject *bulletObject = NULL;
BulletComponent * bulletComponent = (BulletComponent*)curr->GetComponent(Component::BULLET_COMPONENT);
if(NULL != bulletComponent)
{
bulletObject = bulletComponent->GetBulletObject();
}
// create debug render component for all nodes
dbgComp = (DebugRenderComponent *) curr->GetComponent(Component::DEBUG_RENDER_COMPONENT);
if(NULL == dbgComp)
{
dbgComp = new DebugRenderComponent();
newDebugComp = true;
curr->AddComponent(dbgComp);
}
// check other debug settings
// is camera?
CameraComponent *camComp = (CameraComponent *) curr->GetComponent(Component::CAMERA_COMPONENT);
if(NULL != camComp)
{
// set flags to show it
if(newDebugComp)
{
dbgComp->SetDebugFlags(dbgComp->GetDebugFlags() | DebugRenderComponent::DEBUG_DRAW_CAMERA);
}
// create bullet object for camera (allow selecting it)
/*
if(NULL == bulletComponent)
{
bulletComponent = (BulletComponent*) curr->GetOrCreateComponent(Component::BULLET_COMPONENT);
bulletComponent->SetBulletObject(new BulletObject(this, collisionWorld, camComp->GetCamera(), camComp->GetCamera()->GetMatrix()));
}
*/
}
// is light?
if(NULL != curr->GetComponent(Component::LIGHT_COMPONENT))
{
if(newDebugComp)
{
dbgComp->SetDebugFlags(dbgComp->GetDebugFlags() | DebugRenderComponent::DEBUG_DRAW_LIGHT_NODE);
}
if(NULL == bulletComponent || NULL == bulletObject)
{
BulletObject *bObj = new BulletObject(this, collisionWorld, curr, AABBox3(Vector3(), 2.5f), curr->GetWorldTransform());
bulletComponent = (BulletComponent*) curr->GetOrCreateComponent(Component::BULLET_COMPONENT);
bulletComponent->SetBulletObject(bObj);
SafeRelease(bObj);
}
}
// is user node
if(NULL != curr->GetComponent(Component::USER_COMPONENT))
{
if(newDebugComp)
{
dbgComp->SetDebugFlags(dbgComp->GetDebugFlags() | DebugRenderComponent::DEBUG_DRAW_USERNODE);
}
if(NULL == bulletComponent || NULL == bulletObject)
{
BulletObject *bObj = new BulletObject(this, collisionWorld, curr, AABBox3(Vector3(), 2.5f), curr->GetWorldTransform());
bulletComponent = (BulletComponent*) curr->GetOrCreateComponent(Component::BULLET_COMPONENT);
bulletComponent->SetBulletObject(bObj);
SafeRelease(bObj);
}
}
// is render object?
RenderComponent * renderComponent = (RenderComponent*) curr->GetComponent(Component::RENDER_COMPONENT);
if(NULL != renderComponent)
{
RenderObject *rObj = renderComponent->GetRenderObject();
if(NULL != rObj && rObj->GetType() != RenderObject::TYPE_LANDSCAPE && curr->IsLodMain(0))
{
if(NULL == bulletComponent || NULL == bulletObject)
{
BulletObject *bObj = new BulletObject(this, collisionWorld, curr, curr->GetWorldTransform());
bulletComponent = (BulletComponent*) curr->GetOrCreateComponent(Component::BULLET_COMPONENT);
bulletComponent->SetBulletObject(bObj);
SafeRelease(bObj);
}
}
}
}
int size = curr->GetChildrenCount();
for (int i = 0; i < size; i++)
{
CheckNodes(curr->GetChild(i));
}
}
