SO3Terrain.cpp

Go to the documentation of this file.

/*
-----------------------------------------------------------------------------
This source file is part of OpenSpace3D
For the latest info, see http://www.openspace3d.com
 
Copyright (c) 2012 I-maginer
 
This program 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 2 of the License, or (at your option) any later
version.
 
This program 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
this program; if not, write to the Free Software Foundation, Inc., 59 Temple
Place - Suite 330, Boston, MA 02111-1307, USA, or go to
http://www.gnu.org/copyleft/lesser.txt
 
-----------------------------------------------------------------------------
*/
 
#include "SO3Renderer/SO3Root.h"
#include "SO3SceneGraph/SO3Scene.h"
#include "SO3SceneGraph/SO3Terrain.h"
 
#include <OgreBitwise.h>
 
namespace SO3
{
 
STerrain::STerrain(SScene* parent, const std::string& resName) : SData(resName)
{
  // Init member pointers
  mScene = parent;
  mGlobals = OGRE_NEW Ogre::TerrainGlobalOptions();
  mGlobals->setMaxPixelError(8);
  //mGlobals->setRenderQueueGroup(Ogre::RENDER_QUEUE_WORLD_GEOMETRY_1);
  mResourceGroup = SO3_INTERNAL_RESOURCE_GROUP + std::string("/TERRAIN/") + std::string(resName);
  Ogre::ResourceGroupManager::getSingletonPtr()->createResourceGroup(mResourceGroup);
 
  mGlobals->setCompositeMapDistance(2000);
  mGlobals->setCompositeMapAmbient(parent->GetOgreScenePointer()->getAmbientLight());
  mGlobals->setCompositeMapDiffuse(Ogre::ColourValue(1.0f, 1.0f, 1.0f, 1.0f));
  mGlobals->setLightMapSize(256);
  mGlobals->setCastsDynamicShadows(true);
  Ogre::TerrainMaterialGenerator::Profile* matProfile = mGlobals->getDefaultMaterialGenerator()->getActiveProfile();
  //matProfile->setLightmapEnabled(false);
  //matProfile->setReceiveDynamicShadowsEnabled(enabled);
  //matProfile->setReceiveDynamicShadowsLowLod(true);
 
  mTerrain = OGRE_NEW Ogre::Terrain(mScene->GetOgreScenePointer());
  mTerrain->setResourceGroup(mResourceGroup);
}
 
STerrain::STerrain() : SData("")
{
}
 
STerrain::~STerrain()
{
  // Forbiden (private)
  if (mTerrain)
    OGRE_DELETE(mTerrain);
 
  if (mGlobals)
    OGRE_DELETE(mGlobals);
 
  Ogre::ResourceGroupManager::getSingletonPtr()->destroyResourceGroup(mResourceGroup);
}
 
SScene* STerrain::GetParentScene()
{
  return mScene;
}
 
bool STerrain::DefineHeightMap(std::string heightmap, Ogre::Real worldSize, Ogre::Real scale, Ogre::uint16 minBatchsize, Ogre::uint16 maxBatchsize)
{
  Ogre::Image img;
 
  try
  {
    img.load(heightmap, mResourceGroup);
  }
  catch(Ogre::Exception &)
  {
    return false;
  }
 
  // informations géométriques
  Ogre::Terrain::ImportData imp;
  imp.inputImage = &img;
  imp.terrainSize = img.getWidth();
  imp.worldSize = worldSize;
  imp.inputScale = scale;
  imp.minBatchSize = minBatchsize;
  imp.maxBatchSize = maxBatchsize;
 
  if (mTerrain->isLoaded())
    mTerrain->unload();
 
  if (!(Ogre::Bitwise::isPO2(imp.terrainSize - 1) && Ogre::Bitwise::isPO2(imp.minBatchSize - 1) && Ogre::Bitwise::isPO2(imp.maxBatchSize - 1)))
    return false;
 
  // textures
  imp.layerList.resize(3);
  imp.layerList[0].worldSize = 10;
  imp.layerList[0].textureNames.push_back("terraindef/grass_green-01_diffusespecular.dds");
  imp.layerList[0].textureNames.push_back("terraindef/grass_green-01_normalheight.dds");
  imp.layerList[1].worldSize = 20;
  imp.layerList[1].textureNames.push_back("terraindef/growth_weirdfungus-03_diffusespecular.dds");
  imp.layerList[1].textureNames.push_back("terraindef/growth_weirdfungus-03_normalheight.dds");
  imp.layerList[2].worldSize = 100;
  imp.layerList[2].textureNames.push_back("terraindef/dirt_grayrocky_diffusespecular.dds");
  imp.layerList[2].textureNames.push_back("terraindef/dirt_grayrocky_normalheight.dds");
 
  try
  {
    mTerrain->prepare(imp);
    mTerrain->load();
  }
  catch(Ogre::Exception &)
  {
    return false;
  }
 
  // textures blend
  Ogre::TerrainLayerBlendMap* blendMap0 = mTerrain->getLayerBlendMap(1);
  Ogre::TerrainLayerBlendMap* blendMap1 = mTerrain->getLayerBlendMap(2);
  Ogre::Real minHeight0 = 30;
  Ogre::Real fadeDist0 = 20;
  Ogre::Real minHeight1 = 25;
  Ogre::Real fadeDist1 = 5;
  float* pBlend0 = blendMap0->getBlendPointer();
  float* pBlend1 = blendMap1->getBlendPointer();
  for (Ogre::uint16 y = 0; y < mTerrain->getLayerBlendMapSize(); ++y)
  {
      for (Ogre::uint16 x = 0; x < mTerrain->getLayerBlendMapSize(); ++x)
      {
          Ogre::Real tx, ty;
 
          blendMap0->convertImageToTerrainSpace(x, y, &tx, &ty);
          Ogre::Real height = mTerrain->getHeightAtTerrainPosition(tx, ty);
          Ogre::Real val = (height - minHeight0) / fadeDist0;
          val = Ogre::Math::Clamp(val, (Ogre::Real)0, (Ogre::Real)1);
          *pBlend0++ = val;
 
          val = (height - minHeight1) / fadeDist1;
          val = Ogre::Math::Clamp(val, (Ogre::Real)0, (Ogre::Real)1);
          *pBlend1++ = val;
      }
  }
  blendMap0->dirty();
  blendMap1->dirty();
  blendMap0->update();
  blendMap1->update();
 
  mTerrain->freeTemporaryResources();
  return true;
}
 
void STerrain::UpdateLight(Ogre::ColourValue ambColor, Ogre::ColourValue sunColor, Ogre::Vector3 sunDir)
{
  mGlobals->setCompositeMapAmbient(ambColor);
  mGlobals->setCompositeMapDiffuse(sunColor);
  //mGlobals->setLightMapDirection(sunDir);
  //mTerrain->dirtyLightmap();
  //mTerrain->update();
}
 
}