graphics/paysages3d
1
0
Fork 0
Code Releases Activity

paysages : Camera refactoring.

Browse source 
git-svn-id: https://subversion.assembla.com/svn/thunderk/paysages@558 b1fd45b6-86a6-48da-8261-f70d1f35bdcc
This commit is contained in:
Michaël Lemaire 2013-04-27 19:41:57 +00:00 committed by ThunderK
parent a9c37d2ad5
commit 9a4cf159ee
32 changed files with 689 additions and 442 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

26
Makefile
View file

@ -1,19 +1,25 @@
BUILDMODE=debug BUILDMODE=debug
BUILDPATH=./build/${BUILDMODE} BUILDPATH=./build/${BUILDMODE}
CC=gcc
MAKE=make
ifneq (,$(COMPILER))
CC=$(COMPILER)
endif
all: all:
@+cd src/rendering && make BUILDMODE=${BUILDMODE} PROJECT_PATH=${CURDIR} @+cd src/rendering && $(MAKE) CC=${CC} BUILDMODE=${BUILDMODE} PROJECT_PATH=${CURDIR}
@+cd src/exploring && make BUILDMODE=${BUILDMODE} PROJECT_PATH=${CURDIR} @+cd src/exploring && $(MAKE) CC=${CC} BUILDMODE=${BUILDMODE} PROJECT_PATH=${CURDIR}
@+cd src/controlling && make BUILDMODE=${BUILDMODE} PROJECT_PATH=${CURDIR} @+cd src/controlling && $(MAKE) CC=${CC} BUILDMODE=${BUILDMODE} PROJECT_PATH=${CURDIR}
@+cd src/editing && qmake "BUILDMODE=${BUILDMODE}" "PROJECT_PATH=${CURDIR}" && make @+cd src/editing && qmake "BUILDMODE=${BUILDMODE}" "PROJECT_PATH=${CURDIR}" && $(MAKE)
@+cd src/testing && make BUILDMODE=${BUILDMODE} PROJECT_PATH=${CURDIR} @+cd src/testing && $(MAKE) CC=${CC} BUILDMODE=${BUILDMODE} PROJECT_PATH=${CURDIR}
clean: clean:
cd src/rendering && make clean BUILDMODE=${BUILDMODE} PROJECT_PATH=${CURDIR} cd src/rendering && $(MAKE) clean BUILDMODE=${BUILDMODE} PROJECT_PATH=${CURDIR}
cd src/exploring && make clean BUILDMODE=${BUILDMODE} PROJECT_PATH=${CURDIR} cd src/exploring && $(MAKE) clean BUILDMODE=${BUILDMODE} PROJECT_PATH=${CURDIR}
cd src/controlling && make clean BUILDMODE=${BUILDMODE} PROJECT_PATH=${CURDIR} cd src/controlling && $(MAKE) clean BUILDMODE=${BUILDMODE} PROJECT_PATH=${CURDIR}
cd src/editing && qmake "BUILDMODE=${BUILDMODE}" "PROJECT_PATH=${CURDIR}" && make clean cd src/editing && qmake "BUILDMODE=${BUILDMODE}" "PROJECT_PATH=${CURDIR}" && $(MAKE) clean
cd src/testing && make clean BUILDMODE=${BUILDMODE} PROJECT_PATH=${CURDIR} cd src/testing && $(MAKE) clean BUILDMODE=${BUILDMODE} PROJECT_PATH=${CURDIR}
rm -f ${BUILDPATH}/paysages-cli rm -f ${BUILDPATH}/paysages-cli
rm -f ${BUILDPATH}/paysages-qt rm -f ${BUILDPATH}/paysages-qt
rm -f ${BUILDPATH}/paysages-tests rm -f ${BUILDPATH}/paysages-tests

13
src/controlling/main.c
View file

@ -173,14 +173,13 @@ int main(int argc, char** argv)
scenerySetAtmosphere(atmo); scenerySetAtmosphere(atmo);
AtmosphereDefinitionClass.destroy(atmo); AtmosphereDefinitionClass.destroy(atmo);
CameraDefinition camera; CameraDefinition* camera;
Vector3 step = {conf_camera_step_x, conf_camera_step_y, conf_camera_step_z};
camera = cameraCreateDefinition(); camera = cameraCreateDefinition();
sceneryGetCamera(&camera); sceneryGetCamera(camera);
camera.location.x += conf_camera_step_x; cameraSetLocation(camera, v3Add(cameraGetLocation(camera), step));
camera.location.y += conf_camera_step_y; scenerySetCamera(camera);
camera.location.z += conf_camera_step_z; cameraDeleteDefinition(camera);
scenerySetCamera(&camera);
cameraDeleteDefinition(&camera);
renderer = sceneryCreateStandardRenderer(); renderer = sceneryCreateStandardRenderer();
rendererSetPreviewCallbacks(renderer, NULL, NULL, _previewUpdate); rendererSetPreviewCallbacks(renderer, NULL, NULL, _previewUpdate);

5
src/editing/baseform.h
View file

@ -12,15 +12,16 @@
#include "rendering/tools/curve.h" #include "rendering/tools/curve.h"
#include "rendering/tools/color.h" #include "rendering/tools/color.h"
#include "rendering/tools/pack.h" #include "rendering/tools/pack.h"
#include "rendering/tools/lighting.h"
#include "rendering/noise.h" #include "rendering/noise.h"
#include "rendering/layers.h" #include "rendering/layers.h"
class BaseForm:public QWidget class BaseForm : public QWidget
{ {
Q_OBJECT Q_OBJECT
public: public:
BaseForm(QWidget* parent, bool auto_apply=false, bool with_layers=false); BaseForm(QWidget* parent, bool auto_apply = false, bool with_layers = false);
void hideButtons(); void hideButtons();
virtual void savePack(PackStream* stream); virtual void savePack(PackStream* stream);
virtual void loadPack(PackStream* stream); virtual void loadPack(PackStream* stream);

13
src/editing/basepreview.h
View file

@ -11,6 +11,7 @@
#include <QHash> #include <QHash>
#include "previewosd.h" #include "previewosd.h"
#include "rendering/tools/pack.h" #include "rendering/tools/pack.h"
#include "rendering/tools/color.h"
class _ContextChoice class _ContextChoice
{ {
@ -27,7 +28,8 @@ public:
bool value; bool value;
}; };
class BasePreview : public QWidget { class BasePreview : public QWidget
{
Q_OBJECT Q_OBJECT
public: public:
@ -136,12 +138,14 @@ private slots:
/*** Private section ***/ /*** Private section ***/
class PreviewChunk; class PreviewChunk;
class PreviewDrawingThread : public QThread { class PreviewDrawingThread : public QThread
{
public: public:
PreviewDrawingThread(); PreviewDrawingThread();
void askStop(); void askStop();
static inline void usleep(int us) { static inline void usleep(int us)
{
QThread::usleep(us); QThread::usleep(us);
} }
@ -152,7 +156,8 @@ private:
bool _running; bool _running;
}; };
class PreviewDrawingManager { class PreviewDrawingManager
{
public: public:
PreviewDrawingManager(); PreviewDrawingManager();
void startThreads(); void startThreads();

186
src/editing/explorerchunksky.cpp
View file

@ -16,7 +16,7 @@ ExplorerChunkSky::ExplorerChunkSky(Renderer* renderer, double size, SkyboxOrient
void ExplorerChunkSky::onCameraEvent(CameraDefinition* camera) void ExplorerChunkSky::onCameraEvent(CameraDefinition* camera)
{ {
_center = camera->location; _center = cameraGetLocation(camera);
} }
void ExplorerChunkSky::onRenderEvent(QGLWidget*) void ExplorerChunkSky::onRenderEvent(QGLWidget*)
@ -25,68 +25,68 @@ void ExplorerChunkSky::onRenderEvent(QGLWidget*)
Vector3 camera = _center; Vector3 camera = _center;
glBegin(GL_QUADS); glBegin(GL_QUADS);
switch(_orientation) switch (_orientation)
{ {
case SKYBOX_NORTH: case SKYBOX_NORTH:
glTexCoord2d(0.0, 0.0); glTexCoord2d(0.0, 0.0);
glVertex3d(camera.x - size, camera.y + size, camera.z - size); glVertex3d(camera.x - size, camera.y + size, camera.z - size);
glTexCoord2d(0.0, 1.0); glTexCoord2d(0.0, 1.0);
glVertex3d(camera.x - size, camera.y - size, camera.z - size); glVertex3d(camera.x - size, camera.y - size, camera.z - size);
glTexCoord2d(1.0, 1.0); glTexCoord2d(1.0, 1.0);
glVertex3d(camera.x + size, camera.y - size, camera.z - size); glVertex3d(camera.x + size, camera.y - size, camera.z - size);
glTexCoord2d(1.0, 0.0); glTexCoord2d(1.0, 0.0);
glVertex3d(camera.x + size, camera.y + size, camera.z - size); glVertex3d(camera.x + size, camera.y + size, camera.z - size);
break; break;
case SKYBOX_SOUTH: case SKYBOX_SOUTH:
glTexCoord2d(0.0, 0.0); glTexCoord2d(0.0, 0.0);
glVertex3d(camera.x + size, camera.y + size, camera.z + size); glVertex3d(camera.x + size, camera.y + size, camera.z + size);
glTexCoord2d(0.0, 1.0); glTexCoord2d(0.0, 1.0);
glVertex3d(camera.x + size, camera.y - size, camera.z + size); glVertex3d(camera.x + size, camera.y - size, camera.z + size);
glTexCoord2d(1.0, 1.0); glTexCoord2d(1.0, 1.0);
glVertex3d(camera.x - size, camera.y - size, camera.z + size); glVertex3d(camera.x - size, camera.y - size, camera.z + size);
glTexCoord2d(1.0, 0.0); glTexCoord2d(1.0, 0.0);
glVertex3d(camera.x - size, camera.y + size, camera.z + size); glVertex3d(camera.x - size, camera.y + size, camera.z + size);
break; break;
case SKYBOX_EAST: case SKYBOX_EAST:
glTexCoord2d(0.0, 0.0); glTexCoord2d(0.0, 0.0);
glVertex3d(camera.x + size, camera.y + size, camera.z - size); glVertex3d(camera.x + size, camera.y + size, camera.z - size);
glTexCoord2d(0.0, 1.0); glTexCoord2d(0.0, 1.0);
glVertex3d(camera.x + size, camera.y - size, camera.z - size); glVertex3d(camera.x + size, camera.y - size, camera.z - size);
glTexCoord2d(1.0, 1.0); glTexCoord2d(1.0, 1.0);
glVertex3d(camera.x + size, camera.y - size, camera.z + size); glVertex3d(camera.x + size, camera.y - size, camera.z + size);
glTexCoord2d(1.0, 0.0); glTexCoord2d(1.0, 0.0);
glVertex3d(camera.x + size, camera.y + size, camera.z + size); glVertex3d(camera.x + size, camera.y + size, camera.z + size);
break; break;
case SKYBOX_WEST: case SKYBOX_WEST:
glTexCoord2d(0.0, 0.0); glTexCoord2d(0.0, 0.0);
glVertex3d(camera.x - size, camera.y + size, camera.z + size); glVertex3d(camera.x - size, camera.y + size, camera.z + size);
glTexCoord2d(0.0, 1.0); glTexCoord2d(0.0, 1.0);
glVertex3d(camera.x - size, camera.y - size, camera.z + size); glVertex3d(camera.x - size, camera.y - size, camera.z + size);
glTexCoord2d(1.0, 1.0); glTexCoord2d(1.0, 1.0);
glVertex3d(camera.x - size, camera.y - size, camera.z - size); glVertex3d(camera.x - size, camera.y - size, camera.z - size);
glTexCoord2d(1.0, 0.0); glTexCoord2d(1.0, 0.0);
glVertex3d(camera.x - size, camera.y + size, camera.z - size); glVertex3d(camera.x - size, camera.y + size, camera.z - size);
break; break;
case SKYBOX_TOP: case SKYBOX_TOP:
glTexCoord2d(0.0, 0.0); glTexCoord2d(0.0, 0.0);
glVertex3d(camera.x - size, camera.y + size, camera.z + size); glVertex3d(camera.x - size, camera.y + size, camera.z + size);
glTexCoord2d(0.0, 1.0); glTexCoord2d(0.0, 1.0);
glVertex3d(camera.x - size, camera.y + size, camera.z - size); glVertex3d(camera.x - size, camera.y + size, camera.z - size);
glTexCoord2d(1.0, 1.0); glTexCoord2d(1.0, 1.0);
glVertex3d(camera.x + size, camera.y + size, camera.z - size); glVertex3d(camera.x + size, camera.y + size, camera.z - size);
glTexCoord2d(1.0, 0.0); glTexCoord2d(1.0, 0.0);
glVertex3d(camera.x + size, camera.y + size, camera.z + size); glVertex3d(camera.x + size, camera.y + size, camera.z + size);
break; break;
case SKYBOX_BOTTOM: case SKYBOX_BOTTOM:
/*glTexCoord2d(0.0, 0.0); /*glTexCoord2d(0.0, 0.0);
glVertex3d(camera.x - size, camera.y - size, camera.z - size); glVertex3d(camera.x - size, camera.y - size, camera.z - size);
glTexCoord2d(0.0, 1.0); glTexCoord2d(0.0, 1.0);
glVertex3d(camera.x - size, camera.y - size, camera.z + size); glVertex3d(camera.x - size, camera.y - size, camera.z + size);
glTexCoord2d(1.0, 1.0); glTexCoord2d(1.0, 1.0);
glVertex3d(camera.x + size, camera.y - size, camera.z + size); glVertex3d(camera.x + size, camera.y - size, camera.z + size);
glTexCoord2d(1.0, 0.0); glTexCoord2d(1.0, 0.0);
glVertex3d(camera.x + size, camera.y - size, camera.z - size);*/ glVertex3d(camera.x + size, camera.y - size, camera.z - size);*/
break; break;
} }
glEnd(); glEnd();
} }
@ -103,38 +103,38 @@ Color ExplorerChunkSky::getTextureColor(double x, double y)
x -= 0.5; x -= 0.5;
y -= 0.5; y -= 0.5;
switch(_orientation) switch (_orientation)
{ {
case SKYBOX_NORTH: case SKYBOX_NORTH:
location.x = x; location.x = x;
location.y = -y; location.y = -y;
location.z = -0.5; location.z = -0.5;
break; break;
case SKYBOX_SOUTH: case SKYBOX_SOUTH:
location.x = -x; location.x = -x;
location.y = -y; location.y = -y;
location.z = 0.5; location.z = 0.5;
break; break;
case SKYBOX_EAST: case SKYBOX_EAST:
location.x = 0.5; location.x = 0.5;
location.y = -y; location.y = -y;
location.z = x; location.z = x;
break; break;
case SKYBOX_WEST: case SKYBOX_WEST:
location.x = -0.5; location.x = -0.5;
location.y = -y; location.y = -y;
location.z = -x; location.z = -x;
break; break;
case SKYBOX_TOP: case SKYBOX_TOP:
location.x = x; location.x = x;
location.y = 0.5; location.y = 0.5;
location.z = -y; location.z = -y;
break; break;
case SKYBOX_BOTTOM: case SKYBOX_BOTTOM:
location.x = x; location.x = x;
location.y = -0.5; location.y = -0.5;
location.z = y; location.z = y;
break; break;
} }
location = v3Normalize(location); location = v3Normalize(location);
if (location.y < 0.0) if (location.y < 0.0)

32
src/editing/explorerchunkterrain.cpp
View file

@ -9,7 +9,7 @@ ExplorerChunkTerrain::ExplorerChunkTerrain(Renderer* renderer, double x, double
_startx = x; _startx = x;
_startz = z; _startz = z;
_size = size; _size = size;
_overall_step = size * (double)nbchunks; _overall_step = size * (double) nbchunks;
_distance_to_camera = 0.0; _distance_to_camera = 0.0;
@ -19,7 +19,7 @@ ExplorerChunkTerrain::ExplorerChunkTerrain(Renderer* renderer, double x, double
_tessellation_max_size = 32; _tessellation_max_size = 32;
_tessellation = new double[(_tessellation_max_size + 1) * (_tessellation_max_size + 1)]; _tessellation = new double[(_tessellation_max_size + 1) * (_tessellation_max_size + 1)];
_tessellation_current_size = 0; _tessellation_current_size = 0;
_tessellation_step = _size / (double)_tessellation_max_size; _tessellation_step = _size / (double) _tessellation_max_size;
setMaxTextureSize(128); setMaxTextureSize(128);
@ -55,7 +55,7 @@ bool ExplorerChunkTerrain::onMaintainEvent()
{ {
if (_tessellation_current_size == 0 || i % old_tessellation_inc != 0 || j % old_tessellation_inc != 0) if (_tessellation_current_size == 0 || i % old_tessellation_inc != 0 || j % old_tessellation_inc != 0)
{ {
double height = renderer->terrain->getHeight(renderer, _startx + _tessellation_step * (double)i, _startz + _tessellation_step * (double)j, 1); double height = renderer->terrain->getHeight(renderer, _startx + _tessellation_step * (double) i, _startz + _tessellation_step * (double) j, 1);
if (height >= _water_height) if (height >= _water_height)
{ {
_overwater = true; _overwater = true;
@ -84,30 +84,32 @@ bool ExplorerChunkTerrain::onMaintainEvent()
void ExplorerChunkTerrain::onCameraEvent(CameraDefinition* camera) void ExplorerChunkTerrain::onCameraEvent(CameraDefinition* camera)
{ {
Vector3 camera_location = cameraGetLocation(camera);
// Handle position // Handle position
_lock_data.lock(); _lock_data.lock();
if (camera->location.x > _startx + _overall_step * 0.5) if (camera_location.x > _startx + _overall_step * 0.5)
{ {
_startx += _overall_step; _startx += _overall_step;
askReset(); askReset();
} }
if (camera->location.z > _startz + _overall_step * 0.5) if (camera_location.z > _startz + _overall_step * 0.5)
{ {
_startz += _overall_step; _startz += _overall_step;
askReset(); askReset();
} }
if (camera->location.x < _startx - _overall_step * 0.5) if (camera_location.x < _startx - _overall_step * 0.5)
{ {
_startx -= _overall_step; _startx -= _overall_step;
askReset(); askReset();
} }
if (camera->location.z < _startz - _overall_step * 0.5) if (camera_location.z < _startz - _overall_step * 0.5)
{ {
_startz -= _overall_step; _startz -= _overall_step;
askReset(); askReset();
} }
_distance_to_camera = v3Norm(v3Sub(getCenter(), camera->location)); _distance_to_camera = v3Norm(v3Sub(getCenter(), camera_location));
_lock_data.unlock(); _lock_data.unlock();
} }
@ -116,7 +118,7 @@ void ExplorerChunkTerrain::onRenderEvent(QGLWidget*)
{ {
_lock_data.lock(); _lock_data.lock();
int tessellation_size = _tessellation_current_size; int tessellation_size = _tessellation_current_size;
double tsize = 1.0 / (double)_tessellation_max_size; double tsize = 1.0 / (double) _tessellation_max_size;
_lock_data.unlock(); _lock_data.unlock();
if (tessellation_size <= 1 or not _overwater) if (tessellation_size <= 1 or not _overwater)
@ -124,16 +126,16 @@ void ExplorerChunkTerrain::onRenderEvent(QGLWidget*)
return; return;
} }
int tessellation_inc = _tessellation_max_size / (double)tessellation_size; int tessellation_inc = _tessellation_max_size / (double) tessellation_size;
for (int j = 0; j < _tessellation_max_size; j += tessellation_inc) for (int j = 0; j < _tessellation_max_size; j += tessellation_inc)
{ {
glBegin(GL_QUAD_STRIP); glBegin(GL_QUAD_STRIP);
for (int i = 0; i <= _tessellation_max_size; i += tessellation_inc) for (int i = 0; i <= _tessellation_max_size; i += tessellation_inc)
{ {
glTexCoord2d(tsize * (double)i, tsize * (double)j); glTexCoord2d(tsize * (double) i, tsize * (double) j);
glVertex3d(_startx + _tessellation_step * (double)i, _tessellation[j * (_tessellation_max_size + 1) + i], _startz + _tessellation_step * (double)j); glVertex3d(_startx + _tessellation_step * (double) i, _tessellation[j * (_tessellation_max_size + 1) + i], _startz + _tessellation_step * (double) j);
glTexCoord2d(tsize * (double)i, tsize * (double)(j + tessellation_inc)); glTexCoord2d(tsize * (double) i, tsize * (double) (j + tessellation_inc));
glVertex3d(_startx + _tessellation_step * (double)i, _tessellation[(j + tessellation_inc) * (_tessellation_max_size + 1) + i], _startz + _tessellation_step * (double)(j + tessellation_inc)); glVertex3d(_startx + _tessellation_step * (double) i, _tessellation[(j + tessellation_inc) * (_tessellation_max_size + 1) + i], _startz + _tessellation_step * (double) (j + tessellation_inc));
} }
glEnd(); glEnd();
} }
@ -155,7 +157,7 @@ double ExplorerChunkTerrain::getDisplayedSizeHint(CameraDefinition* camera)
{ {
distance = _distance_to_camera; distance = _distance_to_camera;
distance = distance < 0.1 ? 0.1 : distance; distance = distance < 0.1 ? 0.1 : distance;
return (int)ceil(120.0 - distance / 1.5); return (int) ceil(120.0 - distance / 1.5);
} }
else else
{ {

21
src/editing/formrender.cpp
View file

@ -7,16 +7,17 @@
#include "rendering/scenery.h" #include "rendering/scenery.h"
/**************** Previews ****************/ /**************** Previews ****************/
class PreviewRenderLandscape:public BasePreview class PreviewRenderLandscape : public BasePreview
{ {
public: public:
PreviewRenderLandscape(QWidget* parent):BasePreview(parent)
PreviewRenderLandscape(QWidget* parent) : BasePreview(parent)
{ {
_renderer = sceneryCreateStandardRenderer(); _renderer = sceneryCreateStandardRenderer();
_renderer->getCameraLocation = _getCameraLocation; _renderer->getCameraLocation = _getCameraLocation;
lightingManagerDisableSpecularity(_renderer->lighting); lightingManagerDisableSpecularity(_renderer->lighting);
_no_clouds = (CloudsDefinition*)CloudsDefinitionClass.create(); _no_clouds = (CloudsDefinition*) CloudsDefinitionClass.create();
_clouds_enabled = true; _clouds_enabled = true;
addOsd(QString("geolocation")); addOsd(QString("geolocation"));
@ -27,6 +28,7 @@ public:
configScrolling(-1000.0, 1000.0, 0.0, -1000.0, 1000.0, 0.0); configScrolling(-1000.0, 1000.0, 0.0, -1000.0, 1000.0, 0.0);
} }
protected: protected:
Color getColor(double x, double y) Color getColor(double x, double y)
{ {
Vector3 location; Vector3 location;
@ -44,6 +46,7 @@ protected:
return _renderer->terrain->getFinalColor(_renderer, location, scaling); return _renderer->terrain->getFinalColor(_renderer, location, scaling);
} }
} }
void updateData() void updateData()
{ {
sceneryBindRenderer(_renderer); sceneryBindRenderer(_renderer);
@ -54,6 +57,7 @@ protected:
CloudsRendererClass.bind(_renderer, _no_clouds); CloudsRendererClass.bind(_renderer, _no_clouds);
} }
} }
void toggleChangeEvent(QString key, bool value) void toggleChangeEvent(QString key, bool value)
{ {
if (key == "clouds") if (key == "clouds")
@ -85,7 +89,7 @@ private:
/**************** Form ****************/ /**************** Form ****************/
FormRender::FormRender(QWidget *parent) : FormRender::FormRender(QWidget *parent) :
BaseForm(parent, true) BaseForm(parent, true)
{ {
QPushButton* button; QPushButton* button;
@ -102,7 +106,7 @@ FormRender::FormRender(QWidget *parent) :
_preview_landscape = new PreviewRenderLandscape(this); _preview_landscape = new PreviewRenderLandscape(this);
addPreview(_preview_landscape, QString(tr("Top-down preview"))); addPreview(_preview_landscape, QString(tr("Top-down preview")));
addInput(new InputCamera(this, tr("Camera"), &_camera)); addInput(new InputCamera(this, tr("Camera"), _camera));
addInputInt(tr("Quality"), &_params.quality, 1, 10, 1, 1); addInputInt(tr("Quality"), &_params.quality, 1, 10, 1, 1);
addInputInt(tr("Image width"), &_params.width, 100, 2000, 10, 100); addInputInt(tr("Image width"), &_params.width, 100, 2000, 10, 100);
addInputInt(tr("Image height"), &_params.height, 100, 1200, 10, 100); addInputInt(tr("Image height"), &_params.height, 100, 1200, 10, 100);
@ -118,6 +122,7 @@ FormRender::FormRender(QWidget *parent) :
FormRender::~FormRender() FormRender::~FormRender()
{ {
cameraDeleteDefinition(_camera);
if (_renderer_inited) if (_renderer_inited)
{ {
rendererDelete(_renderer); rendererDelete(_renderer);
@ -148,19 +153,19 @@ void FormRender::loadPack(PackStream* stream)
void FormRender::revertConfig() void FormRender::revertConfig()
{ {
sceneryGetCamera(&_camera); sceneryGetCamera(_camera);
BaseForm::revertConfig(); BaseForm::revertConfig();
} }
void FormRender::applyConfig() void FormRender::applyConfig()
{ {
scenerySetCamera(&_camera); scenerySetCamera(_camera);
BaseForm::applyConfig(); BaseForm::applyConfig();
} }
void FormRender::configChangeEvent() void FormRender::configChangeEvent()
{ {
cameraValidateDefinition(&_camera, 1); cameraValidateDefinition(_camera, 1);
BaseForm::configChangeEvent(); BaseForm::configChangeEvent();
} }

2
src/editing/formrender.h
View file

@ -31,7 +31,7 @@ private slots:
private: private:
RenderParams _params; RenderParams _params;
CameraDefinition _camera; CameraDefinition* _camera;
Renderer* _renderer; Renderer* _renderer;
bool _renderer_inited; bool _renderer_inited;
BasePreview* _preview_landscape; BasePreview* _preview_landscape;

38
src/editing/formtextures.cpp
View file

@ -4,12 +4,13 @@
#include "tools.h" #include "tools.h"
/**************** Previews ****************/ /**************** Previews ****************/
class PreviewTexturesCoverage:public BasePreview class PreviewTexturesCoverage : public BasePreview
{ {
public: public:
PreviewTexturesCoverage(QWidget* parent, TexturesLayerDefinition* layer):BasePreview(parent)
PreviewTexturesCoverage(QWidget* parent, TexturesLayerDefinition* layer) : BasePreview(parent)
{ {
_terrain = (TerrainDefinition*)TerrainDefinitionClass.create(); _terrain = (TerrainDefinition*) TerrainDefinitionClass.create();
_renderer = rendererCreate(); _renderer = rendererCreate();
_renderer->render_quality = 3; _renderer->render_quality = 3;
@ -22,11 +23,13 @@ public:
configScaling(20.0, 500.0, 20.0, 50.0); configScaling(20.0, 500.0, 20.0, 50.0);
configScrolling(-1000.0, 1000.0, 0.0, -1000.0, 1000.0, 0.0); configScrolling(-1000.0, 1000.0, 0.0, -1000.0, 1000.0, 0.0);
} }
~PreviewTexturesCoverage() ~PreviewTexturesCoverage()
{ {
//TexturesDefinitionClass.destroy(_preview_layer); //TexturesDefinitionClass.destroy(_preview_layer);
} }
protected: protected:
Color getColor(double x, double y) Color getColor(double x, double y)
{ {
Vector3 location; Vector3 location;
@ -37,6 +40,7 @@ protected:
//result.r = result.g = result.b = texturesGetLayerCoverage(_preview_layer, _renderer, location, this->scaling); //result.r = result.g = result.b = texturesGetLayerCoverage(_preview_layer, _renderer, location, this->scaling);
return result; return result;
} }
void updateData() void updateData()
{ {
sceneryGetTerrain(_terrain); sceneryGetTerrain(_terrain);
@ -52,28 +56,31 @@ private:
TerrainDefinition* _terrain; TerrainDefinition* _terrain;
}; };
class PreviewTexturesColor:public BasePreview class PreviewTexturesColor : public BasePreview
{ {
public: public:
PreviewTexturesColor(QWidget* parent, TexturesLayerDefinition* layer):BasePreview(parent)
PreviewTexturesColor(QWidget* parent, TexturesLayerDefinition* layer) : BasePreview(parent)
{ {
_original_layer = layer; _original_layer = layer;
//_preview_layer = (TexturesLayerDefinition*)TexturesDefinitionClass.create(); //_preview_layer = (TexturesLayerDefinition*)TexturesDefinitionClass.create();
_renderer = rendererCreate(); _renderer = rendererCreate();
_renderer->render_quality = 3; _renderer->render_quality = 3;
_renderer->render_camera.location.x = 0.0;
_renderer->render_camera.location.y = 20.0; Vector3 camera_location = {0.0, 20.0, 0.0};
_renderer->render_camera.location.z = 0.0; cameraSetLocation(_renderer->render_camera, camera_location);
configScaling(0.01, 1.0, 0.01, 0.1); configScaling(0.01, 1.0, 0.01, 0.1);
configScrolling(-1000.0, 1000.0, 0.0, -1000.0, 1000.0, 0.0); configScrolling(-1000.0, 1000.0, 0.0, -1000.0, 1000.0, 0.0);
} }
~PreviewTexturesColor() ~PreviewTexturesColor()
{ {
//TexturesDefinitionClass.destroy(_preview_layer); //TexturesDefinitionClass.destroy(_preview_layer);
} }
protected: protected:
Color getColor(double x, double y) Color getColor(double x, double y)
{ {
Vector3 location; Vector3 location;
@ -83,6 +90,7 @@ protected:
//return texturesGetLayerColor(_preview_layer, _renderer, location, this->scaling); //return texturesGetLayerColor(_preview_layer, _renderer, location, this->scaling);
return COLOR_BLACK; return COLOR_BLACK;
} }
void updateData() void updateData()
{ {
//TexturesDefinitionClass.copy(_original_layer, _preview_layer); //TexturesDefinitionClass.copy(_original_layer, _preview_layer);
@ -94,16 +102,16 @@ private:
}; };
/**************** Form ****************/ /**************** Form ****************/
FormTextures::FormTextures(QWidget *parent): FormTextures::FormTextures(QWidget *parent) :
BaseFormLayer(parent) BaseFormLayer(parent)
{ {
addAutoPreset(tr("Rock")); addAutoPreset(tr("Rock"));
addAutoPreset(tr("Grass")); addAutoPreset(tr("Grass"));
addAutoPreset(tr("Sand")); addAutoPreset(tr("Sand"));
addAutoPreset(tr("Snow")); addAutoPreset(tr("Snow"));
_definition = (TexturesDefinition*)TexturesDefinitionClass.create(); _definition = (TexturesDefinition*) TexturesDefinitionClass.create();
_layer = (TexturesLayerDefinition*)texturesGetLayerType().callback_create(); _layer = (TexturesLayerDefinition*) texturesGetLayerType().callback_create();
_previewCoverage = new PreviewTexturesCoverage(this, _layer); _previewCoverage = new PreviewTexturesCoverage(this, _layer);
_previewColor = new PreviewTexturesColor(this, _layer); _previewColor = new PreviewTexturesColor(this, _layer);
@ -143,16 +151,16 @@ void FormTextures::applyConfig()
void FormTextures::layerReadCurrentFrom(void* layer_definition) void FormTextures::layerReadCurrentFrom(void* layer_definition)
{ {
texturesGetLayerType().callback_copy((TexturesLayerDefinition*)layer_definition, _layer); texturesGetLayerType().callback_copy((TexturesLayerDefinition*) layer_definition, _layer);
} }
void FormTextures::layerWriteCurrentTo(void* layer_definition) void FormTextures::layerWriteCurrentTo(void* layer_definition)
{ {
texturesGetLayerType().callback_copy(_layer, (TexturesLayerDefinition*)layer_definition); texturesGetLayerType().callback_copy(_layer, (TexturesLayerDefinition*) layer_definition);
} }
void FormTextures::autoPresetSelected(int preset) void FormTextures::autoPresetSelected(int preset)
{ {
texturesLayerAutoPreset(_layer, (TexturesLayerPreset)preset); texturesLayerAutoPreset(_layer, (TexturesLayerPreset) preset);
BaseForm::autoPresetSelected(preset); BaseForm::autoPresetSelected(preset);
} }

38
src/editing/formwater.cpp
View file

@ -15,10 +15,11 @@
static WaterDefinition* _definition; static WaterDefinition* _definition;
/**************** Previews ****************/ /**************** Previews ****************/
class PreviewWaterCoverage:public BasePreview class PreviewWaterCoverage : public BasePreview
{ {
public: public:
PreviewWaterCoverage(QWidget* parent):BasePreview(parent)
PreviewWaterCoverage(QWidget* parent) : BasePreview(parent)
{ {
_renderer = waterCreatePreviewCoverageRenderer(); _renderer = waterCreatePreviewCoverageRenderer();
_highlight_enabled = true; _highlight_enabled = true;
@ -30,20 +31,23 @@ public:
configScrolling(-1000.0, 1000.0, 0.0, -1000.0, 1000.0, 0.0); configScrolling(-1000.0, 1000.0, 0.0, -1000.0, 1000.0, 0.0);
} }
protected: protected:
Color getColor(double x, double y) Color getColor(double x, double y)
{ {
return waterGetPreviewCoverage(_renderer, x, y, scaling, _highlight_enabled ? 1 : 0); return waterGetPreviewCoverage(_renderer, x, y, scaling, _highlight_enabled ? 1 : 0);
} }
void updateData() void updateData()
{ {
WaterRendererClass.bind(_renderer, _definition); WaterRendererClass.bind(_renderer, _definition);
// TODO Do this only on full refresh // TODO Do this only on full refresh
TerrainDefinition* terrain = (TerrainDefinition*)TerrainDefinitionClass.create(); TerrainDefinition* terrain = (TerrainDefinition*) TerrainDefinitionClass.create();
sceneryGetTerrain(terrain); sceneryGetTerrain(terrain);
TerrainRendererClass.bind(_renderer, terrain); TerrainRendererClass.bind(_renderer, terrain);
TerrainDefinitionClass.destroy(terrain); TerrainDefinitionClass.destroy(terrain);
} }
void toggleChangeEvent(QString key, bool value) void toggleChangeEvent(QString key, bool value)
{ {
if (key == "highlight") if (key == "highlight")
@ -57,10 +61,11 @@ private:
bool _highlight_enabled; bool _highlight_enabled;
}; };
class PreviewWaterColor:public BasePreview class PreviewWaterColor : public BasePreview
{ {
public: public:
PreviewWaterColor(QWidget* parent):BasePreview(parent)
PreviewWaterColor(QWidget* parent) : BasePreview(parent)
{ {
_background = 0; _background = 0;
_lighting_enabled = false; _lighting_enabled = false;
@ -80,6 +85,7 @@ public:
int _background; int _background;
bool _lighting_enabled; bool _lighting_enabled;
protected: protected:
Color getColor(double x, double y) Color getColor(double x, double y)
{ {
Vector3 eye, look; Vector3 eye, look;
@ -108,15 +114,19 @@ protected:
return _renderer->water->getResult(_renderer, target_x, target_z).final; return _renderer->water->getResult(_renderer, target_x, target_z).final;
} }
void cameraEvent() void cameraEvent()
{ {
cameraSetLocation(&_renderer->render_camera, 0.0, scaling, -10.0 * scaling); Vector3 camera_location = {0.0, scaling, -10.0 * scaling};
cameraSetLocation(_renderer->render_camera, camera_location);
} }
void updateData() void updateData()
{ {
WaterRendererClass.bind(_renderer, _definition); WaterRendererClass.bind(_renderer, _definition);
_renderer->water->definition->height = 0.0; _renderer->water->definition->height = 0.0;
} }
void choiceChangeEvent(const QString& key, int position) void choiceChangeEvent(const QString& key, int position)
{ {
if (key == "bg") if (key == "bg")
@ -125,6 +135,7 @@ protected:
redraw(); redraw();
} }
} }
void toggleChangeEvent(QString key, bool value) void toggleChangeEvent(QString key, bool value)
{ {
if (key == "light") if (key == "light")
@ -140,7 +151,7 @@ private:
static RayCastingResult _rayWalking(Renderer* renderer, Vector3 location, Vector3 direction, int, int, int, int) static RayCastingResult _rayWalking(Renderer* renderer, Vector3 location, Vector3 direction, int, int, int, int)
{ {
RayCastingResult result; RayCastingResult result;
PreviewWaterColor* preview = (PreviewWaterColor*)renderer->customData[0]; PreviewWaterColor* preview = (PreviewWaterColor*) renderer->customData[0];
double x, y; double x, y;
result.hit = 1; result.hit = 1;
@ -157,7 +168,7 @@ private:
switch (preview->_background) switch (preview->_background)
{ {
case 1: case 1:
result.hit_color = (((int)ceil(x * 0.2) % 2 == 0) ^ ((int)ceil(y * 0.2 - 0.5) % 2 == 0)) ? COLOR_WHITE : COLOR_BLACK; result.hit_color = (((int) ceil(x * 0.2) % 2 == 0) ^ ((int) ceil(y * 0.2 - 0.5) % 2 == 0)) ? COLOR_WHITE : COLOR_BLACK;
break; break;
case 2: case 2:
result.hit_color = (y * 0.1 > x * 0.03 + sin(x - M_PI_2)) ? COLOR_WHITE : COLOR_BLACK; result.hit_color = (y * 0.1 > x * 0.03 + sin(x - M_PI_2)) ? COLOR_WHITE : COLOR_BLACK;
@ -187,10 +198,11 @@ private:
return result; return result;
} }
static void _getLightingStatus(Renderer* renderer, LightStatus* status, Vector3, int) static void _getLightingStatus(Renderer* renderer, LightStatus* status, Vector3, int)
{ {
LightDefinition light; LightDefinition light;
PreviewWaterColor* preview = (PreviewWaterColor*)renderer->customData[0]; PreviewWaterColor* preview = (PreviewWaterColor*) renderer->customData[0];
light.color = COLOR_WHITE; light.color = COLOR_WHITE;
light.direction.x = 0.0; light.direction.x = 0.0;
light.direction.y = -0.4794; light.direction.y = -0.4794;
@ -209,13 +221,13 @@ private:
}; };
/**************** Form ****************/ /**************** Form ****************/
FormWater::FormWater(QWidget *parent): FormWater::FormWater(QWidget *parent) :
BaseForm(parent) BaseForm(parent)
{ {
addAutoPreset(tr("Lake surface")); addAutoPreset(tr("Lake surface"));
addAutoPreset(tr("Standard sea")); addAutoPreset(tr("Standard sea"));
_definition = (WaterDefinition*)WaterDefinitionClass.create(); _definition = (WaterDefinition*) WaterDefinitionClass.create();
previewCoverage = new PreviewWaterCoverage(this); previewCoverage = new PreviewWaterCoverage(this);
previewColor = new PreviewWaterColor(this); previewColor = new PreviewWaterColor(this);
@ -259,7 +271,7 @@ void FormWater::configChangeEvent()
void FormWater::autoPresetSelected(int preset) void FormWater::autoPresetSelected(int preset)
{ {
waterAutoPreset(_definition, (WaterPreset)preset); waterAutoPreset(_definition, (WaterPreset) preset);
BaseForm::autoPresetSelected(preset); BaseForm::autoPresetSelected(preset);
} }

23
src/editing/mainwindow.cpp
View file

@ -164,14 +164,14 @@ void MainWindow::refreshAll()
} }
// Refresh preview OSD // Refresh preview OSD
CameraDefinition camera = cameraCreateDefinition(); CameraDefinition* camera = cameraCreateDefinition();
PreviewOsd* osd = PreviewOsd::getInstance(QString("geolocation")); PreviewOsd* osd = PreviewOsd::getInstance(QString("geolocation"));
osd->clearItems(); osd->clearItems();
sceneryGetCamera(&camera); sceneryGetCamera(camera);
PreviewOsdItem* item = osd->newItem(50, 50); PreviewOsdItem* item = osd->newItem(50, 50);
item->drawCamera(&camera); item->drawCamera(camera);
item->setToolTip(QString(tr("Camera"))); item->setToolTip(QString(tr("Camera")));
cameraDeleteDefinition(&camera); cameraDeleteDefinition(camera);
} }
void MainWindow::fileNew() void MainWindow::fileNew()
@ -248,31 +248,34 @@ void MainWindow::quickPreview()
void MainWindow::explore3D() void MainWindow::explore3D()
{ {
CameraDefinition camera; CameraDefinition* camera;
int result; int result;
sceneryGetCamera(&camera); camera = cameraCreateDefinition();
sceneryGetCamera(camera);
DialogExplorer* dialog = new DialogExplorer(this, &camera, true); DialogExplorer* dialog = new DialogExplorer(this, camera, true);
result = dialog->exec(); result = dialog->exec();
delete dialog; delete dialog;
if (result == QDialog::Accepted) if (result == QDialog::Accepted)
{ {
scenerySetCamera(&camera); scenerySetCamera(camera);
refreshAll(); refreshAll();
} }
cameraDeleteDefinition(camera);
} }
void MainWindow::guiSaveCallback(PackStream* stream, void* data) void MainWindow::guiSaveCallback(PackStream* stream, void* data)
{ {
((MainWindow*)data)->guiSave(stream); ((MainWindow*) data)->guiSave(stream);
} }
void MainWindow::guiLoadCallback(PackStream* stream, void* data) void MainWindow::guiLoadCallback(PackStream* stream, void* data)
{ {
((MainWindow*)data)->guiLoad(stream); ((MainWindow*) data)->guiLoad(stream);
} }
void MainWindow::guiSave(PackStream* stream) void MainWindow::guiSave(PackStream* stream)

15
src/editing/previewmaterial.cpp
View file

@ -22,9 +22,8 @@ SmallMaterialPreview::SmallMaterialPreview(QWidget* parent, SurfaceMaterial* mat
_material = material; _material = material;
_renderer = rendererCreate(); _renderer = rendererCreate();
_renderer->render_camera.location.x = 0.0; Vector3 camera_location = {0.0, 0.0, 10.0};
_renderer->render_camera.location.x = 0.0; cameraSetLocation(_renderer->render_camera, camera_location);
_renderer->render_camera.location.z = 10.0;
} }
SmallMaterialPreview::~SmallMaterialPreview() SmallMaterialPreview::~SmallMaterialPreview()
@ -74,20 +73,20 @@ void SmallMaterialPreview::paintEvent(QPaintEvent*)
if (width > height) if (width > height)
{ {
factor = 2.0 / (double)height; factor = 2.0 / (double) height;
} }
else else
{ {
factor = 2.0 / (double)width; factor = 2.0 / (double) width;
} }
dx = factor * (double)width / 2.0; dx = factor * (double) width / 2.0;
dy = factor * (double)height / 2.0; dy = factor * (double) height / 2.0;
for (int x = 0; x < width; x++) for (int x = 0; x < width; x++)
{ {
for (int y = 0; y < height; y++) for (int y = 0; y < height; y++)
{ {
painter.setPen(colorToQColor(getColor((double)x * factor - dx, (double)y * factor - dy))); painter.setPen(colorToQColor(getColor((double) x * factor - dx, (double) y * factor - dy)));
painter.drawPoint(x, y); painter.drawPoint(x, y);
} }
} }

22
src/editing/previewosd.cpp
View file

@ -22,17 +22,19 @@ void PreviewOsdItem::setLocation(double x, double y)
void PreviewOsdItem::drawCamera(CameraDefinition* camera) void PreviewOsdItem::drawCamera(CameraDefinition* camera)
{ {
Vector3 camera_location = cameraGetLocation(camera);
VectorSpherical camera_direction = cameraGetDirectionSpherical(camera);
int w2 = width() / 2; int w2 = width() / 2;
int h2 = height() / 2; int h2 = height() / 2;
_xlocation = camera->location.x; _xlocation = camera_location.x;
_ylocation = camera->location.z; _ylocation = camera_location.z;
QPainter painter(this); QPainter painter(this);
painter.setPen(QPen(Qt::red, 2)); painter.setPen(QPen(Qt::red, 2));
painter.setRenderHints(QPainter::Antialiasing | QPainter::HighQualityAntialiasing, true); painter.setRenderHints(QPainter::Antialiasing | QPainter::HighQualityAntialiasing, true);
painter.drawLine(w2, h2, w2 + w2 * cos(camera->yaw - M_PI_4), h2 - h2 * sin(camera->yaw - M_PI_4)); painter.drawLine(w2, h2, w2 + w2 * cos(camera_direction.phi - M_PI_4), h2 - h2 * sin(camera_direction.phi - M_PI_4));
painter.drawLine(w2, h2, w2 + w2 * cos(camera->yaw + M_PI_4), h2 - h2 * sin(camera->yaw + M_PI_4)); painter.drawLine(w2, h2, w2 + w2 * cos(camera_direction.phi + M_PI_4), h2 - h2 * sin(camera_direction.phi + M_PI_4));
} }
void PreviewOsdItem::setToolTip(QString text) void PreviewOsdItem::setToolTip(QString text)
@ -87,7 +89,7 @@ void PreviewOsd::clearItems()
} }
_items.clear(); _items.clear();
} }
PreviewOsdItem* PreviewOsd::newItem(int width, int height) PreviewOsdItem* PreviewOsd::newItem(int width, int height)
{ {
PreviewOsdItem* item = new PreviewOsdItem(width, height); PreviewOsdItem* item = new PreviewOsdItem(width, height);
@ -106,12 +108,12 @@ PreviewOsdItem* PreviewOsd::newItem(QImage image)
void PreviewOsd::apply(QImage* mask, double xoffset, double yoffset, double scaling) void PreviewOsd::apply(QImage* mask, double xoffset, double yoffset, double scaling)
{ {
QPainter painter(mask); QPainter painter(mask);
for (int i = 0; i < _items.size(); i++) for (int i = 0; i < _items.size(); i++)
{ {
PreviewOsdItem* item = _items[i]; PreviewOsdItem* item = _items[i];
int x = (int)(mask->width() / 2 - (xoffset - item->xlocation()) / scaling - item->width() / 2); int x = (int) (mask->width() / 2 - (xoffset - item->xlocation()) / scaling - item->width() / 2);
int y = (int)(mask->height() / 2 - (yoffset - item->ylocation()) / scaling - item->height() / 2); int y = (int) (mask->height() / 2 - (yoffset - item->ylocation()) / scaling - item->height() / 2);
painter.drawImage(x, y, *item); painter.drawImage(x, y, *item);
} }
} }

73
src/editing/widgetexplorer.cpp
View file

@ -13,9 +13,10 @@
#include "explorerchunksky.h" #include "explorerchunksky.h"
#include "tools.h" #include "tools.h"
class ChunkMaintenanceThread:public QThread class ChunkMaintenanceThread : public QThread
{ {
public: public:
ChunkMaintenanceThread(WidgetExplorer* wanderer) ChunkMaintenanceThread(WidgetExplorer* wanderer)
{ {
_wanderer = wanderer; _wanderer = wanderer;
@ -33,6 +34,7 @@ public:
} }
protected: protected:
void run() void run()
{ {
while (_running) while (_running)
@ -51,7 +53,7 @@ static QVector<ChunkMaintenanceThread*> _threads;
static Vector3 _getCameraLocation(Renderer* renderer, Vector3) static Vector3 _getCameraLocation(Renderer* renderer, Vector3)
{ {
return ((CameraDefinition*)renderer->customData[2])->location; return cameraGetLocation((CameraDefinition*) renderer->customData[2]);
} }
static AtmosphereResult _applyAerialPerspective(Renderer*, Vector3, Color base) static AtmosphereResult _applyAerialPerspective(Renderer*, Vector3, Color base)
@ -64,14 +66,15 @@ static AtmosphereResult _applyAerialPerspective(Renderer*, Vector3, Color base)
return result; return result;
} }
WidgetExplorer::WidgetExplorer(QWidget *parent, CameraDefinition* camera): WidgetExplorer::WidgetExplorer(QWidget *parent, CameraDefinition* camera) :
QGLWidget(parent) QGLWidget(parent)
{ {
setMinimumSize(400, 300); setMinimumSize(400, 300);
setFocusPolicy(Qt::StrongFocus); setFocusPolicy(Qt::StrongFocus);
_current_camera = cameraCreateDefinition();
_base_camera = camera; _base_camera = camera;
cameraCopyDefinition(camera, &_current_camera); cameraCopyDefinition(camera, _current_camera);
_renderer = sceneryCreateStandardRenderer(); _renderer = sceneryCreateStandardRenderer();
_renderer->render_quality = 3; _renderer->render_quality = 3;
@ -100,6 +103,7 @@ WidgetExplorer::~WidgetExplorer()
delete _chunks[i]; delete _chunks[i];
} }
rendererDelete(_renderer); rendererDelete(_renderer);
cameraDeleteDefinition(_current_camera);
} }
void WidgetExplorer::startRendering() void WidgetExplorer::startRendering()
@ -107,14 +111,14 @@ void WidgetExplorer::startRendering()
// Add terrain // Add terrain
int chunks = 20; int chunks = 20;
double size = 400.0; double size = 400.0;
double chunksize = size / (double)chunks; double chunksize = size / (double) chunks;
double start = -size / 2.0; double start = -size / 2.0;
double water_height = _renderer->water->getHeightInfo(_renderer).base_height; double water_height = _renderer->water->getHeightInfo(_renderer).base_height;
for (int i = 0; i < chunks; i++) for (int i = 0; i < chunks; i++)
{ {
for (int j = 0; j < chunks; j++) for (int j = 0; j < chunks; j++)
{ {
ExplorerChunkTerrain* chunk = new ExplorerChunkTerrain(_renderer, start + chunksize * (double)i, start + chunksize * (double)j, chunksize, chunks, water_height); ExplorerChunkTerrain* chunk = new ExplorerChunkTerrain(_renderer, start + chunksize * (double) i, start + chunksize * (double) j, chunksize, chunks, water_height);
_chunks.append(chunk); _chunks.append(chunk);
_updateQueue.append(chunk); _updateQueue.append(chunk);
} }
@ -123,7 +127,7 @@ void WidgetExplorer::startRendering()
// Add skybox // Add skybox
for (int orientation = 0; orientation < 5; orientation++) for (int orientation = 0; orientation < 5; orientation++)
{ {
ExplorerChunkSky* chunk = new ExplorerChunkSky(_renderer, 500.0, (SkyboxOrientation)orientation); ExplorerChunkSky* chunk = new ExplorerChunkSky(_renderer, 500.0, (SkyboxOrientation) orientation);
_chunks.append(chunk); _chunks.append(chunk);
_updateQueue.append(chunk); _updateQueue.append(chunk);
} }
@ -199,13 +203,13 @@ void WidgetExplorer::performChunksMaintenance()
void WidgetExplorer::resetCamera() void WidgetExplorer::resetCamera()
{ {
cameraCopyDefinition(_base_camera, &_current_camera); cameraCopyDefinition(_base_camera, _current_camera);
updateGL(); updateGL();
} }
void WidgetExplorer::validateCamera() void WidgetExplorer::validateCamera()
{ {
cameraCopyDefinition(&_current_camera, _base_camera); cameraCopyDefinition(_current_camera, _base_camera);
} }
void WidgetExplorer::keyPressEvent(QKeyEvent* event) void WidgetExplorer::keyPressEvent(QKeyEvent* event)
@ -228,32 +232,32 @@ void WidgetExplorer::keyPressEvent(QKeyEvent* event)
if (event->key() == Qt::Key_Up) if (event->key() == Qt::Key_Up)
{ {
cameraStrafeForward(&_current_camera, 0.1 * factor); cameraStrafeForward(_current_camera, 0.1 * factor);
updateGL(); updateGL();
} }
else if (event->key() == Qt::Key_Down) else if (event->key() == Qt::Key_Down)
{ {
cameraStrafeForward(&_current_camera, -0.1 * factor); cameraStrafeForward(_current_camera, -0.1 * factor);
updateGL(); updateGL();
} }
else if (event->key() == Qt::Key_Right) else if (event->key() == Qt::Key_Right)
{ {
cameraStrafeRight(&_current_camera, 0.1 * factor); cameraStrafeRight(_current_camera, 0.1 * factor);
updateGL(); updateGL();
} }
else if (event->key() == Qt::Key_Left) else if (event->key() == Qt::Key_Left)
{ {
cameraStrafeRight(&_current_camera, -0.1 * factor); cameraStrafeRight(_current_camera, -0.1 * factor);
updateGL(); updateGL();
} }
else if (event->key() == Qt::Key_PageUp) else if (event->key() == Qt::Key_PageUp)
{ {
cameraStrafeUp(&_current_camera, 0.1 * factor); cameraStrafeUp(_current_camera, 0.1 * factor);
updateGL(); updateGL();
} }
else if (event->key() == Qt::Key_PageDown) else if (event->key() == Qt::Key_PageDown)
{ {
cameraStrafeUp(&_current_camera, -0.1 * factor); cameraStrafeUp(_current_camera, -0.1 * factor);
updateGL(); updateGL();
} }
else else
@ -290,15 +294,15 @@ void WidgetExplorer::mouseMoveEvent(QMouseEvent* event)
if (event->buttons() & Qt::LeftButton) if (event->buttons() & Qt::LeftButton)
{ {
cameraRotateYaw(&_current_camera, (double)(event->x() - _last_mouse_x) * factor * 0.1); cameraRotateYaw(_current_camera, (double) (event->x() - _last_mouse_x) * factor * 0.1);
cameraRotatePitch(&_current_camera, (double)(event->y() - _last_mouse_y) * factor * 0.1); cameraRotatePitch(_current_camera, (double) (event->y() - _last_mouse_y) * factor * 0.1);
updateGL(); updateGL();
event->accept(); event->accept();
} }
else if (event->buttons() & Qt::RightButton) else if (event->buttons() & Qt::RightButton)
{ {
cameraStrafeRight(&_current_camera, (double)(_last_mouse_x - event->x()) * factor); cameraStrafeRight(_current_camera, (double) (_last_mouse_x - event->x()) * factor);
cameraStrafeUp(&_current_camera, (double)(event->y() - _last_mouse_y) * factor); cameraStrafeUp(_current_camera, (double) (event->y() - _last_mouse_y) * factor);
updateGL(); updateGL();
event->accept(); event->accept();
} }
@ -331,7 +335,7 @@ void WidgetExplorer::wheelEvent(QWheelEvent* event)
if (event->orientation() == Qt::Vertical) if (event->orientation() == Qt::Vertical)
{ {
cameraStrafeForward(&_current_camera, (double)event->delta() * factor); cameraStrafeForward(_current_camera, (double) event->delta() * factor);
updateGL(); updateGL();
} }
event->accept(); event->accept();
@ -353,7 +357,7 @@ void WidgetExplorer::timerEvent(QTimerEvent*)
for (int i = 0; i < _chunks.count(); i++) for (int i = 0; i < _chunks.count(); i++)
{ {
_chunks[i]->updatePriority(&_current_camera); _chunks[i]->updatePriority(_current_camera);
} }
_lock_chunks.lock(); _lock_chunks.lock();
qSort(_updateQueue.begin(), _updateQueue.end(), _cmpChunks); qSort(_updateQueue.begin(), _updateQueue.end(), _cmpChunks);
@ -367,8 +371,8 @@ void WidgetExplorer::initializeGL()
void WidgetExplorer::resizeGL(int w, int h) void WidgetExplorer::resizeGL(int w, int h)
{ {
cameraSetRenderSize(&_current_camera, w, h); cameraSetRenderSize(_current_camera, w, h);
exploringSetViewPort(w, h, &_current_camera); exploringSetViewPort(w, h, _current_camera);
} }
void WidgetExplorer::paintGL() void WidgetExplorer::paintGL()
@ -378,14 +382,17 @@ void WidgetExplorer::paintGL()
double frame_time; double frame_time;
WaterDefinition* water = _renderer->water->definition; WaterDefinition* water = _renderer->water->definition;
cameraCopyDefinition(&_current_camera, &_renderer->render_camera); cameraCopyDefinition(_current_camera, _renderer->render_camera);
cameraValidateDefinition(&_current_camera, 1); cameraValidateDefinition(_current_camera, 1);
start_time = QTime::currentTime(); start_time = QTime::currentTime();
glMatrixMode(GL_MODELVIEW); glMatrixMode(GL_MODELVIEW);
glLoadIdentity(); glLoadIdentity();
gluLookAt(_current_camera.location.x, _current_camera.location.y, _current_camera.location.z, _current_camera.target.x, _current_camera.target.y, _current_camera.target.z, _current_camera.up.x, _current_camera.up.y, _current_camera.up.z); Vector3 camera_location = cameraGetLocation(_current_camera);
Vector3 camera_target = cameraGetTarget(_current_camera);
Vector3 camera_up = cameraGetUpVector(_current_camera);
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);
// Background // Background
glClearColor(0.0, 0.0, 0.0, 0.0); glClearColor(0.0, 0.0, 0.0, 0.0);
@ -395,10 +402,10 @@ void WidgetExplorer::paintGL()
glDisable(GL_TEXTURE_2D); glDisable(GL_TEXTURE_2D);
glColor3f(water->material.base.r, water->material.base.g, water->material.base.b); glColor3f(water->material.base.r, water->material.base.g, water->material.base.b);
glBegin(GL_QUADS); glBegin(GL_QUADS);
glVertex3f(_current_camera.location.x - 500.0, water->height, _current_camera.location.z - 500.0); glVertex3f(camera_location.x - 500.0, water->height, camera_location.z - 500.0);
glVertex3f(_current_camera.location.x - 500.0, water->height, _current_camera.location.z + 500.0); glVertex3f(camera_location.x - 500.0, water->height, camera_location.z + 500.0);
glVertex3f(_current_camera.location.x + 500.0, water->height, _current_camera.location.z + 500.0); glVertex3f(camera_location.x + 500.0, water->height, camera_location.z + 500.0);
glVertex3f(_current_camera.location.x + 500.0, water->height, _current_camera.location.z - 500.0); glVertex3f(camera_location.x + 500.0, water->height, camera_location.z - 500.0);
glEnd(); glEnd();
// Render chunks // Render chunks
@ -409,7 +416,7 @@ void WidgetExplorer::paintGL()
_chunks[i]->render(this); _chunks[i]->render(this);
} }
frame_time = 0.001 * (double)start_time.msecsTo(QTime::currentTime()); frame_time = 0.001 * (double) start_time.msecsTo(QTime::currentTime());
_average_frame_time = _average_frame_time * 0.8 + frame_time * 0.2; _average_frame_time = _average_frame_time * 0.8 + frame_time * 0.2;
//printf("%d %f\n", quality, average_frame_time); //printf("%d %f\n", quality, average_frame_time);
@ -434,6 +441,6 @@ void WidgetExplorer::paintGL()
while ((error_code = glGetError()) != GL_NO_ERROR) while ((error_code = glGetError()) != GL_NO_ERROR)
{ {
logDebug(QString("[OpenGL] ERROR : ") + (const char*)gluErrorString(error_code)); logDebug(QString("[OpenGL] ERROR : ") + (const char*) gluErrorString(error_code));
} }
} }

2
src/editing/widgetexplorer.h
View file

@ -34,7 +34,7 @@ private:
void startRendering(); void startRendering();
void stopRendering(); void stopRendering();
CameraDefinition _current_camera; CameraDefinition* _current_camera;
CameraDefinition* _base_camera; CameraDefinition* _base_camera;
Renderer* _renderer; Renderer* _renderer;

108
src/editing/widgetheightmap.cpp
View file

@ -9,8 +9,8 @@
#define HEIGHTMAP_RESOLUTION 256 #define HEIGHTMAP_RESOLUTION 256
WidgetHeightMap::WidgetHeightMap(QWidget *parent, TerrainDefinition* terrain): WidgetHeightMap::WidgetHeightMap(QWidget *parent, TerrainDefinition* terrain) :
QGLWidget(parent) QGLWidget(parent)
{ {
setMinimumSize(500, 500); setMinimumSize(500, 500);
setFocusPolicy(Qt::StrongFocus); setFocusPolicy(Qt::StrongFocus);
@ -39,9 +39,10 @@ WidgetHeightMap::WidgetHeightMap(QWidget *parent, TerrainDefinition* terrain):
_top_camera = cameraCreateDefinition(); _top_camera = cameraCreateDefinition();
_temp_camera = cameraCreateDefinition(); _temp_camera = cameraCreateDefinition();
cameraSetLocation(&_current_camera, 0.0, 80.0, 20.0); Vector3 camera_location = {0.0, 80.0, 20.0};
cameraSetTarget(&_current_camera, 0.0, 0.0, 0.0); cameraSetLocation(_current_camera, camera_location);
cameraCopyDefinition(&_current_camera, &_top_camera); cameraSetTarget(_current_camera, VECTOR_ZERO);
cameraCopyDefinition(_current_camera, _top_camera);
_brush_x = 0.0; _brush_x = 0.0;
_brush_z = 0.0; _brush_z = 0.0;
@ -55,6 +56,9 @@ WidgetHeightMap::WidgetHeightMap(QWidget *parent, TerrainDefinition* terrain):
WidgetHeightMap::~WidgetHeightMap() WidgetHeightMap::~WidgetHeightMap()
{ {
cameraDeleteDefinition(_current_camera);
cameraDeleteDefinition(_top_camera);
cameraDeleteDefinition(_temp_camera);
rendererDelete(_renderer); rendererDelete(_renderer);
noiseDeleteGenerator(_brush_noise); noiseDeleteGenerator(_brush_noise);
delete[] _vertices; delete[] _vertices;
@ -171,7 +175,7 @@ void WidgetHeightMap::mouseMoveEvent(QMouseEvent* event)
void WidgetHeightMap::timerEvent(QTimerEvent*) void WidgetHeightMap::timerEvent(QTimerEvent*)
{ {
QDateTime new_time = QDateTime::currentDateTime(); QDateTime new_time = QDateTime::currentDateTime();
double duration = 0.001 * (double)_last_time.msecsTo(new_time); double duration = 0.001 * (double) _last_time.msecsTo(new_time);
_last_time = new_time; _last_time = new_time;
if (not underMouse()) if (not underMouse())
@ -184,8 +188,12 @@ void WidgetHeightMap::timerEvent(QTimerEvent*)
double brush_strength; double brush_strength;
TerrainBrush brush; TerrainBrush brush;
brush.relative_x = _brush_x + _current_camera.target.x; Vector3 camera_target = cameraGetTarget(_current_camera);
brush.relative_z = _brush_z + _current_camera.target.z; double tx = camera_target.x;
double tz = camera_target.z;
brush.relative_x = _brush_x + tx;
brush.relative_z = _brush_z + tz;
brush.hard_radius = _brush_size * (1.0 - _brush_smoothing); brush.hard_radius = _brush_size * (1.0 - _brush_smoothing);
brush.smoothed_size = _brush_size * _brush_smoothing; brush.smoothed_size = _brush_size * _brush_smoothing;
brush.total_radius = brush.hard_radius + brush.smoothed_size; brush.total_radius = brush.hard_radius + brush.smoothed_size;
@ -194,24 +202,24 @@ void WidgetHeightMap::timerEvent(QTimerEvent*)
switch (_brush_mode) switch (_brush_mode)
{ {
case HEIGHTMAP_BRUSH_RAISE: case HEIGHTMAP_BRUSH_RAISE:
terrainBrushElevation(_terrain->height_map, &brush, brush_strength * _last_brush_action * 20.0); terrainBrushElevation(_terrain->height_map, &brush, brush_strength * _last_brush_action * 20.0);
break; break;
case HEIGHTMAP_BRUSH_SMOOTH: case HEIGHTMAP_BRUSH_SMOOTH:
if (_last_brush_action < 0) if (_last_brush_action < 0)
{ {
terrainBrushSmooth(_terrain->height_map, &brush, brush_strength * 0.1); terrainBrushSmooth(_terrain->height_map, &brush, brush_strength * 0.1);
} }
else else
{ {
terrainBrushAddNoise(_terrain->height_map, &brush, _brush_noise, brush_strength * 10.0); terrainBrushAddNoise(_terrain->height_map, &brush, _brush_noise, brush_strength * 10.0);
} }
break; break;
case HEIGHTMAP_BRUSH_RESTORE: case HEIGHTMAP_BRUSH_RESTORE:
terrainBrushReset(_terrain->height_map, &brush, brush_strength); terrainBrushReset(_terrain->height_map, &brush, brush_strength);
break; break;
default: default:
return; return;
} }
// TODO Only mark dirty the updated area // TODO Only mark dirty the updated area
@ -219,7 +227,12 @@ void WidgetHeightMap::timerEvent(QTimerEvent*)
updateGL(); updateGL();
} }
// Edge scrolling // Move camera
if (cameraTransitionToAnother(_current_camera, _top_camera, 0.1))
{
updateGL();
}
// TODO Apply scrolling to vertex info and dirty only needed area // TODO Apply scrolling to vertex info and dirty only needed area
/*double edge_length = 10.0; /*double edge_length = 10.0;
if (_brush_x > HEIGHTMAP_RESOLUTION / 2.0 - edge_length) if (_brush_x > HEIGHTMAP_RESOLUTION / 2.0 - edge_length)
@ -260,8 +273,8 @@ void WidgetHeightMap::initializeGL()
{ {
glClearColor(0.0, 0.0, 0.0, 0.0); glClearColor(0.0, 0.0, 0.0, 0.0);
GLfloat light_diffuse[] = { 0.75, 0.74, 0.7, 1.0 }; GLfloat light_diffuse[] = {0.75, 0.74, 0.7, 1.0};
GLfloat light_specular[] = { 0.0, 0.0, 0.0, 0.0 }; GLfloat light_specular[] = {0.0, 0.0, 0.0, 0.0};
glLightfv(GL_LIGHT0, GL_DIFFUSE, light_diffuse); glLightfv(GL_LIGHT0, GL_DIFFUSE, light_diffuse);
glLightfv(GL_LIGHT0, GL_SPECULAR, light_specular); glLightfv(GL_LIGHT0, GL_SPECULAR, light_specular);
light_diffuse[0] = 0.3; light_diffuse[0] = 0.3;
@ -335,9 +348,9 @@ void WidgetHeightMap::paintGL()
glGetDoublev(GL_PROJECTION_MATRIX, projection); glGetDoublev(GL_PROJECTION_MATRIX, projection);
glGetIntegerv(GL_VIEWPORT, viewport); glGetIntegerv(GL_VIEWPORT, viewport);
winX = (float)_last_mouse_x; winX = (float) _last_mouse_x;
winY = (float)height() - (float)_last_mouse_y; winY = (float) height() - (float) _last_mouse_y;
glReadPixels(_last_mouse_x, (int)winY, 1, 1, GL_DEPTH_COMPONENT, GL_FLOAT, &winZ); glReadPixels(_last_mouse_x, (int) winY, 1, 1, GL_DEPTH_COMPONENT, GL_FLOAT, &winZ);
if (winZ > 0.0 && winZ < 1000.0) if (winZ > 0.0 && winZ < 1000.0)
{ {
@ -356,10 +369,13 @@ void WidgetHeightMap::paintGL()
// Place camera // Place camera
glMatrixMode(GL_MODELVIEW); glMatrixMode(GL_MODELVIEW);
glLoadIdentity(); glLoadIdentity();
gluLookAt(_current_camera.location.x, _current_camera.location.y, _current_camera.location.z, _current_camera.target.x, _current_camera.target.y, _current_camera.target.z, _current_camera.up.x, _current_camera.up.y, _current_camera.up.z); Vector3 camera_location = cameraGetLocation(_current_camera);
Vector3 camera_target = cameraGetTarget(_current_camera);
Vector3 camera_up = cameraGetUpVector(_current_camera);
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 // Place lights
GLfloat light_position[] = { 40.0, 40.0, 40.0, 0.0 }; GLfloat light_position[] = {40.0, 40.0, 40.0, 0.0};
glLightfv(GL_LIGHT0, GL_POSITION, light_position); glLightfv(GL_LIGHT0, GL_POSITION, light_position);
light_position[0] = -40.0; light_position[0] = -40.0;
light_position[2] = -60.0; light_position[2] = -60.0;
@ -369,6 +385,9 @@ void WidgetHeightMap::paintGL()
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
// Height map // Height map
camera_target = cameraGetTarget(_current_camera);
double tx = camera_target.x;
double tz = camera_target.z;
for (int x = 0; x < rx - 1; x++) for (int x = 0; x < rx - 1; x++)
{ {
glBegin(GL_QUAD_STRIP); glBegin(GL_QUAD_STRIP);
@ -379,8 +398,8 @@ void WidgetHeightMap::paintGL()
_VertexInfo* vertex = _vertices + z * rx + x + dx; _VertexInfo* vertex = _vertices + z * rx + x + dx;
double diff_x, diff_z, diff; double diff_x, diff_z, diff;
diff_x = vertex->point.x - _current_camera.target.x - _brush_x; diff_x = vertex->point.x - tx - _brush_x;
diff_z = vertex->point.z - _current_camera.target.z - _brush_z; diff_z = vertex->point.z - tz - _brush_z;
diff = sqrt(diff_x * diff_x + diff_z * diff_z); diff = sqrt(diff_x * diff_x + diff_z * diff_z);
if (diff > _brush_size) if (diff > _brush_size)
{ {
@ -396,20 +415,20 @@ void WidgetHeightMap::paintGL()
} }
glColor3f(0.8 + diff, vertex->painted ? 1.0 : 0.8, 0.8); glColor3f(0.8 + diff, vertex->painted ? 1.0 : 0.8, 0.8);
glNormal3f(vertex->normal.x, vertex->normal.y, vertex->normal.z); glNormal3f(vertex->normal.x, vertex->normal.y, vertex->normal.z);
glVertex3f(vertex->point.x - _current_camera.target.x, vertex->point.y, vertex->point.z - _current_camera.target.z); glVertex3f(vertex->point.x - tx, vertex->point.y, vertex->point.z - tz);
} }
} }
glEnd(); glEnd();
} }
// Time stats // Time stats
frame_time = 0.001 * (double)start_time.msecsTo(QTime::currentTime()); frame_time = 0.001 * (double) start_time.msecsTo(QTime::currentTime());
_average_frame_time = _average_frame_time * 0.8 + frame_time * 0.2; _average_frame_time = _average_frame_time * 0.8 + frame_time * 0.2;
//printf("%d %f\n", quality, average_frame_time); //printf("%d %f\n", quality, average_frame_time);
while ((error_code = glGetError()) != GL_NO_ERROR) while ((error_code = glGetError()) != GL_NO_ERROR)
{ {
logDebug(QString("[OpenGL] ERROR : ") + (const char*)gluErrorString(error_code)); logDebug(QString("[OpenGL] ERROR : ") + (const char*) gluErrorString(error_code));
} }
} }
@ -426,17 +445,20 @@ void WidgetHeightMap::updateVertexInfo()
_memory_stats = terrainGetMemoryStats(_terrain); _memory_stats = terrainGetMemoryStats(_terrain);
// Update positions // Update positions
Vector3 camera_target = cameraGetTarget(_current_camera);
double tx = camera_target.x;
double tz = camera_target.z;
for (int x = 0; x < rx; x++) for (int x = 0; x < rx; x++)
{ {
for (int z = 0; z < rz; z++) for (int z = 0; z < rz; z++)
{ {
_VertexInfo* vertex = _vertices + z * rx + x; _VertexInfo* vertex = _vertices + z * rx + x;
dx = _current_camera.target.x + x - rx / 2; dx = tx + x - rx / 2;
dz = _current_camera.target.z + z - rz / 2; dz = tz + z - rz / 2;
vertex->point.x = (double)dx; vertex->point.x = (double) dx;
vertex->point.z = (double)dz; vertex->point.z = (double) dz;
vertex->point.y = terrainGetGridHeight(_terrain, dx, dz, 1); vertex->point.y = terrainGetGridHeight(_terrain, dx, dz, 1);

6
src/editing/widgetheightmap.h
View file

@ -72,9 +72,9 @@ private:
QDateTime _last_time; QDateTime _last_time;
bool _mouse_moved; bool _mouse_moved;
CameraDefinition _top_camera; CameraDefinition* _top_camera;
CameraDefinition _temp_camera; CameraDefinition* _temp_camera;
CameraDefinition _current_camera; CameraDefinition* _current_camera;
double _brush_x; double _brush_x;
double _brush_z; double _brush_z;

5
src/exploring/main.c
View file

@ -28,11 +28,14 @@ void exploringInit()
void exploringSetViewPort(int width, int height, CameraDefinition* camera) void exploringSetViewPort(int width, int height, CameraDefinition* camera)
{ {
CameraPerspective perspective;
glViewport(0, 0, width, height); glViewport(0, 0, width, height);
glMatrixMode(GL_PROJECTION); glMatrixMode(GL_PROJECTION);
glLoadIdentity(); glLoadIdentity();
gluPerspective(camera->yfov * 180.0 / M_PI, camera->xratio, camera->znear, camera->zfar); perspective = cameraGetPerspective(camera);
gluPerspective(perspective.yfov * 180.0 / M_PI, perspective.xratio, perspective.znear, perspective.zfar);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
} }

53
src/rendering/atmosphere/preview.c
View file

@ -14,20 +14,44 @@ typedef struct
#define MOUNTS_COUNT 11 #define MOUNTS_COUNT 11
static Mount MOUNTS[MOUNTS_COUNT] = { static Mount MOUNTS[MOUNTS_COUNT] = {
{{2.0, 0.0, -6.0}, 4.0}, {
{{-1.5, 0.0, -8.0}, 4.0}, {2.0, 0.0, -6.0}, 4.0
{{3.0, 0.0, -10.0}, 6.0}, },
{{-8.0, 0.0, -15.0}, 6.0}, {
{{10.0, 0.0, -20.0}, 6.0}, {-1.5, 0.0, -8.0}, 4.0
{{-6.0, 0.0, -30.0}, 8.0}, },
{{15.0, 0.0, -40.0}, 8.0}, {
{{-20.0, 0.0, -50.0}, 8.0}, {3.0, 0.0, -10.0}, 6.0
{{10.0, 0.0, -60.0}, 10.0}, },
{{-5.0, 0.0, -80.0}, 10.0}, {
{{30.0, 0.0, -100.0}, 10.0}, {-8.0, 0.0, -15.0}, 6.0
},
{
{10.0, 0.0, -20.0}, 6.0
},
{
{-6.0, 0.0, -30.0}, 8.0
},
{
{15.0, 0.0, -40.0}, 8.0
},
{
{-20.0, 0.0, -50.0}, 8.0
},
{
{10.0, 0.0, -60.0}, 10.0
},
{
{-5.0, 0.0, -80.0}, 10.0
},
{
{30.0, 0.0, -100.0}, 10.0
},
}; };
static SurfaceMaterial MOUNT_MATERIAL = {{0.4, 0.4, 0.4, 1.0}, 0.0, 0.0}; static SurfaceMaterial MOUNT_MATERIAL = {
{0.4, 0.4, 0.4, 1.0}, 0.0, 0.0
};
static inline int _rayIntersectsTriangle(Vector3 p, Vector3 d, Vector3 v0, Vector3 v1, Vector3 v2, Vector3* hit) static inline int _rayIntersectsTriangle(Vector3 p, Vector3 d, Vector3 v0, Vector3 v1, Vector3 v2, Vector3* hit)
{ {
@ -147,10 +171,9 @@ Color atmosphereGetPreview(Renderer* renderer, double x, double y, double headin
Renderer* atmosphereCreatePreviewRenderer() Renderer* atmosphereCreatePreviewRenderer()
{ {
Renderer* result = rendererCreate(); Renderer* result = rendererCreate();
Vector3 location = {0.0, 7.0, 0.0};
result->render_camera.location.x = 0.0; cameraSetLocation(result->render_camera, location);
result->render_camera.location.y = 7.0;
result->render_camera.location.z = 0.0;
return result; return result;
} }

153
src/rendering/camera.c
View file

@ -6,6 +6,30 @@
#include "scenery.h" #include "scenery.h"
#include "tools.h" #include "tools.h"
struct CameraDefinition
{
Vector3 location;
double yaw;
double pitch;
double roll;
Vector3 target;
Vector3 forward;
Vector3 right;
Vector3 up;
double width;
double height;
CameraPerspective perspective;
double yfov;
double xratio;
double znear;
double zfar;
Matrix4 project;
Matrix4 unproject;
};
void cameraSave(PackStream* stream, CameraDefinition* camera) void cameraSave(PackStream* stream, CameraDefinition* camera)
{ {
v3Save(stream, &camera->location); v3Save(stream, &camera->location);
@ -24,32 +48,34 @@ void cameraLoad(PackStream* stream, CameraDefinition* camera)
cameraValidateDefinition(camera, 0); cameraValidateDefinition(camera, 0);
} }
CameraDefinition cameraCreateDefinition() CameraDefinition* cameraCreateDefinition()
{ {
CameraDefinition definition; CameraDefinition* definition;
definition.location.x = 0.0; definition = malloc(sizeof (CameraDefinition));
definition.location.y = 0.0;
definition.location.z = 0.0;
definition.yaw = 0.0;
definition.pitch = 0.0;
definition.roll = 0.0;
definition.width = 1.0; definition->location.x = 0.0;
definition.height = 1.0; definition->location.y = 0.0;
definition.yfov = 1.57; definition->location.z = 0.0;
definition.xratio = 1.0; definition->yaw = 0.0;
definition.znear = 1.0; definition->pitch = 0.0;
definition.zfar = 1000.0; definition->roll = 0.0;
cameraValidateDefinition(&definition, 0); definition->width = 1.0;
definition->height = 1.0;
definition->yfov = 1.57;
definition->xratio = 1.0;
definition->znear = 1.0;
definition->zfar = 1000.0;
cameraValidateDefinition(definition, 0);
return definition; return definition;
} }
void cameraDeleteDefinition(CameraDefinition* definition) void cameraDeleteDefinition(CameraDefinition* definition)
{ {
UNUSED(definition); free(definition);
} }
void cameraCopyDefinition(CameraDefinition* source, CameraDefinition* destination) void cameraCopyDefinition(CameraDefinition* source, CameraDefinition* destination)
@ -117,22 +143,61 @@ void cameraValidateDefinition(CameraDefinition* definition, int check_above)
definition->unproject = m4Inverse(definition->project); definition->unproject = m4Inverse(definition->project);
} }
void cameraSetLocation(CameraDefinition* camera, double x, double y, double z) Vector3 cameraGetLocation(CameraDefinition* camera)
{ {
camera->location.x = x; return camera->location;
camera->location.y = y; }
camera->location.z = z;
Vector3 cameraGetTarget(CameraDefinition* camera)
{
return camera->target;
}
Vector3 cameraGetUpVector(CameraDefinition* camera)
{
return camera->up;
}
double cameraGetRoll(CameraDefinition* camera)
{
return camera->roll;
}
Vector3 cameraGetDirection(CameraDefinition* camera)
{
return camera->forward;
}
Vector3 cameraGetDirectionNormalized(CameraDefinition* camera)
{
return camera->forward;
}
VectorSpherical cameraGetDirectionSpherical(CameraDefinition* camera)
{
}
CameraPerspective cameraGetPerspective(CameraDefinition* camera)
{
return camera->perspective;
}
void cameraSetLocation(CameraDefinition* camera, Vector3 location)
{
camera->location = location;
cameraValidateDefinition(camera, 0); cameraValidateDefinition(camera, 0);
} }
void cameraSetTarget(CameraDefinition* camera, double x, double y, double z) void cameraSetLocationCoords(CameraDefinition* camera, double x, double y, double z)
{ {
Vector3 forward, target; Vector3 v = {x, y, z};
cameraSetLocation(camera, v);
}
target.x = x; void cameraSetTarget(CameraDefinition* camera, Vector3 target)
target.y = y; {
target.z = z; Vector3 forward;
forward = v3Sub(target, camera->location); forward = v3Sub(target, camera->location);
if (v3Norm(forward) < 0.0000001) if (v3Norm(forward) < 0.0000001)
@ -156,12 +221,20 @@ void cameraSetTarget(CameraDefinition* camera, double x, double y, double z)
else else
{ {
/* Guess angles */ /* Guess angles */
v3ToEuler(forward, &camera->yaw, &camera->pitch); VectorSpherical spherical = v3ToSpherical(forward);
camera->yaw = spherical.phi;
camera->pitch = spherical.theta;
} }
cameraValidateDefinition(camera, 0); cameraValidateDefinition(camera, 0);
} }
void cameraSetTargetCoords(CameraDefinition* camera, double x, double y, double z)
{
Vector3 v = {x, y, z};
cameraSetTarget(camera, v);
}
void cameraSetRoll(CameraDefinition* camera, double angle) void cameraSetRoll(CameraDefinition* camera, double angle)
{ {
camera->roll = angle; camera->roll = angle;
@ -220,7 +293,7 @@ void cameraSetRenderSize(CameraDefinition* camera, int width, int height)
cameraValidateDefinition(camera, 0); cameraValidateDefinition(camera, 0);
} }
Vector3 cameraProject(CameraDefinition* camera, Renderer* renderer, Vector3 point) Vector3 cameraProject(CameraDefinition* camera, Vector3 point)
{ {
point = m4Transform(camera->project, point); point = m4Transform(camera->project, point);
if (point.z < 1.0) if (point.z < 1.0)
@ -233,7 +306,7 @@ Vector3 cameraProject(CameraDefinition* camera, Renderer* renderer, Vector3 poin
return point; return point;
} }
Vector3 cameraUnproject(CameraDefinition* camera, Renderer* renderer, Vector3 point) Vector3 cameraUnproject(CameraDefinition* camera, Vector3 point)
{ {
point.x = (point.x / (0.5 * camera->width) - 1.0); point.x = (point.x / (0.5 * camera->width) - 1.0);
point.y = -(point.y / (0.5 * camera->height) - 1.0); point.y = -(point.y / (0.5 * camera->height) - 1.0);
@ -247,6 +320,7 @@ Vector3 cameraUnproject(CameraDefinition* camera, Renderer* renderer, Vector3 po
* @param col Color of the polygon. * @param col Color of the polygon.
* @param callback Post-processing callback. * @param callback Post-processing callback.
*/ */
/*void cameraPushOverlay(CameraDefinition* camera, Color col, f_RenderFragmentCallback callback) /*void cameraPushOverlay(CameraDefinition* camera, Color col, f_RenderFragmentCallback callback)
{ {
Vertex v1, v2, v3, v4; Vertex v1, v2, v3, v4;
@ -301,38 +375,45 @@ int cameraIsBoxInView(CameraDefinition* camera, Vector3 center, double xsize, do
center.x -= xsize / 2.0; center.x -= xsize / 2.0;
center.y -= ysize / 2.0; center.y -= ysize / 2.0;
center.z -= zsize / 2.0; center.z -= zsize / 2.0;
projected = cameraProject(camera, NULL, center); projected = cameraProject(camera, center);
xmin = xmax = projected.x; xmin = xmax = projected.x;
ymin = ymax = projected.y; ymin = ymax = projected.y;
zmax = projected.z; zmax = projected.z;
center.x += xsize; center.x += xsize;
projected = cameraProject(camera, NULL, center); projected = cameraProject(camera, center);
_updateBox(&projected, &xmin, &xmax, &ymin, &ymax, &zmax); _updateBox(&projected, &xmin, &xmax, &ymin, &ymax, &zmax);
center.z += zsize; center.z += zsize;
projected = cameraProject(camera, NULL, center); projected = cameraProject(camera, center);
_updateBox(&projected, &xmin, &xmax, &ymin, &ymax, &zmax); _updateBox(&projected, &xmin, &xmax, &ymin, &ymax, &zmax);
center.x -= xsize; center.x -= xsize;
projected = cameraProject(camera, NULL, center); projected = cameraProject(camera, center);
_updateBox(&projected, &xmin, &xmax, &ymin, &ymax, &zmax); _updateBox(&projected, &xmin, &xmax, &ymin, &ymax, &zmax);
center.y += ysize; center.y += ysize;
projected = cameraProject(camera, NULL, center); projected = cameraProject(camera, center);
_updateBox(&projected, &xmin, &xmax, &ymin, &ymax, &zmax); _updateBox(&projected, &xmin, &xmax, &ymin, &ymax, &zmax);
center.x += xsize; center.x += xsize;
projected = cameraProject(camera, NULL, center); projected = cameraProject(camera, center);
_updateBox(&projected, &xmin, &xmax, &ymin, &ymax, &zmax); _updateBox(&projected, &xmin, &xmax, &ymin, &ymax, &zmax);
center.z -= zsize; center.z -= zsize;
projected = cameraProject(camera, NULL, center); projected = cameraProject(camera, center);
_updateBox(&projected, &xmin, &xmax, &ymin, &ymax, &zmax); _updateBox(&projected, &xmin, &xmax, &ymin, &ymax, &zmax);
center.x -= xsize; center.x -= xsize;
projected = cameraProject(camera, NULL, center); projected = cameraProject(camera, center);
_updateBox(&projected, &xmin, &xmax, &ymin, &ymax, &zmax); _updateBox(&projected, &xmin, &xmax, &ymin, &ymax, &zmax);
return xmin <= camera->width && xmax >= 0.0 && ymin <= camera->height && ymax >= 0.0 && zmax >= camera->znear; return xmin <= camera->width && xmax >= 0.0 && ymin <= camera->height && ymax >= 0.0 && zmax >= camera->znear;
} }
int cameraTransitionToAnother(CameraDefinition* current, CameraDefinition* wanted, double factor)
{
current->location.z += factor;
cameraValidateDefinition(current, 0);
return 1;
}

37
src/rendering/camera.h
View file

@ -3,22 +3,43 @@
#include "tools/pack.h" #include "tools/pack.h"
#include "tools/euclid.h" #include "tools/euclid.h"
#include "renderer.h"
#ifdef __cplusplus #ifdef __cplusplus
extern "C" { extern "C"
{
#endif #endif
typedef struct CameraDefinition CameraDefinition;
typedef struct
{
double yfov;
double xratio;
double znear;
double zfar;
} CameraPerspective;
void cameraSave(PackStream* stream, CameraDefinition* camera); void cameraSave(PackStream* stream, CameraDefinition* camera);
void cameraLoad(PackStream* stream, CameraDefinition* camera); void cameraLoad(PackStream* stream, CameraDefinition* camera);
CameraDefinition cameraCreateDefinition(); CameraDefinition* cameraCreateDefinition();
void cameraDeleteDefinition(CameraDefinition* definition); void cameraDeleteDefinition(CameraDefinition* definition);
void cameraCopyDefinition(CameraDefinition* source, CameraDefinition* destination); void cameraCopyDefinition(CameraDefinition* source, CameraDefinition* destination);
void cameraValidateDefinition(CameraDefinition* definition, int check_above); void cameraValidateDefinition(CameraDefinition* definition, int check_above);
void cameraSetLocation(CameraDefinition* camera, double x, double y, double z); Vector3 cameraGetLocation(CameraDefinition* camera);
void cameraSetTarget(CameraDefinition* camera, double x, double y, double z); Vector3 cameraGetTarget(CameraDefinition* camera);
Vector3 cameraGetUpVector(CameraDefinition* camera);
double cameraGetRoll(CameraDefinition* camera);
Vector3 cameraGetDirection(CameraDefinition* camera);
Vector3 cameraGetDirectionNormalized(CameraDefinition* camera);
VectorSpherical cameraGetDirectionSpherical(CameraDefinition* camera);
CameraPerspective cameraGetPerspective(CameraDefinition* camera);
void cameraSetLocation(CameraDefinition* camera, Vector3 location);
void cameraSetLocationCoords(CameraDefinition* camera, double x, double y, double z);
void cameraSetTarget(CameraDefinition* camera, Vector3 target);
void cameraSetTargetCoords(CameraDefinition* camera, double x, double y, double z);
void cameraSetRoll(CameraDefinition* camera, double angle); void cameraSetRoll(CameraDefinition* camera, double angle);
void cameraStrafeForward(CameraDefinition* camera, double value); void cameraStrafeForward(CameraDefinition* camera, double value);
@ -30,11 +51,13 @@ void cameraRotateRoll(CameraDefinition* camera, double value);
void cameraSetRenderSize(CameraDefinition* camera, int width, int height); void cameraSetRenderSize(CameraDefinition* camera, int width, int height);
Vector3 cameraProject(CameraDefinition* camera, Renderer* renderer, Vector3 point); Vector3 cameraProject(CameraDefinition* camera, Vector3 point);
Vector3 cameraUnproject(CameraDefinition* camera, Renderer* renderer, Vector3 point); Vector3 cameraUnproject(CameraDefinition* camera, Vector3 point);
/*void cameraPushOverlay(CameraDefinition* camera, Color col, f_RenderFragmentCallback callback);*/ /*void cameraPushOverlay(CameraDefinition* camera, Color col, f_RenderFragmentCallback callback);*/
int cameraIsBoxInView(CameraDefinition* camera, Vector3 center, double xsize, double ysize, double zsize); int cameraIsBoxInView(CameraDefinition* camera, Vector3 center, double xsize, double ysize, double zsize);
int cameraTransitionToAnother(CameraDefinition* current, CameraDefinition* wanted, double factor);
#ifdef __cplusplus #ifdef __cplusplus
} }
#endif #endif

23
src/rendering/main.c
View file

@ -3,7 +3,6 @@
#include "auto.h" #include "auto.h"
#include "system.h" #include "system.h"
#include "camera.h"
#include "scenery.h" #include "scenery.h"
#include "render.h" #include "render.h"
#include "main.h" #include "main.h"
@ -13,35 +12,13 @@
void paysagesInit() void paysagesInit()
{ {
CameraDefinition camera;
systemInit(); systemInit();
openclInit(); openclInit();
sceneryInit(); sceneryInit();
renderInit(); renderInit();
camera = cameraCreateDefinition();
cameraSetLocation(&camera, -12.0, 5.0, 2.0);
cameraSetTarget(&camera, 0.0, 5.0, 0.0);
cameraRotateYaw(&camera, 1.0);
scenerySetCamera(&camera);
cameraDeleteDefinition(&camera);
autoGenRealisticLandscape(0); autoGenRealisticLandscape(0);
// DEBUG
/*double last_height, height, x;
last_height = height = 0.0;
x = 0.0;
while (height <= 1.0 || height >= last_height || last_height < 0.1)
{
last_height = height;
height = terrainGetHeight(x, 0.0);
x += 0.1;
}
cameraSetLocation(x - 2.0, height, 0.0);
cameraSetTarget(x - 1.0, height, 0.0);*/
} }
void paysagesQuit() void paysagesQuit()

24
src/rendering/renderer.c
View file

@ -27,18 +27,20 @@ static Vector3 _getCameraLocation(Renderer* renderer, Vector3 target)
{ {
UNUSED(renderer); UNUSED(renderer);
UNUSED(target); UNUSED(target);
return renderer->render_camera.location; return cameraGetLocation(renderer->render_camera);
} }
static Vector3 _getCameraDirection(Renderer* renderer, Vector3 target) static Vector3 _getCameraDirection(Renderer* renderer, Vector3 target)
{ {
UNUSED(renderer); UNUSED(renderer);
UNUSED(target); UNUSED(target);
return renderer->render_camera.forward;
return cameraGetDirectionNormalized(renderer->render_camera);
} }
static double _getPrecision(Renderer* renderer, Vector3 location) static double _getPrecision(Renderer* renderer, Vector3 location)
{ {
UNUSED(renderer); UNUSED(renderer);
UNUSED(location); UNUSED(location);
return 0.0; return 0.0;
@ -46,18 +48,21 @@ static double _getPrecision(Renderer* renderer, Vector3 location)
static Vector3 _projectPoint(Renderer* renderer, Vector3 point) static Vector3 _projectPoint(Renderer* renderer, Vector3 point)
{ {
UNUSED(renderer); UNUSED(renderer);
return point; return point;
} }
static Vector3 _unprojectPoint(Renderer* renderer, Vector3 point) static Vector3 _unprojectPoint(Renderer* renderer, Vector3 point)
{ {
UNUSED(renderer); UNUSED(renderer);
return point; return point;
} }
static void _pushTriangle(Renderer* renderer, Vector3 v1, Vector3 v2, Vector3 v3, f_RenderFragmentCallback callback, void* callback_data) static void _pushTriangle(Renderer* renderer, Vector3 v1, Vector3 v2, Vector3 v3, f_RenderFragmentCallback callback, void* callback_data)
{ {
Vector3 p1, p2, p3; Vector3 p1, p2, p3;
p1 = renderer->projectPoint(renderer, v1); p1 = renderer->projectPoint(renderer, v1);
@ -69,12 +74,14 @@ static void _pushTriangle(Renderer* renderer, Vector3 v1, Vector3 v2, Vector3 v3
static void _pushQuad(Renderer* renderer, Vector3 v1, Vector3 v2, Vector3 v3, Vector3 v4, f_RenderFragmentCallback callback, void* callback_data) static void _pushQuad(Renderer* renderer, Vector3 v1, Vector3 v2, Vector3 v3, Vector3 v4, f_RenderFragmentCallback callback, void* callback_data)
{ {
renderer->pushTriangle(renderer, v2, v3, v1, callback, callback_data); renderer->pushTriangle(renderer, v2, v3, v1, callback, callback_data);
renderer->pushTriangle(renderer, v4, v1, v3, callback, callback_data); renderer->pushTriangle(renderer, v4, v1, v3, callback, callback_data);
} }
static void _pushDisplacedTriangle(Renderer* renderer, Vector3 v1, Vector3 v2, Vector3 v3, Vector3 ov1, Vector3 ov2, Vector3 ov3, f_RenderFragmentCallback callback, void* callback_data) static void _pushDisplacedTriangle(Renderer* renderer, Vector3 v1, Vector3 v2, Vector3 v3, Vector3 ov1, Vector3 ov2, Vector3 ov3, f_RenderFragmentCallback callback, void* callback_data)
{ {
Vector3 p1, p2, p3; Vector3 p1, p2, p3;
p1 = renderer->projectPoint(renderer, v1); p1 = renderer->projectPoint(renderer, v1);
@ -86,17 +93,20 @@ static void _pushDisplacedTriangle(Renderer* renderer, Vector3 v1, Vector3 v2, V
static void _pushDisplacedQuad(Renderer* renderer, Vector3 v1, Vector3 v2, Vector3 v3, Vector3 v4, Vector3 ov1, Vector3 ov2, Vector3 ov3, Vector3 ov4, f_RenderFragmentCallback callback, void* callback_data) static void _pushDisplacedQuad(Renderer* renderer, Vector3 v1, Vector3 v2, Vector3 v3, Vector3 v4, Vector3 ov1, Vector3 ov2, Vector3 ov3, Vector3 ov4, f_RenderFragmentCallback callback, void* callback_data)
{ {
renderer->pushDisplacedTriangle(renderer, v2, v3, v1, ov2, ov3, ov1, callback, callback_data); renderer->pushDisplacedTriangle(renderer, v2, v3, v1, ov2, ov3, ov1, callback, callback_data);
renderer->pushDisplacedTriangle(renderer, v4, v1, v3, ov4, ov1, ov3, callback, callback_data); renderer->pushDisplacedTriangle(renderer, v4, v1, v3, ov4, ov1, ov3, callback, callback_data);
} }
static RayCastingResult _rayWalking(Renderer* renderer, Vector3 location, Vector3 direction, int terrain, int water, int sky, int clouds) static RayCastingResult _rayWalking(Renderer* renderer, Vector3 location, Vector3 direction, int terrain, int water, int sky, int clouds)
{ {
return _RAYCASTING_NULL; return _RAYCASTING_NULL;
} }
static Color _applyLightingToSurface(Renderer* renderer, Vector3 location, Vector3 normal, SurfaceMaterial* material) static Color _applyLightingToSurface(Renderer* renderer, Vector3 location, Vector3 normal, SurfaceMaterial* material)
{ {
LightStatus* light = lightingCreateStatus(renderer->lighting, location, renderer->getCameraLocation(renderer, location)); LightStatus* light = lightingCreateStatus(renderer->lighting, location, renderer->getCameraLocation(renderer, location));
renderer->atmosphere->getLightingStatus(renderer, light, normal, 0); renderer->atmosphere->getLightingStatus(renderer, light, normal, 0);
Color result = lightingApplyStatus(light, normal, material); Color result = lightingApplyStatus(light, normal, material);
@ -106,6 +116,7 @@ static Color _applyLightingToSurface(Renderer* renderer, Vector3 location, Vecto
static Color _applyMediumTraversal(Renderer* renderer, Vector3 location, Color color) static Color _applyMediumTraversal(Renderer* renderer, Vector3 location, Color color)
{ {
color = renderer->atmosphere->applyAerialPerspective(renderer, location, color).final; color = renderer->atmosphere->applyAerialPerspective(renderer, location, color).final;
color = renderer->clouds->getColor(renderer, color, renderer->getCameraLocation(renderer, location), location); color = renderer->clouds->getColor(renderer, color, renderer->getCameraLocation(renderer, location), location);
return color; return color;
@ -113,7 +124,8 @@ static Color _applyMediumTraversal(Renderer* renderer, Vector3 location, Color c
Renderer* rendererCreate() Renderer* rendererCreate()
{ {
Renderer* result = malloc(sizeof(Renderer));
Renderer* result = malloc(sizeof (Renderer));
RenderParams params = {1, 1, 1, 5}; RenderParams params = {1, 1, 1, 5};
result->render_quality = 5; result->render_quality = 5;
@ -156,6 +168,8 @@ Renderer* rendererCreate()
void rendererDelete(Renderer* renderer) void rendererDelete(Renderer* renderer)
{ {
cameraDeleteDefinition(renderer->render_camera);
lightingManagerDelete(renderer->lighting); lightingManagerDelete(renderer->lighting);
AtmosphereRendererClass.destroy(renderer->atmosphere); AtmosphereRendererClass.destroy(renderer->atmosphere);
@ -171,6 +185,7 @@ void rendererDelete(Renderer* renderer)
void rendererSetPreviewCallbacks(Renderer* renderer, RenderCallbackStart start, RenderCallbackDraw draw, RenderCallbackUpdate update) void rendererSetPreviewCallbacks(Renderer* renderer, RenderCallbackStart start, RenderCallbackDraw draw, RenderCallbackUpdate update)
{ {
renderSetPreviewCallbacks(renderer->render_area, start, draw, update); renderSetPreviewCallbacks(renderer->render_area, start, draw, update);
} }
@ -189,7 +204,7 @@ void rendererStart(Renderer* renderer, RenderParams params)
renderer->render_interrupt = 0; renderer->render_interrupt = 0;
renderer->render_progress = 0.0; renderer->render_progress = 0.0;
cameraSetRenderSize(&renderer->render_camera, renderer->render_width, renderer->render_height); cameraSetRenderSize(renderer->render_camera, renderer->render_width, renderer->render_height);
renderSetBackgroundColor(renderer->render_area, &COLOR_BLACK); renderSetBackgroundColor(renderer->render_area, &COLOR_BLACK);
renderSetParams(renderer->render_area, params); renderSetParams(renderer->render_area, params);
@ -205,6 +220,7 @@ void rendererStart(Renderer* renderer, RenderParams params)
if (++loops >= 10) if (++loops >= 10)
{ {
renderUpdate(renderer->render_area); renderUpdate(renderer->render_area);
loops = 0; loops = 0;
} }

20
src/rendering/renderer.h
View file

@ -7,10 +7,12 @@
#include "terrain/public.h" #include "terrain/public.h"
#include "textures/public.h" #include "textures/public.h"
#include "water/public.h" #include "water/public.h"
#include "camera.h"
#include "render.h" #include "render.h"
#ifdef __cplusplus #ifdef __cplusplus
extern "C" { extern "C"
{
#endif #endif
struct Renderer struct Renderer
@ -19,18 +21,18 @@ struct Renderer
int render_quality; int render_quality;
int render_width; int render_width;
int render_height; int render_height;
CameraDefinition render_camera; CameraDefinition* render_camera;
/* Render related */ /* Render related */
RenderArea* render_area; RenderArea* render_area;
double render_progress; double render_progress;
int render_interrupt; int render_interrupt;
int is_rendering; int is_rendering;
Vector3 (*getCameraLocation)(Renderer* renderer, Vector3 target); Vector3(*getCameraLocation)(Renderer* renderer, Vector3 target);
Vector3 (*getCameraDirection)(Renderer* renderer, Vector3 target); Vector3(*getCameraDirection)(Renderer* renderer, Vector3 target);
double (*getPrecision)(Renderer* renderer, Vector3 location); double (*getPrecision)(Renderer* renderer, Vector3 location);
Vector3 (*projectPoint)(Renderer* renderer, Vector3 point); Vector3(*projectPoint)(Renderer* renderer, Vector3 point);
Vector3 (*unprojectPoint)(Renderer* renderer, Vector3 point); Vector3(*unprojectPoint)(Renderer* renderer, Vector3 point);
int (*addRenderProgress)(Renderer* renderer, double progress); int (*addRenderProgress)(Renderer* renderer, double progress);
void (*pushTriangle)(Renderer* renderer, Vector3 v1, Vector3 v2, Vector3 v3, f_RenderFragmentCallback callback, void* callback_data); void (*pushTriangle)(Renderer* renderer, Vector3 v1, Vector3 v2, Vector3 v3, f_RenderFragmentCallback callback, void* callback_data);
void (*pushQuad)(Renderer* renderer, Vector3 v1, Vector3 v2, Vector3 v3, Vector3 v4, f_RenderFragmentCallback callback, void* callback_data); void (*pushQuad)(Renderer* renderer, Vector3 v1, Vector3 v2, Vector3 v3, Vector3 v4, f_RenderFragmentCallback callback, void* callback_data);
@ -38,11 +40,11 @@ struct Renderer
void (*pushDisplacedQuad)(Renderer* renderer, Vector3 v1, Vector3 v2, Vector3 v3, Vector3 v4, Vector3 ov1, Vector3 ov2, Vector3 ov3, Vector3 ov4, f_RenderFragmentCallback callback, void* callback_data); void (*pushDisplacedQuad)(Renderer* renderer, Vector3 v1, Vector3 v2, Vector3 v3, Vector3 v4, Vector3 ov1, Vector3 ov2, Vector3 ov3, Vector3 ov4, f_RenderFragmentCallback callback, void* callback_data);
/* Shortcuts */ /* Shortcuts */
Color (*applyLightingToSurface)(Renderer* renderer, Vector3 location, Vector3 normal, SurfaceMaterial* material); Color(*applyLightingToSurface)(Renderer* renderer, Vector3 location, Vector3 normal, SurfaceMaterial* material);
Color (*applyMediumTraversal)(Renderer* renderer, Vector3 location, Color color); Color(*applyMediumTraversal)(Renderer* renderer, Vector3 location, Color color);
/* Scenery related */ /* Scenery related */
RayCastingResult (*rayWalking)(Renderer* renderer, Vector3 location, Vector3 direction, int terrain, int water, int sky, int clouds); RayCastingResult(*rayWalking)(Renderer* renderer, Vector3 location, Vector3 direction, int terrain, int water, int sky, int clouds);
/* Autonomous tools */ /* Autonomous tools */
LightingManager* lighting; LightingManager* lighting;

35
src/rendering/scenery.c
View file

@ -6,7 +6,7 @@
#include "system.h" #include "system.h"
static AtmosphereDefinition* _atmosphere; static AtmosphereDefinition* _atmosphere;
static CameraDefinition _camera; static CameraDefinition* _camera;
static CloudsDefinition* _clouds; static CloudsDefinition* _clouds;
static TerrainDefinition* _terrain; static TerrainDefinition* _terrain;
static TexturesDefinition* _textures; static TexturesDefinition* _textures;
@ -34,7 +34,7 @@ void sceneryInit()
void sceneryQuit() void sceneryQuit()
{ {
AtmosphereDefinitionClass.destroy(_atmosphere); AtmosphereDefinitionClass.destroy(_atmosphere);
cameraDeleteDefinition(&_camera); cameraDeleteDefinition(_camera);
CloudsDefinitionClass.destroy(_clouds); CloudsDefinitionClass.destroy(_clouds);
TerrainDefinitionClass.destroy(_terrain); TerrainDefinitionClass.destroy(_terrain);
TexturesDefinitionClass.destroy(_textures); TexturesDefinitionClass.destroy(_textures);
@ -63,7 +63,7 @@ void scenerySave(PackStream* stream)
{ {
noiseSave(stream); noiseSave(stream);
AtmosphereDefinitionClass.save(stream, _atmosphere); AtmosphereDefinitionClass.save(stream, _atmosphere);
cameraSave(stream, &_camera); cameraSave(stream, _camera);
CloudsDefinitionClass.save(stream, _clouds); CloudsDefinitionClass.save(stream, _clouds);
TerrainDefinitionClass.save(stream, _terrain); TerrainDefinitionClass.save(stream, _terrain);
TexturesDefinitionClass.save(stream, _textures); TexturesDefinitionClass.save(stream, _textures);
@ -81,7 +81,7 @@ void sceneryLoad(PackStream* stream)
noiseLoad(stream); noiseLoad(stream);
AtmosphereDefinitionClass.load(stream, _atmosphere); AtmosphereDefinitionClass.load(stream, _atmosphere);
cameraLoad(stream, &_camera); cameraLoad(stream, _camera);
CloudsDefinitionClass.load(stream, _clouds); CloudsDefinitionClass.load(stream, _clouds);
TerrainDefinitionClass.load(stream, _terrain); TerrainDefinitionClass.load(stream, _terrain);
TexturesDefinitionClass.load(stream, _textures); TexturesDefinitionClass.load(stream, _textures);
@ -105,13 +105,13 @@ void sceneryGetAtmosphere(AtmosphereDefinition* atmosphere)
void scenerySetCamera(CameraDefinition* camera) void scenerySetCamera(CameraDefinition* camera)
{ {
cameraCopyDefinition(camera, &_camera); cameraCopyDefinition(camera, _camera);
cameraValidateDefinition(&_camera, 1); cameraValidateDefinition(_camera, 1);
} }
void sceneryGetCamera(CameraDefinition* camera) void sceneryGetCamera(CameraDefinition* camera)
{ {
cameraCopyDefinition(&_camera, camera); cameraCopyDefinition(_camera, camera);
} }
void scenerySetClouds(CloudsDefinition* clouds) void scenerySetClouds(CloudsDefinition* clouds)
@ -128,7 +128,7 @@ void scenerySetTerrain(TerrainDefinition* terrain)
{ {
TerrainDefinitionClass.copy(terrain, _terrain); TerrainDefinitionClass.copy(terrain, _terrain);
cameraValidateDefinition(&_camera, 1); cameraValidateDefinition(_camera, 1);
} }
void sceneryGetTerrain(TerrainDefinition* terrain) void sceneryGetTerrain(TerrainDefinition* terrain)
@ -140,7 +140,7 @@ void scenerySetTextures(TexturesDefinition* textures)
{ {
TexturesDefinitionClass.copy(textures, _textures); TexturesDefinitionClass.copy(textures, _textures);
cameraValidateDefinition(&_camera, 1); cameraValidateDefinition(_camera, 1);
} }
void sceneryGetTextures(TexturesDefinition* textures) void sceneryGetTextures(TexturesDefinition* textures)
@ -152,7 +152,7 @@ void scenerySetWater(WaterDefinition* water)
{ {
WaterDefinitionClass.copy(water, _water); WaterDefinitionClass.copy(water, _water);
cameraValidateDefinition(&_camera, 1); cameraValidateDefinition(_camera, 1);
} }
void sceneryGetWater(WaterDefinition* water) void sceneryGetWater(WaterDefinition* water)
@ -167,11 +167,6 @@ void sceneryRenderFirstPass(Renderer* renderer)
atmosphereRenderSkydome(renderer); atmosphereRenderSkydome(renderer);
} }
/******* Standard renderer *********/ /******* Standard renderer *********/
static RayCastingResult _rayWalking(Renderer* renderer, Vector3 location, Vector3 direction, int terrain, int water, int sky, int clouds) static RayCastingResult _rayWalking(Renderer* renderer, Vector3 location, Vector3 direction, int terrain, int water, int sky, int clouds)
{ {
@ -193,23 +188,23 @@ static RayCastingResult _rayWalking(Renderer* renderer, Vector3 location, Vector
static Vector3 _projectPoint(Renderer* renderer, Vector3 point) static Vector3 _projectPoint(Renderer* renderer, Vector3 point)
{ {
return cameraProject(&renderer->render_camera, renderer, point); return cameraProject(renderer->render_camera, point);
} }
static Vector3 _unprojectPoint(Renderer* renderer, Vector3 point) static Vector3 _unprojectPoint(Renderer* renderer, Vector3 point)
{ {
return cameraUnproject(&renderer->render_camera, renderer, point); return cameraUnproject(renderer->render_camera, point);
} }
static double _getPrecision(Renderer* renderer, Vector3 location) static double _getPrecision(Renderer* renderer, Vector3 location)
{ {
Vector3 projected; Vector3 projected;
projected = cameraProject(&renderer->render_camera, renderer, location); projected = cameraProject(renderer->render_camera, location);
projected.x += 1.0; projected.x += 1.0;
//projected.y += 1.0; //projected.y += 1.0;
return v3Norm(v3Sub(cameraUnproject(&renderer->render_camera, renderer, projected), location)); // / (double)render_quality; return v3Norm(v3Sub(cameraUnproject(renderer->render_camera, projected), location)); // / (double)render_quality;
} }
Renderer* sceneryCreateStandardRenderer() Renderer* sceneryCreateStandardRenderer()
@ -218,7 +213,7 @@ Renderer* sceneryCreateStandardRenderer()
result = rendererCreate(); result = rendererCreate();
cameraCopyDefinition(&_camera, &result->render_camera); cameraCopyDefinition(_camera, result->render_camera);
result->rayWalking = _rayWalking; result->rayWalking = _rayWalking;
result->projectPoint = _projectPoint; result->projectPoint = _projectPoint;

6
src/rendering/shared/preview.c
View file

@ -13,7 +13,7 @@ static PreviewRenderer* _createRenderer()
{ {
PreviewRenderer* renderer; PreviewRenderer* renderer;
renderer = (PreviewRenderer*)malloc(sizeof(PreviewRenderer)); renderer = (PreviewRenderer*)malloc(sizeof (PreviewRenderer));
renderer->renderer = rendererCreate(); renderer->renderer = rendererCreate();
return renderer; return renderer;
@ -27,8 +27,8 @@ static void _deleteRenderer(PreviewRenderer* renderer)
static void _setCamera(PreviewRenderer* renderer, Vector3 location, Vector3 target) static void _setCamera(PreviewRenderer* renderer, Vector3 location, Vector3 target)
{ {
cameraSetLocation(&renderer->renderer->render_camera, location.x, location.y, location.z); cameraSetLocation(renderer->renderer->render_camera, location);
cameraSetTarget(&renderer->renderer->render_camera, target.x, target.y, target.z); cameraSetTarget(renderer->renderer->render_camera, target);
} }
PreviewClass previewCreateClass(FuncPreviewCustomizeRenderer customizeRenderer, FuncPreviewBindDefinition bindDefinition, FuncPreviewGetPixelColor getPixelColor) PreviewClass previewCreateClass(FuncPreviewCustomizeRenderer customizeRenderer, FuncPreviewBindDefinition bindDefinition, FuncPreviewGetPixelColor getPixelColor)

23
src/rendering/shared/types.h
View file

@ -25,29 +25,6 @@ typedef struct
double base_height; double base_height;
} HeightInfo; } HeightInfo;
typedef struct
{
Vector3 location;
double yaw;
double pitch;
double roll;
Vector3 target;
Vector3 forward;
Vector3 right;
Vector3 up;
double width;
double height;
double yfov;
double xratio;
double znear;
double zfar;
Matrix4 project;
Matrix4 unproject;
} CameraDefinition;
typedef void* (*FuncObjectCreate)(); typedef void* (*FuncObjectCreate)();
typedef void (*FuncObjectDelete)(void* object); typedef void (*FuncObjectDelete)(void* object);
typedef void (*FuncObjectCopy)(void* source, void* destination); typedef void (*FuncObjectCopy)(void* source, void* destination);

31
src/rendering/tools/euclid.c
View file

@ -102,10 +102,13 @@ Vector3 v3Cross(Vector3 v1, Vector3 v2)
return result; return result;
} }
void v3ToEuler(Vector3 v, double* heading, double* attitude) VectorSpherical v3ToSpherical(Vector3 v)
{ {
*heading = euclidGet2DAngle(v.x, v.z); VectorSpherical result;
*attitude = euclidGet2DAngle(sqrt(v.x * v.x + v.z * v.z), v.y); result.phi = euclidGet2DAngle(v.x, v.z);
result.theta = euclidGet2DAngle(sqrt(v.x * v.x + v.z * v.z), v.y);
result.r = v3Norm(v);
return result;
} }
void m4Save(PackStream* stream, Matrix4* m) void m4Save(PackStream* stream, Matrix4* m)
@ -361,17 +364,17 @@ Matrix4 m4NewPerspective(double fov_y, double aspect, double near, double far)
double m4Determinant(Matrix4 m) double m4Determinant(Matrix4 m)
{ {
return ((m.a * m.f - m.e * m.b) return ((m.a * m.f - m.e * m.b)
* (m.k * m.p - m.o * m.l) * (m.k * m.p - m.o * m.l)
- (m.a * m.j - m.i * m.b) - (m.a * m.j - m.i * m.b)
* (m.g * m.p - m.o * m.h) * (m.g * m.p - m.o * m.h)
+ (m.a * m.n - m.m * m.b) + (m.a * m.n - m.m * m.b)
* (m.g * m.l - m.k * m.h) * (m.g * m.l - m.k * m.h)
+ (m.e * m.j - m.i * m.f) + (m.e * m.j - m.i * m.f)
* (m.c * m.p - m.o * m.d) * (m.c * m.p - m.o * m.d)
- (m.e * m.n - m.m * m.f) - (m.e * m.n - m.m * m.f)
* (m.c * m.l - m.k * m.d) * (m.c * m.l - m.k * m.d)
+ (m.i * m.n - m.m * m.j) + (m.i * m.n - m.m * m.j)
* (m.c * m.h - m.g * m.d)); * (m.c * m.h - m.g * m.d));
} }
Matrix4 m4Inverse(Matrix4 m) Matrix4 m4Inverse(Matrix4 m)

39
src/rendering/tools/euclid.h
View file

@ -3,8 +3,36 @@
#include "pack.h" #include "pack.h"
/*
* Cartesian coordinates (X, Y, Z) - right handed :
*
* Y (up)
* |
* |
* +----X
* /
* /
* Z
*
* Spherical coordinates (R, PHI, THETA) :
*
* R is the distance to origin
* PHI is typical azimuth
* THETA is elevation angle (not polar angle!)
*
* X=1 Y=0 Z=0 => PHI=0
* X=0 Y=0 Z=-1 => PHI=PI/2
* X=-1 Y=0 Z=0 => PHI=PI
* X=0 Y=0 Z=1 => PHI=3*PI/2
*
* X=1 Y=0 Z=0 => THETA=0
* X=0 Y=1 Z=0 => THETA=PI/2
* X=0 Y=-1 Z=0 => THETA=-PI/2
*/
#ifdef __cplusplus #ifdef __cplusplus
extern "C" { extern "C"
{
#endif #endif
typedef struct typedef struct
@ -14,6 +42,13 @@ typedef struct
double z; double z;
} Vector3; } Vector3;
typedef struct
{
double r;
double theta;
double phi;
} VectorSpherical;
typedef struct typedef struct
{ {
double a; double a;
@ -53,7 +88,7 @@ double v3Norm(Vector3 v);
Vector3 v3Normalize(Vector3 v); Vector3 v3Normalize(Vector3 v);
double v3Dot(Vector3 v1, Vector3 v2); double v3Dot(Vector3 v1, Vector3 v2);
Vector3 v3Cross(Vector3 v1, Vector3 v2); Vector3 v3Cross(Vector3 v1, Vector3 v2);
void v3ToEuler(Vector3 v, double* heading, double* attitude); VectorSpherical v3ToSpherical(Vector3 v);
void m4Save(PackStream* stream, Matrix4* m); void m4Save(PackStream* stream, Matrix4* m);
void m4Load(PackStream* stream, Matrix4* m); void m4Load(PackStream* stream, Matrix4* m);

23
src/testing/camera.c Normal file
View file

@ -0,0 +1,23 @@
#include "testing/common.h"
#include "rendering/camera.h"
#define _checkVector(_vector_, _x_, _y_, _z_) ck_assert_double_eq(_vector_.x, _x_);ck_assert_double_eq(_vector_.y, _y_);ck_assert_double_eq(_vector_.z, _z_)
START_TEST(test_camera_definition)
{
CameraDefinition* cam;
cam = cameraCreateDefinition();
cameraSetLocationCoords(cam, 0.0, 1.0, 1.0);
cameraSetTargetCoords(cam, 0.0, 0.0, 0.0);
_checkVector(cameraGetLocation(cam), 0.0, 1.0, 1.0);
_checkVector(cameraGetTarget(cam), 0.0, 1.0, 1.0);
cameraDeleteDefinition(cam);
}
END_TEST
TEST_CASE(camera, test_camera_definition)

34
src/testing/euclid.c
View file

@ -5,6 +5,7 @@ static inline int _Vector3_cmp(Vector3 v1, Vector3 v2)
{ {
return fabs(v1.x - v2.z) >= 0.00000000001 && fabs(v1.y - v2.y) >= 0.00000000001 && fabs(v1.z - v2.z) >= 0.00000000001; return fabs(v1.x - v2.z) >= 0.00000000001 && fabs(v1.y - v2.y) >= 0.00000000001 && fabs(v1.z - v2.z) >= 0.00000000001;
} }
static inline void _Vector3_str(Vector3 v, char* buffer, int length) static inline void _Vector3_str(Vector3 v, char* buffer, int length)
{ {
snprintf(buffer, length, "(%f,%f,%f)", v.x, v.y, v.z); snprintf(buffer, length, "(%f,%f,%f)", v.x, v.y, v.z);
@ -36,27 +37,42 @@ START_TEST(test_euclid_angles)
ck_assert_double_eq(euclidGet2DAngle(-0.5, 0.5), 3.0 * M_PI_4); ck_assert_double_eq(euclidGet2DAngle(-0.5, 0.5), 3.0 * M_PI_4);
ck_assert_double_eq(euclidGet2DAngle(-0.5, -0.5), 5.0 * M_PI_4); ck_assert_double_eq(euclidGet2DAngle(-0.5, -0.5), 5.0 * M_PI_4);
} }
END_TEST END_TEST
START_TEST(test_vectors) START_TEST(test_vectors)
{ {
Vector3 v1, v2, v3; Vector3 v1, v2, v3;
double d1, d2;
/* Test scaling */ /* Test scaling */
v1.x = 0.0; v1.y = -4.3; v1.z = 8.2; v1.x = 0.0;
v2.x = 0.0; v2.y = -8.6; v2.z = 16.4; v1.y = -4.3;
v3.x = 0.0; v3.y = 2.15; v3.z = -4.1; v1.z = 8.2;
v2.x = 0.0;
v2.y = -8.6;
v2.z = 16.4;
v3.x = 0.0;
v3.y = 2.15;
v3.z = -4.1;
ck_assert_generic_eq(Vector3, v3Scale(v1, 2.0), v2); ck_assert_generic_eq(Vector3, v3Scale(v1, 2.0), v2);
ck_assert_generic_eq(Vector3, v3Scale(v1, -0.5), v3); ck_assert_generic_eq(Vector3, v3Scale(v1, -0.5), v3);
}
/* Test euler angles */ END_TEST
START_TEST(test_vectors_spherical)
{
Vector3 v1;
VectorSpherical v2;
/* Test conversion to spherical */
v1.x = v1.y = v1.z = 0.5; v1.x = v1.y = v1.z = 0.5;
v3ToEuler(v1, &d1, &d2); v2 = v3ToSpherical(v1);
ck_assert_double_eq(d1, M_PI_4); ck_assert_double_eq(v2.r, sqrt(0.5 * 0.5 + 0.5 * 0.5 + 0.5 * 0.5));
ck_assert_double_eq(d2, M_PI_2 - 0.955316618125); ck_assert_double_eq(v2.phi, M_PI_4);
ck_assert_double_eq(v2.theta, M_PI_2 - 0.955316618125);
} }
END_TEST END_TEST
TEST_CASE(euclid, test_euclid_angles, test_vectors) TEST_CASE(euclid, test_euclid_angles, test_vectors_spherical)

2
src/testing/main.c
View file

@ -2,6 +2,7 @@
#include <stdlib.h> #include <stdlib.h>
extern void test_euclid_case(Suite* s); extern void test_euclid_case(Suite* s);
extern void test_camera_case(Suite* s);
int main(int argc, char** argv) int main(int argc, char** argv)
{ {
@ -10,6 +11,7 @@ int main(int argc, char** argv)
/* TODO Find a way to automate this */ /* TODO Find a way to automate this */
test_euclid_case(s); test_euclid_case(s);
test_camera_case(s);
SRunner *sr = srunner_create(s); SRunner *sr = srunner_create(s);
srunner_run_all(sr, CK_NORMAL); srunner_run_all(sr, CK_NORMAL);