void
JunctionSelection::notifyModified(void) const
{
if (!mJunctions.empty())
{
int minx, maxx, minz, maxz;
JunctionMap::const_iterator it = mJunctions.begin();
minx = maxx = it->second.x;
minz = maxz = it->second.z;
while (++it != mJunctions.end())
{
int x = it->second.x;
if (minx > x)
minx = x;
else if (maxx < x)
maxx = x;
int z = it->second.z;
if (minz > z)
minz = z;
else if (maxz < z)
maxz = z;
}
if (minx < 0) minx = 0;
if (minz < 0) minz = 0;
if (maxx > getTerrainData()->mXSize)
maxx = getTerrainData()->mXSize;
if (maxz > getTerrainData()->mZSize)
maxz = getTerrainData()->mZSize;
if (minx <= maxx && minz <= maxz)
{
getTerrain()->notifyHeightModified(minx, minz, maxx+1, maxz+1);
}
}
}
Real TrueSmoothHeightAction::_computeHeight(const JunctionSelection::Junction& junction, Real seconds)
{
float center_x = (MaxBindPoint.first - MinBindPoint.first ) /2 + MinBindPoint.first;
float center_z = (MaxBindPoint.second- MinBindPoint.second) /2 + MinBindPoint.second;
//╝к╦с╚еоп
Real height = getTerrainData()->getHeight(junction.x, junction.z);
float StrenghScalar = RadiusStrength(Ogre::Vector3(center_x,0,center_z),Ogre::Vector3(junction.x ,0,junction.z) ,0.1,(mWeightcnt+mHeightcnt)/4) ;
float SmoothHeight=0;
int vertCnt = 0;
for (int AdjacentZ = 0;AdjacentZ < 3;AdjacentZ++)
{
for (int AdjacentX = 0;AdjacentX < 3;AdjacentX++)
{
int VertX = junction.x - 1 + AdjacentX;
int VertZ = junction.z - 1 + AdjacentZ;
// prevent array out of bounds crash if X and Y are referencing a vertex on the edge of the map
if ( false == getTerrainData()->isValidJunction(VertX, VertZ) )
continue;
SmoothHeight += getTerrainData()->getHeight(VertX, VertZ) ;
vertCnt++;
}
}
SmoothHeight=SmoothHeight/vertCnt;
float Newheight = Lerp(height,SmoothHeight,std::min(StrenghScalar,1.0f)) ;
Real diff = Newheight - height;
Newheight = height + diff *seconds*getSceneManipulator()->getHeightAdjustSpeed() ;
return Newheight;
}
bool
GridSelection::add(int x, int z)
{
if (!getTerrainData()->isValidGrid(x, z))
return false;
size_t index = getTerrainData()->_getGridIndex(x, z);
std::pair<GridMap::iterator, bool> inserted =
mGrids.insert(GridMap::value_type(index, Grid(x, z, getTerrainData()->mGridInfos[index])));
return inserted.second;
}
bool
JunctionSelection::add(int x, int z, Real weight)
{
if (!getTerrainData()->isValidJunction(x, z))
return false;
size_t index = getTerrainData()->_getJunctionIndex(x, z);
std::pair<JunctionMap::iterator, bool> inserted =
mJunctions.insert(JunctionMap::value_type(index, Junction(x, z, getTerrainData()->getHeight(x, z), weight)));
return inserted.second;
}
void SmoothHeightAction::computeAverageHeight(void)
{
Real totalHeight = 0;
Real totalWeight = 0;
mMaxHeight = -1;
mMinHeight = 100000.0f;
MinBindPoint.first = 500000.0f;
MinBindPoint.second = 500000.0f;
MaxBindPoint.first = -1.0f;
MaxBindPoint.second = -1.0f;
JunctionSelection* selection = static_cast<JunctionSelection*>(
getSceneManipulator()->_getSelection("JunctionSelection"));
const JunctionSelection::JunctionMap& junctions = selection->getJunctions();
if (junctions.size()<=0)
{
return;
}
JunctionSelection::JunctionMap::const_iterator it;
for (it = junctions.begin(); it != junctions.end(); ++it)
{
const JunctionSelection::Junction& junction = it->second;
totalWeight += junction.weight;
totalHeight += getTerrainData()->getHeight(junction.x, junction.z) * junction.weight;
mMaxHeight = getTerrainData()->getHeight(junction.x, junction.z) > mMaxHeight ? getTerrainData()->getHeight(junction.x, junction.z) : mMaxHeight ;
mMinHeight = getTerrainData()->getHeight(junction.x, junction.z) < mMinHeight ? getTerrainData()->getHeight(junction.x, junction.z) : mMinHeight ;
MinBindPoint.first = MinBindPoint.first < junction.x ? MinBindPoint.first : junction.x ;
MinBindPoint.second = MinBindPoint.second < junction.z ? MinBindPoint.second : junction.z ;
MaxBindPoint.first = MaxBindPoint.first > junction.x ? MaxBindPoint.first : junction.x ;
MaxBindPoint.second = MaxBindPoint.second > junction.z ? MaxBindPoint.second : junction.z ;
}
mAverageHeight = totalWeight ? totalHeight / totalWeight : 0;
//----------------------
// lefttop right top
// min.x max.y ---------- max.x max.y
// | |
// | |
// | |
// min.x min.y-----------max.x min.y
float leftdown_h = getTerrainData()->getHeight(MinBindPoint.first, MinBindPoint.second);
float righttop_h = getTerrainData()->getHeight(MaxBindPoint.first, MaxBindPoint.second);
float lefttop_h = getTerrainData()->getHeight(MinBindPoint.first, MaxBindPoint.second);
float rightdown_h = getTerrainData()->getHeight(MaxBindPoint.first, MinBindPoint.second);
if ( abs(righttop_h-lefttop_h) > abs(righttop_h-rightdown_h))
ScalarX_axis = true;
else
ScalarX_axis = false;
}
bool
GridSelection::setValue(int x, int z, const TerrainData::GridInfo& info)
{
if (!getTerrainData()->isValidGrid(x, z))
return false;
GridMap::iterator it = mGrids.find(getTerrainData()->_getGridIndex(x, z));
if (it == mGrids.end())
return false;
it->second.info = info;
return true;
}
bool
JunctionSelection::setValue(int x, int z, Real height)
{
if (!getTerrainData()->isValidJunction(x, z))
return false;
JunctionMap::iterator it = mJunctions.find(getTerrainData()->_getJunctionIndex(x, z));
if (it == mJunctions.end())
return false;
it->second.height = height;
return true;
}
void
JunctionPoints::refresh(void)
{
JunctionSelection* selection = static_cast<JunctionSelection*>(
getSceneManipulator()->_getSelection("JunctionSelection"));
const JunctionSelection::JunctionMap& junctions = selection->getJunctions();
DisplayNodes newDisplayNodes;
// Use existing point if possible
for (JunctionSelection::JunctionMap::const_iterator it = junctions.begin(); it != junctions.end(); ++it)
{
const JunctionSelection::Junction& junction = it->second;
Ogre::Vector3 pos = getTerrainData()->_getPosition(junction.x, junction.z);
DisplayNodes::iterator found = mDisplayNodes.find(Ogre::Vector4(pos.x, pos.y, pos.z, junction.weight));
Ogre::SceneNode* node = NULL;
if (found != mDisplayNodes.end())
{
node = found->second;
mDisplayNodes.erase(found);
}
newDisplayNodes.insert(DisplayNodes::value_type(Ogre::Vector4(pos.x, pos.y, pos.z, junction.weight), node));
}
// Build new point and adjust position
for (DisplayNodes::iterator it = newDisplayNodes.begin(); it != newDisplayNodes.end(); ++it)
{
if (!it->second)
{
if (!mDisplayNodes.empty())
{
DisplayNodes::iterator found = mDisplayNodes.begin();
it->second = found->second;
mDisplayNodes.erase(found);
}
else
{
it->second = allocNode();
}
it->second->setPosition(it->first.x,it->first.y,it->first.z);
// 根据节点的权重来设置节点所挂物体的材质颜色
Ogre::MaterialPtr material = createPureColourMaterial(Ogre::ColourValue(it->first.w,(1.0f-it->first.w),0.0f));
// 设置节点的材质
static_cast<Ogre::Entity *>(it->second->getAttachedObject(0))->setMaterialName(material->getName());
}
}
// Hide extra points
for (DisplayNodes::const_iterator it = mDisplayNodes.begin(); it != mDisplayNodes.end(); ++it)
{
freeNode(it->second);
}
std::swap(newDisplayNodes, mDisplayNodes);
}
//-----------------------------------------------------------------------
void
PaintAction::doFinish(GridSelection* origin, bool canceled)
{
assert(origin);
if (canceled)
{
origin->apply();
}
else
{
if (!origin->empty())
{
std::auto_ptr<ModifyTerrainPaintOperator> op(new ModifyTerrainPaintOperator(getSceneManipulator()));
const GridSelection::GridMap& grids = origin->getGrids();
GridSelection::GridMap::const_iterator it;
for (it = grids.begin(); it != grids.end(); ++it)
{
const GridSelection::Grid& grid = it->second;
const TerrainData::GridInfo &newGridInfo = getTerrainData()->getGridInfo(grid.x, grid.z);
const TerrainData::GridInfo &oldGridInfo = grid.info;
if (newGridInfo != oldGridInfo)
{
op->add(grid.x, grid.z, oldGridInfo, newGridInfo);
}
}
if (!op->empty())
getOperatorManager()->addOperator(op.release());
}
}
}
void TrueSmoothHeightAction::computeAverageHeight(void)
{
Real totalHeight = 0;
Real totalWeight = 0;
JunctionSelection* selection = static_cast<JunctionSelection*>( getSceneManipulator()->_getSelection("JunctionSelection"));
const JunctionSelection::JunctionMap& junctions = selection->getJunctions();
JunctionSelection::JunctionMap::const_iterator it;
for (it = junctions.begin(); it != junctions.end(); ++it)
{
const JunctionSelection::Junction& junction = it->second;
totalWeight += junction.weight;
totalHeight += getTerrainData()->getHeight(junction.x, junction.z) * junction.weight;
if(it == junctions.begin())
{
MinBindPoint = std::pair<int, int>(junction.x,junction.z);
MaxBindPoint = std::pair<int, int>(junction.x,junction.z);
}else
{
MinBindPoint.first = MinBindPoint.first < junction.x ? MinBindPoint.first : junction.x ;
MinBindPoint.second = MinBindPoint.second < junction.z ? MinBindPoint.second : junction.z ;
MaxBindPoint.first = MaxBindPoint.first > junction.x ? MaxBindPoint.first : junction.x ;
MaxBindPoint.second = MaxBindPoint.second > junction.z ? MaxBindPoint.second : junction.z ;
}
}
mWeightcnt=MaxBindPoint.first-MinBindPoint.first+1;
mHeightcnt=MaxBindPoint.second-MinBindPoint.second+1;
mAverageHeight = totalWeight ? totalHeight / totalWeight : 0;
}
//-----------------------------------------------------------------------
void TerrainLayerOneEraserAction::_doErase(GridSelection* modified)
{
const GridSelection::GridMap& grids = mCurrentGrids->getGrids();
bool anyModified = false;
if (!grids.empty())
{
for (GridSelection::GridMap::const_iterator it = grids.begin(); it != grids.end(); ++it)
{
const GridSelection::Grid& grid = it->second;
TerrainData::GridInfo info = grid.info;
if ( info.layers[1].pixmapId )
{
info.layers[1].pixmapId = 0;
info.layers[1].orientation = 0;
}
if (info == grid.info)
continue;
anyModified = true;
modified->add(grid.x, grid.z);
getTerrainData()->setGridInfo(grid.x, grid.z, info);
}
if (anyModified)
{
mCurrentGrids->notifyModified();
}
}
}
void GridInfoFlagModifyAction::_doFinish(GridSelection* origin, bool canceled)
{
assert(origin);
if (canceled)
{
origin->apply();
}
else
{
if (!origin->empty())
{
std::auto_ptr<FlipTerrainDiagonalOperator> op(new FlipTerrainDiagonalOperator(getSceneManipulator()));
const GridSelection::GridMap& grids = origin->getGrids();
GridSelection::GridMap::const_iterator it;
for (it = grids.begin(); it != grids.end(); ++it)
{
const GridSelection::Grid& grid = it->second;
uint newFlipFlag = getTerrainData()->getGridInfo(grid.x, grid.z).flags;
uint oldFlipFlag = grid.info.flags;
if (newFlipFlag != oldFlipFlag)
{
op->add(grid.x, grid.z, oldFlipFlag, newFlipFlag);
}
}
if (!op->empty())
getOperatorManager()->addOperator(op.release());
}
}
}
void GridInfoFlagModifyAction::_modifyFlag(const Point& pt)
{
GridSelection* selection = static_cast<GridSelection*>(
getSceneManipulator()->_getSelection("GridSelection"));
Ogre::Vector3 position;
bool intersected = getSceneManipulator()->getTerrainIntersects(pt.x, pt.y, position);
if (intersected)
getSceneManipulator()->_buildSelection(selection, position.x, position.z);
const GridSelection::GridMap& grids = selection->getGrids();
GridSelection::GridMap::const_iterator it;
for (it = grids.begin(); it != grids.end(); ++it)
{
const GridSelection::Grid& grid = it->second;
TerrainData::GridInfo info = grid.info;
info.flags ^= mModifiedFlag;
getTerrainData()->setGridInfo(grid.x, grid.z, info);
}
selection->notifyModified();
}
void
IntersectGrids::refresh(void)
{
GridSelection* selection = static_cast<GridSelection *>(
getSceneManipulator()->_getSelection("GridSelection"));
const GridSelection::GridMap &mGrids = selection->getGrids();
TerrainData *terrainData = getTerrainData();
if (!mGrids.empty())
{
GridSelection::GridMap::const_iterator it = mGrids.begin();
while (it != mGrids.end())
{
// 取得这个grid的四个角的坐标
int minx = it->second.x;
int minz = it->second.z;
int maxx = minx+1;
int maxz = minz+1;
// 判断是否翻转了，因为翻转了会改变顶点的高度
if ( terrainData->getGridInfo(minx, minz).flags & TerrainData::GridInfo::FlipDiagonal )
{
// 第一个三角形
mPosArray.push_back(terrainData->_getPosition(minx,minz)-mIntersectGridsNode->getPosition());
mPosArray.push_back(terrainData->_getPosition(minx,maxz)-mIntersectGridsNode->getPosition());
mPosArray.push_back(terrainData->_getPosition(maxx,maxz)-mIntersectGridsNode->getPosition());
// 第二个三角形
mPosArray.push_back(terrainData->_getPosition(maxx,minz)-mIntersectGridsNode->getPosition());
mPosArray.push_back(terrainData->_getPosition(minx,minz)-mIntersectGridsNode->getPosition());
mPosArray.push_back(terrainData->_getPosition(maxx,maxz)-mIntersectGridsNode->getPosition());
}
else
{
// 第一个三角形
mPosArray.push_back(terrainData->_getPosition(minx,minz)-mIntersectGridsNode->getPosition());
mPosArray.push_back(terrainData->_getPosition(minx,maxz)-mIntersectGridsNode->getPosition());
mPosArray.push_back(terrainData->_getPosition(maxx,minz)-mIntersectGridsNode->getPosition());
// 第二个三角形
mPosArray.push_back(terrainData->_getPosition(maxx,minz)-mIntersectGridsNode->getPosition());
mPosArray.push_back(terrainData->_getPosition(minx,maxz)-mIntersectGridsNode->getPosition());
mPosArray.push_back(terrainData->_getPosition(maxx,maxz)-mIntersectGridsNode->getPosition());
}
++it;
}
intersectGrids->fillPosition(mPosArray);
mPosArray.clear();
}
}
void
GridSelection::apply(void)
{
for (GridMap::const_iterator it = mGrids.begin(); it != mGrids.end(); ++it)
{
const Grid& grid = it->second;
getTerrainData()->setGridInfo(grid.x, grid.z, grid.info);
}
notifyModified();
}
bool CreateObjectAction::updateInstance(const Point& pt)
{
if (mObjectType.empty())
{
hide();
return false;
}
Ogre::Vector3 position, normal;
if (!getSceneManipulator()->getTerrainIntersects(pt, position, &normal, true))
{
hide();
return false;
}
if (!mObject)
{
mObject = ObjectFactoryManager::getSingleton().createInstance(mObjectType);
mObject->setPropertyList(mParameters);
mObject->createRenderInstance(getSceneManipulator());
}
else
{
mObject->setPropertyList(mParameters);
}
Ogre::Vector3 groundingPoint(Ogre::Vector3::ZERO);
if (mObject->hasProperty("grounding point"))
{
// Adjust position by grounding point
groundingPoint = VariantCast<Ogre::Vector3>(mObject->getProperty("grounding point"));
position -= groundingPoint;
}
position = getSceneManipulator()->_alignPosition(position);
position.y = getTerrainData()->getHeightAt(position.x, position.z) - groundingPoint.y;
position = getSceneManipulator()->_alignPosition(position);
if(!mHasPosition)
mObject->setProperty("position", position);
mRangeSphereNode->setVisible(false);
Ogre::String type = mObject->getType();
if ( type == "Light")
{
LightObject *lightObject = static_cast<LightObject *> (mObject.get());
if (mObject->getPropertyAsString("type") == "point")
{
mRangeSphereNode->setPosition(position);
mRangeSphereNode->setVisible(true);
}
}
return true;
}
void SetTerrainHeightAction::_doModify(const Point& pt)
{
Ogre::Vector3 position;
bool intersected = getSceneManipulator()->getTerrainIntersects(pt, position);
if (intersected)
{
bool anyModified = false;
JunctionSelection* selection = static_cast<JunctionSelection*>(
getSceneManipulator()->_getSelection("JunctionSelection"));
getSceneManipulator()->_buildSelection(selection, position.x, position.z);
const JunctionSelection::JunctionMap& junctions = selection->getJunctions();
JunctionSelection::JunctionMap::const_iterator it;
std::vector<TerrainInfo> terrainInfo;
for (it = junctions.begin(); it != junctions.end(); ++it)
{
const JunctionSelection::Junction& junction = it->second;
Real newHeight = mTerrainHeight;
if (newHeight != junction.height)
{
anyModified = true;
mModifiedJunctions->add(junction.x, junction.z, 1);
TerrainInfo terrInfo;
terrInfo.x = junction.x;
terrInfo.z = junction.z;
terrInfo.oldHeight = junction.height;
terrInfo.nowHeight = newHeight;
terrainInfo.push_back(terrInfo);
getTerrainData()->setHeight(junction.x, junction.z, newHeight);
}
}
getSceneManipulator()->_fireTerrainHeightChanged(terrainInfo);
if (anyModified)
{
selection->notifyModified();
}
getSceneManipulator()->getHitIndicator("JunctionPoints")->refresh();
}
else
{
getSceneManipulator()->getHitIndicator("JunctionPoints")->setHitPoint(pt);
}
getSceneManipulator()->getHitIndicator("IntersectPoint")->setHitPoint(pt);
}
Real SmoothHeightAction::_computeHeight(const JunctionSelection::Junction& junction, Real seconds)
{
Real height = getTerrainData()->getHeight(junction.x, junction.z);
if ( mSmoothType == ENUM_SMOOTH_TYPE::SMOOTH_TYPE_TYPE_SMOOTH )
{
Real diff = mAverageHeight - height;
Real secondsRequest = Ogre::Math::Abs(diff * junction.weight / getSceneManipulator()->_getHeightAdjustSpeed());
if (secondsRequest < seconds)
return mAverageHeight;
else
return height + diff * seconds / secondsRequest;
}
float StrenghScalar;
if(ScalarX_axis)
StrenghScalar = (float)(junction.x - MinBindPoint.first) / (float)(MaxBindPoint.first - MinBindPoint.first);
else
StrenghScalar = (float)(junction.z - MinBindPoint.second) / (float)(MaxBindPoint.second - MinBindPoint.second);
if (StrenghScalar < 0.0f)
StrenghScalar = 0.0f;
float minValue = mMaxHeight ;
float maxValue = mMinHeight ;
float Newheight ;
if ( getTerrainData()->getHeight(MaxBindPoint.first, MaxBindPoint.second) < getTerrainData()->getHeight(MinBindPoint.first, MinBindPoint.second) )
Newheight = Lerp(minValue,maxValue,min(StrenghScalar,1.0f)) ;
else
Newheight = Lerp(maxValue,minValue,min(StrenghScalar,1.0f)) ;
Real diff = Newheight - height;
Newheight = height + diff *seconds*getSceneManipulator()->getHeightAdjustSpeed() ;
return Newheight;
}
void CameraDragMove::_onDrag(const Point& pt)
{
if (!mTerrainHitInfo.hitted)
return;
Ogre::Ray ray = getSceneManipulator()->getWindowToViewportRay(pt);
if (!ray.getDirection().y)
return;
Ogre::Vector3 newPosition;
// 对正交投影和透视投影分开处理
if (getSceneManipulator()->getCamera()->getProjectionType() == Ogre::PT_ORTHOGRAPHIC)
{
Real offsetx = mRay.getOrigin().x - ray.getOrigin().x;
Real offsetz = mRay.getOrigin().z - ray.getOrigin().z;
newPosition.x = getSceneManipulator()->getCamera()->getRealPosition().x + offsetx;
newPosition.y = getSceneManipulator()->getCamera()->getRealPosition().y;
newPosition.z = getSceneManipulator()->getCamera()->getRealPosition().z + offsetz;
}
else
{
Real length = (mTerrainHitInfo.position.y - mTerrainHitInfo.hitPosition.y) / ray.getDirection().y;
newPosition = mTerrainHitInfo.hitPosition + ray.getDirection() * length;
if (getSceneManipulator()->getCameraHeightLocked())
{
newPosition.y +=
getTerrainData()->getHeightAt(newPosition.x, newPosition.z) -
getTerrainData()->getHeightAt(mTerrainHitInfo.position.x, mTerrainHitInfo.position.z);
}
}
getSceneManipulator()->setCameraPosition(newPosition);
}
void
JunctionSelection::apply(void)
{
std::vector<TerrainInfo> terrainInfo;
for (JunctionMap::const_iterator it = mJunctions.begin(); it != mJunctions.end(); ++it)
{
const Junction& junction = it->second;
float oldHeight = getTerrainData()->getHeight(junction.x,junction.z);
TerrainInfo terrInfo;
terrInfo.x = junction.x;
terrInfo.z = junction.z;
terrInfo.oldHeight = oldHeight;
terrInfo.nowHeight = junction.height;
terrainInfo.push_back(terrInfo);
getTerrainData()->setHeight(junction.x, junction.z, junction.height);
}
getSceneManipulator()->_fireTerrainHeightChanged(terrainInfo);
notifyModified();
}
//-----------------------------------------------------------------------
void
PaintAction::updatePixmapInfo(void) const
{
mPixmapId = getTerrainData()->_registerPixmap(
mPixmap.textureName,
mPixmap.left,
mPixmap.top,
mPixmap.right,
mPixmap.bottom);
mPixmapTransparent = false;
if (!mPixmap.textureName.empty())
{
mPixmapTransparent = getSceneManipulator()->IsTransparentTexture(mPixmap.textureName);
}
mPixmapInfoValid = true;
}
bool CreateComplexObjectAction::updateInstance(const Point& pt)
{
if (mObjectType.empty())
{
hide();
return false;
}
Ogre::Vector3 position, normal;
if (!getSceneManipulator()->getTerrainIntersects(pt, position, &normal, true))
{
hide();
return false;
}
if (!mObject)
{
mObject = ObjectFactoryManager::getSingleton().createInstance(mObjectType);
mObject->setPropertyList(mParameters);
// 设置物体的位置
Ogre::Vector3 groundingPoint(Ogre::Vector3::ZERO);
if (mObject->hasProperty("grounding point"))
{
// Adjust position by grounding point
groundingPoint = VariantCast<Ogre::Vector3>(mObject->getProperty("grounding point"));
position -= groundingPoint;
}
position = getSceneManipulator()->_alignPosition(position);
position.y = getTerrainData()->getHeightAt(position.x, position.z) - groundingPoint.y;
position = getSceneManipulator()->_alignPosition(position);
mObject->setProperty("position", position);
mObject->createRenderInstance(getSceneManipulator());
}
else
{
mObject->setPropertyList(mParameters);
}
return true;
}
Real RaiseHeightAction::_computeHeight(const JunctionSelection::Junction& junction, Real seconds)
{
return getTerrainData()->getHeight(junction.x, junction.z) + mAdjust * junction.weight;
}
void TerrainSelectionGrids::refresh(void)
{
// 对当前所有的GridSelection进行重绘
GridSelections::const_iterator listIterator = mGridSelectionList.begin();
while ( listIterator != mGridSelectionList.end() )
{
GridSelection* selection = *listIterator;
const GridSelection::GridMap &mGrids = selection->getGrids();
TerrainData *terrainData = getTerrainData();
if (!mGrids.empty())
{
GridSelection::GridMap::const_iterator it = mGrids.begin();
Ogre::Vector3 sceneNodePos = mIntersectGridsNode->getPosition();
while (it != mGrids.end())
{
// 取得这个grid的四个角的坐标
int minx = it->second.x;
int minz = it->second.z;
int maxx = minx+1;
int maxz = minz+1;
// 判断是否翻转了，因为翻转了会改变顶点的高度
if ( terrainData->getGridInfo(minx, minz).flags & TerrainData::GridInfo::FlipDiagonal )
{
// 第一个三角形
mPosArray.push_back(terrainData->_getPosition(minx,minz)-sceneNodePos);
mPosArray.push_back(terrainData->_getPosition(minx,maxz)-sceneNodePos);
mPosArray.push_back(terrainData->_getPosition(maxx,maxz)-sceneNodePos);
// 第二个三角形
mPosArray.push_back(terrainData->_getPosition(maxx,minz)-sceneNodePos);
mPosArray.push_back(terrainData->_getPosition(minx,minz)-sceneNodePos);
mPosArray.push_back(terrainData->_getPosition(maxx,maxz)-sceneNodePos);
}
else
{
// 第一个三角形
mPosArray.push_back(terrainData->_getPosition(minx,minz)-sceneNodePos);
mPosArray.push_back(terrainData->_getPosition(minx,maxz)-sceneNodePos);
mPosArray.push_back(terrainData->_getPosition(maxx,minz)-sceneNodePos);
// 第二个三角形
mPosArray.push_back(terrainData->_getPosition(maxx,minz)-sceneNodePos);
mPosArray.push_back(terrainData->_getPosition(minx,maxz)-sceneNodePos);
mPosArray.push_back(terrainData->_getPosition(maxx,maxz)-sceneNodePos);
}
++it;
}
}
++listIterator;
}
intersectGrids->fillPosition(mPosArray);
mPosArray.clear();
}
bool
GridSelection::exist(int x, int z) const
{
return getTerrainData()->isValidGrid(x, z) &&
mGrids.find(getTerrainData()->_getGridIndex(x, z)) != mGrids.end();
}
bool
GridSelection::remove(int x, int z)
{
return getTerrainData()->isValidGrid(x, z) &&
mGrids.erase(getTerrainData()->_getGridIndex(x, z)) > 0;
}
bool
JunctionSelection::remove(int x, int z)
{
return getTerrainData()->isValidJunction(x, z) &&
mJunctions.erase(getTerrainData()->_getJunctionIndex(x, z)) > 0;
}
bool
JunctionSelection::exist(int x, int z) const
{
return getTerrainData()->isValidJunction(x, z) &&
mJunctions.find(getTerrainData()->_getJunctionIndex(x, z)) != mJunctions.end();
}
