bool EC_OgreCustomObject::CommitChanges(Ogre::ManualObject* object)
{
if (!object)
return false;
if (renderer_.expired())
return false;
RendererPtr renderer = renderer_.lock();
DestroyEntity();
// If placeable is not set yet, set it manually by searching it from the parent entity
if (!placeable_)
{
Scene::Entity* entity = GetParentEntity();
if (entity)
{
ComponentPtr placeable = entity->GetComponent(EC_Placeable::TypeNameStatic());
if (placeable)
placeable_ = placeable;
}
}
if (!object->getNumSections())
return true;
try
{
std::string mesh_name = renderer->GetUniqueObjectName("EC_OgreCustomObject_mesh");
object->convertToMesh(mesh_name);
object->clear();
Ogre::SceneManager* scene_mgr = renderer->GetSceneManager();
entity_ = scene_mgr->createEntity(renderer->GetUniqueObjectName("EC_OgreCustomObject_entity"), mesh_name);
if (entity_)
{
AttachEntity();
entity_->setRenderingDistance(draw_distance_);
entity_->setCastShadows(cast_shadows_);
entity_->setUserAny(Ogre::Any(GetParentEntity()));
// Set UserAny also on subentities
for (uint i = 0; i < entity_->getNumSubEntities(); ++i)
entity_->getSubEntity(i)->setUserAny(entity_->getUserAny());
}
else
{
OgreRenderingModule::LogError("Could not create entity from manualobject mesh");
return false;
}
}
catch (Ogre::Exception& e)
{
OgreRenderingModule::LogError("Could not convert manualobject to mesh: " + std::string(e.what()));
return false;
}
return true;
}
EC_3DCanvas *EC_VideoSource::Get3DCanvas()
{
EC_3DCanvas *canvas = 0;
Scene::Entity* entity = GetParentEntity();
if (entity)
canvas = dynamic_cast<EC_3DCanvas*>(entity->GetOrCreateComponent(EC_3DCanvas::TypeNameStatic()).get());
else
LogError("Could not get parent entity");
return canvas;
}
void EC_Mesh::AutoSetPlaceable()
{
Scene::Entity* entity = GetParentEntity();
if (entity)
{
ComponentPtr placeable = entity->GetComponent(EC_Placeable::TypeNameStatic());
if (placeable)
SetPlaceable(placeable);
}
}
void EC_VideoSource::RegisterActions()
{
Scene::Entity *entity = GetParentEntity();
assert(entity);
if (entity)
{
entity->ConnectAction("Play", this, SLOT(Play()));
entity->ConnectAction("Stop", this, SLOT(Stop()));
entity->ConnectAction("Pause", this, SLOT(Pause()));
}
}
// virtual
bool OgreRenderingModule::HandleEvent(event_category_id_t category_id, event_id_t event_id, Foundation::EventDataInterface* data)
{
PROFILE(OgreRenderingModule_HandleEvent);
if (!renderer_)
return false;
if (category_id == asset_event_category_)
{
return renderer_->GetResourceHandler()->HandleAssetEvent(event_id, data);
}
if (category_id == resource_event_category_)
{
return renderer_->GetResourceHandler()->HandleResourceEvent(event_id, data);
}
if (category_id == input_event_category_ && event_id == Input::Events::INWORLD_CLICK)
{
// do raycast into the world when user clicks mouse button
Input::Events::Movement *movement = checked_static_cast<Input::Events::Movement*>(data);
assert(movement);
Foundation::RaycastResult result = renderer_->Raycast(movement->x_.abs_, movement->y_.abs_);
Scene::Entity *entity = result.entity_;
if (entity)
{
Scene::Events::RaycastEventData event_data(entity->GetId());
event_data.pos = result.pos_, event_data.submesh = result.submesh_, event_data.u = result.u_, event_data.v = result.v_;
framework_->GetEventManager()->SendEvent(scene_event_category_, Scene::Events::EVENT_ENTITY_GRAB, &event_data);
//Semantically same as above but sends the entity pointer
Scene::Events::EntityClickedData clicked_event_data(entity);
framework_->GetEventManager()->SendEvent(scene_event_category_, Scene::Events::EVENT_ENTITY_CLICKED, &clicked_event_data);
}
else
framework_->GetEventManager()->SendEvent(scene_event_category_, Scene::Events::EVENT_ENTITY_NONE_CLICKED, 0);
}
if (network_state_event_category_)
{
if (event_id == ProtocolUtilities::Events::EVENT_USER_DISCONNECTED)
renderer_->ResetImageRendering();
return false;
}
return false;
}
void EC_Touchable::RegisterActions()
{
Scene::Entity *entity = GetParentEntity();
assert(entity);
if (entity)
{
// Generic actions
entity->ConnectAction("Show", this, SLOT(Show()));
entity->ConnectAction("Hide", this, SLOT(Hide()));
// Mouse actions
entity->ConnectAction("MouseHover", this, SLOT(OnHover()));
entity->ConnectAction("MouseHoverIn", this, SLOT(OnHoverIn()));
entity->ConnectAction("MouseHoverOut", this, SLOT(OnHoverOut()));
entity->ConnectAction("MousePress", this, SLOT(OnClick()));
}
}
void EC_Clone::Create()
{
if (renderer_.expired())
return;
Ogre::SceneManager *scene = renderer_.lock()->GetSceneManager();
assert(scene);
if (!scene)
return;
Scene::Entity *entity = GetParentEntity();
assert(entity);
if (!entity)
return;
OgreRenderer::EC_OgrePlaceable *placeable = entity->GetComponent<OgreRenderer::EC_OgrePlaceable>().get();
assert(placeable);
if (!placeable)
return;
// Check out if this entity has EC_OgreMesh or EC_OgreCustomObject.
Ogre::Entity *originalEntity = 0;
if (entity->GetComponent(OgreRenderer::EC_OgreMesh::NameStatic()))
{
OgreRenderer::EC_OgreMesh *ec_mesh= entity->GetComponent<OgreRenderer::EC_OgreMesh>().get();
assert(ec_mesh);
originalEntity = ec_mesh->GetEntity();
sceneNode_ = ec_mesh->GetAdjustmentSceneNode();
}
else if(entity->GetComponent(OgreRenderer::EC_OgreCustomObject::NameStatic()))
{
OgreRenderer::EC_OgreCustomObject *ec_custom = entity->GetComponent<OgreRenderer::EC_OgreCustomObject>().get();
assert(ec_custom);
if (!ec_custom->IsCommitted())
{
LogError("Mesh entity have not been created for the target primitive. Cannot create EC_Highlight.");
return;
}
originalEntity = ec_custom->GetEntity();
sceneNode_ = placeable->GetSceneNode();
}
else
{
LogError("This entity doesn't have either EC_OgreMesh or EC_OgreCustomObject present. Cannot create EC_Highlight.");
return;
}
assert(originalEntity);
if (!originalEntity)
return;
assert(sceneNode_);
if (!sceneNode_)
return;
// Clone the Ogre entity.
cloneName_ = std::string("entity") + renderer_.lock()->GetUniqueObjectName();
entityClone_ = originalEntity->clone(cloneName_);
assert(entityClone_);
// Disable casting of shadows for the clone.
entityClone_->setCastShadows(false);
///\todo If original entity has skeleton, (try to) link it to the clone.
/*
if (originalEntity->hasSkeleton())
{
Ogre::SkeletonInstance *skel = originalEntity->getSkeleton();
// If sharing a skeleton, force the attachment mesh to use the same skeleton
// This is theoretically quite a scary operation, for there is possibility for things to go wrong
Ogre::SkeletonPtr entity_skel = originalEntity->getMesh()->getSkeleton();
if (entity_skel.isNull())
{
LogError("Cannot share skeleton for attachment, not found");
}
else
{
try
{
entityClone_->getMesh()->_notifySkeleton(entity_skel);
}
catch (Ogre::Exception &e)
{
LogError("Could not set shared skeleton for attachment: " + std::string(e.what()));
}
}
}
*/
std::string newMatName = std::string("HighlightMaterial") + renderer_.lock()->GetUniqueObjectName();
try
{
Ogre::MaterialPtr highlightMaterial = OgreRenderer::CloneMaterial("Highlight", newMatName);
entityClone_->setMaterialName(newMatName);
}
catch (Ogre::Exception &e)
{
LogError("Could not set material \"" + newMatName + "\": " + std::string(e.what()));
return;
}
sceneNode_->attachObject(entityClone_);
}
void EC_VideoSource::UpdateCanvas()
{
if (!video_widget_ || !media_object_)
return;
Scene::Entity* entity = GetParentEntity();
if (!entity)
{
LogError("No parent entity, cannot create/update 3DCanvas");
return;
}
// If entity has no valid mesh or prim yet, start a retry timer and try to set the canvas later
if ((!entity->GetComponent(EC_Mesh::TypeNameStatic())) &&
(!entity->GetComponent(EC_OgreCustomObject::TypeNameStatic())))
{
LogDebug("Mesh or prim did not exist yet, retrying");
QTimer::singleShot(500, this, SLOT(UpdateCanvas()));
return;
}
canvas_ = Get3DCanvas();
if (!canvas_)
{
LogError("Could not get 3D Canvas component");
return;
}
// Update widget
if (canvas_->GetWidget() != player_)
{
canvas_->SetWidget(player_);
LogDebug("Widget set");
}
// Update submesh
int submesh = getsubmeshIndex();
if (submesh < 0)
submesh = 0;
if (!canvas_->GetSubMeshes().contains(submesh))
{
canvas_->SetSubmesh(submesh);
LogDebug("Submesh set");
}
// Update refresh rate
if (getrefreshRate() > 0)
{
int ref_rate_msec = 1000 / getrefreshRate();
if (canvas_->GetRefreshRate() != ref_rate_msec)
{
canvas_->SetRefreshRate(getrefreshRate());
LogDebug("Refresh rate set");
}
}
else
canvas_->SetRefreshRate(0);
// Scale down widget
if (getscaleDown() && player_)
{
if (original_size_.isNull())
{
original_size_ = player_->size();
if (original_size_.width() < 1 && original_size_.height() < 1)
original_size_ = QSize(0,0);
else
qDebug() << "Original size set: " << original_size_;
}
if (!original_size_.isNull())
{
QSize scale_down_size(320, 240);
if (player_->size().width() > scale_down_size.width() && player_->size().height() > scale_down_size.height())
{
//player_->resize(scale_down_size);
//LogDebug("Scaled video widget down to 320x240 for performance");
}
}
}
if (start_canvas_)
{
canvas_->Start();
start_canvas_ = false;
playing_canvas_ = true;
LogDebug("Started rendering updates");
if (ready_poller_->isActive())
ready_poller_->stop();
}
if (stop_canvas_)
{
canvas_->Stop();
start_canvas_ = false;
stop_canvas_ = false;
playing_canvas_ = false;
LogDebug("Stoppend rendering updates");
}
}
bool EC_Mesh::SetMesh(QString meshResourceName, bool clone)
{
if (!ViewEnabled())
return false;
if (renderer_.expired())
return false;
RendererPtr renderer = renderer_.lock();
std::string mesh_name = meshResourceName.trimmed().toStdString();
RemoveMesh();
// If placeable is not set yet, set it manually by searching it from the parent entity
if (!placeable_)
{
Scene::Entity* entity = GetParentEntity();
if (entity)
{
ComponentPtr placeable = entity->GetComponent(EC_Placeable::TypeNameStatic());
if (placeable)
placeable_ = placeable;
}
}
Ogre::SceneManager* scene_mgr = renderer->GetSceneManager();
Ogre::Mesh* mesh = PrepareMesh(mesh_name, clone);
if (!mesh)
return false;
try
{
entity_ = scene_mgr->createEntity(renderer->GetUniqueObjectName("EC_Mesh_entity"), mesh->getName());
if (!entity_)
{
LogError("Could not set mesh " + mesh_name);
return false;
}
entity_->setRenderingDistance(drawDistance.Get());
entity_->setCastShadows(castShadows.Get());
entity_->setUserAny(Ogre::Any(GetParentEntity()));
// Set UserAny also on subentities
for (uint i = 0; i < entity_->getNumSubEntities(); ++i)
entity_->getSubEntity(i)->setUserAny(entity_->getUserAny());
if (entity_->hasSkeleton())
{
Ogre::SkeletonInstance* skel = entity_->getSkeleton();
// Enable cumulative mode on skeletal animations
if (skel)
skel->setBlendMode(Ogre::ANIMBLEND_CUMULATIVE);
}
// Make sure adjustment node is uptodate
if (adjustment_node_)
{
Transform newTransform = nodeTransformation.Get();
adjustment_node_->setPosition(newTransform.position.x, newTransform.position.y, newTransform.position.z);
Quaternion adjust(DEGTORAD * newTransform.rotation.x,
DEGTORAD * newTransform.rotation.y,
DEGTORAD * newTransform.rotation.z);
adjustment_node_->setOrientation(Ogre::Quaternion(adjust.w, adjust.x, adjust.y, adjust.z));
// Prevent Ogre exception from zero scale
if (newTransform.scale.x < 0.0000001f)
newTransform.scale.x = 0.0000001f;
if (newTransform.scale.y < 0.0000001f)
newTransform.scale.y = 0.0000001f;
if (newTransform.scale.z < 0.0000001f)
newTransform.scale.z = 0.0000001f;
adjustment_node_->setScale(newTransform.scale.x, newTransform.scale.y, newTransform.scale.z);
}
// Force a re-apply of all materials to this new mesh.
ApplyMaterial();
}
catch (Ogre::Exception& e)
{
LogError("Could not set mesh " + mesh_name + ": " + std::string(e.what()));
return false;
}
AttachEntity();
emit MeshChanged();
return true;
}
