std::shared_ptr<Mesh<Vertex3DNormTex>> MeshConstructor::constructConvexPolygonMesh(const std::vector<Vertex3DNormTex> &vertices, const glm::vec3 &axis1, const glm::vec3 &axis2, const glm::vec3 rotation, float accuracy)
{
std::shared_ptr<Mesh<Vertex3DNormTex>> mesh(std::make_shared<Mesh<Vertex3DNormTex>>());
glm::mat3x2 projection = glm::transpose(glm::mat2x3(axis1, axis2));
std::vector<glm::ivec2> positions;
std::vector<glm::vec2> uniquePositions;
std::vector<int> convexHullPositions;
glm::vec2 middlePoint;
Box meshBounds(glm::vec3(std::numeric_limits<float>::infinity()), -glm::vec3(std::numeric_limits<float>::infinity()));
int startPointIndex = 0;
int nextPointIndex = 0;
glm::mat4 transformation(1);
transformation = glm::rotate(transformation, rotation.x, glm::vec3(1, 0, 0));
transformation = glm::rotate(transformation, rotation.y, glm::vec3(0, 1, 0));
transformation = glm::rotate(transformation, rotation.z, glm::vec3(0, 0, 1));
std::vector<glm::vec2> boundVertices;
for (int i = 0; i < 4; ++i)
{
boundVertices.push_back(projection * glm::vec3(transformation * glm::vec4(vertices[0].m_position, 1)));
}
for (unsigned int vertexIndex = 0; vertexIndex < vertices.size(); ++vertexIndex)
{
glm::vec2 projectedPosition = projection * glm::vec3(transformation * glm::vec4(vertices[vertexIndex].m_position, 1));
if (boundVertices[0].x > projectedPosition.x)
{
boundVertices[0] = projectedPosition;
}
if (boundVertices[1].y > projectedPosition.y)
{
boundVertices[1] = projectedPosition;
}
if (boundVertices[2].x < projectedPosition.x)
{
boundVertices[2] = projectedPosition;
}
if (boundVertices[3].y < projectedPosition.y)
{
boundVertices[3] = projectedPosition;
}
}
meshBounds = Box(glm::vec3(boundVertices[0].x, boundVertices[1].y, 0),glm::vec3(boundVertices[2].x, boundVertices[3].y, 0));
for (int i = 0; i < 4; ++i)
{
glm::vec2 projectedPosition = boundVertices[i];
glm::ivec2 scaledPosition = glm::ivec2(boundVertices[i] * accuracy);
if (std::find(positions.begin(), positions.end(), scaledPosition) == positions.end())
{
positions.push_back(scaledPosition);
}
uniquePositions.push_back(projectedPosition);
middlePoint += projectedPosition;
}
for (unsigned int vertexIndex = 0; vertexIndex < vertices.size(); ++vertexIndex)
{
glm::vec2 projectedPosition = projection * glm::vec3(transformation * glm::vec4(vertices[vertexIndex].m_position, 1));
glm::ivec2 scaledPosition = glm::ivec2(projectedPosition * accuracy);
if (std::find(positions.begin(), positions.end(), scaledPosition) == positions.end())
{
positions.push_back(scaledPosition);
uniquePositions.push_back(projectedPosition);
middlePoint += projectedPosition;
}
}
middlePoint /= uniquePositions.size();
std::sort(uniquePositions.begin(), uniquePositions.end(), [](const glm::vec2& a, const glm::vec2& b) { return a.x < b.x; });
bool firstRun = true;
while (nextPointIndex != startPointIndex || firstRun)
{
firstRun = false;
unsigned int pI1 = nextPointIndex;
glm::vec2 &p1(uniquePositions[pI1]);
bool foundExtremePoint = false;
for (unsigned int pI2 = 0; pI2 < uniquePositions.size() && !foundExtremePoint; ++pI2)
{
if (pI1 != pI2)
{
bool extremePoint = true;
glm::vec2 &p2(uniquePositions[pI2]);
for (unsigned int pI3 = 0; pI3 < uniquePositions.size() && extremePoint; ++pI3)
{
if (pI1 != pI3 && pI2 != pI3)
{
glm::vec2 &p3(uniquePositions[pI3]);
float side = VecHelper::sideOfPoint(p1, p2, p3);
if (side >= 0)
{
side = VecHelper::sideOfPoint(p1, p2, p3);
extremePoint = false;
}
}
}
if (extremePoint)
{
convexHullPositions.push_back(pI2);
nextPointIndex = pI2;
foundExtremePoint = true;
}
}
}
}
convexHullPositions.push_back(static_cast<int>(uniquePositions.size()));
uniquePositions.push_back(middlePoint);
std::vector<Vertex3DNormTex> meshVertices;
std::vector<GLuint> indices;
glm::vec3 invAxis1(axis1.x == 0 ? 0.0f : 1.0f / axis1.x, axis1.y == 0 ? 0.0f : 1.0f / axis1.y, axis1.z == 0 ? 0.0f : 1.0f / axis1.z);
glm::vec3 invAxis2(axis2.x == 0 ? 0.0f : 1.0f / axis2.x, axis2.y == 0 ? 0.0f : 1.0f / axis2.y, axis2.z == 0 ? 0.0f : 1.0f / axis2.z);
glm::mat2x3 projectionToWorld(invAxis1, invAxis2);
glm::vec3 normal(-glm::cross(axis1, axis2));
for (unsigned int convexHullPositionIndex = 0; convexHullPositionIndex < convexHullPositions.size(); ++convexHullPositionIndex)
{
glm::vec2 position = uniquePositions[convexHullPositions[convexHullPositionIndex]];
Vertex3DNormTex vertex;
vertex.m_position = projectionToWorld * position;
vertex.m_texCoord = glm::vec2((static_cast<float>(position.x) - meshBounds.getX()) / meshBounds.getWidth(), (static_cast<float>(position.y) - meshBounds.getY()) / meshBounds.getHeight());
vertex.m_normal = normal;
meshVertices.push_back(vertex);
if (convexHullPositionIndex < convexHullPositions.size() - 1)
{
indices.push_back(convexHullPositionIndex);
indices.push_back((convexHullPositionIndex + 1) % (static_cast<int>(convexHullPositions.size()) - 1));
indices.push_back(static_cast<int>(convexHullPositions.size()) - 1);
}
}
mesh->addVertex(meshVertices);
mesh->setIndices(indices);
return mesh;
}
WaterMesh::WaterMesh(const String& inMeshName, Real planeSize, int inComplexity)
{
int x,y,b; // I prefer to initialize for() variables inside it, but VC doesn't like it ;(
this->meshName = inMeshName ;
this->complexity = inComplexity ;
numFaces = 2 * complexity * complexity;
numVertices = (complexity + 1) * (complexity + 1) ;
lastTimeStamp = 0 ;
lastAnimationTimeStamp = 0;
lastFrameTime = 0 ;
// initialize algorithm parameters
PARAM_C = 0.3f ; // ripple speed
PARAM_D = 0.4f ; // distance
PARAM_U = 0.05f ; // viscosity
PARAM_T = 0.13f ; // time
useFakeNormals = false ;
// allocate space for normal calculation
vNormals = new Vector3[numVertices];
// create mesh and submesh
mesh = MeshManager::getSingleton().createManual(meshName,
ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME);
subMesh = mesh->createSubMesh();
subMesh->useSharedVertices=false;
// Vertex buffers
subMesh->vertexData = new VertexData();
subMesh->vertexData->vertexStart = 0;
subMesh->vertexData->vertexCount = numVertices;
VertexDeclaration* vdecl = subMesh->vertexData->vertexDeclaration;
VertexBufferBinding* vbind = subMesh->vertexData->vertexBufferBinding;
vdecl->addElement(0, 0, VET_FLOAT3, VES_POSITION);
vdecl->addElement(1, 0, VET_FLOAT3, VES_NORMAL);
vdecl->addElement(2, 0, VET_FLOAT2, VES_TEXTURE_COORDINATES);
// Prepare buffer for positions - todo: first attempt, slow
posVertexBuffer =
HardwareBufferManager::getSingleton().createVertexBuffer(
3*sizeof(float),
numVertices,
HardwareBuffer::HBU_DYNAMIC_WRITE_ONLY_DISCARDABLE);
vbind->setBinding(0, posVertexBuffer);
// Prepare buffer for normals - write only
normVertexBuffer =
HardwareBufferManager::getSingleton().createVertexBuffer(
3*sizeof(float),
numVertices,
HardwareBuffer::HBU_DYNAMIC_WRITE_ONLY_DISCARDABLE);
vbind->setBinding(1, normVertexBuffer);
// Prepare texture coords buffer - static one
// todo: optimize to write directly into buffer
float *texcoordsBufData = new float[numVertices*2];
for(y=0;y<=complexity;y++) {
for(x=0;x<=complexity;x++) {
texcoordsBufData[2*(y*(complexity+1)+x)+0] = (float)x / complexity ;
texcoordsBufData[2*(y*(complexity+1)+x)+1] = 1.0f - ((float)y / (complexity)) ;
}
}
texcoordsVertexBuffer =
HardwareBufferManager::getSingleton().createVertexBuffer(
2*sizeof(float),
numVertices,
HardwareBuffer::HBU_STATIC_WRITE_ONLY);
texcoordsVertexBuffer->writeData(0,
texcoordsVertexBuffer->getSizeInBytes(),
texcoordsBufData,
true); // true?
delete [] texcoordsBufData;
vbind->setBinding(2, texcoordsVertexBuffer);
// Prepare buffer for indices
indexBuffer =
HardwareBufferManager::getSingleton().createIndexBuffer(
HardwareIndexBuffer::IT_16BIT,
3*numFaces,
HardwareBuffer::HBU_STATIC, true);
unsigned short *faceVertexIndices = (unsigned short*)
indexBuffer->lock(0, numFaces*3*2, HardwareBuffer::HBL_DISCARD);
for(y=0 ; y<complexity ; y++) {
for(x=0 ; x<complexity ; x++) {
unsigned short *twoface = faceVertexIndices + (y*complexity+x)*2*3;
int p0 = y*(complexity+1) + x ;
int p1 = y*(complexity+1) + x + 1 ;
int p2 = (y+1)*(complexity+1) + x ;
int p3 = (y+1)*(complexity+1) + x + 1 ;
twoface[0]=p2; //first tri
twoface[1]=p1;
twoface[2]=p0;
twoface[3]=p2; //second tri
twoface[4]=p3;
twoface[5]=p1;
}
}
indexBuffer->unlock();
// Set index buffer for this submesh
subMesh->indexData->indexBuffer = indexBuffer;
subMesh->indexData->indexStart = 0;
subMesh->indexData->indexCount = 3*numFaces;
/* prepare vertex positions
* note - we use 3 vertex buffers, since algorighm uses two last phases
* to calculate the next one
*/
for(b=0;b<3;b++) {
vertexBuffers[b] = new float[numVertices * 3] ;
for(y=0;y<=complexity;y++) {
for(x=0;x<=complexity;x++) {
int numPoint = y*(complexity+1) + x ;
float* vertex = vertexBuffers[b] + 3*numPoint ;
vertex[0]=(float)(x) / (float)(complexity) * (float) planeSize ;
vertex[1]= 0 ; // rand() % 30 ;
vertex[2]=(float)(y) / (float)(complexity) * (float) planeSize ;
}
}
}
AxisAlignedBox meshBounds(0,0,0,
planeSize,0, planeSize);
mesh->_setBounds(meshBounds);
currentBuffNumber = 0 ;
posVertexBuffer->writeData(0,
posVertexBuffer->getSizeInBytes(), // size
vertexBuffers[currentBuffNumber], // source
true); // discard?
mesh->load();
mesh->touch();
}
bool Terrain::createTerrain()
{
if(mMainViewport == NULL)
mMainViewport = Core::getSingleton().mCamera->getViewport();
Ogre::CompositorManager::getSingleton().addCompositor(mMainViewport, "DemoCompositor");
Ogre::CompositorManager::getSingleton().setCompositorEnabled(mMainViewport, "DemoCompositor", true);
mMapData = MapDataManager::getSingletonPtr();
DataLibrary* datalib = DataLibrary::getSingletonPtr();
int terrainszie = mMapData->getMapSize() + 2 * MAPBOLDER + 1;
Core::getSingleton().mSceneMgr->setSkyBox(true, "SkyBox",200);
Ogre::GpuSharedParametersPtr sharedparams = Ogre::GpuProgramManager::getSingleton().getSharedParameters("TestSharedParamsName");
float border = mMapData->getMapSize() * 12.0f;
sharedparams->setNamedConstant("border", border);
//创建灯光
Core::getSingleton().mSceneMgr->setAmbientLight(Ogre::ColourValue(0.5f, 0.5f, 0.5f));
mLight = Core::getSingleton().mSceneMgr->createLight("TerrainLight");
mLight->setType(Ogre::Light::LT_DIRECTIONAL);
mLight->setPosition(-500.0f,500.0f, 500.0f);
mLight->setDirection(1.0f, -1.0f, -1.0f);
mLight->setDiffuseColour(Ogre::ColourValue(0.5f, 0.5f,0.5f));
mLight->setSpecularColour(Ogre::ColourValue(0.8f, 0.8f,0.8f));
//设置深度图投影
Ogre::TexturePtr tex = Ogre::TextureManager::getSingleton().getByName("shadowdepthmap");
if(tex.isNull())
tex = Ogre::TextureManager::getSingleton().createManual("shadowdepthmap",
Ogre::ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME, Ogre::TEX_TYPE_2D, 2048, 2048, 0, Ogre::PF_FLOAT16_R, Ogre::TU_RENDERTARGET);
mShadowDepthMapTarget = tex->getBuffer()->getRenderTarget();
Ogre::Viewport* vp = mShadowDepthMapTarget->addViewport(CameraContral::getSingleton().getShadowMapCamera());
vp->setSkiesEnabled(false);
vp->setOverlaysEnabled(false);
vp->setVisibilityMask(VISMASK_OPAQUE);
vp->setMaterialScheme("WriteDepthMap");
vp->setBackgroundColour(Ogre::ColourValue(1.0f,1.0f,1.0f));
mShadowDepthMapTarget->addListener(this);
//弱爆了……
Ogre::MaterialPtr mat;
mat = Ogre::MaterialManager::getSingleton().getByName("TerrainTile");
Ogre::AliasTextureNamePairList texAliasList;
std::string texname;
datalib->getData("GameData/BattleData/MapData/Ground/G0Tex",texname);
texAliasList.insert(std::make_pair("Diffuse",texname));
datalib->getData("GameData/BattleData/MapData/Ground/G1Tex",texname);
texAliasList.insert(std::make_pair("Diffuse1",texname));
datalib->getData("GameData/BattleData/MapData/Ground/G2Tex",texname);
texAliasList.insert(std::make_pair("Diffuse2",texname));
datalib->getData("GameData/BattleData/MapData/Ground/G3Tex",texname);
texAliasList.insert(std::make_pair("Diffuse3",texname));
mat->applyTextureAliases(texAliasList);
texAliasList.clear();
mat = Ogre::MaterialManager::getSingleton().getByName("CliffMat1");
datalib->getData("GameData/BattleData/MapData/Ground/G0Tex",texname);
texAliasList.insert(std::make_pair("Diffuse",texname));
texAliasList.insert(std::make_pair("Diffuse1","Cliff.tga"));
mat->applyTextureAliases(texAliasList);
texAliasList.clear();
mat = Ogre::MaterialManager::getSingleton().getByName("CliffMat2");
datalib->getData("GameData/BattleData/MapData/Ground/G1Tex",texname);
texAliasList.insert(std::make_pair("Diffuse",texname));
texAliasList.insert(std::make_pair("Diffuse1","Cliff.tga"));
mat->applyTextureAliases(texAliasList);
texAliasList.clear();
mat = Ogre::MaterialManager::getSingleton().getByName("CliffMat3");
datalib->getData("GameData/BattleData/MapData/Ground/G2Tex",texname);
texAliasList.insert(std::make_pair("Diffuse",texname));
texAliasList.insert(std::make_pair("Diffuse1","Cliff.tga"));
mat->applyTextureAliases(texAliasList);
texAliasList.clear();
mat = Ogre::MaterialManager::getSingleton().getByName("CliffMat4");
datalib->getData("GameData/BattleData/MapData/Ground/G3Tex",texname);
texAliasList.insert(std::make_pair("Diffuse",texname));
texAliasList.insert(std::make_pair("Diffuse1","Cliff.tga"));
mat->applyTextureAliases(texAliasList);
texAliasList.clear();
mat = Ogre::MaterialManager::getSingleton().getByName("BankMat1");
datalib->getData("GameData/BattleData/MapData/Ground/G0Tex",texname);
texAliasList.insert(std::make_pair("Diffuse",texname));
texAliasList.insert(std::make_pair("Diffuse1","Cliff.tga"));
mat->applyTextureAliases(texAliasList);
texAliasList.clear();
mat = Ogre::MaterialManager::getSingleton().getByName("BankMat2");
datalib->getData("GameData/BattleData/MapData/Ground/G1Tex",texname);
texAliasList.insert(std::make_pair("Diffuse",texname));
texAliasList.insert(std::make_pair("Diffuse1","Cliff.tga"));
mat->applyTextureAliases(texAliasList);
texAliasList.clear();
mat = Ogre::MaterialManager::getSingleton().getByName("BankMat3");
datalib->getData("GameData/BattleData/MapData/Ground/G2Tex",texname);
texAliasList.insert(std::make_pair("Diffuse",texname));
texAliasList.insert(std::make_pair("Diffuse1","Cliff.tga"));
mat->applyTextureAliases(texAliasList);
texAliasList.clear();
mat = Ogre::MaterialManager::getSingleton().getByName("BankMat4");
datalib->getData("GameData/BattleData/MapData/Ground/G3Tex",texname);
texAliasList.insert(std::make_pair("Diffuse",texname));
texAliasList.insert(std::make_pair("Diffuse1","Cliff.tga"));
mat->applyTextureAliases(texAliasList);
texAliasList.clear();
//创建地面Mesh
mTerrainNode = Core::getSingleton().mSceneMgr->getRootSceneNode()->createChildSceneNode("TerrainNode");
int numVertices = terrainszie * terrainszie * VERTEX_QUAD;
int numIndex = terrainszie * terrainszie * VERTEX_PREQUAD;
Ogre::MeshPtr mTerrainMesh = Ogre::MeshManager::getSingleton().createManual("TerrianMesh",
Ogre::ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME);
Ogre::SubMesh* subMesh = mTerrainMesh->createSubMesh();
subMesh->useSharedVertices=false;
subMesh->setMaterialName("TerrainTile");
// 创建顶点数据结构
subMesh->vertexData = new Ogre::VertexData();
subMesh->vertexData->vertexStart = 0;
subMesh->vertexData->vertexCount = numVertices;
//顶点声明与缓冲区绑定
Ogre::VertexDeclaration* vdecl = subMesh->vertexData->vertexDeclaration;
Ogre::VertexBufferBinding* vbind = subMesh->vertexData->vertexBufferBinding;
//设置顶点数据结构
size_t offsetUV = 0;
vdecl->addElement(VERTEX_POS_BINDING, 0, Ogre::VET_FLOAT3,Ogre::VES_POSITION);//向顶点添加一个位置元素
vdecl->addElement(VERTEX_NOM_BINDING, 0, Ogre::VET_FLOAT3,Ogre::VES_NORMAL);
for(int i = 0 ; i < TEXTURE_COUNT ; i ++)
{
offsetUV += vdecl->addElement (VERTEX_UV_BINDING, offsetUV, Ogre::VET_FLOAT2, Ogre::VES_TEXTURE_COORDINATES , i).getSize();
}
// 创建世界坐标顶点缓冲区
Ogre::HardwareVertexBufferSharedPtr vbufPos =
Ogre::HardwareBufferManager::getSingleton().createVertexBuffer(
vdecl->getVertexSize(VERTEX_POS_BINDING),
numVertices,
Ogre::HardwareBuffer::HBU_DYNAMIC_WRITE_ONLY);
vbind->setBinding(VERTEX_POS_BINDING, vbufPos);
Ogre::HardwareVertexBufferSharedPtr vbufNOM =
Ogre::HardwareBufferManager::getSingleton().createVertexBuffer(
vdecl->getVertexSize(VERTEX_NOM_BINDING),
numVertices,
Ogre::HardwareBuffer::HBU_DYNAMIC_WRITE_ONLY);
vbind->setBinding(VERTEX_NOM_BINDING, vbufNOM);
// 创建纹理坐标顶点缓冲区
Ogre::HardwareVertexBufferSharedPtr vbufUV =
Ogre::HardwareBufferManager::getSingleton().createVertexBuffer(
vdecl->getVertexSize(VERTEX_UV_BINDING),
numVertices,
Ogre::HardwareBuffer::HBU_DYNAMIC_WRITE_ONLY);
vbind->setBinding(VERTEX_UV_BINDING, vbufUV);
// 创建索引缓冲区
Ogre::HardwareIndexBufferSharedPtr indexBuffer =
Ogre::HardwareBufferManager::getSingleton().createIndexBuffer(
Ogre::HardwareIndexBuffer::IT_16BIT ,
numIndex,
Ogre::HardwareBuffer::HBU_STATIC_WRITE_ONLY);
//创建地形
float* pBufferPos = (float*)vbufPos->lock(Ogre::HardwareBuffer::HBL_DISCARD);
float* pBufferUV = (float*)vbufUV->lock(Ogre::HardwareBuffer::HBL_DISCARD);
float* pBufferNom = (float*)vbufNOM->lock(Ogre::HardwareBuffer::HBL_DISCARD);
float startpos = - terrainszie * TILESIZE / 2;
for(int y = 0 ; y < terrainszie; y ++)
{
for(int x = 0 ; x < terrainszie; x ++)
{
createTile(x, y, startpos + x * TILESIZE, startpos + y * TILESIZE, pBufferPos, pBufferUV, pBufferNom);
pBufferPos += 3 * VERTEX_QUAD ;
pBufferNom += 3 * VERTEX_QUAD ;
pBufferUV += 2 * VERTEX_QUAD * 4;
}
}
vbufNOM->unlock();
vbufUV->unlock();
vbufPos->unlock();
//写入索引信息
// 锁定索引缓冲区
Ogre::ushort* pIdx = (Ogre::ushort*)indexBuffer->lock(Ogre::HardwareBuffer::HBL_DISCARD);
for(int y = 0 ; y < terrainszie ; y ++)
{
for(int x = 0 ; x < terrainszie ; x ++)
{
Ogre::ushort iIndexTopLeft = (x + y * terrainszie) * VERTEX_QUAD;
Ogre::ushort iIndexTopRight = iIndexTopLeft + 1;
Ogre::ushort iIndexBottomLeft = iIndexTopLeft + 2;
Ogre::ushort iIndexBottomRight = iIndexTopLeft + 3;
*pIdx++ = iIndexBottomLeft;
*pIdx++ = iIndexBottomRight;
*pIdx++ = iIndexTopLeft;
*pIdx++ = iIndexBottomRight;
*pIdx++ = iIndexTopRight;
*pIdx++ = iIndexTopLeft;
}
}
indexBuffer->unlock();
//设置模型的的索引数据
subMesh->indexData->indexBuffer = indexBuffer;
subMesh->indexData->indexStart = 0;
subMesh->indexData->indexCount =numIndex;
Ogre::AxisAlignedBox meshBounds(startpos,0,startpos,
-startpos,5,-startpos);
mTerrainMesh->_setBounds(meshBounds);
mTerrainEntity = Core::getSingleton().mSceneMgr->createEntity("TerrianMesh");
mTerrainNode->attachObject(mTerrainEntity);
mTerrainEntity->setQueryFlags(QUERYMASK_TERRAIN);
mTerrainNode->setPosition(0,0,0);
//创建水面
tex = Ogre::TextureManager::getSingleton().getByName("reflection");
if(tex.isNull())
tex = Ogre::TextureManager::getSingleton().createManual("reflection",
Ogre::ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME, Ogre::TEX_TYPE_2D, 512, 512, 0, Ogre::PF_R8G8B8, Ogre::TU_RENDERTARGET);
mReflectionTarget = tex->getBuffer()->getRenderTarget();
mReflectionTarget->addViewport(Core::getSingleton().mCamera)->setOverlaysEnabled(false);
mReflectionTarget->addListener(this);
// mat = Ogre::MaterialManager::getSingleton().getByName("ReflectionWater");
// tech = mat->getTechnique(0);
// pass = tech->getPass(0);
// tu = pass->getTextureUnitState(1);
// tu->setTextureName(tex->getName());
mWaterPlane = Ogre::Plane(Ogre::Vector3::UNIT_Y, WATERHEIGHT);
mWaterNode = Core::getSingleton().mSceneMgr->getRootSceneNode()->createChildSceneNode("WaterNode");
mWaterObject = Core::getSingleton().mSceneMgr->createManualObject("WaterObject");
mWaterObject->begin("DemoWater",Ogre::RenderOperation::OT_TRIANGLE_LIST);
startpos += TILESIZE/2;
for(int y = 0; y < terrainszie; y++)
for(int x = 0; x < terrainszie; x++)
{
if(mMapData->getTerrainType(x -MAPBOLDER, y -MAPBOLDER ) == Water)
{
mWaterObject->position(startpos + x * TILESIZE, 0.0f, startpos + y * TILESIZE);
mWaterObject->colour(1.0f,1.0f,1.0f);
mWaterObject->normal(0.0f,1.0f,0.0f);
mWaterObject->textureCoord(0.0f,0.0f);
mWaterObject->position(startpos + (x+1) * TILESIZE, 0.0f, startpos + (y+1) * TILESIZE);
mWaterObject->colour(1.0f,1.0f,1.0f);
mWaterObject->normal(0.0f,1.0f,0.0f);
mWaterObject->textureCoord(1.0f,1.0f);
mWaterObject->position(startpos + (x+1) * TILESIZE, 0.0f, startpos + y * TILESIZE);
mWaterObject->colour(1.0f,1.0f,1.0f);
mWaterObject->normal(0.0f,1.0f,0.0f);
mWaterObject->textureCoord(1.0f,0.0f);
mWaterObject->position(startpos + (x+1) * TILESIZE, 0.0f, startpos + (y+1) * TILESIZE);
mWaterObject->colour(1.0f,1.0f,1.0f);
mWaterObject->normal(0.0f,1.0f,0.0f);
mWaterObject->textureCoord(1.0f,1.0f);
mWaterObject->position(startpos + x * TILESIZE, 0.0f, startpos + y * TILESIZE);
mWaterObject->colour(1.0f,1.0f,1.0f);
mWaterObject->normal(0.0f,1.0f,0.0f);
mWaterObject->textureCoord(0.0f,0.0f);
mWaterObject->position(startpos + x * TILESIZE, 0.0f, startpos + (y+1) * TILESIZE);
mWaterObject->colour(1.0f,1.0f,1.0f);
mWaterObject->normal(0.0f,1.0f,0.0f);
mWaterObject->textureCoord(0.0f,1.0f);
}
}
mWaterObject->end();
mWaterNode->attachObject(mWaterObject);
mWaterNode->setPosition(0,WATERHEIGHT,0);
//设置摄像机移动范围
float minx = 0.0f;// = ( - (float)(terrainszie - 2 * MAPBOLDER) / 2.0f - 1.0f) * TILESIZE ;
getWorldCoords(0,0,minx,minx);
minx -= TILESIZE/2;
CameraContral::getSingleton().setMoveRect(minx, minx);
CameraContral::getSingleton().resetCamera();
//深度投影测试
// Ogre::MeshManager::getSingleton().createPlane("testplane", Ogre::ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME,
// mWaterPlane, 64, 64, 1, 1, true, 1, 1, 1, Ogre::Vector3::UNIT_Z);
// Ogre::Entity* testent = Core::getSingleton().mSceneMgr->createEntity("testplaneent", "testplane");
// testent->setMaterialName("DepthTest");
// Ogre::SceneNode* testnode = Core::getSingleton().mSceneMgr->getRootSceneNode()->createChildSceneNode();
// testnode->attachObject(testent);
// testnode->setPosition(0.0f,10.0f,0.0f);
return true;
}
