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; }