teamnwah/openmw-tes3coop
2
0
Fork 1
forked from mirror/openmw-tes3mp
Code Issues Pull requests 1 Releases Wiki Activity

Moon rendering

Browse source
This commit is contained in:
scrawl 2015-04-15 18:50:50 +02:00
parent f7da979669
commit 13a1ba0aab
4 changed files with 342 additions and 65 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

6
apps/openmw/engine.cpp
View file

@ -6,8 +6,6 @@
#include <osgGA/TrackballManipulator> #include <osgGA/TrackballManipulator>
#include <osgViewer/ViewerEventHandlers> #include <osgViewer/ViewerEventHandlers>
#include <osgUtil/IncrementalCompileOperation>
#include <MyGUI_WidgetManager.h> #include <MyGUI_WidgetManager.h>
#include <SDL.h> #include <SDL.h>
@ -494,11 +492,7 @@ void OMW::Engine::go()
mViewer.addEventHandler(new osgViewer::StatsHandler); mViewer.addEventHandler(new osgViewer::StatsHandler);
osg::Timer timer; osg::Timer timer;
//osgUtil::IncrementalCompileOperation* ico = new osgUtil::IncrementalCompileOperation;
//ico->compileAllForNextFrame(1);
//mViewer.setRealizeOperation(ico);
mViewer.realize(); mViewer.realize();
std::cout << "realize took " << timer.time_m() << std::endl;
osg::Timer frameTimer; osg::Timer frameTimer;
while (!mViewer.done()) while (!mViewer.done())
{ {

363
apps/openmw/mwrender/sky.cpp
View file

@ -12,6 +12,9 @@
#include <osgUtil/CullVisitor> #include <osgUtil/CullVisitor>
#include <osg/TexEnvCombine>
#include <osg/TexMat>
#include <boost/lexical_cast.hpp> #include <boost/lexical_cast.hpp>
#include <openengine/misc/rng.hpp> #include <openengine/misc/rng.hpp>
@ -57,7 +60,7 @@ namespace
return mat; return mat;
} }
osg::ref_ptr<osg::Geometry> createTexturedQuad() osg::ref_ptr<osg::Geometry> createTexturedQuad(int numUvSets=1)
{ {
osg::ref_ptr<osg::Geometry> geom = new osg::Geometry; osg::ref_ptr<osg::Geometry> geom = new osg::Geometry;
@ -75,7 +78,8 @@ namespace
texcoords->push_back(osg::Vec2f(1, 1)); texcoords->push_back(osg::Vec2f(1, 1));
texcoords->push_back(osg::Vec2f(1, 0)); texcoords->push_back(osg::Vec2f(1, 0));
geom->setTexCoordArray(0, texcoords, osg::Array::BIND_PER_VERTEX); for (int i=0; i<numUvSets; ++i)
geom->setTexCoordArray(i, texcoords, osg::Array::BIND_PER_VERTEX);
geom->addPrimitiveSet(new osg::DrawArrays(osg::PrimitiveSet::QUADS,0,4)); geom->addPrimitiveSet(new osg::DrawArrays(osg::PrimitiveSet::QUADS,0,4));
@ -111,6 +115,52 @@ private:
osg::Vec4f mEmissionColor; osg::Vec4f mEmissionColor;
}; };
class CloudUpdater : public SceneUtil::StateSetUpdater
{
public:
void setAnimationTimer(float timer);
void setTexture(osg::ref_ptr<osg::Texture2D> texture)
{
mTexture = texture;
}
void setEmissionColor(osg::Vec4f emissionColor)
{
mEmissionColor = emissionColor;
}
void setOpacity(float opacity)
{
mOpacity = opacity;
}
protected:
virtual void setDefaults(osg::StateSet *stateset)
{
stateset->setTextureAttributeAndModes(0, new osg::TexMat, osg::StateAttribute::ON);
stateset->setAttribute(createAlphaTrackingUnlitMaterial(), osg::StateAttribute::ON|osg::StateAttribute::OVERRIDE);
}
virtual void apply(osg::StateSet *stateset, osg::NodeVisitor *nv)
{
mAnimationTimer = nv->getFrameStamp()->getSimulationTime()*0.05;
osg::TexMat* texMat = static_cast<osg::TexMat*>(stateset->getTextureAttribute(0, osg::StateAttribute::TEXMAT));
texMat->setMatrix(osg::Matrix::translate(osg::Vec3f(mAnimationTimer, mAnimationTimer, 0.f)));
stateset->setTextureAttributeAndModes(0, mTexture, osg::StateAttribute::ON|osg::StateAttribute::OVERRIDE);
osg::Material* mat = static_cast<osg::Material*>(stateset->getAttribute(osg::StateAttribute::MATERIAL));
mat->setEmission(osg::Material::FRONT_AND_BACK, mEmissionColor);
// FIXME: handle opacity, will have to resort to either shaders or multitexturing? diffuse alpha is in use by the vertex colors already
}
private:
float mAnimationTimer;
osg::ref_ptr<osg::Texture2D> mTexture;
osg::Vec4f mEmissionColor;
float mOpacity;
};
/// Transform that removes the eyepoint of the modelview matrix, /// Transform that removes the eyepoint of the modelview matrix,
/// i.e. its children are positioned relative to the camera. /// i.e. its children are positioned relative to the camera.
class CameraRelativeTransform : public osg::Transform class CameraRelativeTransform : public osg::Transform
@ -118,6 +168,10 @@ class CameraRelativeTransform : public osg::Transform
public: public:
CameraRelativeTransform() CameraRelativeTransform()
{ {
// Culling works in node-local space, not in camera space, so we can't cull this node correctly
// That's not a problem though, children of this node can be culled just fine
// Just make sure you do not place a CameraRelativeTransform deep in the scene graph
setCullingActive(false);
} }
CameraRelativeTransform(const CameraRelativeTransform& copy, const osg::CopyOp& copyop) CameraRelativeTransform(const CameraRelativeTransform& copy, const osg::CopyOp& copyop)
@ -211,6 +265,219 @@ private:
int mMeshType; int mMeshType;
}; };
class CelestialBody
{
public:
CelestialBody(osg::Group* parentNode, Resource::SceneManager* sceneManager, float scaleFactor = 1.f, int numUvSets=1)
: mSceneManager(sceneManager)
{
mGeode = new osg::Geode;
osg::ref_ptr<osg::Geometry> geom = createTexturedQuad(numUvSets);
mGeode->addDrawable(geom);
mTransform = new osg::PositionAttitudeTransform;
mTransform->setScale(osg::Vec3f(450,450,450) * scaleFactor);
mTransform->addChild(mGeode);
parentNode->addChild(mTransform);
}
void setDirection(const osg::Vec3f& direction)
{
mTransform->setPosition(direction*1000.f);
osg::Quat quat;
quat.makeRotate(osg::Vec3f(0,0,1), direction);
mTransform->setAttitude(quat);
}
void setVisible(bool visible)
{
mTransform->setNodeMask(visible ? ~0 : 0);
}
protected:
osg::ref_ptr<osg::PositionAttitudeTransform> mTransform;
osg::ref_ptr<osg::Geode> mGeode;
Resource::SceneManager* mSceneManager;
};
class Sun : public CelestialBody
{
public:
Sun(osg::Group* parentNode, Resource::SceneManager* sceneManager)
: CelestialBody(parentNode, sceneManager, 1.f, 1)
{
osg::ref_ptr<osg::Texture2D> tex = mSceneManager->getTextureManager()->getTexture2D("textures/tx_sun_05.dds",
osg::Texture::CLAMP, osg::Texture::CLAMP);
mTransform->getOrCreateStateSet()->setTextureAttributeAndModes(0, tex, osg::StateAttribute::ON);
mTransform->getOrCreateStateSet()->setAttributeAndModes(createUnlitMaterial(), osg::StateAttribute::ON);
}
};
class Moon : public CelestialBody
{
public:
enum Type
{
Type_Masser = 0,
Type_Secunda
};
Moon(osg::Group* parentNode, Resource::SceneManager* sceneManager, float scaleFactor, Type type)
: CelestialBody(parentNode, sceneManager, scaleFactor, 2)
, mPhase(Phase_Unspecified)
, mType(type)
{
mUpdater = new MoonUpdater;
mGeode->addUpdateCallback(mUpdater);
setPhase(Phase_WaxingCrescent);
}
enum Phase
{
Phase_New = 0,
Phase_WaxingCrescent,
Phase_WaxingHalf,
Phase_WaxingGibbous,
Phase_Full,
Phase_WaningGibbous,
Phase_WaningHalf,
Phase_WaningCrescent,
Phase_Unspecified
};
void setTextures(const std::string& phaseTex, const std::string& circleTex)
{
osg::ref_ptr<osg::StateSet> stateset = new osg::StateSet;
osg::ref_ptr<osg::Texture2D> moonTex = mSceneManager->getTextureManager()->getTexture2D(circleTex,
osg::Texture::CLAMP, osg::Texture::CLAMP);
// stage 0: render the moon circle in atmosphere color
stateset->setTextureAttributeAndModes(0, moonTex, osg::StateAttribute::ON);
osg::ref_ptr<osg::TexEnvCombine> texEnv = new osg::TexEnvCombine;
texEnv->setSource0_RGB(osg::TexEnvCombine::CONSTANT);
texEnv->setConstantColor(osg::Vec4f(0.f, 0.f, 0.f, 1.f)); // atmospherecolor
stateset->setTextureAttributeAndModes(0, texEnv, osg::StateAttribute::ON);
// stage 1: render the "lit" side of the moon blended over the circle
osg::ref_ptr<osg::Texture2D> moonTex2 = mSceneManager->getTextureManager()->getTexture2D(phaseTex,
osg::Texture::CLAMP, osg::Texture::CLAMP);
stateset->setTextureAttributeAndModes(1, moonTex2, osg::StateAttribute::ON);
osg::ref_ptr<osg::TexEnvCombine> texEnv2 = new osg::TexEnvCombine;
texEnv2->setCombine_RGB(osg::TexEnvCombine::INTERPOLATE);
texEnv2->setCombine_Alpha(osg::TexEnvCombine::MODULATE);
texEnv2->setSource0_Alpha(osg::TexEnvCombine::CONSTANT);
texEnv2->setConstantColor(osg::Vec4f(1.f, 1.f, 1.f, 1.f));
texEnv2->setSource2_RGB(osg::TexEnvCombine::TEXTURE);
stateset->setTextureAttributeAndModes(1, texEnv2, osg::StateAttribute::ON);
mTransform->setStateSet(stateset);
}
void setPhase(const Phase& phase)
{
if (mPhase == phase)
return;
mPhase = phase;
std::string textureName = "textures/tx_";
if (mType == Moon::Type_Secunda) textureName += "secunda_";
else textureName += "masser_";
if (phase == Moon::Phase_New) textureName += "new";
else if (phase == Moon::Phase_WaxingCrescent) textureName += "one_wax";
else if (phase == Moon::Phase_WaxingHalf) textureName += "half_wax";
else if (phase == Moon::Phase_WaxingGibbous) textureName += "three_wax";
else if (phase == Moon::Phase_WaningCrescent) textureName += "one_wan";
else if (phase == Moon::Phase_WaningHalf) textureName += "half_wan";
else if (phase == Moon::Phase_WaningGibbous) textureName += "three_wan";
else if (phase == Moon::Phase_Full) textureName += "full";
textureName += ".dds";
if (mType == Moon::Type_Secunda)
setTextures(textureName, "textures/tx_mooncircle_full_s.dds");
else
setTextures(textureName, "textures/tx_mooncircle_full_m.dds");
}
void setType(const Type& type)
{
mType = type;
}
class MoonUpdater : public SceneUtil::StateSetUpdater
{
public:
MoonUpdater()
: mAlpha(1.f)
{
}
virtual void setDefaults(osg::StateSet *stateset)
{
stateset->setAttributeAndModes(createUnlitMaterial(), osg::StateAttribute::ON|osg::StateAttribute::OVERRIDE);
}
virtual void apply(osg::StateSet *stateset, osg::NodeVisitor*)
{
osg::Material* mat = static_cast<osg::Material*>(stateset->getAttribute(osg::StateAttribute::MATERIAL));
mat->setDiffuse(osg::Material::FRONT_AND_BACK, osg::Vec4f(0.f, 0.f, 0.f, mAlpha));
}
void setAlpha(float alpha)
{
mAlpha = alpha;
}
private:
float mAlpha;
};
void setAlpha(float alpha)
{
mUpdater->setAlpha(alpha);
}
void setAtmosphereColor(const osg::Vec4f& color)
{
// TODO
}
void setColor(const osg::Vec4f& color)
{
// TODO
}
unsigned int getPhaseInt() const
{
if (mPhase == Moon::Phase_New) return 0;
else if (mPhase == Moon::Phase_WaxingCrescent) return 1;
else if (mPhase == Moon::Phase_WaningCrescent) return 1;
else if (mPhase == Moon::Phase_WaxingHalf) return 2;
else if (mPhase == Moon::Phase_WaningHalf) return 2;
else if (mPhase == Moon::Phase_WaxingGibbous) return 3;
else if (mPhase == Moon::Phase_WaningGibbous) return 3;
else if (mPhase == Moon::Phase_Full) return 4;
return 0;
}
private:
Type mType;
Phase mPhase;
osg::ref_ptr<MoonUpdater> mUpdater;
};
SkyManager::SkyManager(osg::Group* parentNode, Resource::SceneManager* sceneManager) SkyManager::SkyManager(osg::Group* parentNode, Resource::SceneManager* sceneManager)
: mSceneManager(sceneManager) : mSceneManager(sceneManager)
, mHour(0.0f) , mHour(0.0f)
@ -240,7 +507,6 @@ SkyManager::SkyManager(osg::Group* parentNode, Resource::SceneManager* sceneMana
, mIsStorm(false) , mIsStorm(false)
{ {
osg::ref_ptr<CameraRelativeTransform> skyroot (new CameraRelativeTransform); osg::ref_ptr<CameraRelativeTransform> skyroot (new CameraRelativeTransform);
skyroot->setCullingActive(false);
parentNode->addChild(skyroot); parentNode->addChild(skyroot);
mRootNode = skyroot; mRootNode = skyroot;
@ -257,8 +523,6 @@ void SkyManager::create()
ModVertexAlphaVisitor modAtmosphere(0); ModVertexAlphaVisitor modAtmosphere(0);
mAtmosphereDay->accept(modAtmosphere); mAtmosphereDay->accept(modAtmosphere);
// osg::Node* alphaBlendedRoot =
mAtmosphereUpdater = new AtmosphereUpdater; mAtmosphereUpdater = new AtmosphereUpdater;
mAtmosphereDay->addUpdateCallback(mAtmosphereUpdater); mAtmosphereDay->addUpdateCallback(mAtmosphereUpdater);
@ -271,27 +535,23 @@ void SkyManager::create()
mAtmosphereNight->accept(modStars); mAtmosphereNight->accept(modStars);
mAtmosphereNight->setNodeMask(0); mAtmosphereNight->setNodeMask(0);
osg::Geode* geode = new osg::Geode; mSun.reset(new Sun(mRootNode, mSceneManager));
osg::ref_ptr<osg::Geometry> sun = createTexturedQuad();
geode->addDrawable(sun);
osg::PositionAttitudeTransform* trans = new osg::PositionAttitudeTransform;
trans->setScale(osg::Vec3f(450,450,450));
trans->addChild(geode);
mRootNode->addChild(trans);
mSunTransform = trans; const MWWorld::Fallback* fallback=MWBase::Environment::get().getWorld()->getFallback();
mMasser.reset(new Moon(mRootNode, mSceneManager, fallback->getFallbackFloat("Moons_Masser_Size")/100, Moon::Type_Masser));
mSecunda.reset(new Moon(mRootNode, mSceneManager, fallback->getFallbackFloat("Moons_Secunda_Size")/100, Moon::Type_Secunda));
mCloudNode = mSceneManager->createInstance("meshes/sky_clouds_01.nif", mRootNode); mCloudNode = mSceneManager->createInstance("meshes/sky_clouds_01.nif", mRootNode);
ModVertexAlphaVisitor modClouds(1); ModVertexAlphaVisitor modClouds(1);
mCloudNode->accept(modClouds); mCloudNode->accept(modClouds);
osg::ref_ptr<osg::Texture2D> sunTex = mSceneManager->getTextureManager()->getTexture2D("textures/tx_sun_05.dds", mCloudUpdater = new CloudUpdater;
osg::Texture::CLAMP, osg::Texture::CLAMP); //mCloudNode->addUpdateCallback(mCloudUpdater);
trans->getOrCreateStateSet()->setTextureAttributeAndModes(0, sunTex, osg::StateAttribute::ON);
trans->getOrCreateStateSet()->setAttributeAndModes(createUnlitMaterial(), osg::StateAttribute::ON);
mCloudNode->getOrCreateStateSet()->setAttributeAndModes(createAlphaTrackingUnlitMaterial(), osg::StateAttribute::ON|osg::StateAttribute::OVERRIDE); mCloudNode->getOrCreateStateSet()->setAttributeAndModes(createAlphaTrackingUnlitMaterial(), osg::StateAttribute::ON|osg::StateAttribute::OVERRIDE);
mCloudNode->setNodeMask(0);
osg::ref_ptr<osg::Depth> depth = new osg::Depth; osg::ref_ptr<osg::Depth> depth = new osg::Depth;
depth->setWriteMask(false); depth->setWriteMask(false);
mRootNode->getOrCreateStateSet()->setAttributeAndModes(depth, osg::StateAttribute::ON); mRootNode->getOrCreateStateSet()->setAttributeAndModes(depth, osg::StateAttribute::ON);
@ -307,16 +567,15 @@ SkyManager::~SkyManager()
int SkyManager::getMasserPhase() const int SkyManager::getMasserPhase() const
{ {
return 0;
if (!mCreated) return 0; if (!mCreated) return 0;
return 0;
//return mMasser->getPhaseInt(); //return mMasser->getPhaseInt();
} }
int SkyManager::getSecundaPhase() const int SkyManager::getSecundaPhase() const
{ {
return 0;
if (!mCreated) return 0; if (!mCreated) return 0;
//return mSecunda->getPhaseInt(); return mSecunda->getPhaseInt();
} }
void SkyManager::clearRain() void SkyManager::clearRain()
@ -376,9 +635,9 @@ void SkyManager::update(float duration)
} }
//mSunGlare->setVisible(mSunEnabled); //mSunGlare->setVisible(mSunEnabled);
//mSun->setVisible(mSunEnabled); mSun->setVisible(mSunEnabled);
//mMasser->setVisible(mMasserEnabled); mMasser->setVisible(mMasserEnabled);
//mSecunda->setVisible(mSecundaEnabled); mSecunda->setVisible(mSecundaEnabled);
// rotate the stars by 360 degrees every 4 days // rotate the stars by 360 degrees every 4 days
//mAtmosphereNight->roll(Degree(MWBase::Environment::get().getWorld()->getTimeScaleFactor()*duration*360 / (3600*96.f))); //mAtmosphereNight->roll(Degree(MWBase::Environment::get().getWorld()->getTimeScaleFactor()*duration*360 / (3600*96.f)));
@ -441,6 +700,11 @@ void SkyManager::setWeather(const MWWorld::WeatherResult& weather)
if (mClouds != weather.mCloudTexture) if (mClouds != weather.mCloudTexture)
{ {
mClouds = weather.mCloudTexture; mClouds = weather.mCloudTexture;
std::string texture = Misc::ResourceHelpers::correctTexturePath(mClouds, mSceneManager->getVFS());
mCloudUpdater->setTexture(mSceneManager->getTextureManager()->getTexture2D(texture,
osg::Texture::REPEAT, osg::Texture::REPEAT));
} }
if (mNextClouds != weather.mNextCloudTexture) if (mNextClouds != weather.mNextCloudTexture)
@ -456,15 +720,18 @@ void SkyManager::setWeather(const MWWorld::WeatherResult& weather)
if (mCloudOpacity != weather.mCloudOpacity) if (mCloudOpacity != weather.mCloudOpacity)
{ {
mCloudOpacity = weather.mCloudOpacity; mCloudOpacity = weather.mCloudOpacity;
mCloudUpdater->setOpacity(0.3);
} }
if (mCloudColour != weather.mSunColor) if (mCloudColour != weather.mSunColor)
{ {
/* // FIXME: this doesn't look correct
osg::Vec4f clr( weather.mSunColor.r()*0.7f + weather.mAmbientColor.r()*0.7f, osg::Vec4f clr( weather.mSunColor.r()*0.7f + weather.mAmbientColor.r()*0.7f,
weather.mSunColor.g()*0.7f + weather.mAmbientColor.g()*0.7f, weather.mSunColor.g()*0.7f + weather.mAmbientColor.g()*0.7f,
weather.mSunColor.b()*0.7f + weather.mAmbientColor.b()*0.7f, 1.f); weather.mSunColor.b()*0.7f + weather.mAmbientColor.b()*0.7f, 1.f);
*/
mCloudUpdater->setEmissionColor(clr);
mCloudColour = weather.mSunColor; mCloudColour = weather.mSunColor;
} }
@ -494,7 +761,7 @@ void SkyManager::setWeather(const MWWorld::WeatherResult& weather)
} }
} }
mAtmosphereNight->setNodeMask((weather.mNight && mEnabled) ? ~0 : 0); //mAtmosphereNight->setNodeMask((weather.mNight && mEnabled) ? ~0 : 0);
/* /*
@ -524,12 +791,16 @@ void SkyManager::setGlare(const float glare)
void SkyManager::sunEnable() void SkyManager::sunEnable()
{ {
mSunEnabled = true; if (!mCreated) return;
mSun->setVisible(true);
} }
void SkyManager::sunDisable() void SkyManager::sunDisable()
{ {
mSunEnabled = false; if (!mCreated) return;
mSun->setVisible(false);
} }
void SkyManager::setStormDirection(const Ogre::Vector3 &direction) void SkyManager::setStormDirection(const Ogre::Vector3 &direction)
@ -541,45 +812,51 @@ void SkyManager::setSunDirection(const osg::Vec3f& direction)
{ {
if (!mCreated) return; if (!mCreated) return;
mSunTransform->setPosition(direction*1000.f); mSun->setDirection(direction);
osg::Quat quat;
quat.makeRotate(osg::Vec3f(0,0,1), direction);
mSunTransform->setAttitude(quat);
//mSunGlare->setPosition(direction); //mSunGlare->setPosition(direction);
} }
void SkyManager::setMasserDirection(const Ogre::Vector3& direction) void SkyManager::setMasserDirection(const osg::Vec3f& direction)
{ {
if (!mCreated) return; if (!mCreated) return;
//mMasser->setPosition(direction);
mMasser->setDirection(direction);
} }
void SkyManager::setSecundaDirection(const Ogre::Vector3& direction) void SkyManager::setSecundaDirection(const osg::Vec3f& direction)
{ {
if (!mCreated) return; if (!mCreated) return;
//mSecunda->setPosition(direction);
mSecunda->setDirection(direction);
} }
void SkyManager::masserEnable() void SkyManager::masserEnable()
{ {
mMasserEnabled = true; if (!mCreated) return;
mMasser->setVisible(true);
} }
void SkyManager::secundaEnable() void SkyManager::secundaEnable()
{ {
mSecundaEnabled = true; if (!mCreated) return;
mSecunda->setVisible(true);
} }
void SkyManager::masserDisable() void SkyManager::masserDisable()
{ {
mMasserEnabled = false; if (!mCreated) return;
mMasser->setVisible(false);
} }
void SkyManager::secundaDisable() void SkyManager::secundaDisable()
{ {
mSecundaEnabled = false; if (!mCreated) return;
mSecunda->setVisible(false);
} }
void SkyManager::setLightningStrength(const float factor) void SkyManager::setLightningStrength(const float factor)
@ -599,13 +876,13 @@ void SkyManager::setLightningStrength(const float factor)
void SkyManager::setMasserFade(const float fade) void SkyManager::setMasserFade(const float fade)
{ {
if (!mCreated) return; if (!mCreated) return;
//mMasser->setVisibility(fade); mMasser->setAlpha(fade);
} }
void SkyManager::setSecundaFade(const float fade) void SkyManager::setSecundaFade(const float fade)
{ {
if (!mCreated) return; if (!mCreated) return;
//mSecunda->setVisibility(fade); mSecunda->setAlpha(fade);
} }
void SkyManager::setHour(double hour) void SkyManager::setHour(double hour)

13
apps/openmw/mwrender/sky.hpp
View file

@ -20,6 +20,9 @@ namespace Resource
namespace MWRender namespace MWRender
{ {
class AtmosphereUpdater; class AtmosphereUpdater;
class CloudUpdater;
class Sun;
class Moon;
class SkyManager class SkyManager
{ {
@ -60,9 +63,9 @@ namespace MWRender
void setSunDirection(const osg::Vec3f& direction); void setSunDirection(const osg::Vec3f& direction);
void setMasserDirection(const Ogre::Vector3& direction); void setMasserDirection(const osg::Vec3f& direction);
void setSecundaDirection(const Ogre::Vector3& direction); void setSecundaDirection(const osg::Vec3f& direction);
void setMasserFade(const float fade); void setMasserFade(const float fade);
@ -94,13 +97,17 @@ namespace MWRender
osg::ref_ptr<osg::Node> mCloudNode; osg::ref_ptr<osg::Node> mCloudNode;
osg::ref_ptr<CloudUpdater> mCloudUpdater;
osg::ref_ptr<osg::Node> mAtmosphereDay; osg::ref_ptr<osg::Node> mAtmosphereDay;
osg::ref_ptr<osg::Node> mAtmosphereNight; osg::ref_ptr<osg::Node> mAtmosphereNight;
osg::ref_ptr<AtmosphereUpdater> mAtmosphereUpdater; osg::ref_ptr<AtmosphereUpdater> mAtmosphereUpdater;
osg::ref_ptr<osg::PositionAttitudeTransform> mSunTransform; std::auto_ptr<Sun> mSun;
std::auto_ptr<Moon> mMasser;
std::auto_ptr<Moon> mSecunda;
bool mCreated; bool mCreated;

25
apps/openmw/mwworld/weather.cpp
View file

@ -426,10 +426,10 @@ void WeatherManager::update(float duration, bool paused)
mRendering->configureFog(mResult.mFogDepth, mResult.mFogColor); mRendering->configureFog(mResult.mFogDepth, mResult.mFogColor);
// disable sun during night // disable sun during night
//if (mHour >= mNightStart || mHour <= mSunriseTime) if (mHour >= mNightStart || mHour <= mSunriseTime)
//mRendering->getSkyManager()->sunDisable(); mRendering->getSkyManager()->sunDisable();
//else else
//mRendering->getSkyManager()->sunEnable(); mRendering->getSkyManager()->sunEnable();
// Update the sun direction. Run it east to west at a fixed angle from overhead. // Update the sun direction. Run it east to west at a fixed angle from overhead.
// The sun's speed at day and night may differ, since mSunriseTime and mNightStart // The sun's speed at day and night may differ, since mSunriseTime and mNightStart
@ -493,10 +493,10 @@ void WeatherManager::update(float duration, bool paused)
(1 - moonHeight) * facing * 0.8f, (1 - moonHeight) * facing * 0.8f,
moonHeight); moonHeight);
//mRendering->getSkyManager()->setMasserDirection(masser); mRendering->getSkyManager()->setMasserDirection(masser);
//mRendering->getSkyManager()->setSecundaDirection(secunda); mRendering->getSkyManager()->setSecundaDirection(secunda);
//mRendering->getSkyManager()->masserEnable(); mRendering->getSkyManager()->masserEnable();
//mRendering->getSkyManager()->secundaEnable(); mRendering->getSkyManager()->secundaEnable();
float angle = (1-moonHeight) * 90.f * facing; float angle = (1-moonHeight) * 90.f * facing;
float masserHourFade = calculateHourFade("Masser"); float masserHourFade = calculateHourFade("Masser");
@ -507,13 +507,13 @@ void WeatherManager::update(float duration, bool paused)
masserAngleFade *= masserHourFade; masserAngleFade *= masserHourFade;
secundaAngleFade *= secundaHourFade; secundaAngleFade *= secundaHourFade;
//mRendering->getSkyManager()->setMasserFade(masserAngleFade); mRendering->getSkyManager()->setMasserFade(masserAngleFade);
//mRendering->getSkyManager()->setSecundaFade(secundaAngleFade); mRendering->getSkyManager()->setSecundaFade(secundaAngleFade);
} }
else else
{ {
//mRendering->getSkyManager()->masserDisable(); mRendering->getSkyManager()->masserDisable();
//mRendering->getSkyManager()->secundaDisable(); mRendering->getSkyManager()->secundaDisable();
} }
if (!paused) if (!paused)
@ -568,7 +568,6 @@ void WeatherManager::update(float duration, bool paused)
mRendering->setAmbientColour(mResult.mAmbientColor); mRendering->setAmbientColour(mResult.mAmbientColor);
//mRendering->sunEnable(false);
mRendering->setSunColour(mResult.mSunColor); mRendering->setSunColour(mResult.mSunColor);
mRendering->getSkyManager()->setWeather(mResult); mRendering->getSkyManager()->setWeather(mResult);