Ejemplo n.º 1
0
int MyTerrain::GetSelectAreaID( Ogre::Ray ray )
{
    Ogre::TerrainGroup::RayResult result=m_pTerrainGroup->rayIntersects(ray);
    if(!result.hit)
        return -1;
    //m_pSceneMgr->getSceneNode("test")->setPosition(result.position);
    bool nosign=false;
    Ogre::Terrain* terrain = m_pTerrainGroup->getTerrain(0,0);


    int size= terrain->getLayerBlendMapSize();

    int x=result.position.x*m_EdgeImage.width()/(float)terrain->getWorldSize();
    int y=result.position.z*m_EdgeImage.height()/(float)terrain->getWorldSize();

    QRgb resultrgb=m_AreaImage.pixel(x,y);
    int gray=qGray(m_EdgeImage.pixel(x,y));
    if(gray!=255)
    {
        return -1;
    }
    else
    {
        int id=qGreen(resultrgb)*256+qBlue(resultrgb);
        if(id<65535)
            return id;
        else
            return -1;
    }
}
Ejemplo n.º 2
0
//-----------------------------------------------------------------------------------------
void CTerrainGroupEditor::_calculatesmoothingfactor(CTerrainPageEditor *handle, Ogre::Vector3 &editpos, float& avg, int& sample_count)
{
    Ogre::Rect brushrect, maprect;
    editpos.x *= (float)(mMapSize->get() - 1);
    editpos.y *= (float)(mMapSize->get() - 1);

    avg = 0.0f;
    sample_count = 0;

    if(!_getEditRect(editpos, brushrect, maprect, mMapSize->get()))
        return;

    Ogre::Terrain *terrain = static_cast<Ogre::Terrain*>(handle->getHandle());

    float *mHeightData = terrain->getHeightData();
    int mapPos;

    for(int j = maprect.top;j < maprect.bottom;j++)
    {
        mapPos = (j * mMapSize->get()) + maprect.left;

        for(int i = maprect.left;i < maprect.right;i++)
        {
            avg += mHeightData[mapPos];
            ++mapPos;
        }
    }

    sample_count = (maprect.right - maprect.left) * (maprect.bottom - maprect.top);
}
Ejemplo n.º 3
0
void MyTerrain::InitHydrax()
{
    if(Global::UseHydrax)
    {
        m_pHydrax=new Hydrax::Hydrax(m_pSceneMgr,MyGameApp::GetSingleton().GetMainCamera(),MyGameApp::GetSingleton().GetRenderWindow()->getViewport(0));

        Hydrax::Module::ProjectedGrid *mModule
            = new Hydrax::Module::ProjectedGrid(
            m_pHydrax,
            new Hydrax::Noise::Perlin(/*Generic one*/),
            Ogre::Plane(Ogre::Vector3(0,1,0), Ogre::Vector3(0,0,0)),
            Hydrax::MaterialManager::NM_VERTEX,
            Hydrax::Module::ProjectedGrid::Options(/*264 /*Generic one*/));

        m_pHydrax->setModule(static_cast<Hydrax::Module::Module*>(mModule));
        m_pHydrax->loadCfg("Hydrax.hdx");

        auto ti=m_pTerrainGroup->getTerrainIterator();
        while(ti.hasMoreElements())
        {
            Ogre::Terrain* t = ti.getNext()->instance;
            Ogre::MaterialPtr pMat = t->getMaterial();
            m_pHydrax->getMaterialManager()->addDepthTechnique(pMat->createTechnique());
        }

        m_pHydrax->create();
    }
}
Ejemplo n.º 4
0
void EmberTerrainGroup::handleResponse(const WorkQueue::Response* res, const WorkQueue* srcQ)
{
	--sLoadingTaskNum;

	LoadRequest lreq = any_cast<LoadRequest>(res->getRequest()->getData());

	if (res->succeeded()) {
		TerrainSlot* slot = lreq.slot;
		Ogre::Terrain* terrain = slot->instance;
		if (terrain) {
			terrain->setPosition(getTerrainSlotPosition(slot->x, slot->y));

			if (mAutoUpdateLod) {
				terrain->load(-1, false);
			} else {
				terrain->load(0, true);
			}

			for (int i = -1; i <= 1; ++i) {
				for (int j = -1; j <= 1; ++j) {
					if (i != 0 || j != 0) {
						connectNeighbour(slot, i, j);
					}
				}

			}
		}
	} else {
		S_LOG_FAILURE("Failed to prepare terrain at " << lreq.slot->x << ", " << lreq.slot->y << ". Error: " << res->getMessages());
		lreq.slot->freeInstance();
	}
}
Ejemplo n.º 5
0
Ogre::Vector2 MyTerrain::GetWorldPointFromImagePoint( Ogre::Vector2 point )
{
    Ogre::Vector2 v;
    Ogre::Terrain* terrain = m_pTerrainGroup->getTerrain(0,0);
    v.x=point.x*m_EdgeImage.width()/(float)terrain->getWorldSize();
    v.y=point.y*m_EdgeImage.height()/(float)terrain->getWorldSize();
    return v;
}
Ejemplo n.º 6
0
void ManipulatorTerrain::SetLayerTexture( int nLayer, int diffuseMapID )
{
	Ogre::Terrain* pTerrain = ManipulatorSystem.GetScene()->GetTerrain();
	assert(nLayer >=0 && nLayer<(int)pTerrain->getLayerCount());

	Ogre::String filename, path;
	Ogre::StringUtil::splitFilename(m_vecLayerTex[diffuseMapID], filename, path);

	SetLayerTexture(nLayer, filename);
}
Ejemplo n.º 7
0
	void TerrainProjectionMarker::FindProjectedTerrainMaterials(Array<string>& matNames)
	{
		auto& pos = GetPositionAbsolute();
		Vector3 orientedSize = Ogre::Quaternion(Ogre::Degree(-90),Ogre::Vector3::UNIT_X) * GetOrientationAbsolute() * Vector3(_halfSize.x, 0.f, _halfSize.y);

		// Check which terrain cells are occupied by marker's corners 
		// ( assume its smaller than terrain cell )
		auto map = GameWorld::GlobalWorld->GetMap();
		auto terrainGrid = GameWorld::GlobalWorld->GetMap()->GetTerrain()->GetTerrainGrid();
		Ogre::Terrain* terrain;
		uint32 xMin = (uint32)std::max(0.f, std::min(pos.x - orientedSize.x, pos.x + orientedSize.x));
		uint32 xMax = (uint32)std::min(map->GetTerrainSize().x, std::max(pos.x - orientedSize.x, pos.x + orientedSize.x));
		uint32 zMin = (uint32)std::max(0.f, std::max(pos.z - orientedSize.y, pos.z + orientedSize.y));
		uint32 zMax = (uint32)std::min(map->GetTerrainSize().y, std::max(pos.z - orientedSize.z, pos.z + orientedSize.z));

		// Check minimal corner terrain
		terrain = terrainGrid->GetTerrainFromPosition(xMin, zMin);
		if( _lastProjectedTerrains[0] != terrain )
		{
			// Terrain cell changed ( or its 1st call )
			_lastProjectedTerrains[0] = terrain;
			matNames.push_back(terrain->getMaterialName());
		}
		// Check maximal corner terrain
		terrain = terrainGrid->GetTerrainFromPosition(xMax, zMax);
		if( _lastProjectedTerrains[0] != terrain )
		{
			// Marker on multiple cells
			if( _lastProjectedTerrains[3] != terrain )
			{
				_lastProjectedTerrains[3] = terrain;
				matNames.push_back(terrain->getMaterialName());
			}
			terrain = terrainGrid->GetTerrainFromPosition(xMax, zMin);
			if( _lastProjectedTerrains[1] != terrain )
			{
				_lastProjectedTerrains[1] = terrain;
				matNames.push_back(terrain->getMaterialName());
			}
			terrain = terrainGrid->GetTerrainFromPosition(xMin, zMax);
			if( _lastProjectedTerrains[2] != terrain )
			{
				_lastProjectedTerrains[2] = terrain;
				matNames.push_back(terrain->getMaterialName());
			}
		}
		else
		{
			// Max and min corner falls into same cell, so we'll have only one terrain
			_lastProjectedTerrains[1] = terrain;
			_lastProjectedTerrains[2] = terrain;
			_lastProjectedTerrains[3] = terrain;
		}
	}
Ejemplo n.º 8
0
void ManipulatorTerrain::SetLayerTexture( int nLayer, const std::string& diffuseMapName )
{
	Ogre::Terrain* pTerrain = ManipulatorSystem.GetScene()->GetTerrain();
	assert(nLayer >=0 && nLayer<(int)pTerrain->getLayerCount());

	Ogre::String name = diffuseMapName.substr(0, diffuseMapName.find("diffuse"));

	//diffuse map
	pTerrain->setLayerTextureName(nLayer, 0, name + "diffusespecular.dds");
	//normal map
	pTerrain->setLayerTextureName(nLayer, 1, name + "normalheight.dds");
}
Ejemplo n.º 9
0
TerrainGenerator::TerrainGenerator(Ogre::SceneManager *scene) 
  : terrains_imported_(false),
    scene_manager_(scene)
{
  /*mCamera->setPosition(Ogre::Vector3(1683, 50, 2116));
  mCamera->lookAt(Ogre::Vector3(1963, 50, 1660));
  mCamera->setNearClipDistance(0.1);
  mCamera->setFarClipDistance(50000);*/

  Ogre::MaterialManager::getSingleton().setDefaultTextureFiltering(Ogre::TFO_ANISOTROPIC);
  Ogre::MaterialManager::getSingleton().setDefaultAnisotropy(7);

  Ogre::Light* light = scene_manager_->createLight("tstLight");
  light->setDiffuseColour(Ogre::ColourValue::White);
  light->setSpecularColour(Ogre::ColourValue(1, 1, 1));

  scene_manager_->setAmbientLight(Ogre::ColourValue(0.9, 0.9, 0.9));
  light->setAttenuation(100000, 1, 1, 1);
  terrain_globals_ = OGRE_NEW Ogre::TerrainGlobalOptions();

  terrain_group_ = OGRE_NEW Ogre::TerrainGroup(scene_manager_, Ogre::Terrain::ALIGN_X_Z, 513, 12000.0f);
  terrain_group_->setFilenameConvention(Ogre::String("BasicTutorial3Terrain"), Ogre::String("dat"));
  terrain_group_->setOrigin(Ogre::Vector3::ZERO);



  configureTerrainDefaults(light);

  for (long x = 0; x <= 0; ++x)
      for (long y = 0; y <= 0; ++y)
          defineTerrain(x, y);

  // sync load since we want everything in place when we start
  terrain_group_->loadAllTerrains(true);

  if (terrains_imported_)
  {
      Ogre::TerrainGroup::TerrainIterator ti = terrain_group_->getTerrainIterator();
      while(ti.hasMoreElements())
      {
          Ogre::Terrain* t = ti.getNext()->instance;
          t->setPosition(Ogre::Vector3(0, -315, 0));
          initBlendMaps(t);
      }
  }

  terrain_group_->freeTemporaryResources();
  
  scene_manager_->setSkyDome(true, "Examples/CloudySky", 5, 8);

  //Optional skybox
  //Graphics::instance()->getSceneManager()->setSkyDome(true, "Examples/CloudySky", 5, 8);
}
Ejemplo n.º 10
0
//-----------------------------------------------------------------------------------------
void CTerrainGroupEditor::_deform(CTerrainPageEditor *handle, Ogre::Vector3 &editpos, float timePassed)
{
    Ogre::Rect brushrect, maprect;
    editpos.x *= (float)(mMapSize->get() - 1);
    editpos.y *= (float)(mMapSize->get() - 1);

    if(!_getEditRect(editpos, brushrect, maprect, mMapSize->get()))
        return;

    handle->_notifyModification(-1, maprect);

    Ogre::Terrain *terrain = static_cast<Ogre::Terrain*>(handle->getHandle());

    float *mHeightData = terrain->getHeightData();

    if(mEditDirection)
        timePassed *= -1.0f;

    float mRatio = (float)BRUSH_DATA_SIZE / (float)mBrushSize;
    float brushPos;
    int mapPos;
    for(int j = maprect.top;j < maprect.bottom;j++)
    {
        brushPos = (brushrect.top + (int)((j - maprect.top) * mRatio)) * BRUSH_DATA_SIZE;
        brushPos += brushrect.left;
        mapPos = (j * mMapSize->get()) + maprect.left;

        for(int i = maprect.left;i < maprect.right;i++)
        {
            assert(mapPos < (mMapSize->get() * mMapSize->get()) && mapPos >= 0);
            assert((int)brushPos < (BRUSH_DATA_SIZE * BRUSH_DATA_SIZE) && (int)brushPos >= 0);

            float val = mHeightData[mapPos] + (mBrushData[(int)brushPos] * mBrushIntensity * timePassed);

            assert(val < 10000.0f);
            assert(val > -10000.0f);

            mHeightData[mapPos] = val;
            ++mapPos;

            brushPos += mRatio;
        }
    }

    terrain->dirtyRect(maprect);
}
Ejemplo n.º 11
0
void MyTerrain::UpdateTexture()
{
    Ogre::Terrain* terrain = m_pTerrainGroup->getTerrain(0,0);
    int size= terrain->getLayerBlendMapSize();
    Ogre::TerrainLayerBlendMap* blendMap3 = terrain->getLayerBlendMap(4);
    float* pBlend3 = blendMap3->getBlendPointer();

    for (Ogre::uint16 y = 0; y < terrain->getLayerBlendMapSize(); ++y)
    {
        for (Ogre::uint16 x = 0; x < terrain->getLayerBlendMapSize(); ++x)
        {
            float tx, ty;

            blendMap3->convertImageToTerrainSpace(x, y, &tx, &ty);
            QRgb rgb=m_AreaImage.pixel(x*m_AreaImage.width()/size,y*m_AreaImage.height()/size);
            int gray=qGray(m_EdgeImage.pixel(x*m_AreaImage.width()/size,y*m_AreaImage.height()/size));
            int r=qRed(rgb);
            int g=qGreen(rgb);
            int b=qBlue(rgb);
            int id=g*256+b;
            if(gray==255&&rgb!=qRgb(255,255,255))
            {
                if(m_AreaVector[id]->m_bHighLight)
                {
                    *pBlend3=0.2;
                }
                else
                {
                    *pBlend3=0;
                }
            }
            else
            {
                *pBlend3=0;
            }
            pBlend3++;


        }
    }
    blendMap3->dirty();
    blendMap3->update();
}
Ejemplo n.º 12
0
void Scene::setup(Sim* sim) {
	mSim = sim;
	mSim->scene = this;

	// Lighting and sky
	mSceneMgr->setAmbientLight(Ogre::ColourValue(0.4, 0.4, 0.4));

	Ogre::Vector3 lightDir(0.55, -0.3f, 0.75);
	lightDir.normalise();

	sun = mSceneMgr->createLight("SunLight");
	sun->setType(Ogre::Light::LT_DIRECTIONAL);
	sun->setDirection(lightDir);
	sun->setDiffuseColour(Ogre::ColourValue::White);
	sun->setSpecularColour(Ogre::ColourValue(0.4, 0.4, 0.4));

	mSceneMgr->setSkyDome(true, "CloudySky");

	// Terrain
	mTerrainGlobals = OGRE_NEW Ogre::TerrainGlobalOptions();
	mTerrainGroup = OGRE_NEW Ogre::TerrainGroup(mSceneMgr, Ogre::Terrain::ALIGN_X_Z,
												terrSize, worldSize);

	configureTerrainDefaults();
	defineTerrain();

	mTerrainGroup->loadAllTerrains(true);
	Ogre::TerrainGroup::TerrainIterator ti = mTerrainGroup->getTerrainIterator();
	while (ti.hasMoreElements()) {
		Ogre::Terrain* t = ti.getNext()->instance;
		t->setVisibilityFlags(RV_Terrain);
	}
	mTerrainGroup->freeTemporaryResources();

	createBulletTerrain();

	// Road
//	setupRoad();

	// Objects
	setupObjects();
}
Ejemplo n.º 13
0
void TerrainManager::CreatePhysicsShape(void)
{
    Ogre::TerrainGroup::TerrainIterator ti = mTerrainGroup->getTerrainIterator();
    while (ti.hasMoreElements())
    {
        Ogre::Terrain *t = ti.getNext()->instance;
        LoadTerrainGeometry(t->getMaterialName(), t->getHeightData(),
                            t->getSize(), t->getWorldSize(), t->getMinHeight(), t->getMaxHeight(), t->getPosition());
    }
}
Ejemplo n.º 14
0
void Scene::createBulletTerrain() {
	Ogre::Terrain* baseTerrain = mTerrainGroup->getTerrain(0, 0);
	btHeightfieldTerrainShape* hfShape = new btHeightfieldTerrainShape(
			baseTerrain->getSize(), baseTerrain->getSize(), baseTerrain->getHeightData(), 1, 0, 0,
			2, PHY_FLOAT, false);
	// Min and max height were set to 0 to force the terrain to be completely flat
	hfShape->setUseDiamondSubdivision(true);

	// This scale is based on the tutorial, but it may not be true...
	float metersBetweenVerts = baseTerrain->getWorldSize() / (baseTerrain->getSize() - 1);
	btVector3 scale(metersBetweenVerts, metersBetweenVerts, 1);
	hfShape->setLocalScaling(scale);

	hfShape->setUserPointer((void*) SU_Terrain);

	btCollisionObject* colObj = new btCollisionObject();
	colObj->setCollisionShape(hfShape);
	colObj->setFriction(0.9); colObj->setRestitution(0.0);
	colObj->setCollisionFlags(colObj->getCollisionFlags() |
							  btCollisionObject::CF_STATIC_OBJECT |
							  btCollisionObject::CF_DISABLE_VISUALIZE_OBJECT);
	mSim->getCollisionWorld()->getDynamicsWorld()->addCollisionObject(colObj);
	mSim->getCollisionWorld()->addShape(hfShape);

	// Border planes
	const float px[4] = {-1, 1, 0, 0};
	const float py[4] = { 0, 0,-1, 1};
	for (int i = 0; i < 4; ++i) {
		btVector3 vpl(px[i], py[i], 0);
		btCollisionShape* shp = new btStaticPlaneShape(vpl, 0);
		shp->setUserPointer((void*) SU_Border);

		btTransform tr;  tr.setIdentity();
		tr.setOrigin(vpl * -0.5 * worldSize);

		btCollisionObject* col = new btCollisionObject();
		col->setCollisionShape(shp);
		col->setWorldTransform(tr);
		col->setFriction(0.3);   //+
		col->setRestitution(0.0);
		col->setCollisionFlags(col->getCollisionFlags() |
							   btCollisionObject::CF_STATIC_OBJECT |
							   btCollisionObject::CF_DISABLE_VISUALIZE_OBJECT);

		mSim->getCollisionWorld()->getDynamicsWorld()->addCollisionObject(col);
		mSim->getCollisionWorld()->addShape(shp);
	}
}
Ejemplo n.º 15
0
//-----------------------------------------------------------------------------------------
void CTerrainGroupEditor::_splat(CTerrainPageEditor *handle, Ogre::Vector3 &editpos, float timePassed)
{
    Ogre::Rect brushrect, maprect;

    Ogre::Terrain *terrain = static_cast<Ogre::Terrain*>(handle->getHandle());

    int mBlendMapSize = terrain->getLayerBlendMapSize();
    editpos.x *= (float)mBlendMapSize;
    editpos.y = (1.0f - editpos.y) * (float)mBlendMapSize;
    if(!_getEditRect(editpos, brushrect, maprect, mBlendMapSize))
        return;

    int mLayer = 0;

    mLayer = handle->_getLayerID(mTextureDiffuse, mTextureNormal, mEditDirection);

    if(mLayer < 1)
        return;

    handle->_notifyModification(mLayer, maprect);

    int mLayerMax = terrain->getLayerCount();
    Ogre::TerrainLayerBlendMap *mBlendMaps[128];
    float *mBlendDatas[128];

    Ogre::TerrainLayerBlendMap *mCurrentBlendMap = terrain->getLayerBlendMap(mLayer);
    float *mCurrentBlendData = mCurrentBlendMap->getBlendPointer();

    for(int l = mLayer;l < mLayerMax;l++)
    {
        mBlendMaps[l] = terrain->getLayerBlendMap(l);
        mBlendDatas[l] = mBlendMaps[l]->getBlendPointer();
    }

    float mRatio = (float)BRUSH_DATA_SIZE / (float)mBrushSize;
    float brushPos;
    int mapPos;

    int right = brushrect.right;
    brushrect.right = BRUSH_DATA_SIZE - brushrect.left;
    brushrect.left = BRUSH_DATA_SIZE - right;

    float factor = mBrushIntensity * timePassed * 0.2f;
    if(!mEditDirection)
    {
        int u;
        float sum;

        for(int j = maprect.top;j < maprect.bottom;j++)
        {
            brushPos = (brushrect.top + (int)((j - maprect.top) * mRatio)) * BRUSH_DATA_SIZE;
            brushPos += brushrect.right;

            mapPos = (j * mBlendMapSize) + maprect.left;

            for(int i = maprect.left;i < maprect.right;i++)
            {
                brushPos -= mRatio;

                assert(mapPos < (mBlendMapSize * mBlendMapSize) && mapPos >= 0);
                assert((int)brushPos < (BRUSH_DATA_SIZE * BRUSH_DATA_SIZE) && (int)brushPos >= 0);

                sum = 0.0f;

                for(u = mLayer + 1;u < mLayerMax;u++)
                    sum += mBlendDatas[u][mapPos];

                float val = mCurrentBlendData[mapPos] + (mBrushData[(int)brushPos] * factor);
                sum += val;

                if(sum > 1.0f)
                {
                    float normfactor = 1.0f / (float)sum;
                    mCurrentBlendData[mapPos] = val * normfactor;
                    for(u = mLayer + 1;u < mLayerMax;u++)
                        mBlendDatas[u][mapPos] *= normfactor;
                }
                else
                    mCurrentBlendData[mapPos] = val;

                ++mapPos;
            }
        }
        for(u = mLayer;u < mLayerMax;u++)
        {
            mBlendMaps[u]->dirtyRect(maprect);
            mBlendMaps[u]->update();
        }
    }
    else
    {
        for(int j = maprect.top;j < maprect.bottom;j++)
        {
            brushPos = (brushrect.top + (int)((j - maprect.top) * mRatio)) * BRUSH_DATA_SIZE;
            brushPos += brushrect.right;

            mapPos = (j * mBlendMapSize) + maprect.left;

            for(int i = maprect.left;i < maprect.right;i++)
            {
                brushPos -= mRatio;

                assert(mapPos < (mBlendMapSize * mBlendMapSize) && mapPos >= 0);
                assert((int)brushPos < (BRUSH_DATA_SIZE * BRUSH_DATA_SIZE) && (int)brushPos >= 0);

                float val = mCurrentBlendData[mapPos] - (mBrushData[(int)brushPos] * factor);

                if(val < 0.0f)
                    val = 0.0f;

                mCurrentBlendData[mapPos] = val;
                ++mapPos;
            }
        }
        mCurrentBlendMap->dirtyRect(maprect);
        mCurrentBlendMap->update();
    }
}
Ejemplo n.º 16
0
CoiHandle terrain_get_layer_blend_map(CoiHandle terrain_handle, int layer_index)
{
  Ogre::Terrain* terrain = reinterpret_cast<Ogre::Terrain*>(terrain_handle);
  return terrain->getLayerBlendMap(layer_index);
}
Ejemplo n.º 17
0
//-----------------------------------------------------------------------------------------
bool CTerrainGroupEditor::update(float timePassed)
{
    if(mEditActive && mDecalFrustum->getVisible())
    {
        mEditDirection = CViewportEditor::mViewKeyboard[CViewportEditor::mSpecial.SPK_REVERSE_UPDATE];

        Ogre::Vector3 cursorpos = mDecalNode->getPosition();
        Ogre::Terrain *terrain;
        Ogre::Vector3 editpos;

        Ogre::TerrainGroup::TerrainList terrainList;
        Ogre::Real halfBrushSizeWorldSpace = (Ogre::Real)(mWorldSize->get() * mBrushSize) / (Ogre::Real)(mMapSize->get()) / 2.0f;
        Ogre::Sphere sphere(cursorpos, halfBrushSizeWorldSpace);
        mHandle->sphereIntersects(sphere, &terrainList);

        mModificationRect.merge(Ogre::Rect(cursorpos.x - halfBrushSizeWorldSpace, cursorpos.z - halfBrushSizeWorldSpace, cursorpos.x + halfBrushSizeWorldSpace, cursorpos.z + halfBrushSizeWorldSpace));

        bool groupUpdateNeeded = false;

        float avg_total = 0.0f;
        float sample_count_total = 0;

        if(mEditMode == EM_SMOOTH)
        {
            for (Ogre::TerrainGroup::TerrainList::iterator ti = terrainList.begin(); ti != terrainList.end(); ++ti)
            {
                terrain = *ti;
                terrain->getTerrainPosition(cursorpos, &editpos);

                CTerrainPageEditor *terED = 0;

                for(NameObjectPairList::iterator it = mChildren.begin(); it != mChildren.end();it++)
                {
                    if(it->second->getHandle() == (void*)terrain)
                    {
                        terED = static_cast<CTerrainPageEditor*>(it->second);
                        break;
                    }
                }

                float avg = 0.0f;
                int sample_count = 0;
                _calculatesmoothingfactor(terED, editpos, avg, sample_count);

                avg_total += avg;
                sample_count_total += sample_count;
            }
        }

        for (Ogre::TerrainGroup::TerrainList::iterator ti = terrainList.begin(); ti != terrainList.end(); ++ti)
        {
            terrain = *ti;
            terrain->getTerrainPosition(cursorpos, &editpos);

            CTerrainPageEditor *terED = 0;

            for(NameObjectPairList::iterator it = mChildren.begin(); it != mChildren.end();it++)
            {
                if(it->second->getHandle() == (void*)terrain)
                {
                    terED = static_cast<CTerrainPageEditor*>(it->second);
                    break;
                }
            }

            if(mEditMode == EM_DEFORM)
            {
                _deform(terED, editpos, timePassed);
                groupUpdateNeeded |= true;
            }
            else if(mEditMode == EM_SMOOTH)
            {
                if(sample_count_total)
                {
                    _smooth(terED, editpos, avg_total / (float)sample_count_total, timePassed);
                    groupUpdateNeeded |= true;
                }
            }
            else if(mEditMode == EM_SPLAT)
                _splat(terED, editpos, timePassed);
            else if(mEditMode == EM_PAINT)
                _paint(terED, editpos, timePassed);
            else if(mEditMode == EM_SPLATGRASS)
                _splatGrass(terED, editpos, timePassed);
        }

        if(groupUpdateNeeded)
            mHandle->update();

        mOgitorsRoot->SetSceneModified(true);
    }

    if(mPGHandle)
        mPGHandle->update();

    return false;
}
Ejemplo n.º 18
0
//-----------------------------------------------------------------------------------------
void CTerrainGroupEditor::_paint(CTerrainPageEditor *handle, Ogre::Vector3 &editpos, float timePassed)
{
    Ogre::Rect brushrect, maprect;
    int ColourMapSize = mColourMapTextureSize->get();
    editpos.x *= (float)ColourMapSize;
    editpos.y = (1.0f - editpos.y) * (float)ColourMapSize;
    if(!_getEditRect(editpos, brushrect, maprect, ColourMapSize))
        return;

    handle->_notifyModification(0, maprect);

    Ogre::Terrain *terrain = static_cast<Ogre::Terrain*>(handle->getHandle());

    float mRatio = (float)BRUSH_DATA_SIZE / (float)mBrushSize;
    float brushPos;
    int mapPos;

    int buffersize = terrain->getGlobalColourMap()->getBuffer()->getSizeInBytes();
    int spacing = buffersize / (ColourMapSize * ColourMapSize);
    unsigned char *data = (unsigned char *)terrain->getGlobalColourMap()->getBuffer()->lock(0,  buffersize, Ogre::HardwareBuffer::HBL_NORMAL);
    Ogre::PixelFormat pf = terrain->getGlobalColourMap()->getBuffer()->getFormat();
    Ogre::ColourValue colVal;

    int right = brushrect.right;
    brushrect.right = BRUSH_DATA_SIZE - brushrect.left;
    brushrect.left = BRUSH_DATA_SIZE - right;

    float factor = std::min(mBrushIntensity * timePassed * 0.2f, 1.0f);
    float bfactor;
    if(!mEditDirection)
    {
        for(int j = maprect.top;j < maprect.bottom;j++)
        {
            brushPos = (brushrect.top + (int)((j - maprect.top) * mRatio)) * BRUSH_DATA_SIZE;
            brushPos += brushrect.right;

            mapPos = (j * ColourMapSize) + maprect.left;

            for(int i = maprect.left;i < maprect.right;i++)
            {
                brushPos -= mRatio;

                assert(mapPos < (ColourMapSize * ColourMapSize) && mapPos >= 0);
                assert((int)brushPos < (BRUSH_DATA_SIZE * BRUSH_DATA_SIZE) && (int)brushPos >= 0);

                bfactor = mBrushData[(int)brushPos] * factor;
                Ogre::PixelUtil::unpackColour(&colVal, pf, (void*)&data[mapPos * spacing]);
                colVal.r = colVal.r + ((mColour.r - colVal.r) * bfactor);
                colVal.g = colVal.g + ((mColour.g - colVal.g) * bfactor);
                colVal.b = colVal.b + ((mColour.b - colVal.b) * bfactor);
                Ogre::PixelUtil::packColour(colVal, pf, (void*)&data[mapPos * spacing]);

                ++mapPos;
            }
        }
    }
    else
    {
        for(int j = maprect.top;j < maprect.bottom;j++)
        {
            brushPos = (brushrect.top + (int)((j - maprect.top) * mRatio)) * BRUSH_DATA_SIZE;
            brushPos += brushrect.right;

            mapPos = (j * ColourMapSize) + maprect.left;

            for(int i = maprect.left;i < maprect.right;i++)
            {
                brushPos -= mRatio;

                assert(mapPos < (ColourMapSize * ColourMapSize) && mapPos >= 0);
                assert((int)brushPos < (BRUSH_DATA_SIZE * BRUSH_DATA_SIZE) && (int)brushPos >= 0);

                bfactor = mBrushData[(int)brushPos] * factor;
                Ogre::PixelUtil::unpackColour(&colVal, pf, (void*)&data[mapPos * spacing]);
                colVal.r = colVal.r + ((1.0f - colVal.r) * bfactor);
                colVal.g = colVal.g + ((1.0f - colVal.g) * bfactor);
                colVal.b = colVal.b + ((1.0f - colVal.b) * bfactor);
                Ogre::PixelUtil::packColour(colVal, pf, (void*)&data[mapPos * spacing]);

                ++mapPos;
            }
        }
    }
    terrain->getGlobalColourMap()->getBuffer()->unlock();
}
Ejemplo n.º 19
0
//-----------------------------------------------------------------------------------------
void CTerrainGroupEditor::_splat(CTerrainPageEditor *handle, Ogre::Vector3 &editpos, float timePassed)
{
    Ogre::Rect brushrect, maprect;

    Ogre::Terrain *terrain = static_cast<Ogre::Terrain*>(handle->getHandle());

    int mBlendMapSize = terrain->getLayerBlendMapSize();
    editpos.x *= (float)mBlendMapSize;
    editpos.y = (1.0f - editpos.y) * (float)mBlendMapSize;
    if(!_getEditRect(editpos, brushrect, maprect, mBlendMapSize))
        return;

    int mLayer = 0;

    mLayer = handle->_getLayerID(mTextureDiffuse, mTextureNormal, mEditDirection);

    if(mLayer == -1)
    {
        Ogre::String msg = handle->getName() + " already has the maximum number of supported texture layers.";
        mSystem->DisplayMessageDialog(OTR(msg), DLGTYPE_OK);
        return;
    }
    else if(mLayer == 0)
    {
        Ogre::TerrainLayerBlendMap *mBlendMaps[128];
        float *mBlendDatas[128];
        int mLayerMax = terrain->getLayerCount();

        for(int l = 1;l < mLayerMax;l++)
        {
            mBlendMaps[l] = terrain->getLayerBlendMap(l);
            mBlendDatas[l] = mBlendMaps[l]->getBlendPointer();
        }

        float maxVal;
        int u;
        int num;

        for(u = mLayerMax-1;u > 0;u--)
        {
            mLayer = u;
            maxVal = 0.0f;

            for(int j = maprect.top;j < maprect.bottom;j++)
            {
                int mapPos = (j * mBlendMapSize) + maprect.left;

                for(int i = maprect.left;i < maprect.right;i++)
                {
                    maxVal += mBlendDatas[u][mapPos];
                }
            }

            num = (maprect.top*mBlendMapSize);
            num = (num+maprect.right)-(num+maprect.left);
            if (maxVal > num)
                break;
        }

        if (mLayer == 0)
            return;

        mEditDirection = true;
    }

    handle->_notifyModification(mLayer, maprect);

    int mLayerMax = terrain->getLayerCount();
    Ogre::TerrainLayerBlendMap *mBlendMaps[128];
    float *mBlendDatas[128];

    Ogre::TerrainLayerBlendMap *mCurrentBlendMap = terrain->getLayerBlendMap(mLayer);
    float *mCurrentBlendData = mCurrentBlendMap->getBlendPointer();

    for(int l = mLayer;l < mLayerMax;l++)
    {
        mBlendMaps[l] = terrain->getLayerBlendMap(l);
        mBlendDatas[l] = mBlendMaps[l]->getBlendPointer();
    }

    float mRatio = (float)BRUSH_DATA_SIZE / (float)mBrushSize;
    float brushPos;
    int mapPos;

    int right = brushrect.right;
    brushrect.right = BRUSH_DATA_SIZE - brushrect.left;
    brushrect.left = BRUSH_DATA_SIZE - right;

    float factor = mBrushIntensity * timePassed * 0.2f;
    if(!mEditDirection)
    {
        int u;
        float sum;

        for(int j = maprect.top;j < maprect.bottom;j++)
        {
            brushPos = (brushrect.top + (int)((j - maprect.top) * mRatio)) * BRUSH_DATA_SIZE;
            brushPos += brushrect.right;

            mapPos = (j * mBlendMapSize) + maprect.left;

            for(int i = maprect.left;i < maprect.right;i++)
            {
                brushPos -= mRatio;

                assert(mapPos < (mBlendMapSize * mBlendMapSize) && mapPos >= 0);
                assert((int)brushPos < (BRUSH_DATA_SIZE * BRUSH_DATA_SIZE) && (int)brushPos >= 0);

                sum = 0.0f;

                for(u = mLayer + 1;u < mLayerMax;u++)
                    sum += mBlendDatas[u][mapPos];

                float val = mCurrentBlendData[mapPos] + (mBrushData[(int)brushPos] * factor);
                sum += val;

                if(sum > 1.0f)
                {
                    float normfactor = 1.0f / (float)sum;
                    mCurrentBlendData[mapPos] = val * normfactor;
                    for(u = mLayer + 1;u < mLayerMax;u++)
                        mBlendDatas[u][mapPos] *= normfactor;
                }
                else
                    mCurrentBlendData[mapPos] = val;

                ++mapPos;
            }
        }
        for(u = mLayer;u < mLayerMax;u++)
        {
            mBlendMaps[u]->dirtyRect(maprect);
            mBlendMaps[u]->update();
        }
    }
    else
    {
        for(int j = maprect.top;j < maprect.bottom;j++)
        {
            brushPos = (brushrect.top + (int)((j - maprect.top) * mRatio)) * BRUSH_DATA_SIZE;
            brushPos += brushrect.right;

            mapPos = (j * mBlendMapSize) + maprect.left;

            for(int i = maprect.left;i < maprect.right;i++)
            {
                brushPos -= mRatio;

                assert(mapPos < (mBlendMapSize * mBlendMapSize) && mapPos >= 0);
                assert((int)brushPos < (BRUSH_DATA_SIZE * BRUSH_DATA_SIZE) && (int)brushPos >= 0);

                float val = mCurrentBlendData[mapPos] - (mBrushData[(int)brushPos] * factor);

                if(val < 0.0f)
                    val = 0.0f;

                mCurrentBlendData[mapPos] = val;
                ++mapPos;
            }
        }
        mCurrentBlendMap->dirtyRect(maprect);
        mCurrentBlendMap->update();
    }
}
Ejemplo n.º 20
0
float terrain_get_height_at_terrain_position(CoiHandle terrain_handle, float x, float y)
{
  Ogre::Terrain* terrain = reinterpret_cast<Ogre::Terrain*>(terrain_handle);
  return terrain->getHeightAtTerrainPosition(x, y);
}
Ejemplo n.º 21
0
int _tmain(int argc, _TCHAR* argv[])
{
	// ------------------------- Check for command line argument -------------------------------------------

	if (! argv[1])
	{
		printf("\n");
		printf("Missing argument.\nExample: \"Converter.exe job1.cfg\"");		
		return 0;	
	}

	// ------------------------- Basic Ogre Engine initialization -------------------------------------------

	Ogre::Root* root = new Ogre::Root;	
	Ogre::RenderSystem* rendersys = root->getRenderSystemByName("Direct3D9 Rendering Subsystem");
	
	rendersys->setConfigOption("Full Screen", "No");
	rendersys->setConfigOption("Video Mode", "800 x 600 @ 32-bit colour");
	
	root->setRenderSystem(rendersys);		
	
	Ogre::ResourceGroupManager::getSingleton().addResourceLocation("resource", "FileSystem", "General");
	Ogre::ResourceGroupManager::getSingleton().initialiseAllResourceGroups();

	root->initialise(false);

	Ogre::RenderWindow* window = root->createRenderWindow("RAW2OGT", 800, 600, false);		
	Ogre::SceneManager* scenemgr = root->createSceneManager(Ogre::SceneType::ST_GENERIC);
	Ogre::Camera* camera = scenemgr->createCamera("camera");
	Ogre::Viewport* viewport = window->addViewport(camera);
	/*Ogre::Vector3 lightdir(0, -0.3, 0.75);
	lightdir.normalise();

	Ogre::Light* l = scenemgr->createLight("tstLight");
	l->setType(Ogre::Light::LT_DIRECTIONAL);
	l->setDirection(lightdir);
	l->setDiffuseColour(Ogre::ColourValue(1.0, 1.0, 1.0));
	l->setSpecularColour(Ogre::ColourValue(0.4, 0.4, 0.4));*/

	scenemgr->setAmbientLight(Ogre::ColourValue(0.7, 0.7, 0.7));
	
	// --------------------------------- Start convert ----------------------------------------------------

	// Load job config
	Ogre::ConfigFile* terrainconfig = OGRE_NEW Ogre::ConfigFile();
	terrainconfig->loadDirect(argv[1]);
		
	// Load info from [general] block
	Ogre::String heightmapfile = terrainconfig->getSetting("heightmap", "general");
	Ogre::Real heightmapscale = Ogre::StringConverter::parseReal(terrainconfig->getSetting("heightmapscale", "general"));
	Ogre::Real heightmapoffset = Ogre::StringConverter::parseReal(terrainconfig->getSetting("heightmapoffset", "general"));
	Ogre::uint16 terrainsize = Ogre::StringConverter::parseUnsignedInt(terrainconfig->getSetting("terrainsize", "general"));
	Ogre::Real worldsize = Ogre::StringConverter::parseReal(terrainconfig->getSetting("worldsize", "general"));
	Ogre::uint16 layercount = Ogre::StringConverter::parseUnsignedInt(terrainconfig->getSetting("layercount", "general"));

	// initialise stream to heightmapfile
	Ogre::DataStreamPtr stream = Ogre::ResourceGroupManager::getSingleton().openResource(heightmapfile, "General");
	size_t size = stream.get()->size();
		
	// verify size
	if(size != terrainsize * terrainsize * 4)
		OGRE_EXCEPT( Ogre::Exception::ERR_INTERNAL_ERROR, "Size of stream does not match terrainsize!", "TerrainPage" );
					
	// load to buffer
	float* buffer = OGRE_ALLOC_T(float, size, Ogre::MEMCATEGORY_GENERAL);
	stream->read(buffer, size);

	// apply scale and offset 
	for(int i=0;i<terrainsize*terrainsize;i++)
	{
		buffer[i]  = (buffer[i] + heightmapoffset) * heightmapscale;
	}

	// Terrain initialization
	Ogre::TerrainGlobalOptions* terrainglobals = OGRE_NEW Ogre::TerrainGlobalOptions();
	terrainglobals->setMaxPixelError(1);
	//terrainglobals->setCompositeMapDistance(30000);
	//terrainglobals->setLightMapDirection(lightdir);
    //terrainglobals->setCompositeMapAmbient(scenemgr->getAmbientLight());
    //terrainglobals->setCompositeMapDiffuse(l->getDiffuseColour());
	
	Ogre::TerrainMaterialGeneratorA::SM2Profile* pMatProfile = 
      static_cast<Ogre::TerrainMaterialGeneratorA::SM2Profile*>(terrainglobals->getDefaultMaterialGenerator()->getActiveProfile());
	
	pMatProfile->setLightmapEnabled(false);
	pMatProfile->setCompositeMapEnabled(false);
	
	Ogre::TerrainGroup* terraingroup = OGRE_NEW Ogre::TerrainGroup(scenemgr, Ogre::Terrain::ALIGN_X_Z, terrainsize, worldsize);
    terraingroup->setFilenameConvention(Ogre::String("terrain"), Ogre::String("ogt"));
    terraingroup->setOrigin(Ogre::Vector3::ZERO);
		
	Ogre::Terrain* terrain = OGRE_NEW Ogre::Terrain(scenemgr);

	// terrainsettings							
	Ogre::Terrain::ImportData& imp = terraingroup->getDefaultImportSettings();	
	imp.terrainSize = terrainsize;
	imp.worldSize = worldsize;
	imp.minBatchSize = 33;
	imp.maxBatchSize = 65;

	// use float RAW heightmap as input
	imp.inputFloat = buffer;
	
	// process texture layers
	imp.layerList.resize(layercount);
	Ogre::StringVector blendmaps(layercount);
	for(int i=0;i<layercount;i++)
	{
		// load layer info
		Ogre::String sectionStr = Ogre::StringConverter::toString(i);
		Ogre::Real layerworldsize = Ogre::StringConverter::parseReal(terrainconfig->getSetting("worldsize", sectionStr));
		
		if (i==0)
		{			
			// no blendmap at layer 0 (baselayer)
			Ogre::String specular = terrainconfig->getSetting("specular", sectionStr);
			Ogre::String normal = terrainconfig->getSetting("normal", sectionStr);

			// add layer		
			imp.layerList[i].textureNames.push_back(specular);
			imp.layerList[i].textureNames.push_back(normal);
			imp.layerList[i].worldSize = layerworldsize;			
		}
		else
		{
			Ogre::String specular = terrainconfig->getSetting("specular", sectionStr);
			Ogre::String normal = terrainconfig->getSetting("normal", sectionStr);
			Ogre::String blend = terrainconfig->getSetting("blend", sectionStr);
		
			// add layer		
			imp.layerList[i].textureNames.push_back(specular);
			imp.layerList[i].textureNames.push_back(normal);	
			imp.layerList[i].worldSize = layerworldsize;

			blendmaps[i] = blend; 
		}
	}

	// load the terrain
	terrain->prepare(imp);
	terrain->load();	
	
	// load those blendmaps into the layers
	for(int j = 1;j < terrain->getLayerCount();j++)
	{
		Ogre::TerrainLayerBlendMap *blendmap = terrain->getLayerBlendMap(j);
		Ogre::Image img;
		img.load(blendmaps[j],"General");
		int blendmapsize = terrain->getLayerBlendMapSize();
		if(img.getWidth() != blendmapsize)
			img.resize(blendmapsize, blendmapsize);

		float *ptr = blendmap->getBlendPointer();
		Ogre::uint8 *data = static_cast<Ogre::uint8*>(img.getPixelBox().data);

		for(int bp = 0;bp < blendmapsize * blendmapsize;bp++)
			ptr[bp] = static_cast<float>(data[bp]) / 255.0f;

		blendmap->dirty();
		blendmap->update();
	}

	// create filename for writing
	int pos = heightmapfile.find_last_of('.');
	if (pos < 0)	
		heightmapfile = heightmapfile + ".ogt";
	else	
		heightmapfile = heightmapfile.substr(0, pos) + ".ogt";
			
	// save as Ogre .OGT
	terrain->save(heightmapfile);	
	Ogre::LogManager::getSingletonPtr()->logMessage(Ogre::LogMessageLevel::LML_NORMAL, heightmapfile + " successfully written.");
	
	// debug viewing (exit with CTRL+C)
	camera->setPosition(-terrainsize, 7000, -terrainsize);
	camera->lookAt(terrainsize/2,0,terrainsize/2);	
	root->startRendering();

	return 0;
}
Ejemplo n.º 22
0
const std::string ManipulatorTerrain::GetLayerNormalMap( int nLayer ) const
{
	Ogre::Terrain* pTerrain = ManipulatorSystem.GetScene()->GetTerrain();
	assert(nLayer >=0 && nLayer<(int)pTerrain->getLayerCount());
	return pTerrain->getLayerTextureName(nLayer, 1);
}
Ejemplo n.º 23
0
float ManipulatorTerrain::GetLayerTexWorldSize( int nLayer )
{
	Ogre::Terrain* pTerrain = ManipulatorSystem.GetScene()->GetTerrain();
	assert(nLayer >=0 && nLayer<(int)pTerrain->getLayerCount());
	return pTerrain->getLayerWorldSize(nLayer);
}
Ejemplo n.º 24
0
float MyTerrain::GetImageXFromWorldX( float x )
{
    Ogre::Terrain* terrain = m_pTerrainGroup->getTerrain(0,0);
    return x*m_EdgeImage.width()/(float)terrain->getWorldSize();
}
Ejemplo n.º 25
0
void ManipulatorTerrain::SetLayerTexWorldSize(int nLayer, float fSize)
{
	Ogre::Terrain* pTerrain = ManipulatorSystem.GetScene()->GetTerrain();
	assert(nLayer >=0 && nLayer<(int)pTerrain->getLayerCount());
	pTerrain->setLayerWorldSize(nLayer, fSize);
}
Ejemplo n.º 26
0
void ManipulatorTerrain::OnEdit( float dt )
{
	assert(m_curEditMode != eTerrainEditMode_None);

	//第0层不能编辑BlendMap,应该从第1层开始
	if(m_curEditMode == eTerrainEditMode_Splat && m_curEditLayer == 0)
		return;

	Ogre::Terrain* pTerrain = ManipulatorSystem.GetScene()->GetTerrain();

	const Vector3 brushPos = m_brush[m_curBrushIndex]->GetPosition();
	Vector3 tsPos;
	pTerrain->getTerrainPosition(brushPos, &tsPos);

	float brushSizeW, brushSizeH;
	m_brush[m_curBrushIndex]->GetDimension(brushSizeW, brushSizeH);
	float worldSize = GetWorldSize();
	brushSizeW /= worldSize;
	brushSizeH /= worldSize;

	int multiplier;
	Ogre::TerrainLayerBlendMap* layer = nullptr;
	if(m_curEditMode == eTerrainEditMode_Deform)
	{
		multiplier = pTerrain->getSize() - 1;
	}
	else
	{
		multiplier = pTerrain->getLayerBlendMapSize();
		layer = pTerrain->getLayerBlendMap(m_curEditLayer);
	}

	long startx = (long)((tsPos.x - brushSizeW / 2) * multiplier);
	long starty = (long)((tsPos.y - brushSizeH / 2) * multiplier);
	long endx = (long)((tsPos.x + brushSizeW / 2) * multiplier);
	long endy= (long)((tsPos.y + brushSizeH / 2) * multiplier);
	startx = max(startx, 0L);
	starty = max(starty, 0L);
	endx = min(endx, (long)multiplier);
	endy = min(endy, (long)multiplier);
	
	for (long y = starty; y <= endy; ++y)
	{
		for (long x = startx; x <= endx; ++x)
		{
			float tsXdist = (x / multiplier) - tsPos.x;
			float tsYdist = (y / multiplier)  - tsPos.y;

			if(m_curEditMode == eTerrainEditMode_Deform)
			{
				float* pData = pTerrain->getHeightData();
				pData[y*GetMapSize()+x] += 100.0f * dt;

			}
			else
			{
				float* pData = layer->getBlendPointer();
				size_t imgY = multiplier - y;
				float newValue = pData[imgY*multiplier+x] + dt;
				newValue = Ogre::Math::Clamp(newValue, 0.0f, 1.0f);
				pData[imgY*multiplier+x] = newValue;
			}
		}
	}
	
	
	if(m_curEditMode == eTerrainEditMode_Deform)
	{
		Ogre::Rect rect(startx, starty, endx, endy);
		pTerrain->dirtyRect(rect);
		pTerrain->update();
	}
	else
	{
		size_t imgStartY = multiplier - starty;
		size_t imgEndY = multiplier - endy;
		Ogre::Rect rect(startx, min(imgStartY,imgEndY), endx, max(imgStartY,imgEndY));

		layer->dirtyRect(rect);
		layer->update();
	}
}
Ejemplo n.º 27
0
void TerrainManager::terrainInit(Ogre::String file, OgreManager* o)
{
	_OgreManager = o;

	initialiseResources();

	createLight();

	setGlobalOptions();

	_TerrainGroup = OGRE_NEW Ogre::TerrainGroup(_OgreManager->getSceneManager(), Ogre::Terrain::ALIGN_X_Z, 513, 12000.0f);
	_TerrainGroup->setFilenameConvention(Ogre::String("GameTerrain"), Ogre::String("dat"));
	_TerrainGroup->setOrigin(Ogre::Vector3::ZERO);

	setDefaultImportSettings();

	bool lTerrainsImported = false;
	 for (long x = 0; x <= 0; ++x)
	 {
        for (long y = 0; y <= 0; ++y)
		{
			//Define terrain function
			 Ogre::String filename = _TerrainGroup->generateFilename(x, y);
			if (Ogre::ResourceGroupManager::getSingleton().resourceExists(_TerrainGroup->getResourceGroup(), filename))
			{
				_TerrainGroup->defineTerrain(x, y);
			}
			else
			{
				Ogre::Image img;
				//Get terrain image
				Ogre::String tempFile = Ogre::StringConverter::toString(x * 10 + y);
				tempFile.append(".bmp");
				img.load("terrain.bmp", Ogre::String("TerrainResources"));
					if (x % 2 != 0)
						img.flipAroundY();
					if (y % 2 != 0)
						img.flipAroundX();
				//Get terrain image end
				_TerrainGroup->defineTerrain(x, y, &img);
				lTerrainsImported = true;
			}
			//Define terrain function end
		}
	}
	
	_TerrainGroup->loadAllTerrains(true);

	if (lTerrainsImported)
    {
        Ogre::TerrainGroup::TerrainIterator ti = _TerrainGroup->getTerrainIterator();
        while(ti.hasMoreElements())
        {
            Ogre::Terrain* t = ti.getNext()->instance;
            //Init blend maps function start
			Ogre::TerrainLayerBlendMap* blendMap0 = t->getLayerBlendMap(1);
			Ogre::TerrainLayerBlendMap* blendMap1 = t->getLayerBlendMap(2);
			Ogre::Real minHeight0 = -10;
			Ogre::Real fadeDist0 = 0;//40;
			Ogre::Real minHeight1 = -10;
			Ogre::Real fadeDist1 = 0;//15;
			float* pBlend0 = blendMap0->getBlendPointer();
			float* pBlend1 = blendMap1->getBlendPointer();
			for (Ogre::uint16 y = 0; y < t->getLayerBlendMapSize(); ++y)
			{
				for (Ogre::uint16 x = 0; x < t->getLayerBlendMapSize(); ++x)
				{
					Ogre::Real tx, ty;
 
					blendMap0->convertImageToTerrainSpace(x, y, &tx, &ty);
					Ogre::Real height = t->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();
			//Init blend maps end
        }
    }

	_TerrainGroup->freeTemporaryResources();

	_OgreManager->getSceneManager()->setSkyBox(true, "Examples/EarlyMorningSkyBox", 5000, true, Ogre::Quaternion::IDENTITY, "GameResources");
}
Ejemplo n.º 28
0
int terrain_get_layer_blend_map_size(CoiHandle terrain_handle)
{
  Ogre::Terrain* terrain = reinterpret_cast<Ogre::Terrain*>(terrain_handle);
  return terrain->getLayerBlendMapSize();
}
Ejemplo n.º 29
0
float MyTerrain::GetImageYFromWorldY( float y )
{
    Ogre::Terrain* terrain = m_pTerrainGroup->getTerrain(0,0);
    return y*m_EdgeImage.height()/(float)terrain->getWorldSize();
}