Files

1757 lines
69 KiB
C++

#include "renderingmanager.hpp"
#include <cstdlib>
#include <sstream>
#include <osg/ClipControl>
#include <osg/ComputeBoundsVisitor>
#include <osg/Group>
#include <osg/Image>
#include <osg/Matrix>
#include <osg/UserDataContainer>
#include <osgDB/Registry>
#include <osgUtil/LineSegmentIntersector>
#include <osgViewer/Viewer>
#include <components/nifosg/nifloader.hpp>
#include <components/debug/debuglog.hpp>
#include <components/stereo/multiview.hpp>
#include <components/stereo/stereomanager.hpp>
#include <components/resource/imagemanager.hpp>
#include <components/resource/keyframemanager.hpp>
#include <components/resource/resourcesystem.hpp>
#include <components/shader/removedalphafunc.hpp>
#include <components/shader/shadermanager.hpp>
#include <components/settings/values.hpp>
#include <components/sceneutil/cullsafeboundsvisitor.hpp>
#include <components/sceneutil/depth.hpp>
#include <components/sceneutil/lightmanager.hpp>
#include <components/sceneutil/material.hpp>
#include <components/sceneutil/positionattitudetransform.hpp>
#include <components/sceneutil/rtt.hpp>
#include <components/sceneutil/shadow.hpp>
#include <components/sceneutil/stateupdater.hpp>
#include <components/sceneutil/texmat.hpp>
#include <components/sceneutil/userdata.hpp>
#include <components/sceneutil/visitor.hpp>
#include <components/sceneutil/workqueue.hpp>
#include <components/sceneutil/writescene.hpp>
#include <components/misc/constants.hpp>
#include <components/terrain/quadtreeworld.hpp>
#include <components/terrain/terraingrid.hpp>
#include <components/esm3/loadcell.hpp>
#include <components/esm4/loadcell.hpp>
#include <components/debug/debugdraw.hpp>
#include <components/detournavigator/navigator.hpp>
#include <components/detournavigator/navmeshcacheitem.hpp>
#include "../mwworld/cellstore.hpp"
#include "../mwworld/class.hpp"
#include "../mwworld/groundcoverstore.hpp"
#include "../mwworld/scene.hpp"
#include "../mwworld/weather.hpp"
#include "../mwgui/postprocessorhud.hpp"
#include "../mwmechanics/actorutil.hpp"
#include "../mwbase/environment.hpp"
#include "../mwbase/windowmanager.hpp"
#include "../mwbase/world.hpp"
#include "actorspaths.hpp"
#include "camera.hpp"
#include "characterpreview.hpp"
#include "effectmanager.hpp"
#include "fogmanager.hpp"
#include "groundcover.hpp"
#include "localmap.hpp"
#include "navmesh.hpp"
#include "npcanimation.hpp"
#include "objectpaging.hpp"
#include "pathgrid.hpp"
#include "postprocessor.hpp"
#include "recastmesh.hpp"
#include "screenshotmanager.hpp"
#include "sky.hpp"
#include "terrainstorage.hpp"
#include "util.hpp"
#include "vismask.hpp"
#include "water.hpp"
namespace
{
class LightManagerUpdateVisitor : public osg::NodeVisitor
{
public:
LightManagerUpdateVisitor()
: osg::NodeVisitor(TRAVERSE_ALL_CHILDREN)
{
setNodeMaskOverride(~0u);
}
void apply(osg::Node& node) override
{
if (auto* rtt = dynamic_cast<SceneUtil::RTTNode*>(&node))
{
for (const auto& [_, vdd] : rtt->getViewDependentDataMap())
{
traverse(*vdd->mCamera.get());
}
}
traverse(node);
}
void apply(osg::Group& node) override
{
if (auto* lm = dynamic_cast<SceneUtil::LightManager*>(&node))
{
if (mDoThreadUnsafeOps)
{
lm->updateMaxLights(Settings::shaders().mMaxLights);
lm->enableClustered(Settings::shaders().mClusteredLighting);
}
lm->processChangedSettings(Settings::shaders().mLightRadiusMultiplier,
Settings::shaders().mMaximumLightDistance, Settings::shaders().mLightFadeStart);
return;
}
traverse(node);
}
void setDoThreadUnsafeOps(bool doThreadUnsafeOps) { mDoThreadUnsafeOps = doThreadUnsafeOps; }
private:
bool mDoThreadUnsafeOps = false;
};
unsigned int getIndoorShadowCastingMask()
{
unsigned int mask = MWRender::Mask_Scene;
if (Settings::shadows().mActorShadows)
mask |= MWRender::Mask_Actor;
if (Settings::shadows().mPlayerShadows)
mask |= MWRender::Mask_Player;
return mask;
}
unsigned int getOutdoorShadowCastingMask()
{
unsigned int mask = getIndoorShadowCastingMask();
if (Settings::shadows().mObjectShadows)
mask |= (MWRender::Mask_Object | MWRender::Mask_Static);
if (Settings::shadows().mTerrainShadows)
mask |= MWRender::Mask_Terrain;
return mask;
}
}
namespace MWRender
{
class PreloadCommonAssetsWorkItem : public SceneUtil::WorkItem
{
public:
PreloadCommonAssetsWorkItem(Resource::ResourceSystem* resourceSystem)
: mResourceSystem(resourceSystem)
{
}
void doWork() override
{
try
{
for (const VFS::Path::Normalized& v : mModels)
mResourceSystem->getSceneManager()->getTemplate(v);
for (const VFS::Path::Normalized& v : mTextures)
mResourceSystem->getImageManager()->getImage(v);
for (const VFS::Path::Normalized& v : mKeyframes)
mResourceSystem->getKeyframeManager()->get(v);
}
catch (const std::exception& e)
{
Log(Debug::Warning) << "Failed to preload common assets: " << e.what();
}
}
std::vector<VFS::Path::Normalized> mModels;
std::vector<VFS::Path::Normalized> mTextures;
std::vector<VFS::Path::Normalized> mKeyframes;
private:
Resource::ResourceSystem* mResourceSystem;
};
RenderingManager::RenderingManager(osgViewer::Viewer* viewer, osg::ref_ptr<osg::Group> rootNode,
Resource::ResourceSystem* resourceSystem, const std::shared_ptr<SceneUtil::WorkQueue>& workQueue,
DetourNavigator::Navigator& navigator, const MWWorld::GroundcoverStore& groundcoverStore,
SceneUtil::UnrefQueue& unrefQueue)
: mSkyBlending(Settings::fog().mSkyBlending)
, mViewer(viewer)
, mRootNode(rootNode)
, mResourceSystem(resourceSystem)
, mWorkQueue(workQueue)
, mNavigator(navigator)
, mNightEyeFactor(0.f)
// TODO: Near clip should not need to be bounded like this, but too small values break OSG shadow calculations
// CPU-side. See issue: #6072
, mNearClip(Settings::camera().mNearClip)
, mViewDistance(Settings::camera().mViewingDistance)
, mFieldOfViewOverridden(false)
, mFieldOfViewOverride(0.f)
, mFieldOfView(Settings::camera().mFieldOfView)
, mFirstPersonFieldOfView(Settings::camera().mFirstPersonFieldOfView)
, mGroundCoverStore(groundcoverStore)
{
bool reverseZ = SceneUtil::AutoDepth::isReversed();
resourceSystem->getSceneManager()->setParticleSystemMask(MWRender::Mask_ParticleSystem);
resourceSystem->getSceneManager()->setAutoUseNormalMaps(Settings::shaders().mAutoUseObjectNormalMaps);
resourceSystem->getSceneManager()->setNormalMapPattern(Settings::shaders().mNormalMapPattern);
resourceSystem->getSceneManager()->setNormalHeightMapPattern(Settings::shaders().mNormalHeightMapPattern);
resourceSystem->getSceneManager()->setAutoUseSpecularMaps(Settings::shaders().mAutoUseObjectSpecularMaps);
resourceSystem->getSceneManager()->setSpecularMapPattern(Settings::shaders().mSpecularMapPattern);
resourceSystem->getSceneManager()->setConvertAlphaTestToAlphaToCoverage(shouldAddMSAAIntermediateTarget());
resourceSystem->getSceneManager()->setAdjustCoverageForAlphaTest(
Settings::shaders().mAdjustCoverageForAlphaTest);
// Let LightManager choose which backend to use based on our hint.
// Ultimately dependent on support for various OpenGL extensions.
osg::ref_ptr<SceneUtil::LightManager> sceneRoot = new SceneUtil::LightManager(
SceneUtil::LightSettings{
.mClusteredLighting = Settings::shaders().mClusteredLighting,
.mMaxLights = Settings::shaders().mMaxLights,
.mMaximumLightDistance = Settings::shaders().mMaximumLightDistance,
.mLightFadeStart = Settings::shaders().mLightFadeStart,
.mLightRadiusMultiplier = Settings::shaders().mLightRadiusMultiplier,
},
resourceSystem);
resourceSystem->getSceneManager()->setSupportsClusteredLighting(sceneRoot->isClusteredSupported());
// Sync clustered lighting setting so it's more intuitive when viewed in the in-game setting panel
Settings::shaders().mClusteredLighting.set(sceneRoot->getClusteredLighting());
sceneRoot->setLightingMask(Mask_Lighting);
mSceneRoot = sceneRoot;
sceneRoot->setNodeMask(Mask_Scene);
sceneRoot->setName("Scene Root");
mShadowManager = std::make_unique<SceneUtil::ShadowManager>(sceneRoot, mRootNode, getOutdoorShadowCastingMask(),
getIndoorShadowCastingMask(), Mask_Terrain | Mask_Object | Mask_Static, Settings::shadows(),
mResourceSystem->getSceneManager()->getShaderManager());
Shader::ShaderManager::DefineMap globalDefines = Shader::getDefaultDefines();
mAppliedShadowDefines = mShadowManager->getShadowDefines(Settings::shadows());
Shader::ShaderManager::DefineMap lightDefines = sceneRoot->getLightDefines();
for (const auto& [key, value] : mAppliedShadowDefines)
globalDefines[key] = value;
globalDefines["forcePPL"] = Settings::shaders().mForcePerPixelLighting ? "1" : "0";
globalDefines["clamp"] = Settings::shaders().mClampLighting ? "1" : "0";
globalDefines["preLightEnv"] = Settings::shaders().mApplyLightingToEnvironmentMaps ? "1" : "0";
globalDefines["classicFalloff"] = Settings::shaders().mClassicFalloff ? "1" : "0";
const bool exponentialFog = Settings::fog().mExponentialFog;
globalDefines["radialFog"] = (exponentialFog || Settings::fog().mRadialFog) ? "1" : "0";
globalDefines["exponentialFog"] = exponentialFog ? "1" : "0";
globalDefines["skyBlending"] = mSkyBlending ? "1" : "0";
globalDefines["particlePointLighting"] = Settings::shaders().mParticlePointLighting ? "1" : "0";
for (auto itr = lightDefines.begin(); itr != lightDefines.end(); itr++)
globalDefines[itr->first] = itr->second;
// Refactor this at some point - most shaders don't care about these defines
const float groundcoverDistance = Settings::groundcover().mRenderingDistance;
globalDefines["groundcoverFadeStart"] = std::to_string(groundcoverDistance * 0.9f);
globalDefines["groundcoverFadeEnd"] = std::to_string(groundcoverDistance);
globalDefines["groundcoverStompMode"] = std::to_string(Settings::groundcover().mStompMode);
globalDefines["groundcoverStompIntensity"] = std::to_string(Settings::groundcover().mStompIntensity);
globalDefines["reverseZ"] = reverseZ ? "1" : "0";
// It is unnecessary to stop/start the viewer as no frames are being rendered yet.
mResourceSystem->getSceneManager()->getShaderManager().setGlobalDefines(globalDefines);
// Only set up the shadow casting shaders once our global defines have been set
mShadowManager->setupShaders(mResourceSystem->getSceneManager()->getShaderManager());
mNavMesh = std::make_unique<NavMesh>(mRootNode, mWorkQueue, Settings::navigator().mEnableNavMeshRender,
Settings::navigator().mNavMeshRenderMode);
mActorsPaths = std::make_unique<ActorsPaths>(mRootNode, Settings::navigator().mEnableAgentsPathsRender);
mRecastMesh = std::make_unique<RecastMesh>(mRootNode, Settings::navigator().mEnableRecastMeshRender);
mPathgrid = std::make_unique<Pathgrid>(mRootNode);
mObjects = std::make_unique<Objects>(mResourceSystem, sceneRoot, unrefQueue);
if (getenv("OPENMW_DONT_PRECOMPILE") == nullptr)
{
mViewer->setIncrementalCompileOperation(new osgUtil::IncrementalCompileOperation);
mViewer->getIncrementalCompileOperation()->setTargetFrameRate(Settings::cells().mTargetFramerate);
}
mDebugDraw = new Debug::DebugDrawer(mResourceSystem->getSceneManager()->getShaderManager());
mDebugDraw->setNodeMask(Mask_Debug);
sceneRoot->addChild(mDebugDraw);
mResourceSystem->getSceneManager()->setIncrementalCompileOperation(mViewer->getIncrementalCompileOperation());
mEffectManager = std::make_unique<EffectManager>(sceneRoot, mResourceSystem);
const std::string& normalMapPattern = Settings::shaders().mNormalMapPattern;
const std::string& heightMapPattern = Settings::shaders().mNormalHeightMapPattern;
const std::string& specularMapPattern = Settings::shaders().mTerrainSpecularMapPattern;
const bool useTerrainNormalMaps = Settings::shaders().mAutoUseTerrainNormalMaps;
const bool useTerrainSpecularMaps = Settings::shaders().mAutoUseTerrainSpecularMaps;
mTerrainStorage = std::make_unique<TerrainStorage>(mResourceSystem, normalMapPattern, heightMapPattern,
useTerrainNormalMaps, specularMapPattern, useTerrainSpecularMaps);
WorldspaceChunkMgr& chunkMgr = getWorldspaceChunkMgr(ESM::Cell::sDefaultWorldspaceId);
mTerrain = chunkMgr.mTerrain.get();
mGroundcover = chunkMgr.mGroundcover.get();
mObjectPaging = chunkMgr.mObjectPaging.get();
mStateUpdater = new SceneUtil::StateUpdater();
sceneRoot->addUpdateCallback(mStateUpdater);
mSharedUniformStateUpdater = new SceneUtil::SharedUniformStateUpdater(Settings::fog().mSkyBlendingStart);
rootNode->addUpdateCallback(mSharedUniformStateUpdater);
mPerViewUniformStateUpdater = new SceneUtil::PerViewUniformStateUpdater(mResourceSystem->getSceneManager(),
mResourceSystem->getSceneManager()->getShaderManager().reserveGlobalTextureUnits(
Shader::ShaderManager::Slot::OpaqueDepthTexture),
mResourceSystem->getSceneManager()->getShaderManager().reserveGlobalTextureUnits(
Shader::ShaderManager::Slot::OpaqueColorTexture));
rootNode->addCullCallback(mPerViewUniformStateUpdater);
mPostProcessor = new PostProcessor(*this, viewer, mRootNode, resourceSystem->getVFS());
resourceSystem->getSceneManager()->setOpaqueDepthTex(
mPostProcessor->getTexture(PostProcessor::Tex_OpaqueDepth, 0),
mPostProcessor->getTexture(PostProcessor::Tex_OpaqueDepth, 1));
resourceSystem->getSceneManager()->setOpaqueColorTex(
mPostProcessor->getTexture(PostProcessor::Tex_OpaqueColor, 0),
mPostProcessor->getTexture(PostProcessor::Tex_OpaqueColor, 1));
resourceSystem->getSceneManager()->setSupportsNormalsRT(mPostProcessor->getSupportsNormalsRT());
resourceSystem->getSceneManager()->setWeatherParticleOcclusion(Settings::shaders().mWeatherParticleOcclusion);
// water goes after terrain for correct waterculling order
mWater = std::make_unique<Water>(
sceneRoot->getParent(0), sceneRoot, mResourceSystem, mViewer->getIncrementalCompileOperation());
mPostProcessor->setupTransparentBin(mWater.get());
mCamera = std::make_unique<Camera>(mViewer->getCamera());
mScreenshotManager = std::make_unique<ScreenshotManager>(viewer);
mViewer->setLightingMode(osgViewer::View::NO_LIGHT);
mSunLight = std::make_shared<SceneUtil::Light>();
mSunLight->setDiffuse(osg::Vec4f(0, 0, 0, 1));
mSunLight->setAmbient(osg::Vec4f(0, 0, 0, 1));
mSunLight->setSpecular(osg::Vec4f(0, 0, 0, 0));
mSunLight->setConstantAttenuation(1.f);
sceneRoot->setSunlight(mSunLight);
sceneRoot->getOrCreateStateSet()->setMode(GL_CULL_FACE, osg::StateAttribute::ON);
sceneRoot->getOrCreateStateSet()->setMode(GL_NORMALIZE, osg::StateAttribute::ON);
osg::ref_ptr<SceneUtil::Material> defaultMat(new SceneUtil::Material);
defaultMat->updateStateSet(sceneRoot->getOrCreateStateSet());
sceneRoot->getOrCreateStateSet()->setAttribute(defaultMat);
sceneRoot->getOrCreateStateSet()->addUniform(new osg::Uniform("distortionStrength", 0.f));
sceneRoot->getOrCreateStateSet()->addUniform(new osg::Uniform("alpha", 1.f));
sceneRoot->getOrCreateStateSet()->addUniform(new osg::Uniform("actorFade", 1.f));
resourceSystem->getSceneManager()->setUpNormalsRTForStateSet(sceneRoot->getOrCreateStateSet(), true);
mFog = std::make_unique<FogManager>();
mSky = std::make_unique<SkyManager>(
sceneRoot, mRootNode, mViewer->getCamera(), resourceSystem->getSceneManager(), mSkyBlending);
if (mSkyBlending)
{
int skyTextureUnit = mResourceSystem->getSceneManager()->getShaderManager().reserveGlobalTextureUnits(
Shader::ShaderManager::Slot::SkyTexture);
mPerViewUniformStateUpdater->enableSkyRTT(skyTextureUnit, mSky->getSkyRTT());
}
osg::Camera::CullingMode cullingMode = osg::Camera::DEFAULT_CULLING | osg::Camera::FAR_PLANE_CULLING;
if (!Settings::camera().mSmallFeatureCulling)
cullingMode &= ~(osg::CullStack::SMALL_FEATURE_CULLING);
else
{
mViewer->getCamera()->setSmallFeatureCullingPixelSize(Settings::camera().mSmallFeatureCullingPixelSize);
cullingMode |= osg::CullStack::SMALL_FEATURE_CULLING;
}
mViewer->getCamera()->setComputeNearFarMode(osg::Camera::DO_NOT_COMPUTE_NEAR_FAR);
mViewer->getCamera()->setCullingMode(cullingMode);
mViewer->getCamera()->setName(Constants::SceneCamera);
auto mask = ~(Mask_UpdateVisitor | Mask_SimpleWater);
MWBase::Environment::get().getWindowManager()->setCullMask(mask);
NifOsg::Loader::setHiddenNodeMask(Mask_UpdateVisitor);
NifOsg::Loader::setIntersectionDisabledNodeMask(Mask_Effect);
NifOsg::Loader::setSoftEffectEnabled(Settings::shaders().mSoftParticles);
mStateUpdater->setFogEnd(mViewDistance);
// Hopefully, anything genuinely requiring the default alpha func of GL_ALWAYS explicitly sets it
mViewer->getSceneData()->getOrCreateStateSet()->setAttribute(Shader::RemovedAlphaFunc::getInstance(GL_ALWAYS));
// The transparent renderbin sets alpha testing on because that was faster on old GPUs. It's now slower and
// breaks things.
mRootNode->getOrCreateStateSet()->setMode(GL_ALPHA_TEST, osg::StateAttribute::OFF);
if (reverseZ)
{
osg::ref_ptr<osg::ClipControl> clipcontrol
= new osg::ClipControl(osg::ClipControl::LOWER_LEFT, osg::ClipControl::ZERO_TO_ONE);
mRootNode->getOrCreateStateSet()->setAttributeAndModes(new SceneUtil::AutoDepth, osg::StateAttribute::ON);
mRootNode->getOrCreateStateSet()->setAttributeAndModes(clipcontrol, osg::StateAttribute::ON);
}
SceneUtil::initTexMatForStateSet(*mViewer->getSceneData()->getOrCreateStateSet());
mRootNode->getOrCreateStateSet()->setMode(
GL_LIGHTING, osg::StateAttribute::OFF | osg::StateAttribute::PROTECTED | osg::StateAttribute::OVERRIDE);
SceneUtil::setCameraClearDepth(mViewer->getCamera());
updateProjectionMatrix();
mViewer->getCamera()->setClearMask(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT);
}
RenderingManager::~RenderingManager()
{
// let background loading thread finish before we delete anything else
mWorkQueue = nullptr;
}
osgUtil::IncrementalCompileOperation* RenderingManager::getIncrementalCompileOperation()
{
return mViewer->getIncrementalCompileOperation();
}
MWRender::Objects& RenderingManager::getObjects()
{
return *mObjects.get();
}
Resource::ResourceSystem* RenderingManager::getResourceSystem()
{
return mResourceSystem;
}
std::unique_ptr<InventoryPreview> RenderingManager::createInventoryPreview(const MWWorld::Ptr& character)
{
return std::make_unique<InventoryPreview>(mRootNode, mResourceSystem, character);
}
std::unique_ptr<RaceSelectionPreview> RenderingManager::createRaceSelectionPreview()
{
return std::make_unique<RaceSelectionPreview>(mRootNode, mResourceSystem);
}
std::unique_ptr<LocalMap> RenderingManager::createLocalMap()
{
return std::make_unique<LocalMap>(mRootNode);
}
const std::shared_ptr<SceneUtil::WorkQueue>& RenderingManager::getWorkQueue() const
{
return mWorkQueue;
}
Terrain::World* RenderingManager::getTerrain()
{
return mTerrain;
}
void RenderingManager::preloadCommonAssets(const MWWorld::WeatherStore& weathers)
{
auto workItem = std::make_shared<PreloadCommonAssetsWorkItem>(mResourceSystem);
for (const MWWorld::Weather* weather : weathers)
{
if (!weather->mParticleEffect.empty())
workItem->mModels.push_back(weather->mParticleEffect);
}
mSky->listAssetsToPreload(workItem->mModels, workItem->mTextures);
mWater->listAssetsToPreload(workItem->mTextures);
workItem->mModels.push_back(Settings::models().mXbaseanim);
workItem->mModels.push_back(Settings::models().mXbaseanim1st);
workItem->mModels.push_back(Settings::models().mXbaseanimfemale);
workItem->mModels.push_back(Settings::models().mXargonianswimkna);
workItem->mKeyframes.push_back(Settings::models().mXbaseanimkf);
workItem->mKeyframes.push_back(Settings::models().mXbaseanim1stkf);
workItem->mKeyframes.push_back(Settings::models().mXbaseanimfemalekf);
workItem->mKeyframes.push_back(Settings::models().mXargonianswimknakf);
workItem->mTextures.emplace_back("textures/_land_default.dds");
mWorkQueue->addWorkItem(std::move(workItem));
}
double RenderingManager::getReferenceTime() const
{
return mViewer->getFrameStamp()->getReferenceTime();
}
SceneUtil::LightManager* RenderingManager::getLightRoot()
{
return mSceneRoot.get();
}
void RenderingManager::setNightEyeFactor(float factor)
{
if (factor != mNightEyeFactor)
{
mNightEyeFactor = factor;
updateAmbient();
}
}
void RenderingManager::setAmbientColour(const osg::Vec4f& colour)
{
mAmbientColor = colour;
updateAmbient();
}
int RenderingManager::skyGetMasserPhase() const
{
return mSky->getMasserPhase();
}
int RenderingManager::skyGetSecundaPhase() const
{
return mSky->getSecundaPhase();
}
void RenderingManager::skySetMoonColour(bool red)
{
mSky->setMoonColour(red);
}
void RenderingManager::configureAmbient(const MWWorld::Cell& cell)
{
bool isInterior = !cell.isExterior() && !cell.isQuasiExterior();
bool needsAdjusting = false;
needsAdjusting = isInterior && (!Settings::shaders().mClassicFalloff || Settings::shaders().mClusteredLighting);
osg::Vec4f ambient = SceneUtil::colourFromRGB(cell.getMood().mAmbiantColor);
if (needsAdjusting)
{
constexpr float pR = 0.2126f;
constexpr float pG = 0.7152f;
constexpr float pB = 0.0722f;
// we already work in linear RGB so no conversions are needed for the luminosity function
float relativeLuminance = pR * ambient.r() + pG * ambient.g() + pB * ambient.b();
const float minimumAmbientLuminance = Settings::shaders().mMinimumInteriorBrightness;
if (relativeLuminance < minimumAmbientLuminance)
{
// brighten ambient so it reaches the minimum threshold but no more, we want to mess with content data
// as least we can
if (ambient.r() == 0.f && ambient.g() == 0.f && ambient.b() == 0.f)
ambient = osg::Vec4(
minimumAmbientLuminance, minimumAmbientLuminance, minimumAmbientLuminance, ambient.a());
else
ambient *= minimumAmbientLuminance / relativeLuminance;
}
}
setAmbientColour(ambient);
osg::Vec4f diffuse = SceneUtil::colourFromRGB(cell.getMood().mDirectionalColor);
setSunColour(diffuse, diffuse, 0.f);
// This is total nonsense but it's what Morrowind uses
static const osg::Vec4f interiorSunPos
= osg::Vec4f(-1.f, osg::DegreesToRadians(45.f), osg::DegreesToRadians(45.f), 0.f);
mPostProcessor->getStateUpdater()->setSunPos(interiorSunPos, false);
mPostProcessor->getStateUpdater()->setSunVec(-interiorSunPos);
mSunLight->setPosition(interiorSunPos);
}
void RenderingManager::setSunColour(const osg::Vec4f& diffuse, const osg::Vec4f& specular, float sunVis)
{
// need to wrap this in a StateUpdater?
mSunLight->setDiffuse(diffuse);
mSunLight->setSpecular(osg::Vec4f(specular.x(), specular.y(), specular.z(), specular.w() * sunVis));
mPostProcessor->getStateUpdater()->setSunColor(diffuse);
mPostProcessor->getStateUpdater()->setSunVis(sunVis);
}
const osg::Vec4f& RenderingManager::getSunLightPosition() const
{
return mSunLight->getPosition();
}
void RenderingManager::setSunDirection(const osg::Vec3f& direction)
{
osg::Vec3f position = -direction;
// This is based on the exterior sun orbit and won't make sense for interiors, see WeatherManager::update
position.z() = 400.f - std::abs(position.x());
// The sun is not always synchronized with the sunlight because reasons
const osg::Vec3f sunlightPos = Settings::shaders().mMatchSunlightToSun ? position : -direction;
// need to wrap this in a StateUpdater?
mSunLight->setPosition(osg::Vec4f(sunlightPos, 0.f));
mSky->setSunDirection(position);
mPostProcessor->getStateUpdater()->setSunPos(osg::Vec4f(position, 0.f), mNight);
mPostProcessor->getStateUpdater()->setSunVec(osg::Vec4f(-sunlightPos, 0.f));
}
void RenderingManager::addCell(const MWWorld::CellStore* store)
{
mPathgrid->addCell(store);
mWater->changeCell(store);
if (store->getCell()->isExterior())
{
enableTerrain(true, store->getCell()->getWorldSpace());
mTerrain->loadCell(store->getCell()->getGridX(), store->getCell()->getGridY());
}
}
void RenderingManager::removeCell(const MWWorld::CellStore* store)
{
mPathgrid->removeCell(store);
mActorsPaths->removeCell(store);
mObjects->removeCell(store);
if (store->getCell()->isExterior())
{
getWorldspaceChunkMgr(store->getCell()->getWorldSpace())
.mTerrain->unloadCell(store->getCell()->getGridX(), store->getCell()->getGridY());
}
mWater->removeCell(store);
}
void RenderingManager::enableTerrain(bool enable, ESM::RefId worldspace)
{
if (!enable)
mWater->setCullCallback(nullptr);
else
{
WorldspaceChunkMgr& newChunks = getWorldspaceChunkMgr(worldspace);
if (newChunks.mTerrain.get() != mTerrain)
{
mTerrain->enable(false);
mTerrain = newChunks.mTerrain.get();
mGroundcover = newChunks.mGroundcover.get();
mObjectPaging = newChunks.mObjectPaging.get();
}
}
mTerrain->enable(enable);
}
void RenderingManager::setSkyEnabled(bool enabled)
{
mSky->setEnabled(enabled);
if (enabled)
mShadowManager->enableOutdoorMode();
else
mShadowManager->enableIndoorMode(Settings::shadows());
mPostProcessor->getStateUpdater()->setIsInterior(!enabled);
}
bool RenderingManager::toggleBorders()
{
bool borders = !mTerrain->getBordersVisible();
mTerrain->setBordersVisible(borders);
return borders;
}
bool RenderingManager::toggleRenderMode(RenderMode mode)
{
if (mode == Render_CollisionDebug || mode == Render_Pathgrid)
return mPathgrid->toggleRenderMode(mode);
else if (mode == Render_Wireframe)
{
bool wireframe = !mStateUpdater->getWireframe();
mStateUpdater->setWireframe(wireframe);
return wireframe;
}
else if (mode == Render_Water)
{
const bool enabled = mWater->toggle();
mStateUpdater->setWaterEnabled(mWater->isVisible());
return enabled;
}
else if (mode == Render_Scene)
{
const auto wm = MWBase::Environment::get().getWindowManager();
unsigned int mask = wm->getCullMask();
bool enabled = !(mask & sToggleWorldMask);
if (enabled)
mask |= sToggleWorldMask;
else
mask &= ~sToggleWorldMask;
mWater->showWorld(enabled);
wm->setCullMask(mask);
return enabled;
}
else if (mode == Render_NavMesh)
{
return mNavMesh->toggle();
}
else if (mode == Render_ActorsPaths)
{
return mActorsPaths->toggle();
}
else if (mode == Render_RecastMesh)
{
return mRecastMesh->toggle();
}
return false;
}
void RenderingManager::configureFog(const MWWorld::Cell& cell)
{
mFog->configure(mViewDistance, cell);
}
void RenderingManager::configureFog(
float fogDepth, float underwaterFog, float dlFactor, float dlOffset, const osg::Vec4f& color)
{
mFog->configure(mViewDistance, fogDepth, underwaterFog, dlFactor, dlOffset, color);
}
SkyManager* RenderingManager::getSkyManager()
{
return mSky.get();
}
void RenderingManager::update(float dt, bool paused)
{
reportStats();
mResourceSystem->getSceneManager()->getShaderManager().update(*mViewer);
mWater->setRainIntensity(mSky->getRainRipplesEnabled() ? mSky->getPrecipitationAlpha() : 0.f);
mWater->update(dt, paused);
if (!paused)
{
mEffectManager->update(dt);
mSky->update(dt);
const MWWorld::Ptr& player = mPlayerAnimation->getPtr();
osg::Vec3f playerPos(player.getRefData().getPosition().asVec3());
float windSpeed = mSky->getBaseWindSpeed();
mSharedUniformStateUpdater->setWindSpeed(windSpeed);
mSharedUniformStateUpdater->setPlayerPos(playerPos);
}
updateNavMesh();
updateRecastMesh();
if (mUpdateProjectionMatrix)
{
mUpdateProjectionMatrix = false;
updateProjectionMatrix();
}
mCamera->update(dt, paused);
float fogStart = mFog->getFogStart(false);
float fogEnd = mFog->getFogEnd(false);
osg::Vec4f fogColor = mFog->getFogColor(false);
float fogUnderwaterStart = mFog->getFogStart(true);
float fogUnderwaterEnd = mFog->getFogEnd(true);
osg::Vec4f fogUnderwaterColor = mFog->getFogColor(true);
bool isUnderwater = mWater->isUnderwater(mCamera->getPosition());
mStateUpdater->setFogColor(fogColor);
mStateUpdater->setFogStart(fogStart);
mStateUpdater->setFogEnd(fogEnd);
mStateUpdater->setUnderwaterFogStart(fogUnderwaterStart);
mStateUpdater->setUnderwaterFogEnd(fogUnderwaterEnd);
mStateUpdater->setUnderwaterFogColor(fogUnderwaterColor);
mViewer->getCamera()->setClearColor(isUnderwater ? fogUnderwaterColor : fogColor);
auto world = MWBase::Environment::get().getWorld();
const auto& stateUpdater = mPostProcessor->getStateUpdater();
stateUpdater->setFogRange(fogStart, fogEnd);
stateUpdater->setNearFar(mNearClip, mViewDistance);
stateUpdater->setIsUnderwater(isUnderwater);
stateUpdater->setFogColor(fogColor);
stateUpdater->setGameHour(world->getTimeStamp().getHour());
stateUpdater->setWeatherId(world->getCurrentWeatherScriptId());
stateUpdater->setNextWeatherId(world->getNextWeatherScriptId());
stateUpdater->setWeatherTransition(world->getWeatherTransition());
stateUpdater->setWindSpeed(world->getWindSpeed());
stateUpdater->setSkyColor(mSky->getSkyColor());
mPostProcessor->setUnderwaterFlag(isUnderwater);
}
void RenderingManager::updatePlayerPtr(const MWWorld::Ptr& ptr)
{
if (mPlayerAnimation.get())
{
setupPlayer(ptr);
mPlayerAnimation->updatePtr(ptr);
}
mCamera->attachTo(ptr);
}
void RenderingManager::removePlayer(const MWWorld::Ptr& player)
{
mWater->removeEmitter(player);
}
void RenderingManager::rotateObject(const MWWorld::Ptr& ptr, const osg::Quat& rot)
{
if (ptr == mCamera->getTrackingPtr() && !mCamera->isVanityOrPreviewModeEnabled())
{
mCamera->rotateCameraToTrackingPtr();
}
ptr.getRefData().getBaseNode()->setAttitude(rot);
}
void RenderingManager::moveObject(const MWWorld::Ptr& ptr, const osg::Vec3f& pos)
{
ptr.getRefData().getBaseNode()->setPosition(pos);
}
void RenderingManager::scaleObject(const MWWorld::Ptr& ptr, const osg::Vec3f& scale)
{
ptr.getRefData().getBaseNode()->setScale(scale);
if (ptr == mCamera->getTrackingPtr()) // update height of camera
mCamera->processViewChange();
}
void RenderingManager::removeObject(const MWWorld::Ptr& ptr)
{
mActorsPaths->remove(ptr);
mObjects->removeObject(ptr);
mWater->removeEmitter(ptr);
}
void RenderingManager::setWaterEnabled(bool enabled)
{
mWater->setEnabled(enabled);
mSky->setWaterEnabled(enabled);
mStateUpdater->setWaterEnabled(mWater->isVisible());
mPostProcessor->getStateUpdater()->setIsWaterEnabled(enabled);
}
void RenderingManager::setWaterHeight(float height)
{
mWater->setCullCallback(mTerrain->getHeightCullCallback(height, Mask_Water));
mWater->setHeight(height);
mSky->setWaterHeight(height);
mStateUpdater->setWaterHeight(height);
mPostProcessor->getStateUpdater()->setWaterHeight(height);
}
std::vector<char> RenderingManager::screenshot(int w, int h)
{
osg::ref_ptr<osg::Image> image(new osg::Image);
mScreenshotManager->screenshot(image.get(), w, h);
osgDB::ReaderWriter* readerwriter = osgDB::Registry::instance()->getReaderWriterForExtension("jpg");
if (!readerwriter)
{
Log(Debug::Error) << "Error: Unable to write screenshot, can't find a jpg ReaderWriter";
return {};
}
std::ostringstream ostream;
osgDB::ReaderWriter::WriteResult result = readerwriter->writeImage(*image, ostream);
if (!result.success())
{
Log(Debug::Error) << "Error: Unable to write screenshot: " << result.message() << " code "
<< result.status();
return {};
}
const std::string data = ostream.str();
return std::vector<char>(data.begin(), data.end());
}
osg::BoundingBox RenderingManager::getObjectBounds(const MWWorld::Ptr& ptr, unsigned int ignoreMask) const
{
SceneUtil::PositionAttitudeTransform* baseNode = ptr.getRefData().getBaseNode();
if (baseNode == nullptr)
return {};
osg::ComputeBoundsVisitor computeBounds;
computeBounds.setTraversalMask(~ignoreMask);
baseNode->accept(computeBounds);
return computeBounds.getBoundingBox();
}
osg::Vec2f RenderingManager::getScreenCoords(const osg::BoundingBox& bb)
{
if (bb.valid())
{
const osg::Matrix viewProj
= mViewer->getCamera()->getViewMatrix() * mViewer->getCamera()->getProjectionMatrix();
const osg::Vec3f worldPoint((bb.xMin() + bb.xMax()) * 0.5f, (bb.yMin() + bb.yMax()) * 0.5f, bb.zMax());
const osg::Vec4f clipPoint = osg::Vec4f(worldPoint, 1.0f) * viewProj;
if (clipPoint.w() > 0.f)
{
const float screenPointX = (clipPoint.x() / clipPoint.w() + 1.f) * 0.5f;
const float screenPointY = (clipPoint.y() / clipPoint.w() - 1.f) * (-0.5f);
if (screenPointX >= 0.f && screenPointX <= 1.f && screenPointY >= 0.f && screenPointY <= 1.f)
return osg::Vec2f(screenPointX, screenPointY);
}
}
return osg::Vec2f(0.5f, 0.f);
}
RenderingManager::RayResult getIntersectionResult(osgUtil::LineSegmentIntersector* intersector,
const osg::ref_ptr<osgUtil::IntersectionVisitor>& visitor, std::span<const MWWorld::Ptr> ignoreList = {})
{
constexpr auto nonObjectWorldMask = Mask_Terrain | Mask_Water;
RenderingManager::RayResult result;
result.mHit = false;
result.mRatio = 0;
if (!intersector->containsIntersections())
return result;
auto test = [&](const osgUtil::LineSegmentIntersector::Intersection& intersection) {
const MWWorld::Ptr* hitPtr = nullptr;
std::vector<const RefnumMarker*> refnumMarkers;
bool hitNonObjectWorld = false;
for (osg::Node* node : intersection.nodePath)
{
const auto& nodeMask = node->getNodeMask();
if (!hitNonObjectWorld)
hitNonObjectWorld = nodeMask & nonObjectWorldMask;
SceneUtil::forEachUserData<MWWorld::Ptr>(*node, [&](const MWWorld::Ptr& ptr) {
if (std::find(ignoreList.begin(), ignoreList.end(), ptr) == ignoreList.end())
hitPtr = &ptr;
});
SceneUtil::forEachUserData<RefnumMarker>(
*node, [&](const RefnumMarker& marker) { refnumMarkers.push_back(&marker); });
}
if (hitPtr)
result.mHitObject = *hitPtr;
unsigned int vertexCounter = 0;
for (unsigned int i = 0; i < refnumMarkers.size(); ++i)
{
unsigned int intersectionIndex = intersection.indexList.empty() ? 0 : intersection.indexList[0];
if (!refnumMarkers[i]->mNumVertices
|| (intersectionIndex >= vertexCounter
&& intersectionIndex < vertexCounter + refnumMarkers[i]->mNumVertices))
{
auto it = std::find_if(
ignoreList.begin(), ignoreList.end(), [target = refnumMarkers[i]->mRefnum](const auto& ptr) {
return target == ptr.getCellRef().getRefNum();
});
if (it == ignoreList.end())
{
result.mHitRefnum = refnumMarkers[i]->mRefnum;
}
break;
}
vertexCounter += refnumMarkers[i]->mNumVertices;
}
if (!result.mHitObject.isEmpty() || result.mHitRefnum.isSet() || hitNonObjectWorld)
{
result.mHit = true;
result.mHitPointWorld = intersection.getWorldIntersectPoint();
result.mHitNormalWorld = intersection.getWorldIntersectNormal();
result.mRatio = static_cast<float>(intersection.ratio);
}
};
if (ignoreList.empty() || intersector->getIntersectionLimit() != osgUtil::LineSegmentIntersector::NO_LIMIT)
{
test(intersector->getFirstIntersection());
}
else
{
for (const auto& intersection : intersector->getIntersections())
{
test(intersection);
if (result.mHit)
{
break;
}
}
}
return result;
}
class IntersectionVisitorWithIgnoreList : public osgUtil::IntersectionVisitor
{
public:
bool skipTransform(osg::Transform& transform)
{
if (mContainsPagedRefs)
return false;
if (const MWWorld::Ptr* p = SceneUtil::findUserData<MWWorld::Ptr>(transform))
return std::find(mIgnoreList.begin(), mIgnoreList.end(), *p) != mIgnoreList.end();
return false;
}
void apply(osg::Transform& transform) override
{
if (skipTransform(transform))
{
return;
}
osgUtil::IntersectionVisitor::apply(transform);
}
void setIgnoreList(std::span<const MWWorld::Ptr> ignoreList) { mIgnoreList = ignoreList; }
void setContainsPagedRefs(bool contains) { mContainsPagedRefs = contains; }
private:
std::span<const MWWorld::Ptr> mIgnoreList;
bool mContainsPagedRefs = false;
};
osg::ref_ptr<osgUtil::IntersectionVisitor> RenderingManager::getIntersectionVisitor(
osgUtil::Intersector* intersector, bool ignorePlayer, bool ignoreActors, bool ignoreTerrain,
std::span<const MWWorld::Ptr> ignoreList)
{
if (!mIntersectionVisitor)
mIntersectionVisitor = new IntersectionVisitorWithIgnoreList;
mIntersectionVisitor->setIgnoreList(ignoreList);
mIntersectionVisitor->setContainsPagedRefs(false);
MWWorld::Scene* worldScene = MWBase::Environment::get().getWorldScene();
for (const auto& ptr : ignoreList)
{
if (worldScene->isPagedRef(ptr))
{
mIntersectionVisitor->setContainsPagedRefs(true);
intersector->setIntersectionLimit(osgUtil::LineSegmentIntersector::NO_LIMIT);
break;
}
}
mIntersectionVisitor->setTraversalNumber(mViewer->getFrameStamp()->getFrameNumber());
mIntersectionVisitor->setFrameStamp(mViewer->getFrameStamp());
mIntersectionVisitor->setIntersector(intersector);
// Terrain picks its LOD from the eye point.
mIntersectionVisitor->setReferenceEyePoint(osg::Vec3f());
mIntersectionVisitor->setReferenceEyePointCoordinateFrame(osgUtil::Intersector::VIEW);
unsigned int mask = ~0u;
mask &= ~(Mask_RenderToTexture | Mask_Sky | Mask_Debug | Mask_Effect | Mask_Water | Mask_SimpleWater
| Mask_Groundcover);
if (ignorePlayer)
mask &= ~(Mask_Player);
if (ignoreActors)
mask &= ~(Mask_Actor | Mask_Player);
if (ignoreTerrain)
mask &= ~(Mask_Terrain);
mIntersectionVisitor->setTraversalMask(mask);
return mIntersectionVisitor;
}
RenderingManager::RayResult RenderingManager::castRay(const osg::Vec3f& origin, const osg::Vec3f& dest,
bool ignorePlayer, bool ignoreActors, bool ignoreTerrain, std::span<const MWWorld::Ptr> ignoreList)
{
osg::ref_ptr<osgUtil::LineSegmentIntersector> intersector(
new osgUtil::LineSegmentIntersector(osgUtil::LineSegmentIntersector::MODEL, origin, dest));
intersector->setIntersectionLimit(osgUtil::LineSegmentIntersector::LIMIT_NEAREST);
osg::ref_ptr<osgUtil::IntersectionVisitor> visitor
= getIntersectionVisitor(intersector, ignorePlayer, ignoreActors, ignoreTerrain, ignoreList);
visitor->setReferenceEyePoint(origin);
visitor->setReferenceEyePointCoordinateFrame(osgUtil::Intersector::MODEL);
mRootNode->accept(*visitor);
return getIntersectionResult(intersector, mIntersectionVisitor, ignoreList);
}
RenderingManager::RayResult RenderingManager::castCameraToViewportRay(
const float nX, const float nY, float maxDistance, bool ignorePlayer, bool ignoreActors, bool ignoreTerrain)
{
osg::ref_ptr<osgUtil::LineSegmentIntersector> intersector(new osgUtil::LineSegmentIntersector(
osgUtil::LineSegmentIntersector::PROJECTION, nX * 2.f - 1.f, nY * (-2.f) + 1.f));
osg::Vec3d dist(0.f, 0.f, -maxDistance);
dist = dist * mViewer->getCamera()->getProjectionMatrix();
osg::Vec3d end = intersector->getEnd();
end.z() = dist.z();
intersector->setEnd(end);
intersector->setIntersectionLimit(osgUtil::LineSegmentIntersector::LIMIT_NEAREST);
mViewer->getCamera()->accept(*getIntersectionVisitor(intersector, ignorePlayer, ignoreActors, ignoreTerrain));
return getIntersectionResult(intersector, mIntersectionVisitor);
}
void RenderingManager::updatePtr(const MWWorld::Ptr& old, const MWWorld::Ptr& updated)
{
mObjects->updatePtr(old, updated);
mActorsPaths->updatePtr(old, updated);
}
void RenderingManager::spawnEffect(VFS::Path::NormalizedView model, std::string_view texture,
const osg::Vec3f& worldPosition, float scale, bool isMagicVFX, bool useAmbientLight, std::string_view effectId,
bool loop)
{
mEffectManager->addEffect(model, texture, worldPosition, scale, isMagicVFX, useAmbientLight, effectId, loop);
}
void RenderingManager::removeEffect(std::string_view effectId)
{
mEffectManager->removeEffect(effectId);
}
void RenderingManager::notifyWorldSpaceChanged()
{
mEffectManager->clear();
mWater->clearRipples();
}
void RenderingManager::clear()
{
mSky->setMoonColour(false);
notifyWorldSpaceChanged();
if (mObjectPaging)
mObjectPaging->clear();
}
MWRender::Animation* RenderingManager::getAnimation(const MWWorld::Ptr& ptr)
{
if (mPlayerAnimation.get() && ptr == mPlayerAnimation->getPtr())
return mPlayerAnimation.get();
return mObjects->getAnimation(ptr);
}
const MWRender::Animation* RenderingManager::getAnimation(const MWWorld::ConstPtr& ptr) const
{
if (mPlayerAnimation.get() && ptr == mPlayerAnimation->getPtr())
return mPlayerAnimation.get();
return mObjects->getAnimation(ptr);
}
PostProcessor* RenderingManager::getPostProcessor()
{
return mPostProcessor;
}
void RenderingManager::setupPlayer(const MWWorld::Ptr& player)
{
if (!mPlayerNode)
{
mPlayerNode = new SceneUtil::PositionAttitudeTransform;
mPlayerNode->setNodeMask(Mask_Player);
mPlayerNode->setName("Player Root");
mSceneRoot->addChild(mPlayerNode);
}
mPlayerNode->setUserDataContainer(new osg::DefaultUserDataContainer);
SceneUtil::addUserData(*mPlayerNode, player);
player.getRefData().setBaseNode(mPlayerNode);
mWater->removeEmitter(player);
mWater->addEmitter(player);
}
void RenderingManager::renderPlayer(const MWWorld::Ptr& player)
{
mPlayerAnimation = std::make_unique<NpcAnimation>(player, player.getRefData().getBaseNode(), mResourceSystem, 0,
NpcAnimation::VM_Normal, mFirstPersonFieldOfView);
mCamera->setAnimation(mPlayerAnimation.get());
mCamera->attachTo(player);
}
void RenderingManager::rebuildPtr(const MWWorld::Ptr& ptr)
{
NpcAnimation* anim = nullptr;
if (ptr == mPlayerAnimation->getPtr())
anim = mPlayerAnimation.get();
else
anim = dynamic_cast<NpcAnimation*>(mObjects->getAnimation(ptr));
if (anim)
{
anim->rebuild();
if (mCamera->getTrackingPtr() == ptr)
{
mCamera->attachTo(ptr);
mCamera->setAnimation(anim);
}
}
}
void RenderingManager::addWaterRippleEmitter(const MWWorld::Ptr& ptr)
{
mWater->addEmitter(ptr);
}
void RenderingManager::removeWaterRippleEmitter(const MWWorld::Ptr& ptr)
{
mWater->removeEmitter(ptr);
}
void RenderingManager::emitWaterRipple(const osg::Vec3f& pos)
{
mWater->emitRipple(pos);
}
void RenderingManager::updateProjectionMatrix()
{
if (mNearClip < 0.0f)
throw std::runtime_error("Near clip is less than zero");
if (mViewDistance < mNearClip)
throw std::runtime_error("Viewing distance is less than near clip");
const int width = Settings::video().mResolutionX;
const int height = Settings::video().mResolutionY;
const double aspect = (height == 0) ? 1.0 : static_cast<double>(width) / height;
const float fov = mFieldOfViewOverridden ? mFieldOfViewOverride : mFieldOfView;
osg::Matrix unreversedProjectionMatrix = osg::Matrix::perspective(fov, aspect, mNearClip, mViewDistance);
osg::Matrix projectionMatrix = SceneUtil::AutoDepth::isReversed()
? SceneUtil::getReversedZProjectionMatrixAsPerspective(fov, aspect, mNearClip, mViewDistance)
: unreversedProjectionMatrix;
if (width != 0 && height != 0)
{
double offsetX = (mProjectionOffset.x() / width) * 2.0;
double offsetY = (mProjectionOffset.y() / height) * 2.0;
const osg::Matrix translation = osg::Matrix::translate(offsetX, offsetY, 0.0);
projectionMatrix.postMult(translation);
unreversedProjectionMatrix.postMult(translation);
}
// We always set the cameras projection matrix to the un-reversed variant for correct frustum culling.
mViewer->getCamera()->setProjectionMatrix(unreversedProjectionMatrix);
mPerViewUniformStateUpdater->setProjectionMatrix(projectionMatrix);
mSharedUniformStateUpdater->setNear(mNearClip);
mSharedUniformStateUpdater->setFar(mViewDistance);
if (Stereo::getStereo())
{
auto res = Stereo::Manager::instance().eyeResolution();
setScreenRes(res.x(), res.y());
Stereo::Manager::instance().setMasterProjectionMatrix(mPerViewUniformStateUpdater->getProjectionMatrix());
}
else
{
setScreenRes(width, height);
}
// Since our fog is not radial yet, we should take FOV in account, otherwise terrain near viewing distance may
// disappear. Limit FOV here just for sure, otherwise viewing distance can be too high.
float distanceMult = std::cos(osg::DegreesToRadians(std::min(fov, 140.f)) / 2.f);
mTerrain->setViewDistance(mViewDistance * (distanceMult ? 1.f / distanceMult : 1.f));
if (mPostProcessor)
{
mPostProcessor->getStateUpdater()->setProjectionMatrix(mPerViewUniformStateUpdater->getProjectionMatrix());
mPostProcessor->getStateUpdater()->setFov(fov);
}
}
void RenderingManager::setScreenRes(int width, int height)
{
mSharedUniformStateUpdater->setScreenRes(static_cast<float>(width), static_cast<float>(height));
}
void RenderingManager::updateTextureFiltering()
{
mViewer->stopThreading();
mResourceSystem->getSceneManager()->setFilterSettings(Settings::general().mTextureMagFilter,
Settings::general().mTextureMinFilter, Settings::general().mTextureMipmap,
static_cast<float>(Settings::general().mAnisotropy));
mTerrain->updateTextureFiltering();
mWater->processChangedSettings({});
mViewer->startThreading();
}
void RenderingManager::updateAmbient()
{
osg::Vec4f color = mAmbientColor;
if (mNightEyeFactor > 0.f)
color += osg::Vec4f(0.7f, 0.7f, 0.7f, 0.0f) * mNightEyeFactor;
mSunLight->setAmbient(color);
mPostProcessor->getStateUpdater()->setAmbientColor(color);
mStateUpdater->setAmbientColor(color);
}
RenderingManager::WorldspaceChunkMgr& RenderingManager::getWorldspaceChunkMgr(ESM::RefId worldspace)
{
auto existingChunkMgr = mWorldspaceChunks.find(worldspace);
if (existingChunkMgr != mWorldspaceChunks.end())
return existingChunkMgr->second;
RenderingManager::WorldspaceChunkMgr newChunkMgr;
const float lodFactor = Settings::terrain().mLodFactor;
const bool groundcover = Settings::groundcover().mEnabled && worldspace == ESM::Cell::sDefaultWorldspaceId;
const bool distantTerrain = Settings::terrain().mDistantTerrain;
const double expiryDelay = Settings::cells().mCacheExpiryDelay;
if (distantTerrain || groundcover)
{
const int compMapResolution = Settings::terrain().mCompositeMapResolution;
const int compMapPower = Settings::terrain().mCompositeMapLevel;
const float compMapLevel = static_cast<float>(std::pow(2, compMapPower));
const int vertexLodMod = Settings::terrain().mVertexLodMod;
const float maxCompGeometrySize = Settings::terrain().mMaxCompositeGeometrySize;
const bool debugChunks = Settings::terrain().mDebugChunks;
auto quadTreeWorld = std::make_unique<Terrain::QuadTreeWorld>(mSceneRoot, mRootNode, mResourceSystem,
mTerrainStorage.get(), Mask_Terrain, Mask_PreCompile, Mask_Debug, compMapResolution, compMapLevel,
lodFactor, vertexLodMod, maxCompGeometrySize, debugChunks, worldspace, expiryDelay);
if (Settings::terrain().mObjectPaging)
{
newChunkMgr.mObjectPaging
= std::make_unique<ObjectPaging>(mResourceSystem->getSceneManager(), worldspace);
quadTreeWorld->addChunkManager(newChunkMgr.mObjectPaging.get());
mResourceSystem->addResourceManager(newChunkMgr.mObjectPaging.get());
}
if (groundcover)
{
const float groundcoverDistance = Settings::groundcover().mRenderingDistance;
const float density = Settings::groundcover().mDensity;
newChunkMgr.mGroundcover = std::make_unique<Groundcover>(
mResourceSystem->getSceneManager(), density, groundcoverDistance, mGroundCoverStore);
quadTreeWorld->addChunkManager(newChunkMgr.mGroundcover.get());
mResourceSystem->addResourceManager(newChunkMgr.mGroundcover.get());
}
newChunkMgr.mTerrain = std::move(quadTreeWorld);
}
else
newChunkMgr.mTerrain = std::make_unique<Terrain::TerrainGrid>(mSceneRoot, mRootNode, mResourceSystem,
mTerrainStorage.get(), Mask_Terrain, worldspace, expiryDelay, Mask_PreCompile, Mask_Debug);
newChunkMgr.mTerrain->setTargetFrameRate(Settings::cells().mTargetFramerate);
float distanceMult = std::cos(osg::DegreesToRadians(std::min(mFieldOfView, 140.f)) / 2.f);
newChunkMgr.mTerrain->setViewDistance(mViewDistance * (distanceMult ? 1.f / distanceMult : 1.f));
newChunkMgr.mTerrain->enableHeightCullCallback(Settings::terrain().mWaterCulling);
return mWorldspaceChunks.emplace(worldspace, std::move(newChunkMgr)).first->second;
}
void RenderingManager::reportStats() const
{
osg::Stats* stats = mViewer->getViewerStats();
unsigned int frameNumber = mViewer->getFrameStamp()->getFrameNumber();
if (stats->collectStats("resource"))
{
mTerrain->reportStats(frameNumber, stats);
}
}
void RenderingManager::processChangedSettings(const Settings::CategorySettingVector& changed)
{
// Only perform a projection matrix update once if a relevant setting is changed.
bool updateProjection = false;
for (Settings::CategorySettingVector::const_iterator it = changed.begin(); it != changed.end(); ++it)
{
if (it->first == "Camera" && it->second == "field of view")
{
mFieldOfView = Settings::camera().mFieldOfView;
updateProjection = true;
}
else if (it->first == "Video" && (it->second == "resolution x" || it->second == "resolution y"))
{
updateProjection = true;
}
else if (it->first == "Camera" && it->second == "viewing distance")
{
setViewDistance(Settings::camera().mViewingDistance);
}
else if (it->first == "General"
&& (it->second == "texture filter" || it->second == "texture mipmap" || it->second == "anisotropy"))
{
updateTextureFiltering();
}
else if (it->first == "Water")
{
mWater->processChangedSettings(changed);
}
else if (it->first == "Shaders" && it->second == "minimum interior brightness")
{
if (MWMechanics::getPlayer().isInCell())
configureAmbient(*MWMechanics::getPlayer().getCell()->getCell());
}
else if (it->first == "Shaders"
&& (it->second == "force per pixel lighting" || it->second == "classic falloff"
|| it->second == "clamp lighting"))
{
mViewer->stopThreading();
auto defines = mResourceSystem->getSceneManager()->getShaderManager().getGlobalDefines();
defines["forcePPL"] = Settings::shaders().mForcePerPixelLighting ? "1" : "0";
defines["classicFalloff"] = Settings::shaders().mClassicFalloff ? "1" : "0";
defines["clamp"] = Settings::shaders().mClampLighting ? "1" : "0";
mResourceSystem->getSceneManager()->getShaderManager().setGlobalDefines(defines);
if (MWMechanics::getPlayer().isInCell() && it->second == "classic falloff")
configureAmbient(*MWMechanics::getPlayer().getCell()->getCell());
mViewer->startThreading();
}
else if (it->first == "Shaders"
&& (it->second == "light radius multiplier" || it->second == "maximum light distance"
|| it->second == "light fade start" || it->second == "max lights"
|| it->second == "clustered lighting" || it->second == "particle point lighting"))
{
if (MWMechanics::getPlayer().isInCell())
configureAmbient(*MWMechanics::getPlayer().getCell()->getCell());
LightManagerUpdateVisitor visitor;
bool lightManagersUpdated = false;
if (it->second == "max lights" || it->second == "clustered lighting"
|| it->second == "particle point lighting")
{
mViewer->stopThreading();
visitor.setDoThreadUnsafeOps(true);
mViewer->getSceneData()->accept(visitor);
lightManagersUpdated = true;
auto defines = mResourceSystem->getSceneManager()->getShaderManager().getGlobalDefines();
for (const auto& [name, key] : getLightRoot()->getLightDefines())
defines[name] = key;
defines["particlePointLighting"] = Settings::shaders().mParticlePointLighting ? "1" : "0";
mResourceSystem->getSceneManager()->getShaderManager().setGlobalDefines(defines);
mStateUpdater->reset();
mViewer->startThreading();
}
if (!lightManagersUpdated)
mViewer->getSceneData()->accept(visitor);
}
else if (it->first == "Shadows")
{
mShadowManager->setupShadowSettings(
Settings::shadows(), mResourceSystem->getSceneManager()->getShaderManager());
mShadowManager->setIndoorShadowCastingMask(getIndoorShadowCastingMask());
mShadowManager->setOutdoorShadowCastingMask(getOutdoorShadowCastingMask());
if (mSky->isEnabled())
mShadowManager->enableOutdoorMode();
else
mShadowManager->enableIndoorMode(Settings::shadows());
Shader::ShaderManager::DefineMap shadowDefines = mShadowManager->getShadowDefines(Settings::shadows());
if (mAppliedShadowDefines != shadowDefines)
{
auto defines = mResourceSystem->getSceneManager()->getShaderManager().getGlobalDefines();
for (const auto& [key, value] : mAppliedShadowDefines)
defines.erase(key);
for (const auto& [key, value] : shadowDefines)
defines[key] = value;
mViewer->stopThreading();
mResourceSystem->getSceneManager()->getShaderManager().setGlobalDefines(defines);
mViewer->startThreading();
mAppliedShadowDefines = std::move(shadowDefines);
}
}
else if (it->first == "Post Processing" && it->second == "enabled")
{
if (Settings::postProcessing().mEnabled)
mPostProcessor->enable();
else
{
mPostProcessor->disable();
if (auto* hud = MWBase::Environment::get().getWindowManager()->getPostProcessorHud())
hud->setVisible(false);
}
}
}
if (updateProjection)
{
updateProjectionMatrix();
}
}
void RenderingManager::setViewDistance(float distance, bool delay)
{
mViewDistance = distance;
if (delay)
{
mUpdateProjectionMatrix = true;
return;
}
updateProjectionMatrix();
}
float RenderingManager::getTerrainHeightAt(const osg::Vec3f& pos, ESM::RefId worldspace)
{
return getWorldspaceChunkMgr(worldspace).mTerrain->getHeightAt(pos);
}
void RenderingManager::overrideFieldOfView(float val)
{
if (mFieldOfViewOverridden != true || mFieldOfViewOverride != val)
{
mFieldOfViewOverridden = true;
mFieldOfViewOverride = val;
updateProjectionMatrix();
}
}
void RenderingManager::setFieldOfView(float val)
{
mFieldOfView = val;
mUpdateProjectionMatrix = true;
}
float RenderingManager::getFieldOfView() const
{
return mFieldOfViewOverridden ? mFieldOfViewOverridden : mFieldOfView;
}
osg::Vec3f RenderingManager::getHalfExtents(const MWWorld::ConstPtr& object) const
{
osg::Vec3f halfExtents(0, 0, 0);
VFS::Path::Normalized modelName(object.getClass().getCorrectedModel(object));
if (modelName.empty())
return halfExtents;
osg::ref_ptr<const osg::Node> node = mResourceSystem->getSceneManager()->getTemplate(modelName);
osg::ComputeBoundsVisitor computeBoundsVisitor;
computeBoundsVisitor.setTraversalMask(~(MWRender::Mask_ParticleSystem | MWRender::Mask_Effect));
const_cast<osg::Node*>(node.get())->accept(computeBoundsVisitor);
osg::BoundingBox bounds = computeBoundsVisitor.getBoundingBox();
if (bounds.valid())
{
halfExtents[0] = std::abs(bounds.xMax() - bounds.xMin()) / 2.f;
halfExtents[1] = std::abs(bounds.yMax() - bounds.yMin()) / 2.f;
halfExtents[2] = std::abs(bounds.zMax() - bounds.zMin()) / 2.f;
}
return halfExtents;
}
osg::BoundingBox RenderingManager::getCullSafeBoundingBox(const MWWorld::Ptr& ptr) const
{
if (ptr.isEmpty())
return {};
osg::ref_ptr<SceneUtil::PositionAttitudeTransform> rootNode = ptr.getRefData().getBaseNode();
// Recalculate bounds on the ptr's template when the object is not loaded or is loaded but paged
MWWorld::Scene* worldScene = MWBase::Environment::get().getWorldScene();
if (!rootNode || worldScene->isPagedRef(ptr))
{
const VFS::Path::Normalized model(ptr.getClass().getCorrectedModel(ptr));
if (model.empty())
return {};
rootNode = new SceneUtil::PositionAttitudeTransform;
// Hack even used by osg internally, osg's NodeVisitor won't accept const qualified nodes
rootNode->addChild(const_cast<osg::Node*>(mResourceSystem->getSceneManager()->getTemplate(model).get()));
const float refScale = ptr.getCellRef().getScale();
rootNode->setScale({ refScale, refScale, refScale });
const auto& rotation = ptr.getCellRef().getPosition().rot;
if (!ptr.getClass().isActor())
rootNode->setAttitude(osg::Quat(rotation[0], osg::Vec3(-1, 0, 0))
* osg::Quat(rotation[1], osg::Vec3(0, -1, 0)) * osg::Quat(rotation[2], osg::Vec3(0, 0, -1)));
rootNode->setPosition(ptr.getCellRef().getPosition().asVec3());
std::unique_ptr<Animation> animation;
if (ptr.getClass().isNpc())
{
rootNode->setNodeMask(Mask_Actor);
animation = std::make_unique<NpcAnimation>(ptr, osg::ref_ptr<osg::Group>(rootNode), mResourceSystem);
}
}
SceneUtil::CullSafeBoundsVisitor computeBounds;
computeBounds.setTraversalMask(~(MWRender::Mask_ParticleSystem | MWRender::Mask_Effect));
rootNode->accept(computeBounds);
return computeBounds.mBoundingBox;
}
void RenderingManager::resetFieldOfView()
{
if (mFieldOfViewOverridden == true)
{
mFieldOfViewOverridden = false;
updateProjectionMatrix();
}
}
void RenderingManager::exportSceneGraph(
const MWWorld::Ptr& ptr, const std::filesystem::path& filename, const std::string& format)
{
osg::Node* node = mViewer->getSceneData();
if (!ptr.isEmpty())
node = ptr.getRefData().getBaseNode();
SceneUtil::writeScene(node, filename, format);
}
LandManager* RenderingManager::getLandManager() const
{
return mTerrainStorage->getLandManager();
}
void RenderingManager::updateActorPath(const MWWorld::ConstPtr& actor, const std::deque<osg::Vec3f>& path,
const DetourNavigator::AgentBounds& agentBounds, const osg::Vec3f& start, const osg::Vec3f& end) const
{
mActorsPaths->update(actor, path, agentBounds, start, end, mNavigator.getSettings());
}
void RenderingManager::removeActorPath(const MWWorld::ConstPtr& actor) const
{
mActorsPaths->remove(actor);
}
void RenderingManager::setNavMeshNumber(const std::size_t value)
{
mNavMeshNumber = value;
}
void RenderingManager::updateNavMesh()
{
if (!mNavMesh->isEnabled())
return;
const auto navMeshes = mNavigator.getNavMeshes();
auto it = navMeshes.begin();
for (std::size_t i = 0; it != navMeshes.end() && i < mNavMeshNumber; ++i)
++it;
if (it == navMeshes.end())
{
mNavMesh->reset();
}
else
{
try
{
mNavMesh->update(it->second, mNavMeshNumber, mNavigator.getSettings());
}
catch (const std::exception& e)
{
Log(Debug::Error) << "NavMesh render update exception: " << e.what();
}
}
}
void RenderingManager::updateRecastMesh()
{
if (!mRecastMesh->isEnabled())
return;
mRecastMesh->update(mNavigator.getRecastMeshTiles(), mNavigator.getSettings());
}
void RenderingManager::setActiveGrid(const osg::Vec4i& grid)
{
mTerrain->setActiveGrid(grid);
}
bool RenderingManager::pagingEnableObject(int type, const MWWorld::ConstPtr& ptr, bool enabled)
{
if (!ptr.isInCell() || !ptr.getCell()->isExterior() || !mObjectPaging)
return false;
if (mObjectPaging->enableObject(type, ptr.getCellRef().getRefNum(), ptr.getCellRef().getPosition().asVec3(),
osg::Vec2i(ptr.getCell()->getCell()->getGridX(), ptr.getCell()->getCell()->getGridY()), enabled))
{
mTerrain->rebuildViews();
return true;
}
return false;
}
void RenderingManager::pagingBlacklistObject(int type, const MWWorld::ConstPtr& ptr)
{
if (!ptr.isInCell() || !ptr.getCell()->isExterior() || !mObjectPaging)
return;
ESM::RefNum refnum = ptr.getCellRef().getRefNum();
if (!refnum.hasContentFile())
return;
if (mObjectPaging->blacklistObject(type, refnum, ptr.getCellRef().getPosition().asVec3(),
osg::Vec2i(ptr.getCell()->getCell()->getGridX(), ptr.getCell()->getCell()->getGridY())))
mTerrain->rebuildViews();
}
bool RenderingManager::pagingUnlockCache()
{
if (mObjectPaging && mObjectPaging->unlockCache())
{
mTerrain->rebuildViews();
return true;
}
return false;
}
void RenderingManager::getPagedRefnums(const osg::Vec4i& activeGrid, std::vector<ESM::RefNum>& out)
{
if (mObjectPaging)
mObjectPaging->getPagedRefnums(activeGrid, out);
}
void RenderingManager::setNavMeshMode(Settings::NavMeshRenderMode value)
{
mNavMesh->setMode(value);
}
}