574 lines
14 KiB
C++
574 lines
14 KiB
C++
#include "widgetheightmap.h"
|
|
|
|
#include <QTime>
|
|
#include <QMouseEvent>
|
|
#include <QWidget>
|
|
#include <math.h>
|
|
#include <GL/glu.h>
|
|
#include "tools.h"
|
|
#include "SoftwareRenderer.h"
|
|
#include "Scenery.h"
|
|
#include "TerrainDefinition.h"
|
|
#include "TerrainHeightMap.h"
|
|
#include "WaterDefinition.h"
|
|
#include "TerrainRenderer.h"
|
|
|
|
#define HEIGHTMAP_RESOLUTION 256
|
|
|
|
WidgetHeightMap::WidgetHeightMap(QWidget* parent) :
|
|
QGLWidget(parent)
|
|
{
|
|
setMinimumSize(500, 500);
|
|
setFocusPolicy(Qt::StrongFocus);
|
|
setMouseTracking(true);
|
|
setCursor(Qt::CrossCursor);
|
|
startTimer(100);
|
|
|
|
_terrain = NULL;
|
|
_renderer = new SoftwareRenderer();
|
|
_vertices = new _VertexInfo[HEIGHTMAP_RESOLUTION * HEIGHTMAP_RESOLUTION];
|
|
|
|
_dirty = true;
|
|
|
|
_water = true;
|
|
_wireframe = true;
|
|
_painted_area = true;
|
|
|
|
_average_frame_time = 0.0;
|
|
|
|
_last_brush_action = 0;
|
|
_last_mouse_x = 250;
|
|
_last_mouse_y = 250;
|
|
_last_time = QDateTime::currentDateTime();
|
|
_mouse_moved = false;
|
|
|
|
_target_x = 0.0;
|
|
_target_z = 0.0;
|
|
_last_update_x = 0;
|
|
_last_update_z = 0;
|
|
|
|
_current_camera = new CameraDefinition;
|
|
_top_camera = new CameraDefinition;
|
|
_temp_camera = new CameraDefinition;
|
|
_zoom = 35.0;
|
|
|
|
_current_camera->setLocation(Vector3(0.0, 80.0, 10.0));
|
|
_current_camera->setTarget(VECTOR_ZERO);
|
|
_top_camera->setZoomToTarget(_zoom);
|
|
_current_camera->copy(_top_camera);
|
|
|
|
_brush = NULL;
|
|
_brush_x = 0.0;
|
|
_brush_z = 0.0;
|
|
}
|
|
|
|
WidgetHeightMap::~WidgetHeightMap()
|
|
{
|
|
delete _current_camera;
|
|
delete _top_camera;
|
|
delete _temp_camera;
|
|
delete _renderer;
|
|
delete[] _vertices;
|
|
}
|
|
|
|
void WidgetHeightMap::setTerrain(TerrainDefinition* terrain)
|
|
{
|
|
_terrain = terrain;
|
|
|
|
_renderer->getScenery()->setTerrain(_terrain);
|
|
_renderer->prepare();
|
|
|
|
revert();
|
|
}
|
|
|
|
void WidgetHeightMap::setBrush(PaintingBrush* brush)
|
|
{
|
|
_brush = brush;
|
|
updateGL();
|
|
}
|
|
|
|
void WidgetHeightMap::revert()
|
|
{
|
|
_dirty = true;
|
|
updateGL();
|
|
}
|
|
|
|
void WidgetHeightMap::toggleWater(bool enabled)
|
|
{
|
|
_water = enabled;
|
|
updateGL();
|
|
}
|
|
|
|
void WidgetHeightMap::toggleGrid(bool enabled)
|
|
{
|
|
_wireframe = enabled;
|
|
updateGL();
|
|
}
|
|
|
|
void WidgetHeightMap::togglePaintedArea(bool enabled)
|
|
{
|
|
_painted_area = enabled;
|
|
updateGL();
|
|
}
|
|
|
|
void WidgetHeightMap::keyPressEvent(QKeyEvent* event)
|
|
{
|
|
if (event->key() == Qt::Key_Up)
|
|
{
|
|
scrollTopCamera(0.0, -1.0);
|
|
}
|
|
else if (event->key() == Qt::Key_Down)
|
|
{
|
|
scrollTopCamera(0.0, 1.0);
|
|
}
|
|
else if (event->key() == Qt::Key_Left)
|
|
{
|
|
scrollTopCamera(-1.0, 0.0);
|
|
}
|
|
else if (event->key() == Qt::Key_Right)
|
|
{
|
|
scrollTopCamera(1.0, 0.0);
|
|
}
|
|
else if (event->key() == Qt::Key_PageUp)
|
|
{
|
|
zoomTopCamera(-3.0);
|
|
}
|
|
else if (event->key() == Qt::Key_PageDown)
|
|
{
|
|
zoomTopCamera(3.0);
|
|
}
|
|
else
|
|
{
|
|
QGLWidget::keyPressEvent(event);
|
|
}
|
|
}
|
|
|
|
void WidgetHeightMap::wheelEvent(QWheelEvent* event)
|
|
{
|
|
if (event->modifiers() == Qt::NoModifier)
|
|
{
|
|
if (event->orientation() == Qt::Vertical)
|
|
{
|
|
zoomTopCamera(-0.05 * (double) event->delta());
|
|
}
|
|
event->accept();
|
|
}
|
|
else
|
|
{
|
|
event->ignore();
|
|
}
|
|
}
|
|
|
|
void WidgetHeightMap::mousePressEvent(QMouseEvent* event)
|
|
{
|
|
_last_mouse_x = event->x();
|
|
_last_mouse_y = event->y();
|
|
if (event->buttons() & Qt::LeftButton)
|
|
{
|
|
_last_brush_action = 1;
|
|
}
|
|
else if (event->buttons() & Qt::RightButton)
|
|
{
|
|
_last_brush_action = -1;
|
|
}
|
|
}
|
|
|
|
void WidgetHeightMap::mouseReleaseEvent(QMouseEvent*)
|
|
{
|
|
_last_brush_action = 0;
|
|
if (_terrain)
|
|
{
|
|
_terrain->height_map->endBrushStroke();
|
|
}
|
|
if (_brush)
|
|
{
|
|
_brush->randomizeNoise();
|
|
}
|
|
}
|
|
|
|
void WidgetHeightMap::mouseMoveEvent(QMouseEvent* event)
|
|
{
|
|
/*if (event->buttons() & Qt::MiddleButton)
|
|
{
|
|
// Rotate around the turntable
|
|
int move_x = event->x() - _last_mouse_x;
|
|
int move_y = event->y() - _last_mouse_y;
|
|
|
|
// TODO
|
|
//_angle_h -= (double)move_x * 0.008;
|
|
//_angle_v += (double)move_y * 0.003;
|
|
}*/
|
|
|
|
_last_mouse_x = event->x();
|
|
_last_mouse_y = event->y();
|
|
_mouse_moved = true;
|
|
|
|
updateGL();
|
|
}
|
|
|
|
void WidgetHeightMap::timerEvent(QTimerEvent*)
|
|
{
|
|
if (not _terrain)
|
|
{
|
|
return;
|
|
}
|
|
|
|
QDateTime new_time = QDateTime::currentDateTime();
|
|
double duration = 0.001 * (double) _last_time.msecsTo(new_time);
|
|
_last_time = new_time;
|
|
|
|
// Update top camera
|
|
Vector3 target = {_target_x, _terrain->getInterpolatedHeight(_target_x, _target_z, true, true), _target_z};
|
|
_top_camera->setLocationCoords(target.x, target.y + 1.0, target.z + 0.1);
|
|
_top_camera->setTarget(target);
|
|
_top_camera->setZoomToTarget(_zoom);
|
|
if (_current_camera->transitionToAnother(_top_camera, 0.8))
|
|
{
|
|
int update_x = (int) (floor(_target_x));
|
|
int update_z = (int) (floor(_target_z));
|
|
|
|
if (update_x - _last_update_x < -10 || update_x - _last_update_x > 10 || update_z - _last_update_z < -10 || update_z - _last_update_z > 10)
|
|
{
|
|
_dirty = true;
|
|
}
|
|
|
|
updateGL();
|
|
}
|
|
|
|
if (not underMouse())
|
|
{
|
|
return;
|
|
}
|
|
|
|
// Apply brush action
|
|
if (_last_brush_action != 0 && _brush)
|
|
{
|
|
_brush->applyToTerrain(_terrain, _brush_x + _target_x, _brush_z + _target_z, duration, _last_brush_action < 0);
|
|
|
|
// TODO Only mark dirty the updated area
|
|
_dirty = true;
|
|
updateGL();
|
|
}
|
|
|
|
// Edge scrolling
|
|
double wx = (double) _last_mouse_x / (double) width();
|
|
double wy = (double) _last_mouse_y / (double) height();
|
|
double limit = 0.15;
|
|
double force = 1.0;
|
|
if (wx < limit)
|
|
{
|
|
scrollTopCamera(-(1.0 - wx / limit) * force, 0.0);
|
|
}
|
|
else if (wx > 1.0 - limit)
|
|
{
|
|
scrollTopCamera(force * (wx - (1.0 - limit)) / limit, 0.0);
|
|
}
|
|
if (wy < limit)
|
|
{
|
|
scrollTopCamera(0.0, -(1.0 - wy / limit) * force);
|
|
}
|
|
else if (wy > 1.0 - limit)
|
|
{
|
|
scrollTopCamera(0.0, force * (wy - (1.0 - limit)) / limit);
|
|
}
|
|
}
|
|
|
|
void WidgetHeightMap::initializeGL()
|
|
{
|
|
glClearColor(0.0, 0.0, 0.0, 0.0);
|
|
|
|
GLfloat light_diffuse[] = {0.75, 0.74, 0.7, 1.0};
|
|
GLfloat light_specular[] = {0.0, 0.0, 0.0, 0.0};
|
|
glLightfv(GL_LIGHT0, GL_DIFFUSE, light_diffuse);
|
|
glLightfv(GL_LIGHT0, GL_SPECULAR, light_specular);
|
|
light_diffuse[0] = 0.3;
|
|
light_diffuse[1] = 0.3;
|
|
light_diffuse[2] = 0.4;
|
|
glLightfv(GL_LIGHT1, GL_DIFFUSE, light_diffuse);
|
|
glLightfv(GL_LIGHT1, GL_SPECULAR, light_specular);
|
|
glShadeModel(GL_SMOOTH);
|
|
glEnable(GL_LIGHTING);
|
|
glEnable(GL_LIGHT0);
|
|
glEnable(GL_LIGHT1);
|
|
glEnable(GL_COLOR_MATERIAL);
|
|
//glColorMaterial(GL_FRONT_AND_BACK, GL_EMISSION);
|
|
|
|
//glFrontFace(GL_CCW);
|
|
//glCullFace(GL_BACK);
|
|
glDisable(GL_CULL_FACE);
|
|
|
|
glDepthFunc(GL_LEQUAL);
|
|
glDepthMask(GL_TRUE);
|
|
glEnable(GL_DEPTH_TEST);
|
|
|
|
glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
|
|
glEnable(GL_LINE_SMOOTH);
|
|
glLineWidth(2.0);
|
|
|
|
glDisable(GL_FOG);
|
|
|
|
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
|
|
}
|
|
|
|
void WidgetHeightMap::resizeGL(int w, int h)
|
|
{
|
|
glViewport(0, 0, w, h);
|
|
|
|
glMatrixMode(GL_PROJECTION);
|
|
glLoadIdentity();
|
|
gluPerspective(1.57 * 180.0 / M_PI, 1.0, 1.0, 1000.0);
|
|
|
|
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
|
|
}
|
|
|
|
void WidgetHeightMap::paintGL()
|
|
{
|
|
GLenum error_code;
|
|
QTime start_time;
|
|
double frame_time;
|
|
int rx, rz;
|
|
|
|
if (not _terrain)
|
|
{
|
|
return;
|
|
}
|
|
|
|
rx = HEIGHTMAP_RESOLUTION;
|
|
rz = HEIGHTMAP_RESOLUTION;
|
|
|
|
// Update vertex cache
|
|
if (_dirty)
|
|
{
|
|
updateVertexInfo();
|
|
emit heightmapChanged();
|
|
_dirty = false;
|
|
}
|
|
|
|
// Picking mouse position using z-buffer (for brush)
|
|
if (_mouse_moved)
|
|
{
|
|
GLint viewport[4];
|
|
GLdouble modelview[16];
|
|
GLdouble projection[16];
|
|
GLfloat winX, winY, winZ;
|
|
Vector3 point;
|
|
|
|
glGetDoublev(GL_MODELVIEW_MATRIX, modelview);
|
|
glGetDoublev(GL_PROJECTION_MATRIX, projection);
|
|
glGetIntegerv(GL_VIEWPORT, viewport);
|
|
|
|
winX = (float) _last_mouse_x;
|
|
winY = (float) height() - (float) _last_mouse_y;
|
|
glReadPixels(_last_mouse_x, (int) winY, 1, 1, GL_DEPTH_COMPONENT, GL_FLOAT, &winZ);
|
|
|
|
if (winZ > 0.0 && winZ < 1000.0)
|
|
{
|
|
gluUnProject(winX, winY, winZ, modelview, projection, viewport, &point.x, &point.y, &point.z);
|
|
|
|
_brush_x = point.x - _target_x;
|
|
_brush_z = point.z - _target_z;
|
|
}
|
|
|
|
_mouse_moved = false;
|
|
}
|
|
|
|
// Place camera
|
|
glMatrixMode(GL_MODELVIEW);
|
|
glLoadIdentity();
|
|
Vector3 camera_location = _current_camera->getLocation();
|
|
Vector3 camera_target = _current_camera->getTarget();
|
|
Vector3 camera_up = _current_camera->getUpVector();
|
|
gluLookAt(camera_location.x, camera_location.y, camera_location.z, camera_target.x, camera_target.y, camera_target.z, camera_up.x, camera_up.y, camera_up.z);
|
|
|
|
// Place lights
|
|
GLfloat light_position[] = {40.0, 40.0, 40.0, 0.0};
|
|
glLightfv(GL_LIGHT0, GL_POSITION, light_position);
|
|
light_position[0] = -40.0;
|
|
light_position[2] = -60.0;
|
|
glLightfv(GL_LIGHT1, GL_POSITION, light_position);
|
|
|
|
// Background
|
|
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
|
|
|
|
// Height map
|
|
for (int x = 0; x < rx - 1; x++)
|
|
{
|
|
glBegin(GL_QUAD_STRIP);
|
|
for (int z = 0; z < rz; z++)
|
|
{
|
|
for (int dx = 1; dx >= 0; dx--)
|
|
{
|
|
_VertexInfo* vertex = _vertices + z * rx + x + dx;
|
|
double brush_influence;
|
|
|
|
if (_brush)
|
|
{
|
|
double diff_x, diff_z;
|
|
|
|
diff_x = vertex->point.x - _target_x - _brush_x;
|
|
diff_z = vertex->point.z - _target_z - _brush_z;
|
|
|
|
brush_influence = _brush->getInfluence(diff_x, diff_z);
|
|
}
|
|
else
|
|
{
|
|
brush_influence = 0.0;
|
|
}
|
|
|
|
glColor3f(0.8 + brush_influence, (_painted_area && vertex->painted) ? 1.0 : 0.8, 0.8);
|
|
glNormal3f(vertex->normal.x, vertex->normal.y, vertex->normal.z);
|
|
glVertex3f(vertex->point.x, vertex->point.y, vertex->point.z);
|
|
}
|
|
}
|
|
glEnd();
|
|
}
|
|
|
|
// Wireframe
|
|
if (_wireframe)
|
|
{
|
|
glDisable(GL_LIGHTING);
|
|
glEnable(GL_BLEND);
|
|
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
|
|
glDisable(GL_DEPTH_TEST);
|
|
glColor4f(0.8, 0.0, 0.0, 0.1);
|
|
for (int z = 0; z < rz; z++)
|
|
{
|
|
glBegin(GL_LINE_STRIP);
|
|
for (int x = 0; x < rx; x++)
|
|
{
|
|
_VertexInfo* vertex = _vertices + z * rx + x;
|
|
glVertex3f(vertex->point.x, vertex->point.y, vertex->point.z);
|
|
}
|
|
glEnd();
|
|
}
|
|
for (int x = 0; x < rx; x++)
|
|
{
|
|
glBegin(GL_LINE_STRIP);
|
|
for (int z = 0; z < rz; z++)
|
|
{
|
|
_VertexInfo* vertex = _vertices + z * rx + x;
|
|
glVertex3f(vertex->point.x, vertex->point.y, vertex->point.z);
|
|
}
|
|
glEnd();
|
|
}
|
|
glEnable(GL_LIGHTING);
|
|
glEnable(GL_DEPTH_TEST);
|
|
glDisable(GL_BLEND);
|
|
}
|
|
|
|
// Water
|
|
if (_water)
|
|
{
|
|
glDisable(GL_LIGHTING);
|
|
glEnable(GL_BLEND);
|
|
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
|
|
glColor4f(0.2, 0.3, 0.7, 0.7);
|
|
glBegin(GL_QUADS);
|
|
double water_height = _terrain->water_height * _terrain->scaling * _terrain->height;
|
|
glVertex3f(_target_x - 500.0, water_height, _target_z - 500.0);
|
|
glVertex3f(_target_x - 500.0, water_height, _target_z + 500.0);
|
|
glVertex3f(_target_x + 500.0, water_height, _target_z + 500.0);
|
|
glVertex3f(_target_x + 500.0, water_height, _target_z - 500.0);
|
|
glEnd();
|
|
glDisable(GL_BLEND);
|
|
glEnable(GL_LIGHTING);
|
|
}
|
|
|
|
// Time stats
|
|
frame_time = 0.001 * (double) start_time.msecsTo(QTime::currentTime());
|
|
_average_frame_time = _average_frame_time * 0.8 + frame_time * 0.2;
|
|
//printf("%d %f\n", quality, average_frame_time);
|
|
|
|
while ((error_code = glGetError()) != GL_NO_ERROR)
|
|
{
|
|
logDebug(QString("[OpenGL] ERROR : ") + (const char*) gluErrorString(error_code));
|
|
}
|
|
}
|
|
|
|
void WidgetHeightMap::scrollTopCamera(double dx, double dz)
|
|
{
|
|
if (dx != 0.0)
|
|
{
|
|
_target_x += dx * _zoom * 0.05;
|
|
}
|
|
if (dz != 0.0)
|
|
{
|
|
|
|
_target_z += dz * _zoom * 0.05;
|
|
}
|
|
}
|
|
|
|
void WidgetHeightMap::zoomTopCamera(double dzoom)
|
|
{
|
|
_zoom += dzoom;
|
|
if (_zoom < 10.0)
|
|
{
|
|
_zoom = 10.0;
|
|
}
|
|
else if (_zoom > 80.0)
|
|
{
|
|
|
|
_zoom = 80.0;
|
|
}
|
|
}
|
|
|
|
void WidgetHeightMap::updateVertexInfo()
|
|
{
|
|
int rx = HEIGHTMAP_RESOLUTION;
|
|
int rz = HEIGHTMAP_RESOLUTION;
|
|
int dx, dz;
|
|
|
|
_VertexInfo* old_vertices = _vertices;
|
|
_vertices = new _VertexInfo[rx * rz];
|
|
delete[] old_vertices;
|
|
|
|
_last_update_x = (int) (floor(_target_x));
|
|
_last_update_z = (int) (floor(_target_z));
|
|
|
|
// Update positions
|
|
for (int x = 0; x < rx; x++)
|
|
{
|
|
for (int z = 0; z < rz; z++)
|
|
{
|
|
_VertexInfo* vertex = _vertices + z * rx + x;
|
|
|
|
dx = _last_update_x + x - rx / 2;
|
|
dz = _last_update_z + z - rz / 2;
|
|
|
|
vertex->point.x = (double) dx;
|
|
vertex->point.z = (double) dz;
|
|
|
|
vertex->point.y = _terrain->getGridHeight(dx, dz, 1) * _terrain->height;
|
|
|
|
vertex->painted = _terrain->height_map->isPainted(dx, dz);
|
|
}
|
|
}
|
|
|
|
// Update normals
|
|
for (int x = 0; x < rx; x++)
|
|
{
|
|
for (int z = 0; z < rz; z++)
|
|
{
|
|
_VertexInfo* vertex = _vertices + z * rx + x;
|
|
|
|
if (x == rx - 1)
|
|
{
|
|
vertex->normal = (vertex - 1)->normal;
|
|
}
|
|
else if (z == rz - 1)
|
|
{
|
|
vertex->normal = (vertex - rx)->normal;
|
|
}
|
|
else
|
|
{
|
|
Vector3 dx, dz;
|
|
|
|
dx = (vertex + 1)->point.sub(vertex->point);
|
|
dz = (vertex + rx)->point.sub(vertex->point);
|
|
|
|
vertex->normal = dz.normalize().crossProduct(dx.normalize());
|
|
}
|
|
}
|
|
}
|
|
}
|