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)); }
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); }
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; }
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 EC_OgreEnvironment::DisableFog() { if (renderer_.expired()) return; RendererPtr renderer = renderer_.lock(); Ogre::SceneManager *sceneManager = renderer->GetSceneManager(); sceneManager->setFog(Ogre::FOG_NONE); }
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()); }
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; }
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; } }
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; } }
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 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); }
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); }
EC_OgreCamera::~EC_OgreCamera() { if (renderer_.expired()) return; DetachCamera(); if (camera_) { RendererPtr renderer = renderer_.lock(); if (renderer->GetCurrentCamera() == camera_) renderer->SetCurrentCamera(0); Ogre::SceneManager* scene_mgr = renderer->GetSceneManager(); scene_mgr->destroyCamera(camera_); camera_ = 0; } }
void EC_Mesh::RemoveAttachmentMesh(uint index) { if (renderer_.expired()) return; RendererPtr renderer = renderer_.lock(); if (!entity_) return; if (index >= attachment_entities_.size()) return; Ogre::SceneManager* scene_mgr = renderer->GetSceneManager(); if (attachment_entities_[index] && attachment_nodes_[index]) { // See if attached to a tagpoint or an ordinary node Ogre::TagPoint* tag = dynamic_cast<Ogre::TagPoint*>(attachment_nodes_[index]); if (tag) { entity_->detachObjectFromBone(attachment_entities_[index]); } else { Ogre::SceneNode* scenenode = dynamic_cast<Ogre::SceneNode*>(attachment_nodes_[index]); if (scenenode) { scenenode->detachObject(attachment_entities_[index]); scene_mgr->destroySceneNode(scenenode); } } attachment_nodes_[index] = 0; } if (attachment_entities_[index]) { if (attachment_entities_[index]->sharesSkeletonInstance()) attachment_entities_[index]->stopSharingSkeletonInstance(); scene_mgr->destroyEntity(attachment_entities_[index]); attachment_entities_[index] = 0; } }
EC_Mesh::EC_Mesh(IModule* module) : IComponent(module->GetFramework()), // Note: we put the opensim haxor adjust right here in the defaults, instead of hardcoding it in code. nodeTransformation(this, "Transform", Transform(Vector3df(0,0,0),Vector3df(90,0,180),Vector3df(1,1,1))), meshRef(this, "Mesh ref"), skeletonRef(this, "Skeleton ref"), meshMaterial(this, "Mesh materials"), drawDistance(this, "Draw distance", 0.0f), castShadows(this, "Cast shadows", false), renderer_(checked_static_cast<OgreRenderingModule*>(module)->GetRenderer()), entity_(0), bone_tagpoint_(0), bone_parent_mesh_(0), bone_attached_mesh_(0), attached_(false), attached_to_bone_(false) { static AttributeMetadata drawDistanceData("", "0", "10000"); drawDistance.SetMetadata(&drawDistanceData); static AttributeMetadata materialMetadata; materialMetadata.elementType = "assetreference"; meshMaterial.SetMetadata(&materialMetadata); static AttributeMetadata meshRefMetadata; AttributeMetadata::ButtonInfoList meshRefButtons; meshRefButtons.push_back(AttributeMetadata::ButtonInfo(meshRef.GetName(), "V", "View")); meshRefMetadata.buttons = meshRefButtons; meshRef.SetMetadata(&meshRefMetadata); RendererPtr renderer = renderer_.lock(); Ogre::SceneManager* scene_mgr = renderer->GetSceneManager(); adjustment_node_ = scene_mgr->createSceneNode(renderer->GetUniqueObjectName("EC_Mesh_adjustment_node")); connect(this, SIGNAL(ParentEntitySet()), SLOT(UpdateSignals())); connect(this, SIGNAL(AttributeChanged(IAttribute*, AttributeChange::Type)), SLOT(OnAttributeUpdated(IAttribute*))); meshAsset = AssetRefListenerPtr(new AssetRefListener()); connect(meshAsset.get(), SIGNAL(Loaded(AssetPtr)), this, SLOT(OnMeshAssetLoaded(AssetPtr)), Qt::UniqueConnection); skeletonAsset = AssetRefListenerPtr(new AssetRefListener()); connect(skeletonAsset.get(), SIGNAL(Loaded(AssetPtr)), this, SLOT(OnSkeletonAssetLoaded(AssetPtr)), Qt::UniqueConnection); }
void EC_OgreCustomObject::DestroyEntity() { if (renderer_.expired()) return; RendererPtr renderer = renderer_.lock(); Ogre::SceneManager* scene_mgr = renderer->GetSceneManager(); if (entity_) { DetachEntity(); std::string mesh_name = entity_->getMesh()->getName(); scene_mgr->destroyEntity(entity_); entity_ = 0; try { Ogre::MeshManager::getSingleton().remove(mesh_name); } catch (...) {} } }
EC_OgreEnvironment::~EC_OgreEnvironment() { if (renderer_.expired()) return; RendererPtr renderer = renderer_.lock(); 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_Mesh::RemoveMesh() { if (renderer_.expired()) return; RendererPtr renderer = renderer_.lock(); if (entity_) { if (attached_to_bone_) DetachMeshFromBone(); RemoveAllAttachments(); DetachEntity(); if (bone_attached_mesh_) bone_attached_mesh_->DetachMeshFromBone(); Ogre::SceneManager* scene_mgr = renderer->GetSceneManager(); scene_mgr->destroyEntity(entity_); entity_ = 0; } if (!cloned_mesh_name_.empty()) { try { Ogre::MeshManager::getSingleton().remove(cloned_mesh_name_); } catch (Ogre::Exception& e) { LogWarning("Could not remove cloned mesh:" + std::string(e.what())); } cloned_mesh_name_ = std::string(); } }
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); */ }
bool EC_Mesh::SetMeshWithSkeleton(const std::string& mesh_name, const std::string& skeleton_name, bool clone) { if (!ViewEnabled()) return false; if (renderer_.expired()) return false; RendererPtr renderer = renderer_.lock(); Ogre::SkeletonPtr skel = Ogre::SkeletonManager::getSingleton().getByName(SanitateAssetIdForOgre(skeleton_name)); if (skel.isNull()) { LogError("Could not set skeleton " + skeleton_name + " to mesh " + mesh_name + ": not found"); return false; } RemoveMesh(); Ogre::SceneManager* scene_mgr = renderer->GetSceneManager(); Ogre::Mesh* mesh = PrepareMesh(mesh_name, clone); if (!mesh) return false; try { mesh->_notifySkeleton(skel); // LogDebug("Set skeleton " + skeleton_name + " to mesh " + mesh_name); } catch (Ogre::Exception& e) { LogError("Could not set skeleton " + skeleton_name + " to mesh " + mesh_name + ": " + std::string(e.what())); return false; } try { entity_ = scene_mgr->createEntity(renderer->GetUniqueObjectName("EC_Mesh_entwithskel"), 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); } } catch (Ogre::Exception& e) { LogError("Could not set mesh " + mesh_name + ": " + std::string(e.what())); return false; } AttachEntity(); emit MeshChanged(); return true; }
bool EC_Mesh::SetAttachmentMesh(uint index, const std::string& mesh_name, const std::string& attach_point, bool share_skeleton) { if (!ViewEnabled()) return false; if (renderer_.expired()) return false; RendererPtr renderer = renderer_.lock(); if (!entity_) { LogError("No mesh entity created yet, can not create attachments"); return false; } Ogre::SceneManager* scene_mgr = renderer->GetSceneManager(); size_t oldsize = attachment_entities_.size(); size_t newsize = index + 1; if (oldsize < newsize) { attachment_entities_.resize(newsize); attachment_nodes_.resize(newsize); for (uint i = oldsize; i < newsize; ++i) { attachment_entities_[i] = 0; attachment_nodes_[i] = 0; } } RemoveAttachmentMesh(index); Ogre::Mesh* mesh = PrepareMesh(mesh_name, false); if (!mesh) return false; if (share_skeleton) { // 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 = entity_->getMesh()->getSkeleton(); if (entity_skel.isNull()) { LogError("Cannot share skeleton for attachment, not found"); return false; } try { mesh->_notifySkeleton(entity_skel); } catch (Ogre::Exception e) { LogError("Could not set shared skeleton for attachment"); return false; } } try { QString entityName = QString("EC_Mesh_attach") + QString::number(index); attachment_entities_[index] = scene_mgr->createEntity(renderer->GetUniqueObjectName(entityName.toStdString()), mesh->getName()); if (!attachment_entities_[index]) { LogError("Could not set attachment mesh " + mesh_name); return false; } attachment_entities_[index]->setRenderingDistance(drawDistance.Get()); attachment_entities_[index]->setCastShadows(castShadows.Get()); attachment_entities_[index]->setUserAny(entity_->getUserAny()); // Set UserAny also on subentities for (uint i = 0; i < attachment_entities_[index]->getNumSubEntities(); ++i) attachment_entities_[index]->getSubEntity(i)->setUserAny(entity_->getUserAny()); Ogre::Bone* attach_bone = 0; if (!attach_point.empty()) { Ogre::Skeleton* skel = entity_->getSkeleton(); if (skel && skel->hasBone(attach_point)) attach_bone = skel->getBone(attach_point); } if (attach_bone) { Ogre::TagPoint* tag = entity_->attachObjectToBone(attach_point, attachment_entities_[index]); attachment_nodes_[index] = tag; } else { QString nodeName = QString("EC_Mesh_attachment_") + QString::number(index); Ogre::SceneNode* node = scene_mgr->createSceneNode(renderer->GetUniqueObjectName(nodeName.toStdString())); node->attachObject(attachment_entities_[index]); adjustment_node_->addChild(node); attachment_nodes_[index] = node; } if (share_skeleton && entity_->hasSkeleton() && attachment_entities_[index]->hasSkeleton()) { attachment_entities_[index]->shareSkeletonInstanceWith(entity_); } } catch (Ogre::Exception& e) { LogError("Could not set attachment mesh " + mesh_name + ": " + std::string(e.what())); return false; } return true; }
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 }
void EC_OgreSky::CreateSky(bool show) { if (renderer_.expired()) return; RendererPtr renderer = renderer_.lock(); DisableSky(); Ogre::SceneManager* scene_mgr = renderer->GetSceneManager(); /*RexTypes::Vector3 v = genericSkyParameters.angleAxis; Ogre::Quaternion orientation(Ogre::Degree(genericSkyParameters.angle), Ogre::Vector3(v.x, v.y, v.z));*/ ///\todo Get the sky type and other parameters from the config file. switch(type_) { case SKYTYPE_BOX: { Ogre::MaterialPtr skyMaterial = Ogre::MaterialManager::getSingleton().getByName(skyBoxParameters.material); skyMaterial->setReceiveShadows(false); try { RexTypes::Vector3 v = skyBoxParameters.angleAxis; Ogre::Quaternion orientation(Ogre::Degree(skyBoxParameters.angle), Ogre::Vector3(v.x, v.y, v.z)); scene_mgr->setSkyBox(show, skyBoxParameters.material, skyBoxParameters.distance, skyBoxParameters.drawFirst, orientation); } catch (Ogre::Exception& e) { OgreRenderingModule::LogError("Could not set SkyBox: " + std::string(e.what())); return; } skyEnabled_ = true; break; } case SKYTYPE_DOME: try { RexTypes::Vector3 v = skyDomeParameters.angleAxis; Ogre::Quaternion orientation(Ogre::Degree(skyDomeParameters.angle), Ogre::Vector3(v.x, v.y, v.z)); scene_mgr->setSkyDome(show, skyDomeParameters.material, skyDomeParameters.curvature, skyDomeParameters.tiling, skyDomeParameters.distance, skyDomeParameters.drawFirst, orientation, skyDomeParameters.xSegments, skyDomeParameters.ySegments, skyDomeParameters.ySegmentsKeep); } catch (Ogre::Exception& e) { OgreRenderingModule::LogError("Could not set SkyDome: " + std::string(e.what())); return; } skyEnabled_ = true; break; case SKYTYPE_PLANE: try { ///\todo Ogre::Plane plane; plane.d = skyPlaneParameters.distance; plane.normal = Ogre::Vector3::NEGATIVE_UNIT_Z; scene_mgr->setSkyPlane(true, plane, skyPlaneParameters.material, skyPlaneParameters.scale, skyPlaneParameters.tiling, true, skyPlaneParameters.bow, skyPlaneParameters.xSegments, skyPlaneParameters.ySegments); } catch (Ogre::Exception& e) { OgreRenderingModule::LogError("Could not set SkyPlane: " + std::string(e.what())); return; } skyEnabled_ = true; break; case SKYTYPE_NONE: default: skyEnabled_ = false; break; } }
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; }