Removed unused preview renderers

This commit is contained in:
Michaël Lemaire 2015-08-12 22:53:54 +02:00
parent 42d3ae4ceb
commit a8ae50df94
33 changed files with 0 additions and 2943 deletions

View file

@ -6,7 +6,6 @@ SUBDIRS = \
basics \
definition \
render/software \
render/preview \
render/opengl \
interface/commandline \
interface/modeler

View file

@ -1,193 +0,0 @@
#include "AtmosphereColorPreviewRenderer.h"
#include "SoftwareRenderer.h"
#include "AtmosphereRenderer.h"
#include "AtmosphereResult.h"
#include "CameraDefinition.h"
#include "SurfaceMaterial.h"
#include "Scenery.h"
#include "BasePreview.h"
/*
* Atmosphere previews.
*/
typedef struct
{
Vector3 location;
double size;
} Mount;
#define MOUNTS_COUNT 11
static Mount MOUNTS[MOUNTS_COUNT] = {
{
{2.0, 0.0, -6.0}, 4.0
},
{
{-1.5, 0.0, -8.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
},
{
{-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(Color(0.4, 0.4, 0.4, 1.0));
static inline int _rayIntersectsTriangle(Vector3 p, Vector3 d, Vector3 v0, Vector3 v1, Vector3 v2, Vector3* hit)
{
Vector3 e1, e2, h, s, q;
double a, f, u, v, t;
e1 = v1.sub(v0);
e2 = v2.sub(v0);
h = d.crossProduct(e2);
a = e1.dotProduct(h);
if (a > -0.00001 && a < 0.00001)
{
return 0;
}
f = 1.0 / a;
s = p.sub(v0);
u = f * s.dotProduct(h);
if (u < 0.0 || u > 1.0)
{
return 0;
}
q = s.crossProduct(e1);
v = f * d.dotProduct(q);
if (v < 0.0 || u + v > 1.0)
{
return 0;
}
t = f * e2.dotProduct(q);
if (t > 0.00001)
{
*hit = p.add(d.scale(t));
return 1;
}
else
{
return 0;
}
}
static inline int _checkHitMountain(Vector3 eye, Vector3 direction, Mount mount, Vector3* hit)
{
Vector3 v0 = mount.location;
Vector3 v1 = mount.location;
Vector3 v2 = mount.location;
v0.x -= mount.size;
v1.x += mount.size;
v2.y += mount.size;
return _rayIntersectsTriangle(eye, direction, v0, v1, v2, hit);
}
static inline int _checkHitGround(Vector3 eye, Vector3 direction, Vector3* hit)
{
if (direction.y > -0.0001)
{
return 0;
}
else
{
hit->x = eye.x - direction.x * eye.y / direction.y;
hit->y = 0.0;
hit->z = eye.z - direction.z * eye.y / direction.y;
return 1;
}
}
static inline int _checkHit(Vector3 eye, Vector3 direction, Vector3* hit, Vector3* normal)
{
int i;
for (i = 0; i < MOUNTS_COUNT; i++)
{
if (_checkHitMountain(eye, direction, MOUNTS[i], hit))
{
*normal = VECTOR_SOUTH;
return 1;
}
}
*normal = VECTOR_UP;
return _checkHitGround(eye, direction, hit);
}
AtmosphereColorPreviewRenderer::AtmosphereColorPreviewRenderer(AtmosphereDefinition* definition, double heading):
definition(definition), heading(heading)
{
getScenery()->getCamera()->setLocation(Vector3(0.0, 7.0, 0.0));
render_camera->setLocation(Vector3(0.0, 7.0, 0.0));
disableClouds();
}
void AtmosphereColorPreviewRenderer::bindEvent(BasePreview* preview)
{
preview->configHdrToneMapping(true);
preview->configScaling(0.5, 5.0, 0.5, 2.5);
}
void AtmosphereColorPreviewRenderer::updateEvent()
{
getScenery()->setAtmosphere(definition);
prepare();
}
Color AtmosphereColorPreviewRenderer::getColor2D(double x, double y, double)
{
Vector3 eye(0.0, 7.0, 0.0);
Vector3 direction = Vector3(x, -y, -1.0).normalize();
Vector3 hit, normal;
Matrix4 rotation;
rotation = Matrix4::newRotateY(heading);
if (_checkHit(eye, direction, &hit, &normal))
{
Color color;
normal = rotation.transform(normal);
hit = rotation.transform(hit);
color = applyLightingToSurface(hit, normal, MOUNT_MATERIAL);
return applyMediumTraversal(hit, color);
}
else
{
direction = rotation.transform(direction);
return getAtmosphereRenderer()->getSkyColor(direction).final;
}
}

View file

@ -1,26 +0,0 @@
#ifndef ATMOSPHERECOLORPREVIEWRENDERER_H
#define ATMOSPHERECOLORPREVIEWRENDERER_H
#include "Base2dPreviewRenderer.h"
namespace paysages {
namespace preview {
class PREVIEWSHARED_EXPORT AtmosphereColorPreviewRenderer:public Base2dPreviewRenderer
{
public:
AtmosphereColorPreviewRenderer(AtmosphereDefinition* definition, double heading);
void bindEvent(BasePreview* preview) override;
void updateEvent() override;
virtual Color getColor2D(double x, double y, double scaling) override;
private:
AtmosphereDefinition* definition;
double heading;
};
}
}
#endif // ATMOSPHERECOLORPREVIEWRENDERER_H

View file

@ -1,39 +0,0 @@
#include "Base2dPreviewRenderer.h"
#include "Scenery.h"
#include "SoftwareRenderer.h"
Base2dPreviewRenderer::Base2dPreviewRenderer():
SoftwareRenderer()
{
}
Base2dPreviewRenderer::~Base2dPreviewRenderer()
{
}
void Base2dPreviewRenderer::bindEvent(BasePreview*)
{
}
void Base2dPreviewRenderer::toggleChangeEvent(const std::string &, bool)
{
}
void Base2dPreviewRenderer::choiceChangeEvent(const std::string &, int)
{
}
void Base2dPreviewRenderer::updateEvent()
{
prepare();
}
void Base2dPreviewRenderer::cameraEvent(double, double, double)
{
}
Color Base2dPreviewRenderer::getColor2D(double, double, double)
{
return COLOR_BLACK;
}

View file

@ -1,33 +0,0 @@
#ifndef BASE2DPREVIEWRENDERER_H
#define BASE2DPREVIEWRENDERER_H
#include "preview_global.h"
#include "SoftwareRenderer.h"
#include "Color.h"
namespace paysages {
namespace preview {
class PREVIEWSHARED_EXPORT Base2dPreviewRenderer: protected SoftwareRenderer
{
public:
Base2dPreviewRenderer();
virtual ~Base2dPreviewRenderer();
virtual void bindEvent(BasePreview* preview);
virtual void toggleChangeEvent(const std::string &key, bool value);
virtual void choiceChangeEvent(const std::string &key, int position);
virtual void updateEvent();
virtual void cameraEvent(double x, double y, double scaling);
virtual Color getColor2D(double x, double y, double scaling);
};
}
}
#endif // BASE2DPREVIEWRENDERER_H

File diff suppressed because it is too large Load diff

View file

@ -1,144 +0,0 @@
#ifndef BASEPREVIEW_H
#define BASEPREVIEW_H
#include "preview_global.h"
#include "DrawingWidget.h"
#include <QImage>
#include <QStringList>
class QPainter;
class QMutex;
class QLabel;
namespace paysages {
namespace preview {
class _ContextChoice
{
public:
QString title;
QStringList items;
int current;
};
class _ContextToggle
{
public:
QString title;
bool value;
};
class PREVIEWSHARED_EXPORT BasePreview : public DrawingWidget
{
Q_OBJECT
public:
BasePreview(QWidget* parent);
~BasePreview();
void setRenderer(Base2dPreviewRenderer* renderer);
virtual void savePack(PackStream* stream);
virtual void loadPack(PackStream* stream);
static void initDrawers();
static void stopDrawers();
static void reviveAll();
void redraw();
QImage startChunkTransaction(int x, int y, int w, int h, int* revision);
bool commitChunkTransaction(const QImage &chunk, int x, int y, int w, int h, int revision);
void rollbackChunkTransaction();
QColor getPixelColor(int x, int y);
void addOsd(QString name);
void configHdrToneMapping(bool active);
void configScaling(double min, double max, double step, double init, bool logarithmic = true);
void configScrolling(double xmin, double xmax, double xinit, double ymin, double ymax, double yinit);
void addChoice(const QString &key, const QString &title, const QStringList &choices, int init_value);
virtual void choiceChangeEvent(const QString &key, int position);
void addToggle(const QString &key, const QString &text, bool init_value);
virtual void toggleChangeEvent(const QString &key, bool value);
protected:
virtual void updateData();
virtual void cameraEvent();
virtual Color getColor(double x, double y);
double xoffset;
double yoffset;
double scaling;
private:
void updateScaling();
void updateChunks();
void invalidatePixbuf(int value);
void timerEvent(QTimerEvent* event);
void showEvent(QShowEvent* event);
void resizeEvent(QResizeEvent* event);
void doDrawing(QPainter* painter);
void contextMenuEvent(QContextMenuEvent* event);
void mousePressEvent(QMouseEvent* event);
void mouseMoveEvent(QMouseEvent* event);
void wheelEvent(QWheelEvent* event);
void leaveEvent(QEvent* event);
QMutex* _lock_drawing;
QImage* _pixbuf;
QVector<PreviewOsd*> _osd;
QHash<QString, _ContextChoice> _choices;
QHash<QString, _ContextToggle> _toggles;
QLabel* _info;
Base2dPreviewRenderer* _renderer;
int _width;
int _height;
int _revision;
int _transactions_count;
bool _redraw_requested;
int mousex;
int mousey;
double scalingbase;
bool alive;
bool _hdr_enabled;
ColorProfile* _hdr_profile;
double conf_scroll_xmin;
double conf_scroll_xmax;
double conf_scroll_xinit;
double conf_scroll_ymin;
double conf_scroll_ymax;
double conf_scroll_yinit;
double conf_scale_min;
double conf_scale_max;
double conf_scale_init;
double conf_scale_step;
bool conf_scroll_logarithmic;
signals:
void contentChange();
void redrawRequested();
private slots:
void choiceSelected(QAction* action);
};
}
}
#endif // BASEPREVIEW_H

View file

@ -1,133 +0,0 @@
#include "CloudsAspectPreviewRenderer.h"
#include "BasePreview.h"
#include "Scenery.h"
#include "clouds/BaseCloudsModel.h"
#include "CloudsDefinition.h"
#include "CloudLayerDefinition.h"
#include "CloudsRenderer.h"
#include "LightStatus.h"
#include "LightComponent.h"
#include "AtmosphereResult.h"
class FakeCloudModel:public BaseCloudsModel
{
public:
FakeCloudModel(BaseCloudsModel* real_model):
BaseCloudsModel(real_model->getLayer()), real_model(real_model)
{
}
virtual ~FakeCloudModel()
{
delete real_model;
}
virtual void update()
{
real_model->update();
}
virtual void getAltitudeRange(double *min_altitude, double *max_altitude) const
{
real_model->getAltitudeRange(min_altitude, max_altitude);
}
virtual void getDetailRange(double *min_step, double *max_step) const
{
real_model->getDetailRange(min_step, max_step);
*min_step *= 0.4;
*max_step *= 0.4;
}
virtual double getProbability(const Vector3 &location, double radius) const
{
return real_model->getProbability(location, radius);
}
virtual Color filterLight(const Color &light, double length, double density) const
{
return real_model->filterLight(light, length, density);
}
virtual Color applyLightExit(const Color &light, const Vector3 &light_direction, const Vector3 &direction_to_eye) const
{
return real_model->applyLightExit(light, light_direction, direction_to_eye);
}
virtual double getDensity(const Vector3 &location) const override
{
Vector3 location_ext(location.x * 0.5, location.y, location.z * 0.5);
double ymin, ymax, thickness;
getAltitudeRange(&ymin, &ymax);
thickness = ymax - ymin;
Vector3 center(0.0, ymin + thickness * 0.5, 0.0);
double distance = 2.0 * location_ext.sub(center).getNorm() / thickness;
double fallout = 0.7;
if (distance > 1.0)
{
return 0.0;
}
else if (distance < 1.0 - fallout)
{
return 1.0;
}
else
{
double factor = (1.0 - distance) / fallout;
return real_model->getDensity(location_ext) * (1.0 - factor) + factor;
}
}
private:
BaseCloudsModel* real_model;
};
CloudsAspectPreviewRenderer::CloudsAspectPreviewRenderer(CloudLayerDefinition* layer):
layer(layer)
{
CloudsDefinition* clouds = getScenery()->getClouds();
clouds->clear();
clouds->addLayer();
render_quality = 6;
}
void CloudsAspectPreviewRenderer::bindEvent(BasePreview* preview)
{
preview->configScaling(0.5, 2.0, 0.1, 2.0);
preview->configHdrToneMapping(true);
}
void CloudsAspectPreviewRenderer::updateEvent()
{
CloudLayerDefinition* preview_layer = getScenery()->getClouds()->getCloudLayer(0);
layer->copy(preview_layer);
preview_layer->coverage = 0.5;
prepare();
disableAtmosphere();
BaseCloudsModel* real_model = getCloudsRenderer()->getLayerModel(0);
getCloudsRenderer()->setLayerModel(0, new FakeCloudModel(real_model), false);
}
Color CloudsAspectPreviewRenderer::getColor2D(double x, double y, double)
{
Vector3 start, end;
BaseCloudsModel* model = getCloudsRenderer()->getLayerModel(0);
double ymin, ymax, thickness;
model->getAltitudeRange(&ymin, &ymax);
thickness = ymax - ymin;
start.x = x * thickness;
start.y = ymin + (1.0 - y) * thickness * 0.5;
start.z = thickness;
end.x = start.x;
end.y = start.y;
end.z = -start.z;
return getCloudsRenderer()->getColor(start, end, COLOR_BLUE);
}

View file

@ -1,27 +0,0 @@
#ifndef CLOUDSASPECTPREVIEWRENDERER_H
#define CLOUDSASPECTPREVIEWRENDERER_H
#include "preview_global.h"
#include "Base2dPreviewRenderer.h"
namespace paysages {
namespace preview {
class PREVIEWSHARED_EXPORT CloudsAspectPreviewRenderer : public Base2dPreviewRenderer
{
public:
CloudsAspectPreviewRenderer(CloudLayerDefinition* layer);
virtual void bindEvent(BasePreview* preview) override;
virtual void updateEvent() override;
virtual Color getColor2D(double x, double y, double scaling) override;
private:
CloudLayerDefinition* layer;
};
}
}
#endif // CLOUDSASPECTPREVIEWRENDERER_H

View file

@ -1,73 +0,0 @@
#include "CloudsCoveragePreviewRenderer.h"
#include "BasePreview.h"
#include "Scenery.h"
#include "CloudsDefinition.h"
#include "CloudLayerDefinition.h"
#include "CloudsRenderer.h"
CloudsCoveragePreviewRenderer::CloudsCoveragePreviewRenderer(CloudLayerDefinition* layer):
layer(layer)
{
perspective = true;
render_quality = 6;
CloudsDefinition* clouds = getScenery()->getClouds();
clouds->clear();
clouds->addLayer();
}
void CloudsCoveragePreviewRenderer::bindEvent(BasePreview* preview)
{
preview->addToggle("3d", "Perspective", perspective);
preview->configScaling(100.0, 1000.0, 20.0, 200.0);
}
void CloudsCoveragePreviewRenderer::updateEvent()
{
layer->copy(getScenery()->getClouds()->getCloudLayer(0));
prepare();
}
Color CloudsCoveragePreviewRenderer::getColor2D(double x, double y, double scaling)
{
if (perspective)
{
Vector3 eye, look;
eye.x = 0.0;
eye.y = scaling;
eye.z = -10.0 * scaling;
look.x = x * 0.01 / scaling;
look.y = -(y * 0.01 - 0.3) / scaling;
look.z = 1.0;
look = look.normalize();
return getCloudsRenderer()->getColor(eye, eye.add(look.scale(1000.0)), COLOR_BLUE);
}
else
{
Vector3 start, end;
start.x = end.x = x;
start.z = end.z = y;
start.y = 1000.0;
end.y = -1000.0;
return getCloudsRenderer()->getColor(start, end, COLOR_BLUE);
}
}
void CloudsCoveragePreviewRenderer::toggleChangeEvent(const std::string &key, bool value)
{
if (key == "3d")
{
perspective = value;
}
}
Color CloudsCoveragePreviewRenderer::applyLightingToSurface(const Vector3 &, const Vector3 &, const SurfaceMaterial &)
{
return COLOR_WHITE;
}

View file

@ -1,32 +0,0 @@
#ifndef CLOUDSCOVERAGEPREVIEWRENDERER_H
#define CLOUDSCOVERAGEPREVIEWRENDERER_H
#include "preview_global.h"
#include "Base2dPreviewRenderer.h"
namespace paysages {
namespace preview {
class PREVIEWSHARED_EXPORT CloudsCoveragePreviewRenderer : public Base2dPreviewRenderer
{
public:
CloudsCoveragePreviewRenderer(CloudLayerDefinition* layer);
virtual void bindEvent(BasePreview* preview) override;
virtual void updateEvent() override;
virtual Color getColor2D(double x, double y, double scaling) override;
virtual void toggleChangeEvent(const std::string &key, bool value) override;
virtual Color applyLightingToSurface(const Vector3 &location, const Vector3 &normal, const SurfaceMaterial &material) override;
private:
bool perspective;
CloudLayerDefinition* layer;
};
}
}
#endif // CLOUDSCOVERAGEPREVIEWRENDERER_H

View file

@ -1,23 +0,0 @@
#include "DrawingWidget.h"
#include <QPainter>
#include <QPainterPath>
DrawingWidget::DrawingWidget(QWidget* parent) :
QWidget(parent)
{
}
void DrawingWidget::paintEvent(QPaintEvent*)
{
QPainter painter(this);
QPainterPath mask;
mask.addRoundedRect(rect(), 8.0, 8.0);
painter.setRenderHint(QPainter::Antialiasing, true);
painter.setClipPath(mask);
painter.setRenderHint(QPainter::Antialiasing, false);
doDrawing(&painter);
}

View file

@ -1,29 +0,0 @@
#ifndef DRAWINGWIDGET_H
#define DRAWINGWIDGET_H
#include "preview_global.h"
#include <QWidget>
class QPaintEvent;
class QPainter;
namespace paysages {
namespace preview {
class PREVIEWSHARED_EXPORT DrawingWidget : public QWidget
{
Q_OBJECT
public:
explicit DrawingWidget(QWidget* parent = 0);
protected:
virtual void doDrawing(QPainter* painter) = 0;
private:
virtual void paintEvent(QPaintEvent* event);
};
}
}
#endif /* DRAWINGWIDGET_H */

View file

@ -1,86 +0,0 @@
#include "PreviewOsd.h"
#include <QImage>
#include <QHash>
#include <QPainter>
#include "PreviewOsdItem.h"
static QHash<QString, PreviewOsd*> _instances;
/*************** PreviewOsd ***************/
PreviewOsd::PreviewOsd()
{
}
PreviewOsd::~PreviewOsd()
{
for (int i = 0; i < _items.size(); i++)
{
delete _items[i];
}
}
PreviewOsd* PreviewOsd::getInstance(QString name)
{
if (_instances.contains(name))
{
return _instances[name];
}
else
{
PreviewOsd* instance = new PreviewOsd();
_instances.insert(name, instance);
return instance;
}
}
void PreviewOsd::clearItems()
{
for (int i = 0; i < _items.size(); i++)
{
delete _items[i];
}
_items.clear();
}
PreviewOsdItem* PreviewOsd::newItem(int width, int height)
{
PreviewOsdItem* item = new PreviewOsdItem(width, height);
_items.append(item);
return item;
}
PreviewOsdItem* PreviewOsd::newItem(const QImage &image)
{
PreviewOsdItem* item = newItem(image.width(), image.height());
QPainter painter(item);
painter.drawImage(0, 0, image);
return item;
}
void PreviewOsd::apply(QImage *mask, double xoffset, double yoffset, double scaling)
{
QPainter painter(mask);
for (int i = 0; i < _items.size(); i++)
{
PreviewOsdItem* item = _items[i];
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);
painter.drawImage(x, y, *item);
}
}
QString PreviewOsd::getToolTip(double x, double y, double scaling)
{
for (int i = 0; i < _items.size(); i++)
{
PreviewOsdItem* item = _items[i];
QString tooltip = item->getToolTip(x, y, scaling);
if (not tooltip.isEmpty())
{
return tooltip;
}
}
return QString();
}

View file

@ -1,33 +0,0 @@
#ifndef PREVIEWOSD_H
#define PREVIEWOSD_H
#include "preview_global.h"
#include <QVector>
class QImage;
namespace paysages {
namespace preview {
class PREVIEWSHARED_EXPORT PreviewOsd
{
public:
PreviewOsd();
~PreviewOsd();
static PreviewOsd* getInstance(QString name);
void clearItems();
PreviewOsdItem* newItem(int width, int height);
PreviewOsdItem* newItem(const QImage& image);
void apply(QImage* mask, double xoffset, double yoffset, double scaling);
QString getToolTip(double x, double y, double scaling);
private:
QVector<PreviewOsdItem*> _items;
};
}
}
#endif

View file

@ -1,52 +0,0 @@
#include "PreviewOsdItem.h"
#include <QPainter>
#include "Vector3.h"
#include "CameraDefinition.h"
PreviewOsdItem::PreviewOsdItem(int width, int height) : QImage(width, height, QImage::Format_ARGB32)
{
_xlocation = 0.0;
_ylocation = 0.0;
fill(0x00000000);
}
void PreviewOsdItem::setLocation(double x, double y)
{
_xlocation = x;
_ylocation = y;
}
void PreviewOsdItem::drawCamera(CameraDefinition* camera)
{
Vector3 camera_location = camera->getLocation();
VectorSpherical camera_direction = camera->getDirectionSpherical();
int w2 = width() / 2;
int h2 = height() / 2;
_xlocation = camera_location.x;
_ylocation = camera_location.z;
QPainter painter(this);
painter.setPen(QPen(Qt::red, 2));
painter.setRenderHints(QPainter::Antialiasing | QPainter::HighQualityAntialiasing, true);
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_direction.phi + M_PI_4), h2 - h2 * sin(camera_direction.phi + M_PI_4));
}
void PreviewOsdItem::setToolTip(QString text)
{
_tooltip = text;
}
QString PreviewOsdItem::getToolTip(double x, double y, double scaling)
{
if (_tooltip.isEmpty() or (x > _xlocation - (width() / 2) * scaling and x < _xlocation + (width() / 2) * scaling and y > _ylocation - (height() / 2) * scaling and y < _ylocation + (height() / 2) * scaling))
{
return _tooltip;
}
else
{
return QString();
}
}

View file

@ -1,34 +0,0 @@
#ifndef PREVIEWOSDITEM_H
#define PREVIEWOSDITEM_H
#include "preview_global.h"
#include <QImage>
namespace paysages {
namespace preview {
class PREVIEWSHARED_EXPORT PreviewOsdItem:public QImage
{
public:
PreviewOsdItem(int width, int height);
void setLocation(double x, double y);
inline double xlocation() {return _xlocation;}
inline double ylocation() {return _ylocation;}
void setToolTip(QString text);
QString getToolTip(double x, double y, double scaling);
void drawCamera(CameraDefinition* camera);
private:
double _xlocation;
double _ylocation;
QString _tooltip;
};
}
}
#endif // PREVIEWOSDITEM_H

View file

@ -1,97 +0,0 @@
#include "SceneryTopDownPreviewRenderer.h"
#include "CloudsDefinition.h"
#include "BasePreview.h"
#include "Scenery.h"
#include "TerrainRenderer.h"
#include "WaterRenderer.h"
#include "CloudsRenderer.h"
#include "LightingManager.h"
SceneryTopDownPreviewRenderer::SceneryTopDownPreviewRenderer(Scenery* scenery):
scenery(scenery)
{
clouds_enabled = true;
render_quality = 3;
}
void SceneryTopDownPreviewRenderer::bindEvent(BasePreview* preview)
{
no_clouds = new CloudsDefinition(NULL);
clouds_enabled = true;
// TODO Translation
preview->addOsd("geolocation");
preview->addToggle("clouds", "Clouds", false);
preview->addToggle("specularity", "Light reflection", false);
preview->configHdrToneMapping(true);
preview->configScaling(0.5, 200.0, 3.0, 50.0);
preview->configScrolling(-1000.0, 1000.0, 0.0, -1000.0, 1000.0, 0.0);
}
void SceneryTopDownPreviewRenderer::updateEvent()
{
setScenery(scenery);
if (not clouds_enabled)
{
getScenery()->getClouds()->clear();
}
getLightingManager()->setSpecularity(specularity_enabled);
prepare();
}
Color SceneryTopDownPreviewRenderer::getColor2D(double x, double y, double scaling)
{
Vector3 location;
double height = getTerrainRenderer()->getHeight(x, y, true);
if (height < getWaterRenderer()->getHeightInfo().max_height)
{
return getWaterRenderer()->getResult(x, y).final;
}
else
{
location.x = x;
location.y = height;
location.z = y;
return getTerrainRenderer()->getFinalColor(location, scaling);
}
}
void SceneryTopDownPreviewRenderer::toggleChangeEvent(const std::string &key, bool value)
{
if (key == "clouds")
{
clouds_enabled = value;
}
else if (key == "specularity")
{
specularity_enabled = value;
}
}
double SceneryTopDownPreviewRenderer::getPrecision(const Vector3 &)
{
return 0.0000001;
}
Vector3 SceneryTopDownPreviewRenderer::getCameraLocation(const Vector3 &target)
{
return target.add(VECTOR_UP.scale(50.0));
}
Color SceneryTopDownPreviewRenderer::applyMediumTraversal(Vector3 location, Color color)
{
if (clouds_enabled)
{
return getCloudsRenderer()->getColor(getCameraLocation(location), location, color);
}
else
{
return color;
}
}

View file

@ -1,37 +0,0 @@
#ifndef SCENERYTOPDOWNPREVIEWRENDERER_H
#define SCENERYTOPDOWNPREVIEWRENDERER_H
#include "preview_global.h"
#include "Base2dPreviewRenderer.h"
namespace paysages {
namespace preview {
class PREVIEWSHARED_EXPORT SceneryTopDownPreviewRenderer : public Base2dPreviewRenderer
{
public:
SceneryTopDownPreviewRenderer(Scenery* scenery);
protected:
virtual void bindEvent(BasePreview* preview) override;
virtual void updateEvent() override;
virtual Color getColor2D(double x, double y, double scaling) override;
virtual void toggleChangeEvent(const std::string &key, bool value) override;
virtual double getPrecision(const Vector3 &location) override;
virtual Vector3 getCameraLocation(const Vector3 &target) override;
virtual Color applyMediumTraversal(Vector3 location, Color color) override;
private:
Scenery* scenery;
bool clouds_enabled;
bool specularity_enabled;
CloudsDefinition* no_clouds;
};
}
}
#endif // SCENERYTOPDOWNPREVIEWRENDERER_H

View file

@ -1,74 +0,0 @@
#include "TerrainShapePreviewRenderer.h"
#include "TexturesDefinition.h"
#include "TextureLayerDefinition.h"
#include "Zone.h"
#include "SurfaceMaterial.h"
#include "NoiseGenerator.h"
#include "BasePreview.h"
#include "Scenery.h"
#include "LightComponent.h"
#include "LightStatus.h"
#include "TerrainRenderer.h"
TerrainShapePreviewRenderer::TerrainShapePreviewRenderer(TerrainDefinition* terrain)
{
_terrain = terrain;
render_quality = 3;
disableClouds();
getScenery()->getTextures()->clear();
getScenery()->getTextures()->addLayer();
TextureLayerDefinition* layer = getScenery()->getTextures()->getTextureLayer(0);
layer->terrain_zone->clear();
layer->displacement_height = 0.0;
layer->material->base = colorToHSL(COLOR_WHITE);
layer->material->reflection = 0.05;
layer->material->shininess = 2.0;
layer->validate();
layer->_detail_noise->clearLevels();
}
Vector3 TerrainShapePreviewRenderer::getCameraLocation(const Vector3 &target)
{
return target.add(Vector3(-10.0, 15.0, 10.0));
}
void TerrainShapePreviewRenderer::bindEvent(BasePreview* preview)
{
preview->addOsd(QString("geolocation"));
preview->configScaling(20.0, 1000.0, 20.0, 200.0);
preview->configScrolling(-1000.0, 1000.0, 0.0, -1000.0, 1000.0, 0.0);
}
void TerrainShapePreviewRenderer::updateEvent()
{
getScenery()->setTerrain(_terrain);
prepare();
disableAtmosphere();
}
Color TerrainShapePreviewRenderer::getColor2D(double x, double y, double scaling)
{
double height;
height = getTerrainRenderer()->getHeight(x, y, true);
if (height > 0.0)
{
return getTerrainRenderer()->getFinalColor(Vector3(x, height, y), 0.000001);
}
else
{
return getWaterColor(x, y, scaling);
}
}
Color TerrainShapePreviewRenderer::getWaterColor(double, double, double)
{
return COLOR_BLUE;
}

View file

@ -1,34 +0,0 @@
#ifndef TERRAINSHAPEPREVIEWRENDERER_H
#define TERRAINSHAPEPREVIEWRENDERER_H
#include "preview_global.h"
#include "Base2dPreviewRenderer.h"
namespace paysages {
namespace preview {
class PREVIEWSHARED_EXPORT TerrainShapePreviewRenderer : public Base2dPreviewRenderer
{
public:
explicit TerrainShapePreviewRenderer(TerrainDefinition* terrain);
protected:
virtual Vector3 getCameraLocation(const Vector3 &target) override;
virtual void bindEvent(BasePreview* preview) override;
virtual void updateEvent() override;
virtual Color getColor2D(double x, double y, double scaling) override;
virtual Color getWaterColor(double x, double y, double scaling);
TerrainDefinition* _terrain;
private:
double _water_height;
};
}
}
#endif // TERRAINSHAPEPREVIEWRENDERER_H

View file

@ -1,51 +0,0 @@
#include "TextureLayerAspectPreviewRenderer.h"
#include "Scenery.h"
#include "BasePreview.h"
#include "TexturesRenderer.h"
TextureLayerAspectPreviewRenderer::TextureLayerAspectPreviewRenderer():
Base2dPreviewRenderer()
{
textures = NULL;
render_quality = 3;
}
void TextureLayerAspectPreviewRenderer::setTextures(TexturesDefinition* textures)
{
this->textures = textures;
}
void TextureLayerAspectPreviewRenderer::setLayer(int layer)
{
this->layer = layer;
}
void TextureLayerAspectPreviewRenderer::bindEvent(BasePreview* preview)
{
preview->addOsd(QString("geolocation"));
preview->configScaling(20.0, 1000.0, 20.0, 200.0);
preview->configScrolling(-1000.0, 1000.0, 0.0, -1000.0, 1000.0, 0.0);
}
void TextureLayerAspectPreviewRenderer::updateEvent()
{
Base2dPreviewRenderer::updateEvent();
if (textures)
{
getScenery()->setTextures(textures);
}
disableAtmosphere();
disableClouds();
}
Color TextureLayerAspectPreviewRenderer::getColor2D(double x, double y, double)
{
TexturesRenderer* textures_renderer = getTexturesRenderer();
return textures_renderer->applyToTerrain(x, y).final_color;
}

View file

@ -1,32 +0,0 @@
#ifndef TEXTURELAYERASPECTPREVIEWRENDERER_H
#define TEXTURELAYERASPECTPREVIEWRENDERER_H
#include "preview_global.h"
#include "Base2dPreviewRenderer.h"
namespace paysages {
namespace preview {
class PREVIEWSHARED_EXPORT TextureLayerAspectPreviewRenderer: public Base2dPreviewRenderer
{
public:
TextureLayerAspectPreviewRenderer();
void setTextures(TexturesDefinition* textures);
void setLayer(int layer);
protected:
virtual void bindEvent(BasePreview* preview);
virtual void updateEvent();
virtual Color getColor2D(double x, double y, double scaling);
private:
TexturesDefinition* textures;
int layer;
};
}
}
#endif // TEXTURELAYERASPECTPREVIEWRENDERER_H

View file

@ -1,59 +0,0 @@
#include "TextureLayerCoveragePreviewRenderer.h"
#include "Scenery.h"
#include "BasePreview.h"
#include "TexturesRenderer.h"
TextureLayerCoveragePreviewRenderer::TextureLayerCoveragePreviewRenderer():
Base2dPreviewRenderer()
{
textures = NULL;
render_quality = 3;
}
void TextureLayerCoveragePreviewRenderer::setTextures(TexturesDefinition* textures)
{
this->textures = textures;
}
void TextureLayerCoveragePreviewRenderer::setTerrain(TerrainDefinition *terrain)
{
getScenery()->setTerrain(terrain);
}
void TextureLayerCoveragePreviewRenderer::setLayer(int layer)
{
this->layer = layer;
}
void TextureLayerCoveragePreviewRenderer::bindEvent(BasePreview* preview)
{
preview->addOsd(QString("geolocation"));
preview->configScaling(20.0, 1000.0, 20.0, 200.0);
preview->configScrolling(-1000.0, 1000.0, 0.0, -1000.0, 1000.0, 0.0);
}
void TextureLayerCoveragePreviewRenderer::updateEvent()
{
Base2dPreviewRenderer::updateEvent();
if (textures)
{
getScenery()->setTextures(textures);
}
disableAtmosphere();
disableClouds();
}
Color TextureLayerCoveragePreviewRenderer::getColor2D(double x, double y, double)
{
TexturesRenderer* textures_renderer = getTexturesRenderer();
TerrainRenderer* terrain_renderer = getTerrainRenderer();
double presence = textures_renderer->getBasePresence(layer, terrain_renderer->getResult(x, y, true, false));
return Color(presence, presence, presence);
}

View file

@ -1,33 +0,0 @@
#ifndef TEXTURELAYERCOVERAGEPREVIEWRENDERER_H
#define TEXTURELAYERCOVERAGEPREVIEWRENDERER_H
#include "preview_global.h"
#include "Base2dPreviewRenderer.h"
namespace paysages {
namespace preview {
class PREVIEWSHARED_EXPORT TextureLayerCoveragePreviewRenderer: public Base2dPreviewRenderer
{
public:
TextureLayerCoveragePreviewRenderer();
void setTextures(TexturesDefinition* textures);
void setTerrain(TerrainDefinition* terrain);
void setLayer(int layer);
protected:
virtual void bindEvent(BasePreview* preview);
virtual void updateEvent();
virtual Color getColor2D(double x, double y, double scaling);
private:
TexturesDefinition* textures;
int layer;
};
}
}
#endif // TEXTURELAYERCOVERAGEPREVIEWRENDERER_H

View file

@ -1,58 +0,0 @@
#include "TexturesMixPreviewRenderer.h"
#include "Scenery.h"
#include "BasePreview.h"
#include "TerrainRenderer.h"
TexturesMixPreviewRenderer::TexturesMixPreviewRenderer():
Base2dPreviewRenderer()
{
textures = NULL;
render_quality = 3;
}
void TexturesMixPreviewRenderer::setTextures(TexturesDefinition* textures)
{
this->textures = textures;
}
void TexturesMixPreviewRenderer::setTerrain(TerrainDefinition *terrain)
{
getScenery()->setTerrain(terrain);
}
void TexturesMixPreviewRenderer::setLayer(int layer)
{
this->layer = layer;
}
void TexturesMixPreviewRenderer::bindEvent(BasePreview* preview)
{
preview->addOsd(QString("geolocation"));
preview->configHdrToneMapping(true);
preview->configScaling(20.0, 1000.0, 20.0, 200.0);
preview->configScrolling(-1000.0, 1000.0, 0.0, -1000.0, 1000.0, 0.0);
}
void TexturesMixPreviewRenderer::updateEvent()
{
Base2dPreviewRenderer::updateEvent();
if (textures)
{
getScenery()->setTextures(textures);
}
disableAtmosphere();
disableClouds();
}
Color TexturesMixPreviewRenderer::getColor2D(double x, double y, double scaling)
{
TerrainRenderer* terrain_renderer = getTerrainRenderer();
Vector3 location(x, terrain_renderer->getHeight(x, y, true), y);
return terrain_renderer->getFinalColor(location, scaling);
}

View file

@ -1,33 +0,0 @@
#ifndef TEXTURESMIXPREVIEWRENDERER_H
#define TEXTURESMIXPREVIEWRENDERER_H
#include "preview_global.h"
#include "Base2dPreviewRenderer.h"
namespace paysages {
namespace preview {
class PREVIEWSHARED_EXPORT TexturesMixPreviewRenderer:public Base2dPreviewRenderer
{
public:
TexturesMixPreviewRenderer();
void setTextures(TexturesDefinition* textures);
void setTerrain(TerrainDefinition* terrain);
void setLayer(int layer);
protected:
virtual void bindEvent(BasePreview* preview) override;
virtual void updateEvent() override;
virtual Color getColor2D(double x, double y, double scaling) override;
private:
int layer;
TexturesDefinition* textures;
};
}
}
#endif // TEXTURESMIXPREVIEWRENDERER_H

View file

@ -1,160 +0,0 @@
#include "WaterAspectPreviewRenderer.h"
#include "BasePreview.h"
#include "Scenery.h"
#include "WaterDefinition.h"
#include "CameraDefinition.h"
#include "WaterRenderer.h"
#include "LightComponent.h"
WaterAspectPreviewRenderer::WaterAspectPreviewRenderer(WaterDefinition* definition):
definition(definition)
{
lighting = true;
background = 2;
render_quality = 3;
customData[0] = &lighting;
customData[1] = &background;
}
void WaterAspectPreviewRenderer::bindEvent(BasePreview* preview)
{
preview->configScaling(10.0, 1000.0, 10.0, 250.0);
//configScrolling(-30.0, 30.0, 0.0, -20.0, 20.0, 0.0);
// TODO Translation
preview->addChoice("bg", "Background", QStringList("None") << "Grid" << "Sinusoid", 2);
preview->addToggle("light", "Light reflection", true);
//preview->configHdrToneMapping(true);
}
void WaterAspectPreviewRenderer::updateEvent()
{
getScenery()->setWater(definition);
getScenery()->getCamera()->setTarget(VECTOR_ZERO);
prepare();
LightComponent light;
std::vector<LightComponent> lights;
light.color = COLOR_WHITE;
light.direction.x = 0.0;
light.direction.y = -0.4794;
light.direction.z = -0.8776;
light.altered = 0;
if (lighting)
{
light.reflection = 1.0;
}
else
{
light.reflection = 0.0;
}
lights.push_back(light);
disableAtmosphere(lights);
}
void WaterAspectPreviewRenderer::cameraEvent(double, double, double scaling)
{
Vector3 camera_location(0.0, scaling, -10.0 * scaling);
getScenery()->getCamera()->setLocation(camera_location);
render_camera->setLocation(camera_location);
}
Color WaterAspectPreviewRenderer::getColor2D(double x, double y, double scaling)
{
Vector3 eye, look;
double target_x, target_z;
eye = render_camera->getLocation();
look = Vector3(x * 0.01 / scaling, -y * 0.01 / scaling - 0.3, 1.0).normalize();
if (look.y > -0.0001)
{
return rayWalking(eye, look, 0, 0, 0, 0).hit_color;
}
target_x = eye.x - look.x * eye.y / look.y;
target_z = eye.z - look.z * eye.y / look.y;
if (target_z > 0.0)
{
return rayWalking(eye, look, 0, 0, 0, 0).hit_color;
}
return getWaterRenderer()->getResult(target_x, target_z).final;
}
void WaterAspectPreviewRenderer::toggleChangeEvent(const std::string &key, bool value)
{
if (key == "light")
{
lighting = value;
}
}
void WaterAspectPreviewRenderer::choiceChangeEvent(const std::string &key, int position)
{
if (key == "bg")
{
background = position;
}
}
double WaterAspectPreviewRenderer::getPrecision(const Vector3 &)
{
return 0.000001;
}
RayCastingResult WaterAspectPreviewRenderer::rayWalking(const Vector3 &location, const Vector3 &direction, int, int, int, int)
{
RayCastingResult result;
double x, y;
result.hit = 1;
if (direction.z < 0.0001)
{
result.hit_color = COLOR_WHITE;
result.hit_location = location;
}
else
{
x = location.x + direction.x * (0.0 - location.z) / direction.z;
y = location.y + direction.y * (0.0 - location.z) / direction.z;
switch (background)
{
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;
break;
case 2:
result.hit_color = (y * 0.1 > x * 0.03 + sin(x - M_PI_2)) ? COLOR_WHITE : COLOR_BLACK;
break;
default:
result.hit_color = COLOR_WHITE;
}
result.hit_location.x = x;
result.hit_location.y = y;
result.hit_location.z = 0.0;
if (result.hit_location.y < 0.0)
{
double lighting_depth = getScenery()->getWater()->lighting_depth;
if (result.hit_location.y < -lighting_depth)
{
result.hit_color = COLOR_BLACK;
}
else
{
double attenuation = -result.hit_location.y / lighting_depth;
result.hit_color.r *= 1.0 - attenuation;
result.hit_color.g *= 1.0 - attenuation;
result.hit_color.b *= 1.0 - attenuation;
}
}
}
return result;
}

View file

@ -1,36 +0,0 @@
#ifndef WATERASPECTPREVIEWRENDERER_H
#define WATERASPECTPREVIEWRENDERER_H
#include "preview_global.h"
#include "Base2dPreviewRenderer.h"
namespace paysages {
namespace preview {
class PREVIEWSHARED_EXPORT WaterAspectPreviewRenderer : public Base2dPreviewRenderer
{
public:
WaterAspectPreviewRenderer(WaterDefinition* definition);
virtual void bindEvent(BasePreview* preview) override;
virtual void updateEvent() override;
virtual void cameraEvent(double x, double y, double scaling) override;
virtual Color getColor2D(double x, double y, double scaling) override;
virtual void toggleChangeEvent(const std::string &key, bool value) override;
virtual void choiceChangeEvent(const std::string &key, int position) override;
virtual double getPrecision(const Vector3 &location) override;
virtual RayCastingResult rayWalking(const Vector3 &location, const Vector3 &direction, int terrain, int water, int sky, int clouds) override;
private:
WaterDefinition* definition;
bool lighting;
int background;
};
}
}
#endif // WATERASPECTPREVIEWRENDERER_H

View file

@ -1,63 +0,0 @@
#include "WaterCoveragePreviewRenderer.h"
#include "BasePreview.h"
#include "Scenery.h"
#include "TerrainDefinition.h"
#include "WaterRenderer.h"
WaterCoveragePreviewRenderer::WaterCoveragePreviewRenderer(WaterDefinition* definition):
TerrainShapePreviewRenderer(new TerrainDefinition(NULL)), definition(definition)
{
highlight = true;
}
WaterCoveragePreviewRenderer::~WaterCoveragePreviewRenderer()
{
delete TerrainShapePreviewRenderer::_terrain;
}
void WaterCoveragePreviewRenderer::setTerrain(TerrainDefinition *terrain)
{
terrain->copy(TerrainShapePreviewRenderer::_terrain);
getScenery()->setTerrain(terrain);
}
void WaterCoveragePreviewRenderer::bindEvent(BasePreview* preview)
{
TerrainShapePreviewRenderer::bindEvent(preview);
// TODO Translation
preview->addToggle("highlight", "Coverage highlight", true);
// TODO Keep camera above center (for reflections)
}
void WaterCoveragePreviewRenderer::toggleChangeEvent(const std::string &key, bool value)
{
if (key == "highlight")
{
highlight = value;
}
}
void WaterCoveragePreviewRenderer::updateEvent()
{
getScenery()->setWater(definition);
TerrainShapePreviewRenderer::updateEvent();
}
Color WaterCoveragePreviewRenderer::getWaterColor(double x, double y, double)
{
Color base;
base = getWaterRenderer()->getResult(x, y).final;
if (highlight)
{
Color mask = {0.5, 0.5, 1.0, 0.5};
base.mask(mask);
}
return base;
}

View file

@ -1,34 +0,0 @@
#ifndef WATERCOVERAGEPREVIEWRENDERER_H
#define WATERCOVERAGEPREVIEWRENDERER_H
#include "preview_global.h"
#include "TerrainShapePreviewRenderer.h"
namespace paysages {
namespace preview {
class PREVIEWSHARED_EXPORT WaterCoveragePreviewRenderer : public TerrainShapePreviewRenderer
{
public:
WaterCoveragePreviewRenderer(WaterDefinition* definition);
virtual ~WaterCoveragePreviewRenderer();
void setTerrain(TerrainDefinition* terrain);
virtual void bindEvent(BasePreview* preview) override;
virtual void updateEvent() override;
virtual Color getWaterColor(double x, double y, double scaling) override;
virtual void toggleChangeEvent(const std::string &key, bool value) override;
private:
WaterDefinition* definition;
bool highlight;
};
}
}
#endif // WATERCOVERAGEPREVIEWRENDERER_H

View file

@ -1,79 +0,0 @@
#-------------------------------------------------
#
# Project created by QtCreator 2013-11-11T17:56:07
#
#-------------------------------------------------
TARGET = paysages_render_preview
TEMPLATE = lib
QT += gui widgets
DEFINES += PREVIEW_LIBRARY
include(../../common.pri)
SOURCES += Base2dPreviewRenderer.cpp \
AtmosphereColorPreviewRenderer.cpp \
BasePreview.cpp \
PreviewOsd.cpp \
DrawingWidget.cpp \
PreviewOsdItem.cpp \
CloudsCoveragePreviewRenderer.cpp \
CloudsAspectPreviewRenderer.cpp \
WaterCoveragePreviewRenderer.cpp \
WaterAspectPreviewRenderer.cpp \
TerrainShapePreviewRenderer.cpp \
SceneryTopDownPreviewRenderer.cpp \
TexturesMixPreviewRenderer.cpp \
TextureLayerCoveragePreviewRenderer.cpp \
TextureLayerAspectPreviewRenderer.cpp
HEADERS += Base2dPreviewRenderer.h\
preview_global.h \
AtmosphereColorPreviewRenderer.h \
BasePreview.h \
PreviewOsd.h \
DrawingWidget.h \
PreviewOsdItem.h \
CloudsCoveragePreviewRenderer.h \
CloudsAspectPreviewRenderer.h \
WaterCoveragePreviewRenderer.h \
WaterAspectPreviewRenderer.h \
TerrainShapePreviewRenderer.h \
SceneryTopDownPreviewRenderer.h \
TexturesMixPreviewRenderer.h \
TextureLayerCoveragePreviewRenderer.h \
TextureLayerAspectPreviewRenderer.h
unix:!symbian {
maemo5 {
target.path = /opt/usr/lib
} else {
target.path = /usr/lib
}
INSTALLS += target
}
win32:CONFIG(release, debug|release): LIBS += -L$$OUT_PWD/../../system/release/ -lpaysages_system
else:win32:CONFIG(debug, debug|release): LIBS += -L$$OUT_PWD/../../system/debug/ -lpaysages_system
else:unix: LIBS += -L$$OUT_PWD/../../system/ -lpaysages_system
INCLUDEPATH += $$PWD/../../system
DEPENDPATH += $$PWD/../../system
win32:CONFIG(release, debug|release): LIBS += -L$$OUT_PWD/../../basics/release/ -lpaysages_basics
else:win32:CONFIG(debug, debug|release): LIBS += -L$$OUT_PWD/../../basics/debug/ -lpaysages_basics
else:unix: LIBS += -L$$OUT_PWD/../../basics/ -lpaysages_basics
INCLUDEPATH += $$PWD/../../basics
DEPENDPATH += $$PWD/../../basics
win32:CONFIG(release, debug|release): LIBS += -L$$OUT_PWD/../../definition/release/ -lpaysages_definition
else:win32:CONFIG(debug, debug|release): LIBS += -L$$OUT_PWD/../../definition/debug/ -lpaysages_definition
else:unix: LIBS += -L$$OUT_PWD/../../definition/ -lpaysages_definition
INCLUDEPATH += $$PWD/../../definition
DEPENDPATH += $$PWD/../../definition
win32:CONFIG(release, debug|release): LIBS += -L$$OUT_PWD/../software/release/ -lpaysages_render_software
else:win32:CONFIG(debug, debug|release): LIBS += -L$$OUT_PWD/../software/debug/ -lpaysages_render_software
else:unix: LIBS += -L$$OUT_PWD/../software/ -lpaysages_render_software
INCLUDEPATH += $$PWD/../software
DEPENDPATH += $$PWD/../software

View file

@ -1,33 +0,0 @@
#ifndef PREVIEW_GLOBAL_H
#define PREVIEW_GLOBAL_H
#include <QtCore/qglobal.h>
#if defined(PREVIEW_LIBRARY)
# define PREVIEWSHARED_EXPORT Q_DECL_EXPORT
#else
# define PREVIEWSHARED_EXPORT Q_DECL_IMPORT
#endif
#include "software_global.h"
namespace paysages {
namespace preview {
class PreviewOsd;
class PreviewOsdItem;
class BasePreview;
class Base2dPreviewRenderer;
class AtmosphereColorPreviewRenderer;
class CloudsCoveragePreviewRenderer;
class CloudsAspectPreviewRenderer;
class WaterCoveragePreviewRenderer;
class WaterAspectPreviewRenderer;
class TerrainShapePreviewRenderer;
class TexturesMixPreviewRenderer;
class TextureLayerCoveragePreviewRenderer;
class TextureLayerAspectPreviewRenderer;
}
}
using namespace paysages::preview;
#endif // PREVIEW_GLOBAL_H