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)); }
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 EC_OgreEnvironment::InitCaelum() { using namespace Caelum; if (renderer_.expired()) return; RendererPtr renderer = renderer_.lock(); if (!renderer->GetViewport()) return; // Headless mode 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)); }
EC_OgreEnvironment::~EC_OgreEnvironment() { if (renderer_.expired()) return; RendererPtr renderer = renderer_.lock(); if (!renderer->GetViewport()) return; // headless //SetBackgoundColor(Color(0, 0, 0)); DisableFog(); if (sunlight_) { Ogre::SceneManager *sceneManager = renderer->GetSceneManager(); sceneManager->destroyLight(sunlight_); sunlight_ = 0; } #ifdef CAELUM ShutdownCaelum(); #endif #ifdef HYDRAX ShutdownHydrax(); #endif }
void EC_OgreEnvironment::InitHydrax() { if (renderer_.expired()) return; RendererPtr renderer = renderer_.lock(); // Create Hydrax system. hydraxSystem_ = new Hydrax::Hydrax(renderer->GetSceneManager(), renderer->GetCurrentCamera(), renderer->GetViewport()); // Create noise module. noiseModule_ = new Hydrax::Noise::Perlin(Hydrax::Noise::Perlin::Options(8, 1.15f, 0.49f, 1.14f, 1.27f)); /*Ogre::Plane(Ogre::Vector3::UNIT_Z, 0)*/ // Create water plane // Ogre::Plane plane(Ogre::Vector3::NEGATIVE_UNIT_Z, 0); /*Ogre::MeshManager::getSingleton().createPlane("HydraxWaterMesh", Ogre::ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME, plane, 5000, 5000, 10, 10, true, 1, 1, 1, Ogre::Vector3::UNIT_X);*/ // Create our projected grid module (Rush) /*module_ = new Hydrax::Module::ProjectedGrid(hydraxSystem_, // Hydrax parent pointer noiseModule_, // Noise module Ogre::Plane(Ogre::Vector3(0,1,0), Ogre::Vector3(0,0,0)), // Base plane Hydrax::MaterialManager::NM_VERTEX, // Normal mode Hydrax::Module::ProjectedGrid::Options(150)); // Projected grid options */ // Nature module_ = new Hydrax::Module::ProjectedGrid( hydraxSystem_, noiseModule_, Ogre::Plane(Ogre::Vector3(0, 1, 0), Ogre::Vector3(0, 0, 0)), Hydrax::MaterialManager::NM_VERTEX, Hydrax::Module::ProjectedGrid::Options(256, 3.25f, 0.035f, true)); hydraxSystem_->setModule(static_cast<Hydrax::Module::Module*>(module_)); // hydraxSystem_->loadCfg("HydraxDemo.hdx"); hydraxSystem_->loadCfg("goodPreset.hdx"); // from "Rush" demo app // hydraxSystem_->setPosition(Ogre::Vector3(0,0,0)); hydraxSystem_->create(); // Rotate the water plane. Ogre::Quaternion orientation(Ogre::Degree(90), Ogre::Vector3(1, 0, 0)); hydraxSystem_->rotate(orientation); // hydraxSystem_->getMesh()->getSceneNode()->setOrientation(orientation); // hydraxSystem_->getRttManager()->getPlanesSceneNode()->setOrientation(orientation); // hydraxSystem_->setPosition(Ogre::Vector3(-5000, -5000, 20)); // hydraxSystem_->setPolygonMode(Ogre::PM_WIREFRAME); // hydraxSystem_->getMaterialManager()->getMaterial(Hydrax::MaterialManager::MAT_WATER)->getTechnique(0)->getPass(0)->setFog(true, Ogre::FOG_NONE); /*hydraxSystem_->setPlanesError(4); hydraxSystem_->setDepthLimit(5.2); hydraxSystem_->setNormalDistortion(0.035); //hydraxSystem_->setDepthColor(Ogre::Vector3(0.04,0.185,0.265)); hydraxSystem_->setSmoothPower(2.5); hydraxSystem_->setCausticsScale(8); hydraxSystem_->setCausticsEnd(0.65); hydraxSystem_->setGlobalTransparency(0); hydraxSystem_->setFullReflectionDistance(99999997952.0); hydraxSystem_->setPolygonMode(Ogre::PM_SOLID/*0*//*); hydraxSystem_->setFoamScale(0.1); hydraxSystem_->getMaterialManager()->getMaterial(Hydrax::MaterialManager::MAT_WATER)->getTechnique(0)->getPass(0)->setFog(true, Ogre::FOG_NONE); */ }
void EC_OgreEnvironment::UpdateVisualEffects(f64 frametime) { if (renderer_.expired()) return; RendererPtr renderer = renderer_.lock(); Ogre::Camera *camera = renderer->GetCurrentCamera(); Ogre::Viewport *viewport = renderer->GetViewport(); Ogre::SceneManager *sceneManager = renderer->GetSceneManager(); #ifdef CAELUM // Set sunlight attenuation using diffuse multiplier. // Seems to be working ok, but feel free to fix if you find better logic and/or values. Ogre::ColourValue diffuseMultiplier(sunColorMultiplier_, sunColorMultiplier_, sunColorMultiplier_, 1); caelumSystem_->getSun()->setDiffuseMultiplier(diffuseMultiplier); Ogre::Light* sun = caelumSystem_->getSun()->getMainLight(); Ogre::Light* moon = caelumSystem_->getMoon()->getMainLight(); float sunDirZaxis = caelumSystem_->getSun()->getMainLight()->getDirection().z; if (sunDirZaxis > 0) { sunColorMultiplier_ -= 0.005f; if (sunColorMultiplier_ <= 0.05f) sunColorMultiplier_ = 0.05f; } else if(sunDirZaxis < 0) { sunColorMultiplier_ += 0.010f; if (sunColorMultiplier_ >= MAX_SUNLIGHT_MULTIPLIER) sunColorMultiplier_ = MAX_SUNLIGHT_MULTIPLIER; } if ( !fog_color_override_) fogColor_ = caelumSystem_->getGroundFog()->getColour(); #endif #ifdef CAELUM // Update Caelum system. caelumSystem_->notifyCameraChanged(camera); caelumSystem_->updateSubcomponents(frametime); // Disable specular from the sun & moon for now, because it easily leads to too strong results sun->setSpecularColour(0.0f, 0.0f, 0.0f); moon->setSpecularColour(0.0f, 0.0f, 0.0f); #endif #ifdef HYDRAX // Update Hydrax system. hydraxSystem_->update(frametime); sunPos = camera->getPosition(); sunPos -= caelumSystem_->getSun()->getLightDirection() * 80000; hydraxSystem_->setSunPosition(sunPos); #endif Ogre::Entity* water = 0; cameraFarClip_ = renderer->GetViewDistance(); if ( sceneManager->hasEntity("WaterEntity") ) water = sceneManager->getEntity("WaterEntity"); if (!water) { // No water entity, set fog value. Real fogStart = fogStart_; Real fogEnd = fogEnd_; ClampFog(fogStart, fogEnd, cameraFarClip_); sceneManager->setFog(Ogre::FOG_LINEAR, fogColor_, 0.001, fogStart, fogEnd); viewport->setBackgroundColour(fogColor_); camera->setFarClipDistance(cameraFarClip_); } else { if(camera->getDerivedPosition().z >= water->getParentNode()->getPosition().z) { // We're above the water. Real fogStart = fogStart_; Real fogEnd = fogEnd_; ClampFog(fogStart, fogEnd, cameraFarClip_); #ifdef CAELUM caelumSystem_->forceSubcomponentVisibilityFlags(caelumComponents_); #endif sceneManager->setFog(Ogre::FOG_LINEAR, fogColor_, 0.001, fogStart, fogEnd); viewport->setBackgroundColour(fogColor_); camera->setFarClipDistance(cameraFarClip_); cameraUnderWater_ = false; } else { // We're below the water. Real fogStart = waterFogStart_; Real fogEnd = waterFogEnd_; Real farClip = waterFogEnd_ + 10.f; if (farClip > cameraFarClip_) farClip = cameraFarClip_; ClampFog(fogStart, fogEnd, farClip); #ifdef CAELUM // Hide the Caelum subsystems. caelumSystem_->forceSubcomponentVisibilityFlags(Caelum::CaelumSystem::CAELUM_COMPONENTS_NONE); #endif sceneManager->setFog(Ogre::FOG_LINEAR, fogColor_ * waterFogColor_, 0.001, fogStart, fogEnd); viewport->setBackgroundColour(fogColor_ * waterFogColor_); camera->setFarClipDistance(farClip); cameraUnderWater_ = true; } } #ifdef CAELUM // If sun color and direction are controlled by user then their value are needed to override here. // internally caelum calculates new values for those so they are needed to set again in each update loop. if ( override_flags_.testFlag(None) ) return; if ( override_flags_.testFlag(AmbientLight)) { // Override ambient light. sceneManager->setAmbientLight(userAmbientLight_); } if ( override_flags_.testFlag(SunDirection) ) { // Override sun direction. if ( sun != 0 ) sun->setDirection(userSunDirection_); } if ( override_flags_.testFlag(SunColor) ) { // Override sun color. if ( sun != 0 ) sun->setDiffuseColour(userSunColor_); } #endif }