Merge remote branch 'scrawl/weather' into weather
Conflicts: apps/openmw/CMakeLists.txtactorid
Marc Zinnschlag
13 years ago
commit
739870489a
@ -1,116 +1,762 @@
|
||||
#include "sky.hpp"
|
||||
#include "Caelum.h"
|
||||
|
||||
namespace MWRender
|
||||
{
|
||||
//
|
||||
// Implements a Caelum sky with default settings.
|
||||
//
|
||||
// Note: this is intended as a temporary solution to provide some form of
|
||||
// sky rendering. This code will obviously need significant tailoring to
|
||||
// support fidelity with Morrowind's rendering. Before doing major work
|
||||
// on this class, more research should be done to determine whether
|
||||
// Caelum or another plug-in such as SkyX would be best for the long-term.
|
||||
//
|
||||
class CaelumManager : public SkyManager
|
||||
{
|
||||
protected:
|
||||
Caelum::CaelumSystem* mpCaelumSystem;
|
||||
|
||||
public:
|
||||
CaelumManager (Ogre::RenderWindow* pRenderWindow,
|
||||
Ogre::Camera* pCamera,
|
||||
const boost::filesystem::path& resDir);
|
||||
virtual ~CaelumManager ();
|
||||
|
||||
virtual void enable() {}
|
||||
|
||||
virtual void disable() {}
|
||||
|
||||
#include <OgreCamera.h>
|
||||
#include <OgreRenderWindow.h>
|
||||
#include <OgreSceneNode.h>
|
||||
#include <OgreMesh.h>
|
||||
#include <OgreSceneManager.h>
|
||||
#include <OgreHardwareVertexBuffer.h>
|
||||
#include <OgreHighLevelGpuProgramManager.h>
|
||||
|
||||
#include <components/nifogre/ogre_nif_loader.hpp>
|
||||
|
||||
using namespace MWRender;
|
||||
using namespace Ogre;
|
||||
|
||||
// the speed at which the clouds are animated
|
||||
#define CLOUD_SPEED 0.001
|
||||
|
||||
// this distance has to be set accordingly so that the
|
||||
// celestial bodies are behind the clouds, but in front of the atmosphere
|
||||
#define CELESTIAL_BODY_DISTANCE 1000.f
|
||||
|
||||
BillboardObject::BillboardObject( const String& textureName,
|
||||
const float initialSize,
|
||||
const Vector3& position,
|
||||
SceneNode* rootNode)
|
||||
{
|
||||
init(textureName, initialSize, position, rootNode);
|
||||
}
|
||||
|
||||
BillboardObject::BillboardObject()
|
||||
{
|
||||
}
|
||||
|
||||
void BillboardObject::setVisible(const bool visible)
|
||||
{
|
||||
mNode->setVisible(visible);
|
||||
}
|
||||
|
||||
void BillboardObject::setSize(const float size)
|
||||
{
|
||||
mNode->setScale(size, size, size);
|
||||
}
|
||||
|
||||
void BillboardObject::setVisibility(const float visibility)
|
||||
{
|
||||
mMaterial->getTechnique(0)->getPass(0)->setDiffuse(0.0, 0.0, 0.0, visibility);
|
||||
}
|
||||
|
||||
void BillboardObject::setPosition(const Vector3& pPosition)
|
||||
{
|
||||
Vector3 normalised = pPosition.normalisedCopy();
|
||||
Vector3 finalPosition = normalised * CELESTIAL_BODY_DISTANCE;
|
||||
|
||||
mBBSet->setCommonDirection( -normalised );
|
||||
|
||||
mNode->setPosition(finalPosition);
|
||||
}
|
||||
|
||||
Vector3 BillboardObject::getPosition() const
|
||||
{
|
||||
return mNode->getPosition();
|
||||
}
|
||||
|
||||
void BillboardObject::setColour(const ColourValue& pColour)
|
||||
{
|
||||
mMaterial->getTechnique(0)->getPass(0)->setSelfIllumination(pColour);
|
||||
}
|
||||
|
||||
void BillboardObject::setRenderQueue(unsigned int id)
|
||||
{
|
||||
mBBSet->setRenderQueueGroup(id);
|
||||
}
|
||||
|
||||
SceneNode* BillboardObject::getNode()
|
||||
{
|
||||
return mNode;
|
||||
}
|
||||
|
||||
void BillboardObject::init(const String& textureName,
|
||||
const float initialSize,
|
||||
const Vector3& position,
|
||||
SceneNode* rootNode)
|
||||
{
|
||||
SceneManager* sceneMgr = rootNode->getCreator();
|
||||
|
||||
virtual void setHour (double hour) {}
|
||||
///< will be called even when sky is disabled.
|
||||
Vector3 finalPosition = position.normalisedCopy() * CELESTIAL_BODY_DISTANCE;
|
||||
|
||||
static unsigned int bodyCount=0;
|
||||
|
||||
/// \todo These billboards are not 100% correct, might want to revisit them later
|
||||
mBBSet = sceneMgr->createBillboardSet("SkyBillboardSet"+StringConverter::toString(bodyCount), 1);
|
||||
mBBSet->setDefaultDimensions(550.f*initialSize, 550.f*initialSize);
|
||||
mBBSet->setRenderQueueGroup(RENDER_QUEUE_SKIES_EARLY+2);
|
||||
mBBSet->setBillboardType(BBT_PERPENDICULAR_COMMON);
|
||||
mBBSet->setCommonDirection( -position.normalisedCopy() );
|
||||
mNode = rootNode->createChildSceneNode();
|
||||
mNode->setPosition(finalPosition);
|
||||
mNode->attachObject(mBBSet);
|
||||
mBBSet->createBillboard(0,0,0);
|
||||
|
||||
mMaterial = MaterialManager::getSingleton().create("BillboardMaterial"+StringConverter::toString(bodyCount), ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME);
|
||||
mMaterial->removeAllTechniques();
|
||||
Pass* p = mMaterial->createTechnique()->createPass();
|
||||
p->setSceneBlending(SBT_TRANSPARENT_ALPHA);
|
||||
p->setDepthCheckEnabled(false);
|
||||
p->setDepthWriteEnabled(false);
|
||||
p->setSelfIllumination(1.0,1.0,1.0);
|
||||
p->setDiffuse(0.0,0.0,0.0,1.0);
|
||||
p->setAmbient(0.0,0.0,0.0);
|
||||
p->createTextureUnitState(textureName);
|
||||
mBBSet->setMaterialName("BillboardMaterial"+StringConverter::toString(bodyCount));
|
||||
|
||||
bodyCount++;
|
||||
}
|
||||
|
||||
Moon::Moon( const String& textureName,
|
||||
const float initialSize,
|
||||
const Vector3& position,
|
||||
SceneNode* rootNode)
|
||||
{
|
||||
init(textureName, initialSize, position, rootNode);
|
||||
|
||||
HighLevelGpuProgramManager& mgr = HighLevelGpuProgramManager::getSingleton();
|
||||
HighLevelGpuProgramPtr vshader;
|
||||
if (mgr.resourceExists("Moon_VP"))
|
||||
vshader = mgr.getByName("Moon_VP");
|
||||
else
|
||||
vshader = mgr.createProgram("Moon_VP", ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME, "cg", GPT_VERTEX_PROGRAM);
|
||||
vshader->setParameter("profiles", "vs_2_x arbvp1");
|
||||
vshader->setParameter("entry_point", "main_vp");
|
||||
StringUtil::StrStreamType outStream;
|
||||
outStream <<
|
||||
"void main_vp( \n"
|
||||
" float4 position : POSITION, \n"
|
||||
" in float2 uv : TEXCOORD0, \n"
|
||||
" out float2 oUV : TEXCOORD0, \n"
|
||||
" out float4 oPosition : POSITION, \n"
|
||||
" uniform float4x4 worldViewProj \n"
|
||||
") \n"
|
||||
"{ \n"
|
||||
" oUV = uv; \n"
|
||||
" oPosition = mul( worldViewProj, position ); \n"
|
||||
"}";
|
||||
vshader->setSource(outStream.str());
|
||||
vshader->load();
|
||||
vshader->getDefaultParameters()->setNamedAutoConstant("worldViewProj", GpuProgramParameters::ACT_WORLDVIEWPROJ_MATRIX);
|
||||
mMaterial->getTechnique(0)->getPass(0)->setVertexProgram(vshader->getName());
|
||||
|
||||
HighLevelGpuProgramPtr fshader;
|
||||
if (mgr.resourceExists("Moon_FP"))
|
||||
fshader = mgr.getByName("Moon_FP");
|
||||
else
|
||||
fshader = mgr.createProgram("Moon_FP", ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME, "cg", GPT_FRAGMENT_PROGRAM);
|
||||
|
||||
fshader->setParameter("profiles", "ps_2_x arbfp1");
|
||||
fshader->setParameter("entry_point", "main_fp");
|
||||
StringUtil::StrStreamType outStream2;
|
||||
outStream2 <<
|
||||
"void main_fp( \n"
|
||||
" in float2 uv : TEXCOORD0, \n"
|
||||
" out float4 oColor : COLOR, \n"
|
||||
" uniform sampler2D texture : TEXUNIT0, \n"
|
||||
" uniform float4 diffuse, \n"
|
||||
" uniform float4 emissive \n"
|
||||
") \n"
|
||||
"{ \n"
|
||||
" float4 tex = tex2D(texture, uv); \n"
|
||||
" oColor = float4(emissive.xyz,1) * tex2D(texture, uv) * float4(1,1,1,diffuse.a); \n"
|
||||
"}";
|
||||
fshader->setSource(outStream2.str());
|
||||
fshader->load();
|
||||
fshader->getDefaultParameters()->setNamedAutoConstant("diffuse", GpuProgramParameters::ACT_SURFACE_DIFFUSE_COLOUR);
|
||||
fshader->getDefaultParameters()->setNamedAutoConstant("emissive", GpuProgramParameters::ACT_SURFACE_EMISSIVE_COLOUR);
|
||||
mMaterial->getTechnique(0)->getPass(0)->setFragmentProgram(fshader->getName());
|
||||
|
||||
setVisibility(1.0);
|
||||
|
||||
mPhase = Moon::Phase_Full;
|
||||
}
|
||||
|
||||
void Moon::setType(const Moon::Type& type)
|
||||
{
|
||||
mType = type;
|
||||
}
|
||||
|
||||
|
||||
/// \todo the moon phase rendering is not correct - the dark part of the moon does not occlude the stars
|
||||
void Moon::setPhase(const Moon::Phase& phase)
|
||||
{
|
||||
Ogre::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";
|
||||
|
||||
mMaterial->getTechnique(0)->getPass(0)->getTextureUnitState(0)->setTextureName(textureName);
|
||||
|
||||
mPhase = phase;
|
||||
}
|
||||
|
||||
Moon::Phase Moon::getPhase() const
|
||||
{
|
||||
return mPhase;
|
||||
}
|
||||
|
||||
unsigned int Moon::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;
|
||||
}
|
||||
|
||||
void SkyManager::ModVertexAlpha(Entity* ent, unsigned int meshType)
|
||||
{
|
||||
// Get the vertex colour buffer of this mesh
|
||||
const Ogre::VertexElement* ves_diffuse = ent->getMesh()->getSubMesh(0)->vertexData->vertexDeclaration->findElementBySemantic( Ogre::VES_DIFFUSE );
|
||||
HardwareVertexBufferSharedPtr colourBuffer = ent->getMesh()->getSubMesh(0)->vertexData->vertexBufferBinding->getBuffer(ves_diffuse->getSource());
|
||||
|
||||
// Lock
|
||||
void* pData = colourBuffer->lock(HardwareBuffer::HBL_NORMAL);
|
||||
|
||||
// Iterate over all vertices
|
||||
int vertex_size = colourBuffer->getVertexSize();
|
||||
float * currentVertex = NULL;
|
||||
for (unsigned int i=0; i<colourBuffer->getNumVertices(); ++i)
|
||||
{
|
||||
// Get a pointer to the vertex colour
|
||||
ves_diffuse->baseVertexPointerToElement( pData, ¤tVertex );
|
||||
|
||||
virtual void setDate (int day, int month) {}
|
||||
///< will be called even when sky is disabled.
|
||||
unsigned char alpha;
|
||||
if (meshType == 0) alpha = i%2 ? 0 : 255; // this is a cylinder, so every second vertex belongs to the bottom-most row
|
||||
else if (meshType == 1)
|
||||
{
|
||||
if (i>= 49 && i <= 64) alpha = 0; // bottom-most row
|
||||
else if (i>= 33 && i <= 48) alpha = 64; // second bottom-most row
|
||||
else alpha = 255;
|
||||
}
|
||||
|
||||
virtual int getMasserPhase() const { return 0; }
|
||||
///< 0 new moon, 1 waxing or waning cresecent, 2 waxing or waning half,
|
||||
/// 3 waxing or waning gibbous, 4 full moon
|
||||
uint8 tmpR = static_cast<uint8>(255);
|
||||
uint8 tmpG = static_cast<uint8>(255);
|
||||
uint8 tmpB = static_cast<uint8>(255);
|
||||
uint8 tmpA = static_cast<uint8>(alpha);
|
||||
|
||||
virtual int getSecundaPhase() const { return 0; }
|
||||
///< 0 new moon, 1 waxing or waning cresecent, 2 waxing or waning half,
|
||||
/// 3 waxing or waning gibbous, 4 full moon
|
||||
// This does not matter since R and B are always 1.
|
||||
/*VertexElementType format = Root::getSingleton().getRenderSystem()->getColourVertexElementType();
|
||||
switch (format)
|
||||
{
|
||||
case VET_COLOUR_ARGB:
|
||||
std::swap(tmpR, tmpB);
|
||||
break;
|
||||
case VET_COLOUR_ABGR:
|
||||
break;
|
||||
default:
|
||||
break;
|
||||
}*/
|
||||
|
||||
// Modify
|
||||
*((uint32*)currentVertex) = tmpR | (tmpG << 8) | (tmpB << 16) | (tmpA << 24);
|
||||
|
||||
virtual void setMoonColour (bool red) {}
|
||||
};
|
||||
// Move to the next vertex
|
||||
pData+=vertex_size;
|
||||
}
|
||||
|
||||
// Unlock
|
||||
ent->getMesh()->getSubMesh(0)->vertexData->vertexBufferBinding->getBuffer(ves_diffuse->getSource())->unlock();
|
||||
}
|
||||
|
||||
SkyManager::SkyManager (SceneNode* pMwRoot, Camera* pCamera) :
|
||||
mGlareFade(0), mGlareEnabled(false)
|
||||
{
|
||||
mViewport = pCamera->getViewport();
|
||||
mSceneMgr = pMwRoot->getCreator();
|
||||
mRootNode = pCamera->getParentSceneNode()->createChildSceneNode();
|
||||
mRootNode->pitch(Degree(-90)); // convert MW to ogre coordinates
|
||||
mRootNode->setInheritOrientation(false);
|
||||
|
||||
/// \todo preload all the textures and meshes that are used for sky rendering
|
||||
|
||||
// Create overlay used for thunderstorm
|
||||
MaterialPtr material = MaterialManager::getSingleton().create( "ThunderMaterial", ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME );
|
||||
Pass* pass = material->getTechnique(0)->getPass(0);
|
||||
pass->setSceneBlending(SBT_TRANSPARENT_ALPHA);
|
||||
mThunderTextureUnit = pass->createTextureUnitState();
|
||||
mThunderTextureUnit->setColourOperationEx(LBX_SOURCE1, LBS_MANUAL, LBS_CURRENT, ColourValue(1.f, 1.f, 1.f)); // always black colour
|
||||
mThunderTextureUnit->setAlphaOperation(LBX_SOURCE1, LBS_MANUAL, LBS_CURRENT, 0.5f);
|
||||
OverlayManager& ovm = OverlayManager::getSingleton();
|
||||
mThunderOverlay = ovm.create( "ThunderOverlay" );
|
||||
OverlayContainer* overlay_panel;
|
||||
overlay_panel = (OverlayContainer*)ovm.createOverlayElement("Panel", "ThunderPanel");
|
||||
overlay_panel->_setPosition(0, 0);
|
||||
overlay_panel->_setDimensions(1, 1);
|
||||
overlay_panel->setMaterialName( "ThunderMaterial" );
|
||||
overlay_panel->show();
|
||||
mThunderOverlay->add2D(overlay_panel);
|
||||
mThunderOverlay->hide();
|
||||
|
||||
mSecunda = new Moon("textures\\tx_secunda_full.dds", 0.5, Vector3(-0.4, 0.4, 0.5), mRootNode);
|
||||
mSecunda->setType(Moon::Type_Secunda);
|
||||
mSecunda->setRenderQueue(RENDER_QUEUE_SKIES_EARLY+4);
|
||||
|
||||
mMasser = new Moon("textures\\tx_masser_full.dds", 0.75, Vector3(-0.4, 0.4, 0.5), mRootNode);
|
||||
mMasser->setRenderQueue(RENDER_QUEUE_SKIES_EARLY+3);
|
||||
mMasser->setType(Moon::Type_Masser);
|
||||
|
||||
mSun = new BillboardObject("textures\\tx_sun_05.dds", 1, Vector3(0.4, 0.4, 0.4), mRootNode);
|
||||
mSunGlare = new BillboardObject("textures\\tx_sun_flash_grey_05.dds", 3, Vector3(0.4, 0.4, 0.4), mRootNode);
|
||||
mSunGlare->setRenderQueue(RENDER_QUEUE_SKIES_LATE);
|
||||
|
||||
CaelumManager::CaelumManager (Ogre::RenderWindow* pRenderWindow,
|
||||
Ogre::Camera* pCamera,
|
||||
const boost::filesystem::path& resDir)
|
||||
: mpCaelumSystem (NULL)
|
||||
|
||||
HighLevelGpuProgramManager& mgr = HighLevelGpuProgramManager::getSingleton();
|
||||
|
||||
// Stars
|
||||
/// \todo sky_night_02.nif (available in Bloodmoon)
|
||||
MeshPtr mesh = NifOgre::NIFLoader::load("meshes\\sky_night_01.nif");
|
||||
Entity* night1_ent = mSceneMgr->createEntity("meshes\\sky_night_01.nif");
|
||||
night1_ent->setRenderQueueGroup(RENDER_QUEUE_SKIES_EARLY+1);
|
||||
|
||||
mAtmosphereNight = mRootNode->createChildSceneNode();
|
||||
mAtmosphereNight->attachObject(night1_ent);
|
||||
|
||||
for (unsigned int i=0; i<night1_ent->getNumSubEntities(); ++i)
|
||||
{
|
||||
using namespace Ogre;
|
||||
using namespace Caelum;
|
||||
|
||||
assert(pCamera);
|
||||
assert(pRenderWindow);
|
||||
|
||||
// Load the Caelum resources
|
||||
//
|
||||
ResourceGroupManager::getSingleton().addResourceLocation((resDir / "caelum").string(), "FileSystem", "Caelum");
|
||||
ResourceGroupManager::getSingleton().initialiseAllResourceGroups();
|
||||
|
||||
// Load the Caelum resources
|
||||
//
|
||||
Ogre::SceneManager* pScene = pCamera->getSceneManager();
|
||||
Caelum::CaelumSystem::CaelumComponent componentMask = CaelumSystem::CAELUM_COMPONENTS_DEFAULT;
|
||||
mpCaelumSystem = new Caelum::CaelumSystem (Root::getSingletonPtr(), pScene, componentMask);
|
||||
MaterialPtr mp = night1_ent->getSubEntity(i)->getMaterial();
|
||||
mp->getTechnique(0)->getPass(0)->setSelfIllumination(1.0, 1.0, 1.0);
|
||||
mp->getTechnique(0)->getPass(0)->setAmbient(0.0, 0.0, 0.0);
|
||||
mp->getTechnique(0)->getPass(0)->setDiffuse(0.0, 0.0, 0.0, 1.0);
|
||||
mp->getTechnique(0)->getPass(0)->setDepthWriteEnabled(false);
|
||||
mp->getTechnique(0)->getPass(0)->setDepthCheckEnabled(false);
|
||||
mp->getTechnique(0)->getPass(0)->setSceneBlending(SBT_TRANSPARENT_ALPHA);
|
||||
|
||||
// Set time acceleration.
|
||||
mpCaelumSystem->getUniversalClock()->setTimeScale(128);
|
||||
mStarsMaterials[i] = mp;
|
||||
}
|
||||
|
||||
// Stars vertex shader
|
||||
HighLevelGpuProgramPtr vshader3 = mgr.createProgram("Stars_VP", ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME,
|
||||
"cg", GPT_VERTEX_PROGRAM);
|
||||
vshader3->setParameter("profiles", "vs_2_x arbvp1");
|
||||
vshader3->setParameter("entry_point", "main_vp");
|
||||
StringUtil::StrStreamType outStream4;
|
||||
outStream4 <<
|
||||
"void main_vp( \n"
|
||||
" float4 position : POSITION, \n"
|
||||
" in float2 uv : TEXCOORD0, \n"
|
||||
" out float2 oUV : TEXCOORD0, \n"
|
||||
" out float oFade : TEXCOORD1, \n"
|
||||
" out float4 oPosition : POSITION, \n"
|
||||
" uniform float4x4 worldViewProj \n"
|
||||
") \n"
|
||||
"{ \n"
|
||||
" oUV = uv; \n"
|
||||
" oFade = (position.z > 50) ? 1.f : 0.f; \n"
|
||||
" oPosition = mul( worldViewProj, position ); \n"
|
||||
"}";
|
||||
vshader3->setSource(outStream4.str());
|
||||
vshader3->load();
|
||||
vshader3->getDefaultParameters()->setNamedAutoConstant("worldViewProj", GpuProgramParameters::ACT_WORLDVIEWPROJ_MATRIX);
|
||||
night1_ent->getSubEntity(3)->getMaterial()->getTechnique(0)->getPass(0)->setVertexProgram(vshader3->getName());
|
||||
|
||||
// Stars fragment shader
|
||||
HighLevelGpuProgramPtr stars_fp = mgr.createProgram("Stars_FP", ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME,
|
||||
"cg", GPT_FRAGMENT_PROGRAM);
|
||||
stars_fp->setParameter("profiles", "ps_2_x arbfp1");
|
||||
stars_fp->setParameter("entry_point", "main_fp");
|
||||
StringUtil::StrStreamType outStream5;
|
||||
outStream5 <<
|
||||
"void main_fp( \n"
|
||||
" in float2 uv : TEXCOORD0, \n"
|
||||
" out float4 oColor : COLOR, \n"
|
||||
" in float fade : TEXCOORD1, \n"
|
||||
" uniform sampler2D texture : TEXUNIT0, \n"
|
||||
" uniform float opacity, \n"
|
||||
" uniform float4 diffuse, \n"
|
||||
" uniform float4 emissive \n"
|
||||
") \n"
|
||||
"{ \n"
|
||||
" oColor = tex2D(texture, uv) * float4(emissive.xyz, 1) * float4(1,1,1,fade*diffuse.a); \n"
|
||||
"}";
|
||||
stars_fp->setSource(outStream5.str());
|
||||
stars_fp->load();
|
||||
stars_fp->getDefaultParameters()->setNamedAutoConstant("emissive", GpuProgramParameters::ACT_SURFACE_EMISSIVE_COLOUR);
|
||||
stars_fp->getDefaultParameters()->setNamedAutoConstant("diffuse", GpuProgramParameters::ACT_SURFACE_DIFFUSE_COLOUR);
|
||||
night1_ent->getSubEntity(3)->getMaterial()->getTechnique(0)->getPass(0)->setFragmentProgram(stars_fp->getName());
|
||||
|
||||
// Atmosphere (day)
|
||||
mesh = NifOgre::NIFLoader::load("meshes\\sky_atmosphere.nif");
|
||||
Entity* atmosphere_ent = mSceneMgr->createEntity("meshes\\sky_atmosphere.nif");
|
||||
|
||||
ModVertexAlpha(atmosphere_ent, 0);
|
||||
|
||||
atmosphere_ent->setRenderQueueGroup(RENDER_QUEUE_SKIES_EARLY);
|
||||
mAtmosphereDay = mRootNode->createChildSceneNode();
|
||||
mAtmosphereDay->attachObject(atmosphere_ent);
|
||||
mAtmosphereMaterial = atmosphere_ent->getSubEntity(0)->getMaterial();
|
||||
|
||||
// Atmosphere shader
|
||||
HighLevelGpuProgramPtr vshader = mgr.createProgram("Atmosphere_VP", ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME,
|
||||
"cg", GPT_VERTEX_PROGRAM);
|
||||
|
||||
// Disable fog since OpenMW is handling OGRE fog elsewhere
|
||||
mpCaelumSystem->setManageSceneFog(false);
|
||||
vshader->setParameter("profiles", "vs_2_x arbvp1");
|
||||
vshader->setParameter("entry_point", "main_vp");
|
||||
|
||||
StringUtil::StrStreamType outStream;
|
||||
outStream <<
|
||||
"void main_vp( \n"
|
||||
" float4 position : POSITION, \n"
|
||||
" in float4 color : COLOR, \n"
|
||||
" out float4 oPosition : POSITION, \n"
|
||||
" out float4 oColor : COLOR, \n"
|
||||
" uniform float4 emissive, \n"
|
||||
" uniform float4x4 worldViewProj \n"
|
||||
") \n"
|
||||
"{ \n"
|
||||
" oPosition = mul( worldViewProj, position ); \n"
|
||||
" oColor = color * emissive; \n"
|
||||
"}";
|
||||
vshader->setSource(outStream.str());
|
||||
vshader->load();
|
||||
|
||||
vshader->getDefaultParameters()->setNamedAutoConstant("worldViewProj", GpuProgramParameters::ACT_WORLDVIEWPROJ_MATRIX);
|
||||
vshader->getDefaultParameters()->setNamedAutoConstant("emissive", GpuProgramParameters::ACT_SURFACE_EMISSIVE_COLOUR);
|
||||
mAtmosphereMaterial->getTechnique(0)->getPass(0)->setVertexProgram(vshader->getName());
|
||||
|
||||
// Change the camera far distance to make sure the sky is not clipped
|
||||
pCamera->setFarClipDistance(50000);
|
||||
// Clouds
|
||||
NifOgre::NIFLoader::load("meshes\\sky_clouds_01.nif");
|
||||
Entity* clouds_ent = mSceneMgr->createEntity("meshes\\sky_clouds_01.nif");
|
||||
clouds_ent->setRenderQueueGroup(RENDER_QUEUE_SKIES_EARLY+5);
|
||||
SceneNode* clouds_node = mRootNode->createChildSceneNode();
|
||||
clouds_node->attachObject(clouds_ent);
|
||||
mCloudMaterial = clouds_ent->getSubEntity(0)->getMaterial();
|
||||
|
||||
// Clouds vertex shader
|
||||
HighLevelGpuProgramPtr vshader2 = mgr.createProgram("Clouds_VP", ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME,
|
||||
"cg", GPT_VERTEX_PROGRAM);
|
||||
vshader2->setParameter("profiles", "vs_2_x arbvp1");
|
||||
vshader2->setParameter("entry_point", "main_vp");
|
||||
StringUtil::StrStreamType outStream3;
|
||||
outStream3 <<
|
||||
"void main_vp( \n"
|
||||
" float4 position : POSITION, \n"
|
||||
" in float4 color : COLOR, \n"
|
||||
" out float4 oColor : TEXCOORD1, \n"
|
||||
" in float2 uv : TEXCOORD0, \n"
|
||||
" out float2 oUV : TEXCOORD0, \n"
|
||||
" out float4 oPosition : POSITION, \n"
|
||||
" uniform float4x4 worldViewProj \n"
|
||||
") \n"
|
||||
"{ \n"
|
||||
" oUV = uv; \n"
|
||||
" oColor = color; \n"
|
||||
" oPosition = mul( worldViewProj, position ); \n"
|
||||
"}";
|
||||
vshader2->setSource(outStream3.str());
|
||||
vshader2->load();
|
||||
vshader2->getDefaultParameters()->setNamedAutoConstant("worldViewProj", GpuProgramParameters::ACT_WORLDVIEWPROJ_MATRIX);
|
||||
mCloudMaterial->getTechnique(0)->getPass(0)->setVertexProgram(vshader2->getName());
|
||||
|
||||
// Clouds fragment shader
|
||||
mCloudFragmentShader = mgr.createProgram("Clouds_FP", ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME,
|
||||
"cg", GPT_FRAGMENT_PROGRAM);
|
||||
mCloudFragmentShader->setParameter("profiles", "ps_2_x arbfp1");
|
||||
mCloudFragmentShader->setParameter("entry_point", "main_fp");
|
||||
StringUtil::StrStreamType outStream2;
|
||||
outStream2 <<
|
||||
"void main_fp( \n"
|
||||
" in float2 uv : TEXCOORD0, \n"
|
||||
" out float4 oColor : COLOR, \n"
|
||||
" in float4 color : TEXCOORD1, \n"
|
||||
" uniform sampler2D texture : TEXUNIT0, \n"
|
||||
" uniform sampler2D secondTexture : TEXUNIT1, \n"
|
||||
" uniform float transitionFactor, \n"
|
||||
" uniform float time, \n"
|
||||
" uniform float speed, \n"
|
||||
" uniform float opacity, \n"
|
||||
" uniform float4 emissive \n"
|
||||
") \n"
|
||||
"{ \n"
|
||||
" uv += float2(1,1) * time * speed * "<<CLOUD_SPEED<<"; \n" // Scroll in x,y direction
|
||||
" float4 tex = lerp(tex2D(texture, uv), tex2D(secondTexture, uv), transitionFactor); \n"
|
||||
" oColor = color * float4(emissive.xyz,1) * tex * float4(1,1,1,opacity); \n"
|
||||
"}";
|
||||
mCloudFragmentShader->setSource(outStream2.str());
|
||||
mCloudFragmentShader->load();
|
||||
mCloudFragmentShader->getDefaultParameters()->setNamedAutoConstant("emissive", GpuProgramParameters::ACT_SURFACE_EMISSIVE_COLOUR);
|
||||
mCloudMaterial->getTechnique(0)->getPass(0)->setFragmentProgram(mCloudFragmentShader->getName());
|
||||
setCloudsOpacity(0.75);
|
||||
|
||||
ModVertexAlpha(clouds_ent, 1);
|
||||
|
||||
// I'm not sure if the materials are being used by any other objects
|
||||
// Make a unique "modifiable" copy of the materials to be sure
|
||||
mCloudMaterial = mCloudMaterial->clone("Clouds");
|
||||
clouds_ent->getSubEntity(0)->setMaterial(mCloudMaterial);
|
||||
mAtmosphereMaterial = mAtmosphereMaterial->clone("Atmosphere");
|
||||
atmosphere_ent->getSubEntity(0)->setMaterial(mAtmosphereMaterial);
|
||||
|
||||
mAtmosphereMaterial->getTechnique(0)->getPass(0)->setSelfIllumination(1.0, 1.0, 1.0);
|
||||
mAtmosphereMaterial->getTechnique(0)->getPass(0)->setDiffuse(0.0, 0.0, 0.0, 0.0);
|
||||
mAtmosphereMaterial->getTechnique(0)->getPass(0)->setAmbient(0.0, 0.0, 0.0);
|
||||
mCloudMaterial->getTechnique(0)->getPass(0)->setSelfIllumination(1.0, 1.0, 1.0);
|
||||
mCloudMaterial->getTechnique(0)->getPass(0)->setDepthWriteEnabled(false);
|
||||
mAtmosphereMaterial->getTechnique(0)->getPass(0)->setDepthWriteEnabled(false);
|
||||
mAtmosphereMaterial->getTechnique(0)->getPass(0)->setSceneBlending(SBT_TRANSPARENT_ALPHA);
|
||||
mCloudMaterial->getTechnique(0)->getPass(0)->setSceneBlending(SBT_TRANSPARENT_ALPHA);
|
||||
|
||||
mCloudMaterial->getTechnique(0)->getPass(0)->createTextureUnitState("");
|
||||
}
|
||||
|
||||
// Register Caelum as an OGRE listener
|
||||
pRenderWindow->addListener(mpCaelumSystem);
|
||||
Root::getSingletonPtr()->addFrameListener(mpCaelumSystem);
|
||||
}
|
||||
SkyManager::~SkyManager()
|
||||
{
|
||||
delete mSun;
|
||||
delete mSunGlare;
|
||||
delete mMasser;
|
||||
delete mSecunda;
|
||||
}
|
||||
|
||||
CaelumManager::~CaelumManager()
|
||||
{
|
||||
if (mpCaelumSystem)
|
||||
mpCaelumSystem->shutdown (false);
|
||||
}
|
||||
int SkyManager::getMasserPhase() const
|
||||
{
|
||||
return mMasser->getPhaseInt();
|
||||
}
|
||||
|
||||
/// Creates and connects the sky rendering component to OGRE.
|
||||
///
|
||||
/// \return NULL on failure.
|
||||
///
|
||||
SkyManager* SkyManager::create (Ogre::RenderWindow* pRenderWindow,
|
||||
Ogre::Camera* pCamera,
|
||||
const boost::filesystem::path& resDir)
|
||||
{
|
||||
SkyManager* pSkyManager = NULL;
|
||||
int SkyManager::getSecundaPhase() const
|
||||
{
|
||||
return mSecunda->getPhaseInt();
|
||||
}
|
||||
|
||||
try
|
||||
{
|
||||
pSkyManager = new CaelumManager(pRenderWindow, pCamera, resDir);
|
||||
}
|
||||
catch (Ogre::Exception& e)
|
||||
void SkyManager::update(float duration)
|
||||
{
|
||||
if (!mEnabled) return;
|
||||
|
||||
// UV Scroll the clouds
|
||||
mCloudMaterial->getTechnique(0)->getPass(0)->getFragmentProgramParameters()->setNamedConstantFromTime("time", 1);
|
||||
|
||||
/// \todo improve this
|
||||
mMasser->setPhase( static_cast<Moon::Phase>( (int) ((mDay % 32)/4.f)) );
|
||||
mSecunda->setPhase ( static_cast<Moon::Phase>( (int) ((mDay % 32)/4.f)) );
|
||||
|
||||
// increase the strength of the sun glare effect depending
|
||||
// on how directly the player is looking at the sun
|
||||
if (mSunEnabled)
|
||||
{
|
||||
Vector3 sun = mSunGlare->getPosition();
|
||||
sun = Vector3(sun.x, sun.z, -sun.y);
|
||||
Vector3 cam = mViewport->getCamera()->getRealDirection();
|
||||
const Degree angle = sun.angleBetween( cam );
|
||||
float val = 1- (angle.valueDegrees() / 180.f);
|
||||
val = (val*val*val*val)*2;
|
||||
|
||||
if (mGlareEnabled)
|
||||
{
|
||||
std::cout << "\nOGRE Exception when attempting to add sky: "
|
||||
<< e.getFullDescription().c_str() << std::endl;
|
||||
mGlareFade += duration*3;
|
||||
if (mGlareFade > 1) mGlareFade = 1;
|
||||
}
|
||||
catch (std::exception& e)
|
||||
else
|
||||
{
|
||||
std::cout << "\nException when attempting to add sky: "
|
||||
<< e.what() << std::endl;
|
||||
mGlareFade -= duration*3;
|
||||
if (mGlareFade < 0.3) mGlareFade = 0;
|
||||
}
|
||||
|
||||
mSunGlare->setSize(val * (mGlareFade));
|
||||
}
|
||||
|
||||
mSunGlare->setVisible(mGlareFade>0 && mSunEnabled);
|
||||
mSun->setVisible(mSunEnabled);
|
||||
mMasser->setVisible(mMasserEnabled);
|
||||
mSecunda->setVisible(mSecundaEnabled);
|
||||
}
|
||||
|
||||
void SkyManager::enable()
|
||||
{
|
||||
mRootNode->setVisible(true);
|
||||
mEnabled = true;
|
||||
}
|
||||
|
||||
void SkyManager::disable()
|
||||
{
|
||||
mRootNode->setVisible(false);
|
||||
mEnabled = false;
|
||||
}
|
||||
|
||||
void SkyManager::setMoonColour (bool red)
|
||||
{
|
||||
mSecunda->setColour( red ? ColourValue(1.0, 0.0784, 0.0784)
|
||||
: ColourValue(1.0, 1.0, 1.0));
|
||||
}
|
||||
|
||||
void SkyManager::setCloudsOpacity(float opacity)
|
||||
{
|
||||
mCloudMaterial->getTechnique(0)->getPass(0)->getFragmentProgramParameters()->setNamedConstant("opacity", Real(opacity));
|
||||
}
|
||||
|
||||
void SkyManager::setWeather(const MWWorld::WeatherResult& weather)
|
||||
{
|
||||
if (mClouds != weather.mCloudTexture)
|
||||
{
|
||||
mCloudMaterial->getTechnique(0)->getPass(0)->getTextureUnitState(0)->setTextureName("textures\\"+weather.mCloudTexture);
|
||||
mClouds = weather.mCloudTexture;
|
||||
}
|
||||
|
||||
if (mNextClouds != weather.mNextCloudTexture)
|
||||
{
|
||||
mCloudMaterial->getTechnique(0)->getPass(0)->getTextureUnitState(1)->setTextureName("textures\\"+weather.mNextCloudTexture);
|
||||
mNextClouds = weather.mNextCloudTexture;
|
||||
}
|
||||
|
||||
if (mCloudBlendFactor != weather.mCloudBlendFactor)
|
||||
{
|
||||
mCloudMaterial->getTechnique(0)->getPass(0)->getFragmentProgramParameters()->setNamedConstant("transitionFactor", Real(weather.mCloudBlendFactor));
|
||||
mCloudBlendFactor = weather.mCloudBlendFactor;
|
||||
}
|
||||
|
||||
if (mCloudOpacity != weather.mCloudOpacity)
|
||||
{
|
||||
mCloudMaterial->getTechnique(0)->getPass(0)->getFragmentProgramParameters()->setNamedConstant("opacity", Real(weather.mCloudOpacity));
|
||||
mCloudOpacity = weather.mCloudOpacity;
|
||||
}
|
||||
|
||||
if (mCloudColour != weather.mSunColor)
|
||||
{
|
||||
ColourValue clr( weather.mSunColor.r*0.7 + weather.mAmbientColor.r*0.7,
|
||||
weather.mSunColor.g*0.7 + weather.mAmbientColor.g*0.7,
|
||||
weather.mSunColor.b*0.7 + weather.mAmbientColor.b*0.7);
|
||||
|
||||
mCloudMaterial->getTechnique(0)->getPass(0)->setSelfIllumination(clr);
|
||||
mCloudColour = weather.mSunColor;
|
||||
}
|
||||
|
||||
if (mSkyColour != weather.mSkyColor)
|
||||
{
|
||||
mAtmosphereMaterial->getTechnique(0)->getPass(0)->setSelfIllumination(weather.mSkyColor);
|
||||
mSkyColour = weather.mSkyColor;
|
||||
}
|
||||
|
||||
if (mCloudSpeed != weather.mCloudSpeed)
|
||||
{
|
||||
mCloudMaterial->getTechnique(0)->getPass(0)->getFragmentProgramParameters()->setNamedConstant("speed", Real(weather.mCloudSpeed));
|
||||
mCloudSpeed = weather.mCloudSpeed;
|
||||
}
|
||||
|
||||
if (weather.mNight && mStarsOpacity != weather.mNightFade)
|
||||
{
|
||||
for (int i=0; i<7; ++i)
|
||||
mStarsMaterials[i]->getTechnique(0)->getPass(0)->setDiffuse(0.0, 0.0, 0.0, weather.mNightFade);
|
||||
mStarsOpacity = weather.mNightFade;
|
||||
}
|
||||
|
||||
float strength;
|
||||
float timeofday_angle = std::abs(mSunGlare->getPosition().z/mSunGlare->getPosition().length());
|
||||
if (timeofday_angle <= 0.44)
|
||||
strength = timeofday_angle/0.44f;
|
||||
else
|
||||
strength = 1.f;
|
||||
|
||||
mSunGlare->setVisibility(weather.mGlareView * strength);
|
||||
|
||||
mAtmosphereNight->setVisible(weather.mNight && mEnabled);
|
||||
}
|
||||
|
||||
return pSkyManager;
|
||||
void SkyManager::setGlare(bool glare)
|
||||
{
|
||||
mGlareEnabled = glare;
|
||||
}
|
||||
|
||||
Vector3 SkyManager::getRealSunPos()
|
||||
{
|
||||
return mSun->getNode()->_getDerivedPosition();
|
||||
}
|
||||
|
||||
void SkyManager::sunEnable()
|
||||
{
|
||||
mSunEnabled = true;
|
||||
}
|
||||
|
||||
void SkyManager::sunDisable()
|
||||
{
|
||||
mSunEnabled = false;
|
||||
}
|
||||
|
||||
void SkyManager::setSunDirection(const Vector3& direction)
|
||||
{
|
||||
mSun->setPosition(direction);
|
||||
mSunGlare->setPosition(direction);
|
||||
}
|
||||
|
||||
void SkyManager::setMasserDirection(const Vector3& direction)
|
||||
{
|
||||
mMasser->setPosition(direction);
|
||||
}
|
||||
|
||||
void SkyManager::setSecundaDirection(const Vector3& direction)
|
||||
{
|
||||
mSecunda->setPosition(direction);
|
||||
}
|
||||
|
||||
void SkyManager::masserEnable()
|
||||
{
|
||||
mMasserEnabled = true;
|
||||
}
|
||||
|
||||
void SkyManager::secundaEnable()
|
||||
{
|
||||
mSecundaEnabled = true;
|
||||
}
|
||||
|
||||
void SkyManager::masserDisable()
|
||||
{
|
||||
mMasserEnabled = false;
|
||||
}
|
||||
|
||||
void SkyManager::secundaDisable()
|
||||
{
|
||||
mSecundaEnabled = false;
|
||||
}
|
||||
|
||||
void SkyManager::setThunder(const float factor)
|
||||
{
|
||||
if (factor > 0.f)
|
||||
{
|
||||
mThunderOverlay->show();
|
||||
mThunderTextureUnit->setAlphaOperation(LBX_SOURCE1, LBS_MANUAL, LBS_CURRENT, factor*0.6);
|
||||
}
|
||||
}
|
||||
else
|
||||
mThunderOverlay->hide();
|
||||
}
|
||||
|
||||
void SkyManager::setMasserFade(const float fade)
|
||||
{
|
||||
mMasser->setVisibility(fade);
|
||||
}
|
||||
|
||||
void SkyManager::setSecundaFade(const float fade)
|
||||
{
|
||||
mSecunda->setVisibility(fade);
|
||||
}
|
||||
|
||||
void SkyManager::setHour(double hour)
|
||||
{
|
||||
mHour = hour;
|
||||
}
|
||||
|
||||
void SkyManager::setDate(int day, int month)
|
||||
{
|
||||
mDay = day;
|
||||
mMonth = month;
|
||||
}
|
||||
|
||||
@ -0,0 +1,803 @@
|
||||
#include "weather.hpp"
|
||||
#include "world.hpp"
|
||||
#include "player.hpp"
|
||||
|
||||
#include "../mwrender/renderingmanager.hpp"
|
||||
#include "../mwsound/soundmanager.hpp"
|
||||
|
||||
#include <ctime>
|
||||
#include <cstdlib>
|
||||
#include <iostream>
|
||||
|
||||
#include <boost/algorithm/string.hpp>
|
||||
|
||||
using namespace Ogre;
|
||||
using namespace MWWorld;
|
||||
using namespace MWSound;
|
||||
|
||||
#define lerp(x, y) (x * (1-factor) + y * factor)
|
||||
|
||||
const std::string WeatherGlobals::mThunderSoundID0 = "Thunder0";
|
||||
const std::string WeatherGlobals::mThunderSoundID1 = "Thunder1";
|
||||
const std::string WeatherGlobals::mThunderSoundID2 = "Thunder2";
|
||||
const std::string WeatherGlobals::mThunderSoundID3 = "Thunder3";
|
||||
|
||||
WeatherManager::WeatherManager(MWRender::RenderingManager* rendering, Environment* env) :
|
||||
mHour(14), mCurrentWeather("clear"), mFirstUpdate(true), mWeatherUpdateTime(0),
|
||||
mThunderFlash(0), mThunderChance(0), mThunderChanceNeeded(50), mThunderSoundDelay(0)
|
||||
{
|
||||
mRendering = rendering;
|
||||
mEnvironment = env;
|
||||
|
||||
#define clr(r,g,b) ColourValue(r/255.f, g/255.f, b/255.f)
|
||||
|
||||
/// \todo read these from Morrowind.ini
|
||||
Weather clear;
|
||||
clear.mCloudTexture = "tx_sky_clear.dds";
|
||||
clear.mCloudsMaximumPercent = 1.0;
|
||||
clear.mTransitionDelta = 0.015;
|
||||
clear.mSkySunriseColor = clr(118, 141, 164);
|
||||
clear.mSkyDayColor = clr(95, 135, 203);
|
||||
clear.mSkySunsetColor = clr(56, 89, 129);
|
||||
clear.mSkyNightColor = clr(9, 10, 11);
|
||||
clear.mFogSunriseColor = clr(255, 189, 157);
|
||||
clear.mFogDayColor = clr(206, 227, 255);
|
||||
clear.mFogSunsetColor = clr(255, 189, 157);
|
||||
clear.mFogNightColor = clr(9, 10, 11);
|
||||
clear.mAmbientSunriseColor = clr(47, 66, 96);
|
||||
clear.mAmbientDayColor = clr(137, 140, 160);
|
||||
clear.mAmbientSunsetColor = clr(68, 75, 96);
|
||||
clear.mAmbientNightColor = clr(32, 35, 42);
|
||||
clear.mSunSunriseColor = clr(242, 159, 99);
|
||||
clear.mSunDayColor = clr(255, 252, 238);
|
||||
clear.mSunSunsetColor = clr(255, 115, 79);
|
||||
clear.mSunNightColor = clr(59, 97, 176);
|
||||
clear.mSunDiscSunsetColor = clr(255, 189, 157);
|
||||
clear.mLandFogDayDepth = 0.69;
|
||||
clear.mLandFogNightDepth = 0.69;
|
||||
clear.mWindSpeed = 0.1;
|
||||
clear.mCloudSpeed = 1.25;
|
||||
clear.mGlareView = 1.0;
|
||||
mWeatherSettings["clear"] = clear;
|
||||
|
||||
Weather cloudy;
|
||||
cloudy.mCloudTexture = "tx_sky_cloudy.dds";
|
||||
cloudy.mCloudsMaximumPercent = 1.0;
|
||||
cloudy.mTransitionDelta = 0.015;
|
||||
cloudy.mSkySunriseColor = clr(126, 158, 173);
|
||||
cloudy.mSkyDayColor = clr(117, 160, 215);
|
||||
cloudy.mSkySunsetColor = clr(111, 114, 159);
|
||||
cloudy.mSkyNightColor = clr(9, 10, 11);
|
||||
cloudy.mFogSunriseColor = clr(255, 207, 149);
|
||||
cloudy.mFogDayColor = clr(245, 235, 224);
|
||||
cloudy.mFogSunsetColor = clr(255, 155, 106);
|
||||
cloudy.mFogNightColor = clr(9, 10, 11);
|
||||
cloudy.mAmbientSunriseColor = clr(66, 74, 87);
|
||||
cloudy.mAmbientDayColor = clr(137, 145, 160);
|
||||
cloudy.mAmbientSunsetColor = clr(71, 80, 92);
|
||||
cloudy.mAmbientNightColor = clr(32, 39, 54);
|
||||
cloudy.mSunSunriseColor = clr(241, 177, 99);
|
||||
cloudy.mSunDayColor = clr(255, 236, 221);
|
||||
cloudy.mSunSunsetColor = clr(255, 89, 00);
|
||||
cloudy.mSunNightColor = clr(77, 91, 124);
|
||||
cloudy.mSunDiscSunsetColor = clr(255, 202, 179);
|
||||
cloudy.mLandFogDayDepth = 0.72;
|
||||
cloudy.mLandFogNightDepth = 0.72;
|
||||
cloudy.mWindSpeed = 0.2;
|
||||
cloudy.mCloudSpeed = 2;
|
||||
cloudy.mGlareView = 1.0;
|
||||
mWeatherSettings["cloudy"] = cloudy;
|
||||
|
||||
Weather foggy;
|
||||
foggy.mCloudTexture = "tx_sky_foggy.dds";
|
||||
foggy.mCloudsMaximumPercent = 1.0;
|
||||
foggy.mTransitionDelta = 0.015;
|
||||
foggy.mSkySunriseColor = clr(197, 190, 180);
|
||||
foggy.mSkyDayColor = clr(184, 211, 228);
|
||||
foggy.mSkySunsetColor = clr(142, 159, 176);
|
||||
foggy.mSkyNightColor = clr(18, 23, 28);
|
||||
foggy.mFogSunriseColor = clr(173, 164, 148);
|
||||
foggy.mFogDayColor = clr(150, 187, 209);
|
||||
foggy.mFogSunsetColor = clr(113, 135, 157);
|
||||
foggy.mFogNightColor = clr(19, 24, 29);
|
||||
foggy.mAmbientSunriseColor = clr(48, 43, 37);
|
||||
foggy.mAmbientDayColor = clr(92, 109, 120);
|
||||
foggy.mAmbientSunsetColor = clr(28, 33, 39);
|
||||
foggy.mAmbientNightColor = clr(28, 33, 39);
|
||||
foggy.mSunSunriseColor = clr(177, 162, 137);
|
||||
foggy.mSunDayColor = clr(111, 131, 151);
|
||||
foggy.mSunSunsetColor = clr(125, 157, 189);
|
||||
foggy.mSunNightColor = clr(81, 100, 119);
|
||||
foggy.mSunDiscSunsetColor = clr(223, 223, 223);
|
||||
foggy.mLandFogDayDepth = 1.0;
|
||||
foggy.mLandFogNightDepth = 1.9;
|
||||
foggy.mWindSpeed = 0;
|
||||
foggy.mCloudSpeed = 1.25;
|
||||
foggy.mGlareView = 0.25;
|
||||
mWeatherSettings["foggy"] = foggy;
|
||||
|
||||
Weather thunderstorm;
|
||||
thunderstorm.mCloudTexture = "tx_sky_thunder.dds";
|
||||
thunderstorm.mCloudsMaximumPercent = 0.66;
|
||||
thunderstorm.mTransitionDelta = 0.03;
|
||||
thunderstorm.mSkySunriseColor = clr(35, 36, 39);
|
||||
thunderstorm.mSkyDayColor = clr(97, 104, 115);
|
||||
thunderstorm.mSkySunsetColor = clr(35, 36, 39);
|
||||
thunderstorm.mSkyNightColor = clr(19, 20, 22);
|
||||
thunderstorm.mFogSunriseColor = clr(70, 74, 85);
|
||||
thunderstorm.mFogDayColor = clr(97, 104, 115);
|
||||
thunderstorm.mFogSunsetColor = clr(70, 74, 85);
|
||||
thunderstorm.mFogNightColor = clr(19, 20, 22);
|
||||
thunderstorm.mAmbientSunriseColor = clr(54, 54, 54);
|
||||
thunderstorm.mAmbientDayColor = clr(90, 90, 90);
|
||||
thunderstorm.mAmbientSunsetColor = clr(54, 54, 54);
|
||||
thunderstorm.mAmbientNightColor = clr(49, 51, 54);
|
||||
thunderstorm.mSunSunriseColor = clr(91, 99, 122);
|
||||
thunderstorm.mSunDayColor = clr(138, 144, 155);
|
||||
thunderstorm.mSunSunsetColor = clr(96, 101, 117);
|
||||
thunderstorm.mSunNightColor = clr(55, 76, 110);
|
||||
thunderstorm.mSunDiscSunsetColor = clr(128, 128, 128);
|
||||
thunderstorm.mLandFogDayDepth = 1;
|
||||
thunderstorm.mLandFogNightDepth = 1.15;
|
||||
thunderstorm.mWindSpeed = 0.5;
|
||||
thunderstorm.mCloudSpeed = 3;
|
||||
thunderstorm.mGlareView = 0;
|
||||
thunderstorm.mRainLoopSoundID = "rain heavy";
|
||||
mWeatherSettings["thunderstorm"] = thunderstorm;
|
||||
|
||||
Weather rain;
|
||||
rain.mCloudTexture = "tx_sky_rainy.dds";
|
||||
rain.mCloudsMaximumPercent = 0.66;
|
||||
rain.mTransitionDelta = 0.015;
|
||||
rain.mSkySunriseColor = clr(71, 74, 75);
|
||||
rain.mSkyDayColor = clr(116, 120, 122);
|
||||
rain.mSkySunsetColor = clr(73, 73, 73);
|
||||
rain.mSkyNightColor = clr(24, 25, 26);
|
||||
rain.mFogSunriseColor = clr(71, 74, 75);
|
||||
rain.mFogDayColor = clr(116, 120, 122);
|
||||
rain.mFogSunsetColor = clr(73, 73, 73);
|
||||
rain.mFogNightColor = clr(24, 25, 26);
|
||||
rain.mAmbientSunriseColor = clr(97, 90, 88);
|
||||
rain.mAmbientDayColor = clr(105, 110, 113);
|
||||
rain.mAmbientSunsetColor = clr(88, 97, 97);
|
||||
rain.mAmbientNightColor = clr(50, 55, 67);
|
||||
rain.mSunSunriseColor = clr(131, 122, 120);
|
||||
rain.mSunDayColor = clr(149, 157, 170);
|
||||
rain.mSunSunsetColor = clr(120, 126, 131);
|
||||
rain.mSunNightColor = clr(50, 62, 101);
|
||||
rain.mSunDiscSunsetColor = clr(128, 128, 128);
|
||||
rain.mLandFogDayDepth = 0.8;
|
||||
rain.mLandFogNightDepth = 0.8;
|
||||
rain.mWindSpeed = 0.3;
|
||||
rain.mCloudSpeed = 2;
|
||||
rain.mGlareView = 0;
|
||||
rain.mRainLoopSoundID = "rain";
|
||||
mWeatherSettings["rain"] = rain;
|
||||
|
||||
Weather overcast;
|
||||
overcast.mCloudTexture = "tx_sky_overcast.dds";
|
||||
overcast.mCloudsMaximumPercent = 1.0;
|
||||
overcast.mTransitionDelta = 0.015;
|
||||
overcast.mSkySunriseColor = clr(91, 99, 106);
|
||||
overcast.mSkyDayColor = clr(143, 146, 149);
|
||||
overcast.mSkySunsetColor = clr(108, 115, 121);
|
||||
overcast.mSkyNightColor = clr(19, 22, 25);
|
||||
overcast.mFogSunriseColor = clr(91, 99, 106);
|
||||
overcast.mFogDayColor = clr(143, 146, 149);
|
||||
overcast.mFogSunsetColor = clr(108, 115, 121);
|
||||
overcast.mFogNightColor = clr(19, 22, 25);
|
||||
overcast.mAmbientSunriseColor = clr(84, 88, 92);
|
||||
overcast.mAmbientDayColor = clr(93, 96, 105);
|
||||
overcast.mAmbientSunsetColor = clr(83, 77, 75);
|
||||
overcast.mAmbientNightColor = clr(57, 60, 66);
|
||||
overcast.mSunSunriseColor = clr(87, 125, 163);
|
||||
overcast.mSunDayColor = clr(163, 169, 183);
|
||||
overcast.mSunSunsetColor = clr(85, 103, 157);
|
||||
overcast.mSunNightColor = clr(32, 54, 100);
|
||||
overcast.mSunDiscSunsetColor = clr(128, 128, 128);
|
||||
overcast.mLandFogDayDepth = 0.7;
|
||||
overcast.mLandFogNightDepth = 0.7;
|
||||
overcast.mWindSpeed = 0.2;
|
||||
overcast.mCloudSpeed = 1.5;
|
||||
overcast.mGlareView = 0;
|
||||
mWeatherSettings["overcast"] = overcast;
|
||||
|
||||
Weather ashstorm;
|
||||
ashstorm.mCloudTexture = "tx_sky_ashstorm.dds";
|
||||
ashstorm.mCloudsMaximumPercent = 1.0;
|
||||
ashstorm.mTransitionDelta = 0.035;
|
||||
ashstorm.mSkySunriseColor = clr(91, 56, 51);
|
||||
ashstorm.mSkyDayColor = clr(124, 73, 58);
|
||||
ashstorm.mSkySunsetColor = clr(106, 55, 40);
|
||||
ashstorm.mSkyNightColor = clr(20, 21, 22);
|
||||
ashstorm.mFogSunriseColor = clr(91, 56, 51);
|
||||
ashstorm.mFogDayColor = clr(124, 73, 58);
|
||||
ashstorm.mFogSunsetColor = clr(106, 55, 40);
|
||||
ashstorm.mFogNightColor = clr(20, 21, 22);
|
||||
ashstorm.mAmbientSunriseColor = clr(52, 42, 37);
|
||||
ashstorm.mAmbientDayColor = clr(75, 49, 41);
|
||||
ashstorm.mAmbientSunsetColor = clr(48, 39, 35);
|
||||
ashstorm.mAmbientNightColor = clr(36, 42, 49);
|
||||
ashstorm.mSunSunriseColor = clr(184, 91, 71);
|
||||
ashstorm.mSunDayColor = clr(228, 139, 114);
|
||||
ashstorm.mSunSunsetColor = clr(185, 86, 57);
|
||||
ashstorm.mSunNightColor = clr(54, 66, 74);
|
||||
ashstorm.mSunDiscSunsetColor = clr(128, 128, 128);
|
||||
ashstorm.mLandFogDayDepth = 1.1;
|
||||
ashstorm.mLandFogNightDepth = 1.2;
|
||||
ashstorm.mWindSpeed = 0.8;
|
||||
ashstorm.mCloudSpeed = 7;
|
||||
ashstorm.mGlareView = 0;
|
||||
ashstorm.mAmbientLoopSoundID = "ashstorm";
|
||||
mWeatherSettings["ashstorm"] = ashstorm;
|
||||
|
||||
Weather blight;
|
||||
blight.mCloudTexture = "tx_sky_blight.dds";
|
||||
blight.mCloudsMaximumPercent = 1.0;
|
||||
blight.mTransitionDelta = 0.04;
|
||||
blight.mSkySunriseColor = clr(90, 35, 35);
|
||||
blight.mSkyDayColor = clr(90, 35, 35);
|
||||
blight.mSkySunsetColor = clr(92, 33, 33);
|
||||
blight.mSkyNightColor = clr(44, 14, 14);
|
||||
blight.mFogSunriseColor = clr(90, 35, 35);
|
||||
blight.mFogDayColor = clr(128, 19, 19);
|
||||
blight.mFogSunsetColor = clr(92, 33, 33);
|
||||
blight.mFogNightColor = clr(44, 14, 14);
|
||||
blight.mAmbientSunriseColor = clr(61, 40, 40);
|
||||
blight.mAmbientDayColor = clr(79, 54, 54);
|
||||
blight.mAmbientSunsetColor = clr(61, 40, 40);
|
||||
blight.mAmbientNightColor = clr(56, 58, 62);
|
||||
blight.mSunSunriseColor = clr(180, 78, 78);
|
||||
blight.mSunDayColor = clr(224, 84, 84);
|
||||
blight.mSunSunsetColor = clr(180, 78, 78);
|
||||
blight.mSunNightColor = clr(61, 91, 143);
|
||||
blight.mSunDiscSunsetColor = clr(128, 128, 128);
|
||||
blight.mLandFogDayDepth = 1.1;
|
||||
blight.mLandFogNightDepth = 1.2;
|
||||
blight.mWindSpeed = 0.9;
|
||||
blight.mCloudSpeed = 9;
|
||||
blight.mGlareView = 0;
|
||||
blight.mAmbientLoopSoundID = "blight";
|
||||
mWeatherSettings["blight"] = blight;
|
||||
|
||||
Weather snow;
|
||||
snow.mCloudTexture = "tx_bm_sky_snow.dds";
|
||||
snow.mCloudsMaximumPercent = 1.0;
|
||||
snow.mTransitionDelta = 0.014;
|
||||
snow.mSkySunriseColor = clr(196, 91, 91);
|
||||
snow.mSkyDayColor = clr(153, 158, 166);
|
||||
snow.mSkySunsetColor = clr(96, 115, 134);
|
||||
snow.mSkyNightColor = clr(31, 35, 39);
|
||||
snow.mFogSunriseColor = clr(106, 91, 91);
|
||||
snow.mFogDayColor = clr(153, 158, 166);
|
||||
snow.mFogSunsetColor = clr(96, 115, 134);
|
||||
snow.mFogNightColor = clr(31, 35, 39);
|
||||
snow.mAmbientSunriseColor = clr(92, 84, 84);
|
||||
snow.mAmbientDayColor = clr(93, 96, 105);
|
||||
snow.mAmbientSunsetColor = clr(70, 79, 87);
|
||||
snow.mAmbientNightColor = clr(49, 58, 68);
|
||||
snow.mSunSunriseColor = clr(141, 109, 109);
|
||||
snow.mSunDayColor = clr(163, 169, 183);
|
||||
snow.mSunSunsetColor = clr(101, 121, 141);
|
||||
snow.mSunNightColor = clr(55, 66, 77);
|
||||
snow.mSunDiscSunsetColor = clr(128, 128, 128);
|
||||
snow.mLandFogDayDepth = 1.0;
|
||||
snow.mLandFogNightDepth = 1.2;
|
||||
snow.mWindSpeed = 0;
|
||||
snow.mCloudSpeed = 1.5;
|
||||
snow.mGlareView = 0;
|
||||
mWeatherSettings["snow"] = snow;
|
||||
|
||||
Weather blizzard;
|
||||
blizzard.mCloudTexture = "tx_bm_sky_blizzard.dds";
|
||||
blizzard.mCloudsMaximumPercent = 1.0;
|
||||
blizzard.mTransitionDelta = 0.030;
|
||||
blizzard.mSkySunriseColor = clr(91, 99, 106);
|
||||
blizzard.mSkyDayColor = clr(121, 133, 145);
|
||||
blizzard.mSkySunsetColor = clr(108, 115, 121);
|
||||
blizzard.mSkyNightColor = clr(27, 29, 31);
|
||||
blizzard.mFogSunriseColor = clr(91, 99, 106);
|
||||
blizzard.mFogDayColor = clr(121, 133, 145);
|
||||
blizzard.mFogSunsetColor = clr(108, 115, 121);
|
||||
blizzard.mFogNightColor = clr(21, 24, 28);
|
||||
blizzard.mAmbientSunriseColor = clr(84, 88, 92);
|
||||
blizzard.mAmbientDayColor = clr(93, 96, 105);
|
||||
blizzard.mAmbientSunsetColor = clr(83, 77, 75);
|
||||
blizzard.mAmbientNightColor = clr(53, 62, 70);
|
||||
blizzard.mSunSunriseColor = clr(114, 128, 146);
|
||||
blizzard.mSunDayColor = clr(163, 169, 183);
|
||||
blizzard.mSunSunsetColor = clr(106, 114, 136);
|
||||
blizzard.mSunNightColor = clr(57, 66, 74);
|
||||
blizzard.mSunDiscSunsetColor = clr(128, 128, 128);
|
||||
blizzard.mLandFogDayDepth = 2.8;
|
||||
blizzard.mLandFogNightDepth = 3.0;
|
||||
blizzard.mWindSpeed = 0.9;
|
||||
blizzard.mCloudSpeed = 7.5;
|
||||
blizzard.mGlareView = 0;
|
||||
blizzard.mAmbientLoopSoundID = "BM Blizzard";
|
||||
mWeatherSettings["blizzard"] = blizzard;
|
||||
}
|
||||
|
||||
void WeatherManager::setWeather(const String& weather, bool instant)
|
||||
{
|
||||
if (instant || mFirstUpdate)
|
||||
{
|
||||
mNextWeather = "";
|
||||
mCurrentWeather = weather;
|
||||
mFirstUpdate = false;
|
||||
}
|
||||
else
|
||||
{
|
||||
if (mNextWeather != "")
|
||||
{
|
||||
// transition more than 50% finished?
|
||||
if (mRemainingTransitionTime/(mWeatherSettings[mCurrentWeather].mTransitionDelta*24.f*60) <= 0.5)
|
||||
mCurrentWeather = mNextWeather;
|
||||
}
|
||||
|
||||
mNextWeather = weather;
|
||||
mRemainingTransitionTime = mWeatherSettings[mCurrentWeather].mTransitionDelta*24.f*60;
|
||||
}
|
||||
}
|
||||
|
||||
WeatherResult WeatherManager::getResult(const String& weather)
|
||||
{
|
||||
const Weather& current = mWeatherSettings[weather];
|
||||
WeatherResult result;
|
||||
|
||||
result.mCloudTexture = current.mCloudTexture;
|
||||
result.mCloudBlendFactor = 0;
|
||||
result.mCloudOpacity = current.mCloudsMaximumPercent;
|
||||
result.mWindSpeed = current.mWindSpeed;
|
||||
result.mCloudSpeed = current.mCloudSpeed;
|
||||
result.mGlareView = current.mGlareView;
|
||||
result.mAmbientLoopSoundID = current.mAmbientLoopSoundID;
|
||||
result.mSunColor = current.mSunDiscSunsetColor;
|
||||
|
||||
const float fade_duration = current.mTransitionDelta * 24.f;
|
||||
|
||||
result.mNight = (mHour < 6.f+fade_duration || mHour > 20.f-fade_duration);
|
||||
|
||||
result.mFogDepth = result.mNight ? current.mLandFogNightDepth : current.mLandFogDayDepth;
|
||||
|
||||
// night
|
||||
if (mHour <= (WeatherGlobals::mSunriseTime-WeatherGlobals::mSunriseDuration)
|
||||
|| mHour >= (WeatherGlobals::mSunsetTime+WeatherGlobals::mSunsetDuration))
|
||||
{
|
||||
result.mFogColor = current.mFogNightColor;
|
||||
result.mAmbientColor = current.mAmbientNightColor;
|
||||
result.mSunColor = current.mSunNightColor;
|
||||
result.mSkyColor = current.mSkyNightColor;
|
||||
result.mNightFade = 1.f;
|
||||
}
|
||||
|
||||
// sunrise
|
||||
else if (mHour >= (WeatherGlobals::mSunriseTime-WeatherGlobals::mSunriseDuration) && mHour <= WeatherGlobals::mSunriseTime)
|
||||
{
|
||||
if (mHour <= (WeatherGlobals::mSunriseTime-WeatherGlobals::mSunriseDuration+fade_duration))
|
||||
{
|
||||
// fade in
|
||||
float advance = (WeatherGlobals::mSunriseTime-WeatherGlobals::mSunriseDuration+fade_duration)-mHour;
|
||||
float factor = (advance / fade_duration);
|
||||
result.mFogColor = lerp(current.mFogSunriseColor, current.mFogNightColor);
|
||||
result.mAmbientColor = lerp(current.mAmbientSunriseColor, current.mAmbientNightColor);
|
||||
result.mSunColor = lerp(current.mSunSunriseColor, current.mSunNightColor);
|
||||
result.mSkyColor = lerp(current.mSkySunriseColor, current.mSkyNightColor);
|
||||
result.mNightFade = factor;
|
||||
}
|
||||
else if (mHour >= (WeatherGlobals::mSunriseTime-fade_duration))
|
||||
{
|
||||
// fade out
|
||||
float advance = mHour-(WeatherGlobals::mSunriseTime-fade_duration);
|
||||
float factor = advance / fade_duration;
|
||||
result.mFogColor = lerp(current.mFogSunriseColor, current.mFogDayColor);
|
||||
result.mAmbientColor = lerp(current.mAmbientSunriseColor, current.mAmbientDayColor);
|
||||
result.mSunColor = lerp(current.mSunSunriseColor, current.mSunDayColor);
|
||||
result.mSkyColor = lerp(current.mSkySunriseColor, current.mSkyDayColor);
|
||||
}
|
||||
else
|
||||
{
|
||||
result.mFogColor = current.mFogSunriseColor;
|
||||
result.mAmbientColor = current.mAmbientSunriseColor;
|
||||
result.mSunColor = current.mSunSunriseColor;
|
||||
result.mSkyColor = current.mSkySunriseColor;
|
||||
}
|
||||
}
|
||||
|
||||
// day
|
||||
else if (mHour >= (WeatherGlobals::mSunriseTime) && mHour <= (WeatherGlobals::mSunsetTime))
|
||||
{
|
||||
result.mFogColor = current.mFogDayColor;
|
||||
result.mAmbientColor = current.mAmbientDayColor;
|
||||
result.mSunColor = current.mSunDayColor;
|
||||
result.mSkyColor = current.mSkyDayColor;
|
||||
}
|
||||
|
||||
// sunset
|
||||
else if (mHour >= (WeatherGlobals::mSunsetTime) && mHour <= (WeatherGlobals::mSunsetTime+WeatherGlobals::mSunsetDuration))
|
||||
{
|
||||
if (mHour <= (WeatherGlobals::mSunsetTime+fade_duration))
|
||||
{
|
||||
// fade in
|
||||
float advance = (WeatherGlobals::mSunsetTime+fade_duration)-mHour;
|
||||
float factor = (advance / fade_duration);
|
||||
result.mFogColor = lerp(current.mFogSunsetColor, current.mFogDayColor);
|
||||
result.mAmbientColor = lerp(current.mAmbientSunsetColor, current.mAmbientDayColor);
|
||||
result.mSunColor = lerp(current.mSunSunsetColor, current.mSunDayColor);
|
||||
result.mSkyColor = lerp(current.mSkySunsetColor, current.mSkyDayColor);
|
||||
}
|
||||
else if (mHour >= (WeatherGlobals::mSunsetTime+WeatherGlobals::mSunsetDuration-fade_duration))
|
||||
{
|
||||
// fade out
|
||||
float advance = mHour-(WeatherGlobals::mSunsetTime+WeatherGlobals::mSunsetDuration-fade_duration);
|
||||
float factor = advance / fade_duration;
|
||||
result.mFogColor = lerp(current.mFogSunsetColor, current.mFogNightColor);
|
||||
result.mAmbientColor = lerp(current.mAmbientSunsetColor, current.mAmbientNightColor);
|
||||
result.mSunColor = lerp(current.mSunSunsetColor, current.mSunNightColor);
|
||||
result.mSkyColor = lerp(current.mSkySunsetColor, current.mSkyNightColor);
|
||||
result.mNightFade = factor;
|
||||
}
|
||||
else
|
||||
{
|
||||
result.mFogColor = current.mFogSunsetColor;
|
||||
result.mAmbientColor = current.mAmbientSunsetColor;
|
||||
result.mSunColor = current.mSunSunsetColor;
|
||||
result.mSkyColor = current.mSkySunsetColor;
|
||||
}
|
||||
}
|
||||
|
||||
return result;
|
||||
}
|
||||
|
||||
WeatherResult WeatherManager::transition(float factor)
|
||||
{
|
||||
const WeatherResult& current = getResult(mCurrentWeather);
|
||||
const WeatherResult& other = getResult(mNextWeather);
|
||||
WeatherResult result;
|
||||
|
||||
result.mCloudTexture = current.mCloudTexture;
|
||||
result.mNextCloudTexture = other.mCloudTexture;
|
||||
result.mCloudBlendFactor = factor;
|
||||
|
||||
result.mCloudOpacity = lerp(current.mCloudOpacity, other.mCloudOpacity);
|
||||
result.mFogColor = lerp(current.mFogColor, other.mFogColor);
|
||||
result.mSunColor = lerp(current.mSunColor, other.mSunColor);
|
||||
result.mSkyColor = lerp(current.mSkyColor, other.mSkyColor);
|
||||
|
||||
result.mAmbientColor = lerp(current.mAmbientColor, other.mAmbientColor);
|
||||
result.mSunDiscColor = lerp(current.mSunDiscColor, other.mSunDiscColor);
|
||||
result.mFogDepth = lerp(current.mFogDepth, other.mFogDepth);
|
||||
result.mWindSpeed = lerp(current.mWindSpeed, other.mWindSpeed);
|
||||
result.mCloudSpeed = lerp(current.mCloudSpeed, other.mCloudSpeed);
|
||||
result.mCloudOpacity = lerp(current.mCloudOpacity, other.mCloudOpacity);
|
||||
result.mGlareView = lerp(current.mGlareView, other.mGlareView);
|
||||
|
||||
result.mNight = current.mNight;
|
||||
|
||||
// sound change behaviour:
|
||||
// if 'other' has a new sound, switch to it after 1/2 of the transition length
|
||||
if (other.mAmbientLoopSoundID != "")
|
||||
result.mAmbientLoopSoundID = factor>0.5 ? other.mAmbientLoopSoundID : current.mAmbientLoopSoundID;
|
||||
// if 'current' has a sound and 'other' does not have a sound, turn off the sound immediately
|
||||
else if (current.mAmbientLoopSoundID != "")
|
||||
result.mAmbientLoopSoundID = "";
|
||||
|
||||
return result;
|
||||
}
|
||||
|
||||
void WeatherManager::update(float duration)
|
||||
{
|
||||
mWeatherUpdateTime -= duration;
|
||||
if (mEnvironment->mWorld->isCellExterior() || mEnvironment->mWorld->isCellQuasiExterior())
|
||||
{
|
||||
std::string regionstr = mEnvironment->mWorld->getPlayer().getPlayer().getCell()->cell->region;
|
||||
boost::algorithm::to_lower(regionstr);
|
||||
|
||||
if (mWeatherUpdateTime <= 0 || regionstr != mCurrentRegion)
|
||||
{
|
||||
mCurrentRegion = regionstr;
|
||||
mWeatherUpdateTime = WeatherGlobals::mWeatherUpdateTime*60.f;
|
||||
|
||||
std::string weather;
|
||||
|
||||
if (mRegionOverrides.find(regionstr) != mRegionOverrides.end())
|
||||
weather = mRegionOverrides[regionstr];
|
||||
else
|
||||
{
|
||||
// get weather probabilities for the current region
|
||||
const ESM::Region *region = mEnvironment->mWorld->getStore().regions.find (regionstr);
|
||||
|
||||
float clear = region->data.clear/255.f;
|
||||
float cloudy = region->data.cloudy/255.f;
|
||||
float foggy = region->data.foggy/255.f;
|
||||
float overcast = region->data.overcast/255.f;
|
||||
float rain = region->data.rain/255.f;
|
||||
float thunder = region->data.thunder/255.f;
|
||||
float ash = region->data.ash/255.f;
|
||||
float blight = region->data.blight/255.f;
|
||||
float snow = region->data.a/255.f;
|
||||
float blizzard = region->data.b/255.f;
|
||||
|
||||
// re-scale to 100 percent
|
||||
const float total = clear+cloudy+foggy+overcast+rain+thunder+ash+blight+snow+blizzard;
|
||||
|
||||
srand(time(NULL));
|
||||
float random = ((rand()%100)/100.f) * total;
|
||||
|
||||
if (random >= snow+blight+ash+thunder+rain+overcast+foggy+cloudy+clear)
|
||||
weather = "blizzard";
|
||||
else if (random >= blight+ash+thunder+rain+overcast+foggy+cloudy+clear)
|
||||
weather = "snow";
|
||||
else if (random >= ash+thunder+rain+overcast+foggy+cloudy+clear)
|
||||
weather = "blight";
|
||||
else if (random >= thunder+rain+overcast+foggy+cloudy+clear)
|
||||
weather = "ashstorm";
|
||||
else if (random >= rain+overcast+foggy+cloudy+clear)
|
||||
weather = "thunderstorm";
|
||||
else if (random >= overcast+foggy+cloudy+clear)
|
||||
weather = "rain";
|
||||
else if (random >= foggy+cloudy+clear)
|
||||
weather = "overcast";
|
||||
else if (random >= cloudy+clear)
|
||||
weather = "foggy";
|
||||
else if (random >= clear)
|
||||
weather = "cloudy";
|
||||
else
|
||||
weather = "clear";
|
||||
}
|
||||
|
||||
setWeather(weather, false);
|
||||
/*
|
||||
std::cout << "roll result: " << random << std::endl;
|
||||
|
||||
std::cout << regionstr << " weather probabilities: " << clear << " " << cloudy << " " << foggy << " "
|
||||
<< overcast << " " << rain << " " << thunder << " " << ash << " " << blight << " " << snow << " "
|
||||
<< blizzard << std::endl;
|
||||
|
||||
std::cout << "New weather : " << weather << std::endl;
|
||||
*/
|
||||
}
|
||||
|
||||
WeatherResult result;
|
||||
|
||||
if (mNextWeather != "")
|
||||
{
|
||||
mRemainingTransitionTime -= duration;
|
||||
if (mRemainingTransitionTime < 0)
|
||||
{
|
||||
mCurrentWeather = mNextWeather;
|
||||
mNextWeather = "";
|
||||
}
|
||||
}
|
||||
|
||||
if (mNextWeather != "")
|
||||
result = transition(1-(mRemainingTransitionTime/(mWeatherSettings[mCurrentWeather].mTransitionDelta*24.f*60)));
|
||||
else
|
||||
result = getResult(mCurrentWeather);
|
||||
|
||||
mRendering->configureFog(result.mFogDepth, result.mFogColor);
|
||||
|
||||
// disable sun during night
|
||||
if (mHour >= WeatherGlobals::mSunsetTime+WeatherGlobals::mSunsetDuration
|
||||
|| mHour <= WeatherGlobals::mSunriseTime-WeatherGlobals::mSunriseDuration)
|
||||
mRendering->getSkyManager()->sunDisable();
|
||||
else
|
||||
{
|
||||
// during day, calculate sun angle
|
||||
float height = 1-std::abs(((mHour-13)/7.f));
|
||||
int facing = mHour > 13.f ? 1 : -1;
|
||||
Vector3 final(
|
||||
(1-height)*facing,
|
||||
(1-height)*facing,
|
||||
height);
|
||||
mRendering->setSunDirection(final);
|
||||
|
||||
mRendering->getSkyManager()->sunEnable();
|
||||
}
|
||||
|
||||
// moon calculations
|
||||
float night;
|
||||
if (mHour >= 14)
|
||||
night = mHour-14;
|
||||
else if (mHour <= 10)
|
||||
night = mHour+10;
|
||||
else
|
||||
night = 0;
|
||||
|
||||
night /= 20.f;
|
||||
|
||||
if (night != 0)
|
||||
{
|
||||
float moonHeight = 1-std::abs((night-0.5)*2);
|
||||
int facing = (mHour > 0.f && mHour<12.f) ? 1 : -1;
|
||||
Vector3 masser(
|
||||
(1-moonHeight)*facing,
|
||||
(1-moonHeight)*facing,
|
||||
moonHeight);
|
||||
|
||||
Vector3 secunda(
|
||||
(1-moonHeight)*facing*0.8,
|
||||
(1-moonHeight)*facing*1.25,
|
||||
moonHeight);
|
||||
|
||||
mRendering->getSkyManager()->setMasserDirection(masser);
|
||||
mRendering->getSkyManager()->setSecundaDirection(secunda);
|
||||
mRendering->getSkyManager()->masserEnable();
|
||||
mRendering->getSkyManager()->secundaEnable();
|
||||
|
||||
float hour_fade;
|
||||
if (mHour >= 7.f && mHour <= 14.f)
|
||||
hour_fade = 1-(mHour-7)/3.f;
|
||||
else if (mHour >= 14 && mHour <= 15.f)
|
||||
hour_fade = mHour-14;
|
||||
else
|
||||
hour_fade = 1;
|
||||
|
||||
float secunda_angle_fade;
|
||||
float masser_angle_fade;
|
||||
float angle = moonHeight*90.f;
|
||||
|
||||
if (angle >= 30 && angle <= 50)
|
||||
secunda_angle_fade = (angle-30)/20.f;
|
||||
else if (angle <30)
|
||||
secunda_angle_fade = 0.f;
|
||||
else
|
||||
secunda_angle_fade = 1.f;
|
||||
|
||||
if (angle >= 40 && angle <= 50)
|
||||
masser_angle_fade = (angle-40)/10.f;
|
||||
else if (angle <40)
|
||||
masser_angle_fade = 0.f;
|
||||
else
|
||||
masser_angle_fade = 1.f;
|
||||
|
||||
masser_angle_fade *= hour_fade;
|
||||
secunda_angle_fade *= hour_fade;
|
||||
|
||||
mRendering->getSkyManager()->setMasserFade(masser_angle_fade);
|
||||
mRendering->getSkyManager()->setSecundaFade(secunda_angle_fade);
|
||||
}
|
||||
else
|
||||
{
|
||||
mRendering->getSkyManager()->masserDisable();
|
||||
mRendering->getSkyManager()->secundaDisable();
|
||||
}
|
||||
|
||||
if (mCurrentWeather == "thunderstorm" && mNextWeather == "")
|
||||
{
|
||||
if (mThunderFlash > 0)
|
||||
{
|
||||
// play the sound after a delay
|
||||
mThunderSoundDelay -= duration;
|
||||
if (mThunderSoundDelay <= 0)
|
||||
{
|
||||
// pick a random sound
|
||||
int sound = rand() % 4;
|
||||
std::string soundname;
|
||||
if (sound == 0) soundname = WeatherGlobals::mThunderSoundID0;
|
||||
else if (sound == 1) soundname = WeatherGlobals::mThunderSoundID1;
|
||||
else if (sound == 2) soundname = WeatherGlobals::mThunderSoundID2;
|
||||
else if (sound == 3) soundname = WeatherGlobals::mThunderSoundID3;
|
||||
mEnvironment->mSoundManager->playSound(soundname, 1.0, 1.0);
|
||||
mThunderSoundDelay = 1000;
|
||||
}
|
||||
|
||||
mThunderFlash -= duration;
|
||||
if (mThunderFlash > 0)
|
||||
mRendering->getSkyManager()->setThunder( mThunderFlash / WeatherGlobals::mThunderThreshold );
|
||||
else
|
||||
{
|
||||
srand(time(NULL));
|
||||
mThunderChanceNeeded = rand() % 100;
|
||||
mThunderChance = 0;
|
||||
mRendering->getSkyManager()->setThunder( 0.f );
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
// no thunder active
|
||||
mThunderChance += duration*4; // chance increases by 4 percent every second
|
||||
if (mThunderChance >= mThunderChanceNeeded)
|
||||
{
|
||||
mThunderFlash = WeatherGlobals::mThunderThreshold;
|
||||
|
||||
mRendering->getSkyManager()->setThunder( mThunderFlash / WeatherGlobals::mThunderThreshold );
|
||||
|
||||
mThunderSoundDelay = WeatherGlobals::mThunderSoundDelay;
|
||||
}
|
||||
}
|
||||
}
|
||||
else
|
||||
mRendering->getSkyManager()->setThunder(0.f);
|
||||
|
||||
mRendering->setAmbientColour(result.mAmbientColor);
|
||||
mRendering->sunEnable();
|
||||
mRendering->setSunColour(result.mSunColor);
|
||||
|
||||
mRendering->getSkyManager()->setWeather(result);
|
||||
}
|
||||
else
|
||||
{
|
||||
mRendering->sunDisable();
|
||||
mRendering->skyDisable();
|
||||
mRendering->getSkyManager()->setThunder(0.f);
|
||||
}
|
||||
}
|
||||
|
||||
void WeatherManager::setHour(const float hour)
|
||||
{
|
||||
// accelerate a bit for testing
|
||||
/*
|
||||
mHour += 0.005;
|
||||
|
||||
if (mHour >= 24.f) mHour = 0.f;
|
||||
|
||||
std::cout << "hour " << mHour << std::endl;
|
||||
*/
|
||||
|
||||
mHour = hour;
|
||||
}
|
||||
|
||||
void WeatherManager::setDate(const int day, const int month)
|
||||
{
|
||||
mDay = day;
|
||||
mMonth = month;
|
||||
}
|
||||
|
||||
unsigned int WeatherManager::getWeatherID() const
|
||||
{
|
||||
// Source: http://www.uesp.net/wiki/Tes3Mod:GetCurrentWeather
|
||||
|
||||
if (mCurrentWeather == "clear")
|
||||
return 0;
|
||||
else if (mCurrentWeather == "cloudy")
|
||||
return 1;
|
||||
else if (mCurrentWeather == "foggy")
|
||||
return 2;
|
||||
else if (mCurrentWeather == "overcast")
|
||||
return 3;
|
||||
else if (mCurrentWeather == "rain")
|
||||
return 4;
|
||||
else if (mCurrentWeather == "thunder")
|
||||
return 5;
|
||||
else if (mCurrentWeather == "ashstorm")
|
||||
return 6;
|
||||
else if (mCurrentWeather == "blight")
|
||||
return 7;
|
||||
else if (mCurrentWeather == "snow")
|
||||
return 8;
|
||||
else if (mCurrentWeather == "blizzard")
|
||||
return 9;
|
||||
|
||||
else
|
||||
return 0;
|
||||
}
|
||||
|
||||
void WeatherManager::changeWeather(const std::string& region, const unsigned int id)
|
||||
{
|
||||
std::string weather;
|
||||
if (id==0)
|
||||
weather = "clear";
|
||||
else if (id==1)
|
||||
weather = "cloudy";
|
||||
else if (id==2)
|
||||
weather = "foggy";
|
||||
else if (id==3)
|
||||
weather = "overcast";
|
||||
else if (id==4)
|
||||
weather = "rain";
|
||||
else if (id==5)
|
||||
weather = "thunder";
|
||||
else if (id==6)
|
||||
weather = "ashstorm";
|
||||
else if (id==7)
|
||||
weather = "blight";
|
||||
else if (id==8)
|
||||
weather = "snow";
|
||||
else if (id==9)
|
||||
weather = "blizzard";
|
||||
else
|
||||
weather = "clear";
|
||||
|
||||
mRegionOverrides[region] = weather;
|
||||
}
|
||||
@ -0,0 +1,272 @@
|
||||
#ifndef GAME_MWWORLD_WEATHER_H
|
||||
#define GAME_MWWORLD_WEATHER_H
|
||||
|
||||
#include <OgreString.h>
|
||||
#include <OgreColourValue.h>
|
||||
|
||||
namespace MWRender
|
||||
{
|
||||
class RenderingManager;
|
||||
}
|
||||
|
||||
namespace MWWorld
|
||||
{
|
||||
class Environment;
|
||||
|
||||
/// Global weather manager properties (according to INI)
|
||||
struct WeatherGlobals
|
||||
{
|
||||
/*
|
||||
[Weather]
|
||||
EnvReduceColor=255,255,255,255
|
||||
LerpCloseColor=037,046,048,255
|
||||
BumpFadeColor=230,239,255,255
|
||||
AlphaReduce=0.35
|
||||
Minimum Time Between Environmental Sounds=1.0
|
||||
Maximum Time Between Environmental Sounds=5.0
|
||||
Sun Glare Fader Max=0.5
|
||||
Sun Glare Fader Angle Max=30.0
|
||||
Sun Glare Fader Color=222,095,039
|
||||
Timescale Clouds=0
|
||||
Precip Gravity=575
|
||||
Hours Between Weather Changes=20
|
||||
Rain Ripples=1
|
||||
Rain Ripple Radius=1024
|
||||
Rain Ripples Per Drop=1
|
||||
Rain Ripple Scale=0.3
|
||||
Rain Ripple Speed=1.0
|
||||
Fog Depth Change Speed=3
|
||||
Sunrise Time=6
|
||||
Sunset Time=18
|
||||
Sunrise Duration=2
|
||||
Sunset Duration=2
|
||||
Sky Pre-Sunrise Time=.5
|
||||
Sky Post-Sunrise Time=1
|
||||
Sky Pre-Sunset Time=1.5
|
||||
Sky Post-Sunset Time=.5
|
||||
Ambient Pre-Sunrise Time=.5
|
||||
Ambient Post-Sunrise Time=2
|
||||
Ambient Pre-Sunset Time=1
|
||||
Ambient Post-Sunset Time=1.25
|
||||
Fog Pre-Sunrise Time=.5
|
||||
Fog Post-Sunrise Time=1
|
||||
Fog Pre-Sunset Time=2
|
||||
Fog Post-Sunset Time=1
|
||||
Sun Pre-Sunrise Time=0
|
||||
Sun Post-Sunrise Time=0
|
||||
Sun Pre-Sunset Time=1
|
||||
Sun Post-Sunset Time=1.25
|
||||
Stars Post-Sunset Start=1
|
||||
Stars Pre-Sunrise Finish=2
|
||||
Stars Fading Duration=2
|
||||
Snow Ripples=0
|
||||
Snow Ripple Radius=1024
|
||||
Snow Ripples Per Flake=1
|
||||
Snow Ripple Scale=0.3
|
||||
Snow Ripple Speed=1.0
|
||||
Snow Gravity Scale=0.1
|
||||
Snow High Kill=700
|
||||
Snow Low Kill=150
|
||||
|
||||
|
||||
[Moons]
|
||||
Masser Size=94
|
||||
Masser Fade In Start=14
|
||||
Masser Fade In Finish=15
|
||||
Masser Fade Out Start=7
|
||||
Masser Fade Out Finish=10
|
||||
Masser Axis Offset=35
|
||||
Masser Speed=.5
|
||||
Masser Daily Increment=1
|
||||
Masser Fade Start Angle=50
|
||||
Masser Fade End Angle=40
|
||||
Masser Moon Shadow Early Fade Angle=0.5
|
||||
Secunda Size=40
|
||||
Secunda Fade In Start=14
|
||||
Secunda Fade In Finish=15
|
||||
Secunda Fade Out Start=7
|
||||
Secunda Fade Out Finish=10
|
||||
Secunda Axis Offset=50
|
||||
Secunda Speed=.6
|
||||
Secunda Daily Increment=1.2
|
||||
Secunda Fade Start Angle=50
|
||||
Secunda Fade End Angle=30
|
||||
Secunda Moon Shadow Early Fade Angle=0.5
|
||||
Script Color=255,20,20
|
||||
*/
|
||||
|
||||
static const float mSunriseTime = 8;
|
||||
static const float mSunsetTime = 18;
|
||||
static const float mSunriseDuration = 2;
|
||||
static const float mSunsetDuration = 2;
|
||||
|
||||
static const float mWeatherUpdateTime = 20.f;
|
||||
|
||||
// morrowind sets these per-weather, but since they are only used by 'thunderstorm'
|
||||
// weather setting anyway, we can just as well set them globally
|
||||
static const float mThunderFrequency = .4;
|
||||
static const float mThunderThreshold = 0.6;
|
||||
static const float mThunderSoundDelay = 0.25;
|
||||
static const std::string mThunderSoundID0;
|
||||
static const std::string mThunderSoundID1;
|
||||
static const std::string mThunderSoundID2;
|
||||
static const std::string mThunderSoundID3;
|
||||
};
|
||||
|
||||
/// Defines the actual weather that results from weather setting (see below), time of day and weather transition
|
||||
struct WeatherResult
|
||||
{
|
||||
Ogre::String mCloudTexture;
|
||||
Ogre::String mNextCloudTexture;
|
||||
float mCloudBlendFactor;
|
||||
|
||||
Ogre::ColourValue mFogColor;
|
||||
|
||||
Ogre::ColourValue mAmbientColor;
|
||||
|
||||
Ogre::ColourValue mSkyColor;
|
||||
|
||||
Ogre::ColourValue mSunColor;
|
||||
|
||||
Ogre::ColourValue mSunDiscColor;
|
||||
|
||||
float mFogDepth;
|
||||
|
||||
float mWindSpeed;
|
||||
|
||||
float mCloudSpeed;
|
||||
|
||||
float mCloudOpacity;
|
||||
|
||||
float mGlareView;
|
||||
|
||||
bool mNight; // use night skybox
|
||||
float mNightFade; // fading factor for night skybox
|
||||
|
||||
Ogre::String mAmbientLoopSoundID;
|
||||
};
|
||||
|
||||
|
||||
/// Defines a single weather setting (according to INI)
|
||||
struct Weather
|
||||
{
|
||||
Ogre::String mCloudTexture;
|
||||
|
||||
// Sky (atmosphere) colors
|
||||
Ogre::ColourValue mSkySunriseColor,
|
||||
mSkyDayColor,
|
||||
mSkySunsetColor,
|
||||
mSkyNightColor;
|
||||
|
||||
// Fog colors
|
||||
Ogre::ColourValue mFogSunriseColor,
|
||||
mFogDayColor,
|
||||
mFogSunsetColor,
|
||||
mFogNightColor;
|
||||
|
||||
// Ambient lighting colors
|
||||
Ogre::ColourValue mAmbientSunriseColor,
|
||||
mAmbientDayColor,
|
||||
mAmbientSunsetColor,
|
||||
mAmbientNightColor;
|
||||
|
||||
// Sun (directional) lighting colors
|
||||
Ogre::ColourValue mSunSunriseColor,
|
||||
mSunDayColor,
|
||||
mSunSunsetColor,
|
||||
mSunNightColor;
|
||||
|
||||
// Fog depth/density
|
||||
float mLandFogDayDepth,
|
||||
mLandFogNightDepth;
|
||||
|
||||
// Color modulation for the sun itself during sunset (not completely sure)
|
||||
Ogre::ColourValue mSunDiscSunsetColor;
|
||||
|
||||
// Duration of weather transition (in days)
|
||||
float mTransitionDelta;
|
||||
|
||||
// No idea what this one is used for?
|
||||
float mWindSpeed;
|
||||
|
||||
// Cloud animation speed multiplier
|
||||
float mCloudSpeed;
|
||||
|
||||
// Multiplier for clouds transparency
|
||||
float mCloudsMaximumPercent;
|
||||
|
||||
// Value between 0 and 1, defines the strength of the sun glare effect
|
||||
float mGlareView;
|
||||
|
||||
// Sound effect
|
||||
// This is used for Blight, Ashstorm and Blizzard (Bloodmoon)
|
||||
Ogre::String mAmbientLoopSoundID;
|
||||
|
||||
// Rain sound effect
|
||||
Ogre::String mRainLoopSoundID;
|
||||
|
||||
/// \todo disease chance
|
||||
};
|
||||
|
||||
///
|
||||
/// Interface for weather settings
|
||||
///
|
||||
class WeatherManager
|
||||
{
|
||||
public:
|
||||
WeatherManager(MWRender::RenderingManager*, MWWorld::Environment*);
|
||||
|
||||
/**
|
||||
* Change the weather in the specified region
|
||||
* @param region that should be changed
|
||||
* @param ID of the weather setting to shift to
|
||||
*/
|
||||
void changeWeather(const std::string& region, const unsigned int id);
|
||||
|
||||
/**
|
||||
* Per-frame update
|
||||
* @param duration
|
||||
*/
|
||||
void update(float duration);
|
||||
|
||||
void setHour(const float hour);
|
||||
|
||||
void setDate(const int day, const int month);
|
||||
|
||||
unsigned int getWeatherID() const;
|
||||
|
||||
private:
|
||||
float mHour;
|
||||
int mDay, mMonth;
|
||||
|
||||
MWRender::RenderingManager* mRendering;
|
||||
MWWorld::Environment* mEnvironment;
|
||||
|
||||
std::map<Ogre::String, Weather> mWeatherSettings;
|
||||
|
||||
std::map<std::string, std::string> mRegionOverrides;
|
||||
|
||||
Ogre::String mCurrentWeather;
|
||||
Ogre::String mNextWeather;
|
||||
|
||||
std::string mCurrentRegion;
|
||||
|
||||
bool mFirstUpdate;
|
||||
|
||||
float mWeatherUpdateTime;
|
||||
|
||||
float mRemainingTransitionTime;
|
||||
|
||||
float mThunderFlash;
|
||||
float mThunderChance;
|
||||
float mThunderChanceNeeded;
|
||||
float mThunderSoundDelay;
|
||||
|
||||
WeatherResult transition(const float factor);
|
||||
WeatherResult getResult(const Ogre::String& weather);
|
||||
|
||||
void setWeather(const Ogre::String& weather, bool instant=false);
|
||||
};
|
||||
}
|
||||
|
||||
#endif // GAME_MWWORLD_WEATHER_H
|
||||
@ -1,66 +0,0 @@
|
||||
project(Caelum)
|
||||
|
||||
IF(MSVC)
|
||||
add_definitions("-D_SCL_SECURE_NO_WARNINGS /wd4305 /wd4244" )
|
||||
ENDIF(MSVC)
|
||||
|
||||
ADD_DEFINITIONS(-DCAELUM_STATIC)
|
||||
INCLUDE_DIRECTORIES(
|
||||
${CMAKE_HOME_DIRECTORY}/extern/caelum/include
|
||||
${OGRE_INCLUDE_DIR}/Ogre
|
||||
)
|
||||
|
||||
file(GLOB_RECURSE CAELUM_SRC src/*)
|
||||
file(GLOB_RECURSE CAELUM_HDR include/*)
|
||||
|
||||
set(SOURCES ${CAELUM_SRC} ${CAELUM_HDR})
|
||||
add_library(caelum STATIC ${SOURCES})
|
||||
|
||||
#
|
||||
# Resources
|
||||
#
|
||||
SET(CAELUM_RES_DEST "${OpenMW_BINARY_DIR}")
|
||||
|
||||
configure_file(${CMAKE_CURRENT_SOURCE_DIR}/resources/AtmosphereDepth.png "${CAELUM_RES_DEST}/resources/caelum/AtmosphereDepth.png" COPYONLY)
|
||||
configure_file(${CMAKE_CURRENT_SOURCE_DIR}/resources/CaelumGroundFog.cg "${CAELUM_RES_DEST}/resources/caelum/CaelumGroundFog.cg" COPYONLY)
|
||||
configure_file(${CMAKE_CURRENT_SOURCE_DIR}/resources/CaelumLayeredClouds.cg "${CAELUM_RES_DEST}/resources/caelum/CaelumLayeredClouds.cg" COPYONLY)
|
||||
configure_file(${CMAKE_CURRENT_SOURCE_DIR}/resources/CaelumPhaseMoon.cg "${CAELUM_RES_DEST}/resources/caelum/CaelumPhaseMoon.cg" COPYONLY)
|
||||
configure_file(${CMAKE_CURRENT_SOURCE_DIR}/resources/CaelumPointStarfield.cg "${CAELUM_RES_DEST}/resources/caelum/CaelumPointStarfield.cg" COPYONLY)
|
||||
configure_file(${CMAKE_CURRENT_SOURCE_DIR}/resources/CaelumSkyDome.cg "${CAELUM_RES_DEST}/resources/caelum/CaelumSkyDome.cg" COPYONLY)
|
||||
configure_file(${CMAKE_CURRENT_SOURCE_DIR}/resources/CloudCoverLookup.png "${CAELUM_RES_DEST}/resources/caelum/CloudCoverLookup.png" COPYONLY)
|
||||
configure_file(${CMAKE_CURRENT_SOURCE_DIR}/resources/DepthComposer.cg "${CAELUM_RES_DEST}/resources/caelum/DepthComposer.cg" COPYONLY)
|
||||
configure_file(${CMAKE_CURRENT_SOURCE_DIR}/resources/DepthComposer.compositor "${CAELUM_RES_DEST}/resources/caelum/DepthComposer.compositor" COPYONLY)
|
||||
configure_file(${CMAKE_CURRENT_SOURCE_DIR}/resources/DepthComposer.material "${CAELUM_RES_DEST}/resources/caelum/DepthComposer.material" COPYONLY)
|
||||
configure_file(${CMAKE_CURRENT_SOURCE_DIR}/resources/DepthRender.program "${CAELUM_RES_DEST}/resources/caelum/DepthRender.program" COPYONLY)
|
||||
configure_file(${CMAKE_CURRENT_SOURCE_DIR}/resources/EarthClearSky2.png "${CAELUM_RES_DEST}/resources/caelum/EarthClearSky2.png" COPYONLY)
|
||||
configure_file(${CMAKE_CURRENT_SOURCE_DIR}/resources/GroundFog.material "${CAELUM_RES_DEST}/resources/caelum/GroundFog.material" COPYONLY)
|
||||
configure_file(${CMAKE_CURRENT_SOURCE_DIR}/resources/GroundFog.program "${CAELUM_RES_DEST}/resources/caelum/GroundFog.program" COPYONLY)
|
||||
configure_file(${CMAKE_CURRENT_SOURCE_DIR}/resources/Haze.program "${CAELUM_RES_DEST}/resources/caelum/Haze.program" COPYONLY)
|
||||
configure_file(${CMAKE_CURRENT_SOURCE_DIR}/resources/LayeredClouds.material "${CAELUM_RES_DEST}/resources/caelum/LayeredClouds.material" COPYONLY)
|
||||
configure_file(${CMAKE_CURRENT_SOURCE_DIR}/resources/MinimalCompositorVP.cg "${CAELUM_RES_DEST}/resources/caelum/MinimalCompositorVP.cg" COPYONLY)
|
||||
configure_file(${CMAKE_CURRENT_SOURCE_DIR}/resources/MinimalCompositorVP.program "${CAELUM_RES_DEST}/resources/caelum/MinimalCompositorVP.program" COPYONLY)
|
||||
configure_file(${CMAKE_CURRENT_SOURCE_DIR}/resources/moon.material "${CAELUM_RES_DEST}/resources/caelum/moon.material" COPYONLY)
|
||||
configure_file(${CMAKE_CURRENT_SOURCE_DIR}/resources/moon_disc.dds "${CAELUM_RES_DEST}/resources/caelum/moon_disc.dds" COPYONLY)
|
||||
configure_file(${CMAKE_CURRENT_SOURCE_DIR}/resources/noise1.dds "${CAELUM_RES_DEST}/resources/caelum/noise1.dds" COPYONLY)
|
||||
configure_file(${CMAKE_CURRENT_SOURCE_DIR}/resources/noise2.dds "${CAELUM_RES_DEST}/resources/caelum/noise2.dds" COPYONLY)
|
||||
configure_file(${CMAKE_CURRENT_SOURCE_DIR}/resources/noise3.dds "${CAELUM_RES_DEST}/resources/caelum/noise3.dds" COPYONLY)
|
||||
configure_file(${CMAKE_CURRENT_SOURCE_DIR}/resources/noise4.dds "${CAELUM_RES_DEST}/resources/caelum/noise4.dds" COPYONLY)
|
||||
configure_file(${CMAKE_CURRENT_SOURCE_DIR}/resources/PointStarfield.material "${CAELUM_RES_DEST}/resources/caelum/PointStarfield.material" COPYONLY)
|
||||
configure_file(${CMAKE_CURRENT_SOURCE_DIR}/resources/Precipitation.cg "${CAELUM_RES_DEST}/resources/caelum/Precipitation.cg" COPYONLY)
|
||||
configure_file(${CMAKE_CURRENT_SOURCE_DIR}/resources/Precipitation.compositor "${CAELUM_RES_DEST}/resources/caelum/Precipitation.compositor" COPYONLY)
|
||||
configure_file(${CMAKE_CURRENT_SOURCE_DIR}/resources/Precipitation.material "${CAELUM_RES_DEST}/resources/caelum/Precipitation.material" COPYONLY)
|
||||
configure_file(${CMAKE_CURRENT_SOURCE_DIR}/resources/precipitation_drizzle.png "${CAELUM_RES_DEST}/resources/caelum/precipitation_drizzle.png" COPYONLY)
|
||||
configure_file(${CMAKE_CURRENT_SOURCE_DIR}/resources/precipitation_hail.png "${CAELUM_RES_DEST}/resources/caelum/precipitation_hail.png" COPYONLY)
|
||||
configure_file(${CMAKE_CURRENT_SOURCE_DIR}/resources/precipitation_icecrystals.png "${CAELUM_RES_DEST}/resources/caelum/precipitation_icecrystals.png" COPYONLY)
|
||||
configure_file(${CMAKE_CURRENT_SOURCE_DIR}/resources/precipitation_icepellets.png "${CAELUM_RES_DEST}/resources/caelum/precipitation_icepellets.png" COPYONLY)
|
||||
configure_file(${CMAKE_CURRENT_SOURCE_DIR}/resources/precipitation_rain.png "${CAELUM_RES_DEST}/resources/caelum/precipitation_rain.png" COPYONLY)
|
||||
configure_file(${CMAKE_CURRENT_SOURCE_DIR}/resources/precipitation_smallhail.png "${CAELUM_RES_DEST}/resources/caelum/precipitation_smallhail.png" COPYONLY)
|
||||
configure_file(${CMAKE_CURRENT_SOURCE_DIR}/resources/precipitation_snow.png "${CAELUM_RES_DEST}/resources/caelum/precipitation_snow.png" COPYONLY)
|
||||
configure_file(${CMAKE_CURRENT_SOURCE_DIR}/resources/precipitation_snowgrains.png "${CAELUM_RES_DEST}/resources/caelum/precipitation_snowgrains.png" COPYONLY)
|
||||
configure_file(${CMAKE_CURRENT_SOURCE_DIR}/resources/SkyDome.material "${CAELUM_RES_DEST}/resources/caelum/SkyDome.material" COPYONLY)
|
||||
configure_file(${CMAKE_CURRENT_SOURCE_DIR}/resources/sphere.mesh "${CAELUM_RES_DEST}/resources/caelum/sphere.mesh" COPYONLY)
|
||||
configure_file(${CMAKE_CURRENT_SOURCE_DIR}/resources/Starfield.jpg "${CAELUM_RES_DEST}/resources/caelum/Starfield.jpg" COPYONLY)
|
||||
configure_file(${CMAKE_CURRENT_SOURCE_DIR}/resources/Starfield.material "${CAELUM_RES_DEST}/resources/caelum/Starfield.material" COPYONLY)
|
||||
configure_file(${CMAKE_CURRENT_SOURCE_DIR}/resources/Sun.material "${CAELUM_RES_DEST}/resources/caelum/Sun.material" COPYONLY)
|
||||
configure_file(${CMAKE_CURRENT_SOURCE_DIR}/resources/SunGradient.png "${CAELUM_RES_DEST}/resources/caelum/SunGradient.png" COPYONLY)
|
||||
configure_file(${CMAKE_CURRENT_SOURCE_DIR}/resources/sun_disc.png "${CAELUM_RES_DEST}/resources/caelum/sun_disc.png" COPYONLY)
|
||||
@ -1,228 +0,0 @@
|
||||
/*
|
||||
This file is part of Caelum.
|
||||
See http://www.ogre3d.org/wiki/index.php/Caelum
|
||||
|
||||
Copyright (c) 2008 Caelum team. See Contributors.txt for details.
|
||||
|
||||
Caelum is free software: you can redistribute it and/or modify
|
||||
it under the terms of the GNU Lesser General Public License as published
|
||||
by the Free Software Foundation, either version 3 of the License, or
|
||||
(at your option) any later version.
|
||||
|
||||
Caelum is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
GNU Lesser General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU Lesser General Public License
|
||||
along with Caelum. If not, see <http://www.gnu.org/licenses/>.
|
||||
*/
|
||||
|
||||
#ifndef CAELUM__ASTRONOMY_H
|
||||
#define CAELUM__ASTRONOMY_H
|
||||
|
||||
#include "CaelumPrerequisites.h"
|
||||
|
||||
namespace Caelum
|
||||
{
|
||||
/** Static class with astronomy routines.
|
||||
* This class contains various astronomical routines useful in Caelum.
|
||||
*
|
||||
* Most of the formulas are from http://stjarnhimlen.se/comp/ppcomp.html
|
||||
* That site contains much more than was implemented here; it has code
|
||||
* for determining the positions of all the planets. Only the sun and
|
||||
* moon are actually useful for caelum.
|
||||
*
|
||||
* The formulas are isolated here in pure procedural code for easier
|
||||
* testing (Tests are done as assertions in the demo).
|
||||
*
|
||||
* Precision is vital here, so this class uses Caelum::LongReal(double)
|
||||
* instead of Ogre::Real(float) for precission. All angles are in degrees
|
||||
* unless otherwise mentioned. Ogre::Degree and Ogre::Radian use
|
||||
* Ogre::Real and should be avoided here.
|
||||
*/
|
||||
class CAELUM_EXPORT Astronomy
|
||||
{
|
||||
private:
|
||||
Astronomy() {}
|
||||
|
||||
static const LongReal PI;
|
||||
|
||||
/** Normalize an angle to the 0, 360 range.
|
||||
* @param x The angle to normalize
|
||||
*/
|
||||
static LongReal normalizeDegrees (LongReal x);
|
||||
|
||||
/// Convert radians to degrees.
|
||||
static LongReal radToDeg (LongReal x);
|
||||
|
||||
/// Convert degrees to radians.
|
||||
static LongReal degToRad (LongReal x);
|
||||
|
||||
static LongReal sinDeg (LongReal x);
|
||||
static LongReal cosDeg (LongReal x);
|
||||
static LongReal atan2Deg (LongReal y, LongReal x);
|
||||
|
||||
public:
|
||||
/// January 1, 2000, noon
|
||||
static const LongReal J2000;
|
||||
|
||||
/** Convert from ecliptic to ecuatorial spherical coordinates, in radians.
|
||||
* @param lon Ecliptic longitude
|
||||
* @param lat Ecliptic latitude
|
||||
* @param rasc Right ascension
|
||||
* @param decl Declination
|
||||
* @warning: This function works in radians.
|
||||
*/
|
||||
static void convertEclipticToEquatorialRad (
|
||||
LongReal lon, LongReal lat,
|
||||
LongReal& rasc, LongReal& decl);
|
||||
|
||||
static void convertRectangularToSpherical (
|
||||
LongReal x, LongReal y, LongReal z,
|
||||
LongReal &rasc, LongReal &decl, LongReal &dist);
|
||||
|
||||
static void convertSphericalToRectangular (
|
||||
LongReal rasc, LongReal decl, LongReal dist,
|
||||
LongReal &x, LongReal &y, LongReal &z);
|
||||
|
||||
/** Convert from equatorial to horizontal coordinates.
|
||||
* This function converts from angles relative to the earth's equator
|
||||
* to angle relative to the horizon at a given point.
|
||||
* @param jday Astronomical time as julian day.
|
||||
* @param longitude Observer's longitude in degrees east.
|
||||
* @param latitude Observer's latitude in degrees north.
|
||||
* @param rasc Object's right ascension.
|
||||
* @param decl Object's declination.
|
||||
* @param azimuth Object's azimuth (clockwise degrees from true north).
|
||||
* @param altitude Object's altitude (degrees above the horizon).
|
||||
*/
|
||||
static void convertEquatorialToHorizontal (
|
||||
LongReal jday,
|
||||
LongReal longitude, LongReal latitude,
|
||||
LongReal rasc, LongReal decl,
|
||||
LongReal &azimuth, LongReal &altitude);
|
||||
|
||||
/** Get the sun's position in the sky in, relative to the horizon.
|
||||
* @param jday Astronomical time as julian day.
|
||||
* @param longitude Observer longitude
|
||||
* @param latitude Observer latitude
|
||||
* @param azimuth Astronomical azimuth, measured clockwise from North = 0.
|
||||
* @param altitude Astronomical altitude, elevation above the horizon.
|
||||
*/
|
||||
static void getHorizontalSunPosition (
|
||||
LongReal jday,
|
||||
LongReal longitude, LongReal latitude,
|
||||
LongReal &azimuth, LongReal &altitude);
|
||||
|
||||
static void getHorizontalSunPosition (
|
||||
LongReal jday,
|
||||
Ogre::Degree longitude, Ogre::Degree latitude,
|
||||
Ogre::Degree &azimuth, Ogre::Degree &altitude);
|
||||
|
||||
/// Gets the moon position at a specific time in ecliptic coordinates
|
||||
/// @param lon: Ecliptic longitude, in radians.
|
||||
/// @param lat: Ecliptic latitude, in radians.
|
||||
static void getEclipticMoonPositionRad (
|
||||
LongReal jday,
|
||||
LongReal &lon,
|
||||
LongReal &lat);
|
||||
|
||||
static void getHorizontalMoonPosition (
|
||||
LongReal jday,
|
||||
LongReal longitude, LongReal latitude,
|
||||
LongReal &azimuth, LongReal &altitude);
|
||||
static void getHorizontalMoonPosition (
|
||||
LongReal jday,
|
||||
Ogre::Degree longitude, Ogre::Degree latitude,
|
||||
Ogre::Degree &azimuth, Ogre::Degree &altitude);
|
||||
|
||||
/** Get astronomical julian day from normal gregorian calendar.
|
||||
* From wikipedia: the integer number of days that have elapsed
|
||||
* since the initial epoch defined as
|
||||
* noon Universal Time (UT) Monday, January 1, 4713 BC
|
||||
* @note this is the time at noon, not midnight.
|
||||
*/
|
||||
static int getJulianDayFromGregorianDate (
|
||||
int year, int month, int day);
|
||||
|
||||
/** Get astronomical julian day from normal gregorian calendar.
|
||||
* Calculate julian day from a day in the normal gregorian calendar.
|
||||
* Time should be given as UTC.
|
||||
* @see http://en.wikipedia.org/wiki/Julian_day
|
||||
*/
|
||||
static LongReal getJulianDayFromGregorianDateTime (
|
||||
int year, int month, int day,
|
||||
int hour, int minute, LongReal second);
|
||||
|
||||
/** Get astronomical julian day from normal gregorian calendar.
|
||||
* @see above (I don't know the proper doxygen syntax).
|
||||
*/
|
||||
static LongReal getJulianDayFromGregorianDateTime (
|
||||
int year, int month, int day,
|
||||
LongReal secondsFromMidnight);
|
||||
|
||||
/// Get gregorian date from integer julian day.
|
||||
static void getGregorianDateFromJulianDay (
|
||||
int julianDay, int &year, int &month, int &day);
|
||||
|
||||
/// Get gregorian date time from floating point julian day.
|
||||
static void getGregorianDateTimeFromJulianDay (
|
||||
LongReal julianDay, int &year, int &month, int &day,
|
||||
int &hour, int &minute, LongReal &second);
|
||||
|
||||
/// Get gregorian date from floating point julian day.
|
||||
static void getGregorianDateFromJulianDay (
|
||||
LongReal julianDay, int &year, int &month, int &day);
|
||||
|
||||
/** Enter high-precission floating-point mode.
|
||||
*
|
||||
* By default Direct3D decreases the precission of ALL floating
|
||||
* point calculations, enough to stop Caelum's astronomy routines
|
||||
* from working correctly.
|
||||
*
|
||||
* To trigger this behaviour in a standard ogre demo select the
|
||||
* Direct3D render system and set "Floating-point mode" to
|
||||
* "Fastest". Otherwise it's not a problem.
|
||||
*
|
||||
* It can be fixed by changing the precission only inside caelum's
|
||||
* astronomy routines using the _controlfp function. This only works
|
||||
* for MSVC on WIN32; This is a no-op on other compilers.
|
||||
*
|
||||
* @note: Must be paired with restoreFloatingPointMode.
|
||||
* @return Value to pass to restoreFloatingModeMode.
|
||||
*/
|
||||
static int enterHighPrecissionFloatingPointMode ();
|
||||
|
||||
/** Restore old floating point precission.
|
||||
* @see enterHighPrecissionFloatingPointMode.
|
||||
*/
|
||||
static void restoreFloatingPointMode (int oldMode);
|
||||
};
|
||||
|
||||
/** Dummy class to increase floting point precission in a block
|
||||
* This class will raise precission in the ctor and restore it
|
||||
* in the destructor. During it's lifetime floating-point
|
||||
* precission will be increased.
|
||||
*
|
||||
* To use this class just create a instance on the stack at the start of a block.
|
||||
*
|
||||
* @see Astronomy::enterHighPrecissionFloatingPointMode
|
||||
*/
|
||||
class CAELUM_EXPORT ScopedHighPrecissionFloatSwitch
|
||||
{
|
||||
private:
|
||||
int mOldFpMode;
|
||||
|
||||
public:
|
||||
inline ScopedHighPrecissionFloatSwitch() {
|
||||
mOldFpMode = Astronomy::enterHighPrecissionFloatingPointMode ();
|
||||
}
|
||||
|
||||
inline ~ScopedHighPrecissionFloatSwitch() {
|
||||
Astronomy::restoreFloatingPointMode (mOldFpMode);
|
||||
}
|
||||
};
|
||||
}
|
||||
|
||||
#endif // CAELUM__ASTRONOMY_H
|
||||
@ -1,44 +0,0 @@
|
||||
/*
|
||||
This file is part of Caelum.
|
||||
See http://www.ogre3d.org/wiki/index.php/Caelum
|
||||
|
||||
Copyright (c) 2006-2008 Caelum team. See Contributors.txt for details.
|
||||
|
||||
Caelum is free software: you can redistribute it and/or modify
|
||||
it under the terms of the GNU Lesser General Public License as published
|
||||
by the Free Software Foundation, either version 3 of the License, or
|
||||
(at your option) any later version.
|
||||
|
||||
Caelum is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
GNU Lesser General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU Lesser General Public License
|
||||
along with Caelum. If not, see <http://www.gnu.org/licenses/>.
|
||||
*/
|
||||
|
||||
#ifndef CAELUM_H
|
||||
#define CAELUM_H
|
||||
|
||||
#include "CaelumPrerequisites.h"
|
||||
#include "CaelumScriptTranslator.h"
|
||||
#include "TypeDescriptor.h"
|
||||
#include "CaelumPlugin.h"
|
||||
#include "CaelumExceptions.h"
|
||||
#include "CaelumSystem.h"
|
||||
#include "CameraBoundElement.h"
|
||||
#include "SkyDome.h"
|
||||
#include "Sun.h"
|
||||
#include "Moon.h"
|
||||
#include "UniversalClock.h"
|
||||
#include "Astronomy.h"
|
||||
#include "CloudSystem.h"
|
||||
#include "PrecipitationController.h"
|
||||
#include "FlatCloudLayer.h"
|
||||
#include "ImageStarfield.h"
|
||||
#include "PointStarfield.h"
|
||||
#include "GroundFog.h"
|
||||
#include "DepthComposer.h"
|
||||
|
||||
#endif // CAELUM_H
|
||||
@ -1,54 +0,0 @@
|
||||
/*
|
||||
This file is part of Caelum.
|
||||
See http://www.ogre3d.org/wiki/index.php/Caelum
|
||||
|
||||
Copyright (c) 2006-2008 Caelum team. See Contributors.txt for details.
|
||||
|
||||
Caelum is free software: you can redistribute it and/or modify
|
||||
it under the terms of the GNU Lesser General Public License as published
|
||||
by the Free Software Foundation, either version 3 of the License, or
|
||||
(at your option) any later version.
|
||||
|
||||
Caelum is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
GNU Lesser General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU Lesser General Public License
|
||||
along with Caelum. If not, see <http://www.gnu.org/licenses/>.
|
||||
*/
|
||||
|
||||
#ifndef CAELUM__CAELUM_EXCEPTIONS_H
|
||||
#define CAELUM__CAELUM_EXCEPTIONS_H
|
||||
|
||||
#include "CaelumPrerequisites.h"
|
||||
|
||||
namespace Caelum
|
||||
{
|
||||
/** Exception class for unsupported features.
|
||||
* This is frequently thrown if a certain required material does not load;
|
||||
* most likely because the hardware does not support the required shaders.
|
||||
*/
|
||||
class CAELUM_EXPORT UnsupportedException : public Ogre::Exception
|
||||
{
|
||||
public:
|
||||
/// Constructor.
|
||||
UnsupportedException
|
||||
(
|
||||
int number,
|
||||
const Ogre::String &description,
|
||||
const Ogre::String &source,
|
||||
const char *file,
|
||||
long line
|
||||
):
|
||||
Ogre::Exception (number, description, source, "UnsupportedException", file, line)
|
||||
{
|
||||
}
|
||||
};
|
||||
|
||||
#define CAELUM_THROW_UNSUPPORTED_EXCEPTION(desc, src) \
|
||||
throw UnsupportedException(-1, (desc), (src), __FILE__, __LINE__);
|
||||
|
||||
}
|
||||
|
||||
#endif // CAELUM__CAELUM_EXCEPTIONS_H
|
||||
@ -1,97 +0,0 @@
|
||||
/*
|
||||
This file is part of Caelum.
|
||||
See http://www.ogre3d.org/wiki/index.php/Caelum
|
||||
|
||||
Copyright (c) 2008 Caelum team. See Contributors.txt for details.
|
||||
|
||||
Caelum is free software: you can redistribute it and/or modify
|
||||
it under the terms of the GNU Lesser General Public License as published
|
||||
by the Free Software Foundation, either version 3 of the License, or
|
||||
(at your option) any later version.
|
||||
|
||||
Caelum is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
GNU Lesser General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU Lesser General Public License
|
||||
along with Caelum. If not, see <http://www.gnu.org/licenses/>.
|
||||
*/
|
||||
|
||||
#ifndef CAELUM__CAELUM_PLUGIN_H
|
||||
#define CAELUM__CAELUM_PLUGIN_H
|
||||
|
||||
#include "CaelumPrerequisites.h"
|
||||
#include "CaelumScriptTranslator.h"
|
||||
#include "TypeDescriptor.h"
|
||||
#include "OgrePlugin.h"
|
||||
|
||||
namespace Caelum
|
||||
{
|
||||
/** Implement an Ogre::Plugin for Caelum.
|
||||
*
|
||||
* Ogre plugins are usually loaded from config files and they register
|
||||
* various stuff in ogre managers. But you can also just link to the
|
||||
* library normally and call install functions manually.
|
||||
*/
|
||||
class CAELUM_EXPORT CaelumPlugin: public Ogre::Singleton<CaelumPlugin>, public Ogre::Plugin
|
||||
{
|
||||
public:
|
||||
/// Get reference to singleton instance; or crash if N/A.
|
||||
static CaelumPlugin& getSingleton(void);
|
||||
/// Get pointer to singleton instance; or pointer if N/A.
|
||||
static CaelumPlugin* getSingletonPtr(void);
|
||||
|
||||
CaelumPlugin();
|
||||
~CaelumPlugin();
|
||||
|
||||
virtual void install ();
|
||||
virtual void initialise ();
|
||||
virtual void shutdown ();
|
||||
virtual void uninstall ();
|
||||
|
||||
static const Ogre::String CAELUM_PLUGIN_NAME;
|
||||
virtual const String& getName () const;
|
||||
|
||||
// Determine if the plugin was installed (if install was called).
|
||||
inline bool isInstalled () const { return mIsInstalled; }
|
||||
|
||||
private:
|
||||
bool mIsInstalled;
|
||||
|
||||
#if CAELUM_TYPE_DESCRIPTORS
|
||||
public:
|
||||
/// Get default type descriptor data for caelum components.
|
||||
CaelumDefaultTypeDescriptorData* getTypeDescriptorData () { return &mTypeDescriptorData; }
|
||||
|
||||
private:
|
||||
CaelumDefaultTypeDescriptorData mTypeDescriptorData;
|
||||
#endif
|
||||
|
||||
#if CAELUM_SCRIPT_SUPPORT
|
||||
public:
|
||||
/** Load CaelumSystem and it's components from a script file.
|
||||
* @param sys Target CaelumSystem.
|
||||
* This is cleared using CaelumSystem::clear before loading.
|
||||
* If scripting data is not found then this is not modified.
|
||||
* @param objectName Name of caelum_sky_system from *.os file.
|
||||
* @param scriptFileGroup The group to search in (unused in Ogre 1.6)
|
||||
*/
|
||||
void loadCaelumSystemFromScript (
|
||||
CaelumSystem* sys,
|
||||
const Ogre::String& objectName,
|
||||
const Ogre::String& scriptFileGroup = Ogre::ResourceGroupManager::AUTODETECT_RESOURCE_GROUP_NAME
|
||||
);
|
||||
|
||||
/// @see PropScriptResourceManager
|
||||
PropScriptResourceManager* getPropScriptResourceManager () { return &mPropScriptResourceManager; }
|
||||
CaelumScriptTranslatorManager* getScriptTranslatorManager () { return &mScriptTranslatorManager; }
|
||||
|
||||
private:
|
||||
PropScriptResourceManager mPropScriptResourceManager;
|
||||
CaelumScriptTranslatorManager mScriptTranslatorManager;
|
||||
#endif
|
||||
};
|
||||
}
|
||||
|
||||
#endif // CAELUM__CAELUM_PLUGIN_H
|
||||
@ -1,25 +0,0 @@
|
||||
/*
|
||||
This file is part of Caelum.
|
||||
See http://www.ogre3d.org/wiki/index.php/Caelum
|
||||
|
||||
Copyright (c) 2006-2007 Caelum team. See Contributors.txt for details.
|
||||
|
||||
Caelum is free software: you can redistribute it and/or modify
|
||||
it under the terms of the GNU Lesser General Public License as published
|
||||
by the Free Software Foundation, either version 3 of the License, or
|
||||
(at your option) any later version.
|
||||
|
||||
Caelum is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
GNU Lesser General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU Lesser General Public License
|
||||
along with Caelum. If not, see <http://www.gnu.org/licenses/>.
|
||||
*/
|
||||
|
||||
#ifdef __APPLE__
|
||||
#include "OGRE/Ogre.h"
|
||||
#else
|
||||
#include "Ogre.h"
|
||||
#endif
|
||||
@ -1,180 +0,0 @@
|
||||
/*
|
||||
This file is part of Caelum.
|
||||
See http://www.ogre3d.org/wiki/index.php/Caelum
|
||||
|
||||
Copyright (c) 2006-2008 Caelum team. See Contributors.txt for details.
|
||||
|
||||
Caelum is free software: you can redistribute it and/or modify
|
||||
it under the terms of the GNU Lesser General Public License as published
|
||||
by the Free Software Foundation, either version 3 of the License, or
|
||||
(at your option) any later version.
|
||||
|
||||
Caelum is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
GNU Lesser General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU Lesser General Public License
|
||||
along with Caelum. If not, see <http://www.gnu.org/licenses/>.
|
||||
*/
|
||||
|
||||
#ifndef CAELUM__CAELUM_PREREQUISITES_H
|
||||
#define CAELUM__CAELUM_PREREQUISITES_H
|
||||
|
||||
// Include external headers
|
||||
#ifdef __APPLE__
|
||||
#include "Ogre/Ogre.h"
|
||||
#else
|
||||
#include "Ogre.h"
|
||||
#endif
|
||||
|
||||
#include <memory>
|
||||
|
||||
// Define the dll export qualifier if compiling for Windows
|
||||
#if OGRE_PLATFORM == OGRE_PLATFORM_WIN32
|
||||
#ifdef CAELUM_STATIC
|
||||
// Don't use dll export qualifier when built as a static lib
|
||||
#define CAELUM_EXPORT
|
||||
#elif CAELUM_LIB
|
||||
#define CAELUM_EXPORT __declspec (dllexport)
|
||||
#else
|
||||
#ifdef __MINGW32__
|
||||
#define CAELUM_EXPORT
|
||||
#else
|
||||
#define CAELUM_EXPORT __declspec (dllimport)
|
||||
#endif
|
||||
#endif
|
||||
#elif OGRE_PLATFORM == OGRE_PLATFORM_APPLE
|
||||
#define CAELUM_EXPORT __attribute__ ((visibility("default")))
|
||||
#else
|
||||
#define CAELUM_EXPORT
|
||||
#endif
|
||||
|
||||
// Define the version code
|
||||
#define CAELUM_VERSION_MAIN 0
|
||||
#define CAELUM_VERSION_SEC 5
|
||||
#define CAELUM_VERSION_TER 0
|
||||
#define CAELUM_VERSION = (CAELUM_VERSION_MAIN << 16) | (CAELUM_VERSION_SEC << 8) | CAELUM_VERSION_TER
|
||||
|
||||
// By default only compile type descriptors for scripting.
|
||||
#ifndef CAELUM_TYPE_DESCRIPTORS
|
||||
#if (OGRE_VERSION >= 0x00010600) && OGRE_USE_NEW_COMPILERS
|
||||
#define CAELUM_TYPE_DESCRIPTORS 1
|
||||
#else
|
||||
#define CAELUM_TYPE_DESCRIPTORS 0
|
||||
#endif
|
||||
#endif
|
||||
|
||||
// Scripting support requires Ogre 1.6
|
||||
// Can be also configured on compiler command line
|
||||
#ifndef CAELUM_SCRIPT_SUPPORT
|
||||
#if (OGRE_VERSION >= 0x00010600) && OGRE_USE_NEW_COMPILERS
|
||||
#define CAELUM_SCRIPT_SUPPORT 1
|
||||
#else
|
||||
#define CAELUM_SCRIPT_SUPPORT 0
|
||||
#endif
|
||||
#else
|
||||
#if !(OGRE_VERSION > 0x00010600)
|
||||
#error "Caelum script support requires Ogre 1.6."
|
||||
#endif
|
||||
#if !(OGRE_USE_NEW_COMPILERS)
|
||||
#error "Caelum script support requires Ogre 1.6 with OGRE_USE_NEW_COMPILERS."
|
||||
#endif
|
||||
#if !(CAELUM_TYPE_DESCRIPTORS)
|
||||
#error "Caelum script support also requires type descriptors."
|
||||
#endif
|
||||
#endif
|
||||
|
||||
/// @file
|
||||
|
||||
/** @mainpage
|
||||
*
|
||||
* %Caelum is an Ogre add-on for atmospheric rendering. It is composed of a
|
||||
* number of small mostly self-contained components and a big
|
||||
* Caelum::CaelumSystem class which ties them all together in an easy-to-use
|
||||
* way.
|
||||
*
|
||||
* More information is available on the wiki page:
|
||||
* http://www.ogre3d.org/wiki/index.php/Caelum
|
||||
*
|
||||
* You can discuss and report issues in the forum:
|
||||
* http://www.ogre3d.org/addonforums/viewforum.php?f=21
|
||||
*/
|
||||
|
||||
/** Caelum namespace
|
||||
*
|
||||
* All of %Caelum is inside this namespace (except for macros).
|
||||
*
|
||||
* @note: This was caelum with a lowercase 'c' in version 0.3
|
||||
*/
|
||||
namespace Caelum
|
||||
{
|
||||
// Caelum needs a lot of precission for astronomical calculations.
|
||||
// Very few calculations use it, and the precission IS required.
|
||||
typedef double LongReal;
|
||||
|
||||
// Use some ogre types.
|
||||
using Ogre::uint8;
|
||||
using Ogre::uint16;
|
||||
using Ogre::ushort;
|
||||
using Ogre::uint32;
|
||||
using Ogre::uint;
|
||||
|
||||
using Ogre::Real;
|
||||
using Ogre::String;
|
||||
|
||||
/// Resource group name for caelum resources.
|
||||
static const String RESOURCE_GROUP_NAME = "Caelum";
|
||||
|
||||
// Render group for caelum stuff
|
||||
// It's best to have them all together
|
||||
enum CaelumRenderQueueGroupId
|
||||
{
|
||||
CAELUM_RENDER_QUEUE_STARFIELD = Ogre::RENDER_QUEUE_SKIES_EARLY + 0,
|
||||
CAELUM_RENDER_QUEUE_MOON_BACKGROUND = Ogre::RENDER_QUEUE_SKIES_EARLY + 1,
|
||||
CAELUM_RENDER_QUEUE_SKYDOME = Ogre::RENDER_QUEUE_SKIES_EARLY + 2,
|
||||
CAELUM_RENDER_QUEUE_MOON = Ogre::RENDER_QUEUE_SKIES_EARLY + 3,
|
||||
CAELUM_RENDER_QUEUE_SUN = Ogre::RENDER_QUEUE_SKIES_EARLY + 4,
|
||||
CAELUM_RENDER_QUEUE_CLOUDS = Ogre::RENDER_QUEUE_SKIES_EARLY + 5,
|
||||
CAELUM_RENDER_QUEUE_GROUND_FOG = Ogre::RENDER_QUEUE_SKIES_EARLY + 6,
|
||||
};
|
||||
|
||||
// Forward declarations
|
||||
class UniversalClock;
|
||||
class SkyDome;
|
||||
class BaseSkyLight;
|
||||
class Moon;
|
||||
class SphereSun;
|
||||
class SpriteSun;
|
||||
class ImageStarfield;
|
||||
class PointStarfield;
|
||||
class CloudSystem;
|
||||
class CaelumSystem;
|
||||
class FlatCloudLayer;
|
||||
class PrecipitationController;
|
||||
class PrecipitationInstance;
|
||||
class GroundFog;
|
||||
class DepthComposer;
|
||||
class DepthComposerInstance;
|
||||
class DepthRenderer;
|
||||
}
|
||||
|
||||
namespace Ogre
|
||||
{
|
||||
#if OGRE_VERSION <= 0x010602
|
||||
// Write an Ogre::Degree to a stream.
|
||||
//
|
||||
// Ogre::Any requires that the wrapped type can be written to a stream;
|
||||
// otherwise it will fail on instantation. This function was placed here
|
||||
// so it's available everywhere. This can't be placed in namespace Caelum.
|
||||
//
|
||||
// Ogre 1.6.3 and up already include this operator; so it's ifdefed out.
|
||||
//
|
||||
// This function is never actually used; the output does not matter.
|
||||
inline std::ostream& operator << (std::ostream& out, Ogre::Degree deg) {
|
||||
return out << deg.valueDegrees();
|
||||
}
|
||||
#endif
|
||||
}
|
||||
|
||||
#endif // CAELUM__CAELUM_PREREQUISITES_H
|
||||
@ -1,216 +0,0 @@
|
||||
/*
|
||||
This file is part of Caelum.
|
||||
See http://www.ogre3d.org/wiki/index.php/Caelum
|
||||
|
||||
Copyright (c) 2008 Caelum team. See Contributors.txt for details.
|
||||
|
||||
Caelum is free software: you can redistribute it and/or modify
|
||||
it under the terms of the GNU Lesser General Public License as published
|
||||
by the Free Software Foundation, either version 3 of the License, or
|
||||
(at your option) any later version.
|
||||
|
||||
Caelum is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
GNU Lesser General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU Lesser General Public License
|
||||
along with Caelum. If not, see <http://www.gnu.org/licenses/>.
|
||||
*/
|
||||
|
||||
#ifndef CAELUM__CAELUM_SCRIPT_TRANSLATOR_H
|
||||
#define CAELUM__CAELUM_SCRIPT_TRANSLATOR_H
|
||||
|
||||
#if CAELUM_SCRIPT_SUPPORT
|
||||
|
||||
#include "CaelumPrerequisites.h"
|
||||
#include "OgreScriptTranslator.h"
|
||||
#include "TypeDescriptor.h"
|
||||
|
||||
namespace Caelum
|
||||
{
|
||||
/** Dummy resources created for property script blocks.
|
||||
*
|
||||
* When parsing material scripts the singleton rendersystem is available
|
||||
* and materials are created using it. But Caelum's scriptable components
|
||||
* require at least an active scene scene manager; and you can't require
|
||||
* something like that when initializing resources.
|
||||
*
|
||||
* So instead a dummy resource like this is created which only remembers
|
||||
* the location of the script block in the resources. Actually loading the
|
||||
* properties will always reparse the script.
|
||||
*
|
||||
* The original file name is available from Ogre::Resource::getOrigin
|
||||
*
|
||||
* These resources are managed by the PropScriptResourceManager. Resource
|
||||
* operations like loading and unloading are meaningless.
|
||||
*/
|
||||
class CAELUM_EXPORT PropScriptResource: public Ogre::Resource {
|
||||
protected:
|
||||
virtual void loadImpl () { }
|
||||
virtual void unloadImpl () { }
|
||||
virtual size_t calculateSize () const { return 0; }
|
||||
|
||||
public:
|
||||
PropScriptResource (
|
||||
Ogre::ResourceManager* creator, const Ogre::String& name, Ogre::ResourceHandle handle,
|
||||
const Ogre::String& group, bool isManual, Ogre::ManualResourceLoader* loader);
|
||||
~PropScriptResource();
|
||||
};
|
||||
|
||||
/** Resource manager for PropScriptResource.
|
||||
*/
|
||||
class CAELUM_EXPORT PropScriptResourceManager: public Ogre::ResourceManager
|
||||
{
|
||||
public:
|
||||
PropScriptResourceManager();
|
||||
|
||||
virtual PropScriptResource* createImpl(
|
||||
const String& name, Ogre::ResourceHandle handle, const String& group,
|
||||
bool isManual, Ogre::ManualResourceLoader* loader, const Ogre::NameValuePairList* createParams);
|
||||
};
|
||||
|
||||
/** An Ogre::ScriptTranslator based on a TypeDescriptor.
|
||||
* This class implements an Ogre::ScriptTranslator based on data from a TypeDescriptor.
|
||||
*
|
||||
* The target object is never created; it must be passed in the context member of the
|
||||
* root node. Some other ScriptTranslator must cooperate and set the context member;
|
||||
* this is similar to how Ogre::PassTranslator depends on Ogre::MaterialTranslator
|
||||
* setting the context.
|
||||
*
|
||||
* Ogre::AbstractNode::context is an Ogre::Any which boxes objects in a way which
|
||||
* stores the static (compile-time) type at assignment. You must cast the
|
||||
* object into a void* before setting it as the context.
|
||||
*
|
||||
* Most of the actual translation functionality is in static functions; a class can
|
||||
* translate based on TypeDescriptor data without deriving from this class.
|
||||
*/
|
||||
class CAELUM_EXPORT TypeDescriptorScriptTranslator: public Ogre::ScriptTranslator
|
||||
{
|
||||
public:
|
||||
/** Get the value of a property or report the appropriate error.
|
||||
* @return Success value.
|
||||
*/
|
||||
static bool getPropValueOrAddError (Ogre::ScriptCompiler* compiler, Ogre::PropertyAbstractNode* prop, int& value);
|
||||
static bool getPropValueOrAddError (Ogre::ScriptCompiler* compiler, Ogre::PropertyAbstractNode* prop, float& value);
|
||||
static bool getPropValueOrAddError (Ogre::ScriptCompiler* compiler, Ogre::PropertyAbstractNode* prop, double& value);
|
||||
static bool getPropValueOrAddError (Ogre::ScriptCompiler* compiler, Ogre::PropertyAbstractNode* prop, bool& value);
|
||||
static bool getPropValueOrAddError (Ogre::ScriptCompiler* compiler, Ogre::PropertyAbstractNode* prop, Ogre::Degree& value);
|
||||
static bool getPropValueOrAddError (Ogre::ScriptCompiler* compiler, Ogre::PropertyAbstractNode* prop, Ogre::ColourValue& value);
|
||||
static bool getPropValueOrAddError (Ogre::ScriptCompiler* compiler, Ogre::PropertyAbstractNode* prop, Ogre::String& value);
|
||||
static bool getPropValueOrAddError (Ogre::ScriptCompiler* compiler, Ogre::PropertyAbstractNode* prop, Ogre::Vector3& value);
|
||||
static bool getPropValueOrAddError (Ogre::ScriptCompiler* compiler, Ogre::PropertyAbstractNode* prop, Ogre::Vector2& value);
|
||||
|
||||
/** Translate a property using a TypeDescriptor; or report error to compiler.
|
||||
*/
|
||||
static void translateProperty (
|
||||
Ogre::ScriptCompiler* compiler,
|
||||
Ogre::PropertyAbstractNode* prop,
|
||||
void* targetObject,
|
||||
const TypeDescriptor* typeDescriptor);
|
||||
|
||||
public:
|
||||
explicit TypeDescriptorScriptTranslator (TypeDescriptor* type = 0);
|
||||
|
||||
virtual void translate (Ogre::ScriptCompiler* compiler, const Ogre::AbstractNodePtr& node);
|
||||
|
||||
inline const TypeDescriptor* getTypeDescriptor () const { return mTypeDescriptor; }
|
||||
inline TypeDescriptor* getTypeDescriptor () { return mTypeDescriptor; }
|
||||
|
||||
private:
|
||||
TypeDescriptor* mTypeDescriptor;
|
||||
};
|
||||
|
||||
/** Script translator for CaelumSystem
|
||||
*/
|
||||
struct CAELUM_EXPORT CaelumSystemScriptTranslator: public Ogre::ScriptTranslator
|
||||
{
|
||||
public:
|
||||
CaelumSystemScriptTranslator();
|
||||
|
||||
virtual void translate (Ogre::ScriptCompiler* compiler, const Ogre::AbstractNodePtr& node);
|
||||
|
||||
void setTranslationTarget (CaelumSystem* target, const Ogre::String& name);
|
||||
void clearTranslationTarget ();
|
||||
|
||||
inline bool hasTranslationTarget () const { return mTranslationTarget != 0; }
|
||||
inline bool foundTranslationTarget () const { return mTranslationTargetFound; }
|
||||
inline CaelumSystem* getTranslationTarget () const { return mTranslationTarget; }
|
||||
inline const Ogre::String& getTranslationTargetName () const { return mTranslationTargetName; }
|
||||
|
||||
inline void setResourceManager (PropScriptResourceManager* value) { mResourceManager = value; }
|
||||
inline PropScriptResourceManager* getResourceManager () const { return mResourceManager; }
|
||||
|
||||
private:
|
||||
PropScriptResourceManager* mResourceManager;
|
||||
CaelumSystem* mTranslationTarget;
|
||||
Ogre::String mTranslationTargetName;
|
||||
bool mTranslationTargetFound;
|
||||
|
||||
public:
|
||||
/** Type descriptor for CaelumSystem itself.
|
||||
* This is use for simple top-level properties.
|
||||
* Components (sun, moon etc) are handled with custom code.
|
||||
*/
|
||||
inline const TypeDescriptor* getTypeDescriptor () const { return mTypeDescriptor; }
|
||||
inline void setTypeDescriptor (const TypeDescriptor* value) { mTypeDescriptor = value; }
|
||||
|
||||
private:
|
||||
const TypeDescriptor* mTypeDescriptor;
|
||||
};
|
||||
|
||||
/** Script translator for CloudSystem
|
||||
* Caelum::CloudSystem requires a special translator because it's made up of separate layers.
|
||||
*
|
||||
* Layers of different types are not supported; only instances of FlatCloudLayer.
|
||||
* CloudSystem doesn't have any top-level properties.
|
||||
*
|
||||
* Overriding works just like for ogre texture units; and you can use name-based overriding.
|
||||
* Names are not preserved after script translation; they're only used inside Ogre's script
|
||||
* compilation steps.
|
||||
*/
|
||||
struct CAELUM_EXPORT CloudSystemScriptTranslator: public Ogre::ScriptTranslator
|
||||
{
|
||||
public:
|
||||
virtual void translate (Ogre::ScriptCompiler* compiler, const Ogre::AbstractNodePtr& node);
|
||||
};
|
||||
|
||||
/** ScriptTranslatorManager for caelum's scriptable objects.
|
||||
* This class contains Ogre::ScriptTranslators for Caelum components.
|
||||
*/
|
||||
class CAELUM_EXPORT CaelumScriptTranslatorManager: public Ogre::ScriptTranslatorManager
|
||||
{
|
||||
public:
|
||||
explicit CaelumScriptTranslatorManager (CaelumDefaultTypeDescriptorData* typeData);
|
||||
|
||||
virtual size_t getNumTranslators () const;
|
||||
|
||||
/// @copydoc Ogre::ScriptTranslatorManager::getTranslator.
|
||||
virtual Ogre::ScriptTranslator* getTranslator (const Ogre::AbstractNodePtr& node);
|
||||
|
||||
void _setPropScriptResourceManager (PropScriptResourceManager* mgr);
|
||||
|
||||
inline CaelumSystemScriptTranslator* getCaelumSystemTranslator () { return &mCaelumSystemTranslator; }
|
||||
|
||||
private:
|
||||
CaelumSystemScriptTranslator mCaelumSystemTranslator;
|
||||
CloudSystemScriptTranslator mCloudSystemTranslator;
|
||||
TypeDescriptorScriptTranslator mFlatCloudLayerTranslator;
|
||||
TypeDescriptorScriptTranslator mSunTranslator;
|
||||
TypeDescriptorScriptTranslator mMoonTranslator;
|
||||
TypeDescriptorScriptTranslator mPointStarfieldTranslator;
|
||||
TypeDescriptorScriptTranslator mGroundFogTranslator;
|
||||
TypeDescriptorScriptTranslator mDepthComposerTranslator;
|
||||
TypeDescriptorScriptTranslator mPrecipitationTranslator;
|
||||
TypeDescriptorScriptTranslator mSkyDomeTranslator;
|
||||
|
||||
/// Maps class name to script translator.
|
||||
/// Does not own memory; just holds pointers to members.
|
||||
typedef std::map<Ogre::String, Ogre::ScriptTranslator*> ScriptTranslatorMap;
|
||||
ScriptTranslatorMap mTranslatorMap;
|
||||
};
|
||||
}
|
||||
|
||||
#endif // CAELUM_SCRIPT_SUPPORT
|
||||
|
||||
#endif // CAELUM__CAELUM_SCRIPT_TRANSLATOR_H
|
||||
@ -1,672 +0,0 @@
|
||||
/*
|
||||
This file is part of Caelum.
|
||||
See http://www.ogre3d.org/wiki/index.php/Caelum
|
||||
|
||||
Copyright (c) 2006-2008 Caelum team. See Contributors.txt for details.
|
||||
|
||||
Caelum is free software: you can redistribute it and/or modify
|
||||
it under the terms of the GNU Lesser General Public License as published
|
||||
by the Free Software Foundation, either version 3 of the License, or
|
||||
(at your option) any later version.
|
||||
|
||||
Caelum is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
GNU Lesser General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU Lesser General Public License
|
||||
along with Caelum. If not, see <http://www.gnu.org/licenses/>.
|
||||
*/
|
||||
|
||||
#ifndef CAELUM__CAELUM_SYSTEM_H
|
||||
#define CAELUM__CAELUM_SYSTEM_H
|
||||
|
||||
#include "CaelumPrerequisites.h"
|
||||
#include "UniversalClock.h"
|
||||
#include "ImageStarfield.h"
|
||||
#include "PointStarfield.h"
|
||||
#include "SkyLight.h"
|
||||
#include "Sun.h"
|
||||
#include "Moon.h"
|
||||
#include "CloudSystem.h"
|
||||
#include "SkyDome.h"
|
||||
#include "DepthComposer.h"
|
||||
#include "PrecipitationController.h"
|
||||
#include "GroundFog.h"
|
||||
#include "PrivatePtr.h"
|
||||
|
||||
namespace Caelum
|
||||
{
|
||||
/** This is the "root class" of caelum.
|
||||
*
|
||||
* This class is created once for one SceneManager and will render the sky
|
||||
* for that scene. CaelumSystem will be visible in all viewports on the
|
||||
* scene and must be notified when those viewports are created and
|
||||
* destroyed.
|
||||
*
|
||||
* @par Components
|
||||
*
|
||||
* %Caelum is built from several classes for different sky elements (the sun,
|
||||
* clouds, etc). Those classes know very little about each other and are
|
||||
* connected through this class. This class is responsible for tracking and
|
||||
* updating sub-components.
|
||||
*
|
||||
* This class "owns" all of the subcomponents, using std::auto_ptr members.
|
||||
* When you call functions like setXxx(new Xxx()) this class takes
|
||||
* ownership of the object's lifetime and will try to update it as
|
||||
* appropriate. All components are optional; disable one component should
|
||||
* never cause a crash. When something is broken disabling components one
|
||||
* by one is a very good way to find the source of the problem.
|
||||
*
|
||||
* The constructor can create a bunch of components with default settings
|
||||
* for you; based on the CaelumSystem::CaelumComponent flags passed.
|
||||
*
|
||||
* @par Updating
|
||||
*
|
||||
* This class is responsible for updating subcomponents. There are two
|
||||
* update functions which must be get called to keep CaelumSystem
|
||||
* functioning properly. One is per-frame and the other is per-camera.
|
||||
*
|
||||
* CaelumSystem::updateSubcomponents must be called once per frame to
|
||||
* advance world time and tie components together. That function will
|
||||
* set certain properties on the subcomponents making up CaelumSystem
|
||||
* If you want to force some properties beyond what CaelumSystem does by
|
||||
* default you can do that AFTER the call to updateSubcompoments. For
|
||||
* example you can override the moon's phase by calling Moon::setPhase.
|
||||
*
|
||||
* CaelumSystem::notifyCameraChanged must be called for each camera
|
||||
* before rendering with that camera. All viewport tweaks and camera
|
||||
* movement must be done BEFORE calling this function. This method will
|
||||
* recenter Caelum's domes on the camera. Also, some subcomponents
|
||||
* can actually depend on field-of-view and viewport resolution (like
|
||||
* PointStarfield).
|
||||
*
|
||||
* You can register CaelumSystem as an Ogre::FrameListener and
|
||||
* updateSubcomponents will be automatically called inside Ogre's
|
||||
* rendering loop (inside frameStarted). If you want more control you
|
||||
* should call updateSubcomponents in your own main loop. That way you
|
||||
* can avoid potential issues with the ordering of multiple FrameListeners.
|
||||
*
|
||||
* You can register CaelumSystem as an Ogre::RenderTargetListener and
|
||||
* notifyCameraChanged will be automatically called inside
|
||||
* preViewportUpdate. That behaviour can be disabled with
|
||||
* setAutoNotifyCameraChanged(false). It is recommended that you
|
||||
* call notifyCameraChanged manually before updating viewports.
|
||||
*
|
||||
* RenderTargetListener::preViewportUpdate does not work as expected
|
||||
* when compositors are involved (those inside Caelum or external).
|
||||
* Compositors plug into preRenderTargetUpdate and render the scene to a
|
||||
* texture BEFORE preViewportUpdate; this means that notifyCameraChanged
|
||||
* will execute before the final compositor pass but after actual scene
|
||||
* rendering.
|
||||
*
|
||||
* If notifyCameraChanged is not called correctly the most likely result
|
||||
* is "flickering" when moving the camera. If you move the camera AFTER
|
||||
* notifyCameraChanged then the domes will not be positioned correctly
|
||||
* and will appear to lag slightly after the camera. Since updates are
|
||||
* always done every frame keeping the camera still will make problems
|
||||
* disappear.
|
||||
*
|
||||
* If you notice z-buffer issues while the camera is still update order
|
||||
* is probably not the cause.
|
||||
*/
|
||||
class CAELUM_EXPORT CaelumSystem:
|
||||
public Ogre::FrameListener,
|
||||
public Ogre::RenderTargetListener
|
||||
{
|
||||
private:
|
||||
/// Root of the Ogre engine.
|
||||
Ogre::Root *mOgreRoot;
|
||||
|
||||
/// Scene manager.
|
||||
Ogre::SceneManager *mSceneMgr;
|
||||
|
||||
/// Caelum scene node for camera-bound elements (most).
|
||||
PrivateSceneNodePtr mCaelumCameraNode;
|
||||
|
||||
/// Caelum scene node for ground-bound elements (only clouds currently).
|
||||
PrivateSceneNodePtr mCaelumGroundNode;
|
||||
|
||||
/// Cleanup requested flag.
|
||||
bool mCleanup;
|
||||
|
||||
/// Automatically move the camera node.
|
||||
bool mAutoMoveCameraNode;
|
||||
|
||||
/// Automatically call this->notifyCameraChanged.
|
||||
bool mAutoNotifyCameraChanged;
|
||||
|
||||
/// Automatically attach compositors to viewports
|
||||
bool mAutoAttachViewportsToComponents;
|
||||
|
||||
/// Automatically set the viewport colour to black.
|
||||
bool mAutoViewportBackground;
|
||||
|
||||
/// Flag to indicate if Caelum manages standard Ogre::Scene fog.
|
||||
bool mManageSceneFog;
|
||||
|
||||
Real mGlobalFogDensityMultiplier;
|
||||
Ogre::ColourValue mGlobalFogColourMultiplier;
|
||||
|
||||
Real mSceneFogDensityMultiplier;
|
||||
Ogre::ColourValue mSceneFogColourMultiplier;
|
||||
|
||||
Real mGroundFogDensityMultiplier;
|
||||
Ogre::ColourValue mGroundFogColourMultiplier;
|
||||
|
||||
/// Flag for managing scene ambient light.
|
||||
bool mManageAmbientLight;
|
||||
|
||||
/// Minimum ambient light; only useful if mManageAmbientLight
|
||||
Ogre::ColourValue mMinimumAmbientLight;
|
||||
|
||||
/// If only one light source should enabled at a time.
|
||||
bool mEnsureSingleLightSource;
|
||||
|
||||
/// Ensure only one of the light sources casts shadows.
|
||||
bool mEnsureSingleShadowSource;
|
||||
|
||||
/// The sky gradients image (for lookups).
|
||||
std::auto_ptr<Ogre::Image> mSkyGradientsImage;
|
||||
|
||||
/// The sun gradients image (for lookups).
|
||||
std::auto_ptr<Ogre::Image> mSunColoursImage;
|
||||
|
||||
/// Observer Latitude (on the earth).
|
||||
Ogre::Degree mObserverLatitude;
|
||||
/// Observer Longitude (on the earth).
|
||||
Ogre::Degree mObserverLongitude;
|
||||
|
||||
static const Ogre::Vector3 makeDirection (
|
||||
Ogre::Degree azimuth, Ogre::Degree altitude);
|
||||
|
||||
// References to sub-components
|
||||
std::auto_ptr<UniversalClock> mUniversalClock;
|
||||
std::auto_ptr<SkyDome> mSkyDome;
|
||||
std::auto_ptr<BaseSkyLight> mSun;
|
||||
std::auto_ptr<Moon> mMoon;
|
||||
std::auto_ptr<ImageStarfield> mImageStarfield;
|
||||
std::auto_ptr<PointStarfield> mPointStarfield;
|
||||
std::auto_ptr<GroundFog> mGroundFog;
|
||||
std::auto_ptr<CloudSystem> mCloudSystem;
|
||||
std::auto_ptr<PrecipitationController> mPrecipitationController;
|
||||
std::auto_ptr<DepthComposer> mDepthComposer;
|
||||
|
||||
public:
|
||||
typedef std::set<Ogre::Viewport*> AttachedViewportSet;
|
||||
|
||||
private:
|
||||
AttachedViewportSet mAttachedViewports;
|
||||
|
||||
public:
|
||||
/** Flags enumeration for caelum components.
|
||||
* This is an enumeration for the components to create by default in
|
||||
* Caelum's constructor. You can still pass 0 and create everything
|
||||
* by hand.
|
||||
*
|
||||
* CaelumSystem's constructor used to take a number of bools but now
|
||||
* there are too many components and this is nicer.
|
||||
*
|
||||
* CAELUM_COMPONENT_ members are for individual components.
|
||||
* CAELUM_COMPONENTS_ are standard bitmasks.
|
||||
* CAELUM_COMPONENTS_DEFAULT picks elements that don't require
|
||||
* modifications to external materials (right now it excludes ground fog).
|
||||
*/
|
||||
enum CaelumComponent
|
||||
{
|
||||
CAELUM_COMPONENT_SKY_DOME = 1 << 1,
|
||||
CAELUM_COMPONENT_MOON = 1 << 3,
|
||||
CAELUM_COMPONENT_SUN = 1 << 4,
|
||||
CAELUM_COMPONENT_IMAGE_STARFIELD = 1 << 5,
|
||||
CAELUM_COMPONENT_POINT_STARFIELD = 1 << 6,
|
||||
CAELUM_COMPONENT_CLOUDS = 1 << 7,
|
||||
CAELUM_COMPONENT_PRECIPITATION = 1 << 8,
|
||||
CAELUM_COMPONENT_SCREEN_SPACE_FOG = 1 << 9,
|
||||
|
||||
// This has nasty dependencies on materials.
|
||||
CAELUM_COMPONENT_GROUND_FOG = 1 << (16 + 0),
|
||||
|
||||
// Groups
|
||||
CAELUM_COMPONENTS_NONE = 0,
|
||||
CAELUM_COMPONENTS_DEFAULT = 0
|
||||
| CAELUM_COMPONENT_SKY_DOME
|
||||
| CAELUM_COMPONENT_MOON
|
||||
| CAELUM_COMPONENT_SUN
|
||||
| CAELUM_COMPONENT_POINT_STARFIELD
|
||||
| CAELUM_COMPONENT_CLOUDS,
|
||||
CAELUM_COMPONENTS_ALL = 0
|
||||
| CAELUM_COMPONENTS_DEFAULT
|
||||
| CAELUM_COMPONENT_PRECIPITATION
|
||||
| CAELUM_COMPONENT_SCREEN_SPACE_FOG
|
||||
| CAELUM_COMPONENT_GROUND_FOG,
|
||||
};
|
||||
|
||||
static const String DEFAULT_SKY_GRADIENTS_IMAGE;
|
||||
static const String DEFAULT_SUN_COLOURS_IMAGE;
|
||||
|
||||
/** Constructor.
|
||||
* Registers itself in the Ogre engine and initialises the system.
|
||||
*
|
||||
* @param root The Ogre root.
|
||||
* @param scene The Ogre scene manager.
|
||||
* @param componentsToCreate Default components for @see autoConfigure.
|
||||
*/
|
||||
CaelumSystem (
|
||||
Ogre::Root *root,
|
||||
Ogre::SceneManager *sceneMgr,
|
||||
CaelumComponent componentsToCreate);
|
||||
|
||||
/** Revert everything to defaults.
|
||||
*
|
||||
* This function will delete all subcomponents and revert everything
|
||||
* to default values (the values which are also set on construction).
|
||||
*/
|
||||
void clear ();
|
||||
|
||||
/** Create some default component with resonable default settings.
|
||||
* This results in a slightly cloudy morning sky.
|
||||
* This will always call clear() before creating components.
|
||||
* autoConfigure (0); is equivalent to clear();
|
||||
*/
|
||||
void autoConfigure (
|
||||
CaelumComponent componentsToCreate);
|
||||
|
||||
/** Destructor.
|
||||
*/
|
||||
~CaelumSystem ();
|
||||
|
||||
/** Shuts down the system and detaches itself from the Ogre engine.
|
||||
*
|
||||
* shutdown(true) is equivalent to deleting CaelumSystem yourself.
|
||||
* shutdown(false) delays destruction to the next time caelum is called as
|
||||
* a frame listener. This makes it safe to shutdown Caelum from inside
|
||||
* another frame listener.
|
||||
*
|
||||
* @param cleanup If this is true then detach and destroy the CaelumSystem instantly.
|
||||
*/
|
||||
void shutdown (bool cleanup);
|
||||
|
||||
/** Update the whole system manually.
|
||||
* You have to call this yourself if you don't register CaelumSystem
|
||||
* as an ogre frame listener. Otherwise it's called automatically.
|
||||
*
|
||||
* @param timeSinceLastFrame: Time passed since last frame.
|
||||
*/
|
||||
void updateSubcomponents (Real timeSinceLastFrame);
|
||||
|
||||
/** Notify subcomponents of camera changes.
|
||||
* This function must be called after camera changes but before
|
||||
* rendering with that camera. If multiple cameras are used it must
|
||||
* be called for each camera before the camera is rendered with.
|
||||
*
|
||||
* This function will move caelum's camera node to the camera
|
||||
* position, but only if getAutoMoveCameraNode.
|
||||
* It will also call CameraBoundElement::notifyCameraChanged
|
||||
*/
|
||||
void notifyCameraChanged(Ogre::Camera* cam);
|
||||
|
||||
/** Get the scene manager for this caelum system.
|
||||
* This is set in the constructor. CaelumSystem can't exist without a valid scene manager.
|
||||
*/
|
||||
inline Ogre::SceneManager* getSceneMgr() const { return mSceneMgr; }
|
||||
|
||||
/// Gets root scene node for camera-bound elements
|
||||
inline Ogre::SceneNode* getCaelumCameraNode(void) const { return mCaelumCameraNode.get(); }
|
||||
|
||||
/// Gets root scene node for ground-bound elements.
|
||||
inline Ogre::SceneNode* getCaelumGroundNode(void) const { return mCaelumGroundNode.get(); }
|
||||
|
||||
/** If true; listen to preViewportUpdate and automatically notifyCameraChanged();
|
||||
*
|
||||
* This is on by default; but does not work with compositors.
|
||||
*
|
||||
* You must attach CaelumSystem as a RenderTargetListener manually for
|
||||
* this to work; as in version 0.3.
|
||||
*/
|
||||
inline void setAutoNotifyCameraChanged(bool value) { mAutoNotifyCameraChanged = value; }
|
||||
/// @see setAutoNotifyCameraChanged
|
||||
inline bool getAutoNotifyCameraChanged() const { return mAutoNotifyCameraChanged; }
|
||||
|
||||
/** If true; automatically attach viewports to subcomponents.
|
||||
*
|
||||
* Some subcomponents use compositors and those compositors need to
|
||||
* be attached to individual viewports. By default CaelumSystem will
|
||||
* try take to take care of that automatically.
|
||||
*
|
||||
* This property allows you to disable that behaviour. If set to false
|
||||
* you must call functions like
|
||||
* PrecipitationController::createViewportInstance manually.
|
||||
*
|
||||
* @see attachViewport detachViewport
|
||||
*/
|
||||
inline void setAutoAttachViewportsToComponents(bool value) { mAutoAttachViewportsToComponents = value; }
|
||||
/// @see setAutoAttachViewportsToComponents.
|
||||
inline bool getAutoAttachViewportsToComponents() const { return mAutoAttachViewportsToComponents; }
|
||||
|
||||
/** If true (default); automatically move the camera node in notifyCameraChanged.
|
||||
* If disable you get full control of the camera node; and in theory
|
||||
* you can attach it to the scene graph however you please.
|
||||
*/
|
||||
inline void setAutoMoveCameraNode(bool value) { mAutoMoveCameraNode = value; }
|
||||
/// @see setAutoMoveCameraNode
|
||||
inline bool getAutoMoveCameraNode() { return mAutoMoveCameraNode; }
|
||||
|
||||
/** If true; automatically set the viewport color to black.
|
||||
* Caelum's domes relies on the viewport background being black.
|
||||
* There's generally no reason to disable this and it's on by default.
|
||||
*/
|
||||
inline void setAutoViewportBackground(bool value) { mAutoViewportBackground = value; }
|
||||
/// @see setAutoViewportBackground
|
||||
inline bool getAutoViewportBackground() const { return mAutoViewportBackground; }
|
||||
|
||||
/// Get the observer's longitude. East is positive, west is negative.
|
||||
inline const Ogre::Degree getObserverLongitude () const { return mObserverLongitude; }
|
||||
|
||||
/// Set the observer's longitude. East is positive, west is negative.
|
||||
inline void setObserverLongitude (Ogre::Degree value) { mObserverLongitude = value; }
|
||||
|
||||
/// Get the observer's latitude. North is positive, south is negative.
|
||||
inline const Ogre::Degree getObserverLatitude () const { return mObserverLatitude; }
|
||||
|
||||
/// Set the observer's latitude. North is positive, south is negative.
|
||||
inline void setObserverLatitude (Ogre::Degree value) { mObserverLatitude = value; }
|
||||
|
||||
inline LongReal getJulianDay () const { return mUniversalClock->getJulianDay (); }
|
||||
inline void setJulianDay (LongReal value) { mUniversalClock->setJulianDay (value); }
|
||||
inline Real getTimeScale () const { return mUniversalClock->getTimeScale (); }
|
||||
inline void setTimeScale (Real value) { mUniversalClock->setTimeScale (value); }
|
||||
|
||||
public:
|
||||
/** Attach CaelumSystem to a viewport.
|
||||
* You should call this for every new viewport looking at the scene
|
||||
* where CaelumSystem is created.
|
||||
*
|
||||
* If the viewport is already attached then nothing happens.
|
||||
*
|
||||
* If getAutoAttachViewportsToComponents() this will add Caelum's compositors.
|
||||
*/
|
||||
void attachViewport (Ogre::Viewport* rt);
|
||||
|
||||
/** Reverse of @see attachViewport.
|
||||
* You need to call this when you destroy a viewport.
|
||||
*
|
||||
* If the viewport is not already attached nothing happens.
|
||||
*/
|
||||
void detachViewport (Ogre::Viewport* rt);
|
||||
|
||||
/** Check if one particular viewport is attached.
|
||||
*/
|
||||
bool isViewportAttached (Ogre::Viewport* vp) const;
|
||||
|
||||
/** Detach from all viewports.
|
||||
*/
|
||||
void detachAllViewports ();
|
||||
|
||||
/// Get a reference to the set of attached viewports.
|
||||
const AttachedViewportSet& _getAttachedViewportSet () { return mAttachedViewports; }
|
||||
|
||||
protected:
|
||||
// Do the work behind attach/detach viewport.
|
||||
void attachViewportImpl (Ogre::Viewport* rt);
|
||||
void detachViewportImpl (Ogre::Viewport* rt);
|
||||
|
||||
public:
|
||||
/// Gets the universal clock.
|
||||
inline UniversalClock *getUniversalClock () const { return mUniversalClock.get(); }
|
||||
|
||||
/// Get the current sky dome, or null if disabled.
|
||||
inline SkyDome* getSkyDome () const { return mSkyDome.get (); }
|
||||
/// Set the skydome, or null to disable.
|
||||
void setSkyDome (SkyDome *obj);
|
||||
|
||||
/// Gets the current sun, or null if disabled.
|
||||
inline BaseSkyLight* getSun () const { return mSun.get (); }
|
||||
/// Set the sun, or null to disable.
|
||||
void setSun (BaseSkyLight* obj);
|
||||
|
||||
/// Gets the current moon, or null if disabled.
|
||||
inline Moon* getMoon () const { return mMoon.get (); }
|
||||
/// Set the moon, or null to disable.
|
||||
void setMoon (Moon* obj);
|
||||
|
||||
/// Gets the current image starfield, or null if disabled.
|
||||
inline ImageStarfield* getImageStarfield () const { return mImageStarfield.get (); }
|
||||
/// Set image starfield, or null to disable.
|
||||
void setImageStarfield (ImageStarfield* obj);
|
||||
|
||||
/// Gets the current point starfield, or null if disabled.
|
||||
inline PointStarfield* getPointStarfield () const { return mPointStarfield.get (); }
|
||||
/// Set image starfield, or null to disable.
|
||||
void setPointStarfield (PointStarfield* obj);
|
||||
|
||||
/// Get ground fog; if enabled.
|
||||
inline GroundFog* getGroundFog () { return mGroundFog.get (); }
|
||||
/// Sets ground fog system, or null to disable.
|
||||
void setGroundFog (GroundFog *obj);
|
||||
|
||||
/// Get cloud system; or null if disabled.
|
||||
inline CloudSystem* getCloudSystem () { return mCloudSystem.get (); }
|
||||
/// Set cloud system; or null to disable.
|
||||
void setCloudSystem (CloudSystem *obj);
|
||||
|
||||
/// Get precipitation controller; or null if disabled.
|
||||
inline PrecipitationController* getPrecipitationController () { return mPrecipitationController.get (); }
|
||||
/// Set precipitation controller; or null to disable.
|
||||
void setPrecipitationController (PrecipitationController *obj);
|
||||
|
||||
/// Get depth composer; or null if disabled.
|
||||
inline DepthComposer* getDepthComposer () { return mDepthComposer.get (); }
|
||||
/// Set depth composer; or null to disable.
|
||||
void setDepthComposer (DepthComposer *obj);
|
||||
|
||||
/** Enables/disables Caelum managing standard Ogre::Scene fog.
|
||||
This makes CaelumSystem control standard Ogre::Scene fogging. It
|
||||
will use EXP2 fog with density from SkyColourModel.
|
||||
|
||||
Fog density multipliers are used; final scene fog density is:
|
||||
SceneMultiplier * GlobalMultiplier * SkyColourModel.GetFogDensity
|
||||
|
||||
When this is set to false it also disables all scene fog (but you
|
||||
control it afterwards).
|
||||
|
||||
@param value New value
|
||||
*/
|
||||
void setManageSceneFog (bool value);
|
||||
|
||||
/** Tells if Caelum is managing the fog or not.
|
||||
@return The value set in setManageSceneFog.
|
||||
*/
|
||||
bool getManageSceneFog () const;
|
||||
|
||||
/** Multiplier for scene fog density (default 1).
|
||||
This is an additional multiplier for Ogre::Scene fog density.
|
||||
This has no effect if getManageSceneFog is false.
|
||||
|
||||
Final scene fog density is:
|
||||
SceneMultiplier * GlobalMultiplier * SkyColourModel.GetFogDensity
|
||||
*/
|
||||
void setSceneFogDensityMultiplier (Real value);
|
||||
|
||||
/** Get the value set by setSceneFogDensityMultiplier.
|
||||
*/
|
||||
Real getSceneFogDensityMultiplier () const;
|
||||
|
||||
/** Set an additional multiplier for fog colour as it comes from SkyColourModel.
|
||||
* This is 0.7 by default; to be compatible with previous versions.
|
||||
*/
|
||||
inline void setSceneFogColourMultiplier (const Ogre::ColourValue& value) { mSceneFogColourMultiplier = value; }
|
||||
|
||||
/// See setSceneFogColourMultiplier.
|
||||
inline const Ogre::ColourValue getSceneFogColourMultiplier () const { return mSceneFogColourMultiplier; }
|
||||
|
||||
/** Multiplier for ground fog density (default 1).
|
||||
* This is an additional multiplier for Caelum::GroundFog DepthComposer ground fog density.
|
||||
*
|
||||
* Final ground fog density is:
|
||||
* GroundFogMultipler * GlobalMultiplier * SkyColourModel.GetFogDensity
|
||||
*/
|
||||
void setGroundFogDensityMultiplier (Real value);
|
||||
|
||||
/** Get the value set by setGroundFogDensityMultiplier.
|
||||
*/
|
||||
Real getGroundFogDensityMultiplier () const;
|
||||
|
||||
/** Set an additional multiplier for ground fog colour as it comes from SkyColourModel.
|
||||
* This is OgreColour::White by default; which has no effect.
|
||||
*/
|
||||
inline void setGroundFogColourMultiplier (const Ogre::ColourValue& value) { mGroundFogColourMultiplier = value; }
|
||||
|
||||
/// See setGroundFogColourMultiplier.
|
||||
inline const Ogre::ColourValue getGroundFogColourMultiplier () const { return mGroundFogColourMultiplier; }
|
||||
|
||||
/** Multiplier for global fog density (default 1).
|
||||
* This is an additional multiplier for fog density as received from
|
||||
* SkyColourModel. There are other multipliers you can tweak for
|
||||
* individual kinds of fog; but this is what you should change from
|
||||
* whatever "game logic" you might have.
|
||||
*/
|
||||
void setGlobalFogDensityMultiplier (Real value);
|
||||
|
||||
/** Get the value set by setSceneFogDensityMultiplier.
|
||||
*/
|
||||
Real getGlobalFogDensityMultiplier () const;
|
||||
|
||||
/** Set an additional multiplier for fog colour.
|
||||
* This will also affect stuff like clouds or precipitation. Careful!
|
||||
* This is OgreColour::White by default; which has no effect.
|
||||
*/
|
||||
inline void setGlobalFogColourMultiplier (const Ogre::ColourValue& value) { mGlobalFogColourMultiplier = value; }
|
||||
|
||||
/// See setGlobalFogColourMultiplier.
|
||||
inline const Ogre::ColourValue getGlobalFogColourMultiplier () const { return mGlobalFogColourMultiplier; }
|
||||
|
||||
/** Set this to true to have CaelumSystem manage the scene's ambient light.
|
||||
* The colour and AmbientMultiplier of the sun and moon are used.
|
||||
* This is false by default.
|
||||
*/
|
||||
inline void setManageAmbientLight (bool value) { mManageAmbientLight = value; }
|
||||
|
||||
/// Check if CaelumSystem is managing ambient lighting.
|
||||
inline bool getManageAmbientLight () const { return mManageAmbientLight; }
|
||||
|
||||
/** Set the minimum value for scene ambient lighting,
|
||||
* This is only used if getManageAmbientLight() is true.
|
||||
* By default this value is Ogre::ColourValue::Black, so it has no effect.
|
||||
*/
|
||||
inline void setMinimumAmbientLight (const Ogre::ColourValue &value) { mMinimumAmbientLight = value; }
|
||||
|
||||
/// @see setMinimumAmbientLight
|
||||
inline const Ogre::ColourValue getMinimumAmbientLight () const { return mMinimumAmbientLight; }
|
||||
|
||||
/** Ensure only one of caelum's light sources is active at a time (the brightest).
|
||||
* This uses SkyLight::setForceDisable to disable low-intensity lightsources.
|
||||
* Their contribution to ambient lighting is not affected.
|
||||
* This implies a single shadow caster.
|
||||
* This is disabled by default; and you can tweak light disabling by yourself.
|
||||
*/
|
||||
inline void setEnsureSingleLightSource (bool value) { mEnsureSingleLightSource = value; }
|
||||
|
||||
/// See setEnsureSingleLightSource
|
||||
inline bool getEnsureSingleLightSource () const { return mEnsureSingleLightSource; }
|
||||
|
||||
/** Ensure only one of caelum's light sources casts shadows (the brightest).
|
||||
* Disabled by default.
|
||||
*/
|
||||
inline void setEnsureSingleShadowSource (bool value) { mEnsureSingleShadowSource = value; }
|
||||
|
||||
/// See setEnsureSingleShadowSource
|
||||
inline bool getEnsureSingleShadowSource () const { return mEnsureSingleShadowSource; }
|
||||
|
||||
/** Gets the fog colour for a certain daytime.
|
||||
@param time The current time.
|
||||
@param sunDir The sun direction.
|
||||
@return The fog colour.
|
||||
*/
|
||||
Ogre::ColourValue getFogColour (Real time, const Ogre::Vector3 &sunDir);
|
||||
|
||||
/** Gets the fog density for a certain daytime.
|
||||
@param time The current time.
|
||||
@param sunDir The sun direction.
|
||||
@return The fog density.
|
||||
*/
|
||||
Real getFogDensity (Real time, const Ogre::Vector3 &sunDir);
|
||||
|
||||
/** Get the colour of the sun sphere.
|
||||
* This colour is used to draw the sun sphere in the sky.
|
||||
* @return The colour of the sun.
|
||||
*/
|
||||
Ogre::ColourValue getSunSphereColour (Real time, const Ogre::Vector3 &sunDir);
|
||||
|
||||
/** Gets the colour of sun light.
|
||||
* This color is used to illuminate the scene.
|
||||
* @return The colour of the sun's light
|
||||
*/
|
||||
Ogre::ColourValue getSunLightColour (Real time, const Ogre::Vector3 &sunDir);
|
||||
|
||||
/// Gets the colour of moon's body.
|
||||
Ogre::ColourValue getMoonBodyColour (const Ogre::Vector3 &moonDir);
|
||||
|
||||
/// Gets the colour of moon's light.
|
||||
Ogre::ColourValue getMoonLightColour (const Ogre::Vector3 &moonDir);
|
||||
|
||||
/// Set the sun gradients image.
|
||||
void setSkyGradientsImage (const Ogre::String &filename = DEFAULT_SKY_GRADIENTS_IMAGE);
|
||||
|
||||
/// Set the sun colours image.
|
||||
/// Sun colour is taken from this image.
|
||||
void setSunColoursImage (const Ogre::String &filename = DEFAULT_SUN_COLOURS_IMAGE);
|
||||
|
||||
/** Get the sun's direction at a certain time.
|
||||
* @param jday astronomical julian day.
|
||||
* @see UniversalClock for julian day calculations.
|
||||
*/
|
||||
const Ogre::Vector3 getSunDirection (LongReal jday);
|
||||
|
||||
/** Get the moon's direction at a certain time.
|
||||
* @param jday astronomical julian day.
|
||||
*/
|
||||
const Ogre::Vector3 getMoonDirection (LongReal jday);
|
||||
|
||||
/** Fake function to get the phase of the moon
|
||||
* @param jday Julian day
|
||||
* @return the phase of the moon; ranging from 0(full moon) to 2(new moon).
|
||||
* The calculations performed by this function are completely fake.
|
||||
* It's a triangle wave with a period of 28.5 days.
|
||||
*/
|
||||
const Ogre::Real getMoonPhase (LongReal jday);
|
||||
|
||||
private:
|
||||
/** Handle FrameListener::frameStarted to call updateSubcomponents every frame.
|
||||
* If you don't register CaelumSystem as a an ogre frame listener you have to
|
||||
* call updateSubcomponents yourself.
|
||||
*/
|
||||
virtual bool frameStarted (const Ogre::FrameEvent &e);
|
||||
|
||||
/** Event trigger called just before rendering a viewport in a render target Caelum is attached to.
|
||||
Useful to make objects follow every camera that renders a viewport in a certain render target.
|
||||
*/
|
||||
virtual void preViewportUpdate (const Ogre::RenderTargetViewportEvent &e);
|
||||
|
||||
/** Free all subcomponents, but not CaelumSystem itself. Can be called multiple times.
|
||||
* @param everything To destroy things that can't be rebuilt.
|
||||
*/
|
||||
void destroySubcomponents (bool everything);
|
||||
|
||||
public:
|
||||
/** Call setQueryFlags for all subcomponents now.
|
||||
*
|
||||
* This is not persistent; you can adjust the query masks of
|
||||
* individual objects afterwards. This also means you should call
|
||||
* this only after you created all other objects.
|
||||
*
|
||||
* Has no effect on compositor-based stuff (precipitation will still show up).
|
||||
*/
|
||||
void forceSubcomponentQueryFlags (uint mask);
|
||||
|
||||
/** Same as @see forceSubcomponentQueryMask; but for visibility
|
||||
*/
|
||||
void forceSubcomponentVisibilityFlags (uint mask);
|
||||
};
|
||||
}
|
||||
|
||||
#endif // CAELUM__CAELUM_SYSTEM_H
|
||||
@ -1,112 +0,0 @@
|
||||
/*
|
||||
This file is part of Caelum.
|
||||
See http://www.ogre3d.org/wiki/index.php/Caelum
|
||||
|
||||
Copyright (c) 2006-2008 Caelum team. See Contributors.txt for details.
|
||||
|
||||
Caelum is free software: you can redistribute it and/or modify
|
||||
it under the terms of the GNU Lesser General Public License as published
|
||||
by the Free Software Foundation, either version 3 of the License, or
|
||||
(at your option) any later version.
|
||||
|
||||
Caelum is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
GNU Lesser General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU Lesser General Public License
|
||||
along with Caelum. If not, see <http://www.gnu.org/licenses/>.
|
||||
*/
|
||||
|
||||
#ifndef CAELUM__CAMERA_BOUND_ELEMENT_H
|
||||
#define CAELUM__CAMERA_BOUND_ELEMENT_H
|
||||
|
||||
#include "CaelumPrerequisites.h"
|
||||
|
||||
namespace Caelum
|
||||
{
|
||||
/** A camera-bound element.
|
||||
*
|
||||
* This should be used as a base class for domes which follow the camera.
|
||||
* It is only meant to be used inside Caelum.
|
||||
*
|
||||
* By default this class work in autoradius mode; where it automatically
|
||||
* resizes itself for camera near/far clipping radius. It will correctly
|
||||
* handle infinite far clip planes.
|
||||
*
|
||||
* This is meant to be used with depth_check and depth_write off.
|
||||
* Trying to place an object "as far as possible" causes precision
|
||||
* troubles; and was removed in version 0.4.
|
||||
*
|
||||
* If far clip distance is finite the radius will be (near + far) / 2.
|
||||
* If far clip distance is infinite (0) the radius will be 10 * near/
|
||||
*/
|
||||
class CAELUM_EXPORT CameraBoundElement
|
||||
{
|
||||
private:
|
||||
/// Defines if the element has an automatic "far" radius or not.
|
||||
bool mAutoRadius;
|
||||
|
||||
public:
|
||||
/** Constructor. Sets auto radius to true.
|
||||
*/
|
||||
CameraBoundElement();
|
||||
|
||||
/// Virtual Destructor.
|
||||
virtual ~CameraBoundElement ();
|
||||
|
||||
/** Notify new camera conditions.
|
||||
* This method notifies that a new camera is about to be used, so
|
||||
* this element can follow it or perform other operations.
|
||||
* The default implementation calls setRadius if in autoRadius mode.
|
||||
* @param cam The new camera.
|
||||
*/
|
||||
virtual void notifyCameraChanged (Ogre::Camera *cam) = 0;
|
||||
|
||||
/** Forces the "far" size of the element to a specific radius.
|
||||
*
|
||||
* If greater than zero this disables AutoRadius mode and forces a
|
||||
* fixed radius. If this is negative or zero the radius is set
|
||||
* automatically in notifyCameraChanged.
|
||||
*
|
||||
* AutoRadius is turned on by default.
|
||||
*
|
||||
* @param radius The positive radius of the element, or a
|
||||
* negative/zero value for AutoRadius mode.
|
||||
*/
|
||||
void forceFarRadius (Ogre::Real radius);
|
||||
|
||||
/** Checks if this element is in auto-radius mode.
|
||||
* While in autoradius mode the element is automatically resized fit
|
||||
* between the near and far radius.
|
||||
*/
|
||||
bool getAutoRadius () const;
|
||||
|
||||
/** Re-enable auto-radius; if disabled.
|
||||
* Auto-radius is on by default; but can be disabled. This function
|
||||
* can turn it back on.
|
||||
*/
|
||||
void setAutoRadius ();
|
||||
|
||||
/** Camera distances multiplier for the far clipping distance.
|
||||
* This threshold will be multiplied with the far clipping distance,
|
||||
* if the camera doesn't use an infinite far clipping plane.
|
||||
*/
|
||||
static const Ogre::Real CAMERA_FAR_DISTANCE_MULTIPLIER;
|
||||
|
||||
/** Camera distances multiplier for the near clipping distance.
|
||||
* This threshold will be multiplied with the near clipping distance,
|
||||
* if the camera does use an infinite far clipping plane.
|
||||
*/
|
||||
static const Ogre::Real CAMERA_NEAR_DISTANCE_MULTIPLIER;
|
||||
|
||||
protected:
|
||||
/** Abstract method to set the radius for this elements
|
||||
* Derived classes should override this and resize their domes.
|
||||
* The actual radius for the dome is controlled in the base class.
|
||||
*/
|
||||
virtual void setFarRadius (Ogre::Real radius);
|
||||
};
|
||||
}
|
||||
|
||||
#endif // CAELUM__CAMERA_BOUND_ELEMENT_H
|
||||
@ -1,89 +0,0 @@
|
||||
/*
|
||||
This file is part of Caelum.
|
||||
See http://www.ogre3d.org/wiki/index.php/Caelum
|
||||
|
||||
Copyright (c) 2008 Caelum team. See Contributors.txt for details.
|
||||
|
||||
Caelum is free software: you can redistribute it and/or modify
|
||||
it under the terms of the GNU Lesser General Public License as published
|
||||
by the Free Software Foundation, either version 3 of the License, or
|
||||
(at your option) any later version.
|
||||
|
||||
Caelum is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
GNU Lesser General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU Lesser General Public License
|
||||
along with Caelum. If not, see <http://www.gnu.org/licenses/>.
|
||||
*/
|
||||
|
||||
#ifndef CAELUM__CLOUD_SYSTEM_H
|
||||
#define CAELUM__CLOUD_SYSTEM_H
|
||||
|
||||
#include "CaelumPrerequisites.h"
|
||||
|
||||
namespace Caelum
|
||||
{
|
||||
/** A cloud system is implemented by a number of cloud layers.
|
||||
* Different cloud layers could implement different kinds of clouds (cirrus, stratus).
|
||||
*/
|
||||
class CAELUM_EXPORT CloudSystem
|
||||
{
|
||||
public:
|
||||
CloudSystem (
|
||||
Ogre::SceneManager *sceneMgr,
|
||||
Ogre::SceneNode *cloudRoot);
|
||||
|
||||
~CloudSystem();
|
||||
|
||||
typedef std::vector<FlatCloudLayer*> LayerVector;
|
||||
|
||||
private:
|
||||
Ogre::SceneManager *mSceneMgr;
|
||||
Ogre::SceneNode *mCloudRoot;
|
||||
LayerVector mLayers;
|
||||
|
||||
public:
|
||||
/** Direct access to the layer vector.
|
||||
*/
|
||||
LayerVector& getLayerVector() { return mLayers; }
|
||||
|
||||
/// Clears all cloud layers.
|
||||
void clearLayers();
|
||||
|
||||
/// Create a new cloud layer with default settings at height 0.
|
||||
/// @return pointer to the new layer.
|
||||
FlatCloudLayer* createLayer();
|
||||
|
||||
/// Create a new cloud layer with default settings at a certain height.
|
||||
/// @return pointer to the new layer.
|
||||
FlatCloudLayer* createLayerAtHeight(Ogre::Real height);
|
||||
|
||||
/// Add new layer. Takes ownership of the layer.
|
||||
void addLayer(FlatCloudLayer* layer);
|
||||
|
||||
/// Get a pointer to a certain layer.
|
||||
inline FlatCloudLayer* getLayer(int index) { return mLayers[index]; }
|
||||
|
||||
/// Get the total number of layers.
|
||||
inline int getLayerCount() { return static_cast<int> (mLayers.size ()); }
|
||||
|
||||
/** Update function called every frame from high above.
|
||||
*/
|
||||
void update (
|
||||
Ogre::Real timePassed,
|
||||
const Ogre::Vector3 &sunDirection,
|
||||
const Ogre::ColourValue &sunLightColour,
|
||||
const Ogre::ColourValue &fogColour,
|
||||
const Ogre::ColourValue &sunSphereColour);
|
||||
|
||||
/// Similar to @see CaelumSystem::forceSubcomponentQueryFlags.
|
||||
virtual void forceLayerQueryFlags (uint flags);
|
||||
|
||||
/// Similar to @see CaelumSystem::forceSubcomponentVisibilityFlags.
|
||||
virtual void forceLayerVisibilityFlags (uint flags);
|
||||
};
|
||||
}
|
||||
|
||||
#endif // CAELUM__CLOUD_SYSTEM_H
|
||||
@ -1,280 +0,0 @@
|
||||
/*
|
||||
This file is part of Caelum.
|
||||
See http://www.ogre3d.org/wiki/index.php/Caelum
|
||||
|
||||
Copyright (c) 2008 Caelum team. See Contributors.txt for details.
|
||||
|
||||
Caelum is free software: you can redistribute it and/or modify
|
||||
it under the terms of the GNU Lesser General Public License as published
|
||||
by the Free Software Foundation, either version 3 of the License, or
|
||||
(at your option) any later version.
|
||||
|
||||
Caelum is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
GNU Lesser General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU Lesser General Public License
|
||||
along with Caelum. If not, see <http://www.gnu.org/licenses/>.
|
||||
*/
|
||||
|
||||
#ifndef CAELUM__DEPTH_COMPOSER_H
|
||||
#define CAELUM__DEPTH_COMPOSER_H
|
||||
|
||||
#include "CaelumPrerequisites.h"
|
||||
#include "FastGpuParamRef.h"
|
||||
|
||||
namespace Caelum
|
||||
{
|
||||
/** Compositor-based precipitation controller.
|
||||
* This class will add and control precipitation controllers to viewports.
|
||||
*
|
||||
* Compositors clone the composing materials. This controller will
|
||||
* register itself as a compositor listener and change the material in notifyMaterialSetup.
|
||||
*/
|
||||
class CAELUM_EXPORT DepthComposer
|
||||
{
|
||||
private:
|
||||
Ogre::SceneManager *mSceneMgr;
|
||||
|
||||
void onCompositorMaterialChanged ();
|
||||
const String& getCompositorName ();
|
||||
|
||||
protected:
|
||||
inline Ogre::SceneManager* getSceneManager() const { return mSceneMgr; }
|
||||
|
||||
friend class DepthComposerInstance;
|
||||
|
||||
public:
|
||||
DepthComposer(Ogre::SceneManager *sceneMgr);
|
||||
virtual ~DepthComposer();
|
||||
|
||||
void update ();
|
||||
|
||||
public:
|
||||
typedef std::map<Ogre::Viewport*, DepthComposerInstance*> ViewportInstanceMap;
|
||||
ViewportInstanceMap mViewportInstanceMap;
|
||||
|
||||
public:
|
||||
DepthComposerInstance* createViewportInstance(Ogre::Viewport* viewport);
|
||||
void destroyViewportInstance(Ogre::Viewport* viewport);
|
||||
DepthComposerInstance* getViewportInstance(Ogre::Viewport* viewport);
|
||||
void destroyAllViewportInstances();
|
||||
|
||||
private:
|
||||
bool mDebugDepthRender;
|
||||
|
||||
public:
|
||||
/// Enables drawing the depth buffer
|
||||
void setDebugDepthRender (bool value);
|
||||
bool getDebugDepthRender () const { return mDebugDepthRender; }
|
||||
|
||||
private:
|
||||
bool mSkyDomeHazeEnabled;
|
||||
Ogre::Vector3 mSunDirection;
|
||||
Ogre::ColourValue mHazeColour;
|
||||
|
||||
public:
|
||||
/// Enables skydome haze.
|
||||
void setSkyDomeHazeEnabled (bool value);
|
||||
bool getSkyDomeHazeEnabled () const { return mSkyDomeHazeEnabled; }
|
||||
|
||||
void setSunDirection (const Ogre::Vector3& value) { mSunDirection = value; }
|
||||
const Ogre::Vector3 getSunDirection () const { return mSunDirection; }
|
||||
|
||||
void setHazeColour (const Ogre::ColourValue& value) { mHazeColour = value; }
|
||||
const Ogre::ColourValue getHazeColour () const { return mHazeColour; }
|
||||
|
||||
private:
|
||||
bool mGroundFogEnabled;
|
||||
Real mGroundFogDensity;
|
||||
Real mGroundFogBaseLevel;
|
||||
Real mGroundFogVerticalDecay;
|
||||
Ogre::ColourValue mGroundFogColour;
|
||||
|
||||
public:
|
||||
/// Enables exponential ground fog.
|
||||
void setGroundFogEnabled (bool value);
|
||||
bool getGroundFogEnabled () const { return mGroundFogEnabled; }
|
||||
|
||||
/// Sets ground fog density
|
||||
void setGroundFogDensity (Real value) { mGroundFogDensity = value; }
|
||||
|
||||
/// Get ground fog density
|
||||
Real getGroundFogDensity () const { return mGroundFogDensity; }
|
||||
|
||||
/// Sets ground fog level
|
||||
/// At ground level fogginess is equal to GroundFogDensity
|
||||
void setGroundFogBaseLevel (Real value) { mGroundFogBaseLevel = value; }
|
||||
|
||||
/// Get ground fog density
|
||||
Real getGroundFogBaseLevel () const { return mGroundFogBaseLevel; }
|
||||
|
||||
/// Sets ground fog vertical decay
|
||||
void setGroundFogVerticalDecay (Real value) { mGroundFogVerticalDecay = value; }
|
||||
|
||||
/// Get ground fog density
|
||||
Real getGroundFogVerticalDecay () const { return mGroundFogVerticalDecay; }
|
||||
|
||||
/// Sets ground fog colour
|
||||
void setGroundFogColour (const Ogre::ColourValue& value) { mGroundFogColour = value; }
|
||||
|
||||
/// Get ground fog colour
|
||||
const Ogre::ColourValue getGroundFogColour () const { return mGroundFogColour; }
|
||||
};
|
||||
|
||||
/** Per-viewport instance of @see DepthComposer
|
||||
* This will create and control one ogre::CompositorInstance.
|
||||
*/
|
||||
class CAELUM_EXPORT DepthComposerInstance: private Ogre::CompositorInstance::Listener
|
||||
{
|
||||
private:
|
||||
DepthComposer* mParent;
|
||||
Ogre::Viewport* mViewport;
|
||||
Ogre::CompositorInstance* mCompInst;
|
||||
std::auto_ptr<DepthRenderer> mDepthRenderer;
|
||||
|
||||
virtual void notifyMaterialSetup(uint pass_id, Ogre::MaterialPtr &mat);
|
||||
virtual void notifyMaterialRender(uint pass_id, Ogre::MaterialPtr &mat);
|
||||
|
||||
struct Params {
|
||||
void setup(Ogre::GpuProgramParametersSharedPtr params);
|
||||
|
||||
Ogre::GpuProgramParametersSharedPtr fpParams;
|
||||
FastGpuParamRef invViewProjMatrix;
|
||||
FastGpuParamRef worldCameraPos;
|
||||
FastGpuParamRef groundFogDensity;
|
||||
FastGpuParamRef groundFogVerticalDecay;
|
||||
FastGpuParamRef groundFogBaseLevel;
|
||||
FastGpuParamRef groundFogColour;
|
||||
FastGpuParamRef sunDirection;
|
||||
FastGpuParamRef hazeColour;
|
||||
} mParams;
|
||||
|
||||
protected:
|
||||
/// Called from DepthComposer::update
|
||||
void _update ();
|
||||
|
||||
void addCompositor ();
|
||||
void removeCompositor ();
|
||||
bool isCompositorEnabled () { return mCompInst != 0; }
|
||||
|
||||
friend class DepthComposer;
|
||||
|
||||
public:
|
||||
/// Get parent DepthComposer; with all the interesting parameters.
|
||||
DepthComposer* getParent() const { return mParent; }
|
||||
|
||||
/// Get the viewport this instance is attached to.
|
||||
Ogre::Viewport* getViewport() const { return mViewport; }
|
||||
|
||||
/// Get compositor instance; attached to the viewport.
|
||||
Ogre::CompositorInstance* getCompositorInstance() const { return mCompInst; }
|
||||
|
||||
/** Get the underlying depth renderer.
|
||||
* Allow the user to tweak the depth renderer.
|
||||
*/
|
||||
Caelum::DepthRenderer* getDepthRenderer () const { return mDepthRenderer.get(); }
|
||||
|
||||
DepthComposerInstance(DepthComposer* parent, Ogre::Viewport* view);
|
||||
virtual ~DepthComposerInstance();
|
||||
};
|
||||
|
||||
/** Render the depth buffer to a texture.
|
||||
*
|
||||
* This class tries to be as generic and flexible as possible; but it
|
||||
* is currently only used by the depth composer.
|
||||
*/
|
||||
class CAELUM_EXPORT DepthRenderer: private Ogre::RenderQueue::RenderableListener
|
||||
{
|
||||
private:
|
||||
Ogre::Viewport* mMasterViewport;
|
||||
Ogre::Viewport* mDepthRenderViewport;
|
||||
Ogre::TexturePtr mDepthRenderTexture;
|
||||
bool mDepthRenderingNow;
|
||||
Ogre::MaterialPtr mDepthRenderMaterial;
|
||||
|
||||
// Override materials during all rendering.
|
||||
#if OGRE_VERSION < 0x00010600
|
||||
virtual bool renderableQueued(
|
||||
Ogre::Renderable* rend,
|
||||
Ogre::uint8 groupId,
|
||||
Ogre::ushort priority,
|
||||
Ogre::Technique** ppTech);
|
||||
#else
|
||||
virtual bool renderableQueued(
|
||||
Ogre::Renderable* rend,
|
||||
Ogre::uint8 groupId,
|
||||
Ogre::ushort priority,
|
||||
Ogre::Technique** ppTech,
|
||||
Ogre::RenderQueue* pQueue);
|
||||
#endif // OGRE_VERSION
|
||||
inline Ogre::Material* getDepthRenderMaterial() const { return mDepthRenderMaterial.get(); }
|
||||
|
||||
int mMinRenderGroupId;
|
||||
int mMaxRenderGroupId;
|
||||
int mViewportVisibilityMask;
|
||||
|
||||
public:
|
||||
DepthRenderer (Ogre::Viewport* viewport);
|
||||
~DepthRenderer ();
|
||||
|
||||
inline Ogre::Viewport* getMasterViewport() { return mMasterViewport; }
|
||||
inline Ogre::Texture* getDepthRenderTexture () { return mDepthRenderTexture.get(); }
|
||||
inline Ogre::Viewport* getDepthRenderViewport () { return mDepthRenderViewport; }
|
||||
inline Ogre::RenderTexture* getDepthRenderTarget () {
|
||||
return mDepthRenderTexture->getBuffer()->getRenderTarget ();
|
||||
}
|
||||
|
||||
/// Render the depth buffer now!
|
||||
void update ();
|
||||
|
||||
/** Render only the render groups in a certain range.
|
||||
* Call this to only render objects in certain render queue groups.
|
||||
* The range is inclusive.
|
||||
* This is a very primitive sort of filter.
|
||||
*/
|
||||
void setRenderGroupRangeFilter (int minGroup, int maxGroup);
|
||||
|
||||
/// @see setRenderGroupRangeFilter
|
||||
int getRenderGroupRangeFilterMin () { return mMinRenderGroupId; }
|
||||
int getRenderGroupRangeFilterMax () { return mMaxRenderGroupId; }
|
||||
|
||||
/** Disable the effects of @see setRenderGroupRangeFilter
|
||||
*/
|
||||
void disableRenderGroupRangeFilter ();
|
||||
|
||||
/** Query mask for the depth rendering viewport.
|
||||
* Enforces on every update ();
|
||||
*/
|
||||
void setViewportVisibilityMask (uint value) { mViewportVisibilityMask = value; }
|
||||
uint getViewportVisibilityMask () { return mViewportVisibilityMask; }
|
||||
void disableViewportVisibilityMask () { mViewportVisibilityMask = ~0; }
|
||||
|
||||
public:
|
||||
/** If true then use a user-supplied material scheme which outputs depth.
|
||||
*
|
||||
* The depth output of most materials is obvious and can be guessed most of the time.
|
||||
* When that fails you can provide a custom material scheme for certain materials which
|
||||
* renders the depth buffer.
|
||||
*
|
||||
* This is enabled by default for a scheme called CaelumDepth.
|
||||
*/
|
||||
inline void setUseCustomDepthScheme (bool value) { mUseCustomDepthScheme = value; }
|
||||
inline bool getUseCustomDepthScheme () { return mUseCustomDepthScheme; }
|
||||
|
||||
/** Set the name of the custom depth scheme (default is CaelumDepth).
|
||||
*/
|
||||
inline void setCustomDepthSchemeName (const Ogre::String& value) { mCustomDepthSchemeName = value; }
|
||||
inline const Ogre::String& getCustomDepthSchemeName () { return mCustomDepthSchemeName; }
|
||||
|
||||
/// Default name of the custom scheme.
|
||||
static const String DEFAULT_CUSTOM_DEPTH_SCHEME_NAME;
|
||||
|
||||
private:
|
||||
bool mUseCustomDepthScheme;
|
||||
Ogre::String mCustomDepthSchemeName;
|
||||
};
|
||||
}
|
||||
|
||||
#endif // CAELUM__DEPTH_COMPOSER_H
|
||||
@ -1,143 +0,0 @@
|
||||
/*
|
||||
This file is part of Caelum.
|
||||
See http://www.ogre3d.org/wiki/index.php/Caelum
|
||||
|
||||
Copyright (c) 2009 Caelum team. See Contributors.txt for details.
|
||||
|
||||
Caelum is free software: you can redistribute it and/or modify
|
||||
it under the terms of the GNU Lesser General Public License as published
|
||||
by the Free Software Foundation, either version 3 of the License, or
|
||||
(at your option) any later version.
|
||||
|
||||
Caelum is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
GNU Lesser General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU Lesser General Public License
|
||||
along with Caelum. If not, see <http://www.gnu.org/licenses/>.
|
||||
*/
|
||||
|
||||
#ifndef CAELUM__FAST_GPU_PARAM_REF_H
|
||||
#define CAELUM__FAST_GPU_PARAM_REF_H
|
||||
|
||||
#include "CaelumPrerequisites.h"
|
||||
|
||||
namespace Caelum
|
||||
{
|
||||
/** @file */
|
||||
|
||||
/** Controls if FastGpuParamRef checks pointer match when setting.
|
||||
* This setting trades safety for performance. By default it's equal to OGRE_DEBUG_MODE.
|
||||
*/
|
||||
#define CAELUM_DEBUG_PARAM_REF OGRE_DEBUG_MODE
|
||||
|
||||
/** An optimized reference to a gpu shared parameter.
|
||||
*
|
||||
* Profiling shows that GpuProgramParameters::_findNamedConstantDefinition is not free.
|
||||
*
|
||||
* This class avoids hash lookups when updating. It's uses no additional
|
||||
* memory than if you were to implement the same thing manually.
|
||||
*
|
||||
* You must also keep the matching Ogre::GpuProgramParametersSharedPtr
|
||||
* and send it whenever you call FastGpuParamRef::set. This is required
|
||||
* to save memory in release mode. Debug mode checks the pointer you
|
||||
* pass to set is the same as the pointer you called bind on; but uses more memory.
|
||||
*
|
||||
* Also; please note that fetching gpu params from a material every frame is not free either.
|
||||
*/
|
||||
class CAELUM_EXPORT FastGpuParamRef
|
||||
{
|
||||
public:
|
||||
/// Default constructor. Starts as unbound
|
||||
FastGpuParamRef(): mPhysicalIndex(InvalidPhysicalIndex)
|
||||
{
|
||||
// mParams needs no initialization; SharedPtrs start as 0.
|
||||
}
|
||||
|
||||
/// Create and bind.
|
||||
FastGpuParamRef(Ogre::GpuProgramParametersSharedPtr paramsPtr, const Ogre::String& name);
|
||||
|
||||
/** Bind to a certain parameter.
|
||||
*
|
||||
* @param paramsPtr params to bind to. Can't be null; you must unbind explicitly.
|
||||
* @param name The name of the parameter to bind.
|
||||
* @param throwIfNotFound Argument to GpuProgramParameters::_findNamedConstantDefinition.
|
||||
*
|
||||
* If throwIfNotFound is false (the default) missing parameters are
|
||||
* ignored and the param ref will remand unbound. Calling set will
|
||||
* then have no effect.
|
||||
*/
|
||||
void bind(
|
||||
Ogre::GpuProgramParametersSharedPtr paramsPtr,
|
||||
const Ogre::String& name,
|
||||
bool throwIfNotFound = false);
|
||||
|
||||
/** Unbind ParamRef.
|
||||
*
|
||||
* If CAELUM_DEBUG_PARAM_REF is 1 this will also release the hold
|
||||
* on GpuProgramParametersSharedPtr.
|
||||
*/
|
||||
void unbind();
|
||||
|
||||
/// Return if this param ref is bound to an actual param.
|
||||
inline bool isBound() const { return mPhysicalIndex != InvalidPhysicalIndex; }
|
||||
|
||||
/// Return the physical index. Only valid if this->isBound().
|
||||
inline size_t getPhysicalIndex () const { return mPhysicalIndex; }
|
||||
|
||||
protected:
|
||||
/** Set the value. No effect if !this->isBound()
|
||||
*
|
||||
* @param params Parameter pointer. Can't be null
|
||||
* @param arg Argument to set.
|
||||
*
|
||||
* Will check params pointer matches the bound pointer if #CAELUM_DEBUG_PARAM_REF.
|
||||
* Otherwise a mismatched params pointer can result in memory corruption.
|
||||
*/
|
||||
template<typename ArgumentT>
|
||||
inline void doSet(const Ogre::GpuProgramParametersSharedPtr& params, ArgumentT arg) const {
|
||||
#if CAELUM_DEBUG_PARAM_REF
|
||||
assert(params.getPointer() == mParams.getPointer());
|
||||
#endif
|
||||
assert(!params.isNull());
|
||||
if (mPhysicalIndex != InvalidPhysicalIndex) {
|
||||
params->_writeRawConstant(mPhysicalIndex, arg);
|
||||
}
|
||||
}
|
||||
|
||||
template<typename ArgumentT>
|
||||
inline void doSet(const Ogre::GpuProgramParametersSharedPtr& params, ArgumentT arg, size_t count) const {
|
||||
#if CAELUM_DEBUG_PARAM_REF
|
||||
assert(params.getPointer() == mParams.getPointer());
|
||||
#endif
|
||||
assert(!params.isNull());
|
||||
if (mPhysicalIndex != InvalidPhysicalIndex) {
|
||||
params->_writeRawConstant(mPhysicalIndex, arg, count);
|
||||
}
|
||||
}
|
||||
|
||||
public:
|
||||
/// @copydoc FastGpuParamRef::doSet
|
||||
inline void set(const Ogre::GpuProgramParametersSharedPtr& params, int val) const { doSet<int>(params, val); }
|
||||
/// @copydoc FastGpuParamRef::doSet
|
||||
inline void set(const Ogre::GpuProgramParametersSharedPtr& params, Ogre::Real val) const { doSet<Ogre::Real>(params, val); }
|
||||
/// @copydoc FastGpuParamRef::doSet
|
||||
inline void set(const Ogre::GpuProgramParametersSharedPtr& params, const Ogre::Vector3& val) const { doSet<const Ogre::Vector3&>(params, val); }
|
||||
/// @copydoc FastGpuParamRef::doSet
|
||||
inline void set(const Ogre::GpuProgramParametersSharedPtr& params, const Ogre::Vector4& val) const { doSet<const Ogre::Vector4&>(params, val); }
|
||||
/// @copydoc FastGpuParamRef::doSet
|
||||
inline void set(const Ogre::GpuProgramParametersSharedPtr& params, const Ogre::ColourValue& val) const { doSet<const Ogre::ColourValue&>(params, val); }
|
||||
/// @copydoc FastGpuParamRef::doSet
|
||||
inline void set(const Ogre::GpuProgramParametersSharedPtr& params, const Ogre::Matrix4& val) const { doSet<const Ogre::Matrix4*>(params, &val, 1); }
|
||||
|
||||
private:
|
||||
#if CAELUM_DEBUG_PARAM_REF
|
||||
Ogre::GpuProgramParametersSharedPtr mParams;
|
||||
#endif
|
||||
static const size_t InvalidPhysicalIndex = 0xFFFFFFFF;
|
||||
size_t mPhysicalIndex;
|
||||
};
|
||||
}
|
||||
|
||||
#endif /* CAELUM__FAST_GPU_PARAM_REF_H */
|
||||
@ -1,366 +0,0 @@
|
||||
/*
|
||||
This file is part of Caelum.
|
||||
See http://www.ogre3d.org/wiki/index.php/Caelum
|
||||
|
||||
Copyright (c) 2008 Caelum team. See Contributors.txt for details.
|
||||
|
||||
Caelum is free software: you can redistribute it and/or modify
|
||||
it under the terms of the GNU Lesser General Public License as published
|
||||
by the Free Software Foundation, either version 3 of the License, or
|
||||
(at your option) any later version.
|
||||
|
||||
Caelum is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
GNU Lesser General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU Lesser General Public License
|
||||
along with Caelum. If not, see <http://www.gnu.org/licenses/>.
|
||||
*/
|
||||
|
||||
#ifndef CAELUM__FLAT_CLOUD_LAYER_H
|
||||
#define CAELUM__FLAT_CLOUD_LAYER_H
|
||||
|
||||
#include "CaelumPrerequisites.h"
|
||||
#include "InternalUtilities.h"
|
||||
#include "PrivatePtr.h"
|
||||
#include "FastGpuParamRef.h"
|
||||
|
||||
namespace Caelum
|
||||
{
|
||||
/** A flat cloud layer; drawn as a simple plane.
|
||||
* Supports movement and variable cloud cover.
|
||||
*
|
||||
* There are significant incompatible difference between this and the
|
||||
* LayeredClouds from version 0.3. This implementation of clouds is
|
||||
* positioned in world space while the old implementation was a curved
|
||||
* plane moving with the camera. It is not possible to perfectly simulate
|
||||
* the older implementation.
|
||||
*
|
||||
* @note This is tighly integrated with LayeredCloud.cg and LayeredClouds.material.
|
||||
*/
|
||||
class CAELUM_EXPORT FlatCloudLayer
|
||||
{
|
||||
public:
|
||||
FlatCloudLayer(
|
||||
Ogre::SceneManager *sceneMgr,
|
||||
Ogre::SceneNode *cloudRoot);
|
||||
|
||||
~FlatCloudLayer();
|
||||
|
||||
/** Update function called each frame from above.
|
||||
* This can be reproduced with calls to other public functions.
|
||||
*/
|
||||
void update (
|
||||
Ogre::Real timePassed,
|
||||
const Ogre::Vector3 &sunDirection,
|
||||
const Ogre::ColourValue &sunLightColour,
|
||||
const Ogre::ColourValue &fogColour,
|
||||
const Ogre::ColourValue &sunSphereColour);
|
||||
|
||||
/// Advance cloud animation (the time part of FlatCloudLayer::update).
|
||||
void advanceAnimation (Ogre::Real timePassed);
|
||||
|
||||
/** Reset most tweak settings to their default values
|
||||
*/
|
||||
void reset ();
|
||||
|
||||
private:
|
||||
Ogre::Vector2 mCloudSpeed;
|
||||
Ogre::Vector2 mCloudMassOffset;
|
||||
Ogre::Vector2 mCloudDetailOffset;
|
||||
|
||||
// Set texture offsets.
|
||||
// Animated every frame.
|
||||
void setCloudMassOffset(const Ogre::Vector2 &cloudMassOffset);
|
||||
void setCloudDetailOffset(const Ogre::Vector2 &cloudDetailOffset);
|
||||
|
||||
public:
|
||||
/** Sets cloud movement speed.
|
||||
* @param cloudSpeed Cloud movement speed.
|
||||
*/
|
||||
void setCloudSpeed (const Ogre::Vector2 &cloudSpeed);
|
||||
|
||||
/** Gets cloud movement speed.
|
||||
* @param cloudSpeed Cloud movement speed.
|
||||
*/
|
||||
const Ogre::Vector2 getCloudSpeed () const { return mCloudSpeed; }
|
||||
|
||||
private:
|
||||
Ogre::Vector3 mSunDirection;
|
||||
Ogre::ColourValue mSunLightColour;
|
||||
Ogre::ColourValue mSunSphereColour;
|
||||
Ogre::ColourValue mFogColour;
|
||||
|
||||
public:
|
||||
void setSunDirection(const Ogre::Vector3 &sunDirection);
|
||||
void setSunLightColour(const Ogre::ColourValue &sunLightColour);
|
||||
void setSunSphereColour(const Ogre::ColourValue &sunSphereColour);
|
||||
void setFogColour(const Ogre::ColourValue &fogColour);
|
||||
const Ogre::Vector3 getSunDirection () const;
|
||||
const Ogre::ColourValue getSunLightColour () const;
|
||||
const Ogre::ColourValue getSunSphereColour () const;
|
||||
const Ogre::ColourValue getFogColour () const;
|
||||
|
||||
private:
|
||||
/// Pointer to scene manager.
|
||||
Ogre::SceneManager *mSceneMgr;
|
||||
|
||||
// Note: objects are destroyed in reverse order of declaration.
|
||||
// This means that objects must be ordered by dependency.
|
||||
|
||||
/// Cloned cloud material.
|
||||
PrivateMaterialPtr mMaterial;
|
||||
|
||||
struct Params
|
||||
{
|
||||
void setup(Ogre::GpuProgramParametersSharedPtr fpParams, Ogre::GpuProgramParametersSharedPtr vpParams);
|
||||
|
||||
Ogre::GpuProgramParametersSharedPtr vpParams;
|
||||
Ogre::GpuProgramParametersSharedPtr fpParams;
|
||||
|
||||
FastGpuParamRef cloudCoverageThreshold;
|
||||
FastGpuParamRef cloudMassOffset;
|
||||
FastGpuParamRef cloudDetailOffset;
|
||||
FastGpuParamRef cloudMassBlend;
|
||||
FastGpuParamRef vpSunDirection;
|
||||
FastGpuParamRef fpSunDirection;
|
||||
FastGpuParamRef sunLightColour;
|
||||
FastGpuParamRef sunSphereColour;
|
||||
FastGpuParamRef fogColour;
|
||||
FastGpuParamRef layerHeight;
|
||||
FastGpuParamRef cloudUVFactor;
|
||||
FastGpuParamRef heightRedFactor;
|
||||
FastGpuParamRef nearFadeDist;
|
||||
FastGpuParamRef farFadeDist;
|
||||
FastGpuParamRef fadeDistMeasurementVector;
|
||||
} mParams;
|
||||
|
||||
private:
|
||||
PrivateMeshPtr mMesh;
|
||||
PrivateSceneNodePtr mNode;
|
||||
PrivateEntityPtr mEntity;
|
||||
|
||||
// Mesh parameters.
|
||||
bool mMeshDirty;
|
||||
Real mMeshWidth, mMeshHeight;
|
||||
int mMeshWidthSegments, mMeshHeightSegments;
|
||||
|
||||
public:
|
||||
/** Regenerate the plane mesh and recreate entity.
|
||||
* This automatically happens in update.
|
||||
*/
|
||||
void _ensureGeometry();
|
||||
|
||||
/** Regenerate the plane mesh and recreate entity.
|
||||
* This automatically happens when mesh parameters are changed.
|
||||
*/
|
||||
void _invalidateGeometry();
|
||||
|
||||
/** Reset all mesh parameters.
|
||||
*/
|
||||
void setMeshParameters (
|
||||
Real meshWidth, Real meshHeight,
|
||||
int meshWidthSegments, int meshHeightSegments);
|
||||
|
||||
/// @see setMeshParameters
|
||||
inline void setMeshWidth (Real value) { mMeshWidth = value; _invalidateGeometry (); }
|
||||
inline void setMeshHeight (Real value) { mMeshHeight = value; _invalidateGeometry (); }
|
||||
inline void setMeshWidthSegments (int value) { mMeshWidthSegments = value; _invalidateGeometry (); }
|
||||
inline void setMeshHeightSegments (int value) { mMeshHeightSegments = value; _invalidateGeometry (); }
|
||||
inline Real getMeshWidth () const { return mMeshWidth; }
|
||||
inline Real getMeshHeight () const { return mMeshHeight; }
|
||||
inline int getMeshWidthSegments () const { return mMeshWidthSegments; }
|
||||
inline int getMeshHeightSegments () const { return mMeshHeightSegments; }
|
||||
|
||||
private:
|
||||
/// Lookup used for cloud coverage, @see setCloudCoverLookup.
|
||||
std::auto_ptr<Ogre::Image> mCloudCoverLookup;
|
||||
|
||||
/// Filename of mCloudCoverLookup
|
||||
Ogre::String mCloudCoverLookupFileName;
|
||||
|
||||
/// Value passed to setCloudCover (before lookup).
|
||||
Ogre::Real mCloudCover;
|
||||
|
||||
public:
|
||||
/** Sets cloud cover, between 0 (completely clear) and 1 (completely covered)
|
||||
* @param cloudCover Cloud cover between 0 and 1
|
||||
*/
|
||||
void setCloudCover (const Ogre::Real cloudCover);
|
||||
|
||||
/** Gets the current cloud cover.
|
||||
* @return Cloud cover, between 0 and 1
|
||||
*/
|
||||
inline Ogre::Real getCloudCover () const { return mCloudCover; }
|
||||
|
||||
/** Set the image used to lookup the cloud coverage threshold.
|
||||
* This image is used to calculate the cloud coverage threshold
|
||||
* based on the desired cloud cover.
|
||||
*
|
||||
* The cloud coverage threshold is substracted from cloud intensity
|
||||
* at any point; to generate fewer or more clouds. That threshold is
|
||||
* not linear, a lookup is required to ensure that setCloudCover(0.1)
|
||||
* will actually have 10% the clouds at setCloudCover(1).
|
||||
*
|
||||
* The lookup is the inverse of the sum on the histogram, and was
|
||||
* calculated with a small hacky tool.
|
||||
*/
|
||||
void setCloudCoverLookup (const Ogre::String& fileName);
|
||||
|
||||
/** Get the filename of the cloud cover lookup image.
|
||||
* This returns the value set by setCloudCoverLookup or an empty
|
||||
* string if disabled.
|
||||
*/
|
||||
const Ogre::String getCloudCoverLookupFileName () const;
|
||||
|
||||
/** Disable any cloud cover lookup.
|
||||
* @see setCloudCoverLookup.
|
||||
*/
|
||||
void disableCloudCoverLookup ();
|
||||
|
||||
private:
|
||||
Ogre::Real mCloudCoverVisibilityThreshold;
|
||||
|
||||
protected:
|
||||
/** Enforce setCloudCoverVisibilityThreshold.
|
||||
*/
|
||||
void _updateVisibilityThreshold ();
|
||||
|
||||
public:
|
||||
/// Get cloud cover visiblity threshold.
|
||||
/// Beneath this cloud coverage nothing is drawn anymore.
|
||||
Ogre::Real getCloudCoverVisibilityThreshold () const { return mCloudCoverVisibilityThreshold; }
|
||||
|
||||
/** Set cloud cover visiblity threshold.
|
||||
*
|
||||
* Beneath this cloud coverage nothing is drawn anymore.
|
||||
* Default value is very very low (0.001). All this does is save you from
|
||||
* destroying/recreating layers when they're too thin to bother drawing.
|
||||
*/
|
||||
void setCloudCoverVisibilityThreshold (const Ogre::Real value);
|
||||
|
||||
private:
|
||||
/// Height of this cloud layer; equal to node's y position.
|
||||
Ogre::Real mHeight;
|
||||
|
||||
public:
|
||||
/** Set the height of the cloud layer.
|
||||
* @param height In world units above the cloud root node.
|
||||
*/
|
||||
void setHeight(Ogre::Real height);
|
||||
|
||||
/** Get the height of the cloud layer.
|
||||
* @return height In world units above the cloud root node.
|
||||
*/
|
||||
Ogre::Real getHeight() const;
|
||||
|
||||
private:
|
||||
/// Current cloud blend position; from 0 to mNoiseTextureNames.size()
|
||||
Ogre::Real mCloudBlendPos;
|
||||
|
||||
/// Current index in the set of textures.
|
||||
/// Cached to avoid setting textures every frame.
|
||||
int mCurrentTextureIndex;
|
||||
|
||||
/// Time required to blend two cloud shapes.
|
||||
Ogre::Real mCloudBlendTime;
|
||||
|
||||
/// Names of noise textures.
|
||||
std::vector<String> mNoiseTextureNames;
|
||||
|
||||
public:
|
||||
/** Sets the time it takes to blend two cloud shaped together, in seconds.
|
||||
* This will also reset the animation at the current time.
|
||||
* @param value Cloud shape blend time in seconds
|
||||
*/
|
||||
void setCloudBlendTime (const Ogre::Real value);
|
||||
|
||||
/** Gets the time it takes to blend two cloud shaped together, in seconds.
|
||||
* @return Cloud shape blend time in seconds
|
||||
*/
|
||||
Ogre::Real getCloudBlendTime () const;
|
||||
|
||||
/** Set the current blending position; between noise textures.
|
||||
* Integer values are used for single textures. Float values blend between two textures.
|
||||
* Values outside [0, textureCount) are wrapped around.
|
||||
* @param value New cloud blending position
|
||||
*/
|
||||
void setCloudBlendPos (const Ogre::Real value);
|
||||
|
||||
/// @see setCloudBlendPos
|
||||
Ogre::Real getCloudBlendPos () const;
|
||||
|
||||
private:
|
||||
Ogre::Real mCloudUVFactor;
|
||||
|
||||
public:
|
||||
/** Cloud texture coordinates are multiplied with this.
|
||||
* Higher values result in more spread-out clouds.
|
||||
* Very low value result in ugly texture repeats.
|
||||
*/
|
||||
void setCloudUVFactor (const Ogre::Real value);
|
||||
/// @see setCloudUVFactor
|
||||
inline Ogre::Real getCloudUVFactor () const { return mCloudUVFactor; }
|
||||
|
||||
private:
|
||||
Ogre::Real mHeightRedFactor;
|
||||
|
||||
public:
|
||||
/** High-altitude clouds are tinted red in the evening.
|
||||
* Higher values attenuate the effect.
|
||||
*/
|
||||
void setHeightRedFactor (const Ogre::Real value);
|
||||
/// @see setCloudUVFactor
|
||||
Ogre::Real getHeightRedFactor () const { return mHeightRedFactor; }
|
||||
|
||||
private:
|
||||
Ogre::Real mNearFadeDist;
|
||||
Ogre::Real mFarFadeDist;
|
||||
Ogre::Vector3 mFadeDistMeasurementVector;
|
||||
|
||||
public:
|
||||
/** Cloud fade distances.
|
||||
*
|
||||
* These are measured horizontally in meters (height is not used).
|
||||
*
|
||||
* The effect is a fade based on alpha blending which occurs between
|
||||
* nearValue and farValue. After farValue nothing is visibile from
|
||||
* this layer.
|
||||
*
|
||||
* Default values are 10000 and 140000
|
||||
*/
|
||||
void setFadeDistances (Ogre::Real nearValue, Ogre::Real farValue);
|
||||
|
||||
/// Set only near fade distance (see setFadeDistances).
|
||||
void setNearFadeDist (const Ogre::Real value);
|
||||
/// Get near fade distance (see setFadeDistances).
|
||||
Ogre::Real getNearFadeDist () const { return mNearFadeDist; }
|
||||
|
||||
/// Set only far fade distance (see setFadeDistances).
|
||||
void setFarFadeDist (const Ogre::Real value);
|
||||
/// Get fade distance (see setFadeDistances).
|
||||
Ogre::Real getFarFadeDist () const { return mFarFadeDist; }
|
||||
|
||||
/** Set on which components is the fade distance measured.
|
||||
*
|
||||
* Default is Vector3(0, 1, 1) which measures fade distance
|
||||
* horizontally in caelum's default assumed coordinate system.
|
||||
*
|
||||
* If you're in a Z-up system you probably want to set this to (1, 1, 0).
|
||||
*
|
||||
* Fade distance is always measured relative to the camera.
|
||||
*/
|
||||
void setFadeDistMeasurementVector (const Ogre::Vector3& value);
|
||||
/// Get the value set by setFadeDistMeasurementVector.
|
||||
const Ogre::Vector3 getFadeDistMeasurementVector () const { return mFadeDistMeasurementVector; }
|
||||
|
||||
public:
|
||||
void setQueryFlags (uint flags) { mEntity->setQueryFlags (flags); }
|
||||
uint getQueryFlags () const { return mEntity->getQueryFlags (); }
|
||||
void setVisibilityFlags (uint flags) { mEntity->setVisibilityFlags (flags); }
|
||||
uint getVisibilityFlags () const { return mEntity->getVisibilityFlags (); }
|
||||
};
|
||||
}
|
||||
|
||||
#endif // CAELUM__FLAT_CLOUD_LAYER_H
|
||||
@ -1,202 +0,0 @@
|
||||
/*
|
||||
This file is part of Caelum.
|
||||
See http://www.ogre3d.org/wiki/index.php/Caelum
|
||||
|
||||
Copyright (c) 2006-2007 Caelum team. See Contributors.txt for details.
|
||||
|
||||
Caelum is free software: you can redistribute it and/or modify
|
||||
it under the terms of the GNU Lesser General Public License as published
|
||||
by the Free Software Foundation, either version 3 of the License, or
|
||||
(at your option) any later version.
|
||||
|
||||
Caelum is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
GNU Lesser General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU Lesser General Public License
|
||||
along with Caelum. If not, see <http://www.gnu.org/licenses/>.
|
||||
*/
|
||||
|
||||
#ifndef GROUNDFOG_H
|
||||
#define GROUNDFOG_H
|
||||
|
||||
#include "CaelumPrerequisites.h"
|
||||
#include "CameraBoundElement.h"
|
||||
#include "PrivatePtr.h"
|
||||
#include "FastGpuParamRef.h"
|
||||
|
||||
namespace Caelum
|
||||
{
|
||||
/** Exponential ground fog system implementation.
|
||||
*
|
||||
* This class controls CaelumGroundFog passes in a potentially large number
|
||||
* of materials, changing shader program parameters. This class keeps a list
|
||||
* of passes to control; which can be build based on pass name.
|
||||
*
|
||||
* This simulates a field of fog where "absorption" at a certain point is
|
||||
* exp(-verticalDecay * (h - fogLevel)). This absorption is multiplicative,
|
||||
* the total fog alpha is e^(-density * absorption_on_view_path).
|
||||
*
|
||||
* You can set verticalDecay to 0 and get standard GL_EXP fog. Don't actually
|
||||
* do that though because you'll get a division by 0.
|
||||
*
|
||||
* @note: This is deprecated starting from Caelum 0.4. The DepthComposer class
|
||||
* provides similar functionality with less intrusion on your materials.
|
||||
*/
|
||||
class CAELUM_EXPORT GroundFog: public CameraBoundElement
|
||||
{
|
||||
public:
|
||||
static const Ogre::String DEFAULT_PASS_NAME;
|
||||
|
||||
/** Constructor.
|
||||
*/
|
||||
GroundFog (Ogre::SceneManager *scene,
|
||||
Ogre::SceneNode *caelumRootNode,
|
||||
const Ogre::String &domeMaterialName = "CaelumGroundFogDome",
|
||||
const Ogre::String &domeEntityName = "CaelumGroundFogDome");
|
||||
|
||||
/** Virtual destructor.
|
||||
*/
|
||||
virtual ~GroundFog ();
|
||||
|
||||
/** Typedef for easier manipulation of a set of Passes.
|
||||
*/
|
||||
typedef std::set<Ogre::Pass *> PassSet;
|
||||
|
||||
/** Get the set of currently controlled passes.
|
||||
* This is provided if you really want to change the set by hand.
|
||||
* You should call forceUpdate after modifying this set.
|
||||
*/
|
||||
PassSet& getPasses();
|
||||
|
||||
/** Get the set of currently controlled passes.
|
||||
* This is a const overload which doesn't let you modify the
|
||||
* underlying collection.
|
||||
*/
|
||||
const PassSet& getPasses () const;
|
||||
|
||||
/** Find caelum fog passes to control by name.
|
||||
* By default this looks for passes called "CaleumGroundFog".
|
||||
* @note This calls forceUpdate()
|
||||
*/
|
||||
void findFogPassesByName (const Ogre::String& passName = DEFAULT_PASS_NAME);
|
||||
|
||||
/// Sets the fog density multiplier
|
||||
void setDensity (Ogre::Real density);
|
||||
|
||||
/// Get the fog density multiplier
|
||||
Ogre::Real getDensity () const;
|
||||
|
||||
/// Sets fog colour
|
||||
void setColour (const Ogre::ColourValue &colour);
|
||||
|
||||
/// Gets fog colour
|
||||
const Ogre::ColourValue getColour () const;
|
||||
|
||||
/// Sets the vertical fog decay constant.
|
||||
void setVerticalDecay (Ogre::Real verticalDecay);
|
||||
|
||||
/// Get the vertical fog decay constant.
|
||||
Ogre::Real getVerticalDecay () const;
|
||||
|
||||
/** Sets the ground level.
|
||||
* At ground level 'fogginess' is equal to 1.
|
||||
*/
|
||||
void setGroundLevel (Ogre::Real GroundLevela);
|
||||
|
||||
/** Get the ground level.
|
||||
*/
|
||||
Ogre::Real getGroundLevel () const;
|
||||
|
||||
/** Forces an update of all the passes. You have to use this if you modify
|
||||
* the set of passes by hand, otherwise avoid it.
|
||||
*/
|
||||
void forceUpdate ();
|
||||
|
||||
private:
|
||||
/// Cached Density
|
||||
Ogre::Real mDensity;
|
||||
|
||||
/// Cached VerticalDecay
|
||||
Ogre::Real mVerticalDecay;
|
||||
|
||||
/// Cached GroundLevel
|
||||
Ogre::Real mGroundLevel;
|
||||
|
||||
/// Fog colour
|
||||
Ogre::ColourValue mFogColour;
|
||||
|
||||
private:
|
||||
/// The scene to control fog in.
|
||||
Ogre::SceneManager* mScene;
|
||||
|
||||
/// Sky dome material
|
||||
PrivateMaterialPtr mDomeMaterial;
|
||||
|
||||
/// Sky dome node
|
||||
PrivateSceneNodePtr mDomeNode;
|
||||
|
||||
/// Sky dome entity
|
||||
PrivateEntityPtr mDomeEntity;
|
||||
|
||||
// Called whenever something changes to update the sky dome.
|
||||
void updateSkyFogging();
|
||||
|
||||
protected:
|
||||
/// Handle far radius.
|
||||
virtual void setFarRadius (Ogre::Real radius);
|
||||
|
||||
public:
|
||||
/// Handle camera change.
|
||||
virtual void notifyCameraChanged (Ogre::Camera *cam);
|
||||
|
||||
void setQueryFlags (uint flags) { mDomeEntity->setQueryFlags (flags); }
|
||||
uint getQueryFlags () const { return mDomeEntity->getQueryFlags (); }
|
||||
void setVisibilityFlags (uint flags) { mDomeEntity->setVisibilityFlags (flags); }
|
||||
uint getVisibilityFlags () const { return mDomeEntity->getVisibilityFlags (); }
|
||||
|
||||
private:
|
||||
/// The passes to control.
|
||||
PassSet mPasses;
|
||||
|
||||
/// Params references.
|
||||
struct FogParamsBase
|
||||
{
|
||||
void setup(Ogre::GpuProgramParametersSharedPtr fpParams);
|
||||
|
||||
Ogre::GpuProgramParametersSharedPtr fpParams;
|
||||
|
||||
FastGpuParamRef fogDensity;
|
||||
FastGpuParamRef fogColour;
|
||||
FastGpuParamRef fogVerticalDecay;
|
||||
FastGpuParamRef fogGroundLevel;
|
||||
|
||||
};
|
||||
|
||||
struct DomeFogParams: public FogParamsBase {
|
||||
void setup(Ogre::GpuProgramParametersSharedPtr fpParams);
|
||||
FastGpuParamRef cameraHeight;
|
||||
} mDomeParams;
|
||||
|
||||
struct PassFogParams: public FogParamsBase {
|
||||
PassFogParams(Ogre::GpuProgramParametersSharedPtr fpParams) { setup(fpParams); }
|
||||
|
||||
static inline bool lessThanByParams(const PassFogParams& a, const PassFogParams& b) {
|
||||
return a.fpParams.get() <= b.fpParams.get();
|
||||
}
|
||||
|
||||
static inline bool equalByParams(const PassFogParams& a, const PassFogParams& b) {
|
||||
return a.fpParams.get() == b.fpParams.get();
|
||||
}
|
||||
};
|
||||
|
||||
typedef std::vector<PassFogParams> PassFogParamsVector;
|
||||
PassFogParamsVector mPassFogParams;
|
||||
|
||||
/// Update mPassFogParams based on mPasses
|
||||
void updatePassFogParams();
|
||||
};
|
||||
}
|
||||
|
||||
#endif //GROUNDFOG_H
|
||||
@ -1,102 +0,0 @@
|
||||
/*
|
||||
This file is part of Caelum.
|
||||
See http://www.ogre3d.org/wiki/index.php/Caelum
|
||||
|
||||
Copyright (c) 2006-2008 Caelum team. See Contributors.txt for details.
|
||||
|
||||
Caelum is free software: you can redistribute it and/or modify
|
||||
it under the terms of the GNU Lesser General Public License as published
|
||||
by the Free Software Foundation, either version 3 of the License, or
|
||||
(at your option) any later version.
|
||||
|
||||
Caelum is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
GNU Lesser General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU Lesser General Public License
|
||||
along with Caelum. If not, see <http://www.gnu.org/licenses/>.
|
||||
*/
|
||||
|
||||
#ifndef CAELUM__IMAGE_STARFIELD_H
|
||||
#define CAELUM__IMAGE_STARFIELD_H
|
||||
|
||||
#include "CaelumPrerequisites.h"
|
||||
#include "CameraBoundElement.h"
|
||||
#include "PrivatePtr.h"
|
||||
|
||||
namespace Caelum
|
||||
{
|
||||
/** Image-based starfield class.
|
||||
* This class implements a starfield based on mapping a single large
|
||||
* texture on a sphere. @see PointStarfield for a better solution.
|
||||
*/
|
||||
class CAELUM_EXPORT ImageStarfield : public CameraBoundElement
|
||||
{
|
||||
protected:
|
||||
/// Reference to the dome node.
|
||||
PrivateSceneNodePtr mNode;
|
||||
|
||||
/// Reference to the (cloned) starfield material.
|
||||
PrivateMaterialPtr mStarfieldMaterial;
|
||||
|
||||
/// Reference to the dome entity.
|
||||
PrivateEntityPtr mEntity;
|
||||
|
||||
/// Name of the spheric dome resource.
|
||||
static const Ogre::String STARFIELD_DOME_NAME;
|
||||
|
||||
/// Name of the starfield material.
|
||||
static const Ogre::String STARFIELD_MATERIAL_NAME;
|
||||
|
||||
/** Inclination of the starfield.
|
||||
*/
|
||||
Ogre::Degree mInclination;
|
||||
|
||||
public:
|
||||
static const String DEFAULT_TEXTURE_NAME;
|
||||
|
||||
/** Constructor.
|
||||
@param sceneMgr The scene manager this dome will belong to.
|
||||
*/
|
||||
ImageStarfield (
|
||||
Ogre::SceneManager *sceneMgr,
|
||||
Ogre::SceneNode *caelumRootNode,
|
||||
const Ogre::String &textureName = DEFAULT_TEXTURE_NAME);
|
||||
|
||||
/** Destructor.
|
||||
*/
|
||||
virtual ~ImageStarfield ();
|
||||
|
||||
/** Sets the starfield inclination. This inclination is the angle between the starfield rotation axis and the horizon plane.
|
||||
@param inc The starfield inclination in degrees. It`s equal to observer latitude taken with opposite sign.
|
||||
*/
|
||||
void setInclination (Ogre::Degree inc);
|
||||
|
||||
/** Updates the starfield position/orientation.
|
||||
@param time Local time in [0, 1] range.
|
||||
*/
|
||||
void update (const float time);
|
||||
|
||||
/** Updates the starfield material.
|
||||
@param mapName The new starfield texture map name.
|
||||
*/
|
||||
void setTexture (const Ogre::String &mapName);
|
||||
|
||||
public:
|
||||
/// Handle camera change.
|
||||
virtual void notifyCameraChanged (Ogre::Camera *cam);
|
||||
|
||||
protected:
|
||||
/// Handle far radius.
|
||||
virtual void setFarRadius (Ogre::Real radius);
|
||||
|
||||
public:
|
||||
void setQueryFlags (uint flags) { mEntity->setQueryFlags (flags); }
|
||||
uint getQueryFlags () const { return mEntity->getQueryFlags (); }
|
||||
void setVisibilityFlags (uint flags) { mEntity->setVisibilityFlags (flags); }
|
||||
uint getVisibilityFlags () const { return mEntity->getVisibilityFlags (); }
|
||||
};
|
||||
}
|
||||
|
||||
#endif // CAELUM__IMAGE_STARFIELD_H
|
||||
@ -1,118 +0,0 @@
|
||||
/*
|
||||
This file is part of Caelum.
|
||||
See http://www.ogre3d.org/wiki/index.php/Caelum
|
||||
|
||||
Copyright (c) 2006-2007 Caelum team. See Contributors.txt for details.
|
||||
|
||||
Caelum is free software: you can redistribute it and/or modify
|
||||
it under the terms of the GNU Lesser General Public License as published
|
||||
by the Free Software Foundation, either version 3 of the License, or
|
||||
(at your option) any later version.
|
||||
|
||||
Caelum is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
GNU Lesser General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU Lesser General Public License
|
||||
along with Caelum. If not, see <http://www.gnu.org/licenses/>.
|
||||
*/
|
||||
|
||||
#ifndef CAELUM_HEADER__PRIVATE_UTILITIES_H
|
||||
#define CAELUM_HEADER__PRIVATE_UTILITIES_H
|
||||
|
||||
#include "CaelumPrerequisites.h"
|
||||
#include "PrivatePtr.h"
|
||||
|
||||
namespace Caelum
|
||||
{
|
||||
/** Private caelum utilities
|
||||
*
|
||||
* This class constains various tiny utilities for caelum to use.
|
||||
*/
|
||||
class CAELUM_EXPORT InternalUtilities
|
||||
{
|
||||
public:
|
||||
/** Gets the interpolated colour between two pixels from an image.
|
||||
Interpolate a texture pixel by hand. (fx, fy) are in texture coordinates,
|
||||
ranging [0-1] across the entire texture.
|
||||
Smooth blending is only done on the x coordinate.
|
||||
Wrapping is only supported on X as well.
|
||||
|
||||
@param fx Horizontal coordinate.
|
||||
@param fy Vertical coordiate.
|
||||
@param img The lookup image.
|
||||
@param wrapX To wrap the x coordinate.
|
||||
@return The interpolated colour.
|
||||
*/
|
||||
static Ogre::ColourValue getInterpolatedColour (
|
||||
float fx,
|
||||
float fy,
|
||||
Ogre::Image *img,
|
||||
bool wrapX = true);
|
||||
|
||||
/** Quickly format a pointer as a string; in hex
|
||||
*/
|
||||
static const Ogre::String pointerToString(void* pointer);
|
||||
|
||||
/** Creates a private clone of a material from a script.
|
||||
*
|
||||
* When a class wants to modify a material at runtime it must not
|
||||
* modify the original material loaded from scripts. Instead it
|
||||
* should create a clone and use that.
|
||||
*
|
||||
* This method throws a Caelum::UnsupportedException on failure.
|
||||
*
|
||||
* @param originalName Name of the original material.
|
||||
* @param cloneName Name of the result clone.
|
||||
*
|
||||
* @return A pointer to an unique material.
|
||||
*/
|
||||
static Ogre::MaterialPtr checkLoadMaterialClone (
|
||||
const Ogre::String& originalName,
|
||||
const Ogre::String& cloneName);
|
||||
|
||||
/** Fetch a compositor by name and check it can be loaded properly
|
||||
*
|
||||
* This method throws a Caelum::UnsupportedException on failure.
|
||||
*
|
||||
* @param name Name of the compositor to check.
|
||||
*
|
||||
* @return A pointer to the compositor (can be ignored)
|
||||
*/
|
||||
static Ogre::CompositorPtr checkCompositorSupported (const Ogre::String& name);
|
||||
|
||||
public:
|
||||
/** Enumeration of types of sky domes.
|
||||
*/
|
||||
enum DomeType {
|
||||
DT_SKY_DOME,
|
||||
DT_IMAGE_STARFIELD,
|
||||
};
|
||||
|
||||
/** Creates a longitude-latitude sky dome.
|
||||
* @note Does nothing if the sphere already exists.
|
||||
* @param name The name of the mesh to be created.
|
||||
* @param segments The number of sphere segments.
|
||||
* @param domeType The type of dome to create.
|
||||
*/
|
||||
static void generateSphericDome (const Ogre::String &name, int segments, DomeType domeType);
|
||||
|
||||
private:
|
||||
/** Fills the vertex and index buffers for a sky gradients type dome.
|
||||
* @param pVertex Pointer to the vertex buffer.
|
||||
* @param pIndices Pointer to the index buffer.
|
||||
* @param segments Subdivision detail.
|
||||
*/
|
||||
static void fillGradientsDomeBuffers (float *pVertex, unsigned short *pIndices, int segments);
|
||||
|
||||
/** Fills the vertex and index buffers for a stardield type dome.
|
||||
* @param pVertex Pointer to the vertex buffer.
|
||||
* @param pIndices Pointer to the index buffer.
|
||||
* @param segments Subdivision detail.
|
||||
*/
|
||||
static void fillStarfieldDomeBuffers (float *pVertex, unsigned short *pIndices, int segments);
|
||||
};
|
||||
}
|
||||
|
||||
#endif // CAELUM_HEADER__PRIVATE_UTILITIES_H
|
||||
@ -1,108 +0,0 @@
|
||||
/*
|
||||
This file is part of Caelum.
|
||||
See http://www.ogre3d.org/wiki/index.php/Caelum
|
||||
|
||||
Copyright (c) 2008 Caelum team. See Contributors.txt for details.
|
||||
|
||||
Caelum is free software: you can redistribute it and/or modify
|
||||
it under the terms of the GNU Lesser General Public License as published
|
||||
by the Free Software Foundation, either version 3 of the License, or
|
||||
(at your option) any later version.
|
||||
|
||||
Caelum is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
GNU Lesser General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU Lesser General Public License
|
||||
along with Caelum. If not, see <http://www.gnu.org/licenses/>.
|
||||
*/
|
||||
|
||||
#ifndef CAELUM__MOON_H
|
||||
#define CAELUM__MOON_H
|
||||
|
||||
#include "CaelumPrerequisites.h"
|
||||
#include "SkyLight.h"
|
||||
#include "FastGpuParamRef.h"
|
||||
#include "PrivatePtr.h"
|
||||
|
||||
namespace Caelum
|
||||
{
|
||||
/** Class representing the moon.
|
||||
* Drawn as two billboards; one after the stars and one after the skydome.
|
||||
* Drawing it before the skydome will make it invisible in daylight; and that's bad.
|
||||
*/
|
||||
class CAELUM_EXPORT Moon:
|
||||
public BaseSkyLight
|
||||
{
|
||||
public:
|
||||
/// Name of the moon material.
|
||||
static const Ogre::String MOON_MATERIAL_NAME;
|
||||
|
||||
/// Name of the moon background material.
|
||||
static const Ogre::String MOON_BACKGROUND_MATERIAL_NAME;
|
||||
|
||||
private:
|
||||
/// Material for MoonBB
|
||||
PrivateMaterialPtr mMoonMaterial;
|
||||
|
||||
/// The moon sprite.
|
||||
PrivateBillboardSetPtr mMoonBB;
|
||||
|
||||
/// Material for mBackBB
|
||||
PrivateMaterialPtr mBackMaterial;
|
||||
|
||||
/// The moon's background; used to block the stars.
|
||||
PrivateBillboardSetPtr mBackBB;
|
||||
|
||||
/// The moon sprite visible angle
|
||||
Ogre::Degree mAngularSize;
|
||||
|
||||
struct Params {
|
||||
void setup(Ogre::GpuProgramParametersSharedPtr fpParams);
|
||||
|
||||
Ogre::GpuProgramParametersSharedPtr fpParams;
|
||||
FastGpuParamRef phase;
|
||||
} mParams;
|
||||
|
||||
public:
|
||||
/** Constructor.
|
||||
*/
|
||||
Moon (
|
||||
Ogre::SceneManager *sceneMgr,
|
||||
Ogre::SceneNode *caelumRootNode,
|
||||
const Ogre::String& moonTextureName = "moon_disc.dds",
|
||||
Ogre::Degree angularSize = Ogre::Degree(3.77f));
|
||||
|
||||
virtual ~Moon ();
|
||||
|
||||
/** Updates the moon material.
|
||||
@param textureName The new moon texture name.
|
||||
*/
|
||||
void setMoonTexture (const Ogre::String &textureName);
|
||||
|
||||
/** Updates the moon size.
|
||||
@param moon TextureAngularSize The new moon texture angular size.
|
||||
*/
|
||||
void setMoonTextureAngularSize(const Ogre::Degree& moonTextureAngularSize);
|
||||
|
||||
/** Sets the moon sphere colour.
|
||||
@param colour The colour used to draw the moon
|
||||
*/
|
||||
void setBodyColour (const Ogre::ColourValue &colour);
|
||||
|
||||
/// Set the moon's phase
|
||||
void setPhase (Ogre::Real phase);
|
||||
|
||||
public:
|
||||
/// Handle camera change.
|
||||
virtual void notifyCameraChanged (Ogre::Camera *cam);
|
||||
|
||||
virtual void setQueryFlags (uint flags);
|
||||
virtual uint getQueryFlags () const;
|
||||
virtual void setVisibilityFlags (uint flags);
|
||||
virtual uint getVisibilityFlags () const;
|
||||
};
|
||||
}
|
||||
|
||||
#endif // CAELUM__MOON_H
|
||||
@ -1,212 +0,0 @@
|
||||
/*
|
||||
This file is part of Caelum.
|
||||
See http://www.ogre3d.org/wiki/index.php/Caelum
|
||||
|
||||
Copyright (c) 2008 Caelum team. See Contributors.txt for details.
|
||||
|
||||
Caelum is free software: you can redistribute it and/or modify
|
||||
it under the terms of the GNU Lesser General Public License as published
|
||||
by the Free Software Foundation, either version 3 of the License, or
|
||||
(at your option) any later version.
|
||||
|
||||
Caelum is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
GNU Lesser General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU Lesser General Public License
|
||||
along with Caelum. If not, see <http://www.gnu.org/licenses/>.
|
||||
*/
|
||||
|
||||
#ifndef CAELUM__POINT_STARFIELD_H
|
||||
#define CAELUM__POINT_STARFIELD_H
|
||||
|
||||
#include "CaelumPrerequisites.h"
|
||||
#include "CameraBoundElement.h"
|
||||
#include "PrivatePtr.h"
|
||||
#include "FastGpuParamRef.h"
|
||||
|
||||
namespace Caelum
|
||||
{
|
||||
/** POD for bright star catalogue entries.
|
||||
* Only J2000 position and magnitude included.
|
||||
*/
|
||||
struct BrightStarCatalogueEntry {
|
||||
signed char rasc_hour;
|
||||
signed char rasc_min;
|
||||
float rasc_sec;
|
||||
signed char decl_deg;
|
||||
signed char decl_min;
|
||||
float decl_sec;
|
||||
float magn;
|
||||
};
|
||||
|
||||
/// There are exactly 9110 stars in our version of the BSC.
|
||||
const int BrightStarCatalogueSize = 9110;
|
||||
|
||||
/// Hardcoded bright star catalogue (BrightStarCatalogue.cpp)
|
||||
extern const BrightStarCatalogueEntry BrightStarCatalogue[BrightStarCatalogueSize];
|
||||
|
||||
/** Point starfield class.
|
||||
* An Ogre::ManualObject is used for drawing because billboards are too slow.
|
||||
*
|
||||
* Stars are sized in pixels; this seems to work a lot better than relative sizes.
|
||||
* Stars could be made even smaller but it would require hinting (nudging pixel
|
||||
* coordinates to match actual screen pixels). Points are hard.
|
||||
*
|
||||
* Loading a bright-star catalogue is supported but star positions are
|
||||
* likely only correct relative to each other. External rotation is probably wrong.
|
||||
*/
|
||||
class CAELUM_EXPORT PointStarfield:
|
||||
public CameraBoundElement
|
||||
{
|
||||
public:
|
||||
/** Constructor.
|
||||
* By default this loads some reasonable defaults and the
|
||||
* bright star catalogue.
|
||||
*/
|
||||
PointStarfield (
|
||||
Ogre::SceneManager *sceneMgr,
|
||||
Ogre::SceneNode *caelumRootNode,
|
||||
bool initWithCatalogue = true);
|
||||
|
||||
/// Destructor.
|
||||
virtual ~PointStarfield ();
|
||||
|
||||
/// Struct representing one star inside PointStarfield.
|
||||
struct Star {
|
||||
Ogre::Degree RightAscension;
|
||||
Ogre::Degree Declination;
|
||||
Ogre::Real Magnitude;
|
||||
};
|
||||
|
||||
/// A vector of Star
|
||||
typedef std::vector<Star> StarVector;
|
||||
|
||||
/** Get a reference to the vector of stars.
|
||||
* You can freely modify this; but you need to updateStars when you're done.
|
||||
*/
|
||||
inline StarVector& getStarVector () { return mStars; }
|
||||
|
||||
/** You must call this if you change the star vector by hand.
|
||||
*/
|
||||
void notifyStarVectorChanged ();
|
||||
|
||||
/// Clear any and all stars.
|
||||
void clearAllStars ();
|
||||
|
||||
/** Add a bunch of random stars.
|
||||
*/
|
||||
void addRandomStars (int count);
|
||||
|
||||
/** Add one star from the bright star catalogue.
|
||||
*/
|
||||
void addStar (const BrightStarCatalogueEntry &entry);
|
||||
|
||||
/** Add stars from the bright star catalogue.
|
||||
* @param count Number of stars to add (in order of brightness).
|
||||
*/
|
||||
void addBrightStarCatalogue (int count = BrightStarCatalogueSize);
|
||||
|
||||
private:
|
||||
/// Cloned material
|
||||
PrivateMaterialPtr mMaterial;
|
||||
|
||||
/// Node for the starfield
|
||||
PrivateSceneNodePtr mNode;
|
||||
|
||||
/// Manual object for drawing.
|
||||
PrivateManualObjectPtr mManualObj;
|
||||
|
||||
/// Star data.
|
||||
std::vector<Star> mStars;
|
||||
|
||||
Ogre::Real mMinPixelSize, mMaxPixelSize, mMag0PixelSize;
|
||||
Ogre::Real mMagnitudeScale;
|
||||
|
||||
Ogre::Degree mObserverLatitude, mObserverLongitude;
|
||||
|
||||
bool mValidGeometry;
|
||||
void invalidateGeometry();
|
||||
void ensureGeometry();
|
||||
|
||||
public:
|
||||
/** Update function; called from CaelumSystem::updateSubcomponents
|
||||
@param time Time of the day.
|
||||
*/
|
||||
void _update (float time);
|
||||
|
||||
/** Magnitude power scale.
|
||||
* Star magnitudes are logarithming; one magnitude difference
|
||||
* means a star is 2.512 times brighter.
|
||||
* This property allows tweaking that value.
|
||||
*/
|
||||
inline void setMagnitudeScale (Ogre::Real value) { mMagnitudeScale = value; }
|
||||
inline Ogre::Real getMagnitudeScale () const { return mMagnitudeScale; }
|
||||
|
||||
inline void setMag0PixelSize (Ogre::Real value) { mMag0PixelSize = value; }
|
||||
inline Ogre::Real getMag0PixelSize () const { return mMag0PixelSize; }
|
||||
|
||||
inline void setMinPixelSize (Ogre::Real value) { mMinPixelSize = value; }
|
||||
inline Ogre::Real getMinPixelSize () const { return mMinPixelSize; }
|
||||
|
||||
inline void setMaxPixelSize (Ogre::Real value) { mMaxPixelSize = value; }
|
||||
inline Ogre::Real getMaxPixelSize () const { return mMaxPixelSize; }
|
||||
|
||||
void setObserverLatitude (Ogre::Degree value);
|
||||
inline Ogre::Degree getObserverLatitude () const { return mObserverLatitude; }
|
||||
|
||||
void setObserverLongitude (Ogre::Degree value);
|
||||
inline Ogre::Degree getObserverLongitude () const { return mObserverLongitude; }
|
||||
|
||||
private:
|
||||
Ogre::Degree mObserverPositionRebuildDelta;
|
||||
|
||||
public:
|
||||
/** Moving the observer position around causes a starfield rebuild.
|
||||
* Default value (DEFAULT_OBSERVER_POSITION_REBUILD_DELTA) is 0.1
|
||||
* degrees which is equivalent to around 170 meters on the earth.
|
||||
*
|
||||
* This only matters if you compute the observer position every
|
||||
* frame. Caelum doesn't contain code for that.
|
||||
*/
|
||||
inline Ogre::Degree getObserverPositionRebuildDelta () const {
|
||||
return mObserverPositionRebuildDelta;
|
||||
}
|
||||
inline void setObserverPositionRebuildDelta (Ogre::Degree value) {
|
||||
mObserverPositionRebuildDelta = value;
|
||||
}
|
||||
|
||||
static const Ogre::Degree DEFAULT_OBSERVER_POSITION_REBUILD_DELTA;
|
||||
|
||||
/// Material used to draw all the points.
|
||||
static const Ogre::String STARFIELD_MATERIAL_NAME;
|
||||
|
||||
/// Handle camera change.
|
||||
virtual void notifyCameraChanged (Ogre::Camera *cam);
|
||||
|
||||
protected:
|
||||
/// Handle far radius.
|
||||
virtual void setFarRadius (Ogre::Real radius);
|
||||
|
||||
public:
|
||||
void setQueryFlags (uint flags) { mManualObj->setQueryFlags (flags); }
|
||||
uint getQueryFlags () const { return mManualObj->getQueryFlags (); }
|
||||
void setVisibilityFlags (uint flags) { mManualObj->setVisibilityFlags (flags); }
|
||||
uint getVisibilityFlags () const { return mManualObj->getVisibilityFlags (); }
|
||||
|
||||
private:
|
||||
struct Params {
|
||||
void setup(Ogre::GpuProgramParametersSharedPtr vpParams);
|
||||
|
||||
Ogre::GpuProgramParametersSharedPtr vpParams;
|
||||
FastGpuParamRef mag_scale;
|
||||
FastGpuParamRef mag0_size;
|
||||
FastGpuParamRef min_size;
|
||||
FastGpuParamRef max_size;
|
||||
FastGpuParamRef aspect_ratio;
|
||||
} mParams;
|
||||
};
|
||||
}
|
||||
|
||||
#endif // CAELUM__POINT_STARFIELD_H
|
||||
@ -1,283 +0,0 @@
|
||||
/*
|
||||
This file is part of Caelum.
|
||||
See http://www.ogre3d.org/wiki/index.php/Caelum
|
||||
|
||||
Copyright (c) 2008 Caelum team. See Contributors.txt for details.
|
||||
|
||||
Caelum is free software: you can redistribute it and/or modify
|
||||
it under the terms of the GNU Lesser General Public License as published
|
||||
by the Free Software Foundation, either version 3 of the License, or
|
||||
(at your option) any later version.
|
||||
|
||||
Caelum is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
GNU Lesser General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU Lesser General Public License
|
||||
along with Caelum. If not, see <http://www.gnu.org/licenses/>.
|
||||
*/
|
||||
|
||||
#ifndef CAELUM__PRECIPITATION_CONTROLLER_H
|
||||
#define CAELUM__PRECIPITATION_CONTROLLER_H
|
||||
|
||||
#include "CaelumPrerequisites.h"
|
||||
#include "FastGpuParamRef.h"
|
||||
|
||||
namespace Caelum
|
||||
{
|
||||
/** Preset parameters for a certain type of precipitation.
|
||||
*/
|
||||
struct PrecipitationPresetParams
|
||||
{
|
||||
Ogre::ColourValue Colour;
|
||||
Ogre::Real Speed;
|
||||
Ogre::String Name;
|
||||
};
|
||||
|
||||
/** An enumeration of the available precipitation presets.
|
||||
* @see PrecipitationController::getPrecipitationPreset
|
||||
*/
|
||||
enum PrecipitationType
|
||||
{
|
||||
PRECTYPE_DRIZZLE = 0,
|
||||
PRECTYPE_RAIN = 1,
|
||||
PRECTYPE_SNOW = 2,
|
||||
PRECTYPE_SNOWGRAINS = 3,
|
||||
PRECTYPE_ICECRYSTALS = 4,
|
||||
PRECTYPE_ICEPELLETS = 5,
|
||||
PRECTYPE_HAIL = 6,
|
||||
PRECTYPE_SMALLHAIL = 7,
|
||||
|
||||
PRECTYPE_CUSTOM = 8,
|
||||
};
|
||||
|
||||
/** Compositor-based precipitation controller.
|
||||
* This class will add and control precipitation controllers to viewports.
|
||||
*
|
||||
* Compositors clone the composing materials. This controller will
|
||||
* register itself as a compositor listener and change the material in notifyMaterialSetup.
|
||||
*/
|
||||
class CAELUM_EXPORT PrecipitationController
|
||||
{
|
||||
private:
|
||||
friend class PrecipitationInstance;
|
||||
|
||||
Ogre::SceneManager *mSceneMgr;
|
||||
Ogre::Vector3 mWindSpeed;
|
||||
Ogre::Real mIntensity;
|
||||
Ogre::Real mSpeed;
|
||||
Ogre::ColourValue mColour;
|
||||
PrecipitationType mPresetType;
|
||||
Ogre::String mTextureName;
|
||||
Ogre::Vector3 mCameraSpeedScale;
|
||||
Ogre::Vector3 mFallingDirection;
|
||||
|
||||
Ogre::Real mAutoDisableThreshold;
|
||||
bool mHardDisableCompositor;
|
||||
|
||||
Ogre::ColourValue mSceneColour;
|
||||
Real mInternalTime;
|
||||
|
||||
// Only meant for the instance ctl in auto-camera-speed mode.
|
||||
Real mSecondsSinceLastFrame;
|
||||
inline Real getSecondsSinceLastFrame() { return mSecondsSinceLastFrame; }
|
||||
|
||||
public:
|
||||
/// Name of the compositor resource.
|
||||
static const String COMPOSITOR_NAME;
|
||||
|
||||
/// Name of the compositor material.
|
||||
static const String MATERIAL_NAME;
|
||||
|
||||
/// Check if a preset type is valid.
|
||||
static bool isPresetType (PrecipitationType value);
|
||||
|
||||
/// Get preset parameters for a certain type of precipitation.
|
||||
static const PrecipitationPresetParams& getPresetParams (PrecipitationType value);
|
||||
|
||||
/// Set all parameters at once.
|
||||
void setParams (const PrecipitationPresetParams& params);
|
||||
|
||||
/// Quickly set a certain preset type of precipitation.
|
||||
void setPresetType (PrecipitationType value);
|
||||
|
||||
/** Get the preset type.
|
||||
* Will return PRECIPITATION_CUSTOM if you modify parameters manually
|
||||
* after setPresetType.
|
||||
*/
|
||||
PrecipitationType getPresetType () const;
|
||||
|
||||
// Texture name, part of a preset
|
||||
void setTextureName(const Ogre::String& textureName);
|
||||
const Ogre::String getTextureName() const;
|
||||
|
||||
/// Precipitation color. Part of a preset
|
||||
void setColour(const Ogre::ColourValue& color);
|
||||
const Ogre::ColourValue getColour() const;
|
||||
|
||||
/// Precipitation speed (affects direction). Part of a preset
|
||||
void setSpeed(Real value);
|
||||
Real getSpeed() const;
|
||||
|
||||
/// Precipitation intensity.
|
||||
void setIntensity(Real value);
|
||||
Real getIntensity() const;
|
||||
|
||||
/// Wind speed and direction
|
||||
void setWindSpeed(const Ogre::Vector3 &value);
|
||||
const Ogre::Vector3 getWindSpeed() const;
|
||||
|
||||
/** The basic direction for falling precipitation.
|
||||
*
|
||||
* This property define the notion of a "falling down" direction.
|
||||
* By default this is Vector3::NEGATIVE_UNIT_Y. You need to change
|
||||
* this for a Z-up system.
|
||||
*/
|
||||
void setFallingDirection(const Ogre::Vector3 &value) { mFallingDirection = value; }
|
||||
const Ogre::Vector3 getFallingDirection() const { return mFallingDirection; }
|
||||
|
||||
/// Set manual camera speed for all viewports.
|
||||
void setManualCameraSpeed(const Ogre::Vector3 &value);
|
||||
|
||||
/// Set auto camera speed everywhere.o
|
||||
void setAutoCameraSpeed();
|
||||
|
||||
/** Automatically disable compositors when intensity is low.
|
||||
* A negative value always enable the compositor.
|
||||
* @note: Ogre::CompositorInstance allocates/frees resources when
|
||||
* enabling or disabling. That is expensive.
|
||||
*/
|
||||
inline void setAutoDisableThreshold (Real value) { mAutoDisableThreshold = value; }
|
||||
inline Real getAutoDisableThreshold () const { return mAutoDisableThreshold; }
|
||||
|
||||
/** Automatically scale camera speed.
|
||||
*
|
||||
* This is multiplied per-component with camera speed; manual or
|
||||
* automatic. It's most useful for automatic camera speed to control
|
||||
* how much of an effect moving the camera has on rain drop directions.
|
||||
*
|
||||
* The components should probably be equal.
|
||||
*
|
||||
* Default in Ogre::Vector3::UNIT_SCALE
|
||||
*/
|
||||
inline void setCameraSpeedScale (const Ogre::Vector3& value) {
|
||||
mCameraSpeedScale = value;
|
||||
}
|
||||
inline const Ogre::Vector3 getCameraSpeedScale () const {
|
||||
return mCameraSpeedScale;
|
||||
}
|
||||
|
||||
/** Set an equal camera speed scale in all dimensions.
|
||||
*/
|
||||
inline void setCameraSpeedScale (Ogre::Real value) {
|
||||
setCameraSpeedScale(Ogre::Vector3::UNIT_SCALE * value);
|
||||
}
|
||||
|
||||
/** Update the the precipitation controller.
|
||||
* @param secondsSinceLastFrame Number of secods since the last frame.
|
||||
*/
|
||||
void update(Real secondsSinceLastFrame, Ogre::ColourValue colour);
|
||||
|
||||
PrecipitationController(
|
||||
Ogre::SceneManager *sceneMgr);
|
||||
~PrecipitationController();
|
||||
|
||||
public:
|
||||
typedef std::map<Ogre::Viewport*, PrecipitationInstance*> ViewportInstanceMap;
|
||||
ViewportInstanceMap mViewportInstanceMap;
|
||||
|
||||
public:
|
||||
/// Add precipitation to a certain viewport.
|
||||
PrecipitationInstance* createViewportInstance(Ogre::Viewport* viewport);
|
||||
|
||||
/// Remove precipitation from a certain viewport.
|
||||
void destroyViewportInstance(Ogre::Viewport* viewport);
|
||||
|
||||
/// Get per-viewport instance, or null if not created yet.
|
||||
PrecipitationInstance* getViewportInstance(Ogre::Viewport* viewport);
|
||||
|
||||
/// Remove from all attached viewports; clean up.
|
||||
void destroyAllViewportInstances();
|
||||
};
|
||||
|
||||
/** Per-viewport instance of precipitation.
|
||||
* This will create and control an ogre::CompositorInstance.
|
||||
*/
|
||||
class PrecipitationInstance: private Ogre::CompositorInstance::Listener
|
||||
{
|
||||
private:
|
||||
friend class PrecipitationController;
|
||||
|
||||
PrecipitationController* mParent;
|
||||
Ogre::Viewport* mViewport;
|
||||
Ogre::CompositorInstance* mCompInst;
|
||||
Ogre::Camera* mLastCamera;
|
||||
Ogre::Vector3 mLastCameraPosition;
|
||||
Ogre::Vector3 mCameraSpeed;
|
||||
bool mAutoCameraSpeed;
|
||||
|
||||
virtual void notifyMaterialSetup(uint pass_id, Ogre::MaterialPtr &mat);
|
||||
virtual void notifyMaterialRender(uint pass_id, Ogre::MaterialPtr &mat);
|
||||
|
||||
/// Called to enforce parameters on a composing material
|
||||
/// Called from notifyMaterialRender.
|
||||
void _updateMaterialParams(
|
||||
const Ogre::MaterialPtr& mat,
|
||||
const Ogre::Camera* cam,
|
||||
const Ogre::Vector3& camSpeed);
|
||||
|
||||
// Add remove the compositors. Do nothing if already added/removed
|
||||
void createCompositor ();
|
||||
void destroyCompositor ();
|
||||
|
||||
// Check if the compositor should be enabled
|
||||
bool shouldBeEnabled () const;
|
||||
|
||||
/// Called from the parent's update.
|
||||
void _update();
|
||||
|
||||
public:
|
||||
inline Ogre::Viewport* getViewport() const { return mViewport; }
|
||||
inline PrecipitationController* getParent() const { return mParent; }
|
||||
inline Ogre::CompositorInstance* getCompositorInstance() const { return mCompInst; }
|
||||
|
||||
/// Check if camera speed is automatically calculated (default true).
|
||||
bool getAutoCameraSpeed();
|
||||
|
||||
/** Set camera speed to automatic calculation.
|
||||
*
|
||||
* @warning: This runs into difficult precission issues. It is
|
||||
* better to use setManualCameraSpeed.
|
||||
*/
|
||||
void setAutoCameraSpeed();
|
||||
|
||||
/// Set manual camera speed; disables automatic calculation.
|
||||
void setManualCameraSpeed(const Ogre::Vector3& value);
|
||||
|
||||
/// Get current camera speed. Doesn't include CameraSpeedScale.
|
||||
const Ogre::Vector3 getCameraSpeed();
|
||||
|
||||
PrecipitationInstance(PrecipitationController* parent, Ogre::Viewport* view);
|
||||
virtual ~PrecipitationInstance();
|
||||
|
||||
private:
|
||||
struct Params {
|
||||
void setup(Ogre::GpuProgramParametersSharedPtr fpParams);
|
||||
|
||||
Ogre::GpuProgramParametersSharedPtr fpParams;
|
||||
FastGpuParamRef precColor;
|
||||
FastGpuParamRef intensity;
|
||||
FastGpuParamRef dropSpeed;
|
||||
FastGpuParamRef corner1;
|
||||
FastGpuParamRef corner2;
|
||||
FastGpuParamRef corner3;
|
||||
FastGpuParamRef corner4;
|
||||
FastGpuParamRef deltaX;
|
||||
FastGpuParamRef deltaY;
|
||||
} mParams;
|
||||
|
||||
};
|
||||
}
|
||||
|
||||
#endif //CAELUM__PRECIPITATION_CONTROLLER_H
|
||||
@ -1,264 +0,0 @@
|
||||
/*
|
||||
This file is part of Caelum.
|
||||
See http://www.ogre3d.org/wiki/index.php/Caelum
|
||||
|
||||
Copyright (c) 2008 Caelum team. See Contributors.txt for details.
|
||||
|
||||
Caelum is free software: you can redistribute it and/or modify
|
||||
it under the terms of the GNU Lesser General Public License as published
|
||||
by the Free Software Foundation, either version 3 of the License, or
|
||||
(at your option) any later version.
|
||||
|
||||
Caelum is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
GNU Lesser General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU Lesser General Public License
|
||||
along with Caelum. If not, see <http://www.gnu.org/licenses/>.
|
||||
*/
|
||||
|
||||
#ifndef CAELUM__PRIVATE_PTR_H
|
||||
#define CAELUM__PRIVATE_PTR_H
|
||||
|
||||
#include "CaelumPrerequisites.h"
|
||||
|
||||
namespace Caelum
|
||||
{
|
||||
/** Default traits for Caelum::PrivatePtr.
|
||||
*
|
||||
* This default traits class make PrivatePtr work like std::auto_ptr.
|
||||
* Other Traits classes can derive from this and only customize some of
|
||||
* the functions.
|
||||
*
|
||||
* @see PrivatePtr
|
||||
*/
|
||||
template<class PointedT>
|
||||
struct DefaultPrivatePtrTraits
|
||||
{
|
||||
/// The type of the inner member to hold in PrivatePtr
|
||||
typedef PointedT* InnerPointerType;
|
||||
|
||||
/// Return an InnerPointerType repressenting a null value.
|
||||
static inline const InnerPointerType getNullValue() {
|
||||
return 0;
|
||||
}
|
||||
|
||||
/// Convert InnerPointerType to a naked PointedT.
|
||||
static inline PointedT* getPointer (const InnerPointerType& inner) {
|
||||
return inner;
|
||||
}
|
||||
|
||||
/// Destroy the inner value (and set null).
|
||||
static void destroy (InnerPointerType& inner)
|
||||
{
|
||||
delete inner;
|
||||
inner = 0;
|
||||
}
|
||||
};
|
||||
|
||||
/** Template for smart pointers with strict unique ownership.
|
||||
* A lot of objects in Ogre are created and destroyed through other
|
||||
* "Manager" objects. Even though the memory for such objects is never
|
||||
* actually leaked better lifetime control is frequently useful.
|
||||
*
|
||||
* PrivatePtr is very similar in behaviour to std::auto_ptr but tries
|
||||
* to mimic Ogre::SharedPtr method names. Only one PrivatePtr must exist to
|
||||
* a certain object at any one time. Assignment and copy construction will
|
||||
* in fact pass away ownership and set the original PrivatePtr to null.
|
||||
*
|
||||
* This very limited functionality makes PrivatePtr very efficient; it should
|
||||
* have no overhead compared to doing the same thing manually.
|
||||
*
|
||||
* PrivatePtr supports customization through a static traits class which
|
||||
* can customize what happens when the PrivatePtr is destroyed. This makes
|
||||
* it possible to use PrivatePtr classes for fine control over the lifetime
|
||||
* of objects which are otherwise managed by an external class.
|
||||
*
|
||||
* @see DefaultPrivatePtrTraits
|
||||
*/
|
||||
template<class PointedT, typename TraitsT = DefaultPrivatePtrTraits<PointedT> >
|
||||
class PrivatePtr
|
||||
{
|
||||
private:
|
||||
/// Brings InnerPointerType as a type in this scope.
|
||||
typedef typename TraitsT::InnerPointerType InnerPointerType;
|
||||
|
||||
/// Inner data member.
|
||||
InnerPointerType mInner;
|
||||
|
||||
public:
|
||||
/** Change the inner value.
|
||||
* This will destroy the old value and gain ownership of the new value.
|
||||
*/
|
||||
void reset (const InnerPointerType& newInner = TraitsT::getNullValue()) {
|
||||
if (mInner == newInner) {
|
||||
return;
|
||||
}
|
||||
TraitsT::destroy (mInner);
|
||||
mInner = newInner;
|
||||
}
|
||||
|
||||
InnerPointerType release () {
|
||||
InnerPointerType result = mInner;
|
||||
mInner = TraitsT::getNullValue();
|
||||
return result;
|
||||
}
|
||||
|
||||
/** Constructor; always initialize to 0.
|
||||
*/
|
||||
PrivatePtr () { mInner = TraitsT::getNullValue (); }
|
||||
|
||||
/** Initializing constructur
|
||||
*/
|
||||
PrivatePtr (const InnerPointerType& inner) { mInner = inner; }
|
||||
|
||||
/** Non-virtual destructor (don't derive from this).
|
||||
*/
|
||||
~PrivatePtr () { setNull(); }
|
||||
|
||||
/** Copy constructor; clears right-hand-side.
|
||||
*/
|
||||
PrivatePtr (PrivatePtr& rhs)
|
||||
{
|
||||
if (&rhs != this) {
|
||||
this->reset (rhs.mInner);
|
||||
rhs.mInner = TraitsT::getNullValue ();
|
||||
}
|
||||
}
|
||||
|
||||
/** Assignment
|
||||
*/
|
||||
const PrivatePtr& operator= (PrivatePtr& rhs)
|
||||
{
|
||||
if (&rhs != this) {
|
||||
this->reset (rhs.mInner);
|
||||
rhs.mInner = TraitsT::getNullValue ();
|
||||
}
|
||||
return *this;
|
||||
}
|
||||
|
||||
/// Check if this is null.
|
||||
bool isNull () const { return mInner == TraitsT::getNullValue (); }
|
||||
|
||||
/// Set to null and destroy contents (if any).
|
||||
void setNull () {
|
||||
TraitsT::destroy (mInner);
|
||||
assert(this->isNull());
|
||||
}
|
||||
|
||||
PointedT* getPointer () const { return TraitsT::getPointer (mInner); }
|
||||
PointedT* get () const { return getPointer (); }
|
||||
PointedT* operator-> () const { return getPointer (); }
|
||||
PointedT& operator* () const{ return *getPointer (); }
|
||||
};
|
||||
|
||||
/** PrivatePtr traits for a movable object.
|
||||
* This kind of pointer will remove the movable from the scene and destroy it.
|
||||
*/
|
||||
template<class MovableT>
|
||||
struct MovableObjectPrivatePtrTraits: public DefaultPrivatePtrTraits<MovableT>
|
||||
{
|
||||
typedef MovableT* InnerPointerType;
|
||||
|
||||
static void destroy (InnerPointerType& inner)
|
||||
{
|
||||
if (inner != 0) {
|
||||
//Ogre::LogManager::getSingletonPtr ()->logMessage (
|
||||
// "PrivatePtr: Destroying movable object " + inner->getName ());
|
||||
inner->_getManager ()->destroyMovableObject (inner);
|
||||
inner = 0;
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
typedef PrivatePtr<Ogre::MovableObject, MovableObjectPrivatePtrTraits<Ogre::MovableObject> > PrivateMovableObjectPtr;
|
||||
typedef PrivatePtr<Ogre::BillboardChain, MovableObjectPrivatePtrTraits<Ogre::BillboardChain> > PrivateBillboardChainPtr;
|
||||
typedef PrivatePtr<Ogre::BillboardSet, MovableObjectPrivatePtrTraits<Ogre::BillboardSet> > PrivateBillboardSetPtr;
|
||||
typedef PrivatePtr<Ogre::Entity, MovableObjectPrivatePtrTraits<Ogre::Entity> > PrivateEntityPtr;
|
||||
typedef PrivatePtr<Ogre::Light, MovableObjectPrivatePtrTraits<Ogre::Light> > PrivateLightPtr;
|
||||
typedef PrivatePtr<Ogre::ManualObject, MovableObjectPrivatePtrTraits<Ogre::ManualObject> > PrivateManualObjectPtr;
|
||||
typedef PrivatePtr<Ogre::ParticleSystem, MovableObjectPrivatePtrTraits<Ogre::ParticleSystem> > PrivateParticleSystemPtr;
|
||||
|
||||
/** PrivatePtr traits for a scene node.
|
||||
* Scene nodes are created and destroyed through the scene manager.
|
||||
* @see PrivatePrivateSceneNodePtr
|
||||
*/
|
||||
struct SceneNodePrivatePtrTraits: public DefaultPrivatePtrTraits<Ogre::SceneNode>
|
||||
{
|
||||
static void destroy (InnerPointerType& inner)
|
||||
{
|
||||
if (inner) {
|
||||
//Ogre::LogManager::getSingletonPtr ()->logMessage (
|
||||
// "PrivatePtr: Destroying scene node " + inner->getName ());
|
||||
inner->getCreator ()->destroySceneNode (inner->getName ());
|
||||
inner = 0;
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
typedef PrivatePtr<Ogre::SceneNode, SceneNodePrivatePtrTraits> PrivateSceneNodePtr;
|
||||
|
||||
/** PrivatePtr traits for uniquely-owned resources.
|
||||
*
|
||||
* All ogre resources are tracked by a resource managed by name and can
|
||||
* be globally referenced from multiple places. This traits class allows
|
||||
* you to hold a pointer to a resource which you create and completely
|
||||
* control.
|
||||
*
|
||||
* The best example of this is a cloned material. It is frequently useful
|
||||
* to create a clone of an existing material and tweak settings for one
|
||||
* particular usage. After the clone is no longer useful the material must
|
||||
* be explicitly removed from the MaterialManager. Otherwise an unloaded
|
||||
* resource handle is leaked.
|
||||
*
|
||||
* When the PrivatePtr gets out of scope the resource is removed from the
|
||||
* manager. In debug mode this will also check that there are no other
|
||||
* references to the destroyed resource.
|
||||
*/
|
||||
template<class PointedT, class InnerT, class ManagerT>
|
||||
struct PrivateResourcePtrTraits
|
||||
{
|
||||
typedef InnerT InnerPointerType;
|
||||
|
||||
static const InnerT getNullValue () {
|
||||
return InnerT();
|
||||
}
|
||||
|
||||
static PointedT* getPointer (const InnerPointerType& inner) {
|
||||
return inner.getPointer ();
|
||||
}
|
||||
|
||||
static void destroy (InnerPointerType& inner) {
|
||||
if (!inner.isNull ()) {
|
||||
//Ogre::LogManager::getSingletonPtr ()->logMessage (
|
||||
// "PrivateResourcePtrTraits: Destroying owned resource"
|
||||
// " name=" + inner->getName () +
|
||||
// " handle=" + Ogre::StringConverter::toString (inner->getHandle ()) );
|
||||
ManagerT::getSingletonPtr ()->remove (inner->getHandle ());
|
||||
assert (inner.unique () && "Resource pointer not unique after destruction");
|
||||
inner.setNull();
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
typedef PrivatePtr <
|
||||
Ogre::Material,
|
||||
PrivateResourcePtrTraits <
|
||||
Ogre::Material,
|
||||
Ogre::MaterialPtr,
|
||||
Ogre::MaterialManager
|
||||
>
|
||||
> PrivateMaterialPtr;
|
||||
|
||||
typedef PrivatePtr <
|
||||
Ogre::Mesh,
|
||||
PrivateResourcePtrTraits <
|
||||
Ogre::Mesh,
|
||||
Ogre::MeshPtr,
|
||||
Ogre::MeshManager
|
||||
>
|
||||
> PrivateMeshPtr;
|
||||
}
|
||||
|
||||
#endif // CAELUM__PRIVATE_PTR_H
|
||||
@ -1,119 +0,0 @@
|
||||
/*
|
||||
This file is part of Caelum.
|
||||
See http://www.ogre3d.org/wiki/index.php/Caelum
|
||||
|
||||
Copyright (c) 2006-2007 Caelum team. See Contributors.txt for details.
|
||||
|
||||
Caelum is free software: you can redistribute it and/or modify
|
||||
it under the terms of the GNU Lesser General Public License as published
|
||||
by the Free Software Foundation, either version 3 of the License, or
|
||||
(at your option) any later version.
|
||||
|
||||
Caelum is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
GNU Lesser General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU Lesser General Public License
|
||||
along with Caelum. If not, see <http://www.gnu.org/licenses/>.
|
||||
*/
|
||||
|
||||
#ifndef CAELUM__SKYDOME_H
|
||||
#define CAELUM__SKYDOME_H
|
||||
|
||||
#include "CaelumPrerequisites.h"
|
||||
#include "CameraBoundElement.h"
|
||||
#include "FastGpuParamRef.h"
|
||||
#include "PrivatePtr.h"
|
||||
|
||||
namespace Caelum
|
||||
{
|
||||
/** A sky dome element.
|
||||
*/
|
||||
class CAELUM_EXPORT SkyDome : public CameraBoundElement
|
||||
{
|
||||
private:
|
||||
/** Name of the spheric dome resource.
|
||||
*/
|
||||
static const Ogre::String SPHERIC_DOME_NAME;
|
||||
|
||||
/** Name of the dome material.
|
||||
*/
|
||||
static const Ogre::String SKY_DOME_MATERIAL_NAME;
|
||||
|
||||
/// Control scene node.
|
||||
PrivateSceneNodePtr mNode;
|
||||
|
||||
/// Sky dome material.
|
||||
PrivateMaterialPtr mMaterial;
|
||||
|
||||
/// Sky dome entity.
|
||||
PrivateEntityPtr mEntity;
|
||||
|
||||
private:
|
||||
/// True if selected technique has shaders.
|
||||
bool mShadersEnabled;
|
||||
|
||||
/// If haze is enabled.
|
||||
bool mHazeEnabled;
|
||||
|
||||
public:
|
||||
/** Constructor
|
||||
* This will setup some nice defaults.
|
||||
* @param sceneMgr The scene manager where this sky dome will be created.
|
||||
*/
|
||||
SkyDome (Ogre::SceneManager *sceneMgr, Ogre::SceneNode *caelumRootNode);
|
||||
|
||||
/** Destructor
|
||||
*/
|
||||
virtual ~SkyDome ();
|
||||
|
||||
/** Sets the sun direction.
|
||||
@param dir The sun light direction.
|
||||
*/
|
||||
void setSunDirection (const Ogre::Vector3& dir);
|
||||
|
||||
/// Explicit haze colour.
|
||||
void setHazeColour (const Ogre::ColourValue& hazeColour);
|
||||
|
||||
/// Set the sky color gradients image.
|
||||
void setSkyGradientsImage (const Ogre::String& gradients);
|
||||
|
||||
/// Set the atmosphere depthh gradient image.
|
||||
void setAtmosphereDepthImage (const Ogre::String& gradients);
|
||||
|
||||
/** Enable or disable skydome haze. This makes the sky darker.
|
||||
* By default haze is disabled.
|
||||
*/
|
||||
void setHazeEnabled (bool value);
|
||||
|
||||
/// If skydome haze is enabled.
|
||||
bool getHazeEnabled () const;
|
||||
|
||||
void setQueryFlags (uint flags) { mEntity->setQueryFlags (flags); }
|
||||
uint getQueryFlags () const { return mEntity->getQueryFlags (); }
|
||||
void setVisibilityFlags (uint flags) { mEntity->setVisibilityFlags (flags); }
|
||||
uint getVisibilityFlags () const { return mEntity->getVisibilityFlags (); }
|
||||
|
||||
public:
|
||||
/// Handle camera change.
|
||||
virtual void notifyCameraChanged (Ogre::Camera *cam);
|
||||
|
||||
protected:
|
||||
/// Handle far radius.
|
||||
virtual void setFarRadius (Ogre::Real radius);
|
||||
|
||||
private:
|
||||
struct Params {
|
||||
void setup(Ogre::GpuProgramParametersSharedPtr vpParams, Ogre::GpuProgramParametersSharedPtr fpParams);
|
||||
|
||||
Ogre::GpuProgramParametersSharedPtr vpParams;
|
||||
Ogre::GpuProgramParametersSharedPtr fpParams;
|
||||
FastGpuParamRef sunDirection;
|
||||
FastGpuParamRef offset;
|
||||
FastGpuParamRef hazeColour;
|
||||
} mParams;
|
||||
};
|
||||
}
|
||||
|
||||
#endif //CAELUM__SKYDOME_H
|
||||
@ -1,175 +0,0 @@
|
||||
/*
|
||||
This file is part of Caelum.
|
||||
See http://www.ogre3d.org/wiki/index.php/Caelum
|
||||
|
||||
Copyright (c) 2008 Caelum team. See Contributors.txt for details.
|
||||
|
||||
Caelum is free software: you can redistribute it and/or modify
|
||||
it under the terms of the GNU Lesser General Public License as published
|
||||
by the Free Software Foundation, either version 3 of the License, or
|
||||
(at your option) any later version.
|
||||
|
||||
Caelum is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
GNU Lesser General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU Lesser General Public License
|
||||
along with Caelum. If not, see <http://www.gnu.org/licenses/>.
|
||||
*/
|
||||
|
||||
#ifndef CAELUM__SKYLIGHT_H
|
||||
#define CAELUM__SKYLIGHT_H
|
||||
|
||||
#include "CameraBoundElement.h"
|
||||
|
||||
namespace Caelum
|
||||
{
|
||||
/** Base class for sky lights (sun and moon).
|
||||
* Contains a directional light which can be automatically disabled when too dim.
|
||||
*/
|
||||
class CAELUM_EXPORT BaseSkyLight : public CameraBoundElement
|
||||
{
|
||||
protected:
|
||||
/// The main directional light.
|
||||
Ogre::Light *mMainLight;
|
||||
|
||||
/// The sun scene node.
|
||||
Ogre::SceneNode *mNode;
|
||||
|
||||
/// Base distance of the light.
|
||||
float mRadius;
|
||||
|
||||
/// The latest normalised sun direction.
|
||||
Ogre::Vector3 mDirection;
|
||||
|
||||
/// Body sphere colour, as set by setBodyColour
|
||||
Ogre::ColourValue mBodyColour;
|
||||
|
||||
/// Sun light colour, as set by setLightColour
|
||||
Ogre::ColourValue mLightColour;
|
||||
|
||||
/// Colour multiplier for light diffuse colour.
|
||||
Ogre::ColourValue mDiffuseMultiplier;
|
||||
|
||||
/// Colour multiplier for light specular colour.
|
||||
Ogre::ColourValue mSpecularMultiplier;
|
||||
|
||||
/** Colour multiplier for ambient light colour.
|
||||
* No effect, this value is only stored here.
|
||||
*/
|
||||
Ogre::ColourValue mAmbientMultiplier;
|
||||
|
||||
/// If the light is automatically disabled beneath mAutoDisableThreshold
|
||||
bool mAutoDisableLight;
|
||||
|
||||
/// Threshold beneath which the light is automatically disabled.
|
||||
Ogre::Real mAutoDisableThreshold;
|
||||
|
||||
/// If the light is always disabled. Separate from the mAutoDisable mechanism.
|
||||
bool mForceDisableLight;
|
||||
|
||||
public:
|
||||
/** Constructor.
|
||||
@param sceneMgr The scene manager where the lights will be created.
|
||||
@param caelumRootNode Root node to attach to. Should be bound to the camera.
|
||||
*/
|
||||
BaseSkyLight (
|
||||
Ogre::SceneManager *sceneMgr,
|
||||
Ogre::SceneNode *caelumRootNode);
|
||||
|
||||
/// Destructor.
|
||||
virtual ~BaseSkyLight () = 0;
|
||||
|
||||
/** Updates skylight parameters.
|
||||
* @param direction Light direction.
|
||||
* @param lightColour Color for the light source
|
||||
* @param bodyColour Color to draw the body of the light (whatever that is).
|
||||
*/
|
||||
virtual void update (
|
||||
const Ogre::Vector3& direction,
|
||||
const Ogre::ColourValue &lightColour,
|
||||
const Ogre::ColourValue &bodyColour);
|
||||
|
||||
/// Retrieves the latest light direction.
|
||||
const Ogre::Vector3 getLightDirection () const;
|
||||
|
||||
/// Set the sun direction.
|
||||
virtual void setLightDirection (const Ogre::Vector3 &dir);
|
||||
|
||||
/// Get current body colour, as set in setBodyColour.
|
||||
const Ogre::ColourValue getBodyColour () const;
|
||||
|
||||
/// Sets the colour to draw the light's body with.
|
||||
virtual void setBodyColour (const Ogre::ColourValue &colour);
|
||||
|
||||
/// Get current light colour, as set in setLightColour.
|
||||
const Ogre::ColourValue getLightColour () const;
|
||||
|
||||
/// Sets the skylight colour.
|
||||
virtual void setLightColour (const Ogre::ColourValue &colour);
|
||||
|
||||
/// Set diffuse multiplier for light colour
|
||||
void setDiffuseMultiplier (const Ogre::ColourValue &diffuse);
|
||||
|
||||
/// Set diffuse multiplier for light colour
|
||||
const Ogre::ColourValue getDiffuseMultiplier () const;
|
||||
|
||||
/// Set specular multiplier for light colour
|
||||
void setSpecularMultiplier (const Ogre::ColourValue &specular);
|
||||
|
||||
/// Set specular multiplier for light colour
|
||||
const Ogre::ColourValue getSpecularMultiplier () const;
|
||||
|
||||
/// Set ambient multiplier for light colour
|
||||
/// This value is only stored here; the SceneManager is not touched
|
||||
/// However, CaelumSystem does use this value.
|
||||
void setAmbientMultiplier (const Ogre::ColourValue &ambient);
|
||||
|
||||
/// Set ambient multiplier for light colour
|
||||
const Ogre::ColourValue getAmbientMultiplier () const;
|
||||
|
||||
/// Direct access to the Ogre::Light.
|
||||
Ogre::Light* getMainLight() const;
|
||||
|
||||
/// Check if the light is automatically disabled.
|
||||
inline bool getAutoDisable() const { return mAutoDisableLight; }
|
||||
|
||||
/** Turn on and off auto-disabling of the light when too dim.
|
||||
* This is off by default. If you set it to true you probably also want to
|
||||
* set the autoDisableThreshold.
|
||||
* The "intensity" of the light for the threshold is calculated as the plain sum of r, g and b.
|
||||
*/
|
||||
inline void setAutoDisable(bool value) { mAutoDisableLight = value; }
|
||||
|
||||
/// Get the auto-disable threshold.
|
||||
inline Ogre::Real getAutoDisableThreshold() const { return mAutoDisableThreshold; }
|
||||
|
||||
/// Set the auto-disable threshold.
|
||||
inline void setAutoDisableThreshold(Ogre::Real value) { mAutoDisableThreshold = value; }
|
||||
|
||||
static const Ogre::Real DEFAULT_AUTO_DISABLE_THRESHOLD;
|
||||
|
||||
/// Disable the light by force; without taking intensity into account.
|
||||
inline void setForceDisable(bool value) { mForceDisableLight = value; }
|
||||
inline bool getForceDisable() const { return mForceDisableLight; }
|
||||
|
||||
virtual void setQueryFlags (uint flags) = 0;
|
||||
virtual uint getQueryFlags () const = 0;
|
||||
virtual void setVisibilityFlags (uint flags) = 0;
|
||||
virtual uint getVisibilityFlags () const = 0;
|
||||
|
||||
protected:
|
||||
/// Handle far radius.
|
||||
virtual void setFarRadius (Ogre::Real radius);
|
||||
|
||||
/// Temporary change main light color
|
||||
void setMainLightColour(const Ogre::ColourValue &colour);
|
||||
|
||||
/// If the light should be enabled for a certain value.
|
||||
/// This functions takes AutoDisable and such into account.
|
||||
bool shouldEnableLight(const Ogre::ColourValue &colour);
|
||||
};
|
||||
}
|
||||
|
||||
#endif // CAELUM__SKYLIGHT_H
|
||||
@ -1,142 +0,0 @@
|
||||
/*
|
||||
This file is part of Caelum.
|
||||
See http://www.ogre3d.org/wiki/index.php/Caelum
|
||||
|
||||
Copyright (c) 2006-2007 Caelum team. See Contributors.txt for details.
|
||||
|
||||
Caelum is free software: you can redistribute it and/or modify
|
||||
it under the terms of the GNU Lesser General Public License as published
|
||||
by the Free Software Foundation, either version 3 of the License, or
|
||||
(at your option) any later version.
|
||||
|
||||
Caelum is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
GNU Lesser General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU Lesser General Public License
|
||||
along with Caelum. If not, see <http://www.gnu.org/licenses/>.
|
||||
*/
|
||||
|
||||
#ifndef CAELUM__SUN_H
|
||||
#define CAELUM__SUN_H
|
||||
|
||||
#include "CaelumPrerequisites.h"
|
||||
#include "CameraBoundElement.h"
|
||||
#include "SkyLight.h"
|
||||
#include "PrivatePtr.h"
|
||||
|
||||
namespace Caelum
|
||||
{
|
||||
class BaseSkyLight;
|
||||
class SphereSun;
|
||||
class SpriteSun;
|
||||
|
||||
typedef SpriteSun Sun;
|
||||
|
||||
/** Class representing the sun as sphere with emissive color on it.
|
||||
* @deprecated
|
||||
*/
|
||||
class CAELUM_EXPORT SphereSun : public BaseSkyLight
|
||||
{
|
||||
public:
|
||||
/// Name of the sun material.
|
||||
static const Ogre::String SUN_MATERIAL_NAME;
|
||||
|
||||
private:
|
||||
/// Reference to the sun material.
|
||||
PrivateMaterialPtr mSunMaterial;
|
||||
|
||||
/// The sun entity.
|
||||
PrivateEntityPtr mSunEntity;
|
||||
|
||||
public:
|
||||
/** Constructor.
|
||||
@param sceneMgr The scene manager where the lights will be created.
|
||||
*/
|
||||
SphereSun (
|
||||
Ogre::SceneManager *sceneMgr,
|
||||
Ogre::SceneNode *caelumRootNode,
|
||||
const Ogre::String &meshName = "sphere.mesh");
|
||||
|
||||
/** Destructor.
|
||||
@note If a sun position model is in use, it will be deleted.
|
||||
*/
|
||||
virtual ~SphereSun ();
|
||||
|
||||
/** Sets the sun sphere colour.
|
||||
@param colour The colour used to draw the sun
|
||||
*/
|
||||
void setBodyColour (const Ogre::ColourValue &colour);
|
||||
|
||||
public:
|
||||
/// Handle camera change.
|
||||
virtual void notifyCameraChanged (Ogre::Camera *cam);
|
||||
|
||||
virtual void setQueryFlags (uint flags) { mSunEntity->setQueryFlags (flags); }
|
||||
virtual uint getQueryFlags () const { return mSunEntity->getQueryFlags (); }
|
||||
virtual void setVisibilityFlags (uint flags) { mSunEntity->setVisibilityFlags (flags); }
|
||||
virtual uint getVisibilityFlags () const { return mSunEntity->getVisibilityFlags (); }
|
||||
};
|
||||
|
||||
/** Class representing the sun as billboard with texture on it.
|
||||
*/
|
||||
class CAELUM_EXPORT SpriteSun : public BaseSkyLight
|
||||
{
|
||||
public:
|
||||
/// Name of the sun material.
|
||||
static const Ogre::String SUN_MATERIAL_NAME;
|
||||
|
||||
protected:
|
||||
/// The sun material.
|
||||
PrivateMaterialPtr mSunMaterial;
|
||||
|
||||
/// The sun sprite / billboard
|
||||
PrivateBillboardSetPtr mSunBillboardSet;
|
||||
|
||||
/// The sun sprite visible angle
|
||||
Ogre::Degree mSunTextureAngularSize;
|
||||
|
||||
public:
|
||||
/** Constructor.
|
||||
@param sceneMgr The scene manager where the lights will be created.
|
||||
@param sunTextureAngularSize 0.53f is real angular size of Sun and Moon, 3.77f is compatible with SphereSun
|
||||
*/
|
||||
SpriteSun (
|
||||
Ogre::SceneManager *sceneMgr,
|
||||
Ogre::SceneNode *caelumRootNode,
|
||||
const Ogre::String& sunTextureName = "sun_disc.png",
|
||||
const Ogre::Degree& sunTextureAngularSize = Ogre::Degree(3.77f));
|
||||
|
||||
/** Destructor.
|
||||
@note If a sun position model is in use, it will be deleted.
|
||||
*/
|
||||
virtual ~SpriteSun ();
|
||||
|
||||
/** Updates the sun material.
|
||||
@param textureName The new sun texture name.
|
||||
*/
|
||||
void setSunTexture (const Ogre::String &textureName);
|
||||
|
||||
/** Updates the sun size.
|
||||
@param sunTextureAngularSize The new sun texture angular size.
|
||||
*/
|
||||
void setSunTextureAngularSize(const Ogre::Degree& sunTextureAngularSize);
|
||||
|
||||
/** Sets the sun sphere colour.
|
||||
@param colour The colour used to draw the sun
|
||||
*/
|
||||
void setBodyColour (const Ogre::ColourValue &colour);
|
||||
|
||||
public:
|
||||
/// Handle camera change.
|
||||
virtual void notifyCameraChanged (Ogre::Camera *cam);
|
||||
|
||||
virtual void setQueryFlags (uint flags) { mSunBillboardSet->setQueryFlags (flags); }
|
||||
virtual uint getQueryFlags () const { return mSunBillboardSet->getQueryFlags (); }
|
||||
virtual void setVisibilityFlags (uint flags) { mSunBillboardSet->setVisibilityFlags (flags); }
|
||||
virtual uint getVisibilityFlags () const { return mSunBillboardSet->getVisibilityFlags (); }
|
||||
};
|
||||
}
|
||||
|
||||
#endif // CAELUM__SUN_H
|
||||
@ -1,271 +0,0 @@
|
||||
/*
|
||||
This file is part of Caelum.
|
||||
See http://www.ogre3d.org/wiki/index.php/Caelum
|
||||
|
||||
Copyright (c) 2008 Caelum team. See Contributors.txt for details.
|
||||
|
||||
Caelum is free software: you can redistribute it and/or modify
|
||||
it under the terms of the GNU Lesser General Public License as published
|
||||
by the Free Software Foundation, either version 3 of the License, or
|
||||
(at your option) any later version.
|
||||
|
||||
Caelum is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
GNU Lesser General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU Lesser General Public License
|
||||
along with Caelum. If not, see <http://www.gnu.org/licenses/>.
|
||||
*/
|
||||
|
||||
#ifndef CAELUM__TYPE_DESCRIPTOR_H
|
||||
#define CAELUM__TYPE_DESCRIPTOR_H
|
||||
|
||||
#include "CaelumPrerequisites.h"
|
||||
|
||||
#if CAELUM_TYPE_DESCRIPTORS
|
||||
|
||||
#include <typeinfo>
|
||||
|
||||
namespace Caelum
|
||||
{
|
||||
class ValuePropertyDescriptor;
|
||||
|
||||
/** Abstract interface for a type descriptor.
|
||||
* A type descriptor contains informations about the properties of
|
||||
* another object. It provides access to a map of strings to
|
||||
* ValuePropertyDescriptor. All methods are const.
|
||||
*
|
||||
* This is not a full reflection mechanism; it doesn't care about
|
||||
* methods and parameters. It's just a way to access object properties
|
||||
* in a uniform way.
|
||||
*
|
||||
* The list of properties supported by a type descriptor is fixed.
|
||||
*
|
||||
* The type descriptor is responsible for the lifetime of
|
||||
* ValuePropertyDescriptor objects; never the user.
|
||||
*/
|
||||
class CAELUM_EXPORT TypeDescriptor
|
||||
{
|
||||
public:
|
||||
virtual ~TypeDescriptor() {};
|
||||
|
||||
typedef std::map<String, const ValuePropertyDescriptor*> PropertyMap;
|
||||
|
||||
/** Get a property descriptor; or null if not available.
|
||||
* @param name Name of the property to request.
|
||||
* @return A pointer to a property descriptor; or null if not available.
|
||||
*/
|
||||
virtual const ValuePropertyDescriptor* getPropertyDescriptor (const Ogre::String& name) const = 0;
|
||||
|
||||
/** Get a map of all supported properties.
|
||||
* Returns a complete list of all supported properties; by value.
|
||||
*/
|
||||
virtual const std::vector<String> getPropertyNames () const = 0;
|
||||
|
||||
/** Get a map of all supported properties.
|
||||
* Returns a complete list of all supported properties; by value.
|
||||
*/
|
||||
virtual const PropertyMap getFullPropertyMap () const = 0;
|
||||
};
|
||||
|
||||
/** Basic property descriptor interface.
|
||||
*
|
||||
* A property descriptor provides a uniform way to change the value of a
|
||||
* simple property. The values are safely wrapped inside an Ogre::Any.
|
||||
*
|
||||
* This only works for simple properties which are copied by value. This
|
||||
* includes floats strings and vectors but not things like Entity pointers.
|
||||
*
|
||||
* All public methods are const because the descriptor itself is not
|
||||
* modified by these methods.
|
||||
*/
|
||||
class CAELUM_EXPORT ValuePropertyDescriptor
|
||||
{
|
||||
public:
|
||||
virtual ~ValuePropertyDescriptor() {};
|
||||
|
||||
/** If the value of the property can be read (true means write-only).
|
||||
*
|
||||
* This is false for write-only properties.
|
||||
* Write-only properties are generally a bad idea but they are supported.
|
||||
* Scripting (with .os files) doesn't actually require reading existing values.
|
||||
*/
|
||||
virtual bool canGetValue () const = 0;
|
||||
|
||||
/// If the value of the property can be set (false means read-only).
|
||||
virtual bool canSetValue () const = 0;
|
||||
|
||||
/** Get the value of the property packed in an Ogre::Any.
|
||||
*
|
||||
* @param target Object to fetch the property from. If target is
|
||||
* not of the correct type behaviour is undefined.
|
||||
*/
|
||||
virtual const Ogre::Any getValue (const void* target) const = 0;
|
||||
|
||||
/** Set the value of the property packed in an Ogre::Any.
|
||||
* @param target Object set the property on. If target is not of
|
||||
* the correct type then behaviour is undefined.
|
||||
* @param value New value of the property.
|
||||
*/
|
||||
virtual void setValue (void* target, const Ogre::Any& value) const = 0;
|
||||
|
||||
/// Get std::type_info for the type of the value.
|
||||
virtual const std::type_info& getValueTypeId () const = 0;
|
||||
|
||||
/** Check if this class also implements TypedValuePropertyDescriptor.
|
||||
*
|
||||
* If this property returns true then you can static_cast this object to
|
||||
* a TypedValuePropertyDescriptor<ValueT>; for the appropiate ValueT.
|
||||
* The appropriate ValueT can be obtained with getValueTypeId.
|
||||
*/
|
||||
virtual bool implementsTypedValuePropertyDescriptor () const {
|
||||
return false;
|
||||
}
|
||||
};
|
||||
|
||||
/** Variant of ValuePropertyDescriptor which allows faster typed get/set methods.
|
||||
*/
|
||||
template<typename ValueT>
|
||||
class CAELUM_EXPORT TypedValuePropertyDescriptor: public ValuePropertyDescriptor
|
||||
{
|
||||
public:
|
||||
/// Get the property's value.
|
||||
virtual const ValueT getValueTyped (const void* target) const = 0;
|
||||
/// Set the property's value.
|
||||
virtual void setValueTyped (void* target, const ValueT& value) const = 0;
|
||||
|
||||
private:
|
||||
virtual const Ogre::Any getValue (const void* target) const {
|
||||
return Ogre::Any(this->getValueTyped (target));
|
||||
}
|
||||
|
||||
virtual void setValue (void* target, const Ogre::Any& value) const {
|
||||
this->setValueTyped (target, Ogre::any_cast<ValueT>(value));
|
||||
}
|
||||
|
||||
virtual const std::type_info& getValueTypeId () const {
|
||||
return typeid(ValueT);
|
||||
}
|
||||
|
||||
virtual bool implementsTypedValuePropertyDescriptor () const {
|
||||
return true;
|
||||
}
|
||||
};
|
||||
|
||||
/** ValuePropertyDescriptor implementation based on function pointers to get/set methods.
|
||||
*/
|
||||
template <class TargetT, typename ParamT, typename InParamT = const ParamT&, typename OutParamT = const ParamT>
|
||||
class AccesorPropertyDescriptor: public TypedValuePropertyDescriptor<ParamT>
|
||||
{
|
||||
public:
|
||||
typedef void(TargetT::*SetFunc)(InParamT);
|
||||
typedef OutParamT(TargetT::*GetFunc)(void) const;
|
||||
|
||||
private:
|
||||
GetFunc mGetFunc;
|
||||
SetFunc mSetFunc;
|
||||
|
||||
public:
|
||||
AccesorPropertyDescriptor (GetFunc getFunc, SetFunc setFunc)
|
||||
{
|
||||
mGetFunc = getFunc;
|
||||
mSetFunc = setFunc;
|
||||
}
|
||||
|
||||
virtual bool canGetValue () const {
|
||||
return mGetFunc != 0;
|
||||
}
|
||||
|
||||
virtual bool canSetValue () const {
|
||||
return mSetFunc != 0;
|
||||
}
|
||||
|
||||
virtual const ParamT getValueTyped(const void* target) const
|
||||
{
|
||||
const TargetT* typedTarget = reinterpret_cast<const TargetT*>(target);
|
||||
return (typedTarget->*mGetFunc)();
|
||||
}
|
||||
|
||||
virtual void setValueTyped(void* target, const ParamT& value) const
|
||||
{
|
||||
TargetT* typedTarget = reinterpret_cast<TargetT*>(target);
|
||||
(typedTarget->*mSetFunc)(value);
|
||||
}
|
||||
};
|
||||
|
||||
/** Default implementation of a TypeDescriptor.
|
||||
* This is a standard implementation of a type descriptor.
|
||||
*
|
||||
* It allows direct access to an internal PropertyMap. The user must
|
||||
* manually fill the map with property descriptors; probably in an init
|
||||
* method of sorts.
|
||||
*/
|
||||
class DefaultTypeDescriptor: public TypeDescriptor
|
||||
{
|
||||
public:
|
||||
DefaultTypeDescriptor ();
|
||||
virtual ~DefaultTypeDescriptor ();
|
||||
|
||||
/** Direct access to the internal property map.
|
||||
* Get the property map used to implement this type descriptor.
|
||||
* Once initialisation is complete the property map should no longer
|
||||
* be modified.
|
||||
*/
|
||||
inline PropertyMap& getPropertyMap () { return mPropertyMap; }
|
||||
|
||||
/// Add a property. Type descriptor takes ownership.
|
||||
void add (const Ogre::String& name, const ValuePropertyDescriptor* descriptor);
|
||||
|
||||
/// Clear the property map; delete all property descriptors.
|
||||
void clear ();
|
||||
|
||||
/// @copydoc TypeDescriptor::getPropertyDescriptor
|
||||
virtual const ValuePropertyDescriptor* getPropertyDescriptor (const Ogre::String& name) const;
|
||||
|
||||
/// @copydoc TypeDescriptor::getPropertyNames
|
||||
virtual const std::vector<String> getPropertyNames () const;
|
||||
|
||||
/// @copydoc TypeDescriptor::getFullPropertyMap
|
||||
virtual const PropertyMap getFullPropertyMap () const;
|
||||
|
||||
private:
|
||||
void deleteAllPropertyDescriptors ();
|
||||
|
||||
PropertyMap mPropertyMap;
|
||||
};
|
||||
|
||||
/** Standard type descriptors for caelum components.
|
||||
*
|
||||
* This class hold pointers to several type descriptors for classes
|
||||
* inside Caelum. All the pointers are initialize in the contructor and
|
||||
* properly destroyed in the destructor.
|
||||
*
|
||||
* The CaelumPlugin singleton contains a const instance of this class. You
|
||||
* should fetch that instead of creating a new object; using
|
||||
* CaelumPlugin::getTypeDescriptorData().
|
||||
*/
|
||||
class CAELUM_EXPORT CaelumDefaultTypeDescriptorData
|
||||
{
|
||||
private:
|
||||
void load();
|
||||
void unload();
|
||||
|
||||
public:
|
||||
CaelumDefaultTypeDescriptorData();
|
||||
~CaelumDefaultTypeDescriptorData();
|
||||
|
||||
DefaultTypeDescriptor* CaelumSystemTypeDescriptor;
|
||||
DefaultTypeDescriptor* PointStarfieldTypeDescriptor;
|
||||
DefaultTypeDescriptor* BaseSkyLightTypeDescriptor;
|
||||
DefaultTypeDescriptor* GroundFogTypeDescriptor;
|
||||
DefaultTypeDescriptor* PrecipitationTypeDescriptor;
|
||||
DefaultTypeDescriptor* DepthComposerTypeDescriptor;
|
||||
DefaultTypeDescriptor* FlatCloudLayerTypeDescriptor;
|
||||
DefaultTypeDescriptor* SkyDomeTypeDescriptor;
|
||||
};
|
||||
}
|
||||
|
||||
#endif // CAELUM_TYPE_DESCRIPTORS
|
||||
|
||||
#endif // CAELUM__TYPE_DESCRIPTOR_H
|
||||
@ -1,111 +0,0 @@
|
||||
/*
|
||||
This file is part of Caelum.
|
||||
See http://www.ogre3d.org/wiki/index.php/Caelum
|
||||
|
||||
Copyright (c) 2006-2008 Caelum team. See Contributors.txt for details.
|
||||
|
||||
Caelum is free software: you can redistribute it and/or modify
|
||||
it under the terms of the GNU Lesser General Public License as published
|
||||
by the Free Software Foundation, either version 3 of the License, or
|
||||
(at your option) any later version.
|
||||
|
||||
Caelum is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
GNU Lesser General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU Lesser General Public License
|
||||
along with Caelum. If not, see <http://www.gnu.org/licenses/>.
|
||||
*/
|
||||
|
||||
#ifndef UNIVERSALCLOCK_H
|
||||
#define UNIVERSALCLOCK_H
|
||||
|
||||
#include "CaelumPrerequisites.h"
|
||||
|
||||
namespace Caelum {
|
||||
|
||||
/** The system's time model.
|
||||
* This class is responsible of keeping track of current astronomical time
|
||||
* and syncronising with ogre time.
|
||||
*
|
||||
* It maintains a snapshot point: At mCurrentTime == 0 julian day was mJulianDayBase.
|
||||
* At any time the julian day can be calculated from mCurrentTime and mJulianDayBase.
|
||||
* This increases precission; mCurrentTime is tracked in seconds while mJulianDayBase
|
||||
* uses days. It would be silly to track the current time in days.
|
||||
*/
|
||||
class CAELUM_EXPORT UniversalClock
|
||||
{
|
||||
private:
|
||||
/// Astronomical julian day at mCurrentTime = 0;
|
||||
LongReal mJulianDayBase;
|
||||
|
||||
/// Seconds since mJulianDayBase.
|
||||
LongReal mCurrentTime;
|
||||
|
||||
/// Seconds since mJulianDayBase at last update.
|
||||
LongReal mLastUpdateTime;
|
||||
|
||||
/// Time scale.
|
||||
Ogre::Real mTimeScale;
|
||||
|
||||
public:
|
||||
/** Number of seconds per day; exactly 60*60*24.
|
||||
*/
|
||||
static const LongReal SECONDS_PER_DAY;
|
||||
|
||||
/** Constructor.
|
||||
*/
|
||||
UniversalClock ();
|
||||
|
||||
/** Sets the time scale.
|
||||
* @param scale The new time scale. If negative, time will move backwards; 2.0 means double speed...
|
||||
*/
|
||||
void setTimeScale (const Ogre::Real scale);
|
||||
|
||||
/** Gets the time scale.
|
||||
* @return The current time scale. Defaults to 1.
|
||||
*/
|
||||
Ogre::Real getTimeScale () const;
|
||||
|
||||
/** Updates the clock.
|
||||
* @param time The time to be added to the clock. It will beaffected by the time scale.
|
||||
*/
|
||||
void update (const Ogre::Real time);
|
||||
|
||||
/** Set the current time as a julian day.
|
||||
* Set the current time as a julian day, which you build using one
|
||||
* of the static getJulianDayFromXXX functions.
|
||||
* Defaults to J2000 (noon january 1st)
|
||||
*/
|
||||
void setJulianDay(LongReal value);
|
||||
|
||||
/** Set the current time as a gregorian date.
|
||||
* This is here as an easy to use function.
|
||||
*/
|
||||
void setGregorianDateTime(
|
||||
int year, int month, int day,
|
||||
int hour, int minute, double second);
|
||||
|
||||
/** Get current julian day.
|
||||
*/
|
||||
LongReal getJulianDay() const;
|
||||
|
||||
/** Get the difference in julian day between this and the last update.
|
||||
* This is most likely very small and unprecise.
|
||||
*/
|
||||
LongReal getJulianDayDifference() const;
|
||||
|
||||
/** Get the current julian second (getJulianDay * SECONDS_PER_DAY)
|
||||
* This is most likely very very large and unprecise.
|
||||
*/
|
||||
LongReal getJulianSecond() const;
|
||||
|
||||
/** Get the difference in seconds between this and the last update.
|
||||
* This is what you want for per-frame updates.
|
||||
*/
|
||||
LongReal getJulianSecondDifference() const;
|
||||
};
|
||||
}
|
||||
|
||||
#endif //UNIVERSALCLOCK_H
|
||||
Binary file not shown.
|
Before Width: | Height: | Size: 220 B |
@ -1,141 +0,0 @@
|
||||
/*
|
||||
This file is part of Caelum.
|
||||
See http://www.ogre3d.org/wiki/index.php/Caelum
|
||||
|
||||
Copyright (c) 2006-2007 Caelum team. See Contributors.txt for details.
|
||||
|
||||
Caelum is free software: you can redistribute it and/or modify
|
||||
it under the terms of the GNU Lesser General Public License as published
|
||||
by the Free Software Foundation, either version 3 of the License, or
|
||||
(at your option) any later version.
|
||||
|
||||
Caelum is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
GNU Lesser General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU Lesser General Public License
|
||||
along with Caelum. If not, see <http://www.gnu.org/licenses/>.
|
||||
*/
|
||||
|
||||
// Returns (exp(x) - 1) / x; avoiding division by 0.
|
||||
// lim when x -> 0 is 1.
|
||||
float expdiv(float x) {
|
||||
if (abs(x) < 0.0001) {
|
||||
return 1;
|
||||
} else {
|
||||
return (exp(x) - 1) / x;
|
||||
}
|
||||
}
|
||||
|
||||
// Return fogging through a layer of fog which drops exponentially by height.
|
||||
//
|
||||
// Standard exp fog with constant density would return (1 - exp(-density * dist)).
|
||||
// This function assumes a variable density vd = exp(-verticalDecay * h - baseLevel)
|
||||
// Full computation is exp(density * dist / (h2 - h1) * int(h1, h2, exp(-verticalDecay * (h2 - h1)))).
|
||||
//
|
||||
// This will gracefully degrade to standard exp fog in verticalDecay is 0; without throwing NaNs.
|
||||
float ExpGroundFog (
|
||||
float dist, float h1, float h2,
|
||||
float density, float verticalDecay, float baseLevel)
|
||||
{
|
||||
float deltaH = (h2 - h1);
|
||||
return 1 - exp (-density * dist * exp(verticalDecay * (baseLevel - h1)) * expdiv(-verticalDecay * deltaH));
|
||||
}
|
||||
|
||||
// Just like ExpGroundFog with h2 = positive infinity
|
||||
// When h2 == negative infinity the value is always +1.
|
||||
float ExpGroundFogInf (
|
||||
float invSinView, float h1,
|
||||
float density, float verticalDecay, float baseLevel)
|
||||
{
|
||||
return 1 - exp (-density * invSinView * exp(verticalDecay * (baseLevel - h1)) * (1 / verticalDecay));
|
||||
}
|
||||
|
||||
// Entry point for GroundFog vertex program.
|
||||
void GroundFog_vp
|
||||
(
|
||||
float4 position : POSITION,
|
||||
|
||||
out float4 oPosition : POSITION,
|
||||
out float4 worldPos : TEXCOORD0,
|
||||
|
||||
uniform float4x4 worldViewProj,
|
||||
uniform float4x4 world
|
||||
) {
|
||||
oPosition = mul(worldViewProj, position);
|
||||
worldPos = mul(world, position);
|
||||
}
|
||||
|
||||
// Entry point for GroundFog fragment program.
|
||||
void GroundFog_fp
|
||||
(
|
||||
in float3 worldPos : TEXCOORD0,
|
||||
|
||||
uniform float3 camPos,
|
||||
uniform float4 fogColour,
|
||||
uniform float fogDensity,
|
||||
uniform float fogVerticalDecay,
|
||||
uniform float fogGroundLevel,
|
||||
|
||||
out float4 oCol : COLOR
|
||||
) {
|
||||
float h1 = camPos.y;
|
||||
float h2 = worldPos.y;
|
||||
float dist = length(camPos - worldPos);
|
||||
float fog = ExpGroundFog(
|
||||
dist, h1, h2,
|
||||
fogDensity, fogVerticalDecay, fogGroundLevel);
|
||||
|
||||
oCol.rgb = fogColour.rgb;
|
||||
oCol.a = fog;
|
||||
}
|
||||
|
||||
// Entry point for GroundFogDome vertex program.
|
||||
void GroundFogDome_vp
|
||||
(
|
||||
in float4 position : POSITION,
|
||||
out float4 oPosition : POSITION,
|
||||
out float3 relPosition : TEXCOORD0,
|
||||
uniform float4x4 worldViewProj
|
||||
) {
|
||||
oPosition = mul(worldViewProj, position);
|
||||
relPosition = normalize(position.xyz);
|
||||
}
|
||||
|
||||
// Entry point for the GroundFogDome fragment program.
|
||||
void GroundFogDome_fp
|
||||
(
|
||||
in float3 relPosition : TEXCOORD0,
|
||||
|
||||
uniform float cameraHeight,
|
||||
uniform float4 fogColour,
|
||||
uniform float fogDensity,
|
||||
uniform float fogVerticalDecay,
|
||||
uniform float fogGroundLevel,
|
||||
|
||||
out float4 oCol : COLOR
|
||||
) {
|
||||
// Fog magic.
|
||||
float invSinView = 1 / (relPosition.y);
|
||||
float h1 = cameraHeight;
|
||||
float aFog;
|
||||
|
||||
if (fogVerticalDecay < 1e-7) {
|
||||
// A value of zero of fogVerticalDecay would result in maximum (1) aFog everywhere.
|
||||
// Output 0 zero instead to disable.
|
||||
aFog = 0;
|
||||
} else {
|
||||
if (invSinView < 0) {
|
||||
// Gazing into the abyss
|
||||
aFog = 1;
|
||||
} else {
|
||||
aFog = saturate (ExpGroundFogInf (
|
||||
invSinView, h1,
|
||||
fogDensity, fogVerticalDecay, fogGroundLevel));
|
||||
}
|
||||
}
|
||||
|
||||
oCol.a = aFog;
|
||||
oCol.rgb = fogColour.rgb;
|
||||
}
|
||||
@ -1,217 +0,0 @@
|
||||
/*
|
||||
This file is part of Caelum.
|
||||
See http://www.ogre3d.org/wiki/index.php/Caelum
|
||||
|
||||
Copyright (c) 2006-2007 Caelum team. See Contributors.txt for details.
|
||||
|
||||
Caelum is free software: you can redistribute it and/or modify
|
||||
it under the terms of the GNU Lesser General Public License as published
|
||||
by the Free Software Foundation, either version 3 of the License, or
|
||||
(at your option) any later version.
|
||||
|
||||
Caelum is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
GNU Lesser General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU Lesser General Public License
|
||||
along with Caelum. If not, see <http://www.gnu.org/licenses/>.
|
||||
*/
|
||||
|
||||
// Global cloud textures
|
||||
sampler cloud_shape1 : register(s0);
|
||||
sampler cloud_shape2 : register(s1);
|
||||
sampler cloud_detail : register(s2);
|
||||
|
||||
// Get cloud layer intensity at a certain point.
|
||||
float LayeredClouds_intensity
|
||||
(
|
||||
in float2 pos,
|
||||
float cloudMassInvScale,
|
||||
float cloudDetailInvScale,
|
||||
float2 cloudMassOffset,
|
||||
float2 cloudDetailOffset,
|
||||
float cloudMassBlend,
|
||||
float cloudDetailBlend,
|
||||
float cloudCoverageThreshold
|
||||
)
|
||||
{
|
||||
// Calculate the base alpha
|
||||
float2 finalMassOffset = cloudMassOffset + pos;
|
||||
float aCloud = lerp(tex2D(cloud_shape1, finalMassOffset * cloudMassInvScale).r,
|
||||
tex2D(cloud_shape2, finalMassOffset * cloudMassInvScale).r,
|
||||
cloudMassBlend);
|
||||
float aDetail = tex2D(cloud_detail, (cloudDetailOffset + pos) * cloudDetailInvScale).r;
|
||||
aCloud = (aCloud + aDetail * cloudDetailBlend) / (1 + cloudDetailBlend);
|
||||
return max(0, aCloud - cloudCoverageThreshold);
|
||||
}
|
||||
|
||||
// Entry point for Cloud vertex program.
|
||||
void LayeredClouds_vp
|
||||
(
|
||||
in float4 position : POSITION,
|
||||
in float2 uv : TEXCOORD0,
|
||||
|
||||
uniform float4x4 worldViewProj,
|
||||
uniform float4x4 worldMatrix,
|
||||
uniform float3 sunDirection,
|
||||
|
||||
out float4 oPosition : POSITION,
|
||||
out float2 oUv : TEXCOORD0,
|
||||
out float3 relPosition : TEXCOORD1,
|
||||
out float sunGlow : TEXCOORD2,
|
||||
out float4 worldPosition : TEXCOORD3
|
||||
) {
|
||||
|
||||
oPosition = mul(worldViewProj, position);
|
||||
worldPosition = mul(worldMatrix, position);
|
||||
oUv = uv;
|
||||
|
||||
// This is the relative position, or view direction.
|
||||
relPosition = normalize (position.xyz);
|
||||
|
||||
// Calculate the angle between the direction of the sun and the current
|
||||
// view direction. This we call "glow" and ranges from 1 next to the sun
|
||||
// to -1 in the opposite direction.
|
||||
sunGlow = dot (relPosition, normalize (-sunDirection));
|
||||
}
|
||||
|
||||
float4 OldCloudColor
|
||||
(
|
||||
float2 uv,
|
||||
float3 relPosition,
|
||||
float sunGlow,
|
||||
|
||||
uniform float cloudMassInvScale,
|
||||
uniform float cloudDetailInvScale,
|
||||
uniform float2 cloudMassOffset,
|
||||
uniform float2 cloudDetailOffset,
|
||||
uniform float cloudMassBlend,
|
||||
uniform float cloudDetailBlend,
|
||||
|
||||
uniform float cloudCoverageThreshold,
|
||||
|
||||
uniform float4 sunColour,
|
||||
uniform float4 fogColour,
|
||||
uniform float cloudSharpness,
|
||||
uniform float cloudThickness
|
||||
|
||||
) {
|
||||
// Initialize output.
|
||||
float4 oCol = float4(1, 1, 1, 0);
|
||||
|
||||
// Get cloud intensity.
|
||||
float intensity = LayeredClouds_intensity
|
||||
(
|
||||
uv,
|
||||
cloudMassInvScale,
|
||||
cloudDetailInvScale,
|
||||
cloudMassOffset,
|
||||
cloudDetailOffset,
|
||||
cloudMassBlend,
|
||||
cloudDetailBlend,
|
||||
cloudCoverageThreshold
|
||||
);
|
||||
|
||||
// Opacity is exponential.
|
||||
float aCloud = saturate(exp(cloudSharpness * intensity) - 1);
|
||||
|
||||
float shine = pow(saturate(sunGlow), 8) / 4;
|
||||
sunColour.rgb *= 1.5;
|
||||
float3 cloudColour = fogColour.rgb * (1 - intensity / 3);
|
||||
float thickness = saturate(0.8 - exp(-cloudThickness * (intensity + 0.2 - shine)));
|
||||
|
||||
oCol.rgb = lerp(sunColour.rgb, cloudColour.rgb, thickness);
|
||||
oCol.a = aCloud;
|
||||
|
||||
return oCol;
|
||||
}
|
||||
|
||||
//Converts a color from RGB to YUV color space
|
||||
//the rgb color is in [0,1] [0,1] [0,1] range
|
||||
//the yuv color is in [0,1] [-0.436,0.436] [-0.615,0.615] range
|
||||
float3 YUVfromRGB(float3 col)
|
||||
{
|
||||
return float3(dot(col, float3(0.299,0.587,0.114)),
|
||||
dot(col, float3(-0.14713,-0.28886,0.436)),
|
||||
dot(col, float3(0.615,-0.51499,-0.10001)));
|
||||
}
|
||||
|
||||
float3 RGBfromYUV(float3 col)
|
||||
{
|
||||
return float3(dot(col,float3(1,0,1.13983)),
|
||||
dot(col,float3(1,-0.39465,-0.58060)),
|
||||
dot(col,float3(1,2.03211,0)));
|
||||
}
|
||||
|
||||
// Creates a color that has the intensity of col1 and the chrominance of col2
|
||||
float3 MagicColorMix(float3 col1, float3 col2)
|
||||
{
|
||||
return saturate(RGBfromYUV(float3(YUVfromRGB(col1).x, YUVfromRGB(col2).yz)));
|
||||
}
|
||||
|
||||
// Entry point for Cloud fragment program.
|
||||
void LayeredClouds_fp
|
||||
(
|
||||
in float2 uv : TEXCOORD0,
|
||||
in float3 relPosition : TEXCOORD1,
|
||||
in float sunGlow : TEXCOORD2,
|
||||
in float4 worldPosition : TEXCOORD3,
|
||||
|
||||
uniform float cloudMassInvScale,
|
||||
uniform float cloudDetailInvScale,
|
||||
uniform float2 cloudMassOffset,
|
||||
uniform float2 cloudDetailOffset,
|
||||
uniform float cloudMassBlend,
|
||||
uniform float cloudDetailBlend,
|
||||
|
||||
uniform float cloudCoverageThreshold,
|
||||
|
||||
uniform float4 sunLightColour,
|
||||
uniform float4 sunSphereColour,
|
||||
uniform float4 fogColour,
|
||||
uniform float4 sunDirection,
|
||||
uniform float cloudSharpness,
|
||||
uniform float cloudThickness,
|
||||
uniform float3 camera_position,
|
||||
|
||||
uniform float3 fadeDistMeasurementVector,
|
||||
uniform float layerHeight,
|
||||
uniform float cloudUVFactor,
|
||||
uniform float heightRedFactor,
|
||||
|
||||
uniform float nearFadeDist,
|
||||
uniform float farFadeDist,
|
||||
|
||||
out float4 oCol : COLOR
|
||||
) {
|
||||
uv *= cloudUVFactor;
|
||||
|
||||
oCol = OldCloudColor(
|
||||
uv, relPosition, sunGlow,
|
||||
cloudMassInvScale, cloudDetailInvScale,
|
||||
cloudMassOffset, cloudDetailOffset,
|
||||
cloudMassBlend, cloudDetailBlend,
|
||||
cloudCoverageThreshold,
|
||||
sunLightColour,
|
||||
fogColour,
|
||||
cloudSharpness,
|
||||
cloudThickness);
|
||||
oCol.r += layerHeight / heightRedFactor;
|
||||
|
||||
//float dist = distance(worldPosition.xyz, camera_position.xyz);
|
||||
float dist = length((worldPosition - camera_position) * fadeDistMeasurementVector);
|
||||
float aMod = 1;
|
||||
if (dist > nearFadeDist) {
|
||||
aMod = saturate(lerp(0, 1, (farFadeDist - dist) / (farFadeDist - nearFadeDist)));
|
||||
}
|
||||
float alfa = oCol.a * aMod;
|
||||
|
||||
float3 cloudDir = normalize(
|
||||
float3(worldPosition.x, layerHeight, worldPosition.y) - camera_position);
|
||||
float angleDiff = saturate(dot(cloudDir, normalize(sunDirection.xyz)));
|
||||
|
||||
float3 lCol = lerp(oCol.rgb, MagicColorMix(oCol.rgb, sunSphereColour.rgb), angleDiff);
|
||||
oCol.rgb = lerp(lCol, oCol.rgb, alfa);
|
||||
oCol.a = alfa;
|
||||
}
|
||||
@ -1,61 +0,0 @@
|
||||
/*
|
||||
This file is part of Caelum.
|
||||
See http://www.ogre3d.org/wiki/index.php/Caelum
|
||||
|
||||
Copyright (c) 2006-2007 Caelum team. See Contributors.txt for details.
|
||||
|
||||
Caelum is free software: you can redistribute it and/or modify
|
||||
it under the terms of the GNU Lesser General Public License as published
|
||||
by the Free Software Foundation, either version 3 of the License, or
|
||||
(at your option) any later version.
|
||||
|
||||
Caelum is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
GNU Lesser General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU Lesser General Public License
|
||||
along with Caelum. If not, see <http://www.gnu.org/licenses/>.
|
||||
*/
|
||||
|
||||
// Get how much of a certain point on the moon is seen (or not) because of the phase.
|
||||
// uv is the rect position on moon; as seen from the earth.
|
||||
// phase ranges from 0 to 2
|
||||
float MoonPhaseFactor(float2 uv, float phase)
|
||||
{
|
||||
float alpha = 1.0;
|
||||
|
||||
float srefx = uv.x - 0.5;
|
||||
float refx = abs(uv.x - 0.5);
|
||||
float refy = abs(uv.y - 0.5);
|
||||
float refxfory = sqrt(0.25 - refy * refy);
|
||||
float xmin = -refxfory;
|
||||
float xmax = refxfory;
|
||||
float xmin1 = (xmax - xmin) * (phase / 2) + xmin;
|
||||
float xmin2 = (xmax - xmin) * phase + xmin;
|
||||
if (srefx < xmin1) {
|
||||
alpha = 0;
|
||||
} else if (srefx < xmin2 && xmin1 != xmin2) {
|
||||
alpha = (srefx - xmin1) / (xmin2 - xmin1);
|
||||
}
|
||||
|
||||
return alpha;
|
||||
}
|
||||
|
||||
void PhaseMoonFP
|
||||
(
|
||||
in float2 uv: TEXCOORD0,
|
||||
uniform float phase,
|
||||
uniform sampler2D moonDisc: register(s0),
|
||||
out float4 outcol : COLOR
|
||||
)
|
||||
{
|
||||
outcol = tex2D(moonDisc, uv);
|
||||
float alpha = MoonPhaseFactor(uv, phase);
|
||||
|
||||
// Get luminance from the texture.
|
||||
float lum = dot(outcol.rgb, float3(0.3333, 0.3333, 0.3333));
|
||||
//float lum = dot(outcol.rgb, float3(0.3, 0.59, 0.11));
|
||||
outcol.a = min(outcol.a, lum * alpha);
|
||||
outcol.rgb /= lum;
|
||||
}
|
||||
@ -1,77 +0,0 @@
|
||||
/*
|
||||
This file is part of Caelum.
|
||||
See http://www.ogre3d.org/wiki/index.php/Caelum
|
||||
|
||||
Copyright (c) 2008 Caelum team. See Contributors.txt for details.
|
||||
|
||||
Caelum is free software: you can redistribute it and/or modify
|
||||
it under the terms of the GNU Lesser General Public License as published
|
||||
by the Free Software Foundation, either version 3 of the License, or
|
||||
(at your option) any later version.
|
||||
|
||||
Caelum is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
GNU Lesser General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU Lesser General Public License
|
||||
along with Caelum. If not, see <http://www.gnu.org/licenses/>.
|
||||
*/
|
||||
|
||||
void StarPointVP
|
||||
(
|
||||
in float4 in_position : POSITION,
|
||||
in float3 in_texcoord : TEXCOORD0,
|
||||
|
||||
uniform float4x4 worldviewproj_matrix,
|
||||
|
||||
// These params are in clipspace; not pixels
|
||||
uniform float mag_scale,
|
||||
uniform float mag0_size,
|
||||
uniform float min_size,
|
||||
uniform float max_size,
|
||||
uniform float render_target_flipping,
|
||||
|
||||
// width/height
|
||||
uniform float aspect_ratio,
|
||||
|
||||
out float2 out_texcoord : TEXCOORD0,
|
||||
out float4 out_position : POSITION,
|
||||
out float4 out_color : COLOR
|
||||
)
|
||||
{
|
||||
float4 in_color = float4(1, 1, 1, 1);
|
||||
out_position = mul(worldviewproj_matrix, in_position);
|
||||
out_texcoord = in_texcoord.xy;
|
||||
|
||||
float magnitude = in_texcoord.z;
|
||||
float size = exp(mag_scale * magnitude) * mag0_size;
|
||||
|
||||
// Fade below minSize.
|
||||
float fade = saturate(size / min_size);
|
||||
out_color = float4(in_color.rgb, fade * fade);
|
||||
|
||||
// Clamp size to range.
|
||||
size = clamp(size, min_size, max_size);
|
||||
|
||||
// Splat the billboard on the screen.
|
||||
out_position.xy +=
|
||||
out_position.w *
|
||||
in_texcoord.xy *
|
||||
float2(size, size * aspect_ratio * render_target_flipping);
|
||||
}
|
||||
|
||||
void StarPointFP
|
||||
(
|
||||
in float4 in_color : COLOR,
|
||||
in float2 in_texcoord : TEXCOORD0,
|
||||
|
||||
out float4 out_color : COLOR
|
||||
)
|
||||
{
|
||||
out_color = in_color;
|
||||
float sqlen = dot(in_texcoord, in_texcoord);
|
||||
|
||||
// A gaussian bell of sorts.
|
||||
out_color.a *= 1.5 * exp(-(sqlen * 8));
|
||||
}
|
||||
@ -1,193 +0,0 @@
|
||||
/*
|
||||
This file is part of Caelum.
|
||||
See http://www.ogre3d.org/wiki/index.php/Caelum
|
||||
|
||||
Copyright (c) 2006-2007 Caelum team. See Contributors.txt for details.
|
||||
|
||||
Caelum is free software: you can redistribute it and/or modify
|
||||
it under the terms of the GNU Lesser General Public License as published
|
||||
by the Free Software Foundation, either version 3 of the License, or
|
||||
(at your option) any later version.
|
||||
|
||||
Caelum is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
GNU Lesser General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU Lesser General Public License
|
||||
along with Caelum. If not, see <http://www.gnu.org/licenses/>.
|
||||
*/
|
||||
|
||||
float bias (float b, float x)
|
||||
{
|
||||
return pow (x, log (b) / log (0.5));
|
||||
}
|
||||
|
||||
float4 sunlightInscatter
|
||||
(
|
||||
float4 sunColour,
|
||||
float absorption,
|
||||
float incidenceAngleCos,
|
||||
float sunlightScatteringFactor
|
||||
)
|
||||
{
|
||||
float scatteredSunlight = bias (sunlightScatteringFactor * 0.5, incidenceAngleCos);
|
||||
|
||||
sunColour = sunColour * (1 - absorption) * float4 (0.9, 0.5, 0.09, 1);
|
||||
|
||||
return sunColour * scatteredSunlight;
|
||||
}
|
||||
|
||||
float fogExp (float z, float density) {
|
||||
return 1 - clamp (pow (2.71828, -z * density), 0, 1);
|
||||
}
|
||||
|
||||
void SkyDomeVP
|
||||
(
|
||||
in float4 position : POSITION,
|
||||
in float4 normal : NORMAL,
|
||||
in float2 uv : TEXCOORD0,
|
||||
|
||||
uniform float lightAbsorption,
|
||||
uniform float4x4 worldViewProj,
|
||||
uniform float3 sunDirection,
|
||||
|
||||
out float4 oPosition : POSITION,
|
||||
out float4 oCol : COLOR,
|
||||
out float2 oUv : TEXCOORD0,
|
||||
out float incidenceAngleCos : TEXCOORD1,
|
||||
out float y : TEXCOORD2,
|
||||
out float3 oNormal : TEXCOORD3
|
||||
)
|
||||
{
|
||||
sunDirection = normalize (sunDirection);
|
||||
normal = normalize (normal);
|
||||
float cosine = dot (-sunDirection, normal);
|
||||
incidenceAngleCos = -cosine;
|
||||
|
||||
y = -sunDirection.y;
|
||||
|
||||
oPosition = mul (worldViewProj, position);
|
||||
oCol = float4 (1, 1, 1, 1);
|
||||
oUv = uv;
|
||||
oNormal = -normal.xyz;
|
||||
}
|
||||
|
||||
void SkyDomeFP
|
||||
(
|
||||
float4 col : COLOR,
|
||||
float2 uv : TEXCOORD0,
|
||||
float incidenceAngleCos : TEXCOORD1,
|
||||
float y : TEXCOORD2,
|
||||
float3 normal : TEXCOORD3,
|
||||
|
||||
uniform sampler gradientsMap : register(s0),
|
||||
uniform sampler1D atmRelativeDepth : register(s1),
|
||||
uniform float4 hazeColour,
|
||||
uniform float offset,
|
||||
|
||||
out float4 oCol : COLOR
|
||||
)
|
||||
{
|
||||
float4 sunColour = float4 (3, 3, 3, 1);
|
||||
|
||||
#ifdef HAZE
|
||||
float fogDensity = 15;
|
||||
// Haze amount calculation
|
||||
float invHazeHeight = 100;
|
||||
float haze = fogExp (pow (clamp (1 - normal.y, 0, 1), invHazeHeight), fogDensity);
|
||||
#endif // HAZE
|
||||
|
||||
// Pass the colour
|
||||
oCol = tex2D (gradientsMap, uv + float2 (offset, 0)) * col;
|
||||
|
||||
// Sunlight inscatter
|
||||
if (incidenceAngleCos > 0)
|
||||
{
|
||||
float sunlightScatteringFactor = 0.05;
|
||||
float sunlightScatteringLossFactor = 0.1;
|
||||
float atmLightAbsorptionFactor = 0.1;
|
||||
|
||||
oCol.rgb += sunlightInscatter (
|
||||
sunColour,
|
||||
clamp (atmLightAbsorptionFactor * (1 - tex1D (atmRelativeDepth, y).r), 0, 1),
|
||||
clamp (incidenceAngleCos, 0, 1),
|
||||
sunlightScatteringFactor).rgb * (1 - sunlightScatteringLossFactor);
|
||||
}
|
||||
|
||||
#ifdef HAZE
|
||||
// Haze pass
|
||||
hazeColour.a = 1;
|
||||
oCol = oCol * (1 - haze) + hazeColour * haze;
|
||||
#endif // HAZE
|
||||
}
|
||||
|
||||
void HazeVP
|
||||
(
|
||||
in float4 position : POSITION,
|
||||
in float4 normal : NORMAL,
|
||||
|
||||
uniform float4x4 worldViewProj,
|
||||
uniform float4 camPos,
|
||||
uniform float3 sunDirection,
|
||||
|
||||
out float4 oPosition : POSITION,
|
||||
out float haze : TEXCOORD0,
|
||||
out float2 sunlight : TEXCOORD1
|
||||
)
|
||||
{
|
||||
sunDirection = normalize (sunDirection);
|
||||
oPosition = mul(worldViewProj, position);
|
||||
haze = length (camPos - position);
|
||||
sunlight.x = dot (-sunDirection, normalize (position - camPos));
|
||||
sunlight.y = -sunDirection.y;
|
||||
}
|
||||
|
||||
void HazeFP
|
||||
(
|
||||
in float haze : TEXCOORD0,
|
||||
in float2 sunlight : TEXCOORD1,
|
||||
|
||||
uniform sampler1D atmRelativeDepth : register(s0),
|
||||
uniform sampler2D gradientsMap : register (s1),
|
||||
uniform float4 fogColour,
|
||||
|
||||
out float4 oCol : COLOR
|
||||
)
|
||||
{
|
||||
float incidenceAngleCos = sunlight.x;
|
||||
float y = sunlight.y;
|
||||
|
||||
float4 sunColour = float4 (3, 2.5, 1, 1);
|
||||
|
||||
// Factor determining the amount of light lost due to absorption
|
||||
float atmLightAbsorptionFactor = 0.1;
|
||||
float fogDensity = 15;
|
||||
|
||||
haze = fogExp (haze * 0.005, atmLightAbsorptionFactor);
|
||||
|
||||
// Haze amount calculation
|
||||
float invHazeHeight = 100;
|
||||
float hazeAbsorption = fogExp (pow (1 - y, invHazeHeight), fogDensity);
|
||||
|
||||
float4 hazeColour;
|
||||
hazeColour = fogColour;
|
||||
if (incidenceAngleCos > 0) {
|
||||
// Factor determining the amount of scattering for the sun light
|
||||
float sunlightScatteringFactor = 0.1;
|
||||
// Factor determining the amount of sun light intensity lost due to scattering
|
||||
float sunlightScatteringLossFactor = 0.3;
|
||||
|
||||
float4 sunlightInscatterColour = sunlightInscatter (
|
||||
sunColour,
|
||||
clamp ((1 - tex1D (atmRelativeDepth, y).r) * hazeAbsorption, 0, 1),
|
||||
clamp (incidenceAngleCos, 0, 1),
|
||||
sunlightScatteringFactor) * (1 - sunlightScatteringLossFactor);
|
||||
hazeColour.rgb =
|
||||
hazeColour.rgb * (1 - sunlightInscatterColour.a) +
|
||||
sunlightInscatterColour.rgb * sunlightInscatterColour.a * haze;
|
||||
}
|
||||
|
||||
oCol = hazeColour;
|
||||
oCol.a = haze;
|
||||
}
|
||||
Binary file not shown.
|
Before Width: | Height: | Size: 262 B |
@ -1,253 +0,0 @@
|
||||
//
|
||||
// This file is part of Caelum.
|
||||
// See http://www.ogre3d.org/wiki/index.php/Caelum
|
||||
//
|
||||
// Copyright (c) 2008 Caelum team. See Contributors.txt for details.
|
||||
//
|
||||
// Caelum is free software: you can redistribute it and/or modify
|
||||
// it under the terms of the GNU Lesser General Public License as published
|
||||
// by the Free Software Foundation, either version 3 of the License, or
|
||||
// (at your option) any later version.
|
||||
//
|
||||
// Caelum is distributed in the hope that it will be useful,
|
||||
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
// GNU Lesser General Public License for more details.
|
||||
//
|
||||
// You should have received a copy of the GNU Lesser General Public License
|
||||
// along with Caelum. If not, see <http://www.gnu.org/licenses/>.
|
||||
//
|
||||
|
||||
#ifdef EXP_GROUND_FOG
|
||||
|
||||
// Returns (exp(x) - 1) / x; avoiding division by 0.
|
||||
// lim when x -> 0 is 1.
|
||||
float expdiv(float x) {
|
||||
if (abs(x) < 0.0001) {
|
||||
return 1;
|
||||
} else {
|
||||
return (exp(x) - 1) / x;
|
||||
}
|
||||
}
|
||||
|
||||
// Return fogging through a layer of fog which drops exponentially by height.
|
||||
//
|
||||
// Standard exp fog with constant density would return (1 - exp(-density * dist)).
|
||||
// This function assumes a variable density vd = exp(-verticalDecay * h - baseLevel)
|
||||
// Full computation is exp(density * dist / (h2 - h1) * int(h1, h2, exp(-verticalDecay * (h2 - h1)))).
|
||||
//
|
||||
// This will gracefully degrade to standard exp fog in verticalDecay is 0; without throwing NaNs.
|
||||
float ExpGroundFog (
|
||||
float dist, float h1, float h2,
|
||||
float density, float verticalDecay, float baseLevel)
|
||||
{
|
||||
float deltaH = (h2 - h1);
|
||||
return 1 - exp (-density * dist * exp(verticalDecay * (baseLevel - h1)) * expdiv(-verticalDecay * deltaH));
|
||||
}
|
||||
|
||||
#endif // EXP_GROUND_FOG
|
||||
|
||||
#ifdef SKY_DOME_HAZE
|
||||
|
||||
float bias (float b, float x)
|
||||
{
|
||||
return pow (x, log (b) / log (0.5));
|
||||
}
|
||||
|
||||
float4 sunlightInscatter
|
||||
(
|
||||
float4 sunColour,
|
||||
float absorption,
|
||||
float incidenceAngleCos,
|
||||
float sunlightScatteringFactor
|
||||
)
|
||||
{
|
||||
float scatteredSunlight = bias (sunlightScatteringFactor * 0.5, incidenceAngleCos);
|
||||
|
||||
sunColour = sunColour * (1 - absorption) * float4 (0.9, 0.5, 0.09, 1);
|
||||
|
||||
return sunColour * scatteredSunlight;
|
||||
}
|
||||
|
||||
float fogExp (float z, float density) {
|
||||
return 1 - clamp (pow (2.71828, -z * density), 0, 1);
|
||||
}
|
||||
|
||||
uniform sampler1D atmRelativeDepth : register(HAZE_DEPTH_TEXTURE);
|
||||
|
||||
float4 CalcHaze
|
||||
(
|
||||
float3 worldPos,
|
||||
float3 worldCamPos,
|
||||
float3 hazeColour,
|
||||
float3 sunDirection
|
||||
)
|
||||
{
|
||||
float haze = length (worldCamPos - worldPos);
|
||||
float incidenceAngleCos = dot (-sunDirection, normalize (worldPos - worldCamPos));
|
||||
float y = -sunDirection.y;
|
||||
|
||||
float4 sunColour = float4 (3, 2.5, 1, 1);
|
||||
|
||||
// Factor determining the amount of light lost due to absorption
|
||||
float atmLightAbsorptionFactor = 0.1;
|
||||
float fogDensity = 15;
|
||||
|
||||
haze = fogExp (haze * 0.005, atmLightAbsorptionFactor);
|
||||
|
||||
// Haze amount calculation
|
||||
float invHazeHeight = 100;
|
||||
float hazeAbsorption = fogExp (pow (1 - y, invHazeHeight), fogDensity);
|
||||
|
||||
if (incidenceAngleCos > 0) {
|
||||
// Factor determining the amount of scattering for the sun light
|
||||
float sunlightScatteringFactor = 0.1;
|
||||
// Factor determining the amount of sun light intensity lost due to scattering
|
||||
float sunlightScatteringLossFactor = 0.3;
|
||||
|
||||
float4 sunlightInscatterColour = sunlightInscatter (
|
||||
sunColour,
|
||||
clamp ((1 - tex1D (atmRelativeDepth, y).r) * hazeAbsorption, 0, 1),
|
||||
clamp (incidenceAngleCos, 0, 1),
|
||||
sunlightScatteringFactor) * (1 - sunlightScatteringLossFactor);
|
||||
hazeColour =
|
||||
hazeColour * (1 - sunlightInscatterColour.a) +
|
||||
sunlightInscatterColour.rgb * sunlightInscatterColour.a * haze;
|
||||
}
|
||||
|
||||
return float4(hazeColour.rgb, haze);
|
||||
}
|
||||
|
||||
#endif // SKY_DOME_HAZE
|
||||
|
||||
void MainFP
|
||||
(
|
||||
in float2 screenPos : TEXCOORD0,
|
||||
|
||||
uniform float4x4 invViewProjMatrix,
|
||||
uniform float4 worldCameraPos,
|
||||
|
||||
#if EXP_GROUND_FOG
|
||||
uniform float groundFogDensity,
|
||||
uniform float groundFogVerticalDecay,
|
||||
uniform float groundFogBaseLevel,
|
||||
uniform float4 groundFogColour,
|
||||
#endif // EXP_GROUND_FOG
|
||||
|
||||
#if SKY_DOME_HAZE
|
||||
uniform float3 hazeColour,
|
||||
uniform float3 sunDirection,
|
||||
#endif // SKY_DOME_HAZE
|
||||
|
||||
sampler screenTexture: register(s0),
|
||||
sampler depthTexture: register(s1),
|
||||
|
||||
out float4 outColor : COLOR
|
||||
)
|
||||
{
|
||||
float4 inColor = tex2D(screenTexture, screenPos);
|
||||
float inDepth = tex2D(depthTexture, screenPos).r;
|
||||
|
||||
// Build normalized device coords; after the perspective divide.
|
||||
//float4 devicePos = float4(1 - screenPos.x * 2, screenPos.y * 2 - 1, inDepth, 1);
|
||||
//float4 devicePos = float4(screenPos.x * 2 - 1, 1 - screenPos.y * 2, 2 * inDepth - 1, 1);
|
||||
float4 devicePos = float4(screenPos.x * 2 - 1, 1 - screenPos.y * 2, inDepth, 1);
|
||||
|
||||
// Go back from device to world coordinates.
|
||||
float4 worldPos = mul(invViewProjMatrix, devicePos);
|
||||
|
||||
// Now undo the perspective divide and go back to "normal" space.
|
||||
worldPos /= worldPos.w;
|
||||
|
||||
float4 color = inColor;
|
||||
|
||||
#if DEBUG_DEPTH_RENDER
|
||||
//color = abs(float4(inDepth, inDepth, inDepth, 1));
|
||||
color = worldPos * float4(0.001, 0.01, 0.001, 1);
|
||||
#endif // DEBUG_DEPTH_RENDER
|
||||
|
||||
#if EXP_GROUND_FOG
|
||||
// Ye olde ground fog.
|
||||
float h1 = worldCameraPos.y;
|
||||
float h2 = worldPos.y;
|
||||
float dist = length(worldCameraPos - worldPos);
|
||||
float fogFactor = ExpGroundFog(
|
||||
dist, h1, h2,
|
||||
groundFogDensity, groundFogVerticalDecay, groundFogBaseLevel);
|
||||
color = lerp(color, groundFogColour, fogFactor);
|
||||
#endif // EXP_GROUND_FOG
|
||||
|
||||
#if SKY_DOME_HAZE
|
||||
float4 hazeValue = CalcHaze (
|
||||
worldPos.xyz,
|
||||
worldCameraPos.xyz,
|
||||
hazeColour,
|
||||
sunDirection);
|
||||
color.rgb = lerp(color.rgb, hazeValue.rgb, hazeValue.a);
|
||||
#endif // SKY_DOME_HAZE
|
||||
|
||||
outColor = color;
|
||||
}
|
||||
|
||||
void DepthRenderVP
|
||||
(
|
||||
float4 inPos : POSITION,
|
||||
|
||||
uniform float4x4 wvpMatrix,
|
||||
|
||||
out float4 magic : TEXCOORD0,
|
||||
out float4 outPos : POSITION
|
||||
)
|
||||
{
|
||||
// Standard transform.
|
||||
outPos = mul(wvpMatrix, inPos);
|
||||
|
||||
// Depth buffer is z/w.
|
||||
// Let the GPU lerp the components of outPos.
|
||||
magic = outPos;
|
||||
}
|
||||
|
||||
void DepthRenderFP
|
||||
(
|
||||
in float4 magic : TEXCOORD0,
|
||||
out float4 output : COLOR
|
||||
)
|
||||
{
|
||||
output = float4(magic.z / magic.w);
|
||||
//output = float4(magic.xy / magic.w, 1, 1);
|
||||
}
|
||||
|
||||
void DepthRenderAlphaRejectionVP
|
||||
(
|
||||
float4 inPos : POSITION,
|
||||
float4 inTexcoord : TEXCOORD0,
|
||||
|
||||
uniform float4x4 wvpMatrix,
|
||||
|
||||
out float4 outTexcoord : TEXCOORD0,
|
||||
out float4 magic : TEXCOORD1,
|
||||
out float4 outPos : POSITION
|
||||
)
|
||||
{
|
||||
// Standard transform.
|
||||
outPos = mul(wvpMatrix, inPos);
|
||||
|
||||
// Depth buffer is z/w.
|
||||
// Let the GPU lerp the components of outPos.
|
||||
magic = outPos;
|
||||
|
||||
outTexcoord = inTexcoord;
|
||||
}
|
||||
|
||||
void DepthRenderAlphaRejectionFP
|
||||
(
|
||||
in float4 texcoord : TEXCOORD0,
|
||||
in float4 magic : TEXCOORD1,
|
||||
sampler mainTex: register(s0),
|
||||
out float4 output : COLOR
|
||||
)
|
||||
{
|
||||
float4 texvalue = tex2D(mainTex, texcoord.xy);
|
||||
// texvalue.a = sin(100 * texcoord.x) + sin(100 * texcoord.y);
|
||||
output = float4(float3(magic.z / magic.w), texvalue.a);
|
||||
}
|
||||
@ -1,139 +0,0 @@
|
||||
//
|
||||
// This file is part of Caelum.
|
||||
// See http://www.ogre3d.org/wiki/index.php/Caelum
|
||||
//
|
||||
// Copyright (c) 2008 Caelum team. See Contributors.txt for details.
|
||||
//
|
||||
// Caelum is free software: you can redistribute it and/or modify
|
||||
// it under the terms of the GNU Lesser General Public License as published
|
||||
// by the Free Software Foundation, either version 3 of the License, or
|
||||
// (at your option) any later version.
|
||||
//
|
||||
// Caelum is distributed in the hope that it will be useful,
|
||||
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
// GNU Lesser General Public License for more details.
|
||||
//
|
||||
// You should have received a copy of the GNU Lesser General Public License
|
||||
// along with Caelum. If not, see <http://www.gnu.org/licenses/>.
|
||||
//
|
||||
|
||||
compositor Caelum/DepthComposer_DebugDepthRender
|
||||
{
|
||||
technique
|
||||
{
|
||||
texture rt0 target_width target_height PF_A8R8G8B8
|
||||
|
||||
target rt0
|
||||
{
|
||||
input previous
|
||||
}
|
||||
|
||||
target_output
|
||||
{
|
||||
input none
|
||||
|
||||
pass render_quad
|
||||
{
|
||||
material Caelum/DepthComposer_DebugDepthRender
|
||||
input 0 rt0
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
compositor Caelum/DepthComposer_Dummy
|
||||
{
|
||||
technique
|
||||
{
|
||||
texture rt0 target_width target_height PF_A8R8G8B8
|
||||
|
||||
target rt0
|
||||
{
|
||||
input previous
|
||||
}
|
||||
|
||||
target_output
|
||||
{
|
||||
input none
|
||||
|
||||
pass render_quad
|
||||
{
|
||||
material Caelum/DepthComposer_Dummy
|
||||
input 0 rt0
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
compositor Caelum/DepthComposer_ExpGroundFog
|
||||
{
|
||||
technique
|
||||
{
|
||||
texture rt0 target_width target_height PF_A8R8G8B8
|
||||
|
||||
target rt0
|
||||
{
|
||||
input previous
|
||||
}
|
||||
|
||||
target_output
|
||||
{
|
||||
input none
|
||||
|
||||
pass render_quad
|
||||
{
|
||||
material Caelum/DepthComposer_ExpGroundFog
|
||||
input 0 rt0
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
compositor Caelum/DepthComposer_SkyDomeHaze
|
||||
{
|
||||
technique
|
||||
{
|
||||
texture rt0 target_width target_height PF_A8R8G8B8
|
||||
|
||||
target rt0
|
||||
{
|
||||
input previous
|
||||
}
|
||||
|
||||
target_output
|
||||
{
|
||||
input none
|
||||
|
||||
pass render_quad
|
||||
{
|
||||
material Caelum/DepthComposer_SkyDomeHaze
|
||||
input 0 rt0
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
compositor Caelum/DepthComposer_SkyDomeHaze_ExpGroundFog
|
||||
{
|
||||
technique
|
||||
{
|
||||
texture rt0 target_width target_height PF_A8R8G8B8
|
||||
|
||||
target rt0
|
||||
{
|
||||
input previous
|
||||
}
|
||||
|
||||
target_output
|
||||
{
|
||||
input none
|
||||
|
||||
pass render_quad
|
||||
{
|
||||
material Caelum/DepthComposer_SkyDomeHaze_ExpGroundFog
|
||||
input 0 rt0
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -1,302 +0,0 @@
|
||||
//
|
||||
// This file is part of Caelum.
|
||||
// See http://www.ogre3d.org/wiki/index.php/Caelum
|
||||
//
|
||||
// Copyright (c) 2008 Caelum team. See Contributors.txt for details.
|
||||
//
|
||||
// Caelum is free software: you can redistribute it and/or modify
|
||||
// it under the terms of the GNU Lesser General Public License as published
|
||||
// by the Free Software Foundation, either version 3 of the License, or
|
||||
// (at your option) any later version.
|
||||
//
|
||||
// Caelum is distributed in the hope that it will be useful,
|
||||
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
// GNU Lesser General Public License for more details.
|
||||
//
|
||||
// You should have received a copy of the GNU Lesser General Public License
|
||||
// along with Caelum. If not, see <http://www.gnu.org/licenses/>.
|
||||
//
|
||||
|
||||
fragment_program Caelum/DepthComposerFP_Dummy cg
|
||||
{
|
||||
source DepthComposer.cg
|
||||
entry_point MainFP
|
||||
profiles ps_3_0 arbfp1
|
||||
|
||||
default_params
|
||||
{
|
||||
}
|
||||
}
|
||||
|
||||
fragment_program Caelum/DepthComposerFP_DebugDepthRender cg
|
||||
{
|
||||
source DepthComposer.cg
|
||||
entry_point MainFP
|
||||
profiles ps_3_0 arbfp1
|
||||
compile_arguments -DDEBUG_DEPTH_RENDER=1
|
||||
|
||||
default_params
|
||||
{
|
||||
param_named invViewProjMatrix float4x4 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
|
||||
}
|
||||
}
|
||||
|
||||
fragment_program Caelum/DepthComposerFP_ExpGroundFog cg
|
||||
{
|
||||
source DepthComposer.cg
|
||||
entry_point MainFP
|
||||
profiles ps_3_0 arbfp1
|
||||
compile_arguments -DEXP_GROUND_FOG=1
|
||||
|
||||
default_params
|
||||
{
|
||||
param_named invViewProjMatrix float4x4 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
|
||||
|
||||
param_named worldCameraPos float4 0 0 0 0
|
||||
|
||||
param_named groundFogDensity float 0.1
|
||||
param_named groundFogVerticalDecay float 0.2
|
||||
param_named groundFogBaseLevel float 5
|
||||
param_named groundFogColour float4 1 0 1 1
|
||||
}
|
||||
}
|
||||
|
||||
fragment_program Caelum/DepthComposerFP_SkyDomeHaze cg
|
||||
{
|
||||
source DepthComposer.cg
|
||||
entry_point MainFP
|
||||
profiles ps_3_0 arbfp1
|
||||
compile_arguments -DSKY_DOME_HAZE=1 -DHAZE_DEPTH_TEXTURE=s2
|
||||
|
||||
default_params
|
||||
{
|
||||
param_named invViewProjMatrix float4x4 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
|
||||
|
||||
param_named worldCameraPos float4 0 0 0 0
|
||||
|
||||
param_named sunDirection float3 0 1 0
|
||||
param_named hazeColour float3 0.1 0.2 0.6
|
||||
}
|
||||
}
|
||||
|
||||
fragment_program Caelum/DepthComposerFP_SkyDomeHaze_ExpGroundFog cg
|
||||
{
|
||||
source DepthComposer.cg
|
||||
entry_point MainFP
|
||||
profiles ps_3_0 arbfp1
|
||||
compile_arguments -DEXP_GROUND_FOG=1 -DSKY_DOME_HAZE=1 -DHAZE_DEPTH_TEXTURE=s2
|
||||
|
||||
default_params
|
||||
{
|
||||
param_named invViewProjMatrix float4x4 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
|
||||
|
||||
param_named worldCameraPos float4 0 0 0 0
|
||||
|
||||
param_named sunDirection float3 0 1 0
|
||||
param_named hazeColour float3 0.1 0.2 0.6
|
||||
|
||||
param_named groundFogDensity float 0.1
|
||||
param_named groundFogVerticalDecay float 0.2
|
||||
param_named groundFogBaseLevel float 5
|
||||
param_named groundFogColour float4 1 0 1 1
|
||||
}
|
||||
}
|
||||
|
||||
material Caelum/DepthRender
|
||||
{
|
||||
technique Default
|
||||
{
|
||||
pass Main
|
||||
{
|
||||
// This is required!
|
||||
depth_write on
|
||||
depth_check on
|
||||
|
||||
vertex_program_ref Caelum/DepthRenderVP
|
||||
{
|
||||
}
|
||||
|
||||
fragment_program_ref Caelum/DepthRenderFP
|
||||
{
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Material for rendering depth of an alpha-rejection material.
|
||||
//
|
||||
// Unlike the regular Caelum/DepthRender this also outputs alpha from a texture.
|
||||
// The shaders (VP/FP) can be trivially used in more complex materials.
|
||||
material Caelum/DepthRenderAlphaRejection
|
||||
{
|
||||
technique Default
|
||||
{
|
||||
pass Main
|
||||
{
|
||||
depth_write on
|
||||
depth_check on
|
||||
|
||||
vertex_program_ref Caelum/DepthRenderAlphaRejectionVP
|
||||
{
|
||||
}
|
||||
|
||||
fragment_program_ref Caelum/DepthRenderAlphaRejectionFP
|
||||
{
|
||||
}
|
||||
|
||||
alpha_rejection greater 128
|
||||
texture_unit Main
|
||||
{
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
material Caelum/DepthComposer_Dummy
|
||||
{
|
||||
technique Default
|
||||
{
|
||||
pass Main
|
||||
{
|
||||
vertex_program_ref Caelum/MinimalCompositorVP
|
||||
{
|
||||
}
|
||||
|
||||
fragment_program_ref Caelum/DepthComposerFP_Dummy
|
||||
{
|
||||
}
|
||||
|
||||
texture_unit Screen
|
||||
{
|
||||
filtering none
|
||||
}
|
||||
|
||||
texture_unit Depth
|
||||
{
|
||||
filtering none
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
material Caelum/DepthComposer_DebugDepthRender
|
||||
{
|
||||
technique Default
|
||||
{
|
||||
pass Main
|
||||
{
|
||||
vertex_program_ref Caelum/MinimalCompositorVP
|
||||
{
|
||||
}
|
||||
|
||||
fragment_program_ref Caelum/DepthComposerFP_DebugDepthRender
|
||||
{
|
||||
}
|
||||
|
||||
texture_unit Screen
|
||||
{
|
||||
filtering none
|
||||
}
|
||||
|
||||
texture_unit Depth
|
||||
{
|
||||
filtering none
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
material Caelum/DepthComposer_ExpGroundFog
|
||||
{
|
||||
technique Default
|
||||
{
|
||||
pass Main
|
||||
{
|
||||
vertex_program_ref Caelum/MinimalCompositorVP
|
||||
{
|
||||
}
|
||||
|
||||
fragment_program_ref Caelum/DepthComposerFP_ExpGroundFog
|
||||
{
|
||||
}
|
||||
|
||||
texture_unit Screen
|
||||
{
|
||||
filtering none
|
||||
}
|
||||
|
||||
texture_unit Depth
|
||||
{
|
||||
filtering none
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
material Caelum/DepthComposer_SkyDomeHaze
|
||||
{
|
||||
technique Default
|
||||
{
|
||||
pass Main
|
||||
{
|
||||
vertex_program_ref Caelum/MinimalCompositorVP
|
||||
{
|
||||
}
|
||||
|
||||
fragment_program_ref Caelum/DepthComposerFP_SkyDomeHaze
|
||||
{
|
||||
}
|
||||
|
||||
texture_unit Screen
|
||||
{
|
||||
filtering none
|
||||
}
|
||||
|
||||
texture_unit Depth
|
||||
{
|
||||
filtering none
|
||||
}
|
||||
|
||||
texture_unit AtmosphereDepth
|
||||
{
|
||||
texture AtmosphereDepth.png 1d
|
||||
tex_address_mode clamp
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
material Caelum/DepthComposer_SkyDomeHaze_ExpGroundFog
|
||||
{
|
||||
technique Default
|
||||
{
|
||||
pass Main
|
||||
{
|
||||
vertex_program_ref Caelum/MinimalCompositorVP
|
||||
{
|
||||
}
|
||||
|
||||
fragment_program_ref Caelum/DepthComposerFP_SkyDomeHaze_ExpGroundFog
|
||||
{
|
||||
}
|
||||
|
||||
texture_unit Screen
|
||||
{
|
||||
filtering none
|
||||
}
|
||||
|
||||
texture_unit Depth
|
||||
{
|
||||
filtering none
|
||||
}
|
||||
|
||||
texture_unit AtmosphereDepth
|
||||
{
|
||||
texture AtmosphereDepth.png 1d
|
||||
filtering bilinear
|
||||
tex_address_mode clamp
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -1,57 +0,0 @@
|
||||
//
|
||||
// This file is part of Caelum.
|
||||
// See http://www.ogre3d.org/wiki/index.php/Caelum
|
||||
//
|
||||
// Copyright (c) 2008 Caelum team. See Contributors.txt for details.
|
||||
//
|
||||
// Caelum is free software: you can redistribute it and/or modify
|
||||
// it under the terms of the GNU Lesser General Public License as published
|
||||
// by the Free Software Foundation, either version 3 of the License, or
|
||||
// (at your option) any later version.
|
||||
//
|
||||
// Caelum is distributed in the hope that it will be useful,
|
||||
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
// GNU Lesser General Public License for more details.
|
||||
//
|
||||
// You should have received a copy of the GNU Lesser General Public License
|
||||
// along with Caelum. If not, see <http://www.gnu.org/licenses/>.
|
||||
//
|
||||
|
||||
vertex_program Caelum/DepthRenderVP cg
|
||||
{
|
||||
source DepthComposer.cg
|
||||
entry_point DepthRenderVP
|
||||
profiles vs_2_0 arbvp1
|
||||
|
||||
default_params
|
||||
{
|
||||
param_named_auto wvpMatrix worldviewproj_matrix
|
||||
}
|
||||
}
|
||||
|
||||
fragment_program Caelum/DepthRenderFP cg
|
||||
{
|
||||
source DepthComposer.cg
|
||||
entry_point DepthRenderFP
|
||||
profiles ps_3_0 fp40 arbfp1
|
||||
}
|
||||
|
||||
vertex_program Caelum/DepthRenderAlphaRejectionVP cg
|
||||
{
|
||||
source DepthComposer.cg
|
||||
entry_point DepthRenderAlphaRejectionVP
|
||||
profiles vs_2_0 arbvp1
|
||||
|
||||
default_params
|
||||
{
|
||||
param_named_auto wvpMatrix worldviewproj_matrix
|
||||
}
|
||||
}
|
||||
|
||||
fragment_program Caelum/DepthRenderAlphaRejectionFP cg
|
||||
{
|
||||
source DepthComposer.cg
|
||||
entry_point DepthRenderAlphaRejectionFP
|
||||
profiles ps_3_0 fp40 arbfp1
|
||||
}
|
||||
Binary file not shown.
|
Before Width: | Height: | Size: 3.0 KiB |
@ -1,71 +0,0 @@
|
||||
//
|
||||
//This file is part of Caelum.
|
||||
//See http://www.ogre3d.org/wiki/index.php/Caelum
|
||||
//
|
||||
//Copyright (c) 2006-2007 Caelum team. See Contributors.txt for details.
|
||||
//
|
||||
//Caelum is free software: you can redistribute it and/or modify
|
||||
//it under the terms of the GNU Lesser General Public License as published
|
||||
//by the Free Software Foundation, either version 3 of the License, or
|
||||
//(at your option) any later version.
|
||||
//
|
||||
//Caelum is distributed in the hope that it will be useful,
|
||||
//but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
//MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
//GNU Lesser General Public License for more details.
|
||||
//
|
||||
//You should have received a copy of the GNU Lesser General Public License
|
||||
//along with Caelum. If not, see <http://www.gnu.org/licenses/>.
|
||||
//
|
||||
|
||||
// Sample base material for using CaelumGroundFog.
|
||||
material CaelumGroundFogBase
|
||||
{
|
||||
technique Default
|
||||
{
|
||||
pass Main
|
||||
{
|
||||
fog_override true none
|
||||
}
|
||||
|
||||
// Fog pass
|
||||
pass CaelumGroundFog
|
||||
{
|
||||
vertex_program_ref CaelumGroundFogVP
|
||||
{
|
||||
}
|
||||
|
||||
fragment_program_ref CaelumGroundFogFP
|
||||
{
|
||||
}
|
||||
|
||||
scene_blend alpha_blend
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
material CaelumGroundFogDome
|
||||
{
|
||||
receive_shadows off
|
||||
|
||||
technique
|
||||
{
|
||||
pass
|
||||
{
|
||||
lighting off
|
||||
depth_check off
|
||||
depth_write off
|
||||
fog_override true
|
||||
scene_blend alpha_blend
|
||||
cull_hardware none
|
||||
|
||||
vertex_program_ref CaelumGroundFogDomeVP
|
||||
{
|
||||
}
|
||||
|
||||
fragment_program_ref CaelumGroundFogDomeFP
|
||||
{
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -1,83 +0,0 @@
|
||||
//
|
||||
//This file is part of Caelum.
|
||||
//See http://www.ogre3d.org/wiki/index.php/Caelum
|
||||
//
|
||||
//Copyright (c) 2006-2007 Caelum team. See Contributors.txt for details.
|
||||
//
|
||||
//Caelum is free software: you can redistribute it and/or modify
|
||||
//it under the terms of the GNU Lesser General Public License as published
|
||||
//by the Free Software Foundation, either version 3 of the License, or
|
||||
//(at your option) any later version.
|
||||
//
|
||||
//Caelum is distributed in the hope that it will be useful,
|
||||
//but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
//MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
//GNU Lesser General Public License for more details.
|
||||
//
|
||||
//You should have received a copy of the GNU Lesser General Public License
|
||||
//along with Caelum. If not, see <http://www.gnu.org/licenses/>.
|
||||
//
|
||||
|
||||
vertex_program CaelumGroundFogVP cg
|
||||
{
|
||||
source CaelumGroundFog.cg
|
||||
entry_point GroundFog_vp
|
||||
profiles vs_2_x arbvp1 vp30
|
||||
|
||||
default_params
|
||||
{
|
||||
param_named_auto worldViewProj worldviewproj_matrix
|
||||
param_named_auto world world_matrix
|
||||
}
|
||||
}
|
||||
|
||||
fragment_program CaelumGroundFogFP cg
|
||||
{
|
||||
source CaelumGroundFog.cg
|
||||
entry_point GroundFog_fp
|
||||
profiles ps_2_x arbfp1 fp30
|
||||
|
||||
default_params
|
||||
{
|
||||
param_named_auto camPos camera_position
|
||||
|
||||
// _auto seems wrong here, since the fog formulas are different than
|
||||
// for standard exp fog.
|
||||
param_named fogDensity float 0
|
||||
param_named fogVerticalDecay float 0
|
||||
param_named fogGroundLevel float 0
|
||||
param_named fogColour float4 0 0 0 0
|
||||
}
|
||||
}
|
||||
|
||||
vertex_program CaelumGroundFogDomeVP cg
|
||||
{
|
||||
source CaelumGroundFog.cg
|
||||
entry_point GroundFogDome_vp
|
||||
profiles vs_2_0 arbvp1
|
||||
|
||||
default_params
|
||||
{
|
||||
param_named_auto worldViewProj worldviewproj_matrix
|
||||
}
|
||||
}
|
||||
|
||||
fragment_program CaelumGroundFogDomeFP cg
|
||||
{
|
||||
source CaelumGroundFog.cg
|
||||
entry_point GroundFogDome_fp
|
||||
profiles ps_2_0 arbfp1
|
||||
|
||||
default_params
|
||||
{
|
||||
// Fog parameters.
|
||||
param_named fogColour float4 0 0 0 0
|
||||
param_named fogDensity float 0
|
||||
param_named fogVerticalDecay float 0
|
||||
param_named fogGroundLevel float 0
|
||||
|
||||
// Send camera height. We can't send camera_position because
|
||||
// the entity is always moved with the camera. Joy.
|
||||
param_named cameraHeight float 0
|
||||
}
|
||||
}
|
||||
@ -1,44 +0,0 @@
|
||||
//
|
||||
//This file is part of Caelum.
|
||||
//See http://www.ogre3d.org/wiki/index.php/Caelum
|
||||
//
|
||||
//Copyright (c) 2006-2007 Caelum team. See Contributors.txt for details.
|
||||
//
|
||||
//Caelum is free software: you can redistribute it and/or modify
|
||||
//it under the terms of the GNU Lesser General Public License as published
|
||||
//by the Free Software Foundation, either version 3 of the License, or
|
||||
//(at your option) any later version.
|
||||
//
|
||||
//Caelum is distributed in the hope that it will be useful,
|
||||
//but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
//MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
//GNU Lesser General Public License for more details.
|
||||
//
|
||||
//You should have received a copy of the GNU Lesser General Public License
|
||||
//along with Caelum. If not, see <http://www.gnu.org/licenses/>.
|
||||
//
|
||||
|
||||
vertex_program CaelumHazeVP cg
|
||||
{
|
||||
source CaelumSkyDome.cg
|
||||
entry_point HazeVP
|
||||
profiles vs_2_0 arbvp1 vp30
|
||||
|
||||
default_params
|
||||
{
|
||||
param_named_auto worldViewProj worldviewproj_matrix
|
||||
param_named_auto camPos camera_position
|
||||
}
|
||||
}
|
||||
|
||||
fragment_program CaelumHazeFP cg
|
||||
{
|
||||
source CaelumSkyDome.cg
|
||||
entry_point HazeFP
|
||||
profiles ps_2_0 arbfp1 fp30
|
||||
|
||||
default_params
|
||||
{
|
||||
param_named_auto fogColour fog_colour
|
||||
}
|
||||
}
|
||||
@ -1,132 +0,0 @@
|
||||
//
|
||||
//This file is part of Caelum.
|
||||
//See http://www.ogre3d.org/wiki/index.php/Caelum
|
||||
//
|
||||
//Copyright (c) 2006-2007 Caelum team. See Contributors.txt for details.
|
||||
//
|
||||
//Caelum is free software: you can redistribute it and/or modify
|
||||
//it under the terms of the GNU Lesser General Public License as published
|
||||
//by the Free Software Foundation, either version 3 of the License, or
|
||||
//(at your option) any later version.
|
||||
//
|
||||
//Caelum is distributed in the hope that it will be useful,
|
||||
//but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
//MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
//GNU Lesser General Public License for more details.
|
||||
//
|
||||
//You should have received a copy of the GNU Lesser General Public License
|
||||
//along with Caelum. If not, see <http://www.gnu.org/licenses/>.
|
||||
//
|
||||
|
||||
vertex_program CaelumLayeredCloudsVP cg
|
||||
{
|
||||
source CaelumLayeredClouds.cg
|
||||
entry_point LayeredClouds_vp
|
||||
profiles vs_3_0 vp40 arbvp1
|
||||
|
||||
default_params
|
||||
{
|
||||
param_named_auto worldViewProj worldviewproj_matrix
|
||||
param_named_auto worldMatrix world_matrix
|
||||
param_named sunDirection float3 -1 -1 0
|
||||
}
|
||||
}
|
||||
|
||||
fragment_program CaelumLayeredCloudsFP cg
|
||||
{
|
||||
source CaelumLayeredClouds.cg
|
||||
entry_point LayeredClouds_fp
|
||||
profiles ps_3_0 fp40 arbfp1
|
||||
|
||||
default_params
|
||||
{
|
||||
// Caelum sky properties
|
||||
param_named sunLightColour float4 1 1 1 1
|
||||
param_named sunSphereColour float4 1 1 1 1
|
||||
param_named sunDirection float4 1 1 1 1
|
||||
|
||||
// Fog colour; used as the base cloud colour.
|
||||
param_named fogColour float4 0 0 0 0
|
||||
|
||||
|
||||
// The inverse of the cloud forms scale
|
||||
param_named cloudMassInvScale float 1.2
|
||||
// The inverse of the cloud details scale
|
||||
param_named cloudDetailInvScale float 4.8
|
||||
|
||||
// Cloud mass offset
|
||||
param_named cloudMassOffset float2 0 0
|
||||
// Cloud details offset
|
||||
param_named cloudDetailOffset float2 0.5 0.5
|
||||
|
||||
// Blending factor between Cloud1 and Cloud2
|
||||
param_named cloudMassBlend float 0.9
|
||||
// Cloud detail weight.
|
||||
param_named cloudDetailBlend float 0.5
|
||||
|
||||
|
||||
// Cloud coverage, between 0 and 1
|
||||
param_named cloudCoverageThreshold float 0.9
|
||||
|
||||
// Cloud sharpness. Lower values result in softer clouds.
|
||||
param_named cloudSharpness float 4
|
||||
|
||||
// Cloud thickness. Bigger values results in darker clouds.
|
||||
param_named cloudThickness float 3
|
||||
|
||||
param_named_auto camera_position camera_position
|
||||
param_named layerHeight float 0
|
||||
|
||||
param_named cloudUVFactor float -1
|
||||
param_named heightRedFactor float -1
|
||||
|
||||
param_named nearFadeDist float -1
|
||||
param_named farFadeDist float -1
|
||||
|
||||
param_named fadeDistMeasurementVector float3 0 1 1
|
||||
}
|
||||
}
|
||||
|
||||
material CaelumLayeredClouds
|
||||
{
|
||||
technique
|
||||
{
|
||||
pass
|
||||
{
|
||||
lighting off
|
||||
depth_check on
|
||||
depth_write off
|
||||
scene_blend alpha_blend
|
||||
fog_override true
|
||||
cull_hardware none
|
||||
|
||||
vertex_program_ref CaelumLayeredCloudsVP
|
||||
{
|
||||
}
|
||||
|
||||
fragment_program_ref CaelumLayeredCloudsFP
|
||||
{
|
||||
}
|
||||
|
||||
texture_unit Cloud1
|
||||
{
|
||||
texture noise1.dds
|
||||
filtering trilinear
|
||||
tex_coord_set 0
|
||||
}
|
||||
|
||||
texture_unit Cloud2
|
||||
{
|
||||
texture noise2.dds
|
||||
filtering trilinear
|
||||
tex_coord_set 1
|
||||
}
|
||||
|
||||
texture_unit Detail
|
||||
{
|
||||
texture noise4.dds
|
||||
tex_coord_set 2
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -1,39 +0,0 @@
|
||||
//
|
||||
// This file is part of Caelum.
|
||||
// See http://www.ogre3d.org/wiki/index.php/Caelum
|
||||
//
|
||||
// Copyright (c) 2008 Caelum team. See Contributors.txt for details.
|
||||
//
|
||||
// Caelum is free software: you can redistribute it and/or modify
|
||||
// it under the terms of the GNU Lesser General Public License as published
|
||||
// by the Free Software Foundation, either version 3 of the License, or
|
||||
// (at your option) any later version.
|
||||
//
|
||||
// Caelum is distributed in the hope that it will be useful,
|
||||
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
// GNU Lesser General Public License for more details.
|
||||
//
|
||||
// You should have received a copy of the GNU Lesser General Public License
|
||||
// along with Caelum. If not, see <http://www.gnu.org/licenses/>.
|
||||
//
|
||||
|
||||
// Fixed function does not always work.
|
||||
// This is a the minimal compositor VP required.
|
||||
void MinimalCompositorVP
|
||||
(
|
||||
in float4 in_pos : POSITION,
|
||||
|
||||
uniform float4x4 worldviewproj_matrix,
|
||||
|
||||
out float2 out_uv0 : TEXCOORD0,
|
||||
out float4 out_pos : POSITION
|
||||
)
|
||||
{
|
||||
// Use standard transform.
|
||||
out_pos = mul(worldviewproj_matrix, in_pos);
|
||||
|
||||
// Convert to image-space
|
||||
in_pos.xy = sign(in_pos.xy);
|
||||
out_uv0 = (float2(in_pos.x, -in_pos.y) + 1.0f) * 0.5f;
|
||||
}
|
||||
@ -1,31 +0,0 @@
|
||||
//
|
||||
// This file is part of Caelum.
|
||||
// See http://www.ogre3d.org/wiki/index.php/Caelum
|
||||
//
|
||||
// Copyright (c) 2008 Caelum team. See Contributors.txt for details.
|
||||
//
|
||||
// Caelum is free software: you can redistribute it and/or modify
|
||||
// it under the terms of the GNU Lesser General Public License as published
|
||||
// by the Free Software Foundation, either version 3 of the License, or
|
||||
// (at your option) any later version.
|
||||
//
|
||||
// Caelum is distributed in the hope that it will be useful,
|
||||
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
// GNU Lesser General Public License for more details.
|
||||
//
|
||||
// You should have received a copy of the GNU Lesser General Public License
|
||||
// along with Caelum. If not, see <http://www.gnu.org/licenses/>.
|
||||
//
|
||||
|
||||
vertex_program Caelum/MinimalCompositorVP cg
|
||||
{
|
||||
source MinimalCompositorVP.cg
|
||||
entry_point MinimalCompositorVP
|
||||
profiles vs_1_1 arbvp1
|
||||
|
||||
default_params
|
||||
{
|
||||
param_named_auto worldviewproj_matrix worldviewproj_matrix
|
||||
}
|
||||
}
|
||||
@ -1,80 +0,0 @@
|
||||
//
|
||||
//This file is part of Caelum.
|
||||
//See http://www.ogre3d.org/wiki/index.php/Caelum
|
||||
//
|
||||
//Copyright (c) 2008 Caelum team. See Contributors.txt for details.
|
||||
//
|
||||
//Caelum is free software: you can redistribute it and/or modify
|
||||
//it under the terms of the GNU Lesser General Public License as published
|
||||
//by the Free Software Foundation, either version 3 of the License, or
|
||||
//(at your option) any later version.
|
||||
//
|
||||
//Caelum is distributed in the hope that it will be useful,
|
||||
//but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
//MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
//GNU Lesser General Public License for more details.
|
||||
//
|
||||
//You should have received a copy of the GNU Lesser General Public License
|
||||
//along with Caelum. If not, see <http://www.gnu.org/licenses/>.
|
||||
//
|
||||
|
||||
vertex_program Caelum/StarPointVP cg
|
||||
{
|
||||
source CaelumPointStarfield.cg
|
||||
entry_point StarPointVP
|
||||
profiles vs_2_0 arbvp1 vp30
|
||||
|
||||
default_params
|
||||
{
|
||||
param_named_auto worldviewproj_matrix worldviewproj_matrix
|
||||
param_named_auto render_target_flipping render_target_flipping
|
||||
|
||||
// Default parameters only here to quiet ogre.
|
||||
param_named mag_scale float -1
|
||||
param_named mag0_size float -1
|
||||
param_named min_size float -1
|
||||
param_named max_size float -1
|
||||
param_named aspect_ratio float -1
|
||||
}
|
||||
}
|
||||
|
||||
fragment_program Caelum/StarPointFP cg
|
||||
{
|
||||
source CaelumPointStarfield.cg
|
||||
entry_point StarPointFP
|
||||
profiles ps_2_0 arbfp1 fp30
|
||||
|
||||
default_params
|
||||
{
|
||||
}
|
||||
}
|
||||
|
||||
material Caelum/StarPoint
|
||||
{
|
||||
receive_shadows off
|
||||
|
||||
technique
|
||||
{
|
||||
pass
|
||||
{
|
||||
depth_check off
|
||||
depth_write off
|
||||
|
||||
vertex_program_ref Caelum/StarPointVP
|
||||
{
|
||||
}
|
||||
|
||||
fragment_program_ref Caelum/StarPointFP
|
||||
{
|
||||
}
|
||||
|
||||
scene_blend alpha_blend
|
||||
|
||||
// Works with default culling:
|
||||
cull_hardware clockwise
|
||||
|
||||
// Override Direct3D shader fog.
|
||||
fog_override true none
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -1,102 +0,0 @@
|
||||
//
|
||||
// This file is part of Caelum.
|
||||
// See http://www.ogre3d.org/wiki/index.php/Caelum
|
||||
//
|
||||
// Copyright (c) 2008 Caelum team. See Contributors.txt for details.
|
||||
//
|
||||
// Caelum is free software: you can redistribute it and/or modify
|
||||
// it under the terms of the GNU Lesser General Public License as published
|
||||
// by the Free Software Foundation, either version 3 of the License, or
|
||||
// (at your option) any later version.
|
||||
//
|
||||
// Caelum is distributed in the hope that it will be useful,
|
||||
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
// GNU Lesser General Public License for more details.
|
||||
//
|
||||
// You should have received a copy of the GNU Lesser General Public License
|
||||
// along with Caelum. If not, see <http://www.gnu.org/licenses/>.
|
||||
//
|
||||
|
||||
sampler scene: register(s0);
|
||||
sampler samplerPrec: register(s1);
|
||||
|
||||
uniform float intensity;
|
||||
uniform float4 ambient_light_colour;
|
||||
|
||||
// - - corner
|
||||
uniform float4 corner1;
|
||||
// + - corner
|
||||
uniform float4 corner2;
|
||||
// - + corner
|
||||
uniform float4 corner3;
|
||||
// + + corner
|
||||
uniform float4 corner4;
|
||||
|
||||
// The x and y coordinal deviations for all 3 layers of precipitation
|
||||
uniform float4 deltaX;
|
||||
uniform float4 deltaY;
|
||||
|
||||
uniform float4 precColor;
|
||||
|
||||
// Cartesian to cylindrical coordinates
|
||||
float2 CylindricalCoordinates(float4 dir) {
|
||||
float R = 0.5;
|
||||
float2 res;
|
||||
//cubical root is used to counteract top/bottom circle effect
|
||||
dir *= R / pow(length(dir.xz), 0.33);
|
||||
res.y = -dir.y;
|
||||
res.x = -atan2(dir.z, dir.x);
|
||||
return res;
|
||||
}
|
||||
|
||||
// Returns alpha value of a precipitation
|
||||
// view_direction is the direction vector resulting from the eye direction,wind direction and possibly other factors
|
||||
float Precipitation
|
||||
(
|
||||
float2 cCoords,
|
||||
float intensity,
|
||||
float2 delta
|
||||
) {
|
||||
cCoords -= delta;
|
||||
float4 raincol = tex2D(samplerPrec, cCoords);
|
||||
return (raincol.g<intensity) ? (raincol.r) : 1;
|
||||
}
|
||||
|
||||
//main entry point
|
||||
void MainFP
|
||||
(
|
||||
in float2 scr_pos : TEXCOORD0,
|
||||
out float4 out_colour : COLOR
|
||||
) {
|
||||
float4 eye = lerp (
|
||||
lerp(corner1, corner3, scr_pos.y),
|
||||
lerp(corner2, corner4, scr_pos.y),
|
||||
scr_pos.x ) ;
|
||||
|
||||
float4 scenecol = tex2D(scene, scr_pos);
|
||||
float2 cCoords = CylindricalCoordinates(eye);
|
||||
float prec1 = Precipitation(cCoords, intensity/4, float2(deltaX.x,deltaY.x));
|
||||
float prec2 = Precipitation(cCoords, intensity/4, float2(deltaX.y,deltaY.y));
|
||||
float prec3 = Precipitation(cCoords, intensity/4, float2(deltaX.z,deltaY.z));
|
||||
float prec = min( min (prec1, prec2), prec3);
|
||||
out_colour = lerp(precColor, scenecol, prec );
|
||||
}
|
||||
|
||||
void MainVP
|
||||
(
|
||||
in float4 in_pos : POSITION,
|
||||
|
||||
uniform float4x4 worldviewproj_matrix,
|
||||
|
||||
out float2 out_uv0 : TEXCOORD0,
|
||||
out float4 out_pos : POSITION
|
||||
)
|
||||
{
|
||||
// Use standard transform.
|
||||
out_pos = mul(worldviewproj_matrix, in_pos);
|
||||
|
||||
// Convert to image-space
|
||||
in_pos.xy = sign(in_pos.xy);
|
||||
out_uv0 = (float2(in_pos.x, -in_pos.y) + 1.0f) * 0.5f;
|
||||
}
|
||||
@ -1,44 +0,0 @@
|
||||
//
|
||||
// This file is part of Caelum.
|
||||
// See http://www.ogre3d.org/wiki/index.php/Caelum
|
||||
//
|
||||
// Copyright (c) 2008 Caelum team. See Contributors.txt for details.
|
||||
//
|
||||
// Caelum is free software: you can redistribute it and/or modify
|
||||
// it under the terms of the GNU Lesser General Public License as published
|
||||
// by the Free Software Foundation, either version 3 of the License, or
|
||||
// (at your option) any later version.
|
||||
//
|
||||
// Caelum is distributed in the hope that it will be useful,
|
||||
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
// GNU Lesser General Public License for more details.
|
||||
//
|
||||
// You should have received a copy of the GNU Lesser General Public License
|
||||
// along with Caelum. If not, see <http://www.gnu.org/licenses/>.
|
||||
//
|
||||
|
||||
compositor Caelum/PrecipitationCompositor
|
||||
{
|
||||
technique
|
||||
{
|
||||
texture rt0 target_width target_height PF_A8R8G8B8
|
||||
|
||||
target rt0
|
||||
{
|
||||
input previous
|
||||
}
|
||||
|
||||
target_output
|
||||
{
|
||||
input none
|
||||
|
||||
pass render_quad
|
||||
{
|
||||
// Renders a fullscreen quad with a material
|
||||
material Caelum/PrecipitationMaterial
|
||||
input 0 rt0
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -1,69 +0,0 @@
|
||||
//
|
||||
// This file is part of Caelum.
|
||||
// See http://www.ogre3d.org/wiki/index.php/Caelum
|
||||
//
|
||||
// Copyright (c) 2008 Caelum team. See Contributors.txt for details.
|
||||
//
|
||||
// Caelum is free software: you can redistribute it and/or modify
|
||||
// it under the terms of the GNU Lesser General Public License as published
|
||||
// by the Free Software Foundation, either version 3 of the License, or
|
||||
// (at your option) any later version.
|
||||
//
|
||||
// Caelum is distributed in the hope that it will be useful,
|
||||
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
// GNU Lesser General Public License for more details.
|
||||
//
|
||||
// You should have received a copy of the GNU Lesser General Public License
|
||||
// along with Caelum. If not, see <http://www.gnu.org/licenses/>.
|
||||
//
|
||||
|
||||
fragment_program Caelum/PrecipitationFP cg
|
||||
{
|
||||
source Precipitation.cg
|
||||
entry_point MainFP
|
||||
profiles ps_3_0 fp40 arbfp1
|
||||
|
||||
default_params
|
||||
{
|
||||
}
|
||||
}
|
||||
|
||||
vertex_program Caelum/PrecipitationVP cg
|
||||
{
|
||||
source Precipitation.cg
|
||||
entry_point MainVP
|
||||
profiles vs_3_0 vp40 arbvp1
|
||||
|
||||
default_params
|
||||
{
|
||||
param_named_auto worldviewproj_matrix worldviewproj_matrix
|
||||
}
|
||||
}
|
||||
|
||||
material Caelum/PrecipitationMaterial
|
||||
{
|
||||
technique Default
|
||||
{
|
||||
pass Main
|
||||
{
|
||||
vertex_program_ref Caelum/PrecipitationVP
|
||||
{
|
||||
}
|
||||
|
||||
fragment_program_ref Caelum/PrecipitationFP
|
||||
{
|
||||
}
|
||||
|
||||
texture_unit Scene
|
||||
{
|
||||
}
|
||||
|
||||
texture_unit Precipitation
|
||||
{
|
||||
texture precipitation_drizzle.png
|
||||
filtering trilinear
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -1,119 +0,0 @@
|
||||
//
|
||||
//This file is part of Caelum.
|
||||
//See http://www.ogre3d.org/wiki/index.php/Caelum
|
||||
//
|
||||
//Copyright (c) 2006-2007 Caelum team. See Contributors.txt for details.
|
||||
//
|
||||
//Caelum is free software: you can redistribute it and/or modify
|
||||
//it under the terms of the GNU Lesser General Public License as published
|
||||
//by the Free Software Foundation, either version 3 of the License, or
|
||||
//(at your option) any later version.
|
||||
//
|
||||
//Caelum is distributed in the hope that it will be useful,
|
||||
//but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
//MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
//GNU Lesser General Public License for more details.
|
||||
//
|
||||
//You should have received a copy of the GNU Lesser General Public License
|
||||
//along with Caelum. If not, see <http://www.gnu.org/licenses/>.
|
||||
//
|
||||
|
||||
fragment_program CaelumSkyDomeFP cg
|
||||
{
|
||||
source CaelumSkyDome.cg
|
||||
entry_point SkyDomeFP
|
||||
compile_arguments -DHAZE
|
||||
profiles ps_2_0 arbfp1
|
||||
|
||||
default_params
|
||||
{
|
||||
// Caelum sky properties
|
||||
param_named offset float 0
|
||||
param_named hazeColour float4 0 0 0 0
|
||||
}
|
||||
}
|
||||
|
||||
fragment_program CaelumSkyDomeFP_NoHaze cg
|
||||
{
|
||||
source CaelumSkyDome.cg
|
||||
entry_point SkyDomeFP
|
||||
profiles ps_2_0 arbfp1
|
||||
|
||||
default_params
|
||||
{
|
||||
// Caelum sky properties
|
||||
param_named offset float 0
|
||||
}
|
||||
}
|
||||
|
||||
vertex_program CaelumSkyDomeVP cg
|
||||
{
|
||||
source CaelumSkyDome.cg
|
||||
entry_point SkyDomeVP
|
||||
profiles vs_2_0 arbvp1
|
||||
|
||||
default_params
|
||||
{
|
||||
param_named_auto worldViewProj worldviewproj_matrix
|
||||
param_named sunDirection float3 1 0 0
|
||||
}
|
||||
}
|
||||
|
||||
material CaelumSkyDomeMaterial
|
||||
{
|
||||
receive_shadows off
|
||||
|
||||
technique
|
||||
{
|
||||
pass
|
||||
{
|
||||
lighting off
|
||||
depth_check off
|
||||
depth_write off
|
||||
scene_blend alpha_blend
|
||||
fog_override true none
|
||||
|
||||
vertex_program_ref CaelumSkyDomeVP
|
||||
{
|
||||
}
|
||||
|
||||
fragment_program_ref CaelumSkyDomeFP
|
||||
{
|
||||
}
|
||||
|
||||
texture_unit
|
||||
{
|
||||
texture EarthClearSky2.png 0
|
||||
tex_address_mode clamp
|
||||
tex_coord_set 0
|
||||
}
|
||||
|
||||
texture_unit
|
||||
{
|
||||
texture AtmosphereDepth.png 1d
|
||||
tex_address_mode clamp
|
||||
tex_coord_set 1
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
technique
|
||||
{
|
||||
pass
|
||||
{
|
||||
lighting off
|
||||
depth_check off
|
||||
depth_write off
|
||||
scene_blend alpha_blend
|
||||
fog_override true
|
||||
|
||||
texture_unit
|
||||
{
|
||||
texture EarthClearSky2.png 0
|
||||
tex_address_mode clamp
|
||||
tex_coord_set 0
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
Binary file not shown.
|
Before Width: | Height: | Size: 462 KiB |
@ -1,42 +0,0 @@
|
||||
//
|
||||
//This file is part of Caelum.
|
||||
//See http://www.ogre3d.org/wiki/index.php/Caelum
|
||||
//
|
||||
//Copyright (c) 2006-2007 Caelum team. See Contributors.txt for details.
|
||||
//
|
||||
//Caelum is free software: you can redistribute it and/or modify
|
||||
//it under the terms of the GNU Lesser General Public License as published
|
||||
//by the Free Software Foundation, either version 3 of the License, or
|
||||
//(at your option) any later version.
|
||||
//
|
||||
//Caelum is distributed in the hope that it will be useful,
|
||||
//but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
//MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
//GNU Lesser General Public License for more details.
|
||||
//
|
||||
//You should have received a copy of the GNU Lesser General Public License
|
||||
//along with Caelum. If not, see <http://www.gnu.org/licenses/>.
|
||||
//
|
||||
|
||||
material CaelumStarfieldMaterial
|
||||
{
|
||||
receive_shadows off
|
||||
|
||||
technique
|
||||
{
|
||||
pass
|
||||
{
|
||||
depth_check off
|
||||
depth_write off
|
||||
lighting off
|
||||
fog_override true
|
||||
|
||||
texture_unit
|
||||
{
|
||||
texture Starfield.jpg 0
|
||||
tex_address_mode wrap
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@ -1,58 +0,0 @@
|
||||
//
|
||||
//This file is part of Caelum.
|
||||
//See http://www.ogre3d.org/wiki/index.php/Caelum
|
||||
//
|
||||
//Copyright (c) 2008 Caelum team. See Contributors.txt for details.
|
||||
//
|
||||
//Caelum is free software: you can redistribute it and/or modify
|
||||
//it under the terms of the GNU Lesser General Public License as published
|
||||
//by the Free Software Foundation, either version 3 of the License, or
|
||||
//(at your option) any later version.
|
||||
//
|
||||
//Caelum is distributed in the hope that it will be useful,
|
||||
//but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
//MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
//GNU Lesser General Public License for more details.
|
||||
//
|
||||
//You should have received a copy of the GNU Lesser General Public License
|
||||
//along with Caelum. If not, see <http://www.gnu.org/licenses/>.
|
||||
//
|
||||
|
||||
material CaelumSphereSun
|
||||
{
|
||||
technique Defaulto
|
||||
{
|
||||
pass Main
|
||||
{
|
||||
depth_check off
|
||||
depth_write off
|
||||
fog_override true none
|
||||
ambient 0 0 0
|
||||
diffuse 0 0 0
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
material CaelumSpriteSun
|
||||
{
|
||||
receive_shadows off
|
||||
technique Default
|
||||
{
|
||||
pass Main
|
||||
{
|
||||
lighting off
|
||||
depth_check off
|
||||
depth_write off
|
||||
fog_override true none
|
||||
ambient 0 0 0
|
||||
diffuse 0 0 0
|
||||
scene_blend src_colour one_minus_src_colour
|
||||
alpha_rejection greater_equal 128
|
||||
emissive vertexcolour
|
||||
texture_unit Texture0
|
||||
{
|
||||
texture sun_disc.png 2d 0
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
Binary file not shown.
|
Before Width: | Height: | Size: 2.8 KiB |
@ -1,107 +0,0 @@
|
||||
//
|
||||
//This file is part of Caelum.
|
||||
//See http://www.ogre3d.org/wiki/index.php/Caelum
|
||||
//
|
||||
//Copyright (c) 2008 Caelum team. See Contributors.txt for details.
|
||||
//
|
||||
//Caelum is free software: you can redistribute it and/or modify
|
||||
//it under the terms of the GNU Lesser General Public License as published
|
||||
//by the Free Software Foundation, either version 3 of the License, or
|
||||
//(at your option) any later version.
|
||||
//
|
||||
//Caelum is distributed in the hope that it will be useful,
|
||||
//but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
//MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
//GNU Lesser General Public License for more details.
|
||||
//
|
||||
//You should have received a copy of the GNU Lesser General Public License
|
||||
//along with Caelum. If not, see <http://www.gnu.org/licenses/>.
|
||||
//
|
||||
|
||||
fragment_program Caelum/PhaseMoonFP cg
|
||||
{
|
||||
source CaelumPhaseMoon.cg
|
||||
entry_point PhaseMoonFP
|
||||
profiles ps_2_0 arbfp1 fp30
|
||||
|
||||
default_params
|
||||
{
|
||||
param_named phase float 0.3
|
||||
}
|
||||
}
|
||||
|
||||
material Caelum/FullMoon
|
||||
{
|
||||
receive_shadows off
|
||||
technique Default
|
||||
{
|
||||
pass Main
|
||||
{
|
||||
lighting off
|
||||
depth_check off
|
||||
depth_write off
|
||||
fog_override true none
|
||||
ambient 0 0 0
|
||||
diffuse 0 0 0
|
||||
scene_blend alpha_blend
|
||||
emissive vertexcolour
|
||||
|
||||
texture_unit Texture0
|
||||
{
|
||||
texture moon_disc.dds 2d
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
material Caelum/PhaseMoon
|
||||
{
|
||||
receive_shadows off
|
||||
technique Default
|
||||
{
|
||||
pass Main
|
||||
{
|
||||
lighting off
|
||||
depth_check off
|
||||
depth_write off
|
||||
fog_override true none
|
||||
ambient 0 0 0
|
||||
diffuse 0 0 0
|
||||
scene_blend alpha_blend
|
||||
|
||||
texture_unit MoonDisc
|
||||
{
|
||||
texture moon_disc.dds
|
||||
}
|
||||
|
||||
fragment_program_ref Caelum/PhaseMoonFP
|
||||
{
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
material Caelum/MoonBackground
|
||||
{
|
||||
receive_shadows off
|
||||
technique Default
|
||||
{
|
||||
pass Main
|
||||
{
|
||||
// Used fixed function lighting to return black.
|
||||
lighting off
|
||||
|
||||
depth_check off
|
||||
depth_write off
|
||||
fog_override true none
|
||||
scene_blend alpha_blend
|
||||
|
||||
texture_unit MoonDisc
|
||||
{
|
||||
texture moon_disc.dds
|
||||
colour_op_ex source1 src_manual src_diffuse 0 0 0 0
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
|
Before Width: | Height: | Size: 569 KiB |
Binary file not shown.
|
Before Width: | Height: | Size: 347 KiB |
Binary file not shown.
|
Before Width: | Height: | Size: 429 KiB |
Binary file not shown.
|
Before Width: | Height: | Size: 423 KiB |
Binary file not shown.
|
Before Width: | Height: | Size: 440 KiB |
Binary file not shown.
|
Before Width: | Height: | Size: 390 KiB |
Binary file not shown.
|
Before Width: | Height: | Size: 426 KiB |
Binary file not shown.
|
Before Width: | Height: | Size: 479 KiB |
Binary file not shown.
Binary file not shown.
|
Before Width: | Height: | Size: 3.0 KiB |
@ -1,349 +0,0 @@
|
||||
/*
|
||||
This file is part of Caelum.
|
||||
See http://www.ogre3d.org/wiki/index.php/Caelum
|
||||
|
||||
Copyright (c) 2008 Caelum team. See Contributors.txt for details.
|
||||
|
||||
Caelum is free software: you can redistribute it and/or modify
|
||||
it under the terms of the GNU Lesser General Public License as published
|
||||
by the Free Software Foundation, either version 3 of the License, or
|
||||
(at your option) any later version.
|
||||
|
||||
Caelum is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
GNU Lesser General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU Lesser General Public License
|
||||
along with Caelum. If not, see <http://www.gnu.org/licenses/>.
|
||||
*/
|
||||
|
||||
#include "CaelumPrecompiled.h"
|
||||
#include "Astronomy.h"
|
||||
|
||||
namespace Caelum
|
||||
{
|
||||
const LongReal Astronomy::PI = 3.1415926535897932384626433832795029L;
|
||||
|
||||
const LongReal Astronomy::J2000 = 2451545.0;
|
||||
|
||||
LongReal Astronomy::radToDeg (LongReal value)
|
||||
{
|
||||
return value * 180 / PI;
|
||||
}
|
||||
|
||||
LongReal Astronomy::degToRad (LongReal value)
|
||||
{
|
||||
return value * PI / 180;
|
||||
}
|
||||
|
||||
LongReal Astronomy::sinDeg (LongReal x) {
|
||||
return std::sin (degToRad (x));
|
||||
}
|
||||
|
||||
LongReal Astronomy::cosDeg (LongReal x) {
|
||||
return std::cos (degToRad (x));
|
||||
}
|
||||
|
||||
LongReal Astronomy::atan2Deg (LongReal y, LongReal x) {
|
||||
return radToDeg(std::atan2 (y, x));
|
||||
}
|
||||
|
||||
LongReal Astronomy::normalizeDegrees (LongReal value)
|
||||
{
|
||||
value = fmod (value, 360);
|
||||
if (value < LongReal (0)) {
|
||||
value += LongReal (360);
|
||||
}
|
||||
return value;
|
||||
}
|
||||
|
||||
void Astronomy::convertEclipticToEquatorialRad (
|
||||
LongReal lon, LongReal lat,
|
||||
LongReal &rasc, LongReal &decl)
|
||||
{
|
||||
double ecl = Astronomy::degToRad(23.439281);
|
||||
|
||||
double x = cos(lon) * cos(lat);
|
||||
double y = cos(ecl) * sin(lon) * cos(lat) - sin(ecl) * sin(lat);
|
||||
double z = sin(ecl) * sin(lon) * cos(lat) + cos(ecl) * sin(lat);
|
||||
|
||||
double r = sqrt(x * x + y * y);
|
||||
rasc = atan2(y, x);
|
||||
decl = atan2(z, r);
|
||||
}
|
||||
|
||||
void Astronomy::convertRectangularToSpherical (
|
||||
LongReal x, LongReal y, LongReal z,
|
||||
LongReal &rasc, LongReal &decl, LongReal &dist)
|
||||
{
|
||||
dist = sqrt (x * x + y * y + z * z);
|
||||
rasc = atan2Deg (y, x);
|
||||
decl = atan2Deg (z, sqrt (x * x + y * y));
|
||||
}
|
||||
|
||||
void Astronomy::convertSphericalToRectangular (
|
||||
LongReal rasc, LongReal decl, LongReal dist,
|
||||
LongReal &x, LongReal &y, LongReal &z)
|
||||
{
|
||||
x = dist * cosDeg (rasc) * cosDeg (decl);
|
||||
y = dist * sinDeg (rasc) * cosDeg (decl);
|
||||
z = dist * sinDeg (decl);
|
||||
}
|
||||
|
||||
void Astronomy::convertEquatorialToHorizontal (
|
||||
LongReal jday,
|
||||
LongReal longitude, LongReal latitude,
|
||||
LongReal rasc, LongReal decl,
|
||||
LongReal &azimuth, LongReal &altitude)
|
||||
{
|
||||
LongReal d = jday - 2451543.5;
|
||||
LongReal w = LongReal (282.9404 + 4.70935E-5 * d);
|
||||
LongReal M = LongReal (356.0470 + 0.9856002585 * d);
|
||||
// Sun's mean longitude
|
||||
LongReal L = w + M;
|
||||
// Universal time of day in degrees.
|
||||
LongReal UT = LongReal(fmod(d, 1) * 360);
|
||||
LongReal hourAngle = longitude + L + LongReal (180) + UT - rasc;
|
||||
|
||||
LongReal x = cosDeg (hourAngle) * cosDeg (decl);
|
||||
LongReal y = sinDeg (hourAngle) * cosDeg (decl);
|
||||
LongReal z = sinDeg (decl);
|
||||
|
||||
LongReal xhor = x * sinDeg (latitude) - z * cosDeg (latitude);
|
||||
LongReal yhor = y;
|
||||
LongReal zhor = x * cosDeg (latitude) + z * sinDeg (latitude);
|
||||
|
||||
azimuth = atan2Deg (yhor, xhor) + LongReal (180);
|
||||
altitude = atan2Deg (zhor, sqrt (xhor * xhor + yhor * yhor));
|
||||
}
|
||||
|
||||
void Astronomy::getHorizontalSunPosition (
|
||||
LongReal jday,
|
||||
LongReal longitude, LongReal latitude,
|
||||
LongReal &azimuth, LongReal &altitude)
|
||||
{
|
||||
// 2451544.5 == Astronomy::getJulianDayFromGregorianDateTime(2000, 1, 1, 0, 0, 0));
|
||||
// 2451543.5 == Astronomy::getJulianDayFromGregorianDateTime(1999, 12, 31, 0, 0, 0));
|
||||
LongReal d = jday - 2451543.5;
|
||||
|
||||
// Sun's Orbital elements:
|
||||
// argument of perihelion
|
||||
LongReal w = LongReal (282.9404 + 4.70935E-5 * d);
|
||||
// eccentricity (0=circle, 0-1=ellipse, 1=parabola)
|
||||
LongReal e = 0.016709 - 1.151E-9 * d;
|
||||
// mean anomaly (0 at perihelion; increases uniformly with time)
|
||||
LongReal M = LongReal(356.0470 + 0.9856002585 * d);
|
||||
// Obliquity of the ecliptic.
|
||||
//LongReal oblecl = LongReal (23.4393 - 3.563E-7 * d);
|
||||
|
||||
// Eccentric anomaly
|
||||
LongReal E = M + radToDeg(e * sinDeg (M) * (1 + e * cosDeg (M)));
|
||||
|
||||
// Sun's Distance(R) and true longitude(L)
|
||||
LongReal xv = cosDeg (E) - e;
|
||||
LongReal yv = sinDeg (E) * sqrt (1 - e * e);
|
||||
//LongReal r = sqrt (xv * xv + yv * yv);
|
||||
LongReal lon = atan2Deg (yv, xv) + w;
|
||||
LongReal lat = 0;
|
||||
|
||||
LongReal lambda = degToRad(lon);
|
||||
LongReal beta = degToRad(lat);
|
||||
LongReal rasc, decl;
|
||||
convertEclipticToEquatorialRad (lambda, beta, rasc, decl);
|
||||
rasc = radToDeg(rasc);
|
||||
decl = radToDeg(decl);
|
||||
|
||||
// Horizontal spherical.
|
||||
Astronomy::convertEquatorialToHorizontal (
|
||||
jday, longitude, latitude, rasc, decl, azimuth, altitude);
|
||||
}
|
||||
|
||||
void Astronomy::getHorizontalSunPosition (
|
||||
LongReal jday,
|
||||
Ogre::Degree longitude, Ogre::Degree latitude,
|
||||
Ogre::Degree &azimuth, Ogre::Degree &altitude)
|
||||
{
|
||||
LongReal az, al;
|
||||
getHorizontalSunPosition(jday, longitude.valueDegrees (), latitude.valueDegrees (), az, al);
|
||||
azimuth = Ogre::Degree(az);
|
||||
altitude = Ogre::Degree(al);
|
||||
}
|
||||
|
||||
void Astronomy::getEclipticMoonPositionRad (
|
||||
LongReal jday,
|
||||
LongReal &lon, LongReal &lat)
|
||||
{
|
||||
// Julian centuries since January 1, 2000
|
||||
double T = (jday - 2451545.0L) / 36525.0L;
|
||||
double lprim = 3.8104L + 8399.7091L * T;
|
||||
double mprim = 2.3554L + 8328.6911L * T;
|
||||
double m = 6.2300L + 648.3019L * T;
|
||||
double d = 5.1985L + 7771.3772L * T;
|
||||
double f = 1.6280L + 8433.4663L * T;
|
||||
lon = lprim
|
||||
+ 0.1098L * sin(mprim)
|
||||
+ 0.0222L * sin(2.0L * d - mprim)
|
||||
+ 0.0115L * sin(2.0L * d)
|
||||
+ 0.0037L * sin(2.0L * mprim)
|
||||
- 0.0032L * sin(m)
|
||||
- 0.0020L * sin(2.0L * f)
|
||||
+ 0.0010L * sin(2.0L * d - 2.0L * mprim)
|
||||
+ 0.0010L * sin(2.0L * d - m - mprim)
|
||||
+ 0.0009L * sin(2.0L * d + mprim)
|
||||
+ 0.0008L * sin(2.0L * d - m)
|
||||
+ 0.0007L * sin(mprim - m)
|
||||
- 0.0006L * sin(d)
|
||||
- 0.0005L * sin(m + mprim);
|
||||
lat =
|
||||
+ 0.0895L * sin(f)
|
||||
+ 0.0049L * sin(mprim + f)
|
||||
+ 0.0048L * sin(mprim - f)
|
||||
+ 0.0030L * sin(2.0L * d - f)
|
||||
+ 0.0010L * sin(2.0L * d + f - mprim)
|
||||
+ 0.0008 * sin(2.0L * d - f - mprim)
|
||||
+ 0.0006L * sin(2.0L * d + f);
|
||||
}
|
||||
|
||||
void Astronomy::getHorizontalMoonPosition (
|
||||
LongReal jday,
|
||||
LongReal longitude, LongReal latitude,
|
||||
LongReal &azimuth, LongReal &altitude)
|
||||
{
|
||||
// Ecliptic spherical
|
||||
LongReal lonecl, latecl;
|
||||
Astronomy::getEclipticMoonPositionRad (jday, lonecl, latecl);
|
||||
|
||||
// Equatorial spherical
|
||||
LongReal rasc, decl;
|
||||
Astronomy::convertEclipticToEquatorialRad (lonecl, latecl, rasc, decl);
|
||||
|
||||
// Radians to degrees (all angles are in radians up to this point)
|
||||
rasc = radToDeg(rasc);
|
||||
decl = radToDeg(decl);
|
||||
|
||||
// Equatorial to horizontal
|
||||
Astronomy::convertEquatorialToHorizontal (
|
||||
jday, longitude, latitude, rasc, decl, azimuth, altitude);
|
||||
}
|
||||
|
||||
void Astronomy::getHorizontalMoonPosition (
|
||||
LongReal jday,
|
||||
Ogre::Degree longitude, Ogre::Degree latitude,
|
||||
Ogre::Degree &azimuth, Ogre::Degree &altitude)
|
||||
{
|
||||
LongReal az, al;
|
||||
getHorizontalMoonPosition(jday, longitude.valueDegrees (), latitude.valueDegrees (), az, al);
|
||||
azimuth = Ogre::Degree(az);
|
||||
altitude = Ogre::Degree(al);
|
||||
}
|
||||
|
||||
int Astronomy::getJulianDayFromGregorianDate(
|
||||
int year, int month, int day)
|
||||
{
|
||||
// Formulas from http://en.wikipedia.org/wiki/Julian_day
|
||||
// These are all integer divisions, but I'm not sure it works
|
||||
// correctly for negative values.
|
||||
int a = (14 - month) / 12;
|
||||
int y = year + 4800 - a;
|
||||
int m = month + 12 * a - 3;
|
||||
return day + (153 * m + 2) / 5 + 365 * y + y / 4 - y / 100 + y / 400 - 32045;
|
||||
}
|
||||
|
||||
LongReal Astronomy::getJulianDayFromGregorianDateTime(
|
||||
int year, int month, int day,
|
||||
int hour, int minute, LongReal second)
|
||||
{
|
||||
ScopedHighPrecissionFloatSwitch precissionSwitch;
|
||||
|
||||
int jdn = getJulianDayFromGregorianDate (year, month, day);
|
||||
// These are NOT integer divisions.
|
||||
LongReal jd = jdn + (hour - 12) / 24.0 + minute / 1440.0 + second / 86400.0;
|
||||
|
||||
return jd;
|
||||
}
|
||||
|
||||
LongReal Astronomy::getJulianDayFromGregorianDateTime(
|
||||
int year, int month, int day,
|
||||
LongReal secondsFromMidnight)
|
||||
{
|
||||
int jdn = getJulianDayFromGregorianDate(year, month, day);
|
||||
LongReal jd = jdn + secondsFromMidnight / 86400.0 - 0.5;
|
||||
return jd;
|
||||
}
|
||||
|
||||
void Astronomy::getGregorianDateFromJulianDay(
|
||||
int julianDay, int &year, int &month, int &day)
|
||||
{
|
||||
// From http://en.wikipedia.org/wiki/Julian_day
|
||||
int J = julianDay;
|
||||
int j = J + 32044;
|
||||
int g = j / 146097;
|
||||
int dg = j % 146097;
|
||||
int c = (dg / 36524 + 1) * 3 / 4;
|
||||
int dc = dg - c * 36524;
|
||||
int b = dc / 1461;
|
||||
int db = dc % 1461;
|
||||
int a = (db / 365 + 1) * 3 / 4;
|
||||
int da = db - a * 365;
|
||||
int y = g * 400 + c * 100 + b * 4 + a;
|
||||
int m = (da * 5 + 308) / 153 - 2;
|
||||
int d = da - (m + 4) * 153 / 5 + 122;
|
||||
year = y - 4800 + (m + 2) / 12;
|
||||
month = (m + 2) % 12 + 1;
|
||||
day = d + 1;
|
||||
}
|
||||
|
||||
void Astronomy::getGregorianDateTimeFromJulianDay(
|
||||
LongReal julianDay, int &year, int &month, int &day,
|
||||
int &hour, int &minute, LongReal &second)
|
||||
{
|
||||
// Integer julian days are at noon.
|
||||
// static_cast<int)(floor( is more precise than Ogre::Math::IFloor.
|
||||
// Yes, it does matter.
|
||||
int ijd = static_cast<int>(floor(julianDay + 0.5));
|
||||
getGregorianDateFromJulianDay(ijd, year, month, day);
|
||||
|
||||
LongReal s = (julianDay + 0.5 - ijd) * 86400.0;
|
||||
hour = static_cast<int>(floor(s / 3600));
|
||||
s -= hour * 3600;
|
||||
minute = static_cast<int>(floor(s / 60));
|
||||
s -= minute * 60;
|
||||
second = s;
|
||||
}
|
||||
|
||||
void Astronomy::getGregorianDateFromJulianDay(
|
||||
LongReal julianDay, int &year, int &month, int &day)
|
||||
{
|
||||
int hour;
|
||||
int minute;
|
||||
LongReal second;
|
||||
getGregorianDateTimeFromJulianDay(julianDay, year, month, day, hour, minute, second);
|
||||
}
|
||||
|
||||
#if (OGRE_PLATFORM == OGRE_PLATFORM_WIN32) && (OGRE_COMPILER == OGRE_COMPILER_MSVC) && (OGRE_ARCH_TYPE != OGRE_ARCHITECTURE_64)
|
||||
int Astronomy::enterHighPrecissionFloatingPointMode ()
|
||||
{
|
||||
int oldMode = ::_controlfp (0, 0);
|
||||
::_controlfp (_PC_64, _MCW_PC);
|
||||
return oldMode;
|
||||
}
|
||||
|
||||
void Astronomy::restoreFloatingPointMode (int oldMode)
|
||||
{
|
||||
::_controlfp (oldMode, _MCW_PC);
|
||||
}
|
||||
#else
|
||||
int Astronomy::enterHighPrecissionFloatingPointMode ()
|
||||
{
|
||||
// Meaningless
|
||||
return 0xC0FFEE;
|
||||
}
|
||||
|
||||
void Astronomy::restoreFloatingPointMode (int oldMode)
|
||||
{
|
||||
// Useless check.
|
||||
assert(oldMode == 0xC0FFEE);
|
||||
}
|
||||
#endif
|
||||
}
|
||||
File diff suppressed because it is too large
Load Diff
@ -1,462 +0,0 @@
|
||||
/*
|
||||
This file is part of Caelum.
|
||||
See http://www.ogre3d.org/wiki/index.php/Caelum
|
||||
|
||||
Copyright (c) 2008 Caelum team. See Contributors.txt for details.
|
||||
|
||||
Caelum is free software: you can redistribute it and/or modify
|
||||
it under the terms of the GNU Lesser General Public License as published
|
||||
by the Free Software Foundation, either version 3 of the License, or
|
||||
(at your option) any later version.
|
||||
|
||||
Caelum is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
GNU Lesser General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU Lesser General Public License
|
||||
along with Caelum. If not, see <http://www.gnu.org/licenses/>.
|
||||
*/
|
||||
|
||||
#include "CaelumPrecompiled.h"
|
||||
#include "CaelumPrerequisites.h"
|
||||
|
||||
#if CAELUM_TYPE_DESCRIPTORS
|
||||
|
||||
#include "TypeDescriptor.h"
|
||||
#include "CaelumSystem.h"
|
||||
#include "FlatCloudLayer.h"
|
||||
|
||||
using namespace Ogre;
|
||||
|
||||
namespace Caelum
|
||||
{
|
||||
CaelumDefaultTypeDescriptorData::CaelumDefaultTypeDescriptorData ():
|
||||
CaelumSystemTypeDescriptor(0),
|
||||
PointStarfieldTypeDescriptor(0),
|
||||
BaseSkyLightTypeDescriptor(0),
|
||||
GroundFogTypeDescriptor(0),
|
||||
PrecipitationTypeDescriptor(0),
|
||||
DepthComposerTypeDescriptor(0),
|
||||
FlatCloudLayerTypeDescriptor(0),
|
||||
SkyDomeTypeDescriptor(0)
|
||||
{
|
||||
try {
|
||||
load ();
|
||||
} catch (...) {
|
||||
unload ();
|
||||
throw;
|
||||
}
|
||||
}
|
||||
|
||||
CaelumDefaultTypeDescriptorData::~CaelumDefaultTypeDescriptorData ()
|
||||
{
|
||||
unload ();
|
||||
}
|
||||
|
||||
template<class T>
|
||||
inline void delete_zero(T*& member) {
|
||||
// Remember: delete 0 is a legal no-op.
|
||||
delete member;
|
||||
member = 0;
|
||||
}
|
||||
|
||||
void CaelumDefaultTypeDescriptorData::unload ()
|
||||
{
|
||||
delete_zero(CaelumSystemTypeDescriptor);
|
||||
delete_zero(PointStarfieldTypeDescriptor);
|
||||
delete_zero(BaseSkyLightTypeDescriptor);
|
||||
delete_zero(GroundFogTypeDescriptor);
|
||||
delete_zero(PrecipitationTypeDescriptor);
|
||||
delete_zero(DepthComposerTypeDescriptor);
|
||||
delete_zero(FlatCloudLayerTypeDescriptor);
|
||||
delete_zero(SkyDomeTypeDescriptor);
|
||||
}
|
||||
|
||||
void CaelumDefaultTypeDescriptorData::load ()
|
||||
{
|
||||
if (!CaelumSystemTypeDescriptor)
|
||||
{
|
||||
std::auto_ptr<DefaultTypeDescriptor> td (new DefaultTypeDescriptor ());
|
||||
|
||||
// Timing settings.
|
||||
td->add("time_scale",
|
||||
new AccesorPropertyDescriptor<Caelum::CaelumSystem, Real, Real, Real>(
|
||||
&Caelum::CaelumSystem::getTimeScale,
|
||||
&Caelum::CaelumSystem::setTimeScale));
|
||||
td->add("julian_day",
|
||||
new AccesorPropertyDescriptor<Caelum::CaelumSystem, LongReal, LongReal, LongReal>(
|
||||
&Caelum::CaelumSystem::getJulianDay,
|
||||
&Caelum::CaelumSystem::setJulianDay));
|
||||
|
||||
// Latitude/longitude
|
||||
td->add("latitude",
|
||||
new AccesorPropertyDescriptor<Caelum::CaelumSystem, Degree, Degree, const Degree>(
|
||||
&Caelum::CaelumSystem::getObserverLatitude,
|
||||
&Caelum::CaelumSystem::setObserverLatitude));
|
||||
td->add("longitude",
|
||||
new AccesorPropertyDescriptor<Caelum::CaelumSystem, Degree, Degree, const Degree>(
|
||||
&Caelum::CaelumSystem::getObserverLongitude,
|
||||
&Caelum::CaelumSystem::setObserverLongitude));
|
||||
|
||||
// Fog settings.
|
||||
td->add("global_fog_density_multiplier",
|
||||
new AccesorPropertyDescriptor<Caelum::CaelumSystem, Real, Real, Real>(
|
||||
&Caelum::CaelumSystem::getGlobalFogDensityMultiplier,
|
||||
&Caelum::CaelumSystem::setGlobalFogDensityMultiplier));
|
||||
td->add("global_fog_colour_multiplier",
|
||||
new AccesorPropertyDescriptor<Caelum::CaelumSystem, ColourValue>(
|
||||
&Caelum::CaelumSystem::getGlobalFogColourMultiplier,
|
||||
&Caelum::CaelumSystem::setGlobalFogColourMultiplier));
|
||||
td->add("manage_scene_fog",
|
||||
new AccesorPropertyDescriptor<Caelum::CaelumSystem, bool, bool, bool>(
|
||||
&Caelum::CaelumSystem::getManageSceneFog,
|
||||
&Caelum::CaelumSystem::setManageSceneFog));
|
||||
td->add("scene_fog_density_multiplier",
|
||||
new AccesorPropertyDescriptor<Caelum::CaelumSystem, Real, Real, Real>(
|
||||
&Caelum::CaelumSystem::getSceneFogDensityMultiplier,
|
||||
&Caelum::CaelumSystem::setSceneFogDensityMultiplier));
|
||||
td->add("scene_fog_colour_multiplier",
|
||||
new AccesorPropertyDescriptor<Caelum::CaelumSystem, ColourValue>(
|
||||
&Caelum::CaelumSystem::getSceneFogColourMultiplier,
|
||||
&Caelum::CaelumSystem::setSceneFogColourMultiplier));
|
||||
td->add("ground_fog_density_multiplier",
|
||||
new AccesorPropertyDescriptor<Caelum::CaelumSystem, Real, Real, Real>(
|
||||
&Caelum::CaelumSystem::getGroundFogDensityMultiplier,
|
||||
&Caelum::CaelumSystem::setGroundFogDensityMultiplier));
|
||||
td->add("ground_fog_colour_multiplier",
|
||||
new AccesorPropertyDescriptor<Caelum::CaelumSystem, ColourValue>(
|
||||
&Caelum::CaelumSystem::getGroundFogColourMultiplier,
|
||||
&Caelum::CaelumSystem::setGroundFogColourMultiplier));
|
||||
|
||||
// Lighting settings.
|
||||
td->add("manage_ambient_light",
|
||||
new AccesorPropertyDescriptor<Caelum::CaelumSystem, bool, bool, bool>(
|
||||
&Caelum::CaelumSystem::getManageAmbientLight,
|
||||
&Caelum::CaelumSystem::setManageAmbientLight));
|
||||
td->add("minimum_ambient_light",
|
||||
new AccesorPropertyDescriptor<Caelum::CaelumSystem, ColourValue>(
|
||||
&Caelum::CaelumSystem::getMinimumAmbientLight,
|
||||
&Caelum::CaelumSystem::setMinimumAmbientLight));
|
||||
td->add("ensure_single_light_source",
|
||||
new AccesorPropertyDescriptor<Caelum::CaelumSystem, bool, bool, bool>(
|
||||
&Caelum::CaelumSystem::getEnsureSingleLightSource,
|
||||
&Caelum::CaelumSystem::setEnsureSingleLightSource));
|
||||
td->add("ensure_single_shadow_source",
|
||||
new AccesorPropertyDescriptor<Caelum::CaelumSystem, bool, bool, bool>(
|
||||
&Caelum::CaelumSystem::getEnsureSingleShadowSource,
|
||||
&Caelum::CaelumSystem::setEnsureSingleShadowSource));
|
||||
|
||||
CaelumSystemTypeDescriptor = td.release ();
|
||||
}
|
||||
|
||||
if (!PointStarfieldTypeDescriptor)
|
||||
{
|
||||
std::auto_ptr<DefaultTypeDescriptor> td (new DefaultTypeDescriptor ());
|
||||
td->add("magnitude_scale",
|
||||
new AccesorPropertyDescriptor<Caelum::PointStarfield, Real, Real, Real>(
|
||||
&Caelum::PointStarfield::getMagnitudeScale,
|
||||
&Caelum::PointStarfield::setMagnitudeScale));
|
||||
td->add("mag0_pixel_size",
|
||||
new AccesorPropertyDescriptor<Caelum::PointStarfield, Real, Real, Real>(
|
||||
&Caelum::PointStarfield::getMag0PixelSize,
|
||||
&Caelum::PointStarfield::setMag0PixelSize));
|
||||
td->add("min_pixel_size",
|
||||
new AccesorPropertyDescriptor<Caelum::PointStarfield, Real, Real, Real>(
|
||||
&Caelum::PointStarfield::getMinPixelSize,
|
||||
&Caelum::PointStarfield::setMinPixelSize));
|
||||
td->add("max_pixel_size",
|
||||
new AccesorPropertyDescriptor<Caelum::PointStarfield, Real, Real, Real>(
|
||||
&Caelum::PointStarfield::getMaxPixelSize,
|
||||
&Caelum::PointStarfield::setMaxPixelSize));
|
||||
td->add("latitude",
|
||||
new AccesorPropertyDescriptor<Caelum::PointStarfield, Degree, Degree, Degree>(
|
||||
&Caelum::PointStarfield::getObserverLatitude,
|
||||
&Caelum::PointStarfield::setObserverLatitude));
|
||||
td->add("longitude",
|
||||
new AccesorPropertyDescriptor<Caelum::PointStarfield, Degree, Degree, Degree>(
|
||||
&Caelum::PointStarfield::getObserverLongitude,
|
||||
&Caelum::PointStarfield::setObserverLongitude));
|
||||
td->add("observer_position_rebuild_delta",
|
||||
new AccesorPropertyDescriptor<Caelum::PointStarfield, Degree, Degree, Degree>(
|
||||
&Caelum::PointStarfield::getObserverPositionRebuildDelta,
|
||||
&Caelum::PointStarfield::setObserverPositionRebuildDelta));
|
||||
PointStarfieldTypeDescriptor = td.release ();
|
||||
}
|
||||
|
||||
if (!BaseSkyLightTypeDescriptor)
|
||||
{
|
||||
std::auto_ptr<DefaultTypeDescriptor> td (new DefaultTypeDescriptor ());
|
||||
td->add("ambient_multiplier",
|
||||
new AccesorPropertyDescriptor<Caelum::BaseSkyLight, ColourValue>(
|
||||
&Caelum::BaseSkyLight::getAmbientMultiplier,
|
||||
&Caelum::BaseSkyLight::setAmbientMultiplier));
|
||||
td->add("specular_multiplier",
|
||||
new AccesorPropertyDescriptor<Caelum::BaseSkyLight, ColourValue>(
|
||||
&Caelum::BaseSkyLight::getSpecularMultiplier,
|
||||
&Caelum::BaseSkyLight::setSpecularMultiplier));
|
||||
td->add("diffuse_multiplier",
|
||||
new AccesorPropertyDescriptor<Caelum::BaseSkyLight, ColourValue>(
|
||||
&Caelum::BaseSkyLight::getDiffuseMultiplier,
|
||||
&Caelum::BaseSkyLight::setDiffuseMultiplier));
|
||||
td->add("light_colour",
|
||||
new AccesorPropertyDescriptor<Caelum::BaseSkyLight, ColourValue>(
|
||||
&Caelum::BaseSkyLight::getLightColour,
|
||||
&Caelum::BaseSkyLight::setLightColour));
|
||||
td->add("body_colour",
|
||||
new AccesorPropertyDescriptor<Caelum::BaseSkyLight, ColourValue>(
|
||||
&Caelum::BaseSkyLight::getBodyColour,
|
||||
&Caelum::BaseSkyLight::setBodyColour));
|
||||
td->add("auto_disable_threshold",
|
||||
new AccesorPropertyDescriptor<Caelum::BaseSkyLight, Real, Real, Real>(
|
||||
&Caelum::BaseSkyLight::getAutoDisableThreshold,
|
||||
&Caelum::BaseSkyLight::setAutoDisableThreshold));
|
||||
td->add("auto_disable",
|
||||
new AccesorPropertyDescriptor<Caelum::BaseSkyLight, bool, bool, bool>(
|
||||
&Caelum::BaseSkyLight::getAutoDisable,
|
||||
&Caelum::BaseSkyLight::setAutoDisable));
|
||||
BaseSkyLightTypeDescriptor = td.release ();
|
||||
}
|
||||
|
||||
if (!GroundFogTypeDescriptor)
|
||||
{
|
||||
std::auto_ptr<DefaultTypeDescriptor> td (new DefaultTypeDescriptor ());
|
||||
td->add("density",
|
||||
new AccesorPropertyDescriptor<Caelum::GroundFog, Real, Real, Real>(
|
||||
&Caelum::GroundFog::getDensity,
|
||||
&Caelum::GroundFog::setDensity));
|
||||
td->add("vertical_decay",
|
||||
new AccesorPropertyDescriptor<Caelum::GroundFog, Real, Real, Real>(
|
||||
&Caelum::GroundFog::getVerticalDecay,
|
||||
&Caelum::GroundFog::setVerticalDecay));
|
||||
td->add("ground_level",
|
||||
new AccesorPropertyDescriptor<Caelum::GroundFog, Real, Real, Real>(
|
||||
&Caelum::GroundFog::getGroundLevel,
|
||||
&Caelum::GroundFog::setGroundLevel));
|
||||
td->add("colour",
|
||||
new AccesorPropertyDescriptor<Caelum::GroundFog, ColourValue>(
|
||||
&Caelum::GroundFog::getColour,
|
||||
&Caelum::GroundFog::setColour));
|
||||
GroundFogTypeDescriptor = td.release ();
|
||||
}
|
||||
|
||||
if (!DepthComposerTypeDescriptor)
|
||||
{
|
||||
std::auto_ptr<DefaultTypeDescriptor> td (new DefaultTypeDescriptor ());
|
||||
td->add("debug_depth_render",
|
||||
new AccesorPropertyDescriptor<Caelum::DepthComposer, bool, bool, bool>(
|
||||
&Caelum::DepthComposer::getDebugDepthRender,
|
||||
&Caelum::DepthComposer::setDebugDepthRender));
|
||||
|
||||
// Legacy haze
|
||||
td->add("haze_enabled",
|
||||
new AccesorPropertyDescriptor<Caelum::DepthComposer, bool, bool, bool>(
|
||||
&Caelum::DepthComposer::getSkyDomeHazeEnabled,
|
||||
&Caelum::DepthComposer::setSkyDomeHazeEnabled));
|
||||
td->add("haze_colour",
|
||||
new AccesorPropertyDescriptor<Caelum::DepthComposer, ColourValue>(
|
||||
&Caelum::DepthComposer::getHazeColour,
|
||||
&Caelum::DepthComposer::setHazeColour));
|
||||
td->add("haze_sun_direction",
|
||||
new AccesorPropertyDescriptor<Caelum::DepthComposer, Vector3>(
|
||||
&Caelum::DepthComposer::getSunDirection,
|
||||
&Caelum::DepthComposer::setSunDirection));
|
||||
|
||||
// Ground fog
|
||||
td->add("ground_fog_enabled",
|
||||
new AccesorPropertyDescriptor<Caelum::DepthComposer, bool, bool, bool>(
|
||||
&Caelum::DepthComposer::getGroundFogEnabled,
|
||||
&Caelum::DepthComposer::setGroundFogEnabled));
|
||||
td->add("ground_fog_density",
|
||||
new AccesorPropertyDescriptor<Caelum::DepthComposer, Real, Real, Real>(
|
||||
&Caelum::DepthComposer::getGroundFogDensity,
|
||||
&Caelum::DepthComposer::setGroundFogDensity));
|
||||
td->add("ground_fog_vertical_decay",
|
||||
new AccesorPropertyDescriptor<Caelum::DepthComposer, Real, Real, Real>(
|
||||
&Caelum::DepthComposer::getGroundFogVerticalDecay,
|
||||
&Caelum::DepthComposer::setGroundFogVerticalDecay));
|
||||
td->add("ground_fog_base_level",
|
||||
new AccesorPropertyDescriptor<Caelum::DepthComposer, Real, Real, Real>(
|
||||
&Caelum::DepthComposer::getGroundFogBaseLevel,
|
||||
&Caelum::DepthComposer::setGroundFogBaseLevel));
|
||||
td->add("ground_fog_colour",
|
||||
new AccesorPropertyDescriptor<Caelum::DepthComposer, ColourValue>(
|
||||
&Caelum::DepthComposer::getGroundFogColour,
|
||||
&Caelum::DepthComposer::setGroundFogColour));
|
||||
|
||||
DepthComposerTypeDescriptor = td.release ();
|
||||
}
|
||||
|
||||
if (!PrecipitationTypeDescriptor)
|
||||
{
|
||||
std::auto_ptr<DefaultTypeDescriptor> td (new DefaultTypeDescriptor ());
|
||||
|
||||
td->add("texture",
|
||||
new AccesorPropertyDescriptor<Caelum::PrecipitationController, String>(
|
||||
&Caelum::PrecipitationController::getTextureName,
|
||||
&Caelum::PrecipitationController::setTextureName));
|
||||
td->add("precipitation_colour",
|
||||
new AccesorPropertyDescriptor<Caelum::PrecipitationController, ColourValue>(
|
||||
&Caelum::PrecipitationController::getColour,
|
||||
&Caelum::PrecipitationController::setColour));
|
||||
td->add("falling_speed",
|
||||
new AccesorPropertyDescriptor<Caelum::PrecipitationController, Real, Real, Real>(
|
||||
&Caelum::PrecipitationController::getSpeed,
|
||||
&Caelum::PrecipitationController::setSpeed));
|
||||
td->add("wind_speed",
|
||||
new AccesorPropertyDescriptor<Caelum::PrecipitationController, Vector3>(
|
||||
&Caelum::PrecipitationController::getWindSpeed,
|
||||
&Caelum::PrecipitationController::setWindSpeed));
|
||||
td->add("camera_speed_scale",
|
||||
new AccesorPropertyDescriptor<Caelum::PrecipitationController, Vector3>(
|
||||
&Caelum::PrecipitationController::getCameraSpeedScale,
|
||||
&Caelum::PrecipitationController::setCameraSpeedScale));
|
||||
td->add("intensity",
|
||||
new AccesorPropertyDescriptor<Caelum::PrecipitationController, Real, Real, Real>(
|
||||
&Caelum::PrecipitationController::getIntensity,
|
||||
&Caelum::PrecipitationController::setIntensity));
|
||||
td->add("auto_disable_intensity",
|
||||
new AccesorPropertyDescriptor<Caelum::PrecipitationController, Real, Real, Real>(
|
||||
&Caelum::PrecipitationController::getAutoDisableThreshold,
|
||||
&Caelum::PrecipitationController::setAutoDisableThreshold));
|
||||
td->add("falling_direction",
|
||||
new AccesorPropertyDescriptor<Caelum::PrecipitationController, Vector3>(
|
||||
&Caelum::PrecipitationController::getFallingDirection,
|
||||
&Caelum::PrecipitationController::setFallingDirection));
|
||||
|
||||
PrecipitationTypeDescriptor = td.release ();
|
||||
}
|
||||
|
||||
if (!FlatCloudLayerTypeDescriptor)
|
||||
{
|
||||
std::auto_ptr<DefaultTypeDescriptor> td (new DefaultTypeDescriptor ());
|
||||
|
||||
// Height.
|
||||
td->add("height",
|
||||
new AccesorPropertyDescriptor<Caelum::FlatCloudLayer, Real, Real, Real>(
|
||||
&Caelum::FlatCloudLayer::getHeight,
|
||||
&Caelum::FlatCloudLayer::setHeight));
|
||||
|
||||
// Coverage parameters.
|
||||
td->add("coverage",
|
||||
new AccesorPropertyDescriptor<Caelum::FlatCloudLayer, Real, Real, Real>(
|
||||
&Caelum::FlatCloudLayer::getCloudCover,
|
||||
&Caelum::FlatCloudLayer::setCloudCover));
|
||||
td->add("cloud_cover_visibility_threshold",
|
||||
new AccesorPropertyDescriptor<Caelum::FlatCloudLayer, Real, Real, Real>(
|
||||
&Caelum::FlatCloudLayer::getCloudCoverVisibilityThreshold,
|
||||
&Caelum::FlatCloudLayer::setCloudCoverVisibilityThreshold));
|
||||
td->add("cloud_cover_lookup",
|
||||
new AccesorPropertyDescriptor<Caelum::FlatCloudLayer, String>(
|
||||
&Caelum::FlatCloudLayer::getCloudCoverLookupFileName,
|
||||
&Caelum::FlatCloudLayer::setCloudCoverLookup));
|
||||
|
||||
// Overwritten by CaelumSystem; included for completeness.
|
||||
td->add("sun_direction",
|
||||
new AccesorPropertyDescriptor<Caelum::FlatCloudLayer, Vector3>(
|
||||
&Caelum::FlatCloudLayer::getSunDirection,
|
||||
&Caelum::FlatCloudLayer::setSunDirection));
|
||||
td->add("sun_light_colour",
|
||||
new AccesorPropertyDescriptor<Caelum::FlatCloudLayer, ColourValue>(
|
||||
&Caelum::FlatCloudLayer::getSunLightColour,
|
||||
&Caelum::FlatCloudLayer::setSunLightColour));
|
||||
td->add("sun_sphere_colour",
|
||||
new AccesorPropertyDescriptor<Caelum::FlatCloudLayer, ColourValue>(
|
||||
&Caelum::FlatCloudLayer::getSunSphereColour,
|
||||
&Caelum::FlatCloudLayer::setSunSphereColour));
|
||||
td->add("fog_colour",
|
||||
new AccesorPropertyDescriptor<Caelum::FlatCloudLayer, ColourValue>(
|
||||
&Caelum::FlatCloudLayer::getFogColour,
|
||||
&Caelum::FlatCloudLayer::setFogColour));
|
||||
|
||||
// Moving noise textures.
|
||||
td->add("cloud_speed",
|
||||
new AccesorPropertyDescriptor<Caelum::FlatCloudLayer, Vector2>(
|
||||
&Caelum::FlatCloudLayer::getCloudSpeed,
|
||||
&Caelum::FlatCloudLayer::setCloudSpeed));
|
||||
|
||||
// Blending time between noise textures.
|
||||
td->add("blend_time",
|
||||
new AccesorPropertyDescriptor<Caelum::FlatCloudLayer, Real, Real, Real>(
|
||||
&Caelum::FlatCloudLayer::getCloudBlendTime,
|
||||
&Caelum::FlatCloudLayer::setCloudBlendTime));
|
||||
|
||||
// Mesh properties
|
||||
td->add("mesh_width",
|
||||
new AccesorPropertyDescriptor<Caelum::FlatCloudLayer, Real, Real, Real>(
|
||||
&Caelum::FlatCloudLayer::getMeshWidth,
|
||||
&Caelum::FlatCloudLayer::setMeshWidth));
|
||||
td->add("mesh_height",
|
||||
new AccesorPropertyDescriptor<Caelum::FlatCloudLayer, Real, Real, Real>(
|
||||
&Caelum::FlatCloudLayer::getMeshHeight,
|
||||
&Caelum::FlatCloudLayer::setMeshHeight));
|
||||
td->add("mesh_width_segments",
|
||||
new AccesorPropertyDescriptor<Caelum::FlatCloudLayer, int, int, int>(
|
||||
&Caelum::FlatCloudLayer::getMeshWidthSegments,
|
||||
&Caelum::FlatCloudLayer::setMeshWidthSegments));
|
||||
td->add("mesh_height_segments",
|
||||
new AccesorPropertyDescriptor<Caelum::FlatCloudLayer, int, int, int>(
|
||||
&Caelum::FlatCloudLayer::getMeshHeightSegments,
|
||||
&Caelum::FlatCloudLayer::setMeshHeightSegments));
|
||||
|
||||
// Misc hacks
|
||||
td->add("cloud_uv_factor",
|
||||
new AccesorPropertyDescriptor<Caelum::FlatCloudLayer, Real, Real, Real>(
|
||||
&Caelum::FlatCloudLayer::getCloudUVFactor,
|
||||
&Caelum::FlatCloudLayer::setCloudUVFactor));
|
||||
td->add("height_red_factor",
|
||||
new AccesorPropertyDescriptor<Caelum::FlatCloudLayer, Real, Real, Real>(
|
||||
&Caelum::FlatCloudLayer::getHeightRedFactor,
|
||||
&Caelum::FlatCloudLayer::setHeightRedFactor));
|
||||
|
||||
// Fading
|
||||
td->add("near_fade_dist",
|
||||
new AccesorPropertyDescriptor<Caelum::FlatCloudLayer, Real, Real, Real>(
|
||||
&Caelum::FlatCloudLayer::getNearFadeDist,
|
||||
&Caelum::FlatCloudLayer::setNearFadeDist));
|
||||
td->add("far_fade_dist",
|
||||
new AccesorPropertyDescriptor<Caelum::FlatCloudLayer, Real, Real, Real>(
|
||||
&Caelum::FlatCloudLayer::getFarFadeDist,
|
||||
&Caelum::FlatCloudLayer::setFarFadeDist));
|
||||
td->add("fade_dist_measurement_vector",
|
||||
new AccesorPropertyDescriptor<Caelum::FlatCloudLayer, Vector3>(
|
||||
&Caelum::FlatCloudLayer::getFadeDistMeasurementVector,
|
||||
&Caelum::FlatCloudLayer::setFadeDistMeasurementVector));
|
||||
|
||||
FlatCloudLayerTypeDescriptor = td.release ();
|
||||
}
|
||||
|
||||
if (!SkyDomeTypeDescriptor)
|
||||
{
|
||||
std::auto_ptr<DefaultTypeDescriptor> td (new DefaultTypeDescriptor ());
|
||||
|
||||
// SkyDome is slightly special because most properties are write-only.
|
||||
|
||||
// Reset by CaelumSystem every frame anyway
|
||||
td->add("sun_direction",
|
||||
new AccesorPropertyDescriptor<Caelum::SkyDome, Ogre::Vector3>(
|
||||
0, &Caelum::SkyDome::setSunDirection));
|
||||
td->add("haze_colour",
|
||||
new AccesorPropertyDescriptor<Caelum::SkyDome, Ogre::ColourValue>(
|
||||
0, &Caelum::SkyDome::setHazeColour));
|
||||
|
||||
// Different files not supported anyway
|
||||
td->add("sky_gradients_image",
|
||||
new AccesorPropertyDescriptor<Caelum::SkyDome, Ogre::String>(
|
||||
0, &Caelum::SkyDome::setSkyGradientsImage));
|
||||
td->add("atmosphere_depth_image",
|
||||
new AccesorPropertyDescriptor<Caelum::SkyDome, Ogre::String>(
|
||||
0, &Caelum::SkyDome::setAtmosphereDepthImage));
|
||||
|
||||
// This does actually make sense.
|
||||
td->add("haze_enabled",
|
||||
new AccesorPropertyDescriptor<Caelum::SkyDome, bool, bool, bool>(
|
||||
&Caelum::SkyDome::getHazeEnabled,
|
||||
&Caelum::SkyDome::setHazeEnabled));
|
||||
|
||||
SkyDomeTypeDescriptor = td.release ();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#endif // CAELUM_TYPE_DESCRIPTORS
|
||||
@ -1,162 +0,0 @@
|
||||
/*
|
||||
This file is part of Caelum.
|
||||
See http://www.ogre3d.org/wiki/index.php/Caelum
|
||||
|
||||
Copyright (c) 2008 Caelum team. See Contributors.txt for details.
|
||||
|
||||
Caelum is free software: you can redistribute it and/or modify
|
||||
it under the terms of the GNU Lesser General Public License as published
|
||||
by the Free Software Foundation, either version 3 of the License, or
|
||||
(at your option) any later version.
|
||||
|
||||
Caelum is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
GNU Lesser General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU Lesser General Public License
|
||||
along with Caelum. If not, see <http://www.gnu.org/licenses/>.
|
||||
*/
|
||||
|
||||
#include "CaelumPrecompiled.h"
|
||||
#include "CaelumPlugin.h"
|
||||
|
||||
template<> Caelum::CaelumPlugin* Ogre::Singleton<Caelum::CaelumPlugin>::ms_Singleton = 0;
|
||||
|
||||
namespace Caelum
|
||||
{
|
||||
CaelumPlugin* CaelumPlugin::getSingletonPtr () {
|
||||
return ms_Singleton;
|
||||
}
|
||||
|
||||
CaelumPlugin& CaelumPlugin::getSingleton () {
|
||||
assert (ms_Singleton);
|
||||
return *ms_Singleton;
|
||||
}
|
||||
|
||||
extern "C" void CAELUM_EXPORT dllStartPlugin () {
|
||||
assert (CaelumPlugin::getSingletonPtr () == 0);
|
||||
CaelumPlugin* plugin = new CaelumPlugin();
|
||||
assert (CaelumPlugin::getSingletonPtr () == plugin);
|
||||
Ogre::Root::getSingleton ().installPlugin (CaelumPlugin::getSingletonPtr ());
|
||||
}
|
||||
|
||||
extern "C" void CAELUM_EXPORT dllStopPlugin () {
|
||||
assert (CaelumPlugin::getSingletonPtr () != 0);
|
||||
Ogre::Root::getSingleton ().uninstallPlugin (CaelumPlugin::getSingletonPtr ());
|
||||
delete CaelumPlugin::getSingletonPtr ();
|
||||
assert (CaelumPlugin::getSingletonPtr () == 0);
|
||||
}
|
||||
|
||||
#if CAELUM_SCRIPT_SUPPORT
|
||||
CaelumPlugin::CaelumPlugin(): mScriptTranslatorManager(&mTypeDescriptorData)
|
||||
#else
|
||||
CaelumPlugin::CaelumPlugin()
|
||||
#endif
|
||||
{
|
||||
mIsInstalled = false;
|
||||
}
|
||||
|
||||
CaelumPlugin::~CaelumPlugin() {
|
||||
}
|
||||
|
||||
const Ogre::String CaelumPlugin::CAELUM_PLUGIN_NAME = "Caelum";
|
||||
|
||||
const Ogre::String& CaelumPlugin::getName () const {
|
||||
return CAELUM_PLUGIN_NAME;
|
||||
}
|
||||
|
||||
void CaelumPlugin::install ()
|
||||
{
|
||||
assert(!mIsInstalled && "Already installed");
|
||||
|
||||
Ogre::LogManager::getSingleton ().logMessage("Caelum plugin version " +
|
||||
Ogre::StringConverter::toString (CAELUM_VERSION_MAIN) + "." +
|
||||
Ogre::StringConverter::toString (CAELUM_VERSION_SEC) + "." +
|
||||
Ogre::StringConverter::toString (CAELUM_VERSION_TER) + " "
|
||||
"installed");
|
||||
|
||||
#if CAELUM_SCRIPT_SUPPORT
|
||||
Ogre::ScriptCompilerManager::getSingleton ().addTranslatorManager (
|
||||
getScriptTranslatorManager ());
|
||||
Ogre::ResourceGroupManager::getSingleton()._registerResourceManager (
|
||||
getPropScriptResourceManager ()->getResourceType (),
|
||||
getPropScriptResourceManager ());
|
||||
|
||||
getScriptTranslatorManager()->_setPropScriptResourceManager (
|
||||
&mPropScriptResourceManager);
|
||||
#endif // CAELUM_SCRIPT_SUPPORT
|
||||
|
||||
mIsInstalled = true;
|
||||
}
|
||||
|
||||
void CaelumPlugin::initialise () {
|
||||
}
|
||||
|
||||
void CaelumPlugin::shutdown () {
|
||||
}
|
||||
|
||||
void CaelumPlugin::uninstall ()
|
||||
{
|
||||
assert(mIsInstalled && "Not installed");
|
||||
|
||||
#if CAELUM_SCRIPT_SUPPORT
|
||||
getScriptTranslatorManager()->_setPropScriptResourceManager (0);
|
||||
|
||||
Ogre::ResourceGroupManager::getSingleton ()._unregisterResourceManager (
|
||||
getPropScriptResourceManager ()->getResourceType ());
|
||||
Ogre::ScriptCompilerManager::getSingleton ().removeTranslatorManager (
|
||||
getScriptTranslatorManager ());
|
||||
#endif // CAELUM_SCRIPT_SUPPORT
|
||||
|
||||
Ogre::LogManager::getSingleton ().logMessage("Caelum plugin uninstalled");
|
||||
|
||||
mIsInstalled = false;
|
||||
}
|
||||
|
||||
#if CAELUM_SCRIPT_SUPPORT
|
||||
void CaelumPlugin::loadCaelumSystemFromScript (
|
||||
CaelumSystem* sys,
|
||||
const Ogre::String& objectName,
|
||||
const Ogre::String& groupName)
|
||||
{
|
||||
assert (sys);
|
||||
assert (this->isInstalled () && "Must install CaelumPlugin before loading scripts");
|
||||
|
||||
// Fetch raw resource ptr. Attempt to support explicit resource groups currently in Ogre trunk.
|
||||
#if OGRE_VERSION >= 0x00010700
|
||||
Ogre::ResourcePtr res = getPropScriptResourceManager ()->getByName (objectName, groupName);
|
||||
#else
|
||||
Ogre::ResourcePtr res = getPropScriptResourceManager ()->getByName (objectName);
|
||||
#endif
|
||||
|
||||
// Check a PropScriptResource was found.
|
||||
PropScriptResource* propRes = static_cast<PropScriptResource*> (res.get ());
|
||||
if (!propRes) {
|
||||
OGRE_EXCEPT (Ogre::Exception::ERR_ITEM_NOT_FOUND,
|
||||
"Could not find caelum_sky_system " + objectName,
|
||||
"CaelumPlugin::loadCaelumSystemFromScript");
|
||||
}
|
||||
|
||||
// Fetch the resource stream. Look in the actual group of the resource!
|
||||
const Ogre::String& scriptFileName = propRes->getOrigin();
|
||||
const Ogre::String& scriptFileGroup = propRes->getGroup();
|
||||
Ogre::DataStreamPtr streamPtr = Ogre::ResourceGroupManager::getSingleton ().openResource (
|
||||
scriptFileName, scriptFileGroup, false);
|
||||
|
||||
// Feed it into the compiler.
|
||||
this->getScriptTranslatorManager()->getCaelumSystemTranslator()->setTranslationTarget (sys, objectName);
|
||||
Ogre::ScriptCompilerManager::getSingleton ().parseScript (streamPtr, Ogre::ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME);
|
||||
bool found = this->getScriptTranslatorManager()->getCaelumSystemTranslator()->foundTranslationTarget ();
|
||||
|
||||
// This shouldn't normally happen.
|
||||
if (!found) {
|
||||
OGRE_EXCEPT (Ogre::Exception::ERR_ITEM_NOT_FOUND,
|
||||
"Could not find caelum_sky_system " + objectName + " in file " + scriptFileName + " on reparsing. "
|
||||
"Perhaps information in PropScriptResourceManager is out of date?",
|
||||
"CaelumPlugin::loadCaelumSystemFromScript");
|
||||
}
|
||||
this->getScriptTranslatorManager()->getCaelumSystemTranslator()->clearTranslationTarget ();
|
||||
}
|
||||
#endif // CAELUM_SCRIPT_SUPPORT
|
||||
}
|
||||
@ -1,21 +0,0 @@
|
||||
/*
|
||||
This file is part of Caelum.
|
||||
See http://www.ogre3d.org/wiki/index.php/Caelum
|
||||
|
||||
Copyright (c) 2006-2007 Caelum team. See Contributors.txt for details.
|
||||
|
||||
Caelum is free software: you can redistribute it and/or modify
|
||||
it under the terms of the GNU Lesser General Public License as published
|
||||
by the Free Software Foundation, either version 3 of the License, or
|
||||
(at your option) any later version.
|
||||
|
||||
Caelum is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
GNU Lesser General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU Lesser General Public License
|
||||
along with Caelum. If not, see <http://www.gnu.org/licenses/>.
|
||||
*/
|
||||
|
||||
#include "CaelumPrecompiled.h"
|
||||
@ -1,643 +0,0 @@
|
||||
/*
|
||||
This file is part of Caelum.
|
||||
See http://www.ogre3d.org/wiki/index.php/Caelum
|
||||
|
||||
Copyright (c) 2006-2008 Caelum team. See Contributors.txt for details.
|
||||
|
||||
Caelum is free software: you can redistribute it and/or modify
|
||||
it under the terms of the GNU Lesser General Public License as published
|
||||
by the Free Software Foundation, either version 3 of the License, or
|
||||
(at your option) any later version.
|
||||
|
||||
Caelum is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
GNU Lesser General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU Lesser General Public License
|
||||
along with Caelum. If not, see <http://www.gnu.org/licenses/>.
|
||||
*/
|
||||
|
||||
#include "CaelumPrecompiled.h"
|
||||
#include "CaelumPrerequisites.h"
|
||||
|
||||
#if CAELUM_SCRIPT_SUPPORT
|
||||
|
||||
#include "CaelumScriptTranslator.h"
|
||||
#include "CaelumSystem.h"
|
||||
#include "CaelumExceptions.h"
|
||||
|
||||
using namespace Ogre;
|
||||
|
||||
namespace Caelum
|
||||
{
|
||||
PropScriptResource::PropScriptResource
|
||||
(
|
||||
Ogre::ResourceManager* creator, const Ogre::String& name, Ogre::ResourceHandle handle,
|
||||
const Ogre::String& group, bool isManual, Ogre::ManualResourceLoader* loader
|
||||
):
|
||||
Ogre::Resource (creator, name, handle, group, isManual, loader)
|
||||
{
|
||||
//Ogre::LogManager::getSingleton().logMessage(
|
||||
// "PropScriptResource::PropScriptResource");
|
||||
}
|
||||
|
||||
PropScriptResource::~PropScriptResource() {
|
||||
//Ogre::LogManager::getSingleton().logMessage(
|
||||
// "PropScriptResource::~PropScriptResource");
|
||||
}
|
||||
|
||||
PropScriptResourceManager::PropScriptResourceManager() {
|
||||
mLoadOrder = 1000;
|
||||
mResourceType = "PropertyScript";
|
||||
}
|
||||
|
||||
PropScriptResource* PropScriptResourceManager::createImpl(
|
||||
const String& name, ResourceHandle handle, const String& group,
|
||||
bool isManual, ManualResourceLoader* loader, const NameValuePairList* createParams)
|
||||
{
|
||||
//Ogre::LogManager::getSingleton().logMessage(
|
||||
// "PropScriptResourceManager::createImpl");
|
||||
return new PropScriptResource (this, name, handle, group, isManual, loader);
|
||||
}
|
||||
|
||||
TypeDescriptorScriptTranslator::TypeDescriptorScriptTranslator (TypeDescriptor* typeDescriptor):
|
||||
mTypeDescriptor(typeDescriptor)
|
||||
{
|
||||
}
|
||||
|
||||
bool TypeDescriptorScriptTranslator::getPropValueOrAddError (
|
||||
ScriptCompiler* compiler,
|
||||
PropertyAbstractNode* prop,
|
||||
bool& value)
|
||||
{
|
||||
if (prop->values.empty ()) {
|
||||
compiler->addError (ScriptCompiler::CE_STRINGEXPECTED, prop->file, prop->line);
|
||||
return false;
|
||||
}
|
||||
if (prop->values.size () > 1) {
|
||||
compiler->addError (ScriptCompiler::CE_FEWERPARAMETERSEXPECTED, prop->file, prop->line,
|
||||
prop->name + " must have at most 1 argument");
|
||||
return false;
|
||||
}
|
||||
if (!Ogre::ScriptTranslator::getBoolean(prop->values.front(), &value)) {
|
||||
compiler->addError (ScriptCompiler::CE_INVALIDPARAMETERS, prop->file, prop->line,
|
||||
prop->values.front()->getValue() + " is not a valid number");
|
||||
return false;
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
bool TypeDescriptorScriptTranslator::getPropValueOrAddError (
|
||||
ScriptCompiler* compiler,
|
||||
PropertyAbstractNode* prop,
|
||||
ColourValue& value)
|
||||
{
|
||||
if (prop->values.empty ()) {
|
||||
compiler->addError (ScriptCompiler::CE_STRINGEXPECTED, prop->file, prop->line);
|
||||
return false;
|
||||
}
|
||||
if (prop->values.size () > 4) {
|
||||
compiler->addError (ScriptCompiler::CE_FEWERPARAMETERSEXPECTED, prop->file, prop->line,
|
||||
prop->name + " must have at most 4 arguments");
|
||||
return false;
|
||||
}
|
||||
if (prop->values.size () < 3) {
|
||||
compiler->addError (ScriptCompiler::CE_FEWERPARAMETERSEXPECTED, prop->file, prop->line,
|
||||
prop->name + " must have at least 3 arguments");
|
||||
}
|
||||
if (!getColour(prop->values.begin(), prop->values.end(), &value)) {
|
||||
compiler->addError (ScriptCompiler::CE_INVALIDPARAMETERS, prop->file, prop->line,
|
||||
prop->name + " requires a colour argument");
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
bool TypeDescriptorScriptTranslator::getPropValueOrAddError (
|
||||
ScriptCompiler* compiler,
|
||||
PropertyAbstractNode* prop,
|
||||
float& value)
|
||||
{
|
||||
if (prop->values.empty ()) {
|
||||
compiler->addError (ScriptCompiler::CE_STRINGEXPECTED, prop->file, prop->line);
|
||||
return false;
|
||||
}
|
||||
if (prop->values.size () > 1) {
|
||||
compiler->addError (ScriptCompiler::CE_FEWERPARAMETERSEXPECTED, prop->file, prop->line,
|
||||
prop->name + " must have at most 1 argument");
|
||||
return false;
|
||||
}
|
||||
if (!Ogre::ScriptTranslator::getFloat(prop->values.front(), &value)) {
|
||||
compiler->addError (ScriptCompiler::CE_INVALIDPARAMETERS, prop->file, prop->line,
|
||||
prop->values.front()->getValue() + " is not a valid number");
|
||||
return false;
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
bool TypeDescriptorScriptTranslator::getPropValueOrAddError (
|
||||
ScriptCompiler* compiler,
|
||||
PropertyAbstractNode* prop,
|
||||
int& value)
|
||||
{
|
||||
if (prop->values.empty ()) {
|
||||
compiler->addError (ScriptCompiler::CE_STRINGEXPECTED, prop->file, prop->line);
|
||||
return false;
|
||||
}
|
||||
if (prop->values.size () > 1) {
|
||||
compiler->addError (ScriptCompiler::CE_FEWERPARAMETERSEXPECTED, prop->file, prop->line,
|
||||
prop->name + " must have at most 1 argument");
|
||||
return false;
|
||||
}
|
||||
if (!Ogre::ScriptTranslator::getInt(prop->values.front(), &value)) {
|
||||
compiler->addError (ScriptCompiler::CE_INVALIDPARAMETERS, prop->file, prop->line,
|
||||
prop->values.front()->getValue() + " is not a valid integer");
|
||||
return false;
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
bool TypeDescriptorScriptTranslator::getPropValueOrAddError (
|
||||
ScriptCompiler* compiler,
|
||||
PropertyAbstractNode* prop,
|
||||
double& value)
|
||||
{
|
||||
if (prop->values.empty ()) {
|
||||
compiler->addError (ScriptCompiler::CE_STRINGEXPECTED, prop->file, prop->line);
|
||||
return false;
|
||||
}
|
||||
if (prop->values.size () > 1) {
|
||||
compiler->addError (ScriptCompiler::CE_FEWERPARAMETERSEXPECTED, prop->file, prop->line,
|
||||
prop->name + " must have at most 1 argument");
|
||||
return false;
|
||||
}
|
||||
// We do need a string stream here for the extra precision.
|
||||
std::stringstream strStream (std::string(prop->values.front()->getValue()));
|
||||
strStream >> value;
|
||||
if (strStream.fail()) {
|
||||
compiler->addError (ScriptCompiler::CE_INVALIDPARAMETERS, prop->file, prop->line,
|
||||
prop->values.front()->getValue() + " is not a valid number");
|
||||
return false;
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
bool TypeDescriptorScriptTranslator::getPropValueOrAddError (
|
||||
ScriptCompiler* compiler,
|
||||
PropertyAbstractNode* prop,
|
||||
Ogre::Degree& value)
|
||||
{
|
||||
if (prop->values.size () == 0) {
|
||||
compiler->addError (ScriptCompiler::CE_STRINGEXPECTED, prop->file, prop->line);
|
||||
return false;
|
||||
}
|
||||
if (prop->values.size () > 3) {
|
||||
compiler->addError (ScriptCompiler::CE_FEWERPARAMETERSEXPECTED, prop->file, prop->line,
|
||||
prop->name + " must have at most 3 arguments");
|
||||
return false;
|
||||
}
|
||||
// Allow 3 components.
|
||||
float degMinSec[3] = { 0, 0, 0 };
|
||||
int k = 0;
|
||||
for (AbstractNodeList::const_iterator it = prop->values.begin(), endIt = prop->values.end(); it != endIt; ++it, ++k) {
|
||||
if (!Ogre::ScriptTranslator::getFloat(*it, °MinSec[k])) {
|
||||
compiler->addError (ScriptCompiler::CE_INVALIDPARAMETERS, prop->file, prop->line,
|
||||
(*it)->getValue () + " is not a valid number");
|
||||
return false;
|
||||
}
|
||||
}
|
||||
value = Ogre::Degree(degMinSec[0] + degMinSec[1] / 60.0 + degMinSec[2] / 3600);
|
||||
return true;
|
||||
}
|
||||
|
||||
bool TypeDescriptorScriptTranslator::getPropValueOrAddError (
|
||||
ScriptCompiler* compiler,
|
||||
PropertyAbstractNode* prop,
|
||||
Ogre::String& value)
|
||||
{
|
||||
if (prop->values.size () == 0) {
|
||||
compiler->addError (ScriptCompiler::CE_STRINGEXPECTED, prop->file, prop->line);
|
||||
return false;
|
||||
}
|
||||
if (prop->values.size () > 1) {
|
||||
compiler->addError (ScriptCompiler::CE_FEWERPARAMETERSEXPECTED, prop->file, prop->line,
|
||||
prop->name + " must have at most 1 arguments");
|
||||
return false;
|
||||
}
|
||||
if (!Ogre::ScriptTranslator::getString(prop->values.front(), &value)) {
|
||||
compiler->addError (ScriptCompiler::CE_INVALIDPARAMETERS, prop->file, prop->line,
|
||||
prop->values.front()->getValue() + " is not a valid string");
|
||||
return false;
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
bool TypeDescriptorScriptTranslator::getPropValueOrAddError (
|
||||
ScriptCompiler* compiler,
|
||||
PropertyAbstractNode* prop,
|
||||
Ogre::Vector3& value)
|
||||
{
|
||||
if (prop->values.size () == 0) {
|
||||
compiler->addError (ScriptCompiler::CE_STRINGEXPECTED, prop->file, prop->line);
|
||||
return false;
|
||||
}
|
||||
if (prop->values.size () > 3) {
|
||||
compiler->addError (ScriptCompiler::CE_FEWERPARAMETERSEXPECTED, prop->file, prop->line,
|
||||
prop->name + " must have at most 3 arguments");
|
||||
return false;
|
||||
}
|
||||
float floats[3];
|
||||
if (!Ogre::ScriptTranslator::getFloats(prop->values.begin(), prop->values.end(), floats, 3)) {
|
||||
compiler->addError (ScriptCompiler::CE_INVALIDPARAMETERS, prop->file, prop->line,
|
||||
"incorrect vector parameters.");
|
||||
return false;
|
||||
}
|
||||
value.x = floats[0];
|
||||
value.y = floats[1];
|
||||
value.z = floats[2];
|
||||
return true;
|
||||
}
|
||||
|
||||
bool TypeDescriptorScriptTranslator::getPropValueOrAddError (
|
||||
ScriptCompiler* compiler,
|
||||
PropertyAbstractNode* prop,
|
||||
Ogre::Vector2& value)
|
||||
{
|
||||
if (prop->values.size () == 0) {
|
||||
compiler->addError (ScriptCompiler::CE_STRINGEXPECTED, prop->file, prop->line);
|
||||
return false;
|
||||
}
|
||||
if (prop->values.size () > 2) {
|
||||
compiler->addError (ScriptCompiler::CE_FEWERPARAMETERSEXPECTED, prop->file, prop->line,
|
||||
prop->name + " must have at most 3 arguments");
|
||||
return false;
|
||||
}
|
||||
float floats[2];
|
||||
if (!Ogre::ScriptTranslator::getFloats(prop->values.begin(), prop->values.end(), floats, 2)) {
|
||||
compiler->addError (ScriptCompiler::CE_INVALIDPARAMETERS, prop->file, prop->line,
|
||||
"incorrect vector parameters.");
|
||||
return false;
|
||||
}
|
||||
value.x = floats[0];
|
||||
value.y = floats[1];
|
||||
return true;
|
||||
}
|
||||
|
||||
template<class T>
|
||||
static bool tryHandlePropertyType (
|
||||
ScriptCompiler* compiler, PropertyAbstractNode* propNode,
|
||||
void* targetObject, const ValuePropertyDescriptor* propDesc)
|
||||
{
|
||||
if (propDesc->getValueTypeId () == typeid(T)) {
|
||||
T val;
|
||||
if (TypeDescriptorScriptTranslator::getPropValueOrAddError (compiler, propNode, val)) {
|
||||
propDesc->setValue (targetObject, Ogre::Any(val));
|
||||
}
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
void TypeDescriptorScriptTranslator::translateProperty (
|
||||
ScriptCompiler* compiler,
|
||||
PropertyAbstractNode* prop,
|
||||
void* targetObject,
|
||||
const TypeDescriptor* typeDescriptor)
|
||||
{
|
||||
const ValuePropertyDescriptor* propDesc = typeDescriptor->getPropertyDescriptor (prop->name);
|
||||
if (!propDesc) {
|
||||
compiler->addError (ScriptCompiler::CE_UNEXPECTEDTOKEN, prop->file, prop->line,
|
||||
"property \"" + prop->name + "\" not recognized; missing from type descriptor.");
|
||||
return;
|
||||
}
|
||||
if (!propDesc->canSetValue ()) {
|
||||
compiler->addError (ScriptCompiler::CE_UNEXPECTEDTOKEN, prop->file, prop->line,
|
||||
"property \"" + prop->name + "\" is read-only and can't be set from a script.");
|
||||
return;
|
||||
}
|
||||
|
||||
//LogManager::getSingleton ().logMessage ("TypeDescriptorScriptTranslator::translateProperty"
|
||||
// " name '" + prop->name + "'");
|
||||
|
||||
bool handled = false
|
||||
|| tryHandlePropertyType<int> (compiler, prop, targetObject, propDesc)
|
||||
|| tryHandlePropertyType<float> (compiler, prop, targetObject, propDesc)
|
||||
|| tryHandlePropertyType<double> (compiler, prop, targetObject, propDesc)
|
||||
|| tryHandlePropertyType<bool> (compiler, prop, targetObject, propDesc)
|
||||
|| tryHandlePropertyType<Ogre::Degree> (compiler, prop, targetObject, propDesc)
|
||||
|| tryHandlePropertyType<Ogre::String> (compiler, prop, targetObject, propDesc)
|
||||
|| tryHandlePropertyType<Ogre::Vector3> (compiler, prop, targetObject, propDesc)
|
||||
|| tryHandlePropertyType<Ogre::Vector2> (compiler, prop, targetObject, propDesc)
|
||||
|| tryHandlePropertyType<Ogre::ColourValue> (compiler, prop, targetObject, propDesc);
|
||||
|
||||
if (!handled) {
|
||||
compiler->addError (ScriptCompiler::CE_UNEXPECTEDTOKEN, prop->file, prop->line,
|
||||
"property \"" + prop->name + "\" is found in type descriptor but has "
|
||||
"unsupported type. Mangled typeid is '" + propDesc->getValueTypeId().name() + "'");
|
||||
}
|
||||
}
|
||||
|
||||
void TypeDescriptorScriptTranslator::translate (ScriptCompiler* compiler, const AbstractNodePtr& node)
|
||||
{
|
||||
//LogManager::getSingleton ().logMessage ("TypeDescriptorScriptTranslator::translate begin");
|
||||
|
||||
// Check type descriptor was set.
|
||||
assert (getTypeDescriptor () && "Type descriptor must be set before we can translate.");
|
||||
|
||||
// Fetch target object.
|
||||
ObjectAbstractNode *objNode = reinterpret_cast<ObjectAbstractNode*>(node.get());
|
||||
assert (!objNode->context.isEmpty ());
|
||||
void* targetObject = any_cast<void*> (objNode->context);
|
||||
assert (targetObject);
|
||||
|
||||
for (AbstractNodeList::iterator i = objNode->children.begin(); i != objNode->children.end(); ++i)
|
||||
{
|
||||
if ((*i)->type == ANT_PROPERTY)
|
||||
{
|
||||
PropertyAbstractNode *prop = reinterpret_cast<PropertyAbstractNode*>((*i).get());
|
||||
|
||||
translateProperty (compiler, prop, targetObject, getTypeDescriptor());
|
||||
}
|
||||
else if((*i)->type == ANT_OBJECT)
|
||||
{
|
||||
compiler->addError (ScriptCompiler::CE_INVALIDPARAMETERS, (*i)->file, (*i)->line);
|
||||
}
|
||||
}
|
||||
|
||||
//LogManager::getSingleton ().logMessage ("TypeDescriptorScriptTranslator::translate end");
|
||||
}
|
||||
|
||||
CaelumSystemScriptTranslator::CaelumSystemScriptTranslator ():
|
||||
mResourceManager(false),
|
||||
mTranslationTarget(0),
|
||||
mTranslationTargetFound(false),
|
||||
mTypeDescriptor(0)
|
||||
{
|
||||
}
|
||||
|
||||
void CaelumSystemScriptTranslator::setTranslationTarget (CaelumSystem* target, const Ogre::String& name)
|
||||
{
|
||||
assert (target != 0);
|
||||
this->mTranslationTarget = target;
|
||||
this->mTranslationTargetName = name;
|
||||
this->mTranslationTargetFound = false;
|
||||
}
|
||||
|
||||
void CaelumSystemScriptTranslator::clearTranslationTarget () {
|
||||
this->mTranslationTarget = 0;
|
||||
this->mTranslationTargetName.clear();
|
||||
this->mTranslationTargetFound = false;
|
||||
}
|
||||
|
||||
void CaelumSystemScriptTranslator::translate (ScriptCompiler* compiler, const AbstractNodePtr& node)
|
||||
{
|
||||
//LogManager::getSingleton ().logMessage ("CaelumSystemScriptTranslator::translate begin");
|
||||
|
||||
ObjectAbstractNode *objNode = reinterpret_cast<ObjectAbstractNode*>(node.get());
|
||||
|
||||
CaelumSystem* sys = 0;
|
||||
|
||||
// Check for a translation target.
|
||||
if (this->getTranslationTarget ()) {
|
||||
sys = this->getTranslationTarget ();
|
||||
|
||||
// Check for a name match.
|
||||
if (this->getTranslationTargetName () != objNode->name) {
|
||||
//LogManager::getSingleton ().logMessage (
|
||||
// "Caelum: Skipped " + objNode->cls + " name " + objNode->name + " while loading");
|
||||
return;
|
||||
}
|
||||
|
||||
// Clear the target; this ensure that properties which are not
|
||||
// mentioned are set to their default values.
|
||||
// We only do this after we found a target; this ensure that if
|
||||
// the target is not found it's not modified either.
|
||||
sys->clear();
|
||||
|
||||
//LogManager::getSingleton ().logMessage (
|
||||
// "Caelum: Found " + objNode->cls + " name " + objNode->name + "; filling properties.");
|
||||
mTranslationTargetFound = true;
|
||||
} else if (this->getResourceManager ()) {
|
||||
// If we don't have a target but have a resource manager then create a resource.
|
||||
//LogManager::getSingleton ().logMessage (
|
||||
// "Caelum: Saved " + objNode->cls + " name " + objNode->name + " as a resource");
|
||||
PropScriptResourceManager* mgr = this->getResourceManager ();
|
||||
ResourcePtr resource = mgr->create (objNode->name, compiler->getResourceGroup());
|
||||
resource->_notifyOrigin (objNode->file);
|
||||
return;
|
||||
}
|
||||
|
||||
objNode->context = sys;
|
||||
|
||||
for (AbstractNodeList::iterator i = objNode->children.begin(); i != objNode->children.end(); ++i)
|
||||
{
|
||||
if ((*i)->type == ANT_PROPERTY)
|
||||
{
|
||||
PropertyAbstractNode *prop = reinterpret_cast<PropertyAbstractNode*>((*i).get());
|
||||
|
||||
// Properties implemented through type descriptor.
|
||||
TypeDescriptorScriptTranslator::translateProperty(
|
||||
compiler, prop,
|
||||
static_cast<void*>(sys),
|
||||
getTypeDescriptor ());
|
||||
}
|
||||
else if((*i)->type == ANT_OBJECT)
|
||||
{
|
||||
ObjectAbstractNode *childObjNode = reinterpret_cast<ObjectAbstractNode*>((*i).get());
|
||||
|
||||
//LogManager::getSingleton ().logMessage ("CaelumSystemScriptTranslator::translate child object"
|
||||
// " value '" + childObjNode->getValue () + "'"
|
||||
// " name '" + childObjNode->name + "'"
|
||||
// " cls '" + childObjNode->cls + "'"
|
||||
// " base '" + childObjNode->base + "'");
|
||||
|
||||
// Only allow declarations with one class token; like "moon { }"
|
||||
#if OGRE_VERSION < 0x010700
|
||||
if (childObjNode->name.empty () == false || childObjNode->base.empty () == false) {
|
||||
#else
|
||||
if (childObjNode->name.empty () == false || childObjNode->bases.size () != 0) {
|
||||
#endif
|
||||
compiler->addError (
|
||||
ScriptCompiler::CE_FEWERPARAMETERSEXPECTED,
|
||||
childObjNode->file, childObjNode->line,
|
||||
"caelum_sky_system components can't have names or bases");
|
||||
continue;
|
||||
}
|
||||
const String& className = childObjNode->cls;
|
||||
|
||||
try {
|
||||
if (className == "sun") {
|
||||
sys->setSun (new Sun (sys->getSceneMgr (), sys->getCaelumCameraNode ()));
|
||||
childObjNode->context = static_cast<void*> (sys->getSun ());
|
||||
} else if (className == "sky_dome") {
|
||||
sys->setSkyDome (new SkyDome (sys->getSceneMgr (), sys->getCaelumCameraNode ()));
|
||||
childObjNode->context = static_cast<void*>(sys->getSkyDome ());
|
||||
} else if (className == "moon") {
|
||||
sys->setMoon (new Moon (sys->getSceneMgr (), sys->getCaelumCameraNode ()));
|
||||
childObjNode->context = static_cast<void*>(sys->getMoon ());
|
||||
} else if (className == "ground_fog") {
|
||||
sys->setGroundFog (new GroundFog (sys->getSceneMgr (), sys->getCaelumCameraNode ()));
|
||||
childObjNode->context = static_cast<void*>(sys->getGroundFog ());
|
||||
} else if (className == "depth_composer") {
|
||||
sys->setDepthComposer (new DepthComposer (sys->getSceneMgr ()));
|
||||
childObjNode->context = static_cast<void*>(sys->getDepthComposer ());
|
||||
} else if (className == "point_starfield") {
|
||||
sys->setPointStarfield (new PointStarfield (sys->getSceneMgr (), sys->getCaelumCameraNode()));
|
||||
childObjNode->context = static_cast<void*>(sys->getPointStarfield ());
|
||||
} else if (className == "precipitation") {
|
||||
sys->setPrecipitationController (new PrecipitationController (sys->getSceneMgr ()));
|
||||
childObjNode->context = static_cast<void*>(sys->getPrecipitationController ());
|
||||
} else if (className == "cloud_system") {
|
||||
sys->setCloudSystem (new CloudSystem (sys->getSceneMgr (), sys->getCaelumGroundNode ()));
|
||||
childObjNode->context = static_cast<void*>(sys->getCloudSystem ());
|
||||
} else {
|
||||
LogManager::getSingleton ().logMessage ("CaelumSystemScriptTranslator::translate "
|
||||
"unknown child object class '" + className + "'");
|
||||
}
|
||||
} catch (Caelum::UnsupportedException& ex) {
|
||||
// Catch all unsupported exceptions and report them.
|
||||
// This should usually happen because the proper shaders are not supported by hardware.
|
||||
//
|
||||
// Script parsing should still succeed.
|
||||
compiler->addError (
|
||||
ScriptCompiler::CE_UNSUPPORTEDBYRENDERSYSTEM,
|
||||
childObjNode->file, childObjNode->line,
|
||||
"Failed to create component \"" + className + "\": " + ex.getFullDescription ());
|
||||
continue;
|
||||
}
|
||||
processNode (compiler, *i);
|
||||
}
|
||||
}
|
||||
|
||||
//LogManager::getSingleton ().logMessage ("SkySystemScriptTranslator::translate END");
|
||||
}
|
||||
|
||||
void CloudSystemScriptTranslator::translate (ScriptCompiler* compiler, const AbstractNodePtr& node)
|
||||
{
|
||||
//LogManager::getSingleton ().logMessage ("SkySystemScriptTranslator::translate begin");
|
||||
|
||||
ObjectAbstractNode *objNode = reinterpret_cast<ObjectAbstractNode*>(node.get());
|
||||
assert (!objNode->context.isEmpty ());
|
||||
void* rawTargetObject = any_cast<void*> (objNode->context);
|
||||
assert (rawTargetObject);
|
||||
|
||||
CloudSystem* target = static_cast<CloudSystem*>(rawTargetObject);
|
||||
|
||||
for (AbstractNodeList::iterator i = objNode->children.begin(); i != objNode->children.end(); ++i)
|
||||
{
|
||||
if ((*i)->type == ANT_PROPERTY)
|
||||
{
|
||||
compiler->addError (
|
||||
ScriptCompiler::CE_INVALIDPARAMETERS,
|
||||
objNode->file, objNode->line,
|
||||
"cloud_system doesn't have any properties");
|
||||
}
|
||||
else if((*i)->type == ANT_OBJECT)
|
||||
{
|
||||
ObjectAbstractNode *childObjNode = reinterpret_cast<ObjectAbstractNode*>((*i).get());
|
||||
|
||||
/*
|
||||
LogManager::getSingleton ().logMessage ("CloudSystemScriptTranslator::translate child object"
|
||||
" value '" + childObjNode->getValue () + "'"
|
||||
" name '" + childObjNode->name + "'"
|
||||
" cls '" + childObjNode->cls + "'"
|
||||
" base '" + childObjNode->base + "'");
|
||||
*/
|
||||
|
||||
const Ogre::String& className = childObjNode->cls;
|
||||
|
||||
if (className == "cloud_layer") {
|
||||
// Don't allow names.
|
||||
#if OGRE_VERSION < 0x010700
|
||||
if (childObjNode->base.empty () == false) {
|
||||
#else
|
||||
if (childObjNode->bases.size () != 0) {
|
||||
#endif
|
||||
compiler->addError (
|
||||
ScriptCompiler::CE_FEWERPARAMETERSEXPECTED,
|
||||
childObjNode->file, childObjNode->line,
|
||||
"cloud_layer can't have a base");
|
||||
continue;
|
||||
}
|
||||
// Height here is irrelevant. It's silly to have it as a FlatCloudLayer ctor parameter.
|
||||
target->createLayerAtHeight (0);
|
||||
FlatCloudLayer* layer = target->getLayer (target->getLayerCount () - 1);
|
||||
|
||||
// Add the new layer as a context for the object node.
|
||||
// This will eventually pass to the TypeDescriptorScriptTranslator for a cloud layer.
|
||||
childObjNode->context = static_cast<void*>(layer);
|
||||
} else {
|
||||
LogManager::getSingleton ().logMessage ("CloudSystemScriptTranslator::translate "
|
||||
"unknown child object class '" + className + "'");
|
||||
}
|
||||
processNode (compiler, *i);
|
||||
}
|
||||
}
|
||||
|
||||
//LogManager::getSingleton ().logMessage ("CloudSystemScriptTranslator::translate END");
|
||||
}
|
||||
|
||||
CaelumScriptTranslatorManager::CaelumScriptTranslatorManager
|
||||
(
|
||||
CaelumDefaultTypeDescriptorData* typeData
|
||||
):
|
||||
mCaelumSystemTranslator(),
|
||||
mCloudSystemTranslator(),
|
||||
mFlatCloudLayerTranslator(typeData->FlatCloudLayerTypeDescriptor),
|
||||
mSunTranslator(typeData->BaseSkyLightTypeDescriptor),
|
||||
mMoonTranslator(typeData->BaseSkyLightTypeDescriptor),
|
||||
mPointStarfieldTranslator(typeData->PointStarfieldTypeDescriptor),
|
||||
mGroundFogTranslator(typeData->GroundFogTypeDescriptor),
|
||||
mDepthComposerTranslator(typeData->DepthComposerTypeDescriptor),
|
||||
mPrecipitationTranslator(typeData->PrecipitationTypeDescriptor),
|
||||
mSkyDomeTranslator(typeData->SkyDomeTypeDescriptor)
|
||||
{
|
||||
mCaelumSystemTranslator.setTypeDescriptor(typeData->CaelumSystemTypeDescriptor);
|
||||
|
||||
// Build translator map to member translators.
|
||||
mTranslatorMap.insert (std::make_pair ("caelum_sky_system", &mCaelumSystemTranslator));
|
||||
mTranslatorMap.insert (std::make_pair ("cloud_system", &mCloudSystemTranslator));
|
||||
mTranslatorMap.insert (std::make_pair ("cloud_layer", &mFlatCloudLayerTranslator));
|
||||
mTranslatorMap.insert (std::make_pair ("sun", &mSunTranslator));
|
||||
mTranslatorMap.insert (std::make_pair ("moon", &mMoonTranslator));
|
||||
mTranslatorMap.insert (std::make_pair ("point_starfield", &mPointStarfieldTranslator));
|
||||
mTranslatorMap.insert (std::make_pair ("ground_fog", &mGroundFogTranslator));
|
||||
mTranslatorMap.insert (std::make_pair ("depth_composer", &mDepthComposerTranslator));
|
||||
mTranslatorMap.insert (std::make_pair ("precipitation", &mPrecipitationTranslator));
|
||||
mTranslatorMap.insert (std::make_pair ("sky_dome", &mSkyDomeTranslator));
|
||||
}
|
||||
|
||||
size_t CaelumScriptTranslatorManager::getNumTranslators () const {
|
||||
// Turns out this is never called.
|
||||
assert(0 && "This method should be removed from Ogre::ScriptTranslatorManager");
|
||||
return mTranslatorMap.size ();
|
||||
}
|
||||
|
||||
void CaelumScriptTranslatorManager::_setPropScriptResourceManager (PropScriptResourceManager* mgr)
|
||||
{
|
||||
mCaelumSystemTranslator.setResourceManager (mgr);
|
||||
}
|
||||
|
||||
ScriptTranslator* CaelumScriptTranslatorManager::getTranslator (const AbstractNodePtr& node)
|
||||
{
|
||||
//LogManager::getSingleton ().logMessage ("CaelumScriptTranslatorManager::getTranslator");
|
||||
if (node->type == ANT_ATOM) {
|
||||
//ObjectAbstractNode* atomNode = reinterpret_cast<ObjectAbstractNode*>(node.get());
|
||||
//LogManager::getSingleton ().logMessage ("CaelumScriptTranslatorManager::getTranslator atom node " + atomNode->getValue ());
|
||||
} else if (node->type == ANT_OBJECT) {
|
||||
ObjectAbstractNode* objNode = reinterpret_cast<ObjectAbstractNode*>(node.get());
|
||||
//LogManager::getSingleton ().logMessage ("CaelumScriptTranslatorManager::getTranslator object node " + objNode->getValue ());
|
||||
|
||||
// Pass down the context.
|
||||
ScriptTranslatorMap::const_iterator it = mTranslatorMap.find(objNode->cls);
|
||||
if (it != mTranslatorMap.end()) {
|
||||
return it->second;
|
||||
}
|
||||
}
|
||||
|
||||
// Not found in this manager.
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
|
||||
#endif // CAELUM_SCRIPT_SUPPORT
|
||||
@ -1,760 +0,0 @@
|
||||
/*
|
||||
This file is part of Caelum.
|
||||
See http://www.ogre3d.org/wiki/index.php/Caelum
|
||||
|
||||
Copyright (c) 2006-2008 Caelum team. See Contributors.txt for details.
|
||||
|
||||
Caelum is free software: you can redistribute it and/or modify
|
||||
it under the terms of the GNU Lesser General Public License as published
|
||||
by the Free Software Foundation, either version 3 of the License, or
|
||||
(at your option) any later version.
|
||||
|
||||
Caelum is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
GNU Lesser General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU Lesser General Public License
|
||||
along with Caelum. If not, see <http://www.gnu.org/licenses/>.
|
||||
*/
|
||||
|
||||
#include "CaelumPrecompiled.h"
|
||||
#include "CaelumSystem.h"
|
||||
#include "CaelumExceptions.h"
|
||||
#include "InternalUtilities.h"
|
||||
#include "Astronomy.h"
|
||||
#include "CaelumPlugin.h"
|
||||
#include "FlatCloudLayer.h"
|
||||
|
||||
using namespace Ogre;
|
||||
|
||||
namespace Caelum
|
||||
{
|
||||
const String CaelumSystem::DEFAULT_SKY_GRADIENTS_IMAGE = "EarthClearSky2.png";
|
||||
const String CaelumSystem::DEFAULT_SUN_COLOURS_IMAGE = "SunGradient.png";
|
||||
|
||||
CaelumSystem::CaelumSystem
|
||||
(
|
||||
Ogre::Root *root,
|
||||
Ogre::SceneManager *sceneMgr,
|
||||
CaelumComponent componentsToCreate/* = CAELUM_COMPONENTS_DEFAULT*/
|
||||
):
|
||||
mOgreRoot (root),
|
||||
mSceneMgr (sceneMgr),
|
||||
mCleanup (false)
|
||||
{
|
||||
LogManager::getSingleton().logMessage ("Caelum: Initialising Caelum system...");
|
||||
//LogManager::getSingleton().logMessage ("Caelum: CaelumSystem* at d" +
|
||||
// StringConverter::toString (reinterpret_cast<uint>(this)));
|
||||
|
||||
Ogre::String uniqueId = Ogre::StringConverter::toString ((size_t)this);
|
||||
if (!CaelumPlugin::getSingletonPtr ()) {
|
||||
LogManager::getSingleton().logMessage ("Caelum: Plugin not installed; installing now.");
|
||||
new CaelumPlugin ();
|
||||
CaelumPlugin::getSingletonPtr ()->install ();
|
||||
CaelumPlugin::getSingletonPtr ()->initialise ();
|
||||
}
|
||||
|
||||
mCaelumCameraNode.reset(mSceneMgr->getRootSceneNode ()->createChildSceneNode ("Caelum/CameraNode/" + uniqueId));
|
||||
mCaelumGroundNode.reset(mSceneMgr->getRootSceneNode ()->createChildSceneNode ("Caelum/GroundNode/" + uniqueId));
|
||||
mUniversalClock.reset(new UniversalClock ());
|
||||
|
||||
// If the "Caelum" resource group does not exist; create it.
|
||||
// This resource group is never released; which may be bad.
|
||||
// What does ogre do for it's own runtime resources?
|
||||
Ogre::StringVector groups = ResourceGroupManager::getSingleton ().getResourceGroups ();
|
||||
if (std::find (groups.begin(), groups.end(), Caelum::RESOURCE_GROUP_NAME) == groups.end()) {
|
||||
LogManager::getSingleton ().logMessage (
|
||||
"Caelum: Creating required internal resource group \'" + RESOURCE_GROUP_NAME + "\'");
|
||||
ResourceGroupManager::getSingleton ().createResourceGroup (Caelum::RESOURCE_GROUP_NAME);
|
||||
}
|
||||
|
||||
// Autoconfigure. Calls clear first to set defaults.
|
||||
autoConfigure (componentsToCreate);
|
||||
}
|
||||
|
||||
void CaelumSystem::destroySubcomponents (bool destroyEverything)
|
||||
{
|
||||
// Destroy sub-components
|
||||
setSkyDome (0);
|
||||
setSun (0);
|
||||
setImageStarfield (0);
|
||||
setPointStarfield (0);
|
||||
setCloudSystem (0);
|
||||
setPrecipitationController (0);
|
||||
setDepthComposer (0);
|
||||
setGroundFog (0);
|
||||
setMoon (0);
|
||||
mSkyGradientsImage.reset ();
|
||||
mSunColoursImage.reset ();
|
||||
|
||||
// These things can't be rebuilt.
|
||||
if (destroyEverything) {
|
||||
LogManager::getSingleton ().logMessage("Caelum: Delete UniversalClock");
|
||||
mUniversalClock.reset ();
|
||||
mCaelumCameraNode.reset ();
|
||||
mCaelumGroundNode.reset ();
|
||||
}
|
||||
}
|
||||
|
||||
CaelumSystem::~CaelumSystem () {
|
||||
destroySubcomponents (true);
|
||||
LogManager::getSingleton ().logMessage ("Caelum: CaelumSystem destroyed.");
|
||||
}
|
||||
|
||||
void CaelumSystem::clear()
|
||||
{
|
||||
// Destroy all subcomponents first.
|
||||
destroySubcomponents (false);
|
||||
|
||||
// Some "magical" behaviour.
|
||||
mAutoMoveCameraNode = true;
|
||||
mAutoNotifyCameraChanged = true;
|
||||
mAutoAttachViewportsToComponents = true;
|
||||
mAutoViewportBackground = true;
|
||||
|
||||
// Default lookups.
|
||||
setSkyGradientsImage(DEFAULT_SKY_GRADIENTS_IMAGE);
|
||||
setSunColoursImage(DEFAULT_SUN_COLOURS_IMAGE);
|
||||
|
||||
// Fog defaults.
|
||||
setManageSceneFog (true);
|
||||
mGlobalFogDensityMultiplier = 1;
|
||||
mGlobalFogColourMultiplier = Ogre::ColourValue(1.0, 1.0, 1.0, 1.0);
|
||||
mSceneFogDensityMultiplier = 1;
|
||||
mSceneFogColourMultiplier = Ogre::ColourValue(0.7, 0.7, 0.7, 0.7);
|
||||
mGroundFogDensityMultiplier = 1;
|
||||
mGroundFogColourMultiplier = Ogre::ColourValue(1.0, 1.0, 1.0, 1.0);
|
||||
|
||||
// Ambient lighting.
|
||||
setManageAmbientLight (true);
|
||||
setMinimumAmbientLight (Ogre::ColourValue (0.1, 0.1, 0.3));
|
||||
mEnsureSingleLightSource = false;
|
||||
mEnsureSingleShadowSource = false;
|
||||
|
||||
// Observer time & position. J2000 is midday.
|
||||
mObserverLatitude = Ogre::Degree(45);
|
||||
mObserverLongitude = Ogre::Degree(0);
|
||||
mUniversalClock->setJulianDay (Astronomy::J2000);
|
||||
}
|
||||
|
||||
void CaelumSystem::autoConfigure
|
||||
(
|
||||
CaelumComponent componentsToCreate/* = CAELUM_COMPONENTS_DEFAULT*/
|
||||
)
|
||||
{
|
||||
// Clear everything; revert to default.
|
||||
clear();
|
||||
|
||||
if (componentsToCreate == 0) {
|
||||
// Nothing to do. Don't print junk if not creating anything.
|
||||
return;
|
||||
}
|
||||
LogManager::getSingleton ().logMessage ("Caelum: Creating caelum sub-components.");
|
||||
|
||||
// Init skydome
|
||||
if (componentsToCreate & CAELUM_COMPONENT_SKY_DOME) {
|
||||
try {
|
||||
this->setSkyDome (new SkyDome (mSceneMgr, getCaelumCameraNode ()));
|
||||
} catch (Caelum::UnsupportedException& ex) {
|
||||
LogManager::getSingleton ().logMessage (
|
||||
"Caelum: Failed to initialize skydome: " + ex.getFullDescription());
|
||||
}
|
||||
}
|
||||
|
||||
// Init sun
|
||||
if (componentsToCreate & CAELUM_COMPONENT_SUN) {
|
||||
try {
|
||||
this->setSun (new SpriteSun (mSceneMgr, getCaelumCameraNode ()));
|
||||
this->getSun ()->setAmbientMultiplier (Ogre::ColourValue (0.5, 0.5, 0.5));
|
||||
this->getSun ()->setDiffuseMultiplier (Ogre::ColourValue (3, 3, 2.7));
|
||||
this->getSun ()->setSpecularMultiplier (Ogre::ColourValue (5, 5, 5));
|
||||
|
||||
this->getSun ()->setAutoDisable (true);
|
||||
this->getSun ()->setAutoDisableThreshold (0.05);
|
||||
} catch (Caelum::UnsupportedException& ex) {
|
||||
LogManager::getSingleton ().logMessage (
|
||||
"Caelum: Failed to initialize sun: " + ex.getFullDescription());
|
||||
}
|
||||
}
|
||||
|
||||
// Init moon
|
||||
if (componentsToCreate & CAELUM_COMPONENT_MOON) {
|
||||
try {
|
||||
this->setMoon (new Moon (mSceneMgr, getCaelumCameraNode ()));
|
||||
this->getMoon ()->setAutoDisable (true);
|
||||
this->getMoon ()->setAutoDisableThreshold (0.05);
|
||||
} catch (Caelum::UnsupportedException& ex) {
|
||||
LogManager::getSingleton ().logMessage (
|
||||
"Caelum: Failed to initialize moon: " + ex.getFullDescription());
|
||||
}
|
||||
}
|
||||
if (componentsToCreate & CAELUM_COMPONENT_IMAGE_STARFIELD) {
|
||||
try {
|
||||
this->setImageStarfield (new ImageStarfield (mSceneMgr, getCaelumCameraNode ()));
|
||||
} catch (Caelum::UnsupportedException& ex) {
|
||||
LogManager::getSingleton ().logMessage (
|
||||
"Caelum: Failed to initialize the old image starfield: " + ex.getFullDescription());
|
||||
}
|
||||
}
|
||||
if (componentsToCreate & CAELUM_COMPONENT_POINT_STARFIELD) {
|
||||
try {
|
||||
this->setPointStarfield (new PointStarfield (mSceneMgr, getCaelumCameraNode ()));
|
||||
} catch (Caelum::UnsupportedException& ex) {
|
||||
LogManager::getSingleton ().logMessage (
|
||||
"Caelum: Failed to initialize starfield: " + ex.getFullDescription());
|
||||
}
|
||||
}
|
||||
if (componentsToCreate & CAELUM_COMPONENT_GROUND_FOG) {
|
||||
try {
|
||||
this->setGroundFog (new GroundFog (mSceneMgr, getCaelumCameraNode ()));
|
||||
} catch (Caelum::UnsupportedException& ex) {
|
||||
LogManager::getSingleton ().logMessage (
|
||||
"Caelum: Failed to initialize ground fog: " + ex.getFullDescription());
|
||||
}
|
||||
}
|
||||
if (componentsToCreate & CAELUM_COMPONENT_CLOUDS) {
|
||||
try {
|
||||
this->setCloudSystem (new CloudSystem (mSceneMgr, getCaelumGroundNode ()));
|
||||
getCloudSystem ()->createLayerAtHeight (3000);
|
||||
getCloudSystem ()->getLayer (0)->setCloudCover (0.3);
|
||||
} catch (Caelum::UnsupportedException& ex) {
|
||||
LogManager::getSingleton ().logMessage (
|
||||
"Caelum: Failed to initialize clouds: " + ex.getFullDescription());
|
||||
}
|
||||
}
|
||||
if (componentsToCreate & CAELUM_COMPONENT_PRECIPITATION) {
|
||||
try {
|
||||
this->setPrecipitationController (new PrecipitationController (mSceneMgr));
|
||||
} catch (Caelum::UnsupportedException& ex) {
|
||||
LogManager::getSingleton ().logMessage (
|
||||
"Caelum: Failed to initialize precipitation: " + ex.getFullDescription());
|
||||
}
|
||||
}
|
||||
if (componentsToCreate & CAELUM_COMPONENT_SCREEN_SPACE_FOG) {
|
||||
try {
|
||||
this->setDepthComposer (new DepthComposer (mSceneMgr));
|
||||
} catch (Caelum::UnsupportedException& ex) {
|
||||
LogManager::getSingleton ().logMessage (
|
||||
"Caelum: Failed to initialize precipitation: " + ex.getFullDescription());
|
||||
}
|
||||
}
|
||||
|
||||
LogManager::getSingleton ().logMessage ("Caelum: DONE initializing");
|
||||
}
|
||||
|
||||
void CaelumSystem::shutdown (const bool cleanup) {
|
||||
LogManager::getSingleton ().logMessage ("Caelum: Shutting down Caelum system...");
|
||||
|
||||
destroySubcomponents (true);
|
||||
|
||||
if (cleanup) {
|
||||
mOgreRoot->removeFrameListener (this);
|
||||
delete this;
|
||||
} else {
|
||||
// We'll delete later. Make sure we're registered as a frame listener, or we'd leak.
|
||||
mOgreRoot->addFrameListener(this);
|
||||
mCleanup = true;
|
||||
}
|
||||
}
|
||||
|
||||
void CaelumSystem::attachViewportImpl (Ogre::Viewport* vp)
|
||||
{
|
||||
LogManager::getSingleton().getDefaultLog ()->logMessage (
|
||||
"CaelumSystem: Attached to"
|
||||
" viewport " + StringConverter::toString ((long)vp) +
|
||||
" render target " + vp->getTarget ()->getName ());
|
||||
if (getAutoAttachViewportsToComponents ()) {
|
||||
if (getPrecipitationController ()) {
|
||||
getPrecipitationController ()->createViewportInstance (vp);
|
||||
}
|
||||
if (getDepthComposer ()) {
|
||||
getDepthComposer ()->createViewportInstance (vp);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void CaelumSystem::detachViewportImpl (Ogre::Viewport* vp)
|
||||
{
|
||||
LogManager::getSingleton().getDefaultLog ()->logMessage (
|
||||
"CaelumSystem: Detached from "
|
||||
" viewport " + StringConverter::toString ((long)vp) +
|
||||
" render target " + vp->getTarget ()->getName ());
|
||||
if (getAutoAttachViewportsToComponents ()) {
|
||||
if (getPrecipitationController ()) {
|
||||
getPrecipitationController ()->destroyViewportInstance (vp);
|
||||
}
|
||||
if (getDepthComposer ()) {
|
||||
getDepthComposer ()->destroyViewportInstance (vp);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void CaelumSystem::attachViewport (Ogre::Viewport* vp)
|
||||
{
|
||||
bool found = !mAttachedViewports.insert (vp).second;
|
||||
if (!found) {
|
||||
attachViewportImpl (vp);
|
||||
}
|
||||
}
|
||||
|
||||
void CaelumSystem::detachViewport (Ogre::Viewport* vp)
|
||||
{
|
||||
std::set<Viewport*>::size_type erase_result = mAttachedViewports.erase(vp);
|
||||
assert(erase_result == 0 || erase_result == 1);
|
||||
bool found = erase_result == 1;
|
||||
if (found) {
|
||||
detachViewportImpl (vp);
|
||||
}
|
||||
}
|
||||
|
||||
void CaelumSystem::detachAllViewports ()
|
||||
{
|
||||
std::set<Viewport*>::const_iterator it = mAttachedViewports.begin(), end = mAttachedViewports.end();
|
||||
for (; it != end; ++it) {
|
||||
detachViewportImpl (*it);
|
||||
}
|
||||
mAttachedViewports.clear();
|
||||
}
|
||||
|
||||
bool CaelumSystem::isViewportAttached (Ogre::Viewport* vp) const {
|
||||
return mAttachedViewports.find (vp) != mAttachedViewports.end();
|
||||
}
|
||||
|
||||
void CaelumSystem::setSkyDome (SkyDome *obj) {
|
||||
mSkyDome.reset (obj);
|
||||
}
|
||||
|
||||
void CaelumSystem::setSun (BaseSkyLight* obj) {
|
||||
mSun.reset (obj);
|
||||
}
|
||||
|
||||
void CaelumSystem::setMoon (Moon* obj) {
|
||||
mMoon.reset (obj);
|
||||
}
|
||||
|
||||
void CaelumSystem::setImageStarfield (ImageStarfield* obj) {
|
||||
mImageStarfield.reset (obj);
|
||||
}
|
||||
|
||||
void CaelumSystem::setPointStarfield (PointStarfield* obj) {
|
||||
mPointStarfield.reset (obj);
|
||||
}
|
||||
|
||||
void CaelumSystem::setGroundFog (GroundFog* obj) {
|
||||
mGroundFog.reset (obj);
|
||||
}
|
||||
|
||||
void CaelumSystem::setCloudSystem (CloudSystem* obj) {
|
||||
mCloudSystem.reset (obj);
|
||||
}
|
||||
|
||||
void CaelumSystem::setPrecipitationController (PrecipitationController* newptr) {
|
||||
PrecipitationController* oldptr = getPrecipitationController ();
|
||||
if (oldptr == newptr) {
|
||||
return;
|
||||
}
|
||||
// Detach old
|
||||
if (getAutoAttachViewportsToComponents() && oldptr) {
|
||||
std::for_each (mAttachedViewports.begin(), mAttachedViewports.end(),
|
||||
std::bind1st (std::mem_fun (&PrecipitationController::destroyViewportInstance), oldptr));
|
||||
}
|
||||
// Attach new.
|
||||
if (getAutoAttachViewportsToComponents() && newptr) {
|
||||
std::for_each (mAttachedViewports.begin(), mAttachedViewports.end(),
|
||||
std::bind1st (std::mem_fun (&PrecipitationController::createViewportInstance), newptr));
|
||||
}
|
||||
mPrecipitationController.reset(newptr);
|
||||
}
|
||||
|
||||
void CaelumSystem::setDepthComposer (DepthComposer* ptr) {
|
||||
mDepthComposer.reset(ptr);
|
||||
if (getAutoAttachViewportsToComponents() && getDepthComposer ()) {
|
||||
std::for_each (
|
||||
mAttachedViewports.begin(), mAttachedViewports.end(),
|
||||
std::bind1st (
|
||||
std::mem_fun (&DepthComposer::createViewportInstance),
|
||||
getDepthComposer ()));
|
||||
}
|
||||
}
|
||||
|
||||
void CaelumSystem::preViewportUpdate (const Ogre::RenderTargetViewportEvent &e) {
|
||||
Ogre::Viewport *viewport = e.source;
|
||||
Ogre::Camera *camera = viewport->getCamera ();
|
||||
|
||||
if (getAutoViewportBackground ()) {
|
||||
viewport->setBackgroundColour (Ogre::ColourValue::Black);
|
||||
}
|
||||
if (getAutoNotifyCameraChanged ()) {
|
||||
this->notifyCameraChanged (camera);
|
||||
}
|
||||
}
|
||||
|
||||
void CaelumSystem::notifyCameraChanged(Ogre::Camera* cam)
|
||||
{
|
||||
// Move camera node.
|
||||
if (getAutoMoveCameraNode ()) {
|
||||
mCaelumCameraNode->setPosition (cam->getDerivedPosition());
|
||||
mCaelumCameraNode->_update (true, true);
|
||||
}
|
||||
|
||||
if (getSkyDome ()) {
|
||||
getSkyDome ()->notifyCameraChanged (cam);
|
||||
}
|
||||
|
||||
if (getSun ()) {
|
||||
getSun ()->notifyCameraChanged (cam);
|
||||
}
|
||||
|
||||
if (getMoon ()) {
|
||||
getMoon ()->notifyCameraChanged (cam);
|
||||
}
|
||||
|
||||
if (getImageStarfield ()) {
|
||||
getImageStarfield ()->notifyCameraChanged (cam);
|
||||
}
|
||||
|
||||
if (getPointStarfield ()) {
|
||||
getPointStarfield ()->notifyCameraChanged (cam);
|
||||
}
|
||||
|
||||
if (getGroundFog ()) {
|
||||
getGroundFog ()->notifyCameraChanged (cam);
|
||||
}
|
||||
}
|
||||
|
||||
bool CaelumSystem::frameStarted (const Ogre::FrameEvent &e) {
|
||||
if (mCleanup) {
|
||||
// Delayed destruction.
|
||||
mOgreRoot->removeFrameListener (this);
|
||||
delete this;
|
||||
return true;
|
||||
}
|
||||
|
||||
updateSubcomponents(e.timeSinceLastFrame);
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
void CaelumSystem::updateSubcomponents (Real timeSinceLastFrame)
|
||||
{
|
||||
/*
|
||||
LogManager::getSingleton().getDefaultLog()->logMessage(
|
||||
"CaelumSystem::updateSubcomponents: " +
|
||||
StringConverter::toString (timeSinceLastFrame, 10));
|
||||
*/
|
||||
|
||||
mUniversalClock->update (timeSinceLastFrame);
|
||||
|
||||
// Timing variables
|
||||
LongReal julDay = mUniversalClock->getJulianDay ();
|
||||
LongReal relDayTime = fmod(julDay, 1);
|
||||
Real secondDiff = timeSinceLastFrame * mUniversalClock->getTimeScale ();
|
||||
|
||||
// Get astronomical parameters.
|
||||
Ogre::Vector3 sunDir = getSunDirection(julDay);
|
||||
Ogre::Vector3 moonDir = getMoonDirection(julDay);
|
||||
Real moonPhase = getMoonPhase(julDay);
|
||||
|
||||
// Get parameters from sky colour model.
|
||||
Real fogDensity = getFogDensity (relDayTime, sunDir);
|
||||
Ogre::ColourValue fogColour = getFogColour (relDayTime, sunDir);
|
||||
Ogre::ColourValue sunLightColour = getSunLightColour (relDayTime, sunDir);
|
||||
Ogre::ColourValue sunSphereColour = getSunSphereColour (relDayTime, sunDir);
|
||||
Ogre::ColourValue moonLightColour = getMoonLightColour (moonDir);
|
||||
Ogre::ColourValue moonBodyColour = getMoonBodyColour (moonDir);
|
||||
|
||||
fogDensity *= mGlobalFogDensityMultiplier;
|
||||
fogColour = fogColour * mGlobalFogColourMultiplier;
|
||||
|
||||
// Update image starfield
|
||||
if (getImageStarfield ()) {
|
||||
getImageStarfield ()->update (relDayTime);
|
||||
getImageStarfield ()->setInclination (-getObserverLatitude ());
|
||||
}
|
||||
|
||||
// Update point starfield
|
||||
if (getPointStarfield ()) {
|
||||
getPointStarfield ()->setObserverLatitude (getObserverLatitude ());
|
||||
getPointStarfield ()->setObserverLongitude (getObserverLongitude ());
|
||||
getPointStarfield ()->_update (relDayTime);
|
||||
}
|
||||
|
||||
// Update skydome.
|
||||
if (getSkyDome ()) {
|
||||
getSkyDome ()->setSunDirection (sunDir);
|
||||
getSkyDome ()->setHazeColour (fogColour * mSceneFogColourMultiplier);
|
||||
}
|
||||
|
||||
// Update scene fog.
|
||||
if (getManageSceneFog ()) {
|
||||
mSceneMgr->setFog (Ogre::FOG_EXP2,
|
||||
fogColour * mSceneFogColourMultiplier,
|
||||
fogDensity * mSceneFogDensityMultiplier);
|
||||
}
|
||||
|
||||
// Update ground fog.
|
||||
if (getGroundFog ()) {
|
||||
getGroundFog ()->setColour (fogColour * mGroundFogColourMultiplier);
|
||||
getGroundFog ()->setDensity (fogDensity * mGroundFogDensityMultiplier);
|
||||
}
|
||||
|
||||
// Update sun
|
||||
if (getSun ()) {
|
||||
mSun->update (sunDir, sunLightColour, sunSphereColour);
|
||||
}
|
||||
|
||||
// Update moon.
|
||||
if (getMoon ()) {
|
||||
mMoon->update (
|
||||
moonDir,
|
||||
moonLightColour,
|
||||
moonBodyColour);
|
||||
mMoon->setPhase (moonPhase);
|
||||
}
|
||||
|
||||
// Update clouds
|
||||
if (getCloudSystem ()) {
|
||||
getCloudSystem ()->update (
|
||||
secondDiff, sunDir, sunLightColour, fogColour, sunSphereColour);
|
||||
}
|
||||
|
||||
// Update precipitation
|
||||
if (getPrecipitationController ()) {
|
||||
getPrecipitationController ()->update (secondDiff, fogColour);
|
||||
}
|
||||
|
||||
// Update screen space fog
|
||||
if (getDepthComposer ()) {
|
||||
getDepthComposer ()->update ();
|
||||
getDepthComposer ()->setSunDirection (sunDir);
|
||||
getDepthComposer ()->setHazeColour (fogColour);
|
||||
getDepthComposer ()->setGroundFogColour (fogColour * mGroundFogColourMultiplier);
|
||||
getDepthComposer ()->setGroundFogDensity (fogDensity * mGroundFogDensityMultiplier);
|
||||
}
|
||||
|
||||
// Update ambient lighting.
|
||||
if (getManageAmbientLight ()) {
|
||||
Ogre::ColourValue ambient = Ogre::ColourValue::Black;
|
||||
if (getMoon ()) {
|
||||
ambient += getMoon ()->getLightColour () * getMoon ()->getAmbientMultiplier ();
|
||||
}
|
||||
if (getSun ()) {
|
||||
ambient += getSun ()->getLightColour () * getSun ()->getAmbientMultiplier ();
|
||||
}
|
||||
ambient.r = std::max(ambient.r, mMinimumAmbientLight.r);
|
||||
ambient.g = std::max(ambient.g, mMinimumAmbientLight.g);
|
||||
ambient.b = std::max(ambient.b, mMinimumAmbientLight.b);
|
||||
ambient.a = std::max(ambient.a, mMinimumAmbientLight.a);
|
||||
// Debug ambient factos (ick).
|
||||
/*
|
||||
LogManager::getSingleton().logMessage (
|
||||
"Sun is " + StringConverter::toString(sunLightColour) + "\n"
|
||||
"Moon is " + StringConverter::toString(moonLightColour) + "\n"
|
||||
"Ambient is " + StringConverter::toString(ambient) + "\n"
|
||||
);
|
||||
*/
|
||||
mSceneMgr->setAmbientLight (ambient);
|
||||
}
|
||||
|
||||
if (getSun() && getMoon ()) {
|
||||
Ogre::Real moonBrightness = moonLightColour.r + moonLightColour.g + moonLightColour.b + moonLightColour.a;
|
||||
Ogre::Real sunBrightness = sunLightColour.r + sunLightColour.g + sunLightColour.b + sunLightColour.a;
|
||||
bool sunBrighterThanMoon = (sunBrightness > moonBrightness);
|
||||
|
||||
if (getEnsureSingleLightSource ()) {
|
||||
getMoon ()->setForceDisable (sunBrighterThanMoon);
|
||||
getSun ()->setForceDisable (!sunBrighterThanMoon);
|
||||
}
|
||||
if (getEnsureSingleShadowSource ()) {
|
||||
getMoon ()->getMainLight ()->setCastShadows (!sunBrighterThanMoon);
|
||||
getSun ()->getMainLight ()->setCastShadows (sunBrighterThanMoon);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void CaelumSystem::setManageSceneFog (bool value) {
|
||||
mManageSceneFog = value;
|
||||
// Prevent having some stale values around.
|
||||
if (!value) {
|
||||
mSceneMgr->setFog (Ogre::FOG_NONE);
|
||||
}
|
||||
}
|
||||
|
||||
bool CaelumSystem::getManageSceneFog () const {
|
||||
return mManageSceneFog;
|
||||
}
|
||||
|
||||
void CaelumSystem::setSceneFogDensityMultiplier (Real value) {
|
||||
mSceneFogDensityMultiplier = value;
|
||||
}
|
||||
|
||||
Real CaelumSystem::getSceneFogDensityMultiplier () const {
|
||||
return mSceneFogDensityMultiplier;
|
||||
}
|
||||
|
||||
void CaelumSystem::setGroundFogDensityMultiplier (Real value) {
|
||||
mGroundFogDensityMultiplier = value;
|
||||
}
|
||||
|
||||
Real CaelumSystem::getGroundFogDensityMultiplier () const {
|
||||
return mGroundFogDensityMultiplier;
|
||||
}
|
||||
|
||||
void CaelumSystem::setGlobalFogDensityMultiplier (Real value) {
|
||||
mGlobalFogDensityMultiplier = value;
|
||||
}
|
||||
|
||||
Real CaelumSystem::getGlobalFogDensityMultiplier () const {
|
||||
return mGlobalFogDensityMultiplier;
|
||||
}
|
||||
|
||||
void CaelumSystem::setSkyGradientsImage (const Ogre::String &filename) {
|
||||
mSkyGradientsImage.reset(new Ogre::Image ());
|
||||
mSkyGradientsImage->load (filename, RESOURCE_GROUP_NAME);
|
||||
}
|
||||
|
||||
void CaelumSystem::setSunColoursImage (const Ogre::String &filename) {
|
||||
mSunColoursImage.reset(new Ogre::Image ());
|
||||
mSunColoursImage->load (filename, RESOURCE_GROUP_NAME);
|
||||
}
|
||||
|
||||
Ogre::ColourValue CaelumSystem::getFogColour (Real time, const Ogre::Vector3 &sunDir) {
|
||||
if (!mSkyGradientsImage.get()) {
|
||||
return Ogre::ColourValue::Black;
|
||||
}
|
||||
|
||||
Real elevation = sunDir.dotProduct (Ogre::Vector3::UNIT_Y) * 0.5 + 0.5;
|
||||
Ogre::ColourValue col = InternalUtilities::getInterpolatedColour (elevation, 1, mSkyGradientsImage.get(), false);
|
||||
return col;
|
||||
}
|
||||
|
||||
Real CaelumSystem::getFogDensity (Real time, const Ogre::Vector3 &sunDir)
|
||||
{
|
||||
if (!mSkyGradientsImage.get()) {
|
||||
return 0;
|
||||
}
|
||||
|
||||
Real elevation = sunDir.dotProduct (Ogre::Vector3::UNIT_Y) * 0.5 + 0.5;
|
||||
Ogre::ColourValue col = InternalUtilities::getInterpolatedColour (elevation, 1, mSkyGradientsImage.get(), false);
|
||||
return col.a;
|
||||
}
|
||||
|
||||
Ogre::ColourValue CaelumSystem::getSunSphereColour (Real time, const Ogre::Vector3 &sunDir)
|
||||
{
|
||||
if (!mSunColoursImage.get()) {
|
||||
return Ogre::ColourValue::White;
|
||||
}
|
||||
|
||||
Real elevation = sunDir.dotProduct (Ogre::Vector3::UNIT_Y);
|
||||
elevation = elevation * 2 + 0.4;
|
||||
return InternalUtilities::getInterpolatedColour (elevation, 1, mSunColoursImage.get(), false);
|
||||
}
|
||||
|
||||
Ogre::ColourValue CaelumSystem::getSunLightColour (Real time, const Ogre::Vector3 &sunDir)
|
||||
{
|
||||
if (!mSkyGradientsImage.get()) {
|
||||
exit(-1);
|
||||
return Ogre::ColourValue::White;
|
||||
}
|
||||
Real elevation = sunDir.dotProduct (Ogre::Vector3::UNIT_Y) * 0.5 + 0.5;
|
||||
|
||||
// Hack: return averaged sky colours.
|
||||
// Don't use an alpha value for lights, this can cause nasty problems.
|
||||
Ogre::ColourValue col = InternalUtilities::getInterpolatedColour (elevation, elevation, mSkyGradientsImage.get(), false);
|
||||
Real val = (col.r + col.g + col.b) / 3;
|
||||
col = Ogre::ColourValue(val, val, val, 1.0);
|
||||
assert(Ogre::Math::RealEqual(col.a, 1));
|
||||
return col;
|
||||
}
|
||||
|
||||
Ogre::ColourValue CaelumSystem::getMoonBodyColour (const Ogre::Vector3 &moonDir) {
|
||||
return Ogre::ColourValue::White;
|
||||
}
|
||||
|
||||
Ogre::ColourValue CaelumSystem::getMoonLightColour (const Ogre::Vector3 &moonDir)
|
||||
{
|
||||
if (!mSkyGradientsImage.get()) {
|
||||
return Ogre::ColourValue::Blue;
|
||||
}
|
||||
// Scaled version of getSunLightColor
|
||||
Real elevation = moonDir.dotProduct (Ogre::Vector3::UNIT_Y) * 0.5 + 0.5;
|
||||
Ogre::ColourValue col = InternalUtilities::getInterpolatedColour (elevation, elevation, mSkyGradientsImage.get(), false);
|
||||
Real val = (col.r + col.g + col.b) / 3;
|
||||
col = Ogre::ColourValue(val / 2.5f, val / 2.5f, val / 2.5f, 1.0);
|
||||
assert(Ogre::Math::RealEqual(col.a, 1));
|
||||
return col;
|
||||
}
|
||||
|
||||
const Ogre::Vector3 CaelumSystem::makeDirection (
|
||||
Ogre::Degree azimuth, Ogre::Degree altitude)
|
||||
{
|
||||
Ogre::Vector3 res;
|
||||
res.z = -Ogre::Math::Cos (azimuth) * Ogre::Math::Cos (altitude); // North
|
||||
res.x = Ogre::Math::Sin (azimuth) * Ogre::Math::Cos (altitude); // East
|
||||
res.y = -Ogre::Math::Sin (altitude); // Zenith
|
||||
return res;
|
||||
}
|
||||
|
||||
const Ogre::Vector3 CaelumSystem::getSunDirection (LongReal jday)
|
||||
{
|
||||
Ogre::Degree azimuth, altitude;
|
||||
{
|
||||
ScopedHighPrecissionFloatSwitch precissionSwitch;
|
||||
|
||||
Astronomy::getHorizontalSunPosition(jday,
|
||||
getObserverLongitude(), getObserverLatitude(),
|
||||
azimuth, altitude);
|
||||
}
|
||||
Ogre::Vector3 res = makeDirection(azimuth, altitude);
|
||||
|
||||
return res;
|
||||
}
|
||||
|
||||
const Ogre::Vector3 CaelumSystem::getMoonDirection (LongReal jday)
|
||||
{
|
||||
Ogre::Degree azimuth, altitude;
|
||||
{
|
||||
ScopedHighPrecissionFloatSwitch precissionSwitch;
|
||||
|
||||
Astronomy::getHorizontalMoonPosition(jday,
|
||||
getObserverLongitude (), getObserverLatitude (),
|
||||
azimuth, altitude);
|
||||
}
|
||||
Ogre::Vector3 res = makeDirection(azimuth, altitude);
|
||||
|
||||
return res;
|
||||
}
|
||||
|
||||
const Ogre::Real CaelumSystem::getMoonPhase (LongReal jday)
|
||||
{
|
||||
// Calculates julian days since January 22, 2008 13:36 (full moon)
|
||||
// and divides by the time between lunations (synodic month)
|
||||
LongReal T = (jday - 2454488.0665L) / 29.531026L;
|
||||
|
||||
T = fabs(fmod(T, 1));
|
||||
return -fabs(-4 * T + 2) + 2;
|
||||
}
|
||||
|
||||
void CaelumSystem::forceSubcomponentQueryFlags (uint flags)
|
||||
{
|
||||
if (getSkyDome ()) getSkyDome ()->setQueryFlags (flags);
|
||||
if (getSun ()) getSun ()->setQueryFlags (flags);
|
||||
if (getMoon ()) getMoon ()->setQueryFlags (flags);
|
||||
if (getImageStarfield ()) getImageStarfield ()->setQueryFlags (flags);
|
||||
if (getPointStarfield ()) getPointStarfield ()->setQueryFlags (flags);
|
||||
if (getGroundFog ()) getGroundFog ()->setQueryFlags (flags);
|
||||
if (getCloudSystem ()) getCloudSystem ()->forceLayerQueryFlags (flags);
|
||||
}
|
||||
|
||||
void CaelumSystem::forceSubcomponentVisibilityFlags (uint flags)
|
||||
{
|
||||
if (getSkyDome ()) getSkyDome ()->setVisibilityFlags (flags);
|
||||
if (getSun ()) getSun ()->setVisibilityFlags (flags);
|
||||
if (getMoon ()) getMoon ()->setVisibilityFlags (flags);
|
||||
if (getImageStarfield ()) getImageStarfield ()->setVisibilityFlags (flags);
|
||||
if (getPointStarfield ()) getPointStarfield ()->setVisibilityFlags (flags);
|
||||
if (getGroundFog ()) getGroundFog ()->setVisibilityFlags (flags);
|
||||
if (getCloudSystem ()) getCloudSystem ()->forceLayerVisibilityFlags (flags);
|
||||
}
|
||||
}
|
||||
@ -1,66 +0,0 @@
|
||||
/*
|
||||
This file is part of Caelum.
|
||||
See http://www.ogre3d.org/wiki/index.php/Caelum
|
||||
|
||||
Copyright (c) 2006-2008 Caelum team. See Contributors.txt for details.
|
||||
|
||||
Caelum is free software: you can redistribute it and/or modify
|
||||
it under the terms of the GNU Lesser General Public License as published
|
||||
by the Free Software Foundation, either version 3 of the License, or
|
||||
(at your option) any later version.
|
||||
|
||||
Caelum is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
GNU Lesser General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU Lesser General Public License
|
||||
along with Caelum. If not, see <http://www.gnu.org/licenses/>.
|
||||
*/
|
||||
|
||||
#include "CaelumPrecompiled.h"
|
||||
#include "CameraBoundElement.h"
|
||||
|
||||
namespace Caelum
|
||||
{
|
||||
const Ogre::Real CameraBoundElement::CAMERA_NEAR_DISTANCE_MULTIPLIER = 10;
|
||||
|
||||
CameraBoundElement::CameraBoundElement():
|
||||
mAutoRadius(true)
|
||||
{
|
||||
}
|
||||
|
||||
CameraBoundElement::~CameraBoundElement()
|
||||
{
|
||||
}
|
||||
|
||||
void CameraBoundElement::notifyCameraChanged (Ogre::Camera *cam) {
|
||||
if (mAutoRadius) {
|
||||
if (cam->getFarClipDistance () > 0) {
|
||||
setFarRadius((cam->getFarClipDistance () + cam->getNearClipDistance ()) / 2);
|
||||
} else {
|
||||
setFarRadius(cam->getNearClipDistance () * CAMERA_NEAR_DISTANCE_MULTIPLIER);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void CameraBoundElement::forceFarRadius (Ogre::Real radius) {
|
||||
if (radius > 0) {
|
||||
mAutoRadius = false;
|
||||
setFarRadius(radius);
|
||||
} else {
|
||||
mAutoRadius = true;
|
||||
}
|
||||
}
|
||||
|
||||
bool CameraBoundElement::getAutoRadius () const {
|
||||
return mAutoRadius;
|
||||
}
|
||||
|
||||
void CameraBoundElement::setAutoRadius () {
|
||||
forceFarRadius (-1);
|
||||
}
|
||||
|
||||
void CameraBoundElement::setFarRadius(Ogre::Real radius) {
|
||||
}
|
||||
}
|
||||
@ -1,95 +0,0 @@
|
||||
/*
|
||||
This file is part of Caelum.
|
||||
See http://www.ogre3d.org/wiki/index.php/Caelum
|
||||
|
||||
Copyright (c) 2008 Caelum team. See Contributors.txt for details.
|
||||
|
||||
Caelum is free software: you can redistribute it and/or modify
|
||||
it under the terms of the GNU Lesser General Public License as published
|
||||
by the Free Software Foundation, either version 3 of the License, or
|
||||
(at your option) any later version.
|
||||
|
||||
Caelum is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
GNU Lesser General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU Lesser General Public License
|
||||
along with Caelum. If not, see <http://www.gnu.org/licenses/>.
|
||||
*/
|
||||
|
||||
#include "CaelumPrecompiled.h"
|
||||
#include "CloudSystem.h"
|
||||
#include "FlatCloudLayer.h"
|
||||
|
||||
using namespace Ogre;
|
||||
|
||||
namespace Caelum
|
||||
{
|
||||
CloudSystem::CloudSystem(
|
||||
Ogre::SceneManager *sceneMgr,
|
||||
Ogre::SceneNode *cloudRoot)
|
||||
{
|
||||
mSceneMgr = sceneMgr;
|
||||
mCloudRoot = cloudRoot;
|
||||
}
|
||||
|
||||
FlatCloudLayer* CloudSystem::createLayerAtHeight(Ogre::Real height)
|
||||
{
|
||||
FlatCloudLayer* layer = this->createLayer ();
|
||||
layer->setHeight(height);
|
||||
return layer;
|
||||
}
|
||||
|
||||
FlatCloudLayer* CloudSystem::createLayer()
|
||||
{
|
||||
std::auto_ptr<FlatCloudLayer> layer(new FlatCloudLayer(mSceneMgr, mCloudRoot));
|
||||
mLayers.push_back(layer.get());
|
||||
return layer.release();
|
||||
}
|
||||
|
||||
void CloudSystem::addLayer(FlatCloudLayer* layer)
|
||||
{
|
||||
assert(layer != NULL);
|
||||
mLayers.push_back(layer);
|
||||
}
|
||||
|
||||
void CloudSystem::clearLayers()
|
||||
{
|
||||
for (unsigned i = 0; i < mLayers.size(); i++)
|
||||
{
|
||||
delete mLayers[i];
|
||||
mLayers[i] = 0;
|
||||
}
|
||||
}
|
||||
|
||||
CloudSystem::~CloudSystem()
|
||||
{
|
||||
clearLayers ();
|
||||
}
|
||||
|
||||
void CloudSystem::update(
|
||||
Ogre::Real timePassed,
|
||||
const Ogre::Vector3 &sunDirection,
|
||||
const Ogre::ColourValue &sunLightColour,
|
||||
const Ogre::ColourValue &fogColour,
|
||||
const Ogre::ColourValue &sunSphereColour)
|
||||
{
|
||||
for (uint i = 0; i < mLayers.size(); i++) {
|
||||
assert(mLayers[i] != NULL);
|
||||
mLayers[i]->update(timePassed, sunDirection, sunLightColour, fogColour, sunSphereColour);
|
||||
}
|
||||
}
|
||||
|
||||
void CloudSystem::forceLayerQueryFlags (uint flags) {
|
||||
for (uint i = 0; i < mLayers.size(); i++) {
|
||||
mLayers[i]->setQueryFlags (flags);
|
||||
}
|
||||
}
|
||||
|
||||
void CloudSystem::forceLayerVisibilityFlags (uint flags) {
|
||||
for (uint i = 0; i < mLayers.size(); i++) {
|
||||
mLayers[i]->setVisibilityFlags (flags);
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -1,491 +0,0 @@
|
||||
/*
|
||||
This file is part of Caelum.
|
||||
See http://www.ogre3d.org/wiki/index.php/Caelum
|
||||
|
||||
Copyright (c) 2008 Caelum team. See Contributors.txt for details.
|
||||
|
||||
Caelum is free software: you can redistribute it and/or modify
|
||||
it under the terms of the GNU Lesser General Public License as published
|
||||
by the Free Software Foundation, either version 3 of the License, or
|
||||
(at your option) any later version.
|
||||
|
||||
Caelum is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
GNU Lesser General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU Lesser General Public License
|
||||
along with Caelum. If not, see <http://www.gnu.org/licenses/>.
|
||||
*/
|
||||
|
||||
#include "CaelumPrecompiled.h"
|
||||
#include "CaelumExceptions.h"
|
||||
#include "DepthComposer.h"
|
||||
|
||||
using namespace Ogre;
|
||||
|
||||
namespace Caelum
|
||||
{
|
||||
DepthComposer::DepthComposer
|
||||
(
|
||||
Ogre::SceneManager *sceneMgr
|
||||
):
|
||||
mSceneMgr (sceneMgr),
|
||||
mDebugDepthRender (false),
|
||||
mSkyDomeHazeEnabled (false),
|
||||
mGroundFogEnabled (false),
|
||||
mGroundFogDensity (0.1),
|
||||
mGroundFogBaseLevel (5),
|
||||
mGroundFogVerticalDecay (0.2),
|
||||
mGroundFogColour (ColourValue::Black)
|
||||
{
|
||||
}
|
||||
|
||||
DepthComposer::~DepthComposer()
|
||||
{
|
||||
destroyAllViewportInstances();
|
||||
}
|
||||
|
||||
void DepthComposer::setDebugDepthRender (bool value)
|
||||
{
|
||||
if (mDebugDepthRender == value) {
|
||||
return;
|
||||
}
|
||||
mDebugDepthRender = value;
|
||||
onCompositorMaterialChanged ();
|
||||
}
|
||||
|
||||
void DepthComposer::setSkyDomeHazeEnabled (bool value)
|
||||
{
|
||||
if (mSkyDomeHazeEnabled == value) {
|
||||
return;
|
||||
}
|
||||
mSkyDomeHazeEnabled = value;
|
||||
onCompositorMaterialChanged ();
|
||||
}
|
||||
|
||||
void DepthComposer::setGroundFogEnabled (bool value)
|
||||
{
|
||||
if (mGroundFogEnabled == value) {
|
||||
return;
|
||||
}
|
||||
mGroundFogEnabled = value;
|
||||
onCompositorMaterialChanged ();
|
||||
}
|
||||
|
||||
const String& DepthComposer::getCompositorName ()
|
||||
{
|
||||
// Constant Ogre::Strings for names.
|
||||
static const Ogre::String CompositorName_DebugDepthRender =
|
||||
"Caelum/DepthComposer_DebugDepthRender";
|
||||
static const Ogre::String CompositorName_Dummy =
|
||||
"Caelum/DepthComposer_Dummy";
|
||||
static const Ogre::String CompositorName_ExpGroundFog =
|
||||
"Caelum/DepthComposer_ExpGroundFog";
|
||||
static const Ogre::String CompositorName_SkyDomeHaze =
|
||||
"Caelum/DepthComposer_SkyDomeHaze";
|
||||
static const Ogre::String CompositorName_SkyDomeHaze_ExpGroundFog =
|
||||
"Caelum/DepthComposer_SkyDomeHaze_ExpGroundFog";
|
||||
|
||||
// Should probably build materials and compositors by hand.
|
||||
if (mDebugDepthRender) {
|
||||
return CompositorName_DebugDepthRender;
|
||||
} else if (mSkyDomeHazeEnabled == false && mGroundFogEnabled == false) {
|
||||
return CompositorName_Dummy;
|
||||
} else if (mSkyDomeHazeEnabled == false && mGroundFogEnabled == true) {
|
||||
return CompositorName_ExpGroundFog;
|
||||
} else if (mSkyDomeHazeEnabled == true && mGroundFogEnabled == false) {
|
||||
return CompositorName_SkyDomeHaze;
|
||||
} else if (mSkyDomeHazeEnabled == true && mGroundFogEnabled == true) {
|
||||
return CompositorName_SkyDomeHaze_ExpGroundFog;
|
||||
} else {
|
||||
assert (0);
|
||||
return CompositorName_Dummy;
|
||||
}
|
||||
}
|
||||
|
||||
void DepthComposer::onCompositorMaterialChanged ()
|
||||
{
|
||||
ViewportInstanceMap::const_iterator it;
|
||||
ViewportInstanceMap::const_iterator begin = mViewportInstanceMap.begin();
|
||||
ViewportInstanceMap::const_iterator end = mViewportInstanceMap.end();
|
||||
for (it = begin; it != end; ++it) {
|
||||
it->second->removeCompositor ();
|
||||
it->second->addCompositor ();
|
||||
}
|
||||
}
|
||||
|
||||
void DepthComposer::update ()
|
||||
{
|
||||
ViewportInstanceMap::const_iterator it;
|
||||
ViewportInstanceMap::const_iterator begin = mViewportInstanceMap.begin();
|
||||
ViewportInstanceMap::const_iterator end = mViewportInstanceMap.end();
|
||||
for (it = begin; it != end; ++it) {
|
||||
assert(it->first == it->second->getViewport());
|
||||
it->second->_update ();
|
||||
}
|
||||
}
|
||||
|
||||
DepthComposerInstance::DepthComposerInstance
|
||||
(
|
||||
DepthComposer* parent,
|
||||
Ogre::Viewport* viewport
|
||||
):
|
||||
mParent(parent),
|
||||
mViewport(viewport),
|
||||
mCompInst(0)
|
||||
{
|
||||
LogManager::getSingleton().logMessage (
|
||||
"Caelum::DepthComposer: Attaching screen-space fog instance"
|
||||
" to viewport \'" + StringConverter::toString ((long)getViewport ()) + "\'"
|
||||
" of render target \'" + getViewport()->getTarget ()->getName () + "\'");
|
||||
|
||||
addCompositor ();
|
||||
mDepthRenderer.reset (new DepthRenderer (getViewport ()));
|
||||
}
|
||||
|
||||
DepthComposerInstance::~DepthComposerInstance()
|
||||
{
|
||||
removeCompositor ();
|
||||
mDepthRenderer.reset ();
|
||||
|
||||
LogManager::getSingleton().logMessage (
|
||||
"Caelum::DepthComposer: Detached screen-space fog instance"
|
||||
" from viewport \'" + StringConverter::toString ((long)getViewport ()) + "\'"
|
||||
" of render target \'" + getViewport()->getTarget ()->getName () + "\'");
|
||||
}
|
||||
|
||||
void DepthComposerInstance::addCompositor ()
|
||||
{
|
||||
CompositorManager* compMgr = CompositorManager::getSingletonPtr();
|
||||
|
||||
const String& compositorName = getParent ()->getCompositorName ();
|
||||
mCompInst = compMgr->addCompositor(mViewport, compositorName);
|
||||
if (!mCompInst) {
|
||||
CAELUM_THROW_UNSUPPORTED_EXCEPTION (
|
||||
"Can't add \'" + compositorName + "\' compositor.",
|
||||
"DepthComposer");
|
||||
}
|
||||
assert(mCompInst);
|
||||
mCompInst->setEnabled (true);
|
||||
mCompInst->addListener (this);
|
||||
}
|
||||
|
||||
void DepthComposerInstance::removeCompositor ()
|
||||
{
|
||||
CompositorManager* compMgr = CompositorManager::getSingletonPtr();
|
||||
compMgr->removeCompositor (mViewport, mCompInst->getCompositor ()->getName ());
|
||||
mCompInst = 0;
|
||||
}
|
||||
|
||||
void DepthComposerInstance::notifyMaterialSetup(uint pass_id, Ogre::MaterialPtr &mat)
|
||||
{
|
||||
//LogManager::getSingleton ().logMessage (
|
||||
// "Caelum::DepthComposer: Material setup");
|
||||
|
||||
Pass* pass = mat->getBestTechnique ()->getPass (0);
|
||||
|
||||
TextureUnitState *depthTus = pass->getTextureUnitState(1);
|
||||
if (depthTus->getTextureName () != mDepthRenderer->getDepthRenderTexture ()->getName()) {
|
||||
depthTus->setTextureName (mDepthRenderer->getDepthRenderTexture ()->getName ());
|
||||
LogManager::getSingleton ().logMessage (
|
||||
"Caelum::DepthComposer: Assigned depth texture in compositor material");
|
||||
}
|
||||
|
||||
mParams.setup(pass->getFragmentProgramParameters ());
|
||||
}
|
||||
|
||||
void DepthComposerInstance::Params::setup(Ogre::GpuProgramParametersSharedPtr fpParams)
|
||||
{
|
||||
this->fpParams = fpParams;
|
||||
invViewProjMatrix.bind(fpParams, "invViewProjMatrix");
|
||||
worldCameraPos.bind(fpParams, "worldCameraPos");
|
||||
groundFogDensity.bind(fpParams, "groundFogDensity");
|
||||
groundFogVerticalDecay.bind(fpParams, "groundFogVerticalDecay");
|
||||
groundFogBaseLevel.bind(fpParams, "groundFogBaseLevel");
|
||||
groundFogColour.bind(fpParams, "groundFogColour");
|
||||
sunDirection.bind(fpParams, "sunDirection");
|
||||
hazeColour.bind(fpParams, "hazeColour");
|
||||
}
|
||||
|
||||
void DepthComposerInstance::notifyMaterialRender(uint pass_id, Ogre::MaterialPtr &mat)
|
||||
{
|
||||
Camera* camera = getViewport ()->getCamera ();
|
||||
|
||||
assert(mParams.fpParams == mat->getBestTechnique ()->getPass (0)->getFragmentProgramParameters ());
|
||||
|
||||
// Auto param in a compositor does not use the external camera.
|
||||
// This means that sending matrices as auto_param will not work as expected.
|
||||
// Do it manually instead.
|
||||
Matrix4 projMatrix = camera->getProjectionMatrixWithRSDepth();
|
||||
Matrix4 viewMatrix = camera->getViewMatrix();
|
||||
|
||||
mParams.invViewProjMatrix.set(mParams.fpParams, (projMatrix * viewMatrix).inverse());
|
||||
|
||||
mParams.worldCameraPos.set(mParams.fpParams, camera->getDerivedPosition ());
|
||||
|
||||
mParams.groundFogDensity.set(mParams.fpParams, getParent ()->getGroundFogDensity ());
|
||||
mParams.groundFogVerticalDecay.set(mParams.fpParams, getParent ()->getGroundFogVerticalDecay ());
|
||||
mParams.groundFogBaseLevel.set(mParams.fpParams, getParent ()->getGroundFogBaseLevel ());
|
||||
mParams.groundFogColour.set(mParams.fpParams, getParent ()->getGroundFogColour ());
|
||||
|
||||
mParams.sunDirection.set(mParams.fpParams, getParent ()->getSunDirection ());
|
||||
mParams.hazeColour.set(mParams.fpParams, getParent ()->getHazeColour ());
|
||||
}
|
||||
|
||||
void DepthComposerInstance::_update ()
|
||||
{
|
||||
mDepthRenderer->update ();
|
||||
}
|
||||
|
||||
DepthComposerInstance* DepthComposer::createViewportInstance(Ogre::Viewport* vp)
|
||||
{
|
||||
ViewportInstanceMap::const_iterator it = mViewportInstanceMap.find(vp);
|
||||
if (it == mViewportInstanceMap.end()) {
|
||||
std::auto_ptr<DepthComposerInstance> inst(new DepthComposerInstance(this, vp));
|
||||
mViewportInstanceMap.insert(std::make_pair(vp, inst.get()));
|
||||
// hold instance until successfully added to map.
|
||||
return inst.release();
|
||||
} else {
|
||||
return it->second;
|
||||
}
|
||||
}
|
||||
|
||||
DepthComposerInstance* DepthComposer::getViewportInstance(Ogre::Viewport* vp) {
|
||||
ViewportInstanceMap::iterator it = mViewportInstanceMap.find(vp);
|
||||
if (it != mViewportInstanceMap.end()) {
|
||||
return it->second;
|
||||
} else {
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
|
||||
void DepthComposer::destroyViewportInstance(Viewport* vp)
|
||||
{
|
||||
ViewportInstanceMap::iterator it = mViewportInstanceMap.find(vp);
|
||||
if (it != mViewportInstanceMap.end()) {
|
||||
DepthComposerInstance* inst = it->second;
|
||||
delete inst;
|
||||
mViewportInstanceMap.erase(it);
|
||||
}
|
||||
}
|
||||
|
||||
void DepthComposer::destroyAllViewportInstances() {
|
||||
ViewportInstanceMap::const_iterator it;
|
||||
ViewportInstanceMap::const_iterator begin = mViewportInstanceMap.begin();
|
||||
ViewportInstanceMap::const_iterator end = mViewportInstanceMap.end();
|
||||
for (it = begin; it != end; ++it) {
|
||||
assert(it->first == it->second->getViewport());
|
||||
delete it->second;
|
||||
}
|
||||
mViewportInstanceMap.clear();
|
||||
}
|
||||
|
||||
const String DepthRenderer::DEFAULT_CUSTOM_DEPTH_SCHEME_NAME = "CaelumDepth";
|
||||
|
||||
DepthRenderer::DepthRenderer
|
||||
(
|
||||
Viewport* masterViewport
|
||||
):
|
||||
mMasterViewport (masterViewport),
|
||||
mDepthRenderViewport (0),
|
||||
mDepthRenderingNow (false),
|
||||
mViewportVisibilityMask (~0),
|
||||
mUseCustomDepthScheme (true),
|
||||
mCustomDepthSchemeName (DEFAULT_CUSTOM_DEPTH_SCHEME_NAME)
|
||||
{
|
||||
disableRenderGroupRangeFilter ();
|
||||
|
||||
Ogre::String uniqueId = Ogre::StringConverter::toString ((size_t)this);
|
||||
|
||||
// Not cloned!
|
||||
mDepthRenderMaterial = MaterialManager::getSingleton ().getByName ("Caelum/DepthRender");
|
||||
mDepthRenderMaterial->load();
|
||||
if (!mDepthRenderMaterial->getBestTechnique ()) {
|
||||
CAELUM_THROW_UNSUPPORTED_EXCEPTION (
|
||||
"Can't load depth render material: " +
|
||||
mDepthRenderMaterial->getUnsupportedTechniquesExplanation(),
|
||||
"DepthComposer");
|
||||
}
|
||||
|
||||
TextureManager* texMgr = TextureManager::getSingletonPtr();
|
||||
|
||||
int width = getMasterViewport ()->getActualWidth ();
|
||||
int height = getMasterViewport ()->getActualHeight ();
|
||||
LogManager::getSingleton ().logMessage (
|
||||
"Caelum::DepthRenderer: Creating depth render texture size " +
|
||||
StringConverter::toString (width) +
|
||||
"x" +
|
||||
StringConverter::toString (height));
|
||||
|
||||
PixelFormat desiredFormat = PF_FLOAT32_R;
|
||||
PixelFormat requestFormat = desiredFormat;
|
||||
if (texMgr->isFormatSupported (TEX_TYPE_2D, desiredFormat, TU_RENDERTARGET)) {
|
||||
LogManager::getSingleton ().logMessage (
|
||||
"Caelum::DepthRenderer: RenderSystem has native support for " +
|
||||
PixelUtil::getFormatName (desiredFormat));
|
||||
} else if (texMgr->isEquivalentFormatSupported (TEX_TYPE_2D, desiredFormat, TU_RENDERTARGET)) {
|
||||
PixelFormat equivFormat = texMgr->getNativeFormat (TEX_TYPE_2D, desiredFormat, TU_RENDERTARGET);
|
||||
LogManager::getSingleton ().logMessage (
|
||||
"Caelum::DepthRenderer: RenderSystem supports " +
|
||||
PixelUtil::getFormatName (equivFormat) +
|
||||
" instead of " +
|
||||
PixelUtil::getFormatName (desiredFormat));
|
||||
requestFormat = equivFormat;
|
||||
} else {
|
||||
CAELUM_THROW_UNSUPPORTED_EXCEPTION (
|
||||
PixelUtil::getFormatName(desiredFormat) + " or equivalent not supported",
|
||||
"DepthRenderer");
|
||||
}
|
||||
|
||||
if (texMgr->isHardwareFilteringSupported (TEX_TYPE_2D, requestFormat, TU_RENDERTARGET)) {
|
||||
LogManager::getSingleton ().logMessage (
|
||||
"Caelum::DepthRenderer: RenderSystem supports hardware filtering for " +
|
||||
PixelUtil::getFormatName (requestFormat));
|
||||
} else {
|
||||
LogManager::getSingleton ().logMessage (
|
||||
"Caelum::DepthRenderer: RenderSystem does not support hardware filtering for " +
|
||||
PixelUtil::getFormatName (requestFormat));
|
||||
}
|
||||
|
||||
// Create depth texture.
|
||||
// This depends on the size of the viewport.
|
||||
mDepthRenderTexture = texMgr->createManual(
|
||||
"Caelum/DepthComposer/" + uniqueId + "/DepthTexture",
|
||||
Caelum::RESOURCE_GROUP_NAME,
|
||||
TEX_TYPE_2D,
|
||||
width, height, 1,
|
||||
0,
|
||||
requestFormat,
|
||||
TU_RENDERTARGET,
|
||||
0);
|
||||
|
||||
assert(getDepthRenderTarget());
|
||||
|
||||
// Should be the same format
|
||||
LogManager::getSingleton().logMessage (
|
||||
"Caelum::DepthRenderer: Created depth render texture"
|
||||
" actual format " + PixelUtil::getFormatName (getDepthRenderTexture()->getFormat ()) +
|
||||
" desired format " + PixelUtil::getFormatName (getDepthRenderTexture()->getDesiredFormat ()));
|
||||
|
||||
// We do our updates by hand.
|
||||
getDepthRenderTarget()->setAutoUpdated (false);
|
||||
|
||||
// Viewport for the depth rtt. Don't set camera here; it can mess Camera::getViewport();
|
||||
mDepthRenderViewport = getDepthRenderTarget()->addViewport(0);
|
||||
getDepthRenderViewport ()->setShadowsEnabled (false);
|
||||
getDepthRenderViewport ()->setOverlaysEnabled (false);
|
||||
getDepthRenderViewport ()->setClearEveryFrame (true);
|
||||
|
||||
// Depth buffer values range from 0 to 1 in both OpenGL and Directx; unless depth ranges are used.
|
||||
// Clear to the maximum value.
|
||||
getDepthRenderViewport ()->setBackgroundColour (Ogre::ColourValue (1, 1, 1, 1));
|
||||
}
|
||||
|
||||
DepthRenderer::~DepthRenderer()
|
||||
{
|
||||
TextureManager* texMgr = TextureManager::getSingletonPtr();
|
||||
|
||||
// Destroy render texture.
|
||||
if (!mDepthRenderTexture.isNull ()) {
|
||||
texMgr->remove (mDepthRenderTexture->getHandle ());
|
||||
mDepthRenderTexture.setNull ();
|
||||
}
|
||||
}
|
||||
|
||||
void DepthRenderer::update ()
|
||||
{
|
||||
Camera* camera = getMasterViewport ()->getCamera ();
|
||||
Viewport* oldCameraViewport = camera->getViewport ();
|
||||
SceneManager *sceneManager = camera->getSceneManager ();
|
||||
|
||||
assert (oldCameraViewport == getMasterViewport ());
|
||||
assert (getDepthRenderViewport ()->getActualWidth () == getMasterViewport()->getActualWidth ());
|
||||
assert (getDepthRenderViewport ()->getActualHeight () == getMasterViewport()->getActualHeight ());
|
||||
|
||||
getDepthRenderViewport ()->setVisibilityMask (mViewportVisibilityMask);
|
||||
getDepthRenderViewport ()->setCamera (camera);
|
||||
if (this->getUseCustomDepthScheme ()) {
|
||||
getDepthRenderViewport ()->setMaterialScheme (this->getCustomDepthSchemeName ());
|
||||
}
|
||||
|
||||
// Restore old listener after we're done.
|
||||
// Hopefully this will not break horribly.
|
||||
RenderQueue::RenderableListener* oldListener = sceneManager->getRenderQueue ()->getRenderableListener();
|
||||
if (oldListener) {
|
||||
//LogManager::getSingleton ().logMessage (
|
||||
// "Caelum: Found another render queue listener. This could be bad.");
|
||||
}
|
||||
sceneManager->getRenderQueue ()->setRenderableListener (this);
|
||||
|
||||
mDepthRenderingNow = true;
|
||||
//LogManager::getSingleton ().logMessage ("Caelum: Begin depth rendering");
|
||||
getDepthRenderTarget ()->update ();
|
||||
//LogManager::getSingleton ().logMessage ("Caelum: End depth rendering");
|
||||
mDepthRenderingNow = false;
|
||||
|
||||
sceneManager->getRenderQueue ()->setRenderableListener (oldListener);
|
||||
oldListener = 0;
|
||||
|
||||
// Restore the camera's viewport. Ogre compositors do the same thing.
|
||||
camera->_notifyViewport (oldCameraViewport);
|
||||
}
|
||||
|
||||
#if OGRE_VERSION < 0x00010600
|
||||
bool DepthRenderer::renderableQueued(
|
||||
Ogre::Renderable* rend,
|
||||
Ogre::uint8 groupId,
|
||||
Ogre::ushort priority,
|
||||
Ogre::Technique** ppTech)
|
||||
#else
|
||||
bool DepthRenderer::renderableQueued(
|
||||
Ogre::Renderable* rend,
|
||||
Ogre::uint8 groupId,
|
||||
Ogre::ushort priority,
|
||||
Ogre::Technique** ppTech,
|
||||
Ogre::RenderQueue* pQueue)
|
||||
#endif // OGRE_VERSION
|
||||
{
|
||||
assert (mDepthRenderingNow);
|
||||
|
||||
/*
|
||||
LogManager::getSingleton ().logMessage (
|
||||
"Caelum: Renderable queued"
|
||||
" group " + StringConverter::toString (groupId) +
|
||||
" priority " + StringConverter::toString (priority));
|
||||
*/
|
||||
if (groupId < mMinRenderGroupId || groupId > mMaxRenderGroupId) {
|
||||
return false;
|
||||
}
|
||||
|
||||
if (this->getUseCustomDepthScheme () && (*ppTech)->getSchemeName () == this->getCustomDepthSchemeName ()) {
|
||||
/*
|
||||
LogManager::getSingleton().getDefaultLog()->logMessage (
|
||||
"Custom scheme with tech " + (*ppTech)->getName () +
|
||||
" passCount " + StringConverter::toString ((*ppTech)->getNumPasses ()) +
|
||||
" vp " + (*ppTech)->getPass (0)->getVertexProgramName () +
|
||||
" fp " + (*ppTech)->getPass (0)->getFragmentProgramName ());
|
||||
*/
|
||||
return true;
|
||||
}
|
||||
|
||||
// Get depth material
|
||||
Material* depthMaterial = getDepthRenderMaterial ();
|
||||
Technique* tech = depthMaterial->getBestTechnique ();
|
||||
|
||||
// Replace ALL techniques.
|
||||
*ppTech = tech;
|
||||
return true;
|
||||
}
|
||||
|
||||
void DepthRenderer::setRenderGroupRangeFilter (int minGroup, int maxGroup)
|
||||
{
|
||||
mMinRenderGroupId = minGroup;
|
||||
mMaxRenderGroupId = maxGroup;
|
||||
}
|
||||
|
||||
void DepthRenderer::disableRenderGroupRangeFilter()
|
||||
{
|
||||
setRenderGroupRangeFilter(Ogre::RENDER_QUEUE_BACKGROUND, Ogre::RENDER_QUEUE_MAX);
|
||||
}
|
||||
}
|
||||
@ -1,59 +0,0 @@
|
||||
/*
|
||||
This file is part of Caelum.
|
||||
See http://www.ogre3d.org/wiki/index.php/Caelum
|
||||
|
||||
Copyright (c) 2009 Caelum team. See Contributors.txt for details.
|
||||
|
||||
Caelum is free software: you can redistribute it and/or modify
|
||||
it under the terms of the GNU Lesser General Public License as published
|
||||
by the Free Software Foundation, either version 3 of the License, or
|
||||
(at your option) any later version.
|
||||
|
||||
Caelum is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
GNU Lesser General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU Lesser General Public License
|
||||
along with Caelum. If not, see <http://www.gnu.org/licenses/>.
|
||||
*/
|
||||
|
||||
#include "CaelumPrecompiled.h"
|
||||
#include "FastGpuParamRef.h"
|
||||
|
||||
using namespace Ogre;
|
||||
|
||||
namespace Caelum
|
||||
{
|
||||
FastGpuParamRef::FastGpuParamRef(Ogre::GpuProgramParametersSharedPtr paramsPtr, const Ogre::String& name)
|
||||
{
|
||||
this->bind(paramsPtr, name);
|
||||
}
|
||||
|
||||
void FastGpuParamRef::bind(
|
||||
Ogre::GpuProgramParametersSharedPtr params,
|
||||
const Ogre::String& name,
|
||||
bool throwIfNotFound/* = false*/)
|
||||
{
|
||||
assert(!params.isNull());
|
||||
#if CAELUM_DEBUG_PARAM_REF
|
||||
mParams = params;
|
||||
#endif
|
||||
const GpuConstantDefinition* def = params->_findNamedConstantDefinition(name, throwIfNotFound);
|
||||
if (def) {
|
||||
mPhysicalIndex = def->physicalIndex;
|
||||
assert(this->isBound());
|
||||
} else {
|
||||
mPhysicalIndex = InvalidPhysicalIndex;
|
||||
assert(!this->isBound());
|
||||
}
|
||||
}
|
||||
|
||||
void FastGpuParamRef::unbind() {
|
||||
#if CAELUM_DEBUG_PARAM_REF
|
||||
mParams.setNull();
|
||||
#endif
|
||||
mPhysicalIndex = InvalidPhysicalIndex;
|
||||
assert(!this->isBound());
|
||||
}
|
||||
}
|
||||
@ -1,384 +0,0 @@
|
||||
/*
|
||||
This file is part of Caelum.
|
||||
See http://www.ogre3d.org/wiki/index.php/Caelum
|
||||
|
||||
Copyright (c) 2008 Caelum team. See Contributors.txt for details.
|
||||
|
||||
Caelum is free software: you can redistribute it and/or modify
|
||||
it under the terms of the GNU Lesser General Public License as published
|
||||
by the Free Software Foundation, either version 3 of the License, or
|
||||
(at your option) any later version.
|
||||
|
||||
Caelum is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
GNU Lesser General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU Lesser General Public License
|
||||
along with Caelum. If not, see <http://www.gnu.org/licenses/>.
|
||||
*/
|
||||
|
||||
#include "CaelumPrecompiled.h"
|
||||
#include "FlatCloudLayer.h"
|
||||
#include "CaelumExceptions.h"
|
||||
#include "InternalUtilities.h"
|
||||
|
||||
namespace Caelum
|
||||
{
|
||||
FlatCloudLayer::FlatCloudLayer(
|
||||
Ogre::SceneManager *sceneMgr,
|
||||
Ogre::SceneNode *cloudRoot)
|
||||
{
|
||||
Ogre::String uniqueSuffix = InternalUtilities::pointerToString(this);
|
||||
|
||||
// Clone material
|
||||
mMaterial.reset(InternalUtilities::checkLoadMaterialClone ("CaelumLayeredClouds", "Caelum/FlatCloudLayer/Material" + uniqueSuffix));
|
||||
|
||||
mParams.setup(
|
||||
mMaterial->getTechnique(0)->getPass(0)->getVertexProgramParameters(),
|
||||
mMaterial->getTechnique(0)->getPass(0)->getFragmentProgramParameters());
|
||||
|
||||
// Create the scene node.
|
||||
mSceneMgr = sceneMgr;
|
||||
mNode.reset(cloudRoot->createChildSceneNode());
|
||||
mNode->setPosition(Ogre::Vector3(0, 0, 0));
|
||||
|
||||
// Noise texture names are fixed.
|
||||
mNoiseTextureNames.clear();
|
||||
mNoiseTextureNames.push_back("noise1.dds");
|
||||
mNoiseTextureNames.push_back("noise2.dds");
|
||||
mNoiseTextureNames.push_back("noise3.dds");
|
||||
mNoiseTextureNames.push_back("noise4.dds");
|
||||
|
||||
// Invalid; will reset on first opportunity.
|
||||
mCurrentTextureIndex = -1;
|
||||
|
||||
// By default height is 0; the user is expected to change this.
|
||||
setHeight(0);
|
||||
|
||||
// Reset parameters. This is relied upon to initialize most fields.
|
||||
this->reset();
|
||||
|
||||
// Ensure geometry; don't wait for first update.
|
||||
this->_ensureGeometry();
|
||||
}
|
||||
|
||||
FlatCloudLayer::~FlatCloudLayer()
|
||||
{
|
||||
mSceneMgr = 0;
|
||||
|
||||
// Rely on PrivatePtr for everything interesting.
|
||||
}
|
||||
|
||||
void FlatCloudLayer::_invalidateGeometry () {
|
||||
mMeshDirty = true;
|
||||
}
|
||||
|
||||
void FlatCloudLayer::_ensureGeometry ()
|
||||
{
|
||||
if (!mMeshDirty) {
|
||||
return;
|
||||
}
|
||||
|
||||
// Generate unique names based on pointer.
|
||||
Ogre::String uniqueId = Ogre::StringConverter::toString((size_t)this);
|
||||
Ogre::String planeMeshName = "Caelum/FlatCloudLayer/Plane/" + uniqueId;
|
||||
Ogre::String entityName = "Caelum/FlatCloudLayer/Entity/" + uniqueId;
|
||||
|
||||
// Cleanup first. Entity references mesh so it must be destroyed first.
|
||||
mEntity.reset();
|
||||
mMesh.reset();
|
||||
|
||||
/*
|
||||
Ogre::LogManager::getSingleton().logMessage(
|
||||
"Creating cloud layer mesh " +
|
||||
Ogre::StringConverter::toString(mMeshWidthSegments) + "x" +
|
||||
Ogre::StringConverter::toString(mMeshHeightSegments) + " segments");
|
||||
*/
|
||||
|
||||
// Recreate mesh.
|
||||
Ogre::Plane meshPlane(
|
||||
Ogre::Vector3(1, 1, 0),
|
||||
Ogre::Vector3(1, 1, 1),
|
||||
Ogre::Vector3(0, 1, 1));
|
||||
mMesh.reset(Ogre::MeshManager::getSingleton().createPlane(
|
||||
planeMeshName, Caelum::RESOURCE_GROUP_NAME, meshPlane,
|
||||
mMeshWidth, mMeshHeight,
|
||||
mMeshWidthSegments, mMeshHeightSegments,
|
||||
false, 1,
|
||||
1.0f, 1.0f,
|
||||
Ogre::Vector3::UNIT_X));
|
||||
|
||||
// Recreate entity.
|
||||
mEntity.reset(mSceneMgr->createEntity(entityName, mMesh->getName()));
|
||||
mEntity->setMaterialName(mMaterial->getName());
|
||||
|
||||
// Reattach entity.
|
||||
mNode->attachObject(mEntity.get());
|
||||
|
||||
// Mark done.
|
||||
mMeshDirty = false;
|
||||
}
|
||||
|
||||
void FlatCloudLayer::setMeshParameters (
|
||||
Real meshWidth, Real meshHeight,
|
||||
int meshWidthSegments, int meshHeightSegments)
|
||||
{
|
||||
bool invalidate =
|
||||
(mMeshWidthSegments != meshWidthSegments) ||
|
||||
(mMeshHeightSegments != meshHeightSegments) ||
|
||||
(abs(mMeshWidth - meshWidth) > 0.001) ||
|
||||
(abs(mMeshHeight - meshHeight) > 0.001);
|
||||
mMeshWidth = meshWidth;
|
||||
mMeshHeight = meshHeight;
|
||||
mMeshWidthSegments = meshWidthSegments;
|
||||
mMeshHeightSegments = meshHeightSegments;
|
||||
if (invalidate) {
|
||||
_invalidateGeometry();
|
||||
}
|
||||
}
|
||||
|
||||
void FlatCloudLayer::reset()
|
||||
{
|
||||
_invalidateGeometry ();
|
||||
setMeshParameters(10000000, 10000000, 10, 10);
|
||||
|
||||
assert (mCloudCoverLookup.get() == 0);
|
||||
setCloudCoverLookup ("CloudCoverLookup.png");
|
||||
setCloudCover (0.3);
|
||||
setCloudCoverVisibilityThreshold (0.001);
|
||||
|
||||
setCloudMassOffset (Ogre::Vector2(0, 0));
|
||||
setCloudDetailOffset (Ogre::Vector2(0, 0));
|
||||
setCloudBlendTime (3600 * 24);
|
||||
setCloudBlendPos (0.5);
|
||||
|
||||
setCloudSpeed (Ogre::Vector2(0.000005, -0.000009));
|
||||
|
||||
setCloudUVFactor (150);
|
||||
setHeightRedFactor (100000);
|
||||
|
||||
setFadeDistances (10000, 140000);
|
||||
setFadeDistMeasurementVector (Ogre::Vector3(0, 1, 1));
|
||||
|
||||
setSunDirection (Ogre::Vector3::UNIT_Y);
|
||||
setFogColour (Ogre::ColourValue::Black);
|
||||
setSunLightColour (Ogre::ColourValue::White);
|
||||
setSunSphereColour (Ogre::ColourValue::White);
|
||||
}
|
||||
|
||||
void FlatCloudLayer::update (
|
||||
Ogre::Real timePassed,
|
||||
const Ogre::Vector3 &sunDirection,
|
||||
const Ogre::ColourValue &sunLightColour,
|
||||
const Ogre::ColourValue &fogColour,
|
||||
const Ogre::ColourValue &sunSphereColour)
|
||||
{
|
||||
// Advance animation
|
||||
advanceAnimation (timePassed);
|
||||
|
||||
// Set parameters.
|
||||
setSunDirection (sunDirection);
|
||||
setSunLightColour (sunLightColour);
|
||||
setSunSphereColour (sunSphereColour);
|
||||
setFogColour (fogColour);
|
||||
|
||||
this->_ensureGeometry();
|
||||
|
||||
this->_updateVisibilityThreshold();
|
||||
}
|
||||
|
||||
void FlatCloudLayer::_updateVisibilityThreshold ()
|
||||
{
|
||||
if (!mEntity.isNull()) {
|
||||
mEntity->setVisible (getCloudCover () > this->getCloudCoverVisibilityThreshold ());
|
||||
}
|
||||
}
|
||||
|
||||
void FlatCloudLayer::advanceAnimation (Ogre::Real timePassed)
|
||||
{
|
||||
// Move clouds.
|
||||
setCloudMassOffset(mCloudMassOffset + timePassed * mCloudSpeed);
|
||||
setCloudDetailOffset(mCloudDetailOffset - timePassed * mCloudSpeed);
|
||||
|
||||
// Animate cloud blending.
|
||||
setCloudBlendPos (getCloudBlendPos () + timePassed / mCloudBlendTime);
|
||||
}
|
||||
|
||||
void FlatCloudLayer::Params::setup(Ogre::GpuProgramParametersSharedPtr vpParams, Ogre::GpuProgramParametersSharedPtr fpParams)
|
||||
{
|
||||
this->vpParams = vpParams;
|
||||
this->fpParams = fpParams;
|
||||
cloudCoverageThreshold.bind(fpParams, "cloudCoverageThreshold");
|
||||
cloudMassOffset.bind(fpParams, "cloudMassOffset");
|
||||
cloudDetailOffset.bind(fpParams, "cloudDetailOffset");
|
||||
cloudMassBlend.bind(fpParams, "cloudMassBlend");
|
||||
vpSunDirection.bind(vpParams, "sunDirection");
|
||||
fpSunDirection.bind(fpParams, "sunDirection");
|
||||
sunLightColour.bind(fpParams, "sunLightColour");
|
||||
sunSphereColour.bind(fpParams, "sunSphereColour");
|
||||
fogColour.bind(fpParams, "fogColour");
|
||||
layerHeight.bind(fpParams, "layerHeight");
|
||||
cloudUVFactor.bind(fpParams, "cloudUVFactor");
|
||||
heightRedFactor.bind(fpParams, "heightRedFactor");
|
||||
nearFadeDist.bind(fpParams, "nearFadeDist");
|
||||
farFadeDist.bind(fpParams, "farFadeDist");
|
||||
fadeDistMeasurementVector.bind(fpParams, "fadeDistMeasurementVector");
|
||||
}
|
||||
|
||||
void FlatCloudLayer::setCloudCoverLookup (const Ogre::String& fileName) {
|
||||
mCloudCoverLookup.reset(0);
|
||||
mCloudCoverLookup.reset(new Ogre::Image());
|
||||
mCloudCoverLookup->load(fileName, RESOURCE_GROUP_NAME);
|
||||
|
||||
mCloudCoverLookupFileName = fileName;
|
||||
}
|
||||
|
||||
void FlatCloudLayer::disableCloudCoverLookup () {
|
||||
mCloudCoverLookup.reset (0);
|
||||
mCloudCoverLookupFileName.clear ();
|
||||
}
|
||||
|
||||
const Ogre::String FlatCloudLayer::getCloudCoverLookupFileName () const {
|
||||
return mCloudCoverLookupFileName;
|
||||
}
|
||||
|
||||
void FlatCloudLayer::setCloudCoverVisibilityThreshold(const Ogre::Real value) {
|
||||
mCloudCoverVisibilityThreshold = value;
|
||||
_updateVisibilityThreshold();
|
||||
}
|
||||
|
||||
void FlatCloudLayer::setCloudCover(const Ogre::Real cloudCover) {
|
||||
mCloudCover = cloudCover;
|
||||
float cloudCoverageThreshold = 0;
|
||||
if (mCloudCoverLookup.get() != 0) {
|
||||
cloudCoverageThreshold = InternalUtilities::getInterpolatedColour(cloudCover, 1, mCloudCoverLookup.get(), false).r;
|
||||
} else {
|
||||
cloudCoverageThreshold = 1 - cloudCover;
|
||||
}
|
||||
mParams.cloudCoverageThreshold.set(mParams.fpParams, cloudCoverageThreshold);
|
||||
_updateVisibilityThreshold();
|
||||
}
|
||||
|
||||
void FlatCloudLayer::setCloudMassOffset(const Ogre::Vector2 &cloudMassOffset) {
|
||||
mCloudMassOffset = cloudMassOffset;
|
||||
mParams.cloudMassOffset.set(mParams.fpParams, Ogre::Vector3(cloudMassOffset.x,cloudMassOffset.y,0));
|
||||
}
|
||||
|
||||
void FlatCloudLayer::setCloudDetailOffset(const Ogre::Vector2 &cloudDetailOffset) {
|
||||
mCloudDetailOffset = cloudDetailOffset;
|
||||
mParams.cloudDetailOffset.set(mParams.fpParams, Ogre::Vector3(cloudDetailOffset.x,cloudDetailOffset.y,0));
|
||||
}
|
||||
|
||||
void FlatCloudLayer::setCloudBlendTime(const Ogre::Real value) {
|
||||
mCloudBlendTime = value;
|
||||
}
|
||||
|
||||
Ogre::Real FlatCloudLayer::getCloudBlendTime () const {
|
||||
return mCloudBlendTime;
|
||||
}
|
||||
|
||||
void FlatCloudLayer::setCloudBlendPos (const Ogre::Real value)
|
||||
{
|
||||
mCloudBlendPos = value;
|
||||
int textureCount = static_cast<int>(mNoiseTextureNames.size());
|
||||
|
||||
// Convert to int and bring to [0, textureCount)
|
||||
int currentTextureIndex = static_cast<int>(floor(mCloudBlendPos));
|
||||
currentTextureIndex = ((currentTextureIndex % textureCount) + textureCount) % textureCount;
|
||||
assert(0 <= currentTextureIndex);
|
||||
assert(currentTextureIndex < textureCount);
|
||||
|
||||
// Check if we have to change textures.
|
||||
if (currentTextureIndex != mCurrentTextureIndex) {
|
||||
String texture1 = mNoiseTextureNames[currentTextureIndex];
|
||||
String texture2 = mNoiseTextureNames[(currentTextureIndex + 1) % textureCount];
|
||||
//Ogre::LogManager::getSingleton ().logMessage (
|
||||
// "Caelum: Switching cloud layer textures to " + texture1 + " and " + texture2);
|
||||
Ogre::Pass* pass = mMaterial->getBestTechnique()->getPass(0);
|
||||
pass->getTextureUnitState(0)->setTextureName(texture1);
|
||||
pass->getTextureUnitState(1)->setTextureName(texture2);
|
||||
mCurrentTextureIndex = currentTextureIndex;
|
||||
}
|
||||
|
||||
Ogre::Real cloudMassBlend = fmod(mCloudBlendPos, 1);
|
||||
mParams.cloudMassBlend.set(mParams.fpParams, cloudMassBlend);
|
||||
}
|
||||
|
||||
Ogre::Real FlatCloudLayer::getCloudBlendPos () const {
|
||||
return mCloudBlendPos;
|
||||
}
|
||||
|
||||
void FlatCloudLayer::setCloudSpeed (const Ogre::Vector2 &cloudSpeed) {
|
||||
mCloudSpeed = cloudSpeed;
|
||||
}
|
||||
|
||||
void FlatCloudLayer::setSunDirection (const Ogre::Vector3 &sunDirection) {
|
||||
mSunDirection = sunDirection;
|
||||
mParams.vpSunDirection.set(mParams.vpParams, sunDirection);
|
||||
mParams.fpSunDirection.set(mParams.fpParams, sunDirection);
|
||||
}
|
||||
|
||||
void FlatCloudLayer::setSunLightColour (const Ogre::ColourValue &sunLightColour) {
|
||||
mParams.sunLightColour.set(mParams.fpParams, mSunLightColour = sunLightColour);
|
||||
}
|
||||
|
||||
void FlatCloudLayer::setSunSphereColour (const Ogre::ColourValue &sunSphereColour) {
|
||||
mParams.sunSphereColour.set(mParams.fpParams, mSunSphereColour = sunSphereColour);
|
||||
}
|
||||
|
||||
void FlatCloudLayer::setFogColour (const Ogre::ColourValue &fogColour) {
|
||||
mParams.fogColour.set(mParams.fpParams, mFogColour = fogColour);
|
||||
}
|
||||
|
||||
const Ogre::Vector3 FlatCloudLayer::getSunDirection () const {
|
||||
return mSunDirection;
|
||||
}
|
||||
|
||||
const Ogre::ColourValue FlatCloudLayer::getSunLightColour () const {
|
||||
return mSunLightColour;
|
||||
}
|
||||
|
||||
const Ogre::ColourValue FlatCloudLayer::getSunSphereColour () const {
|
||||
return mSunSphereColour;
|
||||
}
|
||||
|
||||
const Ogre::ColourValue FlatCloudLayer::getFogColour () const {
|
||||
return mFogColour;
|
||||
}
|
||||
|
||||
void FlatCloudLayer::setHeight(Ogre::Real height) {
|
||||
mNode->setPosition(Ogre::Vector3(0, height, 0));
|
||||
mHeight = height;
|
||||
mParams.layerHeight.set(mParams.fpParams, mHeight);
|
||||
}
|
||||
|
||||
Ogre::Real FlatCloudLayer::getHeight() const {
|
||||
return mHeight;
|
||||
}
|
||||
|
||||
void FlatCloudLayer::setCloudUVFactor (const Ogre::Real value) {
|
||||
mParams.cloudUVFactor.set(mParams.fpParams, mCloudUVFactor = value);
|
||||
}
|
||||
|
||||
void FlatCloudLayer::setHeightRedFactor (const Ogre::Real value) {
|
||||
mParams.heightRedFactor.set(mParams.fpParams, mHeightRedFactor = value);
|
||||
}
|
||||
|
||||
void FlatCloudLayer::setFadeDistances (const Ogre::Real nearValue, const Ogre::Real farValue) {
|
||||
setNearFadeDist (nearValue);
|
||||
setFarFadeDist (farValue);
|
||||
}
|
||||
|
||||
void FlatCloudLayer::setNearFadeDist (const Ogre::Real value) {
|
||||
mParams.nearFadeDist.set(mParams.fpParams, mNearFadeDist = value);
|
||||
}
|
||||
|
||||
void FlatCloudLayer::setFarFadeDist (const Ogre::Real value) {
|
||||
mParams.farFadeDist.set(mParams.fpParams, mFarFadeDist = value);
|
||||
}
|
||||
|
||||
void FlatCloudLayer::setFadeDistMeasurementVector (const Ogre::Vector3& value) {
|
||||
mParams.fadeDistMeasurementVector.set(mParams.fpParams, mFadeDistMeasurementVector = value);
|
||||
}
|
||||
}
|
||||
@ -1,216 +0,0 @@
|
||||
/*
|
||||
This file is part of Caelum.
|
||||
See http://www.ogre3d.org/wiki/index.php/Caelum
|
||||
|
||||
Copyright (c) 2006-2007 Caelum team. See Contributors.txt for details.
|
||||
|
||||
Caelum is free software: you can redistribute it and/or modify
|
||||
it under the terms of the GNU Lesser General Public License as published
|
||||
by the Free Software Foundation, either version 3 of the License, or
|
||||
(at your option) any later version.
|
||||
|
||||
Caelum is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
GNU Lesser General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU Lesser General Public License
|
||||
along with Caelum. If not, see <http://www.gnu.org/licenses/>.
|
||||
*/
|
||||
|
||||
#include "CaelumPrecompiled.h"
|
||||
#include "GroundFog.h"
|
||||
#include "CaelumExceptions.h"
|
||||
#include "InternalUtilities.h"
|
||||
|
||||
namespace Caelum
|
||||
{
|
||||
const Ogre::String GroundFog::DEFAULT_PASS_NAME = "CaelumGroundFog";
|
||||
|
||||
GroundFog::GroundFog(
|
||||
Ogre::SceneManager *sceneMgr,
|
||||
Ogre::SceneNode *caelumRootNode,
|
||||
const Ogre::String &domeMaterialName,
|
||||
const Ogre::String &domeEntityName):
|
||||
mScene(sceneMgr)
|
||||
{
|
||||
Ogre::String uniqueSuffix = InternalUtilities::pointerToString (this);
|
||||
|
||||
mDomeMaterial.reset(InternalUtilities::checkLoadMaterialClone (domeMaterialName, domeMaterialName + uniqueSuffix));
|
||||
mDomeParams.setup(mDomeMaterial->getTechnique(0)->getPass(0)->getFragmentProgramParameters());
|
||||
|
||||
// Create dome entity, using a prefab sphere.
|
||||
// The prefab sphere has a radius of 50 units.
|
||||
// If this changes in future version of ogre this might break.
|
||||
mDomeEntity.reset (mScene->createEntity (domeEntityName, Ogre::SceneManager::PT_SPHERE));
|
||||
mDomeEntity->setMaterialName (mDomeMaterial->getName ());
|
||||
mDomeEntity->setCastShadows (false);
|
||||
mDomeEntity->setRenderQueueGroup (CAELUM_RENDER_QUEUE_GROUND_FOG);
|
||||
sceneMgr->getRenderQueue()->getQueueGroup(CAELUM_RENDER_QUEUE_GROUND_FOG)->setShadowsEnabled(false);
|
||||
|
||||
// Create dome node
|
||||
mDomeNode.reset (caelumRootNode->createChildSceneNode ());
|
||||
mDomeNode->attachObject (mDomeEntity.get());
|
||||
|
||||
// Initialize default fog parameters
|
||||
mDensity = 0.1;
|
||||
mVerticalDecay = 0.2;
|
||||
mGroundLevel = 5;
|
||||
mFogColour = Ogre::ColourValue::Black;
|
||||
|
||||
forceUpdate();
|
||||
}
|
||||
|
||||
GroundFog::~GroundFog() {
|
||||
// Disable passes.
|
||||
setDensity(0);
|
||||
}
|
||||
|
||||
GroundFog::PassSet& GroundFog::getPasses() {
|
||||
return mPasses;
|
||||
}
|
||||
|
||||
const GroundFog::PassSet& GroundFog::getPasses() const {
|
||||
return mPasses;
|
||||
}
|
||||
|
||||
void GroundFog::findFogPassesByName (const Ogre::String& passName) {
|
||||
Ogre::MaterialManager *matManager = Ogre::MaterialManager::getSingletonPtr();
|
||||
Ogre::MaterialManager::ResourceMapIterator matIt = matManager->getResourceIterator();
|
||||
while (matIt.hasMoreElements()) {
|
||||
Ogre::MaterialPtr mat = matIt.getNext();
|
||||
Ogre::Material::TechniqueIterator techIt = mat->getTechniqueIterator();
|
||||
while (techIt.hasMoreElements()) {
|
||||
Ogre::Technique *tech = techIt.getNext();
|
||||
Ogre::Technique::PassIterator passIt = tech->getPassIterator();
|
||||
while (passIt.hasMoreElements()) {
|
||||
Ogre::Pass *pass = passIt.getNext();
|
||||
if (pass->getName() == passName) {
|
||||
mPasses.insert(pass);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
forceUpdate();
|
||||
}
|
||||
|
||||
void GroundFog::setDensity (Ogre::Real density) {
|
||||
if (Ogre::Math::Abs(mDensity - density) > 0.000001) {
|
||||
for (PassFogParamsVector::const_iterator it = mPassFogParams.begin(), end = mPassFogParams.end(); it != end; ++it) {
|
||||
it->fogDensity.set(it->fpParams, density);
|
||||
}
|
||||
mDensity = density;
|
||||
}
|
||||
updateSkyFogging();
|
||||
}
|
||||
|
||||
Ogre::Real GroundFog::getDensity () const {
|
||||
return mDensity;
|
||||
}
|
||||
|
||||
void GroundFog::setColour (const Ogre::ColourValue &colour) {
|
||||
bool different =
|
||||
Ogre::Math::Abs(mFogColour.r - colour.r) > 0.001 ||
|
||||
Ogre::Math::Abs(mFogColour.g - colour.g) > 0.001 ||
|
||||
Ogre::Math::Abs(mFogColour.b - colour.b) > 0.001 ||
|
||||
Ogre::Math::Abs(mFogColour.a - colour.a) > 0.001;
|
||||
if (different) {
|
||||
for (PassFogParamsVector::const_iterator it = mPassFogParams.begin(), end = mPassFogParams.end(); it != end; ++it) {
|
||||
it->fogColour.set(it->fpParams, colour);
|
||||
}
|
||||
mFogColour = colour;
|
||||
}
|
||||
updateSkyFogging();
|
||||
}
|
||||
|
||||
const Ogre::ColourValue GroundFog::getColour () const {
|
||||
return mFogColour;
|
||||
}
|
||||
|
||||
void GroundFog::setVerticalDecay (Ogre::Real verticalDecay) {
|
||||
if (Ogre::Math::Abs(mVerticalDecay - verticalDecay) > 0.000001) {
|
||||
for (PassFogParamsVector::const_iterator it = mPassFogParams.begin(), end = mPassFogParams.end(); it != end; ++it) {
|
||||
it->fogVerticalDecay.set(it->fpParams, verticalDecay);
|
||||
}
|
||||
mVerticalDecay = verticalDecay;
|
||||
}
|
||||
updateSkyFogging();
|
||||
}
|
||||
|
||||
Ogre::Real GroundFog::getVerticalDecay () const {
|
||||
return mVerticalDecay;
|
||||
}
|
||||
|
||||
void GroundFog::setGroundLevel (Ogre::Real groundLevel) {
|
||||
if (Ogre::Math::Abs(mGroundLevel - groundLevel) > 0.000001) {
|
||||
for (PassFogParamsVector::const_iterator it = mPassFogParams.begin(), end = mPassFogParams.end(); it != end; ++it) {
|
||||
it->fogGroundLevel.set(it->fpParams, groundLevel);
|
||||
}
|
||||
mGroundLevel = groundLevel;
|
||||
}
|
||||
updateSkyFogging();
|
||||
}
|
||||
|
||||
Ogre::Real GroundFog::getGroundLevel () const {
|
||||
return mGroundLevel;
|
||||
}
|
||||
|
||||
void GroundFog::updateSkyFogging() {
|
||||
mDomeParams.fogDensity.set(mDomeParams.fpParams, mDensity);
|
||||
mDomeParams.fogVerticalDecay.set(mDomeParams.fpParams, mVerticalDecay);
|
||||
mDomeParams.fogGroundLevel.set(mDomeParams.fpParams, mGroundLevel);
|
||||
mDomeParams.fogColour.set(mDomeParams.fpParams, mFogColour);
|
||||
}
|
||||
|
||||
void GroundFog::forceUpdate ()
|
||||
{
|
||||
updatePassFogParams();
|
||||
for (PassFogParamsVector::const_iterator it = mPassFogParams.begin(), end = mPassFogParams.end(); it != end; ++it) {
|
||||
const PassFogParams& params = *it;
|
||||
params.fogDensity.set(params.fpParams, mDensity);
|
||||
params.fogVerticalDecay.set(params.fpParams, mVerticalDecay);
|
||||
params.fogGroundLevel.set(params.fpParams, mGroundLevel);
|
||||
params.fogColour.set(params.fpParams, mFogColour);
|
||||
}
|
||||
updateSkyFogging();
|
||||
}
|
||||
|
||||
void GroundFog::updatePassFogParams ()
|
||||
{
|
||||
mPassFogParams.clear();
|
||||
for (PassSet::const_iterator it = mPasses.begin(), end = mPasses.end(); it != end; ++it) {
|
||||
mPassFogParams.push_back(PassFogParams((*it)->getFragmentProgramParameters()));
|
||||
}
|
||||
std::sort(mPassFogParams.begin(), mPassFogParams.end(), PassFogParams::lessThanByParams);
|
||||
std::unique(mPassFogParams.begin(), mPassFogParams.end(), PassFogParams::equalByParams);
|
||||
}
|
||||
|
||||
void GroundFog::FogParamsBase::setup(Ogre::GpuProgramParametersSharedPtr fpParams) {
|
||||
this->fpParams = fpParams;
|
||||
fogDensity.bind(fpParams, "fogDensity");
|
||||
fogVerticalDecay.bind(fpParams, "fogVerticalDecay");
|
||||
fogGroundLevel.bind(fpParams, "fogGroundLevel");
|
||||
fogColour.bind(fpParams, "fogColour");
|
||||
}
|
||||
|
||||
void GroundFog::DomeFogParams::setup(Ogre::GpuProgramParametersSharedPtr fpParams) {
|
||||
FogParamsBase::setup(fpParams);
|
||||
cameraHeight.bind(fpParams, "cameraHeight");
|
||||
}
|
||||
|
||||
void GroundFog::notifyCameraChanged (Ogre::Camera *cam)
|
||||
{
|
||||
CameraBoundElement::notifyCameraChanged (cam);
|
||||
|
||||
// Send camera height to shader.
|
||||
float cameraHeight = cam->getDerivedPosition().dotProduct(mDomeNode->_getDerivedOrientation() * Ogre::Vector3::UNIT_Y);
|
||||
mDomeParams.cameraHeight.set(mDomeParams.fpParams, cameraHeight);
|
||||
}
|
||||
|
||||
void GroundFog::setFarRadius (Ogre::Real radius)
|
||||
{
|
||||
CameraBoundElement::setFarRadius(radius);
|
||||
// Adjust for radius 50.
|
||||
mDomeNode->setScale(Ogre::Vector3::UNIT_SCALE * radius / 50.0);
|
||||
}
|
||||
}
|
||||
@ -1,87 +0,0 @@
|
||||
/*
|
||||
This file is part of Caelum.
|
||||
See http://www.ogre3d.org/wiki/index.php/Caelum
|
||||
|
||||
Copyright (c) 2006-2008 Caelum team. See Contributors.txt for details.
|
||||
|
||||
Caelum is free software: you can redistribute it and/or modify
|
||||
it under the terms of the GNU Lesser General Public License as published
|
||||
by the Free Software Foundation, either version 3 of the License, or
|
||||
(at your option) any later version.
|
||||
|
||||
Caelum is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
GNU Lesser General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU Lesser General Public License
|
||||
along with Caelum. If not, see <http://www.gnu.org/licenses/>.
|
||||
*/
|
||||
|
||||
#include "CaelumPrecompiled.h"
|
||||
#include "ImageStarfield.h"
|
||||
#include "InternalUtilities.h"
|
||||
|
||||
namespace Caelum
|
||||
{
|
||||
const Ogre::String ImageStarfield::STARFIELD_DOME_NAME = "CaelumStarfieldDome";
|
||||
const Ogre::String ImageStarfield::STARFIELD_MATERIAL_NAME = "CaelumStarfieldMaterial";
|
||||
const Ogre::String ImageStarfield::DEFAULT_TEXTURE_NAME = "Starfield.jpg";
|
||||
|
||||
ImageStarfield::ImageStarfield
|
||||
(
|
||||
Ogre::SceneManager *sceneMgr,
|
||||
Ogre::SceneNode *caelumRootNode,
|
||||
const Ogre::String &textureName/* = DEFAULT_TEXUTRE_NAME*/
|
||||
)
|
||||
{
|
||||
mInclination = Ogre::Degree (0);
|
||||
|
||||
String uniqueSuffix = "/" + InternalUtilities::pointerToString (this);
|
||||
|
||||
mStarfieldMaterial.reset (InternalUtilities::checkLoadMaterialClone (STARFIELD_MATERIAL_NAME, STARFIELD_MATERIAL_NAME + uniqueSuffix));
|
||||
setTexture (textureName);
|
||||
|
||||
sceneMgr->getRenderQueue ()->getQueueGroup (CAELUM_RENDER_QUEUE_STARFIELD)->setShadowsEnabled (false);
|
||||
|
||||
InternalUtilities::generateSphericDome (STARFIELD_DOME_NAME, 32, InternalUtilities::DT_IMAGE_STARFIELD);
|
||||
|
||||
mEntity.reset(sceneMgr->createEntity ("Caelum/StarfieldDome" + uniqueSuffix, STARFIELD_DOME_NAME));
|
||||
mEntity->setMaterialName (mStarfieldMaterial->getName());
|
||||
mEntity->setRenderQueueGroup (CAELUM_RENDER_QUEUE_STARFIELD);
|
||||
mEntity->setCastShadows (false);
|
||||
|
||||
mNode.reset (caelumRootNode->createChildSceneNode ());
|
||||
mNode->attachObject (mEntity.get ());
|
||||
}
|
||||
|
||||
ImageStarfield::~ImageStarfield ()
|
||||
{
|
||||
}
|
||||
|
||||
void ImageStarfield::notifyCameraChanged (Ogre::Camera *cam) {
|
||||
CameraBoundElement::notifyCameraChanged (cam);
|
||||
}
|
||||
|
||||
void ImageStarfield::setFarRadius (Ogre::Real radius) {
|
||||
CameraBoundElement::setFarRadius(radius);
|
||||
mNode->setScale (Ogre::Vector3::UNIT_SCALE * radius);
|
||||
}
|
||||
|
||||
void ImageStarfield::setInclination (Ogre::Degree inc) {
|
||||
mInclination = inc;
|
||||
}
|
||||
|
||||
void ImageStarfield::update (const float time) {
|
||||
Ogre::Quaternion orientation = Ogre::Quaternion::IDENTITY;
|
||||
orientation = orientation * Ogre::Quaternion (Ogre::Radian (mInclination + Ogre::Degree (90)), Ogre::Vector3::UNIT_X);
|
||||
orientation = orientation * Ogre::Quaternion (Ogre::Radian (-time * 2 * Ogre::Math::PI), Ogre::Vector3::UNIT_Y);
|
||||
|
||||
mNode->setOrientation (orientation);
|
||||
}
|
||||
|
||||
void ImageStarfield::setTexture (const Ogre::String &mapName) {
|
||||
// Update the starfield material
|
||||
mStarfieldMaterial->getBestTechnique ()->getPass (0)->getTextureUnitState (0)->setTextureName (mapName);
|
||||
}
|
||||
}
|
||||
@ -1,328 +0,0 @@
|
||||
/*
|
||||
This file is part of Caelum.
|
||||
See http://www.ogre3d.org/wiki/index.php/Caelum
|
||||
|
||||
Copyright (c) 2006-2007 Caelum team. See Contributors.txt for details.
|
||||
|
||||
Caelum is free software: you can redistribute it and/or modify
|
||||
it under the terms of the GNU Lesser General Public License as published
|
||||
by the Free Software Foundation, either version 3 of the License, or
|
||||
(at your option) any later version.
|
||||
|
||||
Caelum is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
GNU Lesser General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU Lesser General Public License
|
||||
along with Caelum. If not, see <http://www.gnu.org/licenses/>.
|
||||
*/
|
||||
|
||||
#include "CaelumPrecompiled.h"
|
||||
#include "CaelumExceptions.h"
|
||||
#include "InternalUtilities.h"
|
||||
#include "PrivatePtr.h"
|
||||
|
||||
namespace Caelum
|
||||
{
|
||||
Ogre::ColourValue InternalUtilities::getInterpolatedColour (
|
||||
float fx, float fy, Ogre::Image *img, bool wrapX)
|
||||
{
|
||||
// Don't -> all the time, and avoid unsigned warnings
|
||||
int imgWidth = static_cast<int>(img->getWidth ());
|
||||
int imgHeight = static_cast<int>(img->getHeight ());
|
||||
|
||||
// Calculate pixel y coord.
|
||||
int py = Ogre::Math::IFloor(Ogre::Math::Abs (fy) * (imgHeight - 1));
|
||||
// Snap to py image bounds.
|
||||
py = std::max(0, std::min(py, imgHeight - 1));
|
||||
|
||||
// Get the two closest pixels on x.
|
||||
// px1 and px2 are the closest integer pixels to px.
|
||||
float px = fx * (img->getWidth () - 1);
|
||||
int px1, px2;
|
||||
px1 = Ogre::Math::IFloor(px);
|
||||
px2 = Ogre::Math::ICeil(px);
|
||||
|
||||
if (wrapX) {
|
||||
// Wrap x coords. The funny addition ensures that it does
|
||||
// "the right thing" for negative values.
|
||||
px1 = (px1 % imgWidth + imgWidth) % imgWidth;
|
||||
px2 = (px2 % imgWidth + imgWidth) % imgWidth;
|
||||
} else {
|
||||
px1 = std::max(0, std::min(px1, imgWidth - 1));
|
||||
px2 = std::max(0, std::min(px2, imgWidth - 1));
|
||||
}
|
||||
|
||||
// Calculate the interpolated pixel
|
||||
Ogre::ColourValue c1, c2, cf;
|
||||
c1 = img->getColourAt (px1, py, 0);
|
||||
c2 = img->getColourAt (px2, py, 0);
|
||||
|
||||
// Blend the two pixels together.
|
||||
// diff is the weight between pixel 1 and pixel 2.
|
||||
float diff = px - px1;
|
||||
cf = c1 * (1 - diff) + c2 * diff;
|
||||
|
||||
return cf;
|
||||
}
|
||||
|
||||
const Ogre::String InternalUtilities::pointerToString (void* pointer)
|
||||
{
|
||||
std::stringstream stream;
|
||||
stream.width(2 * sizeof(void *));
|
||||
stream.fill('0');
|
||||
stream.unsetf(std::ios::dec);
|
||||
stream.setf(std::ios::hex);
|
||||
stream.setf(std::ios::uppercase);
|
||||
stream << reinterpret_cast<std::ptrdiff_t>(pointer);
|
||||
return stream.str();
|
||||
}
|
||||
|
||||
Ogre::MaterialPtr InternalUtilities::checkLoadMaterialClone (
|
||||
const Ogre::String& originalName,
|
||||
const Ogre::String& cloneName)
|
||||
{
|
||||
Ogre::MaterialPtr scriptMaterial = Ogre::MaterialManager::getSingletonPtr()->getByName(originalName);
|
||||
if (scriptMaterial.isNull()) {
|
||||
CAELUM_THROW_UNSUPPORTED_EXCEPTION (
|
||||
"Can't find material \"" + originalName + "\"",
|
||||
"Caelum");
|
||||
}
|
||||
|
||||
// Create clone
|
||||
Caelum::PrivateMaterialPtr clonedMaterial (scriptMaterial->clone (cloneName));
|
||||
|
||||
// Test clone loads and there is at least on supported technique
|
||||
clonedMaterial->load ();
|
||||
if (clonedMaterial->getBestTechnique () == 0) {
|
||||
CAELUM_THROW_UNSUPPORTED_EXCEPTION (
|
||||
"Can't load material \"" + originalName + "\": " + clonedMaterial->getUnsupportedTechniquesExplanation(),
|
||||
"Caelum");
|
||||
}
|
||||
|
||||
return clonedMaterial.release();
|
||||
}
|
||||
|
||||
Ogre::CompositorPtr InternalUtilities::checkCompositorSupported (const Ogre::String& name)
|
||||
{
|
||||
Ogre::CompositorPtr comp = Ogre::CompositorManager::getSingletonPtr()->getByName(name);
|
||||
if (comp.isNull()) {
|
||||
CAELUM_THROW_UNSUPPORTED_EXCEPTION (
|
||||
"Can't find compositor \"" + name + "\"",
|
||||
"Caelum");
|
||||
}
|
||||
|
||||
// Check the compositor is supported after loading.
|
||||
comp->load ();
|
||||
if (comp->getNumSupportedTechniques () == 0) {
|
||||
CAELUM_THROW_UNSUPPORTED_EXCEPTION (
|
||||
"Can't load compositor \"" + name + "\"",
|
||||
"Caelum");
|
||||
}
|
||||
|
||||
return comp;
|
||||
}
|
||||
|
||||
void InternalUtilities::generateSphericDome (const Ogre::String &name, int segments, DomeType type)
|
||||
{
|
||||
// Return now if already exists
|
||||
if (Ogre::MeshManager::getSingleton ().resourceExists (name)) {
|
||||
return;
|
||||
}
|
||||
|
||||
Ogre::LogManager::getSingleton ().logMessage (
|
||||
"Caelum: Creating " + name + " sphere mesh resource...");
|
||||
|
||||
// Use the mesh manager to create the mesh
|
||||
Ogre::MeshPtr msh = Ogre::MeshManager::getSingleton ().createManual (name, RESOURCE_GROUP_NAME);
|
||||
// Create a submesh
|
||||
Ogre::SubMesh *sub = msh->createSubMesh ();
|
||||
|
||||
// Create the shared vertex data
|
||||
Ogre::VertexData *vertexData = new Ogre::VertexData ();
|
||||
msh->sharedVertexData = vertexData;
|
||||
|
||||
// Define the vertices' format
|
||||
Ogre::VertexDeclaration *vertexDecl = vertexData->vertexDeclaration;
|
||||
size_t currOffset = 0;
|
||||
// Position
|
||||
vertexDecl->addElement (0, currOffset, Ogre::VET_FLOAT3, Ogre::VES_POSITION);
|
||||
currOffset += Ogre::VertexElement::getTypeSize (Ogre::VET_FLOAT3);
|
||||
// Normal
|
||||
vertexDecl->addElement (0, currOffset, Ogre::VET_FLOAT3, Ogre::VES_NORMAL);
|
||||
currOffset += Ogre::VertexElement::getTypeSize (Ogre::VET_FLOAT3);
|
||||
// Texture coordinates
|
||||
vertexDecl->addElement (0, currOffset, Ogre::VET_FLOAT2, Ogre::VES_TEXTURE_COORDINATES, 0);
|
||||
currOffset += Ogre::VertexElement::getTypeSize (Ogre::VET_FLOAT2);
|
||||
|
||||
// Allocate the vertex buffer
|
||||
switch (type) {
|
||||
case DT_SKY_DOME:
|
||||
vertexData->vertexCount = segments * (segments - 1) + 2;
|
||||
break;
|
||||
case DT_IMAGE_STARFIELD:
|
||||
vertexData->vertexCount = (segments + 1) * (segments + 1);
|
||||
break;
|
||||
};
|
||||
Ogre::HardwareVertexBufferSharedPtr vBuf = Ogre::HardwareBufferManager::getSingleton ().createVertexBuffer (vertexDecl->getVertexSize (0), vertexData->vertexCount, Ogre::HardwareBuffer::HBU_STATIC_WRITE_ONLY, false);
|
||||
Ogre::VertexBufferBinding *binding = vertexData->vertexBufferBinding;
|
||||
binding->setBinding (0, vBuf);
|
||||
|
||||
float *pVertex = static_cast<float *>(vBuf->lock (Ogre::HardwareBuffer::HBL_DISCARD));
|
||||
|
||||
// Allocate the index buffer
|
||||
switch (type) {
|
||||
case DT_SKY_DOME:
|
||||
sub->indexData->indexCount = 2 * segments * (segments - 1) * 3;
|
||||
break;
|
||||
case DT_IMAGE_STARFIELD:
|
||||
sub->indexData->indexCount = 2 * (segments - 1) * segments * 3;
|
||||
break;
|
||||
};
|
||||
sub->indexData->indexBuffer = Ogre::HardwareBufferManager::getSingleton ().createIndexBuffer (Ogre::HardwareIndexBuffer::IT_16BIT, sub->indexData->indexCount, Ogre::HardwareBuffer::HBU_STATIC_WRITE_ONLY, false);
|
||||
Ogre::HardwareIndexBufferSharedPtr iBuf = sub->indexData->indexBuffer;
|
||||
unsigned short *pIndices = static_cast<unsigned short *>(iBuf->lock (Ogre::HardwareBuffer::HBL_DISCARD));
|
||||
|
||||
// Fill the buffers
|
||||
switch (type) {
|
||||
case DT_SKY_DOME:
|
||||
fillGradientsDomeBuffers (pVertex, pIndices, segments);
|
||||
break;
|
||||
case DT_IMAGE_STARFIELD:
|
||||
fillStarfieldDomeBuffers (pVertex, pIndices, segments);
|
||||
break;
|
||||
};
|
||||
|
||||
// Close the vertex buffer
|
||||
vBuf->unlock ();
|
||||
|
||||
// Close the index buffer
|
||||
iBuf->unlock ();
|
||||
|
||||
// Finishing it...
|
||||
sub->useSharedVertices = true;
|
||||
msh->_setBounds (Ogre::AxisAlignedBox (-1, -1, -1, 1, 1, 1), false);
|
||||
msh->_setBoundingSphereRadius (1);
|
||||
msh->load ();
|
||||
|
||||
Ogre::LogManager::getSingleton ().logMessage (
|
||||
"Caelum: generateSphericDome DONE");
|
||||
}
|
||||
|
||||
void InternalUtilities::fillGradientsDomeBuffers (float *pVertex, unsigned short *pIndices, int segments)
|
||||
{
|
||||
const float deltaLatitude = Ogre::Math::PI / (float )segments;
|
||||
const float deltaLongitude = Ogre::Math::PI * 2.0 / (float )segments;
|
||||
|
||||
// Generate the rings
|
||||
for (int i = 1; i < segments; i++) {
|
||||
float r0 = Ogre::Math::Sin (Ogre::Radian (i * deltaLatitude));
|
||||
float y0 = Ogre::Math::Cos (Ogre::Radian (i * deltaLatitude));
|
||||
|
||||
for (int j = 0; j < segments; j++) {
|
||||
float x0 = r0 * Ogre::Math::Sin (Ogre::Radian (j * deltaLongitude));
|
||||
float z0 = r0 * Ogre::Math::Cos (Ogre::Radian (j * deltaLongitude));
|
||||
|
||||
*pVertex++ = x0;
|
||||
*pVertex++ = y0;
|
||||
*pVertex++ = z0;
|
||||
|
||||
*pVertex++ = -x0;
|
||||
*pVertex++ = -y0;
|
||||
*pVertex++ = -z0;
|
||||
|
||||
*pVertex++ = 0;
|
||||
*pVertex++ = 1 - y0;
|
||||
}
|
||||
}
|
||||
|
||||
// Generate the "north pole"
|
||||
*pVertex++ = 0; // Position
|
||||
*pVertex++ = 1;
|
||||
*pVertex++ = 0;
|
||||
*pVertex++ = 0; // Normal
|
||||
*pVertex++ = -1;
|
||||
*pVertex++ = 0;
|
||||
*pVertex++ = 0; // UV
|
||||
*pVertex++ = 0;
|
||||
|
||||
// Generate the "south pole"
|
||||
*pVertex++ = 0; // Position
|
||||
*pVertex++ = -1;
|
||||
*pVertex++ = 0;
|
||||
*pVertex++ = 0; // Normal
|
||||
*pVertex++ = 1;
|
||||
*pVertex++ = 0;
|
||||
*pVertex++ = 0; // UV
|
||||
*pVertex++ = 2;
|
||||
|
||||
// Generate the mid segments
|
||||
for (int i = 0; i < segments - 2; i++) {
|
||||
for (int j = 0; j < segments; j++) {
|
||||
*pIndices++ = segments * i + j;
|
||||
*pIndices++ = segments * i + (j + 1) % segments;
|
||||
*pIndices++ = segments * (i + 1) + (j + 1) % segments;
|
||||
*pIndices++ = segments * i + j;
|
||||
*pIndices++ = segments * (i + 1) + (j + 1) % segments;
|
||||
*pIndices++ = segments * (i + 1) + j;
|
||||
}
|
||||
}
|
||||
|
||||
// Generate the upper cap
|
||||
for (int i = 0; i < segments; i++) {
|
||||
*pIndices++ = segments * (segments - 1);
|
||||
*pIndices++ = (i + 1) % segments;
|
||||
*pIndices++ = i;
|
||||
}
|
||||
|
||||
// Generate the lower cap
|
||||
for (int i = 0; i < segments; i++) {
|
||||
*pIndices++ = segments * (segments - 1) + 1;
|
||||
*pIndices++ = segments * (segments - 2) + i;
|
||||
*pIndices++ = segments * (segments - 2) + (i + 1) % segments;
|
||||
}
|
||||
}
|
||||
|
||||
void InternalUtilities::fillStarfieldDomeBuffers (float *pVertex, unsigned short *pIndices, int segments)
|
||||
{
|
||||
const float deltaLatitude = Ogre::Math::PI / (float )segments;
|
||||
const float deltaLongitude = Ogre::Math::PI * 2.0 / (float )segments;
|
||||
|
||||
// Generate the rings
|
||||
for (int i = 0; i <= segments; i++) {
|
||||
float r0 = Ogre::Math::Sin (Ogre::Radian (i * deltaLatitude));
|
||||
float y0 = Ogre::Math::Cos (Ogre::Radian (i * deltaLatitude));
|
||||
|
||||
for (int j = 0; j <= segments; j++) {
|
||||
float x0 = r0 * Ogre::Math::Sin (Ogre::Radian (j * deltaLongitude));
|
||||
float z0 = r0 * Ogre::Math::Cos (Ogre::Radian (j * deltaLongitude));
|
||||
|
||||
*pVertex++ = x0;
|
||||
*pVertex++ = y0;
|
||||
*pVertex++ = z0;
|
||||
|
||||
*pVertex++ = -x0;
|
||||
*pVertex++ = -y0;
|
||||
*pVertex++ = -z0;
|
||||
|
||||
*pVertex++ = (float )j / (float )segments;
|
||||
*pVertex++ = 1 - (y0 * 0.5 + 0.5);
|
||||
}
|
||||
}
|
||||
|
||||
// Generate the mid segments
|
||||
int vRowSize = segments + 1;
|
||||
for (int i = 1; i < segments; i++) {
|
||||
for (int j = 0; j < segments; j++) {
|
||||
int baseIdx = vRowSize * i + j;
|
||||
*pIndices++ = baseIdx;
|
||||
*pIndices++ = baseIdx + 1;
|
||||
*pIndices++ = baseIdx + vRowSize + 1;
|
||||
*pIndices++ = baseIdx + 1;
|
||||
*pIndices++ = baseIdx;
|
||||
*pIndices++ = baseIdx - vRowSize;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -1,140 +0,0 @@
|
||||
/*
|
||||
This file is part of Caelum.
|
||||
See http://www.ogre3d.org/wiki/index.php/Caelum
|
||||
|
||||
Copyright (c) 2008 Caelum team. See Contributors.txt for details.
|
||||
|
||||
Caelum is free software: you can redistribute it and/or modify
|
||||
it under the terms of the GNU Lesser General Public License as published
|
||||
by the Free Software Foundation, either version 3 of the License, or
|
||||
(at your option) any later version.
|
||||
|
||||
Caelum is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
GNU Lesser General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU Lesser General Public License
|
||||
along with Caelum. If not, see <http://www.gnu.org/licenses/>.
|
||||
*/
|
||||
|
||||
#include "CaelumPrecompiled.h"
|
||||
#include "CaelumExceptions.h"
|
||||
#include "InternalUtilities.h"
|
||||
#include "Moon.h"
|
||||
#include <memory>
|
||||
|
||||
namespace Caelum
|
||||
{
|
||||
const Ogre::String Moon::MOON_MATERIAL_NAME = "Caelum/PhaseMoon";
|
||||
const Ogre::String Moon::MOON_BACKGROUND_MATERIAL_NAME = "Caelum/MoonBackground";
|
||||
|
||||
Moon::Moon (
|
||||
Ogre::SceneManager *sceneMgr,
|
||||
Ogre::SceneNode *caelumRootNode,
|
||||
const Ogre::String& moonTextureName,
|
||||
Ogre::Degree angularSize
|
||||
):
|
||||
BaseSkyLight(sceneMgr, caelumRootNode),
|
||||
mAngularSize(angularSize)
|
||||
{
|
||||
Ogre::String uniqueSuffix = "/" + InternalUtilities::pointerToString(this);
|
||||
|
||||
// Clone materials
|
||||
mMoonMaterial.reset(InternalUtilities::checkLoadMaterialClone(MOON_MATERIAL_NAME, MOON_MATERIAL_NAME + uniqueSuffix));
|
||||
mBackMaterial.reset(InternalUtilities::checkLoadMaterialClone(MOON_BACKGROUND_MATERIAL_NAME, MOON_BACKGROUND_MATERIAL_NAME + uniqueSuffix));
|
||||
|
||||
assert (!mMoonMaterial.isNull ());
|
||||
assert (mMoonMaterial->getTechnique (0));
|
||||
assert (mMoonMaterial->getTechnique (0)->getPass (0));
|
||||
assert (mMoonMaterial->getTechnique (0)->getPass( 0)->hasFragmentProgram ());
|
||||
mParams.setup(mMoonMaterial->getBestTechnique ()->getPass (0)->getFragmentProgramParameters ());
|
||||
|
||||
setMoonTexture(moonTextureName);
|
||||
|
||||
mMoonBB.reset(sceneMgr->createBillboardSet("Caelum/Moon/MoonBB" + uniqueSuffix, 1));
|
||||
mMoonBB->setMaterialName (mMoonMaterial->getName());
|
||||
mMoonBB->setCastShadows (false);
|
||||
mMoonBB->setRenderQueueGroup (CAELUM_RENDER_QUEUE_MOON);
|
||||
mMoonBB->setDefaultDimensions (1.0f, 1.0f);
|
||||
mMoonBB->createBillboard (Ogre::Vector3::ZERO);
|
||||
|
||||
mBackBB.reset(sceneMgr->createBillboardSet("Caelum/Moon/BackBB" + uniqueSuffix, 1));
|
||||
mBackBB->setMaterialName (mBackMaterial->getName());
|
||||
mBackBB->setCastShadows (false);
|
||||
mBackBB->setRenderQueueGroup (CAELUM_RENDER_QUEUE_MOON_BACKGROUND);
|
||||
mBackBB->setDefaultDimensions (1.0f, 1.0f);
|
||||
mBackBB->createBillboard (Ogre::Vector3::ZERO);
|
||||
|
||||
mNode->attachObject (mMoonBB.get());
|
||||
mNode->attachObject (mBackBB.get());
|
||||
}
|
||||
|
||||
Moon::~Moon () {
|
||||
}
|
||||
|
||||
void Moon::setBodyColour (const Ogre::ColourValue &colour) {
|
||||
BaseSkyLight::setBodyColour(colour);
|
||||
|
||||
// Set moon material colour.
|
||||
mMoonBB->getBillboard(0)->setColour(colour);
|
||||
}
|
||||
|
||||
void Moon::setMoonTexture (const Ogre::String &textureName)
|
||||
{
|
||||
// Update the moon material
|
||||
assert(mMoonMaterial->getBestTechnique ());
|
||||
assert(mMoonMaterial->getBestTechnique ()->getPass (0));
|
||||
assert(mMoonMaterial->getBestTechnique ()->getPass (0)->getTextureUnitState (0));
|
||||
mMoonMaterial->getBestTechnique ()->getPass (0)->getTextureUnitState (0)->setTextureName (textureName);
|
||||
mBackMaterial->getBestTechnique ()->getPass (0)->getTextureUnitState (0)->setTextureName (textureName);
|
||||
}
|
||||
|
||||
void Moon::setMoonTextureAngularSize(const Ogre::Degree& moonTextureAngularSize){
|
||||
mAngularSize = moonTextureAngularSize;
|
||||
}
|
||||
|
||||
void Moon::notifyCameraChanged (Ogre::Camera *cam) {
|
||||
// This calls setFarRadius
|
||||
BaseSkyLight::notifyCameraChanged(cam);
|
||||
|
||||
// Set moon position.
|
||||
Ogre::Real moonDistance = mRadius - mRadius * Ogre::Math::Tan(mAngularSize);
|
||||
mNode->setPosition(-mDirection * moonDistance);
|
||||
|
||||
// Set moon scaling in [1.0 ~ 1.2] range
|
||||
float factor = 1.2f - mBodyColour.b * 0.2f;
|
||||
float scale = factor * moonDistance * Ogre::Math::Tan(mAngularSize);
|
||||
mNode->setScale (Ogre::Vector3::UNIT_SCALE * scale);
|
||||
}
|
||||
|
||||
void Moon::Params::setup(Ogre::GpuProgramParametersSharedPtr fpParams)
|
||||
{
|
||||
this->fpParams = fpParams;
|
||||
this->phase.bind(fpParams, "phase");
|
||||
}
|
||||
|
||||
void Moon::setPhase (Ogre::Real phase) {
|
||||
mParams.phase.set(mParams.fpParams, phase);
|
||||
}
|
||||
|
||||
void Moon::setQueryFlags (uint flags) {
|
||||
mMoonBB->setQueryFlags (flags);
|
||||
mBackBB->setQueryFlags (flags);
|
||||
}
|
||||
|
||||
uint Moon::getQueryFlags () const {
|
||||
assert (mMoonBB->getQueryFlags () == mBackBB->getQueryFlags ());
|
||||
return mMoonBB->getQueryFlags ();
|
||||
}
|
||||
|
||||
void Moon::setVisibilityFlags (uint flags) {
|
||||
mMoonBB->setVisibilityFlags (flags);
|
||||
mBackBB->setVisibilityFlags (flags);
|
||||
}
|
||||
|
||||
uint Moon::getVisibilityFlags () const {
|
||||
assert (mMoonBB->getVisibilityFlags () == mBackBB->getVisibilityFlags ());
|
||||
return mMoonBB->getVisibilityFlags ();
|
||||
}
|
||||
}
|
||||
Some files were not shown because too many files have changed in this diff Show More
Loading…
Reference in New Issue