292 lines
8.4 KiB
C++
292 lines
8.4 KiB
C++
#include "ExplorerChunkTerrain.h"
|
|
|
|
#include OPENGL_FUNCTIONS_INCLUDE
|
|
#include <cmath>
|
|
#include <QImage>
|
|
#include <QOpenGLTexture>
|
|
#include "ColorProfile.h"
|
|
#include "CameraDefinition.h"
|
|
#include "OpenGLRenderer.h"
|
|
#include "TerrainRenderer.h"
|
|
|
|
ExplorerChunkTerrain::ExplorerChunkTerrain(OpenGLRenderer* renderer, double x, double z, double size, int nbchunks, double water_height):
|
|
_renderer(renderer)
|
|
{
|
|
_color_profile = new ColorProfile;
|
|
|
|
priority = 0.0;
|
|
_reset_needed = false;
|
|
|
|
_texture = new QImage(1, 1, QImage::Format_ARGB32);
|
|
texture = new QOpenGLTexture(*_texture);
|
|
_texture_changed = false;
|
|
_texture_current_size = 0;
|
|
_texture_max_size = 0;
|
|
|
|
_startx = x;
|
|
_startz = z;
|
|
_size = size;
|
|
_overall_step = size * (double) nbchunks;
|
|
|
|
_distance_to_camera = 0.0;
|
|
|
|
_water_height = water_height;
|
|
_overwater = false;
|
|
|
|
_tessellation_max_size = 32;
|
|
_tessellation = new double[(_tessellation_max_size + 1) * (_tessellation_max_size + 1)];
|
|
_tessellation_current_size = 0;
|
|
_tessellation_step = _size / (double) _tessellation_max_size;
|
|
|
|
setMaxTextureSize(128);
|
|
|
|
maintain();
|
|
}
|
|
|
|
ExplorerChunkTerrain::~ExplorerChunkTerrain()
|
|
{
|
|
_lock_data.lock();
|
|
delete _color_profile;
|
|
delete _texture;
|
|
delete texture;
|
|
delete [] _tessellation;
|
|
_lock_data.unlock();
|
|
}
|
|
|
|
bool ExplorerChunkTerrain::maintain()
|
|
{
|
|
bool subchanged;
|
|
|
|
_lock_data.lock();
|
|
if (_reset_needed)
|
|
{
|
|
_reset_needed = false;
|
|
_texture_current_size = 0;
|
|
_tessellation_current_size = 0;
|
|
_overwater = false;
|
|
}
|
|
_lock_data.unlock();
|
|
|
|
subchanged = onMaintainEvent();
|
|
|
|
// Improve texture resolution
|
|
if (_texture_current_size < _texture_max_size)
|
|
{
|
|
int new_texture_size = _texture_current_size ? _texture_current_size * 2 : 1;
|
|
QImage* new_image = new QImage(_texture->scaled(new_texture_size + 1, new_texture_size + 1, Qt::IgnoreAspectRatio, Qt::FastTransformation));
|
|
for (int j = 0; j <= new_texture_size; j++)
|
|
{
|
|
for (int i = 0; i <= new_texture_size; i++)
|
|
{
|
|
if (_texture_current_size <= 1 || i % 2 != 0 || j % 2 != 0)
|
|
{
|
|
Color color = getTextureColor((double)i / (double)new_texture_size, (double)j / (double)new_texture_size);
|
|
color = _color_profile->apply(color);
|
|
color.normalize();
|
|
new_image->setPixel(i, j, color.to32BitBGRA());
|
|
}
|
|
}
|
|
}
|
|
|
|
_lock_data.lock();
|
|
delete _texture;
|
|
_texture = new_image;
|
|
_texture_current_size = new_texture_size;
|
|
_texture_changed = true;
|
|
_lock_data.unlock();
|
|
|
|
/*if (_texture_current_size < 4 && _texture_current_size < _texture_max_size)
|
|
{
|
|
maintain();
|
|
}*/
|
|
|
|
return true;
|
|
}
|
|
else
|
|
{
|
|
return subchanged;
|
|
}
|
|
}
|
|
|
|
bool ExplorerChunkTerrain::onMaintainEvent()
|
|
{
|
|
// Improve heightmap resolution
|
|
if (_tessellation_current_size < _tessellation_max_size)
|
|
{
|
|
int new_tessellation_size = _tessellation_current_size ? _tessellation_current_size * 4 : 2;
|
|
int old_tessellation_inc = _tessellation_current_size ? _tessellation_max_size / _tessellation_current_size : 1;
|
|
int new_tessellation_inc = _tessellation_max_size / new_tessellation_size;
|
|
for (int j = 0; j <= _tessellation_max_size; j += new_tessellation_inc)
|
|
{
|
|
for (int i = 0; i <= _tessellation_max_size; i += new_tessellation_inc)
|
|
{
|
|
if (_tessellation_current_size == 0 || i % old_tessellation_inc != 0 || j % old_tessellation_inc != 0)
|
|
{
|
|
double height = _renderer->getTerrainRenderer()->getHeight(_startx + _tessellation_step * (double) i, _startz + _tessellation_step * (double) j, 1);
|
|
if (height >= _water_height)
|
|
{
|
|
_overwater = true;
|
|
}
|
|
_tessellation[j * (_tessellation_max_size + 1) + i] = height;
|
|
}
|
|
}
|
|
}
|
|
|
|
_lock_data.lock();
|
|
_tessellation_current_size = new_tessellation_size;
|
|
_lock_data.unlock();
|
|
|
|
if (_tessellation_current_size < 4 && _tessellation_current_size < _tessellation_max_size)
|
|
{
|
|
onMaintainEvent();
|
|
}
|
|
|
|
return true;
|
|
}
|
|
else
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
|
|
void ExplorerChunkTerrain::updatePriority(CameraDefinition* camera)
|
|
{
|
|
if (_reset_needed || (_texture_max_size > 1 && _texture_current_size <= 1))
|
|
{
|
|
priority = 1000.0;
|
|
}
|
|
else if (_texture_current_size == _texture_max_size)
|
|
{
|
|
priority = -1000.0;
|
|
}
|
|
else
|
|
{
|
|
priority = getDisplayedSizeHint(camera) - _texture_current_size;
|
|
}
|
|
|
|
Vector3 camera_location = camera->getLocation();
|
|
|
|
// Handle position
|
|
_lock_data.lock();
|
|
if (camera_location.x > _startx + _overall_step * 0.5)
|
|
{
|
|
_startx += _overall_step;
|
|
askReset();
|
|
}
|
|
if (camera_location.z > _startz + _overall_step * 0.5)
|
|
{
|
|
_startz += _overall_step;
|
|
askReset();
|
|
}
|
|
if (camera_location.x < _startx - _overall_step * 0.5)
|
|
{
|
|
_startx -= _overall_step;
|
|
askReset();
|
|
}
|
|
if (camera_location.z < _startz - _overall_step * 0.5)
|
|
{
|
|
_startz -= _overall_step;
|
|
askReset();
|
|
}
|
|
|
|
_distance_to_camera = getCenter().sub(camera_location).getNorm();
|
|
|
|
_lock_data.unlock();
|
|
}
|
|
|
|
void ExplorerChunkTerrain::render(OpenGLFunctions* functions)
|
|
{
|
|
// Put texture in place
|
|
_lock_data.lock();
|
|
if (_texture_changed)
|
|
{
|
|
_texture_changed = false;
|
|
texture->destroy();
|
|
// TODO Only do the scale if not power-of-two textures are unsupported by GPU
|
|
texture->setData(_texture->scaled(_texture_current_size, _texture_current_size, Qt::IgnoreAspectRatio, Qt::SmoothTransformation));
|
|
//texture->setData(*_texture);
|
|
texture->setWrapMode(QOpenGLTexture::DirectionS, QOpenGLTexture::ClampToEdge);
|
|
texture->setWrapMode(QOpenGLTexture::DirectionT, QOpenGLTexture::ClampToEdge);
|
|
}
|
|
texture->bind();
|
|
_lock_data.unlock();
|
|
|
|
// Delegate poly rendering to subclass
|
|
if (!_reset_needed)
|
|
{
|
|
_lock_data.lock();
|
|
int tessellation_size = _tessellation_current_size;
|
|
double tsize = 1.0 / (double) _tessellation_max_size;
|
|
_lock_data.unlock();
|
|
|
|
if (tessellation_size <= 1 or not _overwater)
|
|
{
|
|
return;
|
|
}
|
|
|
|
int tessellation_inc = _tessellation_max_size / (double) tessellation_size;
|
|
for (int j = 0; j < _tessellation_max_size; j += tessellation_inc)
|
|
{
|
|
functions->glBegin(GL_QUAD_STRIP);
|
|
for (int i = 0; i <= _tessellation_max_size; i += tessellation_inc)
|
|
{
|
|
functions->glTexCoord2d(tsize * (double) i, tsize * (double) j);
|
|
functions->glVertex3d(_startx + _tessellation_step * (double) i, _tessellation[j * (_tessellation_max_size + 1) + i], _startz + _tessellation_step * (double) j);
|
|
functions->glTexCoord2d(tsize * (double) i, tsize * (double) (j + tessellation_inc));
|
|
functions->glVertex3d(_startx + _tessellation_step * (double) i, _tessellation[(j + tessellation_inc) * (_tessellation_max_size + 1) + i], _startz + _tessellation_step * (double) (j + tessellation_inc));
|
|
}
|
|
functions->glEnd();
|
|
}
|
|
}
|
|
}
|
|
|
|
void ExplorerChunkTerrain::askReset()
|
|
{
|
|
_reset_needed = true;
|
|
}
|
|
|
|
void ExplorerChunkTerrain::setMaxTextureSize(int size)
|
|
{
|
|
_texture_max_size = size;
|
|
}
|
|
|
|
double ExplorerChunkTerrain::getDisplayedSizeHint(CameraDefinition* camera)
|
|
{
|
|
double distance;
|
|
Vector3 center;
|
|
|
|
if (not _overwater)
|
|
{
|
|
return -1000.0;
|
|
}
|
|
|
|
center = getCenter();
|
|
|
|
if (camera->isBoxInView(center, _size, 40.0, _size))
|
|
{
|
|
distance = _distance_to_camera;
|
|
distance = distance < 0.1 ? 0.1 : distance;
|
|
return (int) ceil(120.0 - distance / 1.5);
|
|
}
|
|
else
|
|
{
|
|
return -800.0;
|
|
}
|
|
}
|
|
|
|
Color ExplorerChunkTerrain::getTextureColor(double x, double y)
|
|
{
|
|
Vector3 location = {_startx + x * _size, 0.0, _startz + y * _size};
|
|
return _renderer->getTerrainRenderer()->getFinalColor(location, 0.01);
|
|
}
|
|
|
|
Vector3 ExplorerChunkTerrain::getCenter()
|
|
{
|
|
Vector3 result;
|
|
|
|
result.x = _startx + _size / 2.0;
|
|
result.y = 0.0;
|
|
result.z = _startz + _size / 2.0;
|
|
|
|
return result;
|
|
}
|