void ShowHideAnim::onTimer(qlib::time_value elapsed, AnimMgr *pMgr)
{
const double rho = getRho(elapsed);
// rend array should be filled here!!
rendlist_t::const_iterator riter = rendBegin();
rendlist_t::const_iterator rend = rendEnd();
for (; riter!=rend; ++riter) {
RendererPtr pRend = *riter;
if (m_bHide) {
// hiding
setVisible(pRend, true);
if (m_bFade)
pRend->setPropReal("alpha", (1.0-rho)*m_dTgtAlpha);
}
else {
// showing
MB_DPRINTLN("ShowHideAnim.onTimer> SetVisible TRUE!!!");
setVisible(pRend, true);
if (m_bFade) {
pRend->setPropReal("alpha", rho*m_dTgtAlpha);
MB_DPRINTLN("ShowHideAnim.onTimer> SetAlpha %f!", rho);
}
}
}
}
void EC_OgreEnvironment::InitCaelum()
{
using namespace Caelum;
if (renderer_.expired())
return;
RendererPtr renderer = renderer_.lock();
caelumComponents_ = CaelumSystem::CAELUM_COMPONENTS_NONE;
caelumComponents_ = caelumComponents_ |
CaelumSystem::CAELUM_COMPONENT_SKY_DOME |
CaelumSystem::CAELUM_COMPONENT_MOON |
CaelumSystem::CAELUM_COMPONENT_SUN |
CaelumSystem::CAELUM_COMPONENT_POINT_STARFIELD |
CaelumSystem::CAELUM_COMPONENT_SCREEN_SPACE_FOG |
CaelumSystem::CAELUM_COMPONENT_GROUND_FOG;
// Caelum clouds are hidden, otherwise shadows get messed up.
caelumSystem_ = new CaelumSystem(renderer->GetRoot().get(),
renderer->GetSceneManager(), (CaelumSystem::CaelumComponent)caelumComponents_);
// Flip the Caelum camera and ground node orientations 90 degrees.
Ogre::Quaternion orientation(Ogre::Degree(90), Ogre::Vector3(1, 0, 0));
caelumSystem_->getCaelumCameraNode()->setOrientation(orientation);
caelumSystem_->getCaelumGroundNode()->setOrientation(orientation);
// We want to manage the fog ourself.
caelumSystem_->setManageSceneFog(false);
// Use just one light (the brightest one) at a time.
caelumSystem_->setEnsureSingleLightSource(true);
caelumSystem_->setEnsureSingleShadowSource(true);
caelumSystem_->getMoon()->setDiffuseMultiplier(Ogre::ColourValue(0.25f, 0.25f, 0.25f));
}
Ogre::Mesh* EC_Mesh::PrepareMesh(const std::string& mesh_name, bool clone)
{
if (!ViewEnabled())
return 0;
if (renderer_.expired())
return 0;
RendererPtr renderer = renderer_.lock();
Ogre::MeshManager& mesh_mgr = Ogre::MeshManager::getSingleton();
Ogre::MeshPtr mesh = mesh_mgr.getByName(SanitateAssetIdForOgre(mesh_name));
// For local meshes, mesh will not get automatically loaded until used in an entity. Load now if necessary
if (mesh.isNull())
{
try
{
mesh_mgr.load(mesh_name, Ogre::ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME);
mesh = mesh_mgr.getByName(mesh_name);
}
catch (Ogre::Exception& e)
{
LogError("Could not load mesh " + mesh_name + ": " + std::string(e.what()));
return 0;
}
}
// If mesh is still null, must abort
if (mesh.isNull())
{
LogError("Mesh " + mesh_name + " does not exist");
return 0;
}
if (clone)
{
try
{
mesh = mesh->clone(renderer->GetUniqueObjectName("EC_Mesh_clone"));
mesh->setAutoBuildEdgeLists(false);
cloned_mesh_name_ = mesh->getName();
}
catch (Ogre::Exception& e)
{
LogError("Could not clone mesh " + mesh_name + ":" + std::string(e.what()));
return 0;
}
}
if (mesh->hasSkeleton())
{
Ogre::SkeletonPtr skeleton = Ogre::SkeletonManager::getSingleton().getByName(mesh->getSkeletonName());
if (skeleton.isNull() || skeleton->getNumBones() == 0)
{
LogDebug("Mesh " + mesh_name + " has a skeleton with 0 bones. Disabling the skeleton.");
mesh->setSkeletonName("");
}
}
return mesh.get();
}
void EC_OgreEnvironment::InitShadows()
{
if (renderer_.expired())
return;
RendererPtr renderer = renderer_.lock();
float shadowFarDist = 50;
unsigned short shadowTextureSize = 2048;
size_t shadowTextureCount = 1;
Ogre::ColourValue shadowColor(0.6f, 0.6f, 0.6f);
// This is the default material to use for shadow buffer rendering pass, overridable in script.
// Note that we use the same single material (vertex program) for each object, so we're relying on
// that we use Ogre software skinning. Hardware skinning would require us to do different vertex programs
// for skinned/nonskinned geometry.
std::string ogreShadowCasterMaterial = "rex/ShadowCaster";
Ogre::SceneManager* sceneManager = renderer->GetSceneManager();
sceneManager->setShadowColour(shadowColor);
sceneManager->setShadowFarDistance(shadowFarDist);
sceneManager->setShadowTextureSize(shadowTextureSize);
sceneManager->setShadowTextureCount(shadowTextureCount);
sceneManager->setShadowTexturePixelFormat(Ogre::PF_FLOAT16_R);
sceneManager->setShadowTechnique(Ogre::SHADOWTYPE_TEXTURE_ADDITIVE_INTEGRATED);
sceneManager->setShadowTextureCasterMaterial(ogreShadowCasterMaterial.c_str());
sceneManager->setShadowTextureSelfShadow(true);
Ogre::ShadowCameraSetupPtr shadowCameraSetup = Ogre::ShadowCameraSetupPtr(new Ogre::FocusedShadowCameraSetup());
sceneManager->setShadowCameraSetup(shadowCameraSetup);
// If set to true, problems with objects that clip into the ground
sceneManager->setShadowCasterRenderBackFaces(false);
}
void EC_OgreCamera::SetActive()
{
if (renderer_.expired())
return;
RendererPtr renderer = renderer_.lock();
renderer->SetCurrentCamera(camera_);
}
bool EC_OgreCamera::IsActive() const
{
if (renderer_.expired())
return false;
RendererPtr renderer = renderer_.lock();
return renderer->GetCurrentCamera() == camera_;
}
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;
}
LightPixel::CameraPtr Application::ActiveCamera()
{
RendererPtr render = Engine::Instance().RendererInstance();
CameraPtr & camera = render->CurFrameBuffer()->GetViewport()->camera;
//BOOST_ASSERT(camera);
return camera;
}
Color EC_OgreEnvironment::GetBackgoundColor() const
{
if (renderer_.expired())
return Color(0.0f, 0.0f, 0.0f, 0.0f);
RendererPtr renderer = renderer_.lock();
return ToCoreColor(renderer->GetViewport()->getBackgroundColour());
}
void EC_OgreEnvironment::SetBackgoundColor(const Color &color)
{
if (renderer_.expired())
return;
RendererPtr renderer = renderer_.lock();
renderer->GetViewport()->setBackgroundColour(ToOgreColor(color));
}
void EC_OgreEnvironment::DisableFog()
{
if (renderer_.expired())
return;
RendererPtr renderer = renderer_.lock();
Ogre::SceneManager *sceneManager = renderer->GetSceneManager();
sceneManager->setFog(Ogre::FOG_NONE);
}
Color EC_OgreEnvironment::GetAmbientLightColor() const
{
if (renderer_.expired())
return Color(0.0f, 0.0f, 0.0f, 0.0f);
RendererPtr renderer = renderer_.lock();
Ogre::SceneManager *sceneManager = renderer->GetSceneManager();
return ToCoreColor(sceneManager->getAmbientLight());
}
void Application::Update()
{
this->UpdateStats();
this->DoUpdate();
RendererPtr render = Engine::Instance().RendererInstance();
render->Refresh();
}
void RealPropAnim::onPropInit(AnimMgr *pMgr, qlib::uid_t tgt_uid)
{
RendererPtr pTgtRend = qsys::SceneManager::getRendererS(tgt_uid);
if (pTgtRend.isnull()) {
LOG_DPRINTLN("RealPropAnim.onPropInit> Unknown tgt uid %d", int(tgt_uid));
return;
}
qlib::LVariant var(m_startValue);
pTgtRend->setProperty(getPropName(), var);
}
EC_OgreLight::EC_OgreLight(Foundation::ModuleInterface* module) :
Foundation::ComponentInterface(module->GetFramework()),
renderer_(checked_static_cast<OgreRenderingModule*>(module)->GetRenderer()),
light_(0),
attached_(false)
{
RendererPtr renderer = renderer_.lock();
Ogre::SceneManager* scene_mgr = renderer->GetSceneManager();
light_ = scene_mgr->createLight(renderer->GetUniqueObjectName());
}
BOOL CGameEditorView::OnMouseWheel(UINT nFlags, short zDelta, CPoint pt)
{
// TODO: 在此添加消息处理程序代码和/或调用默认值
RendererPtr pRenderer = Project::Instance()->GetRenderer();
if(pRenderer)
{
pRenderer->OnMouseWheel(nFlags, zDelta, pt);
}
return CView::OnMouseWheel(nFlags, zDelta, pt);
}
void EC_OgreSky::DisableSky()
{
if (renderer_.expired())
return;
RendererPtr renderer = renderer_.lock();
Ogre::SceneManager* scene_mgr = renderer->GetSceneManager();
scene_mgr->setSkyBox(false, "");
scene_mgr->setSkyDome(false, "");
scene_mgr->setSkyPlane(false, Ogre::Plane(), "");
skyEnabled_ = false;
}
void RealPropAnim::onEnd(qlib::time_value elapsed, AnimMgr *pMgr)
{
qlib::LVariant var(m_endValue);
LString propnm = getPropName();
// rend array should be filled here!!
rendlist_t::const_iterator riter = rendBegin();
rendlist_t::const_iterator rend = rendEnd();
for (; riter!=rend; ++riter) {
RendererPtr pRend = *riter;
pRend->setProperty(propnm, var);
}
}
void RealPropAnim::onStart(qlib::time_value elapsed, AnimMgr *pMgr)
{
qlib::LVariant var(m_startValue);
LString propname = getPropName();
fillRendArray(pMgr->getTgtScene());
rendlist_t::const_iterator riter = rendBegin();
rendlist_t::const_iterator rend = rendEnd();
for (; riter!=rend; ++riter) {
RendererPtr pRend = *riter;
pRend->setProperty(propname, var);
}
}
void CGameEditorView::OnRButtonDown(UINT nFlags, CPoint point)
{
// TODO: 在此添加消息处理程序代码和/或调用默认值
RendererPtr pRenderer = Project::Instance()->GetRenderer();
if(pRenderer)
{
pRenderer->OnMouseRButtonDown(nFlags, point);
}
CView::OnRButtonDown(nFlags, point);
}
EC_OgreLight::~EC_OgreLight()
{
if (renderer_.expired())
return;
RendererPtr renderer = renderer_.lock();
if (light_)
{
DetachLight();
Ogre::SceneManager* scene_mgr = renderer->GetSceneManager();
scene_mgr->destroyLight(light_);
light_ = 0;
}
}
void EC_OgreEnvironment::CreateSunlight()
{
if (renderer_.expired())
return;
RendererPtr renderer = renderer_.lock();
Ogre::SceneManager* sceneManager = renderer->GetSceneManager();
sunlight_ = sceneManager->createLight(renderer->GetUniqueObjectName());
sunlight_->setType(Ogre::Light::LT_DIRECTIONAL);
///\todo Read parameters from config file?
sunlight_->setDiffuseColour(0.93f, 1, 0.13f);
sunlight_->setDirection(-1, -1, -1);
sunlight_->setCastShadows(true);
SetAmbientLightColor(Color(0.5, 0.5, 0.5, 1));
}
void CGameEditorView::OnRButtonUp(UINT nFlags , CPoint point)
{
RendererPtr pRenderer = Project::Instance()->GetRenderer();
if(pRenderer)
{
pRenderer->OnMouseRButtonUp(nFlags, point);
}
ClientToScreen(&point);
OnContextMenu(this, point);
}
EC_Mesh::~EC_Mesh()
{
if (renderer_.expired())
return;
RendererPtr renderer = renderer_.lock();
RemoveMesh();
if (adjustment_node_)
{
Ogre::SceneManager* scene_mgr = renderer->GetSceneManager();
scene_mgr->destroySceneNode(adjustment_node_);
adjustment_node_ = 0;
}
}
RendererPtr Object::createRenderer(const LString &type_name)
{
RendererFactory *pRF = RendererFactory::getInstance();
RendererPtr pRend = pRF->create(type_name);
if (!registerRendererImpl(pRend)) {
// error !! cannot register renderer.
LOG_DPRINTLN("ERROR !! cannot register renderer");
LString msg = LString::format("Cannot register renderer %s", type_name.c_str());
MB_THROW(qlib::RuntimeException, msg);
return RendererPtr();
}
MB_DPRINTLN("createRenderer clientObjID=%d OK", (int)pRend->getClientObjID());
return pRend;
}
void EC_OgreEnvironment::SetAmbientLightColor(const Color &color)
{
if (renderer_.expired())
return;
RendererPtr renderer = renderer_.lock();
Ogre::SceneManager* sceneManager = renderer->GetSceneManager();
sceneManager->setAmbientLight(ToOgreColor(color));
// Assure that there is "not" None-flag set.
if ( override_flags_.testFlag(None))
override_flags_ &= ~None;
override_flags_|=AmbientLight;
userAmbientLight_ = ToOgreColor(color);
}
bool RendGroup::hasCenter() const
{
ObjectPtr pObj = getClientObj();
Object::RendIter iter = pObj->beginRend();
Object::RendIter eiter = pObj->endRend();
for (;iter!=eiter;++iter) {
RendererPtr pRend = iter->second;
if (!pRend->getGroupName().equals(getName()))
continue;
if (pRend->hasCenter()) {
return true;
}
}
// none of the renderers in this group has valid center
return false;
}
EC_OgreCamera::EC_OgreCamera(Foundation::ModuleInterface* module) :
Foundation::ComponentInterface(module->GetFramework()),
renderer_(checked_static_cast<OgreRenderingModule*>(module)->GetRenderer()),
attached_(false),
camera_(0)
{
RendererPtr renderer = renderer_.lock();
Ogre::SceneManager* scene_mgr = renderer->GetSceneManager();
Ogre::Viewport* viewport = renderer->GetViewport();
camera_ = scene_mgr->createCamera(renderer->GetUniqueObjectName());
// Set default values for the camera
camera_->setNearClipDistance(0.1f);
camera_->setFarClipDistance(2000.f);
camera_->setAspectRatio(Ogre::Real(viewport->getActualWidth() / Ogre::Real(viewport->getActualHeight())));
camera_->setAutoAspectRatio(true);
}
void RealPropAnim::onTimer(qlib::time_value elapsed, AnimMgr *pMgr)
{
const double rho = getRho(elapsed);
// MB_DPRINTLN("spin(%s) rho=%f", getName().c_str(), rho);
double value = m_startValue*(1.0-rho) + m_endValue*rho;
qlib::LVariant var(value);
LString propnm = getPropName();
// rend array should be filled here!!
rendlist_t::const_iterator riter = rendBegin();
rendlist_t::const_iterator rend = rendEnd();
for (; riter!=rend; ++riter) {
RendererPtr pRend = *riter;
pRend->setProperty(propnm, var);
}
}
bool Object::destroyRenderer(qlib::uid_t uid)
{
// get renderer ptr/check consistency
rendtab_t::iterator i = m_rendtab.find(uid);
if (i==m_rendtab.end())
return false;
RendererPtr pRend = i->second;
ScenePtr pScene = getScene();
if (pScene.isnull() || pRend.isnull()) {
LOG_DPRINTLN("Object::destroyRenderer> fatal error pScene or pRend is NULL!");
return false;
}
// detach renderer from the view-related resources (DL, VBO, etc)
pRend->unloading();
// Detach the parent scene from the renderer event source
pRend->removeListener(pScene.get());
// Fire the SCE_REND_REMOVING Event, before removing the renderer
{
MB_DPRINTLN("Object> Firing SCE_REND_REMOVING event...");
SceneEvent ev;
ev.setType(SceneEvent::SCE_REND_REMOVING);
ev.setSource(getSceneID());
ev.setTarget(pRend->getUID());
pScene->fireSceneEvent(ev);
}
// remove the rend from the scene's cache list
pScene->removeRendCache(pRend);
// 2012/9/30
// Detach the rend from obj HERE is very important!!
// (This call remove the rend from object's event listener list.
// Otherwise, deleted ptr will remain in the listener list, and thus cause crash!!)
qlib::uid_t objid = pRend->detachObj();
// MB_ASSERT(objid==this->m_uid);
// 2012/9/30
// Setting scene ID to null will cause removing pRend from the scene's listener list
// (Without this, deleted ptr will remain in scene's listener list, after clearing the UNDO data!!)
pRend->setSceneID(qlib::invalid_uid);
// Remove from the renderer table
m_rendtab.erase(i);
// Record undo/redo info
UndoManager *pUM = pScene->getUndoMgr();
if (pUM->isOK()) {
ObjLoadEditInfo *pPEI = MB_NEW ObjLoadEditInfo;
pPEI->setupRendDestroy(getUID(), pRend);
pUM->addEditInfo(pPEI);
}
return true;
}
