2015-04-03 13:49:07 +08:00
|
|
|
/****************************************************************************
|
2018-01-29 16:25:32 +08:00
|
|
|
Copyright (c) 2015-2016 Chukong Technologies Inc.
|
|
|
|
Copyright (c) 2017-2018 Xiamen Yaji Software Co., Ltd.
|
2015-04-03 13:49:07 +08:00
|
|
|
|
|
|
|
http://www.cocos2d-x.org
|
|
|
|
|
|
|
|
Permission is hereby granted, free of charge, to any person obtaining a copy
|
|
|
|
of this software and associated documentation files (the "Software"), to deal
|
|
|
|
in the Software without restriction, including without limitation the rights
|
|
|
|
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
|
|
|
copies of the Software, and to permit persons to whom the Software is
|
|
|
|
furnished to do so, subject to the following conditions:
|
|
|
|
|
|
|
|
The above copyright notice and this permission notice shall be included in
|
|
|
|
all copies or substantial portions of the Software.
|
|
|
|
|
|
|
|
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
|
|
|
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
|
|
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
|
|
|
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
|
|
|
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
|
|
|
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
|
|
|
|
THE SOFTWARE.
|
|
|
|
****************************************************************************/
|
|
|
|
|
2016-03-20 21:53:44 +08:00
|
|
|
#include "3d/CCTerrain.h"
|
2015-04-03 13:49:07 +08:00
|
|
|
|
2015-01-15 11:45:06 +08:00
|
|
|
USING_NS_CC;
|
2015-04-03 13:49:07 +08:00
|
|
|
#include <stdlib.h>
|
2015-06-24 15:49:09 +08:00
|
|
|
#include <float.h>
|
|
|
|
#include <set>
|
2015-01-15 11:45:06 +08:00
|
|
|
#include "renderer/CCRenderer.h"
|
2019-02-27 17:16:25 +08:00
|
|
|
#include "renderer/ccShaders.h"
|
|
|
|
#include "renderer/backend/Device.h"
|
|
|
|
#include "renderer/backend/Program.h"
|
|
|
|
#include "renderer/backend/Buffer.h"
|
2015-03-30 18:25:22 +08:00
|
|
|
#include "base/CCDirector.h"
|
2015-04-08 19:11:46 +08:00
|
|
|
#include "base/CCEventType.h"
|
2015-06-24 15:49:09 +08:00
|
|
|
#include "2d/CCCamera.h"
|
2016-03-21 21:04:06 +08:00
|
|
|
#include "platform/CCImage.h"
|
2019-02-27 17:16:25 +08:00
|
|
|
#include "3d/CC3DProgramInfo.h"
|
2015-01-23 18:09:54 +08:00
|
|
|
|
2015-01-20 10:34:30 +08:00
|
|
|
NS_CC_BEGIN
|
2015-04-03 13:49:07 +08:00
|
|
|
|
2019-03-13 16:05:02 +08:00
|
|
|
namespace {
|
|
|
|
//It's used for creating a default texture when lightMap is nullpter
|
|
|
|
static unsigned char cc_2x2_white_image[] = {
|
|
|
|
// RGBA8888
|
|
|
|
0xFF, 0xFF, 0xFF, 0xFF,
|
|
|
|
0xFF, 0xFF, 0xFF, 0xFF,
|
|
|
|
0xFF, 0xFF, 0xFF, 0xFF,
|
|
|
|
0xFF, 0xFF, 0xFF, 0xFF
|
|
|
|
};
|
|
|
|
|
|
|
|
// check a number is power of two.
|
|
|
|
static bool isPOT(int number)
|
|
|
|
{
|
|
|
|
bool flag = false;
|
|
|
|
if ((number > 0) && (number&(number - 1)) == 0)
|
|
|
|
flag = true;
|
|
|
|
return flag;
|
|
|
|
}
|
2015-04-03 13:49:07 +08:00
|
|
|
}
|
|
|
|
|
2015-03-30 18:25:22 +08:00
|
|
|
Terrain * Terrain::create(TerrainData ¶meter, CrackFixedType fixedType)
|
2015-01-15 11:45:06 +08:00
|
|
|
{
|
2015-01-30 15:46:39 +08:00
|
|
|
Terrain * terrain = new (std::nothrow)Terrain();
|
2015-07-31 18:35:47 +08:00
|
|
|
if (terrain->initWithTerrainData(parameter, fixedType))
|
2015-07-30 17:17:57 +08:00
|
|
|
{
|
|
|
|
terrain->autorelease();
|
|
|
|
return terrain;
|
|
|
|
}
|
|
|
|
CC_SAFE_DELETE(terrain);
|
|
|
|
return terrain;
|
|
|
|
}
|
2015-07-31 18:35:47 +08:00
|
|
|
bool Terrain::initWithTerrainData(TerrainData ¶meter, CrackFixedType fixedType)
|
2015-07-30 17:17:57 +08:00
|
|
|
{
|
|
|
|
this->setSkirtHeightRatio(parameter._skirtHeightRatio);
|
|
|
|
this->_terrainData = parameter;
|
|
|
|
this->_crackFixedType = fixedType;
|
|
|
|
this->_isCameraViewChanged = true;
|
2015-01-15 11:45:06 +08:00
|
|
|
//chunksize
|
2015-07-30 17:17:57 +08:00
|
|
|
this->_chunkSize = parameter._chunkSize;
|
|
|
|
bool initResult = true;
|
2015-04-01 18:24:05 +08:00
|
|
|
|
2015-04-03 13:49:07 +08:00
|
|
|
//init heightmap
|
2016-02-03 23:12:37 +08:00
|
|
|
initResult &= this->initHeightMap(parameter._heightMapSrc);
|
2015-04-03 13:49:07 +08:00
|
|
|
//init textures alpha map,detail Maps
|
2015-07-30 17:17:57 +08:00
|
|
|
initResult &= this->initTextures();
|
|
|
|
initResult &= this->initProperties();
|
2016-03-21 21:04:06 +08:00
|
|
|
|
2015-07-30 17:17:57 +08:00
|
|
|
return initResult;
|
2015-01-15 11:45:06 +08:00
|
|
|
}
|
|
|
|
|
2015-07-29 14:32:36 +08:00
|
|
|
void cocos2d::Terrain::setLightMap(const std::string& fileName)
|
2015-07-29 13:24:12 +08:00
|
|
|
{
|
2015-08-03 10:27:57 +08:00
|
|
|
CC_SAFE_RELEASE(_lightMap);
|
2015-07-29 13:24:12 +08:00
|
|
|
auto image = new (std::nothrow)Image();
|
|
|
|
image->initWithImageFile(fileName);
|
|
|
|
_lightMap = new (std::nothrow)Texture2D();
|
|
|
|
_lightMap->initWithImage(image);
|
|
|
|
|
|
|
|
Texture2D::TexParams tRepeatParams;//set texture parameters
|
2019-03-12 16:26:41 +08:00
|
|
|
tRepeatParams.magFilter = tRepeatParams.minFilter = backend::SamplerFilter::LINEAR;
|
2019-03-13 10:54:26 +08:00
|
|
|
tRepeatParams.sAddressMode = backend::SamplerAddressMode::REPEAT;
|
|
|
|
tRepeatParams.tAddressMode = backend::SamplerAddressMode::REPEAT;
|
2015-07-29 13:24:12 +08:00
|
|
|
_lightMap->setTexParameters(tRepeatParams);
|
|
|
|
|
|
|
|
}
|
|
|
|
|
2015-07-29 14:32:36 +08:00
|
|
|
void cocos2d::Terrain::setLightDir(const Vec3& lightDir)
|
2015-07-29 13:24:12 +08:00
|
|
|
{
|
|
|
|
_lightDir = lightDir;
|
|
|
|
}
|
|
|
|
|
2015-04-03 13:49:07 +08:00
|
|
|
bool Terrain::initProperties()
|
2015-01-15 11:45:06 +08:00
|
|
|
{
|
2019-10-15 09:40:59 +08:00
|
|
|
auto* program = backend::Program::getBuiltinProgram(backend::ProgramType::TERRAIN_3D);
|
|
|
|
_programState = new backend::ProgramState(program);
|
2015-04-07 18:47:19 +08:00
|
|
|
|
2019-02-27 17:16:25 +08:00
|
|
|
_stateBlock.depthWrite = true;
|
|
|
|
_stateBlock.depthTest = true;
|
|
|
|
_stateBlock.cullFace = backend::CullMode::FRONT;
|
2015-05-20 08:18:44 +08:00
|
|
|
|
2015-01-15 11:45:06 +08:00
|
|
|
setDrawWire(false);
|
|
|
|
setIsEnableFrustumCull(true);
|
2019-02-27 17:16:25 +08:00
|
|
|
setAnchorPoint(Vec2(0, 0));
|
2015-01-15 11:45:06 +08:00
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2015-01-20 10:34:30 +08:00
|
|
|
void Terrain::draw(cocos2d::Renderer *renderer, const cocos2d::Mat4 &transform, uint32_t flags)
|
2015-01-15 11:45:06 +08:00
|
|
|
{
|
2015-05-26 17:51:26 +08:00
|
|
|
auto modelMatrix = getNodeToWorldTransform();
|
2019-02-27 17:16:25 +08:00
|
|
|
if (memcmp(&modelMatrix, &_terrainModelMatrix, sizeof(Mat4)) != 0)
|
2015-05-26 17:51:26 +08:00
|
|
|
{
|
|
|
|
_terrainModelMatrix = modelMatrix;
|
|
|
|
_quadRoot->preCalculateAABB(_terrainModelMatrix);
|
|
|
|
}
|
2016-03-21 21:04:06 +08:00
|
|
|
|
2019-03-06 17:03:16 +08:00
|
|
|
auto &projectionMatrix = Director::getInstance()->getMatrix(MATRIX_STACK_TYPE::MATRIX_STACK_PROJECTION);
|
|
|
|
auto finalMatrix = projectionMatrix * transform;
|
2019-02-27 17:16:25 +08:00
|
|
|
_programState->setUniform(_mvpMatrixLocation, &finalMatrix.m, sizeof(finalMatrix.m));
|
|
|
|
|
|
|
|
_programState->setUniform(_lightDirLocation, &_lightDir, sizeof(_lightDir));
|
|
|
|
if (!_alphaMap)
|
|
|
|
{
|
|
|
|
_programState->setTexture(_detailMapLocation[0], 0, _detailMapTextures[0]->getBackendTexture());
|
|
|
|
int hasAlphaMap = 0;
|
|
|
|
_programState->setUniform(_alphaIsHasAlphaMapLocation, &hasAlphaMap, sizeof(hasAlphaMap));
|
2018-09-11 14:39:30 +08:00
|
|
|
}
|
|
|
|
else
|
2015-01-15 11:45:06 +08:00
|
|
|
{
|
2019-02-27 17:16:25 +08:00
|
|
|
float detailMapSize[4] = { 0.0f, 0.0f, 0.0f, 0.0f };
|
|
|
|
for (int i = 0; i < _maxDetailMapValue; ++i)
|
2015-01-15 11:45:06 +08:00
|
|
|
{
|
2019-02-27 17:16:25 +08:00
|
|
|
_programState->setTexture(_detailMapLocation[i], i, _detailMapTextures[i]->getBackendTexture());
|
|
|
|
detailMapSize[i] = _terrainData._detailMaps[i]._detailMapSize;
|
2015-01-15 11:45:06 +08:00
|
|
|
}
|
2019-02-27 17:16:25 +08:00
|
|
|
_programState->setUniform(_detailMapSizeLocation, detailMapSize, sizeof(detailMapSize));
|
2015-01-30 15:46:39 +08:00
|
|
|
|
2019-02-27 17:16:25 +08:00
|
|
|
int hasAlphaMap = 1;
|
|
|
|
_programState->setUniform(_alphaIsHasAlphaMapLocation, &hasAlphaMap, sizeof(hasAlphaMap));
|
|
|
|
_programState->setTexture(_alphaMapLocation, 4, _alphaMap->getBackendTexture());
|
2015-01-15 11:45:06 +08:00
|
|
|
}
|
2015-07-29 13:24:12 +08:00
|
|
|
if (_lightMap)
|
|
|
|
{
|
2019-02-27 17:16:25 +08:00
|
|
|
int hasLightMap = 1;
|
|
|
|
_programState->setUniform(_lightMapCheckLocation, &hasLightMap, sizeof(hasLightMap));
|
|
|
|
_programState->setTexture(_lightMapLocation, 5, _lightMap->getBackendTexture());
|
|
|
|
}
|
|
|
|
else
|
2015-07-29 13:24:12 +08:00
|
|
|
{
|
2019-02-27 17:16:25 +08:00
|
|
|
int hasLightMap = 0;
|
|
|
|
_programState->setUniform(_lightMapCheckLocation, &hasLightMap, sizeof(hasLightMap));
|
2019-03-13 16:05:02 +08:00
|
|
|
#ifdef CC_USE_METAL
|
|
|
|
_programState->setTexture(_lightMapLocation, 5, _dummyTexture->getBackendTexture());
|
|
|
|
#endif
|
2015-07-29 13:24:12 +08:00
|
|
|
}
|
2015-01-15 11:45:06 +08:00
|
|
|
auto camera = Camera::getVisitingCamera();
|
2015-03-03 14:14:50 +08:00
|
|
|
|
2019-02-27 17:16:25 +08:00
|
|
|
if (memcmp(&_CameraMatrix, &camera->getViewMatrix(), sizeof(Mat4)) != 0)
|
2015-03-03 14:14:50 +08:00
|
|
|
{
|
|
|
|
_isCameraViewChanged = true;
|
|
|
|
_CameraMatrix = camera->getViewMatrix();
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2019-02-27 17:16:25 +08:00
|
|
|
if (_isCameraViewChanged)
|
2015-03-03 14:14:50 +08:00
|
|
|
{
|
2015-06-17 15:58:17 +08:00
|
|
|
auto m = camera->getNodeToWorldTransform();
|
2015-03-03 14:14:50 +08:00
|
|
|
//set lod
|
2015-06-16 17:46:21 +08:00
|
|
|
setChunksLOD(Vec3(m.m[12], m.m[13], m.m[14]));
|
2015-03-03 14:14:50 +08:00
|
|
|
}
|
|
|
|
|
2019-02-27 17:16:25 +08:00
|
|
|
if (_isCameraViewChanged)
|
2015-03-03 14:14:50 +08:00
|
|
|
{
|
2016-03-21 21:04:06 +08:00
|
|
|
_quadRoot->resetNeedDraw(true);//reset it
|
2015-03-03 14:14:50 +08:00
|
|
|
//camera frustum culling
|
2015-07-29 13:24:12 +08:00
|
|
|
if (_isEnableFrustumCull)
|
|
|
|
{
|
|
|
|
_quadRoot->cullByCamera(camera, _terrainModelMatrix);
|
|
|
|
}
|
2015-03-03 14:14:50 +08:00
|
|
|
}
|
2015-03-27 13:43:09 +08:00
|
|
|
_quadRoot->draw();
|
2019-02-27 17:16:25 +08:00
|
|
|
if (_isCameraViewChanged)
|
2015-03-03 14:14:50 +08:00
|
|
|
{
|
|
|
|
_isCameraViewChanged = false;
|
|
|
|
}
|
2015-05-20 08:18:44 +08:00
|
|
|
|
2015-01-30 15:46:39 +08:00
|
|
|
}
|
2015-01-15 11:45:06 +08:00
|
|
|
|
2015-11-12 18:08:29 +08:00
|
|
|
bool Terrain::initHeightMap(const std::string& heightMap)
|
2015-01-15 11:45:06 +08:00
|
|
|
{
|
2015-12-16 14:02:55 +08:00
|
|
|
_heightMapImage = new (std::nothrow) Image();
|
2015-01-23 18:09:54 +08:00
|
|
|
_heightMapImage->initWithImageFile(heightMap);
|
|
|
|
_data = _heightMapImage->getData();
|
2019-02-27 17:16:25 +08:00
|
|
|
_imageWidth = _heightMapImage->getWidth();
|
|
|
|
_imageHeight = _heightMapImage->getHeight();
|
2015-03-27 10:12:24 +08:00
|
|
|
|
2015-04-03 13:49:07 +08:00
|
|
|
//only the image size is the Powers Of Two(POT) or POT+1
|
2019-02-27 17:16:25 +08:00
|
|
|
if ((isPOT(_imageWidth) && isPOT(_imageHeight)) || (isPOT(_imageWidth - 1) && isPOT(_imageHeight - 1)))
|
2015-01-15 11:45:06 +08:00
|
|
|
{
|
2019-02-27 17:16:25 +08:00
|
|
|
int chunk_amount_y = _imageHeight / _chunkSize.height;
|
|
|
|
int chunk_amount_x = _imageWidth / _chunkSize.width;
|
2015-04-03 13:49:07 +08:00
|
|
|
loadVertices();
|
|
|
|
calculateNormal();
|
|
|
|
memset(_chunkesArray, 0, sizeof(_chunkesArray));
|
|
|
|
|
2019-02-27 17:16:25 +08:00
|
|
|
for (int m = 0; m < chunk_amount_y; m++)
|
2015-01-15 11:45:06 +08:00
|
|
|
{
|
2019-02-27 17:16:25 +08:00
|
|
|
for (int n = 0; n < chunk_amount_x; n++)
|
2015-04-03 13:49:07 +08:00
|
|
|
{
|
2019-02-27 17:16:25 +08:00
|
|
|
_chunkesArray[m][n] = new (std::nothrow) Chunk(this);
|
2015-04-03 13:49:07 +08:00
|
|
|
_chunkesArray[m][n]->_size = _chunkSize;
|
2019-02-27 17:16:25 +08:00
|
|
|
_chunkesArray[m][n]->generate(_imageWidth, _imageHeight, m, n, _data);
|
2015-04-03 13:49:07 +08:00
|
|
|
}
|
2015-01-15 11:45:06 +08:00
|
|
|
}
|
2015-03-27 10:12:24 +08:00
|
|
|
|
2015-04-03 13:49:07 +08:00
|
|
|
//calculate the neighbor
|
2019-02-27 17:16:25 +08:00
|
|
|
for (int m = 0; m < chunk_amount_y; m++)
|
2015-01-15 11:45:06 +08:00
|
|
|
{
|
2019-02-27 17:16:25 +08:00
|
|
|
for (int n = 0; n < chunk_amount_x; n++)
|
2015-04-03 13:49:07 +08:00
|
|
|
{
|
2019-02-27 17:16:25 +08:00
|
|
|
if (n - 1 >= 0) _chunkesArray[m][n]->_left = _chunkesArray[m][n - 1];
|
|
|
|
if (n + 1 < chunk_amount_x) _chunkesArray[m][n]->_right = _chunkesArray[m][n + 1];
|
|
|
|
if (m - 1 >= 0) _chunkesArray[m][n]->_back = _chunkesArray[m - 1][n];
|
|
|
|
if (m + 1 < chunk_amount_y) _chunkesArray[m][n]->_front = _chunkesArray[m + 1][n];
|
2015-04-03 13:49:07 +08:00
|
|
|
}
|
2015-01-15 11:45:06 +08:00
|
|
|
}
|
2019-02-27 17:16:25 +08:00
|
|
|
_quadRoot = new (std::nothrow) QuadTree(0, 0, _imageWidth, _imageHeight, this);
|
|
|
|
setLODDistance(_chunkSize.width, 2 * _chunkSize.width, 3 * _chunkSize.width);
|
2015-04-03 13:49:07 +08:00
|
|
|
return true;
|
2019-02-27 17:16:25 +08:00
|
|
|
}
|
|
|
|
else
|
2015-04-03 13:49:07 +08:00
|
|
|
{
|
|
|
|
CCLOG("warning: the height map size is not POT or POT + 1");
|
|
|
|
return false;
|
2015-01-15 11:45:06 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-01-20 10:34:30 +08:00
|
|
|
Terrain::Terrain()
|
2019-02-27 17:16:25 +08:00
|
|
|
: _alphaMap(nullptr)
|
|
|
|
, _lightMap(nullptr)
|
|
|
|
, _lightDir(-1.f, -1.f, 0.f)
|
2018-09-10 15:04:35 +08:00
|
|
|
#if CC_ENABLE_CACHE_TEXTURE_DATA
|
2019-02-27 17:16:25 +08:00
|
|
|
, _backToForegroundListener(nullptr)
|
2018-09-10 15:04:35 +08:00
|
|
|
#endif
|
2015-01-15 11:45:06 +08:00
|
|
|
{
|
2018-09-10 15:04:35 +08:00
|
|
|
#if CC_ENABLE_CACHE_TEXTURE_DATA
|
|
|
|
_backToForegroundListener = EventListenerCustom::create(EVENT_RENDERER_RECREATED,
|
2015-04-08 19:11:46 +08:00
|
|
|
[this](EventCustom*)
|
|
|
|
{
|
|
|
|
reload();
|
|
|
|
}
|
|
|
|
);
|
2015-04-10 14:22:07 +08:00
|
|
|
Director::getInstance()->getEventDispatcher()->addEventListenerWithFixedPriority(_backToForegroundListener, 1);
|
|
|
|
#endif
|
2019-03-13 16:05:02 +08:00
|
|
|
#ifdef CC_USE_METAL
|
|
|
|
auto image = new (std::nothrow)Image();
|
|
|
|
bool CC_UNUSED isOK = image->initWithRawData(cc_2x2_white_image, sizeof(cc_2x2_white_image), 2, 2, 8);
|
|
|
|
CCASSERT(isOK, "The 2x2 empty texture was created unsuccessfully.");
|
|
|
|
_dummyTexture = new (std::nothrow)Texture2D();
|
|
|
|
_dummyTexture->initWithImage(image);
|
|
|
|
CC_SAFE_RELEASE(image);
|
|
|
|
#endif
|
2015-01-15 11:45:06 +08:00
|
|
|
}
|
|
|
|
|
2016-05-17 12:17:56 +08:00
|
|
|
void Terrain::setChunksLOD(const Vec3& cameraPos)
|
2015-01-15 11:45:06 +08:00
|
|
|
{
|
2019-02-27 17:16:25 +08:00
|
|
|
int chunk_amount_y = _imageHeight / _chunkSize.height;
|
|
|
|
int chunk_amount_x = _imageWidth / _chunkSize.width;
|
|
|
|
for (int m = 0; m < chunk_amount_y; m++)
|
|
|
|
for (int n = 0; n < chunk_amount_x; n++)
|
2015-01-15 11:45:06 +08:00
|
|
|
{
|
2015-03-03 14:14:50 +08:00
|
|
|
AABB aabb = _chunkesArray[m][n]->_parent->_worldSpaceAABB;
|
2015-01-15 11:45:06 +08:00
|
|
|
auto center = aabb.getCenter();
|
2015-06-16 17:46:21 +08:00
|
|
|
float dist = Vec2(center.x, center.z).distance(Vec2(cameraPos.x, cameraPos.z));
|
2015-01-15 11:45:06 +08:00
|
|
|
_chunkesArray[m][n]->_currentLod = 3;
|
2019-02-27 17:16:25 +08:00
|
|
|
for (int i = 0; i < 3; ++i)
|
2015-01-15 11:45:06 +08:00
|
|
|
{
|
2019-02-27 17:16:25 +08:00
|
|
|
if (dist <= _lodDistance[i])
|
2015-01-23 18:09:54 +08:00
|
|
|
{
|
2015-01-15 11:45:06 +08:00
|
|
|
_chunkesArray[m][n]->_currentLod = i;
|
|
|
|
break;
|
2015-01-23 18:09:54 +08:00
|
|
|
}
|
2015-01-15 11:45:06 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-05-27 18:19:44 +08:00
|
|
|
float Terrain::getHeight(float x, float z, Vec3 * normal) const
|
2015-01-15 11:45:06 +08:00
|
|
|
{
|
2019-02-27 17:16:25 +08:00
|
|
|
Vec2 pos(x, z);
|
2015-01-15 11:45:06 +08:00
|
|
|
|
|
|
|
//top-left
|
2019-02-27 17:16:25 +08:00
|
|
|
Vec2 tl(-1 * _terrainData._mapScale*_imageWidth / 2, -1 * _terrainData._mapScale*_imageHeight / 2);
|
2017-02-09 10:55:24 +08:00
|
|
|
auto mulResult = getNodeToWorldTransform() * Vec4(tl.x, 0.0f, tl.y, 1.0f);
|
|
|
|
tl.set(mulResult.x, mulResult.z);
|
2015-01-15 11:45:06 +08:00
|
|
|
|
|
|
|
Vec2 to_tl = pos - tl;
|
|
|
|
|
|
|
|
//real size
|
2019-02-27 17:16:25 +08:00
|
|
|
Vec2 size(_imageWidth*_terrainData._mapScale, _imageHeight*_terrainData._mapScale);
|
2017-02-09 10:55:24 +08:00
|
|
|
mulResult = getNodeToWorldTransform() * Vec4(size.x, 0.0f, size.y, 0.0f);
|
|
|
|
size.set(mulResult.x, mulResult.z);
|
2015-01-15 11:45:06 +08:00
|
|
|
|
2019-02-27 17:16:25 +08:00
|
|
|
float width_ratio = to_tl.x / size.x;
|
|
|
|
float height_ratio = to_tl.y / size.y;
|
2015-01-15 11:45:06 +08:00
|
|
|
|
2015-04-02 14:04:31 +08:00
|
|
|
float image_x = width_ratio * _imageWidth;
|
|
|
|
float image_y = height_ratio * _imageHeight;
|
2019-02-27 17:16:25 +08:00
|
|
|
float u = image_x - (int)image_x;
|
|
|
|
float v = image_y - (int)image_y;
|
2015-01-15 11:45:06 +08:00
|
|
|
float i = (int)image_x;
|
|
|
|
float j = (int)image_y;
|
2015-01-27 15:18:59 +08:00
|
|
|
|
|
|
|
|
2019-02-27 17:16:25 +08:00
|
|
|
if (image_x >= _imageWidth - 1 || image_y >= _imageHeight - 1 || image_x < 0 || image_y < 0)
|
2015-01-15 11:45:06 +08:00
|
|
|
{
|
2015-05-22 09:07:57 +08:00
|
|
|
if (normal)
|
|
|
|
{
|
|
|
|
normal->setZero();
|
|
|
|
}
|
2015-01-30 15:46:39 +08:00
|
|
|
return 0;
|
2019-02-27 17:16:25 +08:00
|
|
|
}
|
|
|
|
else
|
2015-01-15 11:45:06 +08:00
|
|
|
{
|
2019-02-27 17:16:25 +08:00
|
|
|
float a = getImageHeight(i, j)*getScaleY();
|
|
|
|
float b = getImageHeight(i, j + 1)*getScaleY();
|
|
|
|
float c = getImageHeight(i + 1, j)*getScaleY();
|
|
|
|
float d = getImageHeight(i + 1, j + 1)*getScaleY();
|
|
|
|
if (normal)
|
2015-01-27 15:18:59 +08:00
|
|
|
{
|
|
|
|
normal->x = c - b;
|
|
|
|
normal->y = 2;
|
|
|
|
normal->z = d - a;
|
|
|
|
normal->normalize();
|
|
|
|
//(*normal) = (1-u)*(1-v)*getNormal(i,j)+ (1-u)*v*getNormal(i,j+1) + u*(1-v)*getNormal(i+1,j)+ u*v*getNormal(i+1,j+1);
|
|
|
|
}
|
2019-02-27 17:16:25 +08:00
|
|
|
float result = (1 - u)*(1 - v)*getImageHeight(i, j)*getScaleY() + (1 - u)*v*getImageHeight(i, j + 1)*getScaleY() + u * (1 - v)*getImageHeight(i + 1, j)*getScaleY() + u * v*getImageHeight(i + 1, j + 1)*getScaleY();
|
2016-10-20 18:17:37 +08:00
|
|
|
return result;
|
2015-01-15 11:45:06 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-05-17 12:17:56 +08:00
|
|
|
float Terrain::getHeight(const Vec2& pos, Vec3* normal) const
|
2015-01-15 11:45:06 +08:00
|
|
|
{
|
2016-05-17 12:17:56 +08:00
|
|
|
return getHeight(pos.x, pos.y, normal);
|
2015-01-15 11:45:06 +08:00
|
|
|
}
|
|
|
|
|
2019-02-27 17:16:25 +08:00
|
|
|
float Terrain::getImageHeight(int pixel_x, int pixel_y) const
|
2015-01-15 11:45:06 +08:00
|
|
|
{
|
2019-02-27 17:16:25 +08:00
|
|
|
int byte_stride = 1;
|
2019-01-30 09:35:17 +08:00
|
|
|
switch (_heightMapImage->getPixelFormat())
|
2015-01-23 18:09:54 +08:00
|
|
|
{
|
2019-06-03 09:39:51 +08:00
|
|
|
case backend::PixelFormat::BGRA8888:
|
2015-01-23 18:09:54 +08:00
|
|
|
byte_stride = 4;
|
|
|
|
break;
|
2019-06-03 09:39:51 +08:00
|
|
|
case backend::PixelFormat::RGB888:
|
2019-02-27 17:16:25 +08:00
|
|
|
byte_stride = 3;
|
2015-01-23 18:09:54 +08:00
|
|
|
break;
|
2019-06-03 09:39:51 +08:00
|
|
|
case backend::PixelFormat::I8:
|
2019-02-27 17:16:25 +08:00
|
|
|
byte_stride = 1;
|
2015-01-23 18:09:54 +08:00
|
|
|
break;
|
|
|
|
default:
|
|
|
|
break;
|
|
|
|
}
|
2019-02-27 17:16:25 +08:00
|
|
|
return _data[(pixel_y*_imageWidth + pixel_x)*byte_stride] * 1.0 / 255 * _terrainData._mapHeight - 0.5*_terrainData._mapHeight;
|
2015-01-15 11:45:06 +08:00
|
|
|
}
|
|
|
|
|
2015-01-20 10:34:30 +08:00
|
|
|
void Terrain::loadVertices()
|
2015-01-15 11:45:06 +08:00
|
|
|
{
|
2015-04-02 14:04:31 +08:00
|
|
|
_maxHeight = -99999;
|
|
|
|
_minHeight = 99999;
|
2019-02-27 17:16:25 +08:00
|
|
|
for (int i = 0; i < _imageHeight; ++i)
|
2015-01-15 11:45:06 +08:00
|
|
|
{
|
2019-02-27 17:16:25 +08:00
|
|
|
for (int j = 0; j < _imageWidth; j++)
|
2015-01-15 11:45:06 +08:00
|
|
|
{
|
2019-02-27 17:16:25 +08:00
|
|
|
float height = getImageHeight(j, i);
|
2015-01-15 11:45:06 +08:00
|
|
|
TerrainVertexData v;
|
2019-02-27 17:16:25 +08:00
|
|
|
v._position = Vec3(j*_terrainData._mapScale - _imageWidth / 2 * _terrainData._mapScale, //x
|
2015-03-27 11:46:02 +08:00
|
|
|
height, //y
|
2019-02-27 17:16:25 +08:00
|
|
|
i*_terrainData._mapScale - _imageHeight / 2 * _terrainData._mapScale);//z
|
|
|
|
v._texcoord = Tex2F(j*1.0 / _imageWidth, i*1.0 / _imageHeight);
|
|
|
|
_vertices.push_back(v);
|
2015-03-27 11:46:02 +08:00
|
|
|
|
|
|
|
//update the min & max height;
|
2019-02-27 17:16:25 +08:00
|
|
|
if (height > _maxHeight) _maxHeight = height;
|
|
|
|
if (height < _minHeight) _minHeight = height;
|
2015-01-15 11:45:06 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-01-20 10:34:30 +08:00
|
|
|
void Terrain::calculateNormal()
|
2015-01-15 11:45:06 +08:00
|
|
|
{
|
2015-04-02 14:04:31 +08:00
|
|
|
_indices.clear();
|
2015-01-15 11:45:06 +08:00
|
|
|
//we generate whole terrain indices(global indices) for correct normal calculate
|
2019-02-27 17:16:25 +08:00
|
|
|
for (int i = 0; i < _imageHeight - 1; i += 1)
|
2015-01-15 11:45:06 +08:00
|
|
|
{
|
2019-02-27 17:16:25 +08:00
|
|
|
for (int j = 0; j < _imageWidth - 1; j += 1)
|
2016-03-21 21:04:06 +08:00
|
|
|
{
|
2015-01-15 11:45:06 +08:00
|
|
|
|
2015-04-02 14:04:31 +08:00
|
|
|
int nLocIndex = i * _imageWidth + j;
|
2019-02-27 17:16:25 +08:00
|
|
|
_indices.push_back(nLocIndex);
|
|
|
|
_indices.push_back(nLocIndex + _imageWidth);
|
|
|
|
_indices.push_back(nLocIndex + 1);
|
2015-01-15 11:45:06 +08:00
|
|
|
|
2019-02-27 17:16:25 +08:00
|
|
|
_indices.push_back(nLocIndex + 1);
|
|
|
|
_indices.push_back(nLocIndex + _imageWidth);
|
|
|
|
_indices.push_back(nLocIndex + _imageWidth + 1);
|
2015-01-15 11:45:06 +08:00
|
|
|
}
|
|
|
|
}
|
2017-01-19 09:41:57 +08:00
|
|
|
for (size_t i = 0, size = _indices.size(); i < size; i += 3) {
|
2015-04-02 14:04:31 +08:00
|
|
|
unsigned int Index0 = _indices[i];
|
|
|
|
unsigned int Index1 = _indices[i + 1];
|
|
|
|
unsigned int Index2 = _indices[i + 2];
|
2015-04-08 15:17:05 +08:00
|
|
|
Vec3 v1 = _vertices[Index1]._position - _vertices[Index0]._position;
|
|
|
|
Vec3 v2 = _vertices[Index2]._position - _vertices[Index0]._position;
|
2015-01-15 11:45:06 +08:00
|
|
|
Vec3 Normal;
|
2019-02-27 17:16:25 +08:00
|
|
|
Vec3::cross(v1, v2, &Normal);
|
2015-01-15 11:45:06 +08:00
|
|
|
Normal.normalize();
|
2015-04-08 15:17:05 +08:00
|
|
|
_vertices[Index0]._normal += Normal;
|
|
|
|
_vertices[Index1]._normal += Normal;
|
|
|
|
_vertices[Index2]._normal += Normal;
|
2015-01-15 11:45:06 +08:00
|
|
|
}
|
|
|
|
|
2017-01-19 09:41:57 +08:00
|
|
|
for (auto &vertex : _vertices) {
|
|
|
|
vertex._normal.normalize();
|
2015-01-15 11:45:06 +08:00
|
|
|
}
|
|
|
|
//global indices no need at all
|
2015-04-02 14:04:31 +08:00
|
|
|
_indices.clear();
|
2015-01-15 11:45:06 +08:00
|
|
|
}
|
|
|
|
|
2015-01-20 10:34:30 +08:00
|
|
|
void Terrain::setDrawWire(bool bool_value)
|
2015-01-15 11:45:06 +08:00
|
|
|
{
|
|
|
|
_isDrawWire = bool_value;
|
|
|
|
}
|
|
|
|
|
2015-03-30 18:25:22 +08:00
|
|
|
void Terrain::setLODDistance(float lod_1, float lod_2, float lod_3)
|
2015-01-15 11:45:06 +08:00
|
|
|
{
|
|
|
|
_lodDistance[0] = lod_1;
|
|
|
|
_lodDistance[1] = lod_2;
|
|
|
|
_lodDistance[2] = lod_3;
|
|
|
|
}
|
|
|
|
|
2015-01-20 10:34:30 +08:00
|
|
|
void Terrain::setIsEnableFrustumCull(bool bool_value)
|
2015-01-15 11:45:06 +08:00
|
|
|
{
|
|
|
|
_isEnableFrustumCull = bool_value;
|
|
|
|
}
|
|
|
|
|
2015-01-23 18:09:54 +08:00
|
|
|
Terrain::~Terrain()
|
|
|
|
{
|
2015-08-03 10:27:57 +08:00
|
|
|
CC_SAFE_RELEASE(_alphaMap);
|
|
|
|
CC_SAFE_RELEASE(_lightMap);
|
|
|
|
CC_SAFE_RELEASE(_heightMapImage);
|
2019-03-13 16:05:02 +08:00
|
|
|
CC_SAFE_RELEASE(_dummyTexture);
|
2019-02-27 17:16:25 +08:00
|
|
|
CC_SAFE_RELEASE_NULL(_programState);
|
2015-04-01 18:24:05 +08:00
|
|
|
delete _quadRoot;
|
2019-02-27 17:16:25 +08:00
|
|
|
for (int i = 0; i < 4; ++i)
|
2015-04-01 18:24:05 +08:00
|
|
|
{
|
2019-02-27 17:16:25 +08:00
|
|
|
if (_detailMapTextures[i])
|
2015-04-01 18:24:05 +08:00
|
|
|
{
|
|
|
|
_detailMapTextures[i]->release();
|
|
|
|
}
|
|
|
|
}
|
2019-02-27 17:16:25 +08:00
|
|
|
for (int i = 0; i < MAX_CHUNKES; ++i)
|
2015-01-23 18:14:44 +08:00
|
|
|
{
|
2019-02-27 17:16:25 +08:00
|
|
|
for (int j = 0; j < MAX_CHUNKES; j++)
|
2015-01-23 18:14:44 +08:00
|
|
|
{
|
2019-02-27 17:16:25 +08:00
|
|
|
if (_chunkesArray[i][j])
|
2015-01-30 15:46:39 +08:00
|
|
|
{
|
|
|
|
delete _chunkesArray[i][j];
|
|
|
|
}
|
2015-01-23 18:14:44 +08:00
|
|
|
}
|
|
|
|
}
|
2015-04-01 18:24:05 +08:00
|
|
|
|
2018-09-10 15:04:35 +08:00
|
|
|
#if CC_ENABLE_CACHE_TEXTURE_DATA
|
2015-04-08 19:11:46 +08:00
|
|
|
Director::getInstance()->getEventDispatcher()->removeEventListener(_backToForegroundListener);
|
|
|
|
#endif
|
2015-01-23 18:09:54 +08:00
|
|
|
}
|
|
|
|
|
2015-05-27 18:19:44 +08:00
|
|
|
cocos2d::Vec3 Terrain::getNormal(int pixel_x, int pixel_y) const
|
2015-01-27 15:18:59 +08:00
|
|
|
{
|
2019-02-27 17:16:25 +08:00
|
|
|
float a = getImageHeight(pixel_x, pixel_y)*getScaleY();
|
|
|
|
float b = getImageHeight(pixel_x, pixel_y + 1)*getScaleY();
|
|
|
|
float c = getImageHeight(pixel_x + 1, pixel_y)*getScaleY();
|
|
|
|
float d = getImageHeight(pixel_x + 1, pixel_y + 1)*getScaleY();
|
2015-01-27 15:18:59 +08:00
|
|
|
Vec3 normal;
|
|
|
|
normal.x = c - b;
|
|
|
|
normal.y = 2;
|
|
|
|
normal.z = d - a;
|
|
|
|
normal.normalize();
|
|
|
|
return normal;
|
|
|
|
}
|
|
|
|
|
2015-05-27 18:19:44 +08:00
|
|
|
cocos2d::Vec3 Terrain::getIntersectionPoint(const Ray & ray) const
|
2015-01-29 18:06:00 +08:00
|
|
|
{
|
2015-06-23 14:27:19 +08:00
|
|
|
Vec3 collisionPoint;
|
|
|
|
if (getIntersectionPoint(ray, collisionPoint))
|
|
|
|
{
|
|
|
|
return collisionPoint;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2019-02-27 17:16:25 +08:00
|
|
|
return Vec3(0, 0, 0);
|
2015-06-23 14:27:19 +08:00
|
|
|
}
|
2015-01-29 18:06:00 +08:00
|
|
|
}
|
|
|
|
|
2015-08-07 17:36:35 +08:00
|
|
|
bool Terrain::getIntersectionPoint(const Ray & ray_, Vec3 & intersectionPoint) const
|
2015-05-22 09:07:57 +08:00
|
|
|
{
|
2016-10-27 15:10:24 +08:00
|
|
|
// convert ray from world space to local space
|
2015-08-07 17:36:35 +08:00
|
|
|
Ray ray(ray_);
|
|
|
|
getWorldToNodeTransform().transformPoint(&(ray._origin));
|
|
|
|
|
2015-06-23 14:27:19 +08:00
|
|
|
std::set<Chunk *> closeList;
|
2019-02-27 17:16:25 +08:00
|
|
|
Vec2 start = Vec2(ray_._origin.x, ray_._origin.z);
|
|
|
|
Vec2 dir = Vec2(ray._direction.x, ray._direction.z);
|
2015-06-23 14:27:19 +08:00
|
|
|
start = convertToTerrainSpace(start);
|
2019-02-27 17:16:25 +08:00
|
|
|
start.x /= (_terrainData._chunkSize.width + 1);
|
|
|
|
start.y /= (_terrainData._chunkSize.height + 1);
|
2015-06-23 14:27:19 +08:00
|
|
|
Vec2 delta = dir.getNormalized();
|
2015-06-23 16:11:00 +08:00
|
|
|
auto width = float(_imageWidth) / (_terrainData._chunkSize.width + 1);
|
|
|
|
auto height = float(_imageHeight) / (_terrainData._chunkSize.height + 1);
|
2015-06-24 15:49:09 +08:00
|
|
|
bool hasIntersect = false;
|
|
|
|
float intersectionDist = FLT_MAX;
|
|
|
|
Vec3 tmpIntersectionPoint;
|
2019-02-27 17:16:25 +08:00
|
|
|
for (;;)
|
2015-06-23 14:27:19 +08:00
|
|
|
{
|
2015-06-24 10:49:18 +08:00
|
|
|
int x1 = floorf(start.x);
|
|
|
|
int x2 = ceilf(start.x);
|
|
|
|
int y1 = floorf(start.y);
|
|
|
|
int y2 = ceilf(start.y);
|
|
|
|
for (int x = x1; x <= x2; x++) {
|
|
|
|
for (int y = y1; y <= y2; y++) {
|
|
|
|
auto chunk = getChunkByIndex(x, y);
|
|
|
|
if (chunk)
|
2015-06-23 14:27:19 +08:00
|
|
|
{
|
2015-06-24 10:49:18 +08:00
|
|
|
if (closeList.find(chunk) == closeList.end())
|
2015-06-23 14:27:19 +08:00
|
|
|
{
|
2017-01-16 11:20:07 +08:00
|
|
|
if (chunk->getIntersectPointWithRay(ray, tmpIntersectionPoint))
|
2015-06-24 10:49:18 +08:00
|
|
|
{
|
2015-06-24 15:49:09 +08:00
|
|
|
float dist = (ray._origin - tmpIntersectionPoint).length();
|
|
|
|
if (intersectionDist > dist)
|
|
|
|
{
|
|
|
|
hasIntersect = true;
|
|
|
|
intersectionDist = dist;
|
|
|
|
intersectionPoint = tmpIntersectionPoint;
|
|
|
|
}
|
2015-06-24 10:49:18 +08:00
|
|
|
}
|
|
|
|
closeList.insert(chunk);
|
2015-06-23 14:27:19 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2019-02-27 17:16:25 +08:00
|
|
|
if ((delta.x > 0 && start.x > width) || (delta.x < 0 && start.x < 0))
|
2015-06-23 16:11:00 +08:00
|
|
|
{
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
if ((delta.y > 0 && start.y > height) || (delta.y < 0 && start.y < 0))
|
|
|
|
{
|
|
|
|
break;
|
|
|
|
}
|
2015-06-24 10:49:18 +08:00
|
|
|
start.x += delta.x;
|
|
|
|
start.y += delta.y;
|
2015-05-22 09:07:57 +08:00
|
|
|
}
|
2015-06-24 15:49:09 +08:00
|
|
|
return hasIntersect;
|
2015-05-22 09:07:57 +08:00
|
|
|
}
|
|
|
|
|
2015-01-30 15:46:39 +08:00
|
|
|
void Terrain::setMaxDetailMapAmount(int max_value)
|
|
|
|
{
|
|
|
|
_maxDetailMapValue = max_value;
|
|
|
|
}
|
|
|
|
|
2016-05-17 12:17:56 +08:00
|
|
|
cocos2d::Vec2 Terrain::convertToTerrainSpace(const Vec2& worldSpaceXZ) const
|
2015-03-27 10:12:24 +08:00
|
|
|
{
|
2019-02-27 17:16:25 +08:00
|
|
|
Vec2 pos(worldSpaceXZ.x, worldSpaceXZ.y);
|
2015-03-27 10:12:24 +08:00
|
|
|
|
|
|
|
//top-left
|
2019-02-27 17:16:25 +08:00
|
|
|
Vec2 tl(-1 * _terrainData._mapScale*_imageWidth / 2, -1 * _terrainData._mapScale*_imageHeight / 2);
|
|
|
|
auto result = getNodeToWorldTransform()*Vec4(tl.x, 0.0f, tl.y, 1.0f);
|
2015-04-20 01:40:52 +08:00
|
|
|
tl.set(result.x, result.z);
|
2015-03-27 10:12:24 +08:00
|
|
|
|
|
|
|
Vec2 to_tl = pos - tl;
|
|
|
|
|
|
|
|
//real size
|
2019-02-27 17:16:25 +08:00
|
|
|
Vec2 size(_imageWidth*_terrainData._mapScale, _imageHeight*_terrainData._mapScale);
|
|
|
|
result = getNodeToWorldTransform()*Vec4(size.x, 0.0f, size.y, 0.0f);
|
2015-04-20 01:40:52 +08:00
|
|
|
size.set(result.x, result.z);
|
2015-03-27 10:12:24 +08:00
|
|
|
|
2019-02-27 17:16:25 +08:00
|
|
|
float width_ratio = to_tl.x / size.x;
|
|
|
|
float height_ratio = to_tl.y / size.y;
|
2015-03-27 10:12:24 +08:00
|
|
|
|
2015-04-02 14:04:31 +08:00
|
|
|
float image_x = width_ratio * _imageWidth;
|
|
|
|
float image_y = height_ratio * _imageHeight;
|
2019-02-27 17:16:25 +08:00
|
|
|
return Vec2(image_x, image_y);
|
2015-03-27 10:12:24 +08:00
|
|
|
}
|
|
|
|
|
2015-11-12 18:08:29 +08:00
|
|
|
void Terrain::resetHeightMap(const std::string& heightMap)
|
2015-03-27 10:12:24 +08:00
|
|
|
{
|
|
|
|
_heightMapImage->release();
|
2015-04-02 14:04:31 +08:00
|
|
|
_vertices.clear();
|
2015-03-27 10:12:24 +08:00
|
|
|
free(_data);
|
2019-02-27 17:16:25 +08:00
|
|
|
for (int i = 0; i < MAX_CHUNKES; ++i)
|
2015-03-27 10:12:24 +08:00
|
|
|
{
|
2019-02-27 17:16:25 +08:00
|
|
|
for (int j = 0; j < MAX_CHUNKES; j++)
|
2015-03-27 10:12:24 +08:00
|
|
|
{
|
2019-02-27 17:16:25 +08:00
|
|
|
if (_chunkesArray[i][j])
|
2015-03-27 10:12:24 +08:00
|
|
|
{
|
|
|
|
delete _chunkesArray[i][j];
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2015-03-27 13:43:09 +08:00
|
|
|
delete _quadRoot;
|
2015-03-27 10:12:24 +08:00
|
|
|
initHeightMap(heightMap);
|
|
|
|
}
|
|
|
|
|
2015-03-27 11:46:02 +08:00
|
|
|
float Terrain::getMinHeight()
|
|
|
|
{
|
2015-04-02 14:04:31 +08:00
|
|
|
return _minHeight;
|
2015-03-27 11:46:02 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
float Terrain::getMaxHeight()
|
|
|
|
{
|
2015-04-02 14:04:31 +08:00
|
|
|
return _maxHeight;
|
2015-03-27 11:46:02 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
cocos2d::AABB Terrain::getAABB()
|
|
|
|
{
|
2015-03-27 13:43:09 +08:00
|
|
|
return _quadRoot->_worldSpaceAABB;
|
|
|
|
}
|
|
|
|
|
|
|
|
Terrain::QuadTree * Terrain::getQuadTree()
|
|
|
|
{
|
|
|
|
return _quadRoot;
|
2015-03-27 11:46:02 +08:00
|
|
|
}
|
|
|
|
|
2015-05-08 15:49:33 +08:00
|
|
|
|
|
|
|
std::vector<float> Terrain::getHeightData() const
|
|
|
|
{
|
|
|
|
std::vector<float> data;
|
|
|
|
data.resize(_imageWidth * _imageHeight);
|
2016-10-27 15:10:24 +08:00
|
|
|
for (int i = 0; i < _imageHeight; ++i) {
|
2015-05-08 15:49:33 +08:00
|
|
|
for (int j = 0; j < _imageWidth; j++) {
|
|
|
|
int idx = i * _imageWidth + j;
|
|
|
|
data[idx] = (_vertices[idx]._position.y);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return data;
|
|
|
|
}
|
|
|
|
|
2015-06-23 14:27:19 +08:00
|
|
|
Terrain::Chunk * cocos2d::Terrain::getChunkByIndex(int x, int y) const
|
|
|
|
{
|
2019-02-27 17:16:25 +08:00
|
|
|
if (x < 0 || y < 0 || x >= MAX_CHUNKES || y >= MAX_CHUNKES) return nullptr;
|
2015-06-23 14:27:19 +08:00
|
|
|
return _chunkesArray[y][x];
|
|
|
|
}
|
|
|
|
|
2015-03-30 18:25:22 +08:00
|
|
|
void Terrain::setAlphaMap(cocos2d::Texture2D * newAlphaMapTexture)
|
|
|
|
{
|
2015-08-03 10:27:57 +08:00
|
|
|
CC_SAFE_RETAIN(newAlphaMapTexture);
|
|
|
|
CC_SAFE_RELEASE(_alphaMap);
|
2015-03-30 18:25:22 +08:00
|
|
|
_alphaMap = newAlphaMapTexture;
|
|
|
|
}
|
|
|
|
|
|
|
|
void Terrain::setDetailMap(unsigned int index, DetailMap detailMap)
|
|
|
|
{
|
2019-02-27 17:16:25 +08:00
|
|
|
if (index > 4)
|
2015-03-30 18:25:22 +08:00
|
|
|
{
|
2019-02-27 17:16:25 +08:00
|
|
|
CCLOG("invalid DetailMap index %d\n", index);
|
2015-03-30 18:25:22 +08:00
|
|
|
}
|
2015-04-08 15:17:05 +08:00
|
|
|
_terrainData._detailMaps[index] = detailMap;
|
2019-02-27 17:16:25 +08:00
|
|
|
if (_detailMapTextures[index])
|
2015-03-30 18:25:22 +08:00
|
|
|
{
|
|
|
|
|
|
|
|
_detailMapTextures[index]->release();
|
|
|
|
}
|
|
|
|
_detailMapTextures[index] = new (std::nothrow)Texture2D();
|
|
|
|
auto textImage = new (std::nothrow)Image();
|
2015-04-08 15:17:05 +08:00
|
|
|
textImage->initWithImageFile(detailMap._detailMapSrc);
|
2015-03-30 18:25:22 +08:00
|
|
|
_detailMapTextures[index]->initWithImage(textImage);
|
2015-04-07 18:47:19 +08:00
|
|
|
delete textImage;
|
2015-03-30 18:25:22 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
Terrain::ChunkIndices Terrain::lookForIndicesLOD(int neighborLod[4], int selfLod, bool * result)
|
|
|
|
{
|
2019-02-27 17:16:25 +08:00
|
|
|
(*result) = false;
|
2015-03-30 18:25:22 +08:00
|
|
|
ChunkIndices tmp;
|
2019-02-27 17:16:25 +08:00
|
|
|
tmp._indexBuffer = nullptr;
|
2015-04-08 15:17:05 +08:00
|
|
|
tmp._size = 0;
|
2019-02-27 17:16:25 +08:00
|
|
|
if (_chunkLodIndicesSet.empty())
|
2015-03-30 18:25:22 +08:00
|
|
|
{
|
2019-02-27 17:16:25 +08:00
|
|
|
(*result) = false;
|
2015-03-30 18:25:22 +08:00
|
|
|
return tmp;
|
2019-02-27 17:16:25 +08:00
|
|
|
}
|
|
|
|
else
|
2015-03-30 18:25:22 +08:00
|
|
|
{
|
|
|
|
int test[5];
|
2019-02-27 17:16:25 +08:00
|
|
|
memcpy(test, neighborLod, sizeof(int[4]));
|
2015-03-30 18:25:22 +08:00
|
|
|
test[4] = selfLod;
|
2019-02-27 17:16:25 +08:00
|
|
|
for (size_t i = 0, size = _chunkLodIndicesSet.size(); i < size; ++i)
|
2015-03-30 18:25:22 +08:00
|
|
|
{
|
2019-02-27 17:16:25 +08:00
|
|
|
if (memcmp(test, _chunkLodIndicesSet[i]._relativeLod, sizeof(test)) == 0)
|
2015-03-30 18:25:22 +08:00
|
|
|
{
|
|
|
|
(*result) = true;
|
|
|
|
return _chunkLodIndicesSet[i]._chunkIndices;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2019-02-27 17:16:25 +08:00
|
|
|
(*result) = false;
|
2015-03-30 18:25:22 +08:00
|
|
|
return tmp;
|
|
|
|
}
|
|
|
|
|
2019-06-05 17:58:33 +08:00
|
|
|
Terrain::ChunkIndices Terrain::insertIndicesLOD(int neighborLod[4], int selfLod, uint16_t * indices, int size)
|
2015-03-30 18:25:22 +08:00
|
|
|
{
|
|
|
|
ChunkLODIndices lodIndices;
|
2019-02-27 17:16:25 +08:00
|
|
|
memcpy(lodIndices._relativeLod, neighborLod, sizeof(int[4]));
|
2015-04-08 15:17:05 +08:00
|
|
|
lodIndices._relativeLod[4] = selfLod;
|
|
|
|
lodIndices._chunkIndices._size = size;
|
2019-02-27 17:16:25 +08:00
|
|
|
|
|
|
|
auto buffer = backend::Device::getInstance()->newBuffer(sizeof(uint16_t) * size, backend::BufferType::INDEX, backend::BufferUsage::STATIC);
|
|
|
|
buffer->updateData(indices, sizeof(uint16_t) * size);
|
|
|
|
|
|
|
|
CC_SAFE_RELEASE_NULL(lodIndices._chunkIndices._indexBuffer);
|
|
|
|
lodIndices._chunkIndices._indexBuffer = buffer;
|
2015-03-30 18:25:22 +08:00
|
|
|
this->_chunkLodIndicesSet.push_back(lodIndices);
|
|
|
|
return lodIndices._chunkIndices;
|
|
|
|
}
|
|
|
|
|
|
|
|
Terrain::ChunkIndices Terrain::lookForIndicesLODSkrit(int selfLod, bool * result)
|
|
|
|
{
|
|
|
|
ChunkIndices badResult;
|
2019-02-27 17:16:25 +08:00
|
|
|
badResult._indexBuffer = nullptr;
|
2015-04-08 15:17:05 +08:00
|
|
|
badResult._size = 0;
|
2019-02-27 17:16:25 +08:00
|
|
|
if (this->_chunkLodIndicesSkirtSet.empty())
|
2015-03-30 18:25:22 +08:00
|
|
|
{
|
2019-02-27 17:16:25 +08:00
|
|
|
(*result) = false;
|
|
|
|
return badResult;
|
2015-03-30 18:25:22 +08:00
|
|
|
}
|
2019-02-27 17:16:25 +08:00
|
|
|
for (size_t i = 0, size = _chunkLodIndicesSkirtSet.size(); i < size; ++i)
|
2015-03-30 18:25:22 +08:00
|
|
|
{
|
2019-02-27 17:16:25 +08:00
|
|
|
if (_chunkLodIndicesSkirtSet[i]._selfLod == selfLod)
|
2015-03-30 18:25:22 +08:00
|
|
|
{
|
|
|
|
(*result) = true;
|
|
|
|
return _chunkLodIndicesSkirtSet[i]._chunkIndices;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
(*result) = false;
|
|
|
|
return badResult;
|
|
|
|
}
|
|
|
|
|
2019-06-05 17:58:33 +08:00
|
|
|
Terrain::ChunkIndices Terrain::insertIndicesLODSkirt(int selfLod, uint16_t * indices, int size)
|
2015-03-30 18:25:22 +08:00
|
|
|
{
|
|
|
|
ChunkLODIndicesSkirt skirtIndices;
|
2015-04-08 15:17:05 +08:00
|
|
|
skirtIndices._selfLod = selfLod;
|
|
|
|
skirtIndices._chunkIndices._size = size;
|
2019-02-27 17:16:25 +08:00
|
|
|
|
|
|
|
auto buffer = backend::Device::getInstance()->newBuffer(sizeof(uint16_t) * size, backend::BufferType::INDEX, backend::BufferUsage::STATIC);
|
2019-06-05 17:58:33 +08:00
|
|
|
buffer->updateData(indices, sizeof(uint16_t)*size);
|
2019-02-27 17:16:25 +08:00
|
|
|
|
|
|
|
CC_SAFE_RELEASE_NULL(skirtIndices._chunkIndices._indexBuffer);
|
|
|
|
skirtIndices._chunkIndices._indexBuffer = buffer;
|
2015-03-30 18:25:22 +08:00
|
|
|
this->_chunkLodIndicesSkirtSet.push_back(skirtIndices);
|
|
|
|
return skirtIndices._chunkIndices;
|
2015-03-27 11:46:02 +08:00
|
|
|
}
|
|
|
|
|
2015-04-01 18:24:05 +08:00
|
|
|
void Terrain::setSkirtHeightRatio(float ratio)
|
|
|
|
{
|
|
|
|
_skirtRatio = ratio;
|
|
|
|
}
|
|
|
|
|
|
|
|
void Terrain::onEnter()
|
|
|
|
{
|
2015-07-28 16:07:14 +08:00
|
|
|
#if CC_ENABLE_SCRIPT_BINDING
|
|
|
|
if (_scriptType == kScriptTypeJavascript)
|
|
|
|
{
|
2015-07-28 18:24:03 +08:00
|
|
|
if (ScriptEngineManager::sendNodeEventToJSExtended(this, kNodeOnEnter))
|
2015-07-28 16:07:14 +08:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
#endif
|
2016-03-21 21:04:06 +08:00
|
|
|
|
2015-04-01 18:24:05 +08:00
|
|
|
Node::onEnter();
|
|
|
|
_terrainModelMatrix = getNodeToWorldTransform();
|
|
|
|
_quadRoot->preCalculateAABB(_terrainModelMatrix);
|
2015-04-08 10:10:05 +08:00
|
|
|
cacheUniformAttribLocation();
|
2015-04-01 18:24:05 +08:00
|
|
|
}
|
|
|
|
|
2015-04-08 10:10:05 +08:00
|
|
|
void Terrain::cacheUniformAttribLocation()
|
2015-04-01 18:24:05 +08:00
|
|
|
{
|
2019-08-15 16:51:49 +08:00
|
|
|
auto vertexLayout = _programState->getVertexLayout();
|
2019-03-12 19:40:13 +08:00
|
|
|
const auto& attributeInfo = _programState->getProgram()->getActiveAttributes();
|
|
|
|
auto iter = attributeInfo.find("a_position");
|
|
|
|
if(iter != attributeInfo.end())
|
|
|
|
{
|
2019-08-15 16:51:49 +08:00
|
|
|
vertexLayout->setAttribute("a_position", iter->second.location, backend::VertexFormat::FLOAT3, 0, false);
|
2019-03-12 19:40:13 +08:00
|
|
|
}
|
|
|
|
iter = attributeInfo.find("a_texCoord");
|
|
|
|
if(iter != attributeInfo.end())
|
|
|
|
{
|
2019-08-15 16:51:49 +08:00
|
|
|
vertexLayout->setAttribute("a_texCoord", iter->second.location, backend::VertexFormat::FLOAT2, offsetof(TerrainVertexData, _texcoord), false);
|
2019-03-12 19:40:13 +08:00
|
|
|
}
|
|
|
|
iter = attributeInfo.find("a_normal");
|
|
|
|
if(iter != attributeInfo.end())
|
|
|
|
{
|
2019-08-15 16:51:49 +08:00
|
|
|
vertexLayout->setAttribute("a_normal", iter->second.location, backend::VertexFormat::FLOAT3, offsetof(TerrainVertexData, _normal), false);
|
2019-03-12 19:40:13 +08:00
|
|
|
}
|
2019-08-15 16:51:49 +08:00
|
|
|
vertexLayout->setLayout(sizeof(TerrainVertexData));
|
2019-02-27 17:16:25 +08:00
|
|
|
|
|
|
|
_alphaMapLocation.reset();
|
|
|
|
for (int i = 0; i < 4; ++i)
|
2015-04-03 13:49:07 +08:00
|
|
|
{
|
2019-02-27 17:16:25 +08:00
|
|
|
_detailMapLocation[i].reset();
|
2015-04-03 13:49:07 +08:00
|
|
|
}
|
2019-02-27 17:16:25 +08:00
|
|
|
_detailMapSizeLocation.reset();
|
|
|
|
|
|
|
|
_alphaIsHasAlphaMapLocation = _programState->getUniformLocation("u_has_alpha");
|
|
|
|
_lightMapCheckLocation = _programState->getUniformLocation("u_has_light_map");
|
|
|
|
if (!_alphaMap)
|
2015-04-01 18:24:05 +08:00
|
|
|
{
|
2019-02-27 17:16:25 +08:00
|
|
|
_detailMapLocation[0] = _programState->getUniformLocation("u_texture0");
|
|
|
|
}
|
|
|
|
else
|
2015-04-01 18:24:05 +08:00
|
|
|
{
|
2019-02-27 17:16:25 +08:00
|
|
|
for (int i = 0; i < _maxDetailMapValue; ++i)
|
2015-04-01 18:24:05 +08:00
|
|
|
{
|
|
|
|
char str[20];
|
2019-02-27 17:16:25 +08:00
|
|
|
sprintf(str, "u_texture%d", i);
|
|
|
|
_detailMapLocation[i] = _programState->getUniformLocation(str);
|
2015-04-01 18:24:05 +08:00
|
|
|
}
|
2019-02-27 17:16:25 +08:00
|
|
|
|
|
|
|
_detailMapSizeLocation = _programState->getUniformLocation("u_detailSize"); //float[4]
|
|
|
|
|
|
|
|
_alphaMapLocation = _programState->getUniformLocation("u_alphaMap");
|
2015-04-01 18:24:05 +08:00
|
|
|
}
|
2019-02-27 17:16:25 +08:00
|
|
|
_lightMapLocation = _programState->getUniformLocation("u_lightMap");
|
|
|
|
_lightDirLocation = _programState->getUniformLocation("u_lightDir");
|
|
|
|
_mvpMatrixLocation = _programState->getUniformLocation("u_MVPMatrix");
|
2015-04-01 18:24:05 +08:00
|
|
|
}
|
|
|
|
|
2015-04-03 13:49:07 +08:00
|
|
|
bool Terrain::initTextures()
|
|
|
|
{
|
2016-10-27 15:10:24 +08:00
|
|
|
for (int i = 0; i < 4; ++i)
|
2015-07-29 13:24:12 +08:00
|
|
|
{
|
|
|
|
_detailMapTextures[i] = nullptr;
|
|
|
|
}
|
|
|
|
|
2015-04-03 13:49:07 +08:00
|
|
|
Texture2D::TexParams texParam;
|
2019-03-13 10:54:26 +08:00
|
|
|
texParam.sAddressMode = backend::SamplerAddressMode::REPEAT;
|
|
|
|
texParam.tAddressMode = backend::SamplerAddressMode::REPEAT;
|
2019-02-27 17:16:25 +08:00
|
|
|
if (_terrainData._alphaMapSrc.empty())
|
2015-04-03 13:49:07 +08:00
|
|
|
{
|
|
|
|
auto textImage = new (std::nothrow)Image();
|
2015-04-08 15:17:05 +08:00
|
|
|
textImage->initWithImageFile(_terrainData._detailMaps[0]._detailMapSrc);
|
2015-04-03 13:49:07 +08:00
|
|
|
auto texture = new (std::nothrow)Texture2D();
|
|
|
|
texture->initWithImage(textImage);
|
|
|
|
texture->generateMipmap();
|
|
|
|
_detailMapTextures[0] = texture;
|
2019-03-12 16:26:41 +08:00
|
|
|
texParam.minFilter = backend::SamplerFilter::LINEAR;
|
|
|
|
texParam.magFilter = backend::SamplerFilter::LINEAR;
|
2015-04-03 13:49:07 +08:00
|
|
|
texture->setTexParameters(texParam);
|
|
|
|
delete textImage;
|
2019-02-27 17:16:25 +08:00
|
|
|
}
|
|
|
|
else
|
2015-04-03 13:49:07 +08:00
|
|
|
{
|
|
|
|
//alpha map
|
2016-03-21 21:04:06 +08:00
|
|
|
auto image = new (std::nothrow)Image();
|
2015-04-08 15:17:05 +08:00
|
|
|
image->initWithImageFile(_terrainData._alphaMapSrc);
|
2015-04-03 13:49:07 +08:00
|
|
|
_alphaMap = new (std::nothrow)Texture2D();
|
|
|
|
_alphaMap->initWithImage(image);
|
2019-03-13 10:54:26 +08:00
|
|
|
texParam.sAddressMode = backend::SamplerAddressMode::CLAMP_TO_EDGE;
|
|
|
|
texParam.tAddressMode = backend::SamplerAddressMode::CLAMP_TO_EDGE;
|
2019-03-12 16:26:41 +08:00
|
|
|
texParam.minFilter = backend::SamplerFilter::LINEAR;
|
|
|
|
texParam.magFilter = backend::SamplerFilter::LINEAR;
|
2015-04-03 13:49:07 +08:00
|
|
|
_alphaMap->setTexParameters(texParam);
|
|
|
|
delete image;
|
|
|
|
|
2019-02-27 17:16:25 +08:00
|
|
|
for (int i = 0; i < _terrainData._detailMapAmount; ++i)
|
2015-04-03 13:49:07 +08:00
|
|
|
{
|
|
|
|
auto textImage = new (std::nothrow)Image();
|
2015-04-08 15:17:05 +08:00
|
|
|
textImage->initWithImageFile(_terrainData._detailMaps[i]._detailMapSrc);
|
2015-04-03 13:49:07 +08:00
|
|
|
auto texture = new (std::nothrow)Texture2D();
|
|
|
|
texture->initWithImage(textImage);
|
|
|
|
delete textImage;
|
|
|
|
texture->generateMipmap();
|
|
|
|
_detailMapTextures[i] = texture;
|
|
|
|
|
2019-03-13 10:54:26 +08:00
|
|
|
texParam.sAddressMode = backend::SamplerAddressMode::REPEAT;
|
|
|
|
texParam.tAddressMode = backend::SamplerAddressMode::REPEAT;
|
2019-03-12 16:26:41 +08:00
|
|
|
texParam.minFilter = backend::SamplerFilter::LINEAR;
|
|
|
|
texParam.magFilter = backend::SamplerFilter::LINEAR;
|
2015-04-03 13:49:07 +08:00
|
|
|
texture->setTexParameters(texParam);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
setMaxDetailMapAmount(_terrainData._detailMapAmount);
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2015-04-08 19:11:46 +08:00
|
|
|
void Terrain::reload()
|
|
|
|
{
|
2019-02-27 17:16:25 +08:00
|
|
|
int chunk_amount_y = _imageHeight / _chunkSize.height;
|
|
|
|
int chunk_amount_x = _imageWidth / _chunkSize.width;
|
2015-04-10 14:22:07 +08:00
|
|
|
|
2019-02-27 17:16:25 +08:00
|
|
|
for (int m = 0; m < chunk_amount_y; m++)
|
2015-04-10 14:22:07 +08:00
|
|
|
{
|
2019-02-27 17:16:25 +08:00
|
|
|
for (int n = 0; n < chunk_amount_x; n++)
|
2015-04-10 14:22:07 +08:00
|
|
|
{
|
|
|
|
_chunkesArray[m][n]->finish();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-04-08 19:11:46 +08:00
|
|
|
initTextures();
|
|
|
|
_chunkLodIndicesSet.clear();
|
|
|
|
_chunkLodIndicesSkirtSet.clear();
|
|
|
|
}
|
|
|
|
|
2015-01-20 10:34:30 +08:00
|
|
|
void Terrain::Chunk::finish()
|
2015-01-15 11:45:06 +08:00
|
|
|
{
|
2015-09-09 11:37:41 +08:00
|
|
|
//generate two VBO ,the first for vertices, we just setup datas once ,won't changed at all
|
2016-03-21 21:04:06 +08:00
|
|
|
//the second vbo for the indices, because we use level of detail technique to each chunk, so we will modified frequently
|
2015-01-15 11:45:06 +08:00
|
|
|
|
2019-02-27 17:16:25 +08:00
|
|
|
CC_SAFE_RELEASE_NULL(_buffer);
|
|
|
|
_buffer = backend::Device::getInstance()->newBuffer(sizeof(TerrainVertexData) * _originalVertices.size(), backend::BufferType::VERTEX, backend::BufferUsage::DYNAMIC);
|
2015-01-15 11:45:06 +08:00
|
|
|
|
2019-02-27 17:16:25 +08:00
|
|
|
_buffer->updateData(&_originalVertices[0], sizeof(TerrainVertexData)*_originalVertices.size());
|
2015-01-15 11:45:06 +08:00
|
|
|
|
|
|
|
calculateSlope();
|
2015-01-15 15:54:12 +08:00
|
|
|
|
2019-02-27 17:16:25 +08:00
|
|
|
for (int i = 0; i < 4; ++i)
|
2015-01-15 15:54:12 +08:00
|
|
|
{
|
2019-02-27 17:16:25 +08:00
|
|
|
int step = 1 << _currentLod;
|
2016-03-21 21:04:06 +08:00
|
|
|
//reserve the indices size, the first part is the core part of the chunk, the second part & third part is for fix crack
|
2019-02-27 17:16:25 +08:00
|
|
|
int indicesAmount = (_terrain->_chunkSize.width / step + 1)*(_terrain->_chunkSize.height / step + 1) * 6 + (_terrain->_chunkSize.height / step) * 6
|
|
|
|
+ (_terrain->_chunkSize.width / step) * 6;
|
2015-04-08 15:17:05 +08:00
|
|
|
_lod[i]._indices.reserve(indicesAmount);
|
2015-01-15 15:54:12 +08:00
|
|
|
}
|
2015-04-10 14:22:07 +08:00
|
|
|
_oldLod = -1;
|
2015-01-15 11:45:06 +08:00
|
|
|
}
|
|
|
|
|
2015-01-20 10:34:30 +08:00
|
|
|
void Terrain::Chunk::bindAndDraw()
|
2015-01-15 11:45:06 +08:00
|
|
|
{
|
2019-02-27 17:16:25 +08:00
|
|
|
if (_terrain->_isCameraViewChanged || _oldLod < 0)
|
2015-03-03 14:14:50 +08:00
|
|
|
{
|
2015-03-30 18:25:22 +08:00
|
|
|
switch (_terrain->_crackFixedType)
|
|
|
|
{
|
|
|
|
case CrackFixedType::SKIRT:
|
|
|
|
|
|
|
|
updateIndicesLODSkirt();
|
|
|
|
break;
|
|
|
|
case CrackFixedType::INCREASE_LOWER:
|
|
|
|
updateVerticesForLOD();
|
|
|
|
updateIndicesLOD();
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
break;
|
|
|
|
}
|
2019-02-27 17:16:25 +08:00
|
|
|
|
2015-03-03 14:14:50 +08:00
|
|
|
}
|
2019-02-27 17:16:25 +08:00
|
|
|
|
|
|
|
auto *renderer = Director::getInstance()->getRenderer();
|
|
|
|
CCASSERT(_buffer && _chunkIndices._indexBuffer, "buffer should not be nullptr");
|
|
|
|
_command.setIndexBuffer(_chunkIndices._indexBuffer, backend::IndexFormat::U_SHORT);
|
|
|
|
_command.setVertexBuffer(_buffer);
|
|
|
|
_command.getPipelineDescriptor().programState = _terrain->_programState;
|
|
|
|
_command.setIndexDrawInfo(0, _chunkIndices._size);
|
|
|
|
renderer->addCommand(&_command);
|
2015-04-08 15:17:05 +08:00
|
|
|
CC_INCREMENT_GL_DRAWN_BATCHES_AND_VERTICES(1, _chunkIndices._size);
|
2015-01-15 11:45:06 +08:00
|
|
|
}
|
|
|
|
|
2016-11-16 09:48:37 +08:00
|
|
|
void Terrain::Chunk::generate(int imgWidth, int imageHei, int m, int n, const unsigned char * /*data*/)
|
2015-01-15 11:45:06 +08:00
|
|
|
{
|
2015-04-08 15:17:05 +08:00
|
|
|
_posY = m;
|
|
|
|
_posX = n;
|
2015-03-30 18:25:22 +08:00
|
|
|
switch (_terrain->_crackFixedType)
|
2015-01-15 11:45:06 +08:00
|
|
|
{
|
2015-03-30 18:25:22 +08:00
|
|
|
case CrackFixedType::SKIRT:
|
2019-02-27 17:16:25 +08:00
|
|
|
{
|
|
|
|
for (int i = _size.height*m; i <= _size.height*(m + 1); ++i)
|
2015-01-15 11:45:06 +08:00
|
|
|
{
|
2019-02-27 17:16:25 +08:00
|
|
|
if (i >= imageHei) break;
|
|
|
|
for (int j = _size.width*n; j <= _size.width*(n + 1); j++)
|
2015-03-30 18:25:22 +08:00
|
|
|
{
|
2019-02-27 17:16:25 +08:00
|
|
|
if (j >= imgWidth)break;
|
|
|
|
auto v = _terrain->_vertices[i*imgWidth + j];
|
|
|
|
_originalVertices.push_back(v);
|
2015-03-30 18:25:22 +08:00
|
|
|
}
|
2019-02-27 17:16:25 +08:00
|
|
|
}
|
|
|
|
// add four skirts
|
2016-03-21 21:04:06 +08:00
|
|
|
|
2019-02-27 17:16:25 +08:00
|
|
|
float skirtHeight = _terrain->_skirtRatio *_terrain->_terrainData._mapScale * 8;
|
|
|
|
//#1
|
|
|
|
_terrain->_skirtVerticesOffset[0] = (int)_originalVertices.size();
|
|
|
|
for (int i = _size.height*m; i <= _size.height*(m + 1); ++i)
|
|
|
|
{
|
|
|
|
auto v = _terrain->_vertices[i*imgWidth + _size.width*(n + 1)];
|
|
|
|
v._position.y -= skirtHeight;
|
|
|
|
_originalVertices.push_back(v);
|
|
|
|
}
|
2015-04-01 18:24:05 +08:00
|
|
|
|
2019-02-27 17:16:25 +08:00
|
|
|
//#2
|
|
|
|
_terrain->_skirtVerticesOffset[1] = (int)_originalVertices.size();
|
|
|
|
for (int j = _size.width*n; j <= _size.width*(n + 1); j++)
|
|
|
|
{
|
|
|
|
auto v = _terrain->_vertices[_size.height*(m + 1)*imgWidth + j];
|
|
|
|
v._position.y -= skirtHeight;
|
|
|
|
_originalVertices.push_back(v);
|
|
|
|
}
|
2015-04-01 18:24:05 +08:00
|
|
|
|
2019-02-27 17:16:25 +08:00
|
|
|
//#3
|
|
|
|
_terrain->_skirtVerticesOffset[2] = (int)_originalVertices.size();
|
|
|
|
for (int i = _size.height*m; i <= _size.height*(m + 1); ++i)
|
|
|
|
{
|
|
|
|
auto v = _terrain->_vertices[i*imgWidth + _size.width*n];
|
|
|
|
v._position.y -= skirtHeight;
|
|
|
|
_originalVertices.push_back(v);
|
|
|
|
}
|
2015-03-30 18:25:22 +08:00
|
|
|
|
2019-02-27 17:16:25 +08:00
|
|
|
//#4
|
|
|
|
_terrain->_skirtVerticesOffset[3] = (int)_originalVertices.size();
|
|
|
|
for (int j = _size.width*n; j <= _size.width*(n + 1); j++)
|
|
|
|
{
|
|
|
|
auto v = _terrain->_vertices[_size.height*m*imgWidth + j];
|
|
|
|
v._position.y -= skirtHeight;
|
|
|
|
//v.position.y = -5;
|
|
|
|
_originalVertices.push_back(v);
|
2015-01-15 11:45:06 +08:00
|
|
|
}
|
2019-02-27 17:16:25 +08:00
|
|
|
}
|
|
|
|
break;
|
2015-03-30 18:25:22 +08:00
|
|
|
case CrackFixedType::INCREASE_LOWER:
|
2019-02-27 17:16:25 +08:00
|
|
|
{
|
|
|
|
for (int i = _size.height*m; i <= _size.height*(m + 1); ++i)
|
2015-03-30 18:25:22 +08:00
|
|
|
{
|
2019-02-27 17:16:25 +08:00
|
|
|
if (i >= imageHei) break;
|
|
|
|
for (int j = _size.width*n; j <= _size.width*(n + 1); j++)
|
2015-03-30 18:25:22 +08:00
|
|
|
{
|
2019-02-27 17:16:25 +08:00
|
|
|
if (j >= imgWidth)break;
|
|
|
|
auto v = _terrain->_vertices[i*imgWidth + j];
|
|
|
|
_originalVertices.push_back(v);
|
2015-03-30 18:25:22 +08:00
|
|
|
}
|
|
|
|
}
|
2019-02-27 17:16:25 +08:00
|
|
|
}
|
|
|
|
break;
|
2015-01-15 11:45:06 +08:00
|
|
|
}
|
2015-06-23 14:27:19 +08:00
|
|
|
//store triangle:
|
2016-10-27 15:10:24 +08:00
|
|
|
for (int i = 0; i < _size.height; ++i)
|
2015-06-23 14:27:19 +08:00
|
|
|
{
|
|
|
|
for (int j = 0; j < _size.width; j++)
|
|
|
|
{
|
2019-02-27 17:16:25 +08:00
|
|
|
int nLocIndex = i * (_size.width + 1) + j;
|
|
|
|
Triangle a(_originalVertices[nLocIndex]._position, _originalVertices[nLocIndex + 1 * (_size.width + 1)]._position, _originalVertices[nLocIndex + 1]._position);
|
|
|
|
Triangle b(_originalVertices[nLocIndex + 1]._position, _originalVertices[nLocIndex + 1 * (_size.width + 1)]._position, _originalVertices[nLocIndex + 1 * (_size.width + 1) + 1]._position);
|
2015-06-23 14:27:19 +08:00
|
|
|
|
|
|
|
_trianglesList.push_back(a);
|
|
|
|
_trianglesList.push_back(b);
|
|
|
|
}
|
|
|
|
}
|
2015-03-30 18:25:22 +08:00
|
|
|
|
2015-01-15 11:45:06 +08:00
|
|
|
calculateAABB();
|
|
|
|
finish();
|
|
|
|
}
|
|
|
|
|
2019-02-27 17:16:25 +08:00
|
|
|
Terrain::Chunk::Chunk(Terrain *terrain)
|
2015-01-15 11:45:06 +08:00
|
|
|
{
|
2019-02-27 17:16:25 +08:00
|
|
|
_terrain = terrain;
|
2015-01-15 11:45:06 +08:00
|
|
|
_currentLod = 0;
|
2015-04-03 13:49:07 +08:00
|
|
|
_left = nullptr;
|
|
|
|
_right = nullptr;
|
|
|
|
_back = nullptr;
|
|
|
|
_front = nullptr;
|
2015-03-03 14:14:50 +08:00
|
|
|
_oldLod = -1;
|
2019-02-27 17:16:25 +08:00
|
|
|
for (int i = 0; i < 4; ++i)
|
2015-03-03 14:14:50 +08:00
|
|
|
{
|
|
|
|
_neighborOldLOD[i] = -1;
|
|
|
|
}
|
2019-02-27 17:16:25 +08:00
|
|
|
_command.init(_terrain->_globalZOrder);
|
|
|
|
_command.setTransparent(false);
|
|
|
|
_command.set3D(true);
|
2019-03-07 17:30:11 +08:00
|
|
|
_command.setPrimitiveType(MeshCommand::PrimitiveType::TRIANGLE);
|
|
|
|
_command.setDrawType(MeshCommand::DrawType::ELEMENT);
|
2019-03-08 11:06:03 +08:00
|
|
|
|
|
|
|
|
|
|
|
_command.setBeforeCallback(CC_CALLBACK_0(Terrain::onBeforeDraw, terrain));
|
|
|
|
_command.setAfterCallback(CC_CALLBACK_0(Terrain::onAfterDraw, terrain));
|
|
|
|
|
2019-02-27 17:16:25 +08:00
|
|
|
auto &pipelineDescriptor = _command.getPipelineDescriptor();
|
|
|
|
pipelineDescriptor.blendDescriptor.blendEnabled = false;
|
2015-01-15 11:45:06 +08:00
|
|
|
}
|
|
|
|
|
2015-03-30 18:25:22 +08:00
|
|
|
void Terrain::Chunk::updateIndicesLOD()
|
2015-01-15 11:45:06 +08:00
|
|
|
{
|
2015-03-03 14:14:50 +08:00
|
|
|
int currentNeighborLOD[4];
|
2019-02-27 17:16:25 +08:00
|
|
|
if (_left)
|
2015-03-03 14:14:50 +08:00
|
|
|
{
|
2015-04-03 13:49:07 +08:00
|
|
|
currentNeighborLOD[0] = _left->_currentLod;
|
2019-02-27 17:16:25 +08:00
|
|
|
}
|
|
|
|
else { currentNeighborLOD[0] = -1; }
|
|
|
|
if (_right)
|
2015-03-03 14:14:50 +08:00
|
|
|
{
|
2015-04-03 13:49:07 +08:00
|
|
|
currentNeighborLOD[1] = _right->_currentLod;
|
2019-02-27 17:16:25 +08:00
|
|
|
}
|
|
|
|
else { currentNeighborLOD[1] = -1; }
|
|
|
|
if (_back)
|
2015-03-03 14:14:50 +08:00
|
|
|
{
|
2015-04-03 13:49:07 +08:00
|
|
|
currentNeighborLOD[2] = _back->_currentLod;
|
2019-02-27 17:16:25 +08:00
|
|
|
}
|
|
|
|
else { currentNeighborLOD[2] = -1; }
|
|
|
|
if (_front)
|
2015-03-03 14:14:50 +08:00
|
|
|
{
|
2015-04-03 13:49:07 +08:00
|
|
|
currentNeighborLOD[3] = _front->_currentLod;
|
2019-02-27 17:16:25 +08:00
|
|
|
}
|
|
|
|
else { currentNeighborLOD[3] = -1; }
|
2015-03-03 14:14:50 +08:00
|
|
|
|
2019-02-27 17:16:25 +08:00
|
|
|
if (_oldLod == _currentLod && (memcmp(currentNeighborLOD, _neighborOldLOD, sizeof(currentNeighborLOD)) == 0))
|
2015-03-03 14:14:50 +08:00
|
|
|
{
|
|
|
|
return;// no need to update
|
|
|
|
}
|
2015-03-30 18:25:22 +08:00
|
|
|
bool isOk;
|
2019-02-27 17:16:25 +08:00
|
|
|
_chunkIndices = _terrain->lookForIndicesLOD(currentNeighborLOD, _currentLod, &isOk);
|
|
|
|
if (isOk)
|
2015-03-30 18:25:22 +08:00
|
|
|
{
|
|
|
|
return;
|
|
|
|
}
|
2019-02-27 17:16:25 +08:00
|
|
|
memcpy(_neighborOldLOD, currentNeighborLOD, sizeof(currentNeighborLOD));
|
2015-03-03 14:14:50 +08:00
|
|
|
_oldLod = _currentLod;
|
2015-01-15 11:45:06 +08:00
|
|
|
int gridY = _size.height;
|
|
|
|
int gridX = _size.width;
|
|
|
|
|
2019-02-27 17:16:25 +08:00
|
|
|
int step = 1 << _currentLod;
|
|
|
|
if ((_left&&_left->_currentLod > _currentLod) || (_right&&_right->_currentLod > _currentLod)
|
|
|
|
|| (_back&&_back->_currentLod > _currentLod) || (_front && _front->_currentLod > _currentLod))
|
2015-01-23 18:09:54 +08:00
|
|
|
//need update indices.
|
|
|
|
{
|
2016-03-21 21:04:06 +08:00
|
|
|
//t-junction inner
|
2015-04-08 15:17:05 +08:00
|
|
|
_lod[_currentLod]._indices.clear();
|
2019-02-27 17:16:25 +08:00
|
|
|
for (int i = step; i < gridY - step; i += step)
|
2015-01-15 11:45:06 +08:00
|
|
|
{
|
2019-02-27 17:16:25 +08:00
|
|
|
for (int j = step; j < gridX - step; j += step)
|
2016-03-21 21:04:06 +08:00
|
|
|
{
|
2019-02-27 17:16:25 +08:00
|
|
|
int nLocIndex = i * (gridX + 1) + j;
|
|
|
|
_lod[_currentLod]._indices.push_back(nLocIndex);
|
|
|
|
_lod[_currentLod]._indices.push_back(nLocIndex + step * (gridX + 1));
|
|
|
|
_lod[_currentLod]._indices.push_back(nLocIndex + step);
|
|
|
|
|
|
|
|
_lod[_currentLod]._indices.push_back(nLocIndex + step);
|
|
|
|
_lod[_currentLod]._indices.push_back(nLocIndex + step * (gridX + 1));
|
|
|
|
_lod[_currentLod]._indices.push_back(nLocIndex + step * (gridX + 1) + step);
|
2015-01-15 11:45:06 +08:00
|
|
|
}
|
2015-01-23 18:09:54 +08:00
|
|
|
}
|
|
|
|
//fix T-crack
|
2019-02-27 17:16:25 +08:00
|
|
|
int next_step = 1 << (_currentLod + 1);
|
|
|
|
if (_left&&_left->_currentLod > _currentLod)//left
|
2015-01-23 18:09:54 +08:00
|
|
|
{
|
2019-02-27 17:16:25 +08:00
|
|
|
for (int i = 0; i < gridY; i += next_step)
|
2015-01-15 11:45:06 +08:00
|
|
|
{
|
2019-02-27 17:16:25 +08:00
|
|
|
_lod[_currentLod]._indices.push_back(i*(gridX + 1) + step);
|
|
|
|
_lod[_currentLod]._indices.push_back(i*(gridX + 1));
|
|
|
|
_lod[_currentLod]._indices.push_back((i + next_step)*(gridX + 1));
|
2015-01-15 11:45:06 +08:00
|
|
|
|
2019-02-27 17:16:25 +08:00
|
|
|
_lod[_currentLod]._indices.push_back(i*(gridX + 1) + step);
|
|
|
|
_lod[_currentLod]._indices.push_back((i + next_step)*(gridX + 1));
|
|
|
|
_lod[_currentLod]._indices.push_back((i + step)*(gridX + 1) + step);
|
2015-01-15 11:45:06 +08:00
|
|
|
|
2019-02-27 17:16:25 +08:00
|
|
|
_lod[_currentLod]._indices.push_back((i + step)*(gridX + 1) + step);
|
|
|
|
_lod[_currentLod]._indices.push_back((i + next_step)*(gridX + 1));
|
|
|
|
_lod[_currentLod]._indices.push_back((i + next_step)*(gridX + 1) + step);
|
2015-01-23 18:09:54 +08:00
|
|
|
}
|
2019-02-27 17:16:25 +08:00
|
|
|
}
|
|
|
|
else {
|
|
|
|
int start = 0;
|
|
|
|
int end = gridY;
|
|
|
|
if (_front&&_front->_currentLod > _currentLod) end -= step;
|
|
|
|
if (_back&&_back->_currentLod > _currentLod) start += step;
|
|
|
|
for (int i = start; i < end; i += step)
|
2015-01-23 18:09:54 +08:00
|
|
|
{
|
2019-02-27 17:16:25 +08:00
|
|
|
_lod[_currentLod]._indices.push_back(i*(gridX + 1) + step);
|
|
|
|
_lod[_currentLod]._indices.push_back(i*(gridX + 1));
|
|
|
|
_lod[_currentLod]._indices.push_back((i + step)*(gridX + 1));
|
2015-01-15 11:45:06 +08:00
|
|
|
|
2019-02-27 17:16:25 +08:00
|
|
|
_lod[_currentLod]._indices.push_back(i*(gridX + 1) + step);
|
|
|
|
_lod[_currentLod]._indices.push_back((i + step)*(gridX + 1));
|
|
|
|
_lod[_currentLod]._indices.push_back((i + step)*(gridX + 1) + step);
|
2015-01-23 18:09:54 +08:00
|
|
|
}
|
|
|
|
}
|
2015-01-15 11:45:06 +08:00
|
|
|
|
2019-02-27 17:16:25 +08:00
|
|
|
if (_right&&_right->_currentLod > _currentLod)//LEFT
|
2015-01-23 18:09:54 +08:00
|
|
|
{
|
2019-02-27 17:16:25 +08:00
|
|
|
for (int i = 0; i < gridY; i += next_step)
|
2015-01-15 11:45:06 +08:00
|
|
|
{
|
2019-02-27 17:16:25 +08:00
|
|
|
_lod[_currentLod]._indices.push_back(i*(gridX + 1) + gridX);
|
|
|
|
_lod[_currentLod]._indices.push_back(i*(gridX + 1) + gridX - step);
|
|
|
|
_lod[_currentLod]._indices.push_back((i + step)*(gridX + 1) + gridX - step);
|
2015-01-15 11:45:06 +08:00
|
|
|
|
2019-02-27 17:16:25 +08:00
|
|
|
_lod[_currentLod]._indices.push_back(i*(gridX + 1) + gridX);
|
|
|
|
_lod[_currentLod]._indices.push_back((i + step)*(gridX + 1) + gridX - step);
|
|
|
|
_lod[_currentLod]._indices.push_back((i + next_step)*(gridX + 1) + gridX - step);
|
2015-01-15 11:45:06 +08:00
|
|
|
|
2019-02-27 17:16:25 +08:00
|
|
|
_lod[_currentLod]._indices.push_back(i*(gridX + 1) + gridX);
|
|
|
|
_lod[_currentLod]._indices.push_back((i + next_step)*(gridX + 1) + gridX - step);
|
|
|
|
_lod[_currentLod]._indices.push_back((i + next_step)*(gridX + 1) + gridX);
|
2015-01-23 18:09:54 +08:00
|
|
|
}
|
2019-02-27 17:16:25 +08:00
|
|
|
}
|
|
|
|
else {
|
|
|
|
int start = 0;
|
|
|
|
int end = gridY;
|
|
|
|
if (_front&&_front->_currentLod > _currentLod) end -= step;
|
|
|
|
if (_back&&_back->_currentLod > _currentLod) start += step;
|
|
|
|
for (int i = start; i < end; i += step)
|
2015-01-23 18:09:54 +08:00
|
|
|
{
|
2019-02-27 17:16:25 +08:00
|
|
|
_lod[_currentLod]._indices.push_back(i*(gridX + 1) + gridX);
|
|
|
|
_lod[_currentLod]._indices.push_back(i*(gridX + 1) + gridX - step);
|
|
|
|
_lod[_currentLod]._indices.push_back((i + step)*(gridX + 1) + gridX - step);
|
2015-01-15 11:45:06 +08:00
|
|
|
|
2019-02-27 17:16:25 +08:00
|
|
|
_lod[_currentLod]._indices.push_back(i*(gridX + 1) + gridX);
|
|
|
|
_lod[_currentLod]._indices.push_back((i + step)*(gridX + 1) + gridX - step);
|
|
|
|
_lod[_currentLod]._indices.push_back((i + step)*(gridX + 1) + gridX);
|
2015-01-23 18:09:54 +08:00
|
|
|
}
|
2015-01-15 11:45:06 +08:00
|
|
|
}
|
2019-02-27 17:16:25 +08:00
|
|
|
if (_front&&_front->_currentLod > _currentLod)//front
|
2015-01-23 18:09:54 +08:00
|
|
|
{
|
2019-02-27 17:16:25 +08:00
|
|
|
for (int i = 0; i < gridX; i += next_step)
|
2015-01-15 11:45:06 +08:00
|
|
|
{
|
2019-02-27 17:16:25 +08:00
|
|
|
_lod[_currentLod]._indices.push_back((gridY - step)*(gridX + 1) + i);
|
|
|
|
_lod[_currentLod]._indices.push_back(gridY*(gridX + 1) + i);
|
|
|
|
_lod[_currentLod]._indices.push_back((gridY - step)*(gridX + 1) + i + step);
|
2015-01-15 11:45:06 +08:00
|
|
|
|
2019-02-27 17:16:25 +08:00
|
|
|
_lod[_currentLod]._indices.push_back((gridY - step)*(gridX + 1) + i + step);
|
|
|
|
_lod[_currentLod]._indices.push_back(gridY*(gridX + 1) + i);
|
|
|
|
_lod[_currentLod]._indices.push_back(gridY*(gridX + 1) + i + next_step);
|
2015-01-15 11:45:06 +08:00
|
|
|
|
2019-02-27 17:16:25 +08:00
|
|
|
_lod[_currentLod]._indices.push_back((gridY - step)*(gridX + 1) + i + step);
|
|
|
|
_lod[_currentLod]._indices.push_back(gridY*(gridX + 1) + i + next_step);
|
|
|
|
_lod[_currentLod]._indices.push_back((gridY - step)*(gridX + 1) + i + next_step);
|
2015-01-23 18:09:54 +08:00
|
|
|
}
|
2019-02-27 17:16:25 +08:00
|
|
|
}
|
|
|
|
else
|
2015-01-23 18:09:54 +08:00
|
|
|
{
|
2019-02-27 17:16:25 +08:00
|
|
|
for (int i = step; i < gridX - step; i += step)
|
2015-01-15 11:45:06 +08:00
|
|
|
{
|
2019-02-27 17:16:25 +08:00
|
|
|
_lod[_currentLod]._indices.push_back((gridY - step)*(gridX + 1) + i);
|
|
|
|
_lod[_currentLod]._indices.push_back(gridY*(gridX + 1) + i);
|
|
|
|
_lod[_currentLod]._indices.push_back((gridY - step)*(gridX + 1) + i + step);
|
2015-01-15 11:45:06 +08:00
|
|
|
|
2019-02-27 17:16:25 +08:00
|
|
|
_lod[_currentLod]._indices.push_back((gridY - step)*(gridX + 1) + i + step);
|
|
|
|
_lod[_currentLod]._indices.push_back(gridY*(gridX + 1) + i);
|
|
|
|
_lod[_currentLod]._indices.push_back(gridY*(gridX + 1) + i + step);
|
2015-01-15 11:45:06 +08:00
|
|
|
}
|
2015-01-23 18:09:54 +08:00
|
|
|
}
|
2019-02-27 17:16:25 +08:00
|
|
|
if (_back&&_back->_currentLod > _currentLod)//back
|
2015-01-23 18:09:54 +08:00
|
|
|
{
|
2019-02-27 17:16:25 +08:00
|
|
|
for (int i = 0; i < gridX; i += next_step)
|
2015-01-15 11:45:06 +08:00
|
|
|
{
|
2015-04-08 15:17:05 +08:00
|
|
|
_lod[_currentLod]._indices.push_back(i);
|
2019-02-27 17:16:25 +08:00
|
|
|
_lod[_currentLod]._indices.push_back(step*(gridX + 1) + i);
|
|
|
|
_lod[_currentLod]._indices.push_back(step*(gridX + 1) + i + step);
|
2015-01-15 11:45:06 +08:00
|
|
|
|
2015-04-08 15:17:05 +08:00
|
|
|
_lod[_currentLod]._indices.push_back(i);
|
2019-02-27 17:16:25 +08:00
|
|
|
_lod[_currentLod]._indices.push_back(step*(gridX + 1) + i + step);
|
|
|
|
_lod[_currentLod]._indices.push_back(i + next_step);
|
2015-01-15 11:45:06 +08:00
|
|
|
|
2019-02-27 17:16:25 +08:00
|
|
|
_lod[_currentLod]._indices.push_back(i + next_step);
|
|
|
|
_lod[_currentLod]._indices.push_back(step*(gridX + 1) + i + step);
|
|
|
|
_lod[_currentLod]._indices.push_back(step*(gridX + 1) + i + next_step);
|
2015-01-15 11:45:06 +08:00
|
|
|
}
|
2019-02-27 17:16:25 +08:00
|
|
|
}
|
|
|
|
else {
|
|
|
|
for (int i = step; i < gridX - step; i += step)
|
2015-01-15 11:45:06 +08:00
|
|
|
{
|
2015-04-08 15:17:05 +08:00
|
|
|
_lod[_currentLod]._indices.push_back(i);
|
2019-02-27 17:16:25 +08:00
|
|
|
_lod[_currentLod]._indices.push_back(step*(gridX + 1) + i);
|
|
|
|
_lod[_currentLod]._indices.push_back(step*(gridX + 1) + i + step);
|
2015-01-15 11:45:06 +08:00
|
|
|
|
2015-04-08 15:17:05 +08:00
|
|
|
_lod[_currentLod]._indices.push_back(i);
|
2019-02-27 17:16:25 +08:00
|
|
|
_lod[_currentLod]._indices.push_back(step*(gridX + 1) + i + step);
|
|
|
|
_lod[_currentLod]._indices.push_back(i + step);
|
2015-01-23 18:09:54 +08:00
|
|
|
}
|
|
|
|
}
|
2015-03-30 18:25:22 +08:00
|
|
|
|
2019-02-27 17:16:25 +08:00
|
|
|
_chunkIndices = _terrain->insertIndicesLOD(currentNeighborLOD, _currentLod, &_lod[_currentLod]._indices[0], (int)_lod[_currentLod]._indices.size());
|
|
|
|
}
|
|
|
|
else {
|
2015-01-23 18:09:54 +08:00
|
|
|
//No lod difference, use simple method
|
2015-04-08 15:17:05 +08:00
|
|
|
_lod[_currentLod]._indices.clear();
|
2019-02-27 17:16:25 +08:00
|
|
|
for (int i = 0; i < gridY; i += step)
|
2015-01-23 18:09:54 +08:00
|
|
|
{
|
2019-02-27 17:16:25 +08:00
|
|
|
for (int j = 0; j < gridX; j += step)
|
2016-03-21 21:04:06 +08:00
|
|
|
{
|
2015-01-15 11:45:06 +08:00
|
|
|
|
2019-02-27 17:16:25 +08:00
|
|
|
int nLocIndex = i * (gridX + 1) + j;
|
|
|
|
_lod[_currentLod]._indices.push_back(nLocIndex);
|
|
|
|
_lod[_currentLod]._indices.push_back(nLocIndex + step * (gridX + 1));
|
|
|
|
_lod[_currentLod]._indices.push_back(nLocIndex + step);
|
2015-01-23 18:09:54 +08:00
|
|
|
|
2019-02-27 17:16:25 +08:00
|
|
|
_lod[_currentLod]._indices.push_back(nLocIndex + step);
|
|
|
|
_lod[_currentLod]._indices.push_back(nLocIndex + step * (gridX + 1));
|
|
|
|
_lod[_currentLod]._indices.push_back(nLocIndex + step * (gridX + 1) + step);
|
2015-01-15 11:45:06 +08:00
|
|
|
}
|
|
|
|
}
|
2019-02-27 17:16:25 +08:00
|
|
|
_chunkIndices = _terrain->insertIndicesLOD(currentNeighborLOD, _currentLod, &_lod[_currentLod]._indices[0], (int)_lod[_currentLod]._indices.size());
|
2015-01-23 18:09:54 +08:00
|
|
|
}
|
2015-01-15 11:45:06 +08:00
|
|
|
}
|
|
|
|
|
2015-01-20 10:34:30 +08:00
|
|
|
void Terrain::Chunk::calculateAABB()
|
2015-01-15 11:45:06 +08:00
|
|
|
{
|
|
|
|
std::vector<Vec3>pos;
|
2019-02-27 17:16:25 +08:00
|
|
|
for (size_t i = 0, size = _originalVertices.size(); i < size; ++i)
|
2015-01-15 11:45:06 +08:00
|
|
|
{
|
2015-06-16 17:46:21 +08:00
|
|
|
pos.push_back(_originalVertices[i]._position);
|
2015-01-15 11:45:06 +08:00
|
|
|
}
|
2019-02-27 17:16:25 +08:00
|
|
|
_aabb.updateMinMax(&pos[0], pos.size());
|
2015-01-15 11:45:06 +08:00
|
|
|
}
|
|
|
|
|
2015-01-20 10:34:30 +08:00
|
|
|
void Terrain::Chunk::calculateSlope()
|
2015-01-15 11:45:06 +08:00
|
|
|
{
|
|
|
|
//find max slope
|
2015-04-08 15:17:05 +08:00
|
|
|
auto lowest = _originalVertices[0]._position;
|
2019-02-27 17:16:25 +08:00
|
|
|
for (size_t i = 0, size = _originalVertices.size(); i < size; ++i)
|
2015-01-15 11:45:06 +08:00
|
|
|
{
|
2019-02-27 17:16:25 +08:00
|
|
|
if (_originalVertices[i]._position.y < lowest.y)
|
2015-01-15 11:45:06 +08:00
|
|
|
{
|
2015-04-08 15:17:05 +08:00
|
|
|
lowest = _originalVertices[i]._position;
|
2015-01-15 11:45:06 +08:00
|
|
|
}
|
|
|
|
}
|
2015-04-08 15:17:05 +08:00
|
|
|
auto highest = _originalVertices[0]._position;
|
2019-02-27 17:16:25 +08:00
|
|
|
for (size_t i = 0, size = _originalVertices.size(); i < size; ++i)
|
2015-01-15 11:45:06 +08:00
|
|
|
{
|
2019-02-27 17:16:25 +08:00
|
|
|
if (_originalVertices[i]._position.y > highest.y)
|
2015-01-15 11:45:06 +08:00
|
|
|
{
|
2015-04-08 15:17:05 +08:00
|
|
|
highest = _originalVertices[i]._position;
|
2015-01-15 11:45:06 +08:00
|
|
|
}
|
|
|
|
}
|
2019-02-27 17:16:25 +08:00
|
|
|
Vec2 a(lowest.x, lowest.z);
|
|
|
|
Vec2 b(highest.x, highest.z);
|
2015-01-23 18:09:54 +08:00
|
|
|
float dist = a.distance(b);
|
2019-02-27 17:16:25 +08:00
|
|
|
_slope = (highest.y - lowest.y) / dist;
|
2015-01-15 11:45:06 +08:00
|
|
|
}
|
|
|
|
|
2017-01-16 11:20:07 +08:00
|
|
|
bool Terrain::Chunk::getIntersectPointWithRay(const Ray& ray, Vec3& intersectPoint)
|
2015-06-23 14:27:19 +08:00
|
|
|
{
|
2015-06-24 10:49:18 +08:00
|
|
|
if (!ray.intersects(_aabb))
|
|
|
|
return false;
|
2016-03-21 21:04:06 +08:00
|
|
|
|
2015-06-24 15:49:09 +08:00
|
|
|
float minDist = FLT_MAX;
|
2015-06-23 14:27:19 +08:00
|
|
|
bool isFind = false;
|
2019-04-28 09:20:22 +08:00
|
|
|
for (const auto& triangle : _trianglesList)
|
2015-06-23 14:27:19 +08:00
|
|
|
{
|
|
|
|
Vec3 p;
|
2017-01-16 11:20:07 +08:00
|
|
|
if (triangle.getIntersectPoint(ray, p))
|
2015-06-23 14:27:19 +08:00
|
|
|
{
|
|
|
|
float dist = ray._origin.distance(p);
|
2019-02-27 17:16:25 +08:00
|
|
|
if (dist < minDist)
|
2015-06-23 14:27:19 +08:00
|
|
|
{
|
2019-02-27 17:16:25 +08:00
|
|
|
intersectPoint = p;
|
|
|
|
minDist = dist;
|
2015-06-23 14:27:19 +08:00
|
|
|
}
|
2019-02-27 17:16:25 +08:00
|
|
|
isFind = true;
|
2015-06-23 14:27:19 +08:00
|
|
|
}
|
|
|
|
}
|
2016-03-21 21:04:06 +08:00
|
|
|
|
2015-06-24 14:10:38 +08:00
|
|
|
return isFind;
|
2015-06-23 14:27:19 +08:00
|
|
|
}
|
|
|
|
|
2015-01-20 10:34:30 +08:00
|
|
|
void Terrain::Chunk::updateVerticesForLOD()
|
2015-01-15 11:45:06 +08:00
|
|
|
{
|
2019-02-27 17:16:25 +08:00
|
|
|
if (_oldLod == _currentLod) { return; } // no need to update vertices
|
2015-04-08 15:17:05 +08:00
|
|
|
_currentVertices = _originalVertices;
|
2015-01-23 18:09:54 +08:00
|
|
|
int gridY = _size.height;
|
|
|
|
int gridX = _size.width;
|
|
|
|
|
2016-07-04 22:12:45 +08:00
|
|
|
if (_currentLod >= 2 && std::abs(_slope) > 1.2f)
|
2015-01-23 18:09:54 +08:00
|
|
|
{
|
2019-02-27 17:16:25 +08:00
|
|
|
int step = 1 << _currentLod;
|
|
|
|
for (int i = step; i < gridY - step; i += step)
|
|
|
|
for (int j = step; j < gridX - step; j += step)
|
2015-01-15 11:45:06 +08:00
|
|
|
{
|
2015-01-23 18:09:54 +08:00
|
|
|
// use linear-sample adjust vertices height
|
|
|
|
float height = 0;
|
|
|
|
float count = 0;
|
2019-02-27 17:16:25 +08:00
|
|
|
for (int n = i - step / 2; n < i + step / 2; n++)
|
2015-01-15 11:45:06 +08:00
|
|
|
{
|
2019-02-27 17:16:25 +08:00
|
|
|
for (int m = j - step / 2; m < j + step / 2; m++)
|
2015-01-23 18:09:54 +08:00
|
|
|
{
|
2019-02-27 17:16:25 +08:00
|
|
|
float weight = (step / 2 - std::abs(n - i))*(step / 2 - std::abs(m - j));
|
|
|
|
height += _originalVertices[m*(gridX + 1) + n]._position.y;
|
2015-01-23 18:09:54 +08:00
|
|
|
count += weight;
|
|
|
|
}
|
2015-01-15 11:45:06 +08:00
|
|
|
}
|
2019-02-27 17:16:25 +08:00
|
|
|
_currentVertices[i*(gridX + 1) + j]._position.y = height / count;
|
2015-01-15 11:45:06 +08:00
|
|
|
}
|
2015-01-23 18:09:54 +08:00
|
|
|
}
|
2015-01-15 11:45:06 +08:00
|
|
|
|
2015-11-05 15:18:46 +08:00
|
|
|
_oldLod = _currentLod;
|
2015-01-15 11:45:06 +08:00
|
|
|
}
|
|
|
|
|
2015-01-23 18:14:44 +08:00
|
|
|
Terrain::Chunk::~Chunk()
|
|
|
|
{
|
2019-02-27 17:16:25 +08:00
|
|
|
CC_SAFE_RELEASE_NULL(_buffer);
|
2015-01-23 18:14:44 +08:00
|
|
|
}
|
|
|
|
|
2015-03-30 18:25:22 +08:00
|
|
|
void Terrain::Chunk::updateIndicesLODSkirt()
|
|
|
|
{
|
2019-02-27 17:16:25 +08:00
|
|
|
if (_oldLod == _currentLod) return;
|
2015-03-30 18:25:22 +08:00
|
|
|
_oldLod = _currentLod;
|
|
|
|
bool isOk;
|
2019-02-27 17:16:25 +08:00
|
|
|
_chunkIndices = _terrain->lookForIndicesLODSkrit(_currentLod, &isOk);
|
|
|
|
if (isOk) return;
|
2015-03-30 18:25:22 +08:00
|
|
|
|
|
|
|
int gridY = _size.height;
|
|
|
|
int gridX = _size.width;
|
2019-02-27 17:16:25 +08:00
|
|
|
int step = 1 << _currentLod;
|
|
|
|
int k = 0;
|
|
|
|
for (int i = 0; i < gridY; i += step, k += step)
|
2015-03-30 18:25:22 +08:00
|
|
|
{
|
2019-02-27 17:16:25 +08:00
|
|
|
for (int j = 0; j < gridX; j += step)
|
2016-03-21 21:04:06 +08:00
|
|
|
{
|
2019-02-27 17:16:25 +08:00
|
|
|
int nLocIndex = i * (gridX + 1) + j;
|
|
|
|
_lod[_currentLod]._indices.push_back(nLocIndex);
|
|
|
|
_lod[_currentLod]._indices.push_back(nLocIndex + step * (gridX + 1));
|
|
|
|
_lod[_currentLod]._indices.push_back(nLocIndex + step);
|
|
|
|
|
|
|
|
_lod[_currentLod]._indices.push_back(nLocIndex + step);
|
|
|
|
_lod[_currentLod]._indices.push_back(nLocIndex + step * (gridX + 1));
|
|
|
|
_lod[_currentLod]._indices.push_back(nLocIndex + step * (gridX + 1) + step);
|
2015-03-30 18:25:22 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
//add skirt
|
|
|
|
//#1
|
2019-02-27 17:16:25 +08:00
|
|
|
for (int i = 0; i < gridY; i += step)
|
2015-03-30 18:25:22 +08:00
|
|
|
{
|
2019-02-27 17:16:25 +08:00
|
|
|
int nLocIndex = i * (gridX + 1) + gridX;
|
|
|
|
_lod[_currentLod]._indices.push_back(nLocIndex);
|
|
|
|
_lod[_currentLod]._indices.push_back(nLocIndex + step * (gridX + 1));
|
|
|
|
_lod[_currentLod]._indices.push_back((gridY + 1) *(gridX + 1) + i);
|
2015-03-30 18:25:22 +08:00
|
|
|
|
2019-02-27 17:16:25 +08:00
|
|
|
_lod[_currentLod]._indices.push_back((gridY + 1) *(gridX + 1) + i);
|
|
|
|
_lod[_currentLod]._indices.push_back(nLocIndex + step * (gridX + 1));
|
|
|
|
_lod[_currentLod]._indices.push_back((gridY + 1) *(gridX + 1) + i + step);
|
2015-03-30 18:25:22 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
//#2
|
2019-02-27 17:16:25 +08:00
|
|
|
for (int j = 0; j < gridX; j += step)
|
2015-03-30 18:25:22 +08:00
|
|
|
{
|
2019-02-27 17:16:25 +08:00
|
|
|
int nLocIndex = (gridY)* (gridX + 1) + j;
|
|
|
|
_lod[_currentLod]._indices.push_back(nLocIndex);
|
|
|
|
_lod[_currentLod]._indices.push_back(_terrain->_skirtVerticesOffset[1] + j);
|
|
|
|
_lod[_currentLod]._indices.push_back(nLocIndex + step);
|
2015-03-30 18:25:22 +08:00
|
|
|
|
2019-02-27 17:16:25 +08:00
|
|
|
_lod[_currentLod]._indices.push_back(nLocIndex + step);
|
|
|
|
_lod[_currentLod]._indices.push_back(_terrain->_skirtVerticesOffset[1] + j);
|
|
|
|
_lod[_currentLod]._indices.push_back(_terrain->_skirtVerticesOffset[1] + j + step);
|
2015-04-01 18:24:05 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
//#3
|
2019-02-27 17:16:25 +08:00
|
|
|
for (int i = 0; i < gridY; i += step)
|
2015-04-01 18:24:05 +08:00
|
|
|
{
|
2019-02-27 17:16:25 +08:00
|
|
|
int nLocIndex = i * (gridX + 1);
|
|
|
|
_lod[_currentLod]._indices.push_back(nLocIndex);
|
|
|
|
_lod[_currentLod]._indices.push_back(_terrain->_skirtVerticesOffset[2] + i);
|
|
|
|
_lod[_currentLod]._indices.push_back((i + step)*(gridX + 1));
|
2015-04-01 18:24:05 +08:00
|
|
|
|
2019-02-27 17:16:25 +08:00
|
|
|
_lod[_currentLod]._indices.push_back((i + step)*(gridX + 1));
|
|
|
|
_lod[_currentLod]._indices.push_back(_terrain->_skirtVerticesOffset[2] + i);
|
|
|
|
_lod[_currentLod]._indices.push_back(_terrain->_skirtVerticesOffset[2] + i + step);
|
2015-03-30 18:25:22 +08:00
|
|
|
}
|
|
|
|
|
2015-04-01 18:24:05 +08:00
|
|
|
//#4
|
2019-02-27 17:16:25 +08:00
|
|
|
for (int j = 0; j < gridX; j += step)
|
2015-04-01 18:24:05 +08:00
|
|
|
{
|
|
|
|
int nLocIndex = j;
|
2019-02-27 17:16:25 +08:00
|
|
|
_lod[_currentLod]._indices.push_back(nLocIndex + step);
|
|
|
|
_lod[_currentLod]._indices.push_back(_terrain->_skirtVerticesOffset[3] + j);
|
|
|
|
_lod[_currentLod]._indices.push_back(nLocIndex);
|
2015-04-01 18:24:05 +08:00
|
|
|
|
|
|
|
|
2019-02-27 17:16:25 +08:00
|
|
|
_lod[_currentLod]._indices.push_back(_terrain->_skirtVerticesOffset[3] + j + step);
|
|
|
|
_lod[_currentLod]._indices.push_back(_terrain->_skirtVerticesOffset[3] + j);
|
|
|
|
_lod[_currentLod]._indices.push_back(nLocIndex + step);
|
2015-04-01 18:24:05 +08:00
|
|
|
}
|
2015-03-30 18:25:22 +08:00
|
|
|
|
2019-02-27 17:16:25 +08:00
|
|
|
_chunkIndices = _terrain->insertIndicesLODSkirt(_currentLod, &_lod[_currentLod]._indices[0], (int)_lod[_currentLod]._indices.size());
|
2015-03-30 18:25:22 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
Terrain::QuadTree::QuadTree(int x, int y, int w, int h, Terrain * terrain)
|
2015-01-15 11:45:06 +08:00
|
|
|
{
|
2015-03-03 14:14:50 +08:00
|
|
|
_terrain = terrain;
|
2015-01-23 18:09:54 +08:00
|
|
|
_needDraw = true;
|
2015-04-03 13:49:07 +08:00
|
|
|
_parent = nullptr;
|
2019-02-27 17:16:25 +08:00
|
|
|
_tl = nullptr;
|
|
|
|
_tr = nullptr;
|
|
|
|
_bl = nullptr;
|
|
|
|
_br = nullptr;
|
2015-04-03 13:49:07 +08:00
|
|
|
_posX = x;
|
|
|
|
_posY = y;
|
|
|
|
this->_height = h;
|
|
|
|
this->_width = w;
|
2019-02-27 17:16:25 +08:00
|
|
|
if (_width > terrain->_chunkSize.width &&_height > terrain->_chunkSize.height) //subdivision
|
2015-01-23 18:09:54 +08:00
|
|
|
{
|
2015-01-20 10:34:30 +08:00
|
|
|
_isTerminal = false;
|
2019-02-27 17:16:25 +08:00
|
|
|
this->_tl = new (std::nothrow) QuadTree(x, y, _width / 2, _height / 2, terrain);
|
2015-04-03 13:49:07 +08:00
|
|
|
this->_tl->_parent = this;
|
2019-02-27 17:16:25 +08:00
|
|
|
this->_tr = new (std::nothrow) QuadTree(x + _width / 2, y, _width / 2, _height / 2, terrain);
|
2015-04-03 13:49:07 +08:00
|
|
|
this->_tr->_parent = this;
|
2019-02-27 17:16:25 +08:00
|
|
|
this->_bl = new (std::nothrow) QuadTree(x, y + _height / 2, _width / 2, _height / 2, terrain);
|
2015-04-03 13:49:07 +08:00
|
|
|
this->_bl->_parent = this;
|
2019-02-27 17:16:25 +08:00
|
|
|
this->_br = new (std::nothrow) QuadTree(x + _width / 2, y + _height / 2, _width / 2, _height / 2, terrain);
|
2015-04-03 13:49:07 +08:00
|
|
|
this->_br->_parent = this;
|
|
|
|
|
2015-04-08 15:17:05 +08:00
|
|
|
_localAABB.merge(_tl->_localAABB);
|
|
|
|
_localAABB.merge(_tr->_localAABB);
|
|
|
|
_localAABB.merge(_bl->_localAABB);
|
|
|
|
_localAABB.merge(_br->_localAABB);
|
2019-02-27 17:16:25 +08:00
|
|
|
}
|
|
|
|
else // is terminal Node
|
2015-01-15 11:45:06 +08:00
|
|
|
{
|
2019-02-27 17:16:25 +08:00
|
|
|
int m = _posY / terrain->_chunkSize.height;
|
|
|
|
int n = _posX / terrain->_chunkSize.width;
|
2015-01-20 10:34:30 +08:00
|
|
|
_chunk = terrain->_chunkesArray[m][n];
|
|
|
|
_isTerminal = true;
|
2015-04-08 15:17:05 +08:00
|
|
|
_localAABB = _chunk->_aabb;
|
2015-03-03 14:14:50 +08:00
|
|
|
_chunk->_parent = this;
|
2015-06-23 14:27:19 +08:00
|
|
|
|
|
|
|
for (auto & triangle : _chunk->_trianglesList)
|
|
|
|
{
|
|
|
|
triangle.transform(_terrain->getNodeToWorldTransform());
|
|
|
|
}
|
2015-01-15 11:45:06 +08:00
|
|
|
}
|
2015-04-08 15:17:05 +08:00
|
|
|
_worldSpaceAABB = _localAABB;
|
2015-03-03 14:14:50 +08:00
|
|
|
_worldSpaceAABB.transform(_terrain->getNodeToWorldTransform());
|
2015-01-15 11:45:06 +08:00
|
|
|
}
|
|
|
|
|
2015-01-20 10:34:30 +08:00
|
|
|
void Terrain::QuadTree::draw()
|
2015-01-15 11:45:06 +08:00
|
|
|
{
|
2019-02-27 17:16:25 +08:00
|
|
|
if (!_needDraw)return;
|
|
|
|
if (_isTerminal) {
|
2015-01-15 11:45:06 +08:00
|
|
|
this->_chunk->bindAndDraw();
|
2019-02-27 17:16:25 +08:00
|
|
|
}
|
|
|
|
else
|
2015-01-15 11:45:06 +08:00
|
|
|
{
|
2015-04-03 13:49:07 +08:00
|
|
|
this->_tl->draw();
|
|
|
|
this->_tr->draw();
|
|
|
|
this->_br->draw();
|
|
|
|
this->_bl->draw();
|
2015-01-15 11:45:06 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-01-20 10:34:30 +08:00
|
|
|
void Terrain::QuadTree::resetNeedDraw(bool value)
|
2015-01-15 11:45:06 +08:00
|
|
|
{
|
|
|
|
this->_needDraw = value;
|
2019-02-27 17:16:25 +08:00
|
|
|
if (!_isTerminal)
|
2015-01-15 11:45:06 +08:00
|
|
|
{
|
2015-04-03 13:49:07 +08:00
|
|
|
_tl->resetNeedDraw(value);
|
|
|
|
_tr->resetNeedDraw(value);
|
|
|
|
_bl->resetNeedDraw(value);
|
|
|
|
_br->resetNeedDraw(value);
|
2015-01-15 11:45:06 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-03-30 18:25:22 +08:00
|
|
|
void Terrain::QuadTree::cullByCamera(const Camera * camera, const Mat4 & worldTransform)
|
2015-01-15 11:45:06 +08:00
|
|
|
{
|
2019-02-27 17:16:25 +08:00
|
|
|
if(!camera->isVisibleInFrustum(&_worldSpaceAABB))
|
|
|
|
{
|
2015-01-15 11:45:06 +08:00
|
|
|
this->resetNeedDraw(false);
|
2019-02-27 17:16:25 +08:00
|
|
|
}
|
|
|
|
else if (!_isTerminal) {
|
|
|
|
_tl->cullByCamera(camera, worldTransform);
|
|
|
|
_tr->cullByCamera(camera, worldTransform);
|
|
|
|
_bl->cullByCamera(camera, worldTransform);
|
|
|
|
_br->cullByCamera(camera, worldTransform);
|
|
|
|
}
|
2015-01-15 11:45:06 +08:00
|
|
|
}
|
|
|
|
|
2015-04-01 18:24:05 +08:00
|
|
|
void Terrain::QuadTree::preCalculateAABB(const Mat4 & worldTransform)
|
2015-03-03 14:14:50 +08:00
|
|
|
{
|
2015-04-01 18:24:05 +08:00
|
|
|
|
2015-04-08 15:17:05 +08:00
|
|
|
_worldSpaceAABB = _localAABB;
|
2015-04-03 13:49:07 +08:00
|
|
|
_worldSpaceAABB.transform(worldTransform);
|
2019-02-27 17:16:25 +08:00
|
|
|
if (!_isTerminal) {
|
2015-04-03 13:49:07 +08:00
|
|
|
_tl->preCalculateAABB(worldTransform);
|
|
|
|
_tr->preCalculateAABB(worldTransform);
|
|
|
|
_bl->preCalculateAABB(worldTransform);
|
|
|
|
_br->preCalculateAABB(worldTransform);
|
2015-03-03 14:14:50 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-04-01 18:24:05 +08:00
|
|
|
Terrain::QuadTree::~QuadTree()
|
|
|
|
{
|
2019-02-27 17:16:25 +08:00
|
|
|
if (_tl) delete _tl;
|
|
|
|
if (_tr) delete _tr;
|
|
|
|
if (_bl) delete _bl;
|
|
|
|
if (_br) delete _br;
|
2015-04-01 18:24:05 +08:00
|
|
|
}
|
|
|
|
|
2019-02-27 17:16:25 +08:00
|
|
|
Terrain::TerrainData::TerrainData(const std::string& heightMapsrc, const std::string& textureSrc, const Size & chunksize, float height, float scale)
|
2016-03-21 21:04:06 +08:00
|
|
|
{
|
2015-04-08 15:17:05 +08:00
|
|
|
this->_heightMapSrc = heightMapsrc;
|
|
|
|
this->_detailMaps[0]._detailMapSrc = textureSrc;
|
2015-11-12 18:08:29 +08:00
|
|
|
this->_alphaMapSrc = "";
|
2015-04-08 15:17:05 +08:00
|
|
|
this->_chunkSize = chunksize;
|
|
|
|
this->_mapHeight = height;
|
2016-03-21 21:04:06 +08:00
|
|
|
this->_mapScale = scale;
|
2015-04-08 15:17:05 +08:00
|
|
|
_skirtHeightRatio = 1;
|
2015-01-15 11:45:06 +08:00
|
|
|
}
|
|
|
|
|
2015-11-12 18:08:29 +08:00
|
|
|
Terrain::TerrainData::TerrainData(const std::string& heightMapsrc, const std::string& alphamap, const DetailMap& detail1, const DetailMap& detail2, const DetailMap& detail3, const DetailMap& detail4, const Size & chunksize, float height, float scale)
|
2015-01-15 11:45:06 +08:00
|
|
|
{
|
2015-04-08 15:17:05 +08:00
|
|
|
this->_heightMapSrc = heightMapsrc;
|
2015-11-12 18:08:29 +08:00
|
|
|
this->_alphaMapSrc = alphamap;
|
2015-04-08 15:17:05 +08:00
|
|
|
this->_detailMaps[0] = detail1;
|
|
|
|
this->_detailMaps[1] = detail2;
|
|
|
|
this->_detailMaps[2] = detail3;
|
|
|
|
this->_detailMaps[3] = detail4;
|
|
|
|
this->_chunkSize = chunksize;
|
|
|
|
this->_mapHeight = height;
|
|
|
|
this->_mapScale = scale;
|
2015-01-23 18:09:54 +08:00
|
|
|
_detailMapAmount = 4;
|
2015-04-08 15:17:05 +08:00
|
|
|
_skirtHeightRatio = 1;
|
2015-01-23 18:09:54 +08:00
|
|
|
}
|
|
|
|
|
2015-11-12 18:08:29 +08:00
|
|
|
Terrain::TerrainData::TerrainData(const std::string& heightMapsrc, const std::string& alphamap, const DetailMap& detail1, const DetailMap& detail2, const DetailMap& detail3, const Size & chunksize /*= Size(32,32)*/, float height /*= 2*/, float scale /*= 0.1*/)
|
2015-01-23 18:09:54 +08:00
|
|
|
{
|
2015-04-08 15:17:05 +08:00
|
|
|
this->_heightMapSrc = heightMapsrc;
|
2015-11-12 18:08:29 +08:00
|
|
|
this->_alphaMapSrc = alphamap;
|
2015-04-08 15:17:05 +08:00
|
|
|
this->_detailMaps[0] = detail1;
|
|
|
|
this->_detailMaps[1] = detail2;
|
|
|
|
this->_detailMaps[2] = detail3;
|
|
|
|
this->_chunkSize = chunksize;
|
|
|
|
this->_mapHeight = height;
|
|
|
|
this->_mapScale = scale;
|
2015-01-23 18:09:54 +08:00
|
|
|
_detailMapAmount = 3;
|
2015-04-08 15:17:05 +08:00
|
|
|
_skirtHeightRatio = 1;
|
2015-01-15 11:45:06 +08:00
|
|
|
}
|
|
|
|
|
2015-01-20 10:34:30 +08:00
|
|
|
Terrain::TerrainData::TerrainData()
|
2015-01-15 11:45:06 +08:00
|
|
|
{
|
|
|
|
|
|
|
|
}
|
|
|
|
|
2019-02-27 17:16:25 +08:00
|
|
|
Terrain::ChunkIndices::ChunkIndices(const Terrain::ChunkIndices &other)
|
|
|
|
{
|
|
|
|
_indexBuffer = other._indexBuffer;
|
|
|
|
CC_SAFE_RETAIN(_indexBuffer);
|
|
|
|
_size = other._size;
|
|
|
|
}
|
|
|
|
|
|
|
|
Terrain::ChunkIndices& Terrain::ChunkIndices::operator=(const Terrain::ChunkIndices &other)
|
|
|
|
{
|
|
|
|
if(other._indexBuffer != _indexBuffer)
|
|
|
|
{
|
|
|
|
CC_SAFE_RELEASE_NULL(_indexBuffer);
|
|
|
|
_indexBuffer = other._indexBuffer;
|
|
|
|
CC_SAFE_RETAIN(_indexBuffer);
|
|
|
|
}
|
|
|
|
_size = other._size;
|
|
|
|
return *this;
|
|
|
|
}
|
|
|
|
|
|
|
|
Terrain::ChunkIndices::~ChunkIndices()
|
|
|
|
{
|
|
|
|
CC_SAFE_RELEASE_NULL(_indexBuffer);
|
|
|
|
}
|
|
|
|
|
2015-11-12 18:08:29 +08:00
|
|
|
Terrain::DetailMap::DetailMap(const std::string& detailMapPath, float size /*= 35*/)
|
2015-01-15 11:45:06 +08:00
|
|
|
{
|
2015-04-08 15:17:05 +08:00
|
|
|
this->_detailMapSrc = detailMapPath;
|
|
|
|
this->_detailMapSize = size;
|
2015-01-15 11:45:06 +08:00
|
|
|
}
|
|
|
|
|
2015-01-20 10:34:30 +08:00
|
|
|
Terrain::DetailMap::DetailMap()
|
2015-01-15 11:45:06 +08:00
|
|
|
{
|
2016-03-21 21:04:06 +08:00
|
|
|
_detailMapSrc = "";
|
2015-04-08 15:17:05 +08:00
|
|
|
_detailMapSize = 35;
|
2015-01-15 11:45:06 +08:00
|
|
|
}
|
2015-05-08 15:49:33 +08:00
|
|
|
|
2016-05-17 12:17:56 +08:00
|
|
|
Terrain::Triangle::Triangle(const Vec3& p1, const Vec3& p2, const Vec3& p3)
|
2015-06-23 14:27:19 +08:00
|
|
|
{
|
|
|
|
_p1 = p1;
|
|
|
|
_p2 = p2;
|
|
|
|
_p3 = p3;
|
|
|
|
}
|
|
|
|
|
2016-05-17 12:17:56 +08:00
|
|
|
void Terrain::Triangle::transform(const cocos2d::Mat4& matrix)
|
2015-06-23 14:27:19 +08:00
|
|
|
{
|
|
|
|
matrix.transformPoint(&_p1);
|
|
|
|
matrix.transformPoint(&_p2);
|
|
|
|
matrix.transformPoint(&_p3);
|
|
|
|
}
|
|
|
|
|
2015-06-24 15:49:09 +08:00
|
|
|
//Please refer to 3D Math Primer for Graphics and Game Development
|
2017-01-16 11:20:07 +08:00
|
|
|
bool Terrain::Triangle::getIntersectPoint(const Ray& ray, Vec3& intersectPoint) const
|
2015-06-23 14:27:19 +08:00
|
|
|
{
|
|
|
|
// E1
|
|
|
|
Vec3 E1 = _p2 - _p1;
|
|
|
|
|
|
|
|
// E2
|
|
|
|
Vec3 E2 = _p3 - _p1;
|
|
|
|
|
|
|
|
// P
|
|
|
|
Vec3 P;
|
2019-02-27 17:16:25 +08:00
|
|
|
Vec3::cross(ray._direction, E2, &P);
|
2015-06-23 14:27:19 +08:00
|
|
|
|
|
|
|
// determinant
|
2019-02-27 17:16:25 +08:00
|
|
|
float det = E1.dot(P);
|
2015-06-23 14:27:19 +08:00
|
|
|
|
|
|
|
// keep det > 0, modify T accordingly
|
|
|
|
Vec3 T;
|
|
|
|
if (det > 0)
|
|
|
|
{
|
|
|
|
T = ray._origin - _p1;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
T = _p1 - ray._origin;
|
|
|
|
det = -det;
|
|
|
|
}
|
|
|
|
|
|
|
|
// If determinant is near zero, ray lies in plane of triangle
|
|
|
|
if (det < 0.0001f)
|
|
|
|
return false;
|
|
|
|
|
2019-02-27 17:16:25 +08:00
|
|
|
float t; // ray dist
|
|
|
|
float u, v;//barycentric coordinate
|
|
|
|
// Calculate u and make sure u <= 1
|
2015-06-23 14:27:19 +08:00
|
|
|
u = T.dot(P);
|
|
|
|
if (u < 0.0f || u > det)
|
|
|
|
return false;
|
|
|
|
|
|
|
|
// Q
|
2016-03-21 21:04:06 +08:00
|
|
|
Vec3 Q;
|
2019-02-27 17:16:25 +08:00
|
|
|
Vec3::cross(T, E1, &Q);
|
2015-06-23 14:27:19 +08:00
|
|
|
|
|
|
|
// Calculate v and make sure u + v <= 1
|
|
|
|
v = ray._direction.dot(Q);
|
|
|
|
if (v < 0.0f || u + v > det)
|
|
|
|
return false;
|
|
|
|
|
|
|
|
// Calculate t, scale parameters, ray intersects triangle
|
|
|
|
t = E2.dot(Q);
|
|
|
|
|
|
|
|
float fInvDet = 1.0f / det;
|
|
|
|
t *= fInvDet;
|
|
|
|
|
2017-01-16 11:20:07 +08:00
|
|
|
intersectPoint = ray._origin + ray._direction * t;
|
2015-06-23 14:27:19 +08:00
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2019-02-27 17:16:25 +08:00
|
|
|
void Terrain::onBeforeDraw()
|
|
|
|
{
|
|
|
|
_stateBlockOld.save();
|
|
|
|
_stateBlock.apply();
|
|
|
|
}
|
|
|
|
|
|
|
|
void Terrain::onAfterDraw()
|
|
|
|
{
|
|
|
|
_stateBlockOld.apply();
|
|
|
|
}
|
|
|
|
|
|
|
|
void Terrain::StateBlock::save()
|
|
|
|
{
|
|
|
|
auto renderer = Director::getInstance()->getRenderer();
|
|
|
|
depthWrite = renderer->getDepthWrite();
|
|
|
|
depthTest = renderer->getDepthTest();
|
|
|
|
cullFace = renderer->getCullMode();
|
2019-03-27 13:59:10 +08:00
|
|
|
winding = renderer->getWinding();
|
2019-02-27 17:16:25 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
void Terrain::StateBlock::apply()
|
|
|
|
{
|
|
|
|
auto renderer = Director::getInstance()->getRenderer();
|
|
|
|
renderer->setDepthTest(depthTest);
|
|
|
|
renderer->setDepthWrite(depthWrite);
|
|
|
|
renderer->setCullMode(cullFace);
|
2019-03-27 13:59:10 +08:00
|
|
|
renderer->setWinding(winding);
|
2019-02-27 17:16:25 +08:00
|
|
|
}
|
|
|
|
|
2015-06-23 18:31:20 +08:00
|
|
|
NS_CC_END
|