graphics/paysages3d
1
0
Fork 0
Code Releases Activity

Refactored TexturesDefinition, getting rid of legacy layers

Browse source
This commit is contained in:
Michaël Lemaire 2013-11-16 19:12:42 +01:00
parent 5506158363
commit fa5c0041af
39 changed files with 823 additions and 1180 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

144
src/definition/Layers.cpp
View file

@ -1,16 +1,8 @@
#include "Layers.h"
Layers::Layers(BaseDefinition* parent, LayerConstructor layer_constructor, LayerType* legacy_type):
Layers::Layers(BaseDefinition* parent, LayerConstructor layer_constructor):
BaseDefinition(parent), layer_constructor(layer_constructor)
{
if (legacy_type)
{
this->legacy_type = *legacy_type;
}
else
{
this->legacy_type.callback_create = NULL;
}
max_layer_count = 100;
null_layer = layer_constructor(this);
}
@ -31,7 +23,6 @@ void Layers::copy(BaseDefinition* destination_) const
destination->clear();
destination->max_layer_count = max_layer_count;
destination->legacy_type = legacy_type;
null_layer->copy(destination->null_layer);
@ -44,6 +35,13 @@ void Layers::copy(BaseDefinition* destination_) const
}
}
Layers* Layers::newCopy() const
{
Layers* result = new Layers(NULL, layer_constructor);
copy(result);
return result;
}
void Layers::setMaxLayerCount(int max_layer_count)
{
this->max_layer_count = max_layer_count;
@ -133,129 +131,3 @@ void Layers::clear()
removeLayer(0);
}
}
// Transitional C-API
BaseDefinition* _legacyLayerConstructor(Layers* layers)
{
return new LegacyLayer(layers, &layers->legacy_type);
}
Layers* layersCreate(LayerType type, int max_layer_count)
{
Layers* result = new Layers(NULL, _legacyLayerConstructor, &type);
result->setMaxLayerCount(max_layer_count);
return result;
}
Layers* layersCreateCopy(Layers* original)
{
if (original->legacy_type.callback_create)
{
Layers* result = new Layers(NULL, _legacyLayerConstructor, &original->legacy_type);
original->copy(result);
return result;
}
else
{
Layers* result = new Layers(NULL, original->layer_constructor, NULL);
original->copy(result);
return result;
}
}
void layersDelete(Layers* layers)
{
delete layers;
}
void layersCopy(Layers* source, Layers* destination)
{
source->copy(destination);
}
void layersValidate(Layers* layers)
{
layers->validate();
}
void layersSave(PackStream* stream, Layers* layers)
{
layers->save(stream);
}
void layersLoad(PackStream* stream, Layers* layers)
{
layers->load(stream);
}
const char* layersGetName(Layers* layers, int layer)
{
if (layers->legacy_type.callback_create)
{
return ((LegacyLayer*)(layers->getLayer(layer)))->getLegacyName();
}
else
{
return "";
}
}
void layersSetName(Layers* layers, int layer, const char* name)
{
layers->getLayer(layer)->setName(name);
}
void layersClear(Layers* layers)
{
layers->clear();
}
int layersCount(Layers* layers)
{
return layers->count();
}
void* layersGetLayer(Layers* layers, int layer)
{
if (layers->legacy_type.callback_create)
{
LegacyLayer* legacy = (LegacyLayer*)(layers->getLayer(layer));
return legacy->getLegacyDefinition();
}
else
{
return layers->getLayer(layer);
}
}
int layersAddLayer(Layers* layers, void* definition)
{
if (layers->legacy_type.callback_create)
{
int position;
LegacyLayer* legacy = new LegacyLayer(layers, &layers->legacy_type);
if (definition)
{
layers->legacy_type.callback_copy(definition, legacy->getLegacyDefinition());
}
position = layers->addLayer(legacy);
return position;
}
else
{
BaseDefinition* copied = layers->layer_constructor(layers);
((BaseDefinition*)definition)->copy(copied);
return layers->addLayer(copied);
}
}
void layersDeleteLayer(Layers* layers, int layer)
{
layers->removeLayer(layer);
}
void layersMove(Layers* layers, int layer, int new_position)
{
layers->moveLayer(layer, new_position);
}

34
src/definition/Layers.h
View file

@ -2,15 +2,12 @@
#define LAYERS_H
#include "definition_global.h"
#include "BaseDefinition.h"
#include "LegacyLayer.h"
namespace paysages {
namespace system {class PackStream;}
namespace definition {
class Layers;
typedef BaseDefinition* (*LayerConstructor)(Layers* parent);
/**
@ -19,10 +16,11 @@ typedef BaseDefinition* (*LayerConstructor)(Layers* parent);
class DEFINITIONSHARED_EXPORT Layers:public BaseDefinition
{
public:
Layers(BaseDefinition* parent, LayerConstructor layer_constructor, LayerType* legacy_type=0);
Layers(BaseDefinition* parent, LayerConstructor layer_constructor);
virtual ~Layers();
virtual void copy(BaseDefinition* destination) const override;
Layers* newCopy() const;
void setMaxLayerCount(int max_layer_count);
@ -45,12 +43,8 @@ public:
void moveLayer(BaseDefinition* layer, int new_position);
void clear();
// Transitional data storage
LayerType legacy_type;
// TODO make private when there is no more legacy layer
LayerConstructor layer_constructor;
public:
LayerConstructor layer_constructor;
int max_layer_count;
QList<BaseDefinition*> layers;
BaseDefinition* null_layer;
@ -59,24 +53,4 @@ public:
}
}
DEFINITIONSHARED_EXPORT Layers* layersCreate(LayerType type, int max_layer_count);
DEFINITIONSHARED_EXPORT Layers* layersCreateCopy(Layers* original);
DEFINITIONSHARED_EXPORT void layersDelete(Layers* layers);
DEFINITIONSHARED_EXPORT void layersCopy(Layers* source, Layers* destination);
DEFINITIONSHARED_EXPORT void layersValidate(Layers* layers);
DEFINITIONSHARED_EXPORT void layersSave(PackStream* stream, Layers* layers);
DEFINITIONSHARED_EXPORT void layersLoad(PackStream* stream, Layers* layers);
DEFINITIONSHARED_EXPORT const char* layersGetName(Layers* layers, int layer);
DEFINITIONSHARED_EXPORT void layersSetName(Layers* layers, int layer, const char* name);
DEFINITIONSHARED_EXPORT void layersClear(Layers* layers);
DEFINITIONSHARED_EXPORT int layersCount(Layers* layers);
DEFINITIONSHARED_EXPORT void* layersGetLayer(Layers* layers, int layer);
DEFINITIONSHARED_EXPORT int layersAddLayer(Layers* layers, void* definition);
DEFINITIONSHARED_EXPORT void layersDeleteLayer(Layers* layers, int layer);
DEFINITIONSHARED_EXPORT void layersMove(Layers* layers, int layer, int new_position);
#endif // LAYERS_H

43
src/definition/LegacyLayer.cpp
View file

@ -1,43 +0,0 @@
#include "LegacyLayer.h"
LegacyLayer::LegacyLayer(BaseDefinition* parent, LayerType* type):
BaseDefinition(parent), type(*type)
{
legacy = type->callback_create();
setName(getName());
}
LegacyLayer::~LegacyLayer()
{
type.callback_delete(legacy);
}
void LegacyLayer::save(PackStream* pack) const
{
BaseDefinition::save(pack);
type.callback_save(pack, legacy);
}
void LegacyLayer::load(PackStream* pack)
{
BaseDefinition::load(pack);
type.callback_load(pack, legacy);
}
void LegacyLayer::copy(BaseDefinition* destination) const
{
BaseDefinition::copy(destination);
type.callback_copy(legacy, ((LegacyLayer*)destination)->legacy);
}
void LegacyLayer::validate()
{
BaseDefinition::validate();
type.callback_validate(legacy);
}
void LegacyLayer::setName(QString name)
{
BaseDefinition::setName(name);
qstrncpy(legacy_name, name.toUtf8().constData(), 99);
}

55
src/definition/LegacyLayer.h
View file

@ -1,55 +0,0 @@
#ifndef LEGACYLAYER_H
#define LEGACYLAYER_H
#include <BaseDefinition.h>
namespace paysages {
namespace system {class PackStream;}
namespace definition {
typedef void* (*LayerCallbackCreate)();
typedef void (*LayerCallbackDelete)(void* layer);
typedef void (*LayerCallbackCopy)(void* source, void* definition);
typedef void (*LayerCallbackValidate)(void* layer);
typedef void (*LayerCallbackSave)(PackStream* stream, void* layer);
typedef void (*LayerCallbackLoad)(PackStream* stream, void* layer);
typedef struct {
LayerCallbackCreate callback_create;
LayerCallbackDelete callback_delete;
LayerCallbackCopy callback_copy;
LayerCallbackValidate callback_validate;
LayerCallbackSave callback_save;
LayerCallbackLoad callback_load;
} LayerType;
/**
* @brief Wrapper around the old LayerType, used by C code.
*/
class LegacyLayer:public BaseDefinition
{
public:
LegacyLayer(BaseDefinition* parent, LayerType* type);
virtual ~LegacyLayer();
virtual void save(PackStream* pack) const;
virtual void load(PackStream* pack);
virtual void copy(BaseDefinition* destination) const;
virtual void validate();
virtual void setName(QString name);
inline void* getLegacyDefinition() { return legacy; }
inline char* getLegacyName() {return legacy_name;}
private:
LayerType type;
void* legacy;
char legacy_name[100];
};
}
}
#endif // LEGACYLAYER_H

154
src/definition/TextureLayerDefinition.cpp Normal file
View file

@ -0,0 +1,154 @@
#include "TextureLayerDefinition.h"
#include "Zone.h"
#include "NoiseGenerator.h"
#include "SurfaceMaterial.h"
#include "PackStream.h"
TextureLayerDefinition::TextureLayerDefinition(BaseDefinition* parent):
BaseDefinition(parent)
{
terrain_zone = new Zone;
_displacement_noise = new NoiseGenerator;
_detail_noise = new NoiseGenerator;
material = new SurfaceMaterial;
}
TextureLayerDefinition::~TextureLayerDefinition()
{
delete terrain_zone;
delete _displacement_noise;
delete _detail_noise;
delete material;
}
void TextureLayerDefinition::validate()
{
if (displacement_scaling < 0.000001)
{
displacement_scaling = 0.000001;
}
_displacement_noise->clearLevels();
_displacement_noise->addLevelsSimple(9, 1.0, -1.0, 1.0, 0.0);
_displacement_noise->normalizeAmplitude(-1.0, 1.0, 0);
_displacement_noise->validate();
_detail_noise->clearLevels();
_detail_noise->addLevelsSimple(7, 0.01, -1.0, 1.0, 0.0);
_detail_noise->normalizeAmplitude(-0.008, 0.008, 0);
_detail_noise->validate();
materialValidate(material);
/* Update zone height range */
// TODO
/*TerrainDefinition* terrain = Scenery::getCurrent()->getTerrain();
if (terrain)
{
HeightInfo height_info = terrainGetHeightInfo(terrain);
zoneSetRelativeHeight(terrain_zone, height_info.min_height, height_info.base_height, height_info.max_height);
}*/
}
void TextureLayerDefinition::copy(BaseDefinition *_destination) const
{
TextureLayerDefinition* destination = (TextureLayerDefinition*)_destination;
terrain_zone->copy(destination->terrain_zone);
destination->displacement_scaling = displacement_scaling;
destination->displacement_height = displacement_height;
destination->displacement_offset = displacement_offset;
*destination->material = *material;
_displacement_noise->copy(destination->_displacement_noise);
_detail_noise->copy(destination->_detail_noise);
}
void TextureLayerDefinition::save(PackStream* stream) const
{
terrain_zone->save(stream);
stream->write(&displacement_scaling);
stream->write(&displacement_height);
stream->write(&displacement_offset);
materialSave(stream, material);
_displacement_noise->save(stream);
_detail_noise->save(stream);
}
void TextureLayerDefinition::load(PackStream* stream)
{
terrain_zone->load(stream);
stream->read(&displacement_scaling);
stream->read(&displacement_height);
stream->read(&displacement_offset);
materialLoad(stream, material);
_displacement_noise->load(stream);
_detail_noise->load(stream);
}
void TextureLayerDefinition::applyPreset(TextureLayerPreset preset)
{
_displacement_noise->randomizeOffsets();
_detail_noise->randomizeOffsets();
terrain_zone->clear();
switch (preset)
{
case TEXTURES_LAYER_PRESET_MUD:
displacement_height = 0.05;
displacement_scaling = 3.0;
displacement_offset = 0.0;
material->base = colorToHSL(colorFromValues(0.4, 0.38, 0.35, 1.0));
material->reflection = 0.003;
material->shininess = 4.0;
break;
case TEXTURES_LAYER_PRESET_ROCK:
terrain_zone->addHeightRangeQuick(1.0, 0.5, 0.55, 1.0, 1.0);
displacement_height = 0.3;
displacement_scaling = 2.0;
displacement_offset = 0.0;
material->base = colorToHSL(colorFromValues(0.6, 0.55, 0.57, 1.0));
material->reflection = 0.006;
material->shininess = 6.0;
break;
case TEXTURES_LAYER_PRESET_GRASS:
terrain_zone->addHeightRangeQuick(1.0, 0.45, 0.5, 0.8, 1.0);
terrain_zone->addSlopeRangeQuick(1.0, 0.0, 0.0, 0.05, 0.4);
displacement_height = 0.0;
displacement_scaling = 1.0;
displacement_offset = 0.0;
material->base = colorToHSL(colorFromValues(0.12, 0.19, 0.035, 1.0));
material->reflection = 0.001;
material->shininess = 4.0;
break;
case TEXTURES_LAYER_PRESET_SAND:
terrain_zone->addHeightRangeQuick(1.0, 0.498, 0.502, 0.505, 0.51);
terrain_zone->addSlopeRangeQuick(1.0, 0.0, 0.0, 0.7, 0.1);
displacement_height = 0.02;
displacement_scaling = 5.0;
displacement_offset = 0.0;
material->base = colorToHSL(colorFromValues(0.93, 0.9, 0.8, 1.0));
material->reflection = 0.008;
material->shininess = 1.0;
break;
case TEXTURES_LAYER_PRESET_SNOW:
terrain_zone->addHeightRangeQuick(1.0, 0.77, 0.85, 1.0, 1.0);
terrain_zone->addSlopeRangeQuick(1.0, 0.0, 0.0, 0.2, 1.0);
displacement_height = 0.1;
displacement_scaling = 1.0;
displacement_offset = 0.0;
material->base = colorToHSL(colorFromValues(1.0, 1.0, 1.0, 1.0));
material->reflection = 0.25;
material->shininess = 0.6;
break;
default:
break;
}
validate();
}

60
src/definition/TextureLayerDefinition.h Normal file
View file

@ -0,0 +1,60 @@
#ifndef TEXTURELAYERDEFINITION_H
#define TEXTURELAYERDEFINITION_H
#include "definition_global.h"
#include "BaseDefinition.h"
namespace paysages {
namespace definition {
class DEFINITIONSHARED_EXPORT TextureLayerDefinition : public BaseDefinition
{
public:
typedef enum
{
TEXTURES_MERGE_FADE,
TEXTURES_MERGE_DISSOLVE,
TEXTURES_MERGE_DISPLACEMENT_VALUE
} TextureMergeMode;
typedef enum
{
TEXTURES_LAYER_PRESET_MUD,
TEXTURES_LAYER_PRESET_ROCK,
TEXTURES_LAYER_PRESET_GRASS,
TEXTURES_LAYER_PRESET_SAND,
TEXTURES_LAYER_PRESET_SNOW
} TextureLayerPreset;
public:
TextureLayerDefinition(BaseDefinition* parent);
virtual ~TextureLayerDefinition();
virtual void save(PackStream* stream) const override;
virtual void load(PackStream* stream) override;
virtual void copy(BaseDefinition* destination) const override;
virtual void validate() override;
void applyPreset(TextureLayerPreset preset);
public:
Zone* terrain_zone;
double displacement_scaling;
double displacement_height;
double displacement_offset;
/*double detail_scaling;
double detail_height;*/
SurfaceMaterial* material;
/*double cancel_displacement_factor;
TexturesMergeMode merge_mode;*/
NoiseGenerator* _displacement_noise;
NoiseGenerator* _detail_noise;
/*Curve* _local_slope_condition;*/
};
}
}
#endif // TEXTURELAYERDEFINITION_H

66
src/definition/TexturesDefinition.cpp Normal file
View file

@ -0,0 +1,66 @@
#include "TexturesDefinition.h"
#include "TextureLayerDefinition.h"
static BaseDefinition* _layer_constructor(Layers* parent)
{
return new TextureLayerDefinition(parent);
}
TexturesDefinition::TexturesDefinition(BaseDefinition *parent)
: Layers(parent, _layer_constructor)
{
}
void TexturesDefinition::applyPreset(TexturesPreset preset)
{
TextureLayerDefinition* layer;
clear();
layer = getTextureLayer(addLayer());
layer->applyPreset(TextureLayerDefinition::TEXTURES_LAYER_PRESET_MUD);
layer->setName("Mud");
if (preset == TEXTURES_PRESET_FULL)
{
layer = getTextureLayer(addLayer());
layer->applyPreset(TextureLayerDefinition::TEXTURES_LAYER_PRESET_ROCK);
layer->setName("Ground");
layer = getTextureLayer(addLayer());
layer->applyPreset(TextureLayerDefinition::TEXTURES_LAYER_PRESET_GRASS);
layer->setName("Grass");
layer = getTextureLayer(addLayer());
layer->applyPreset(TextureLayerDefinition::TEXTURES_LAYER_PRESET_SAND);
layer->setName("Sand");
layer = getTextureLayer(addLayer());
layer->applyPreset(TextureLayerDefinition::TEXTURES_LAYER_PRESET_SNOW);
layer->setName("Snow");
}
else if (preset == TEXTURES_PRESET_IRELAND)
{
layer = getTextureLayer(addLayer());
layer->applyPreset(TextureLayerDefinition::TEXTURES_LAYER_PRESET_ROCK);
layer->setName("Ground");
layer = getTextureLayer(addLayer());
layer->applyPreset(TextureLayerDefinition::TEXTURES_LAYER_PRESET_GRASS);
layer->setName("Grass");
}
else if (preset == TEXTURES_PRESET_ALPS)
{
layer = getTextureLayer(addLayer());
layer->applyPreset(TextureLayerDefinition::TEXTURES_LAYER_PRESET_ROCK);
layer->setName("Ground");
layer = getTextureLayer(addLayer());
layer->applyPreset(TextureLayerDefinition::TEXTURES_LAYER_PRESET_SNOW);
layer->setName("Snow");
}
else if (preset == TEXTURES_PRESET_CANYON)
{
/* TODO */
}
}

31
src/definition/TexturesDefinition.h Normal file
View file

@ -0,0 +1,31 @@
#ifndef TEXTURESDEFINITION_H
#define TEXTURESDEFINITION_H
#include "definition_global.h"
#include "Layers.h"
namespace paysages {
namespace definition {
class DEFINITIONSHARED_EXPORT TexturesDefinition : public Layers
{
public:
TexturesDefinition(BaseDefinition *parent);
inline TextureLayerDefinition* getTextureLayer(int position) const {return (TextureLayerDefinition*)getLayer(position);}
typedef enum
{
TEXTURES_PRESET_FULL,
TEXTURES_PRESET_IRELAND,
TEXTURES_PRESET_ALPS,
TEXTURES_PRESET_CANYON
} TexturesPreset;
void applyPreset(TexturesPreset preset);
};
}
}
#endif // TEXTURESDEFINITION_H

278
src/definition/Zone.cpp Normal file
View file

@ -0,0 +1,278 @@
#include "Zone.h"
#include "Curve.h"
#include "PackStream.h"
#include "Vector3.h"
#define MAX_CIRCLES 10
namespace paysages {
namespace definition {
class Circle
{
public:
double value;
double centerx;
double centerz;
double softradius;
double hardradius;
};
}
}
Zone::Zone(BaseDefinition *parent):
BaseDefinition(parent)
{
value_by_height = new Curve;
absolute_height = 1;
value_by_height->setDefault(1.0);
value_by_slope = new Curve;
value_by_slope->setDefault(1.0);
circles_included_count = 0;
circles_included = new Circle[MAX_CIRCLES];
}
Zone::~Zone()
{
delete value_by_height;
delete value_by_slope;
delete circles_included;
}
void Zone::save(PackStream* stream) const
{
int i;
stream->write(&absolute_height);
stream->write(&relative_height_min);
stream->write(&relative_height_middle);
stream->write(&relative_height_max);
value_by_height->save(stream);
value_by_slope->save(stream);
stream->write(&circles_included_count);
for (i = 0; i < circles_included_count; i++)
{
stream->write(&circles_included[i].value);
stream->write(&circles_included[i].centerx);
stream->write(&circles_included[i].centerz);
stream->write(&circles_included[i].softradius);
stream->write(&circles_included[i].hardradius);
}
}
void Zone::load(PackStream* stream)
{
int i;
stream->read(&absolute_height);
stream->read(&relative_height_min);
stream->read(&relative_height_middle);
stream->read(&relative_height_max);
value_by_height->load(stream);
value_by_slope->load(stream);
stream->read(&circles_included_count);
for (i = 0; i < circles_included_count; i++)
{
stream->read(&circles_included[i].value);
stream->read(&circles_included[i].centerx);
stream->read(&circles_included[i].centerz);
stream->read(&circles_included[i].softradius);
stream->read(&circles_included[i].hardradius);
}
}
void Zone::copy(BaseDefinition* _destination) const
{
Zone* destination = (Zone*)_destination;
destination->absolute_height = absolute_height;
destination->relative_height_min = relative_height_min;
destination->relative_height_middle = relative_height_middle;
destination->relative_height_max = relative_height_max;
value_by_height->copy(destination->value_by_height);
value_by_slope->copy(destination->value_by_slope);
memcpy(destination->circles_included, circles_included, sizeof(Circle) * circles_included_count);
destination->circles_included_count = circles_included_count;
}
void Zone::clear()
{
value_by_height->clear();
value_by_slope->clear();
circles_included_count = 0;
}
void Zone::setAbsoluteHeight()
{
absolute_height = 1;
}
void Zone::setRelativeHeight(double min, double middle, double max)
{
if (max < min)
{
max = min;
}
if (middle < min)
{
middle = min;
}
if (middle > max)
{
middle = max;
}
absolute_height = 0;
relative_height_min = min;
relative_height_middle = middle;
relative_height_max = max;
}
void Zone::includeCircleArea(double value, double centerx, double centerz, double softradius, double hardradius)
{
Circle circle = {value, centerx, centerz, softradius, hardradius};
if (circles_included_count < MAX_CIRCLES)
{
circles_included[circles_included_count++] = circle;
}
}
void Zone::getHeightCurve(Curve* curve) const
{
value_by_height->copy(curve);
}
void Zone::setHeightCurve(Curve* curve)
{
curve->copy(value_by_height);
}
void Zone::addHeightRangeQuick(double value, double hardmin, double softmin, double softmax, double hardmax)
{
value_by_height->addPoint(hardmin, 0.0);
value_by_height->addPoint(softmin, value);
value_by_height->addPoint(softmax, value);
value_by_height->addPoint(hardmax, 0.0);
}
void Zone::getSlopeCurve(Curve* curve) const
{
value_by_slope->copy(curve);
}
void Zone::setSlopeCurve(Curve* curve)
{
curve->copy(value_by_slope);
}
void Zone::addSlopeRangeQuick(double value, double hardmin, double softmin, double softmax, double hardmax)
{
value_by_slope->addPoint(hardmin, 0.0);
value_by_slope->addPoint(softmin, value);
value_by_slope->addPoint(softmax, value);
value_by_slope->addPoint(hardmax, 0.0);
}
static inline double _getCircleInfluence(const Circle &circle, const Vector3 &position)
{
double radius, dx, dz;
dx = position.x - circle.centerx;
dz = position.z - circle.centerz;
radius = sqrt(dx * dx + dz * dz);
if (radius > circle.hardradius)
{
return 0.0;
}
else if (radius < circle.softradius)
{
return circle.value;
}
else
{
return circle.value * (circle.hardradius - radius) / (circle.hardradius - circle.softradius);
}
}
double Zone::getValue(const Vector3 &location, const Vector3 &normal) const
{
int i;
double final_height;
double value, value_height, value_steepness, value_circle;
if (circles_included_count > 0)
{
value_circle = 0.0;
for (i = 0; i < circles_included_count; i++)
{
value = _getCircleInfluence(circles_included[i], location);
if (value > value_circle)
{
value_circle = value;
}
}
}
else
{
value_circle = 1.0;
}
if (absolute_height)
{
final_height = location.y;
}
else
{
if (location.y >= relative_height_max)
{
final_height = 1.0;
}
else if (location.y <= relative_height_min)
{
final_height = 0.0;
}
else if (location.y <= relative_height_middle)
{
final_height = 0.5 * (location.y - relative_height_min) / (relative_height_middle - relative_height_min);
}
else
{
final_height = 0.5 + 0.5 * (location.y - relative_height_middle) / (relative_height_max - relative_height_middle);
}
}
value_height = value_by_height->getValue(final_height);
value_steepness = value_by_slope->getValue(1.0 - normal.y);
if (value_steepness < value_height)
{
if (value_circle < value_steepness)
{
return value_circle;
}
else
{
return value_steepness;
}
}
else
{
if (value_circle < value_height)
{
return value_circle;
}
else
{
return value_height;
}
}
}

58
src/definition/Zone.h Normal file
View file

@ -0,0 +1,58 @@
#ifndef ZONE_H
#define ZONE_H
#include "definition_global.h"
#include "BaseDefinition.h"
namespace paysages {
namespace definition {
class Circle;
class DEFINITIONSHARED_EXPORT Zone : public BaseDefinition
{
public:
Zone(BaseDefinition *parent = 0);
virtual ~Zone();
virtual void save(PackStream* stream) const override;
virtual void load(PackStream* stream) override;
virtual void copy(BaseDefinition* destination) const override;
void clear();
void setAbsoluteHeight();
void setRelativeHeight(double min, double middle, double max);
void includeCircleArea(double value, double centerx, double centerz, double softradius, double hardradius);
void excludeCircleArea(double centerx, double centerz, double softradius, double hardradius);
void getHeightCurve(Curve* curve) const;
void setHeightCurve(Curve* curve);
void addHeightRangeQuick(double value, double hardmin, double softmin, double softmax, double hardmax);
void getSlopeCurve(Curve* curve) const;
void setSlopeCurve(Curve* curve);
void addSlopeRangeQuick(double value, double hardmin, double softmin, double softmax, double hardmax);
double getValue(const Vector3 &location, const Vector3 &normal) const;
private:
int absolute_height;
double relative_height_min;
double relative_height_middle;
double relative_height_max;
Curve* value_by_height;
Curve* value_by_slope;
Circle* circles_included;
int circles_included_count;
};
}
}
#endif // ZONE_H

12
src/definition/definition.pro
View file

@ -16,25 +16,29 @@ include(../common.pri)
SOURCES += \
BaseDefinition.cpp \
Layers.cpp \
LegacyLayer.cpp \
WaterDefinition.cpp \
SurfaceMaterial.cpp \
CameraDefinition.cpp \
CloudsDefinition.cpp \
CloudLayerDefinition.cpp \
AtmosphereDefinition.cpp
AtmosphereDefinition.cpp \
TexturesDefinition.cpp \
TextureLayerDefinition.cpp \
Zone.cpp
HEADERS +=\
definition_global.h \
BaseDefinition.h \
Layers.h \
LegacyLayer.h \
WaterDefinition.h \
SurfaceMaterial.h \
CameraDefinition.h \
CloudsDefinition.h \
CloudLayerDefinition.h \
AtmosphereDefinition.h
AtmosphereDefinition.h \
TexturesDefinition.h \
TextureLayerDefinition.h \
Zone.h
unix:!symbian {
maemo5 {

3
src/definition/definition_global.h
View file

@ -15,11 +15,14 @@ namespace definition {
class BaseDefinition;
class CameraDefinition;
class SurfaceMaterial;
class Zone;
class WaterDefinition;
class Layers;
class CloudsDefinition;
class CloudLayerDefinition;
class AtmosphereDefinition;
class TexturesDefinition;
class TextureLayerDefinition;
}
}
using namespace paysages::definition;

35
src/interface/desktop/baseformlayer.cpp
View file

@ -1,6 +1,7 @@
#include "baseformlayer.h"
#include <QInputDialog>
#include "Layers.h"
BaseFormLayer::BaseFormLayer(QWidget* parent, Layers* layers) : BaseForm(parent, false, true)
{
@ -9,7 +10,7 @@ BaseFormLayer::BaseFormLayer(QWidget* parent, Layers* layers) : BaseForm(parent,
if (layers)
{
_layers_original = layers;
_layers_modified = layersCreateCopy(_layers_original);
_layers_modified = _layers_original->newCopy();
}
}
@ -17,7 +18,7 @@ BaseFormLayer::~BaseFormLayer()
{
if (_layers_modified)
{
layersDelete(_layers_modified);
delete _layers_modified;
}
}
@ -25,7 +26,7 @@ void BaseFormLayer::revertConfig()
{
if (_layers_original && _layers_modified)
{
layersCopy(_layers_original, _layers_modified);
_layers_original->copy(_layers_modified);
layerSelectedEvent(currentLayer());
}
@ -36,7 +37,7 @@ void BaseFormLayer::applyConfig()
{
if (_layers_original && _layers_modified)
{
layersCopy(_layers_modified, _layers_original);
_layers_modified->copy(_layers_original);
}
BaseForm::applyConfig();
@ -47,9 +48,9 @@ void BaseFormLayer::setLayers(Layers* layers)
_layers_original = layers;
if (_layers_modified)
{
layersDelete(_layers_modified);
delete _layers_modified;
}
_layers_modified = layersCreateCopy(_layers_original);
_layers_modified = _layers_original->newCopy();
revertConfig();
}
@ -61,8 +62,8 @@ void BaseFormLayer::configChangeEvent()
{
if (_layers_modified)
{
layerWriteCurrentTo(layersGetLayer(_layers_modified, currentLayer()));
layersValidate(_layers_modified);
layerWriteCurrentTo(_layers_modified->getLayer(currentLayer()));
_layers_modified->validate();
}
BaseForm::configChangeEvent();
@ -74,9 +75,9 @@ QStringList BaseFormLayer::getLayers()
if (_layers_modified)
{
for (int i = 0; i < layersCount(_layers_modified); i++)
for (int i = 0; i < _layers_modified->count(); i++)
{
result << QString::fromUtf8(layersGetName(_layers_modified, i));
result << _layers_modified->getLayer(i)->getName();
}
}
@ -90,14 +91,14 @@ void BaseFormLayer::layerAddedEvent()
QString layer_name = QInputDialog::getText(this, tr("Create layer"), tr("Layer name :"), QLineEdit::Normal, tr("Unnamed layer"));
if (not layer_name.isEmpty())
{
int layer = layersAddLayer(_layers_modified, NULL);
int layer = _layers_modified->addLayer();
if (layer >= 0)
{
layersSetName(_layers_modified, layer, layer_name.toUtf8().data());
_layers_modified->getLayer(layer)->setName(layer_name);
BaseForm::layerAddedEvent();
afterLayerAdded(layersGetLayer(_layers_modified, layer));
afterLayerAdded(_layers_modified->getLayer(layer));
}
}
}
@ -107,7 +108,7 @@ void BaseFormLayer::layerDeletedEvent(int layer)
{
if (_layers_modified)
{
layersDeleteLayer(_layers_modified, layer);
_layers_modified->removeLayer(layer);
}
BaseForm::layerDeletedEvent(layer);
@ -117,7 +118,7 @@ void BaseFormLayer::layerMovedEvent(int layer, int new_position)
{
if (_layers_modified)
{
layersMove(_layers_modified, layer, new_position);
_layers_modified->moveLayer(layer, new_position);
}
BaseForm::layerMovedEvent(layer, new_position);
@ -127,7 +128,7 @@ void BaseFormLayer::layerRenamedEvent(int layer, QString new_name)
{
if (_layers_modified)
{
layersSetName(_layers_modified, layer, new_name.toUtf8().data());
_layers_modified->getLayer(layer)->setName(new_name);
}
BaseForm::layerRenamedEvent(layer, new_name);
@ -137,7 +138,7 @@ void BaseFormLayer::layerSelectedEvent(int layer)
{
if (_layers_modified && layer >= 0)
{
layerReadCurrentFrom(layersGetLayer(_layers_modified, layer));
layerReadCurrentFrom(_layers_modified->getLayer(layer));
}
BaseForm::layerSelectedEvent(layer);

16
src/interface/desktop/common/freelayerhelper.cpp
View file

@ -23,7 +23,7 @@ void FreeLayerHelper::refreshLayers()
emit tableUpdateNeeded();
int n = layersCount(_layers);
int n = _layers->count();
if (n == 0)
{
_selected = -1;
@ -96,7 +96,7 @@ void FreeLayerHelper::setEditButton(QPushButton* button)
void FreeLayerHelper::addLayer()
{
_selected = layersAddLayer(_layers, NULL);
_selected = _layers->addLayer(NULL);
emit(layersChanged());
refreshLayers();
}
@ -105,7 +105,7 @@ void FreeLayerHelper::deleteLayer()
{
if (_selected >= 0)
{
layersDeleteLayer(_layers, _selected);
_layers->removeLayer(_selected);
emit(layersChanged());
refreshLayers();
}
@ -115,7 +115,7 @@ void FreeLayerHelper::moveLayerDown()
{
if (_selected > 0)
{
layersMove(_layers, _selected, _selected - 1);
_layers->moveLayer(_selected, _selected - 1);
_selected--;
emit(layersChanged());
refreshLayers();
@ -124,9 +124,9 @@ void FreeLayerHelper::moveLayerDown()
void FreeLayerHelper::moveLayerUp()
{
if (_selected >= 0 && _selected < layersCount(_layers) - 1)
if (_selected >= 0 && _selected < _layers->count() - 1)
{
layersMove(_layers, _selected, _selected + 1);
_layers->moveLayer(_selected, _selected + 1);
_selected++;
emit(layersChanged());
refreshLayers();
@ -135,7 +135,7 @@ void FreeLayerHelper::moveLayerUp()
void FreeLayerHelper::startEditing()
{
if (_selected >= 0 && _selected < layersCount(_layers))
if (_selected >= 0 && _selected < _layers->count())
{
emit(editRequired(_selected));
}
@ -143,7 +143,7 @@ void FreeLayerHelper::startEditing()
void FreeLayerHelper::tableSelectionChanged(int row, int)
{
int n = layersCount(_layers);
int n = _layers->count();
if (n == 0 or row >= n)
{

31
src/interface/desktop/formtextures.cpp
View file

@ -5,13 +5,16 @@
#include "renderer.h"
#include "tools.h"
#include "CameraDefinition.h"
#include "TexturesDefinition.h"
#include "TextureLayerDefinition.h"
#include "terrain/public.h"
/**************** Previews ****************/
class PreviewTexturesCoverage : public BasePreview
{
public:
PreviewTexturesCoverage(QWidget* parent, TexturesLayerDefinition* layer) : BasePreview(parent)
PreviewTexturesCoverage(QWidget* parent, TextureLayerDefinition* layer) : BasePreview(parent)
{
_renderer = rendererCreate();
_renderer->render_quality = 3;
@ -51,7 +54,7 @@ protected:
private:
Renderer* _renderer;
TexturesLayerDefinition* _original_layer;
TextureLayerDefinition* _original_layer;
TexturesDefinition* _preview_definition;
};
@ -59,7 +62,7 @@ class PreviewTexturesColor : public BasePreview
{
public:
PreviewTexturesColor(QWidget* parent, TexturesLayerDefinition* layer) : BasePreview(parent)
PreviewTexturesColor(QWidget* parent, TextureLayerDefinition* layer) : BasePreview(parent)
{
_original_layer = layer;
//_preview_layer = (TexturesLayerDefinition*)TexturesDefinitionClass.create();
@ -95,8 +98,8 @@ protected:
}
private:
Renderer* _renderer;
TexturesLayerDefinition* _original_layer;
TexturesLayerDefinition* _preview_layer;
TextureLayerDefinition* _original_layer;
TextureLayerDefinition* _preview_layer;
};
/**************** Form ****************/
@ -108,8 +111,8 @@ BaseFormLayer(parent)
addAutoPreset(tr("Sand"));
addAutoPreset(tr("Snow"));
_definition = (TexturesDefinition*) TexturesDefinitionClass.create();
_layer = (TexturesLayerDefinition*) texturesGetLayerType().callback_create();
_definition = new TexturesDefinition(NULL);
_layer = new TextureLayerDefinition(NULL);
_previewCoverage = new PreviewTexturesCoverage(this, _layer);
_previewColor = new PreviewTexturesColor(this, _layer);
@ -118,7 +121,7 @@ BaseFormLayer(parent)
addInputDouble(tr("Displacement height"), &_layer->displacement_height, 0.0, 0.1, 0.001, 0.01);
addInputDouble(tr("Displacement scaling"), &_layer->displacement_scaling, 0.003, 0.3, 0.003, 0.03);
addInputMaterial(tr("Material"), &_layer->material);
addInputMaterial(tr("Material"), _layer->material);
/*addInputCurve(tr("Coverage by altitude"), _layer->terrain_zone->value_by_height, -20.0, 20.0, 0.0, 1.0, tr("Terrain altitude"), tr("Texture coverage"));
addInputCurve(tr("Coverage by slope"), _layer->terrain_zone->value_by_slope, 0.0, 5.0, 0.0, 1.0, tr("Terrain slope"), tr("Texture coverage"));*/
@ -126,13 +129,13 @@ BaseFormLayer(parent)
addInputDouble(tr("Layer thickness"), &_layer->thickness, 0.0, 0.1, 0.001, 0.01);
addInputDouble(tr("Transparency thickness"), &_layer->thickness_transparency, 0.0, 0.1, 0.001, 0.01);*/
setLayers(_definition->layers);
setLayers(_definition);
}
FormTextures::~FormTextures()
{
TexturesDefinitionClass.destroy(_definition);
texturesGetLayerType().callback_delete(_layer);
delete _definition;
delete _layer;
}
void FormTextures::revertConfig()
@ -149,16 +152,16 @@ void FormTextures::applyConfig()
void FormTextures::layerReadCurrentFrom(void* layer_definition)
{
texturesGetLayerType().callback_copy((TexturesLayerDefinition*) layer_definition, _layer);
((TextureLayerDefinition*)layer_definition)->copy(_layer);
}
void FormTextures::layerWriteCurrentTo(void* layer_definition)
{
texturesGetLayerType().callback_copy(_layer, (TexturesLayerDefinition*) layer_definition);
_layer->copy((TextureLayerDefinition*)layer_definition);
}
void FormTextures::autoPresetSelected(int preset)
{
texturesLayerAutoPreset(_layer, (TexturesLayerPreset) preset);
_layer->applyPreset((TextureLayerDefinition::TextureLayerPreset)preset);
BaseForm::autoPresetSelected(preset);
}

4
src/interface/desktop/formtextures.h
View file

@ -4,7 +4,7 @@
#include "desktop_global.h"
#include "baseformlayer.h"
#include "textures/public.h"
class QWidget;
class FormTextures : public BaseFormLayer
@ -26,7 +26,7 @@ protected:
private:
TexturesDefinition* _definition;
TexturesLayerDefinition* _layer;
TextureLayerDefinition* _layer;
BasePreview* _previewCoverage;
BasePreview* _previewColor;
};

2
src/interface/desktop/inputlayers.cpp
View file

@ -19,7 +19,7 @@ InputLayers::InputLayers(QWidget* form, QString label, Layers* value, FormLayerB
void InputLayers::updatePreview()
{
((QLabel*)_preview)->setText(tr("%1 layers").arg(layersCount(_value)));
((QLabel*)_preview)->setText(tr("%1 layers").arg(_value->count()));
BaseInput::updatePreview();
}

6
src/interface/desktop/textures/DialogTexturesLayer.cpp
View file

@ -1,6 +1,8 @@
#include "DialogTexturesLayer.h"
#include "ui_DialogTexturesLayer.h"
#include "TexturesDefinition.h"
DialogTexturesLayer::DialogTexturesLayer(QWidget* parent, TexturesDefinition* textures, int layer) :
QDialog(parent),
ui(new Ui::DialogTexturesLayer)
@ -9,12 +11,12 @@ DialogTexturesLayer::DialogTexturesLayer(QWidget* parent, TexturesDefinition* te
this->layer = layer;
original = textures;
modified = (TexturesDefinition*)TexturesDefinitionClass.create();
modified = new TexturesDefinition(NULL);
}
DialogTexturesLayer::~DialogTexturesLayer()
{
delete ui;
TexturesDefinitionClass.destroy(modified);
delete modified;
}

3
src/interface/desktop/textures/DialogTexturesLayer.h
View file

@ -1,8 +1,9 @@
#ifndef DIALOGTEXTURESLAYER_H
#define DIALOGTEXTURESLAYER_H
#include "desktop_global.h"
#include <QDialog>
#include "textures/public.h"
namespace Ui {
class DialogTexturesLayer;

2
src/interface/desktop/textures/PreviewCumul.h
View file

@ -5,8 +5,6 @@
#include "Base2dPreviewRenderer.h"
class TexturesDefinition;
class PreviewCumul : public Base2dPreviewRenderer
{
public:

2
src/interface/desktop/textures/PreviewLayerCoverage.h
View file

@ -5,8 +5,6 @@
#include "Base2dPreviewRenderer.h"
class TexturesDefinition;
class PreviewLayerCoverage : public Base2dPreviewRenderer
{
public:

2
src/interface/desktop/textures/PreviewLayerLook.h
View file

@ -5,8 +5,6 @@
#include "Base2dPreviewRenderer.h"
class TexturesDefinition;
class PreviewLayerLook : public Base2dPreviewRenderer
{
public:

17
src/interface/desktop/textures/maintexturesform.cpp
View file

@ -4,19 +4,22 @@
#include "../common/freeformhelper.h"
#include "../common/freelayerhelper.h"
#include "Scenery.h"
#include "TexturesDefinition.h"
#include "TextureLayerDefinition.h"
#include "previewmaterial.h"
#include "textures/PreviewLayerCoverage.h"
#include "textures/PreviewLayerLook.h"
#include "textures/PreviewCumul.h"
#include "textures/DialogTexturesLayer.h"
#include "textures/public.h"
MainTexturesForm::MainTexturesForm(QWidget *parent) : QWidget(parent), ui(new Ui::MainTexturesForm)
{
textures = (TexturesDefinition*) TexturesDefinitionClass.create();
textures = new TexturesDefinition(NULL);
ui->setupUi(this);
layer_helper = new FreeLayerHelper(textures->layers, true);
layer_helper = new FreeLayerHelper(textures, true);
layer_helper->setLayerTable(ui->layersGrid);
layer_helper->setAddButton(ui->layer_add);
layer_helper->setDelButton(ui->layer_del);
@ -69,23 +72,23 @@ void MainTexturesForm::updateLayers()
ui->layersGrid->clearContents();
n = layersCount(textures->layers);
n = textures->count();
ui->layersGrid->setRowCount(n);
for (i = 0; i < n; i++)
{
QTableWidgetItem* item;
TexturesLayerDefinition* layer = (TexturesLayerDefinition*) layersGetLayer(textures->layers, i);
TextureLayerDefinition* layer = textures->getTextureLayer(i);
item = new QTableWidgetItem(QString("%1").arg(i + 1));
item->setFlags(Qt::ItemIsSelectable | Qt::ItemIsEnabled);
ui->layersGrid->setItem(n - 1 - i, 0, item);
item = new QTableWidgetItem(QString(layersGetName(textures->layers, i)));
item = new QTableWidgetItem(layer->getName());
item->setFlags(Qt::ItemIsSelectable | Qt::ItemIsEnabled);
ui->layersGrid->setItem(n - 1 - i, 1, item);
QWidget* widget = new SmallMaterialPreview(ui->layersGrid, &layer->material);
QWidget* widget = new SmallMaterialPreview(ui->layersGrid, layer->material);
//widget->setMinimumSize(50, 50);
ui->layersGrid->setCellWidget(n - 1 - i, 2, widget);
@ -125,7 +128,7 @@ void MainTexturesForm::editLayer(int layer)
void MainTexturesForm::selectPreset(int preset)
{
texturesAutoPreset(textures, (TexturesPreset)preset);
textures->applyPreset((TexturesDefinition::TexturesPreset)preset);
}
void MainTexturesForm::updateLocalDataFromScenery()

4
src/interface/desktop/textures/maintexturesform.h
View file

@ -1,8 +1,9 @@
#ifndef MAINTEXTURESFORM_H
#define MAINTEXTURESFORM_H
#include "desktop_global.h"
#include <QWidget>
#include "textures/public.h"
namespace Ui {
class MainTexturesForm;
@ -13,6 +14,7 @@ class FreeLayerHelper;
class PreviewLayerCoverage;
class PreviewLayerLook;
class PreviewCumul;
class Renderer;
class MainTexturesForm : public QWidget
{

23
src/rendering/Scenery.cpp
View file

@ -5,14 +5,15 @@
#include "NoiseGenerator.h"
#include "PackStream.h"
#include "atmosphere/public.h"
#include "CameraDefinition.h"
#include "CloudsDefinition.h"
#include "terrain/public.h"
#include "textures/public.h"
#include "renderer.h"
#include "terrain/ter_raster.h"
#include "WaterDefinition.h"
#include "AtmosphereDefinition.h"
#include "CameraDefinition.h"
#include "CloudsDefinition.h"
#include "TexturesDefinition.h"
#include "WaterDefinition.h"
static Scenery _main_scenery;
@ -23,13 +24,14 @@ Scenery::Scenery():
camera = new CameraDefinition;
clouds = new CloudsDefinition(this);
terrain = (TerrainDefinition*)TerrainDefinitionClass.create();
textures = (TexturesDefinition*)TexturesDefinitionClass.create();
textures = new TexturesDefinition(this);
water = new WaterDefinition(this);
addChild(camera);
addChild(atmosphere);
addChild(water);
addChild(camera);
addChild(clouds);
addChild(textures);
addChild(water);
_custom_load = NULL;
_custom_save = NULL;
@ -39,7 +41,6 @@ Scenery::Scenery():
Scenery::~Scenery()
{
TerrainDefinitionClass.destroy(terrain);
TexturesDefinitionClass.destroy(textures);
}
Scenery* Scenery::getCurrent()
@ -61,7 +62,6 @@ void Scenery::save(PackStream* stream) const
noiseSave(stream);
TerrainDefinitionClass.save(stream, terrain);
TexturesDefinitionClass.save(stream, textures);
if (_custom_save)
{
@ -76,7 +76,6 @@ void Scenery::load(PackStream* stream)
noiseLoad(stream);
TerrainDefinitionClass.load(stream, terrain);
TexturesDefinitionClass.load(stream, textures);
if (_custom_load)
{
@ -102,7 +101,7 @@ void Scenery::autoPreset(int seed)
srand(seed);
terrainAutoPreset(terrain, TERRAIN_PRESET_STANDARD);
texturesAutoPreset(textures, TEXTURES_PRESET_FULL);
textures->applyPreset(TexturesDefinition::TEXTURES_PRESET_FULL);
atmosphere->applyPreset(AtmosphereDefinition::ATMOSPHERE_PRESET_CLEAR_DAY);
water->applyPreset(WATER_PRESET_LAKE);
clouds->applyPreset(CloudsDefinition::CLOUDS_PRESET_PARTLY_CLOUDY);
@ -156,12 +155,12 @@ void Scenery::getTerrain(TerrainDefinition* terrain)
void Scenery::setTextures(TexturesDefinition* textures)
{
TexturesDefinitionClass.copy(textures, this->textures);
textures->copy(this->textures);
}
void Scenery::getTextures(TexturesDefinition* textures)
{
TexturesDefinitionClass.copy(this->textures, textures);
this->textures->copy(textures);
}
void Scenery::setWater(WaterDefinition* water)

1
src/rendering/Scenery.h
View file

@ -6,7 +6,6 @@
#include "BaseDefinition.h"
class TerrainDefinition;
class TexturesDefinition;
class Renderer;
typedef void (*SceneryCustomDataCallback)(PackStream* stream, void* data);

4
src/rendering/rendering.pro
View file

@ -30,9 +30,6 @@ SOURCES += main.cpp \
textures/tex_tools.cpp \
textures/tex_rendering.cpp \
textures/tex_preview.cpp \
textures/tex_presets.cpp \
textures/tex_definition.cpp \
tools/zone.cpp \
tools/texture.cpp \
tools/parallel.cpp \
tools/memory.cpp \
@ -68,7 +65,6 @@ HEADERS += \
textures/tex_preview.h \
textures/public.h \
textures/private.h \
tools/zone.h \
tools/texture.h \
tools/parallel.h \
tools/memory.h \

23
src/rendering/terrain/ter_preview.cpp
View file

@ -6,6 +6,9 @@
#include "NoiseGenerator.h"
#include "atmosphere/public.h"
#include "textures/public.h"
#include "TextureLayerDefinition.h"
#include "TexturesDefinition.h"
#include "Zone.h"
/*
* Terrain previews.
@ -57,21 +60,17 @@ void terrainAlterPreviewRenderer(Renderer* renderer)
renderer->getCameraLocation = _getCameraLocation;
renderer->atmosphere->getLightingStatus = _getLightingStatus;
TexturesDefinition* textures;
textures = (TexturesDefinition*)TexturesDefinitionClass.create();
layersClear(textures->layers);
TexturesLayerDefinition* layer = (TexturesLayerDefinition*)layersGetLayer(textures->layers, layersAddLayer(textures->layers, NULL));
zoneClear(layer->terrain_zone);
TexturesDefinition textures(NULL);
TextureLayerDefinition* layer = textures.getTextureLayer(textures.addLayer());
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;
TexturesDefinitionClass.validate(textures);
layer->material->base = colorToHSL(COLOR_WHITE);
layer->material->reflection = 0.05;
layer->material->shininess = 2.0;
layer->validate();
layer->_detail_noise->clearLevels();
TexturesRendererClass.bind(renderer, textures);
TexturesDefinitionClass.destroy(textures);
TexturesRendererClass.bind(renderer, &textures);
}
Color terrainGetPreviewColor(Renderer* renderer, double x, double z, double detail)

2
src/rendering/textures/private.h
View file

@ -6,7 +6,7 @@
/*
* Get the base presence factor of a layer, not accounting for other layers.
*/
double texturesGetLayerBasePresence(TexturesLayerDefinition* layer, TerrainResult terrain);
double texturesGetLayerBasePresence(TextureLayerDefinition* layer, TerrainResult terrain);
/*
* Get triplanar noise value, depending on the normal direction.

56
src/rendering/textures/public.h
View file

@ -3,63 +3,15 @@
#include "../rendering_global.h"
#include "Layers.h"
#include "tools/zone.h"
#include "tools/lighting.h"
#include "terrain/public.h"
#include "SurfaceMaterial.h"
#define TEXTURES_MAX_LAYERS 50
typedef enum
{
TEXTURES_PRESET_FULL,
TEXTURES_PRESET_IRELAND,
TEXTURES_PRESET_ALPS,
TEXTURES_PRESET_CANYON
} TexturesPreset;
typedef enum
{
TEXTURES_LAYER_PRESET_MUD,
TEXTURES_LAYER_PRESET_ROCK,
TEXTURES_LAYER_PRESET_GRASS,
TEXTURES_LAYER_PRESET_SAND,
TEXTURES_LAYER_PRESET_SNOW
} TexturesLayerPreset;
typedef enum
{
TEXTURES_MERGE_FADE,
TEXTURES_MERGE_DISSOLVE,
TEXTURES_MERGE_DISPLACEMENT_VALUE
} TexturesMergeMode;
typedef struct
{
Zone* terrain_zone;
double displacement_scaling;
double displacement_height;
double displacement_offset;
/*double detail_scaling;
double detail_height;*/
SurfaceMaterial material;
/*double cancel_displacement_factor;
TexturesMergeMode merge_mode;*/
NoiseGenerator* _displacement_noise;
NoiseGenerator* _detail_noise;
/*Curve* _local_slope_condition;*/
} TexturesLayerDefinition;
class TexturesDefinition
{
public:
Layers* layers;
};
typedef struct
{
TexturesLayerDefinition* layer;
TextureLayerDefinition* layer;
double presence;
Color color;
} TexturesLayerResult;
@ -89,14 +41,8 @@ public:
};
RENDERINGSHARED_EXPORT extern StandardDefinition TexturesDefinitionClass;
RENDERINGSHARED_EXPORT extern StandardRenderer TexturesRendererClass;
RENDERINGSHARED_EXPORT LayerType texturesGetLayerType();
RENDERINGSHARED_EXPORT void texturesAutoPreset(TexturesDefinition* definition, TexturesPreset preset);
RENDERINGSHARED_EXPORT void texturesLayerAutoPreset(TexturesLayerDefinition* definition, TexturesLayerPreset preset);
RENDERINGSHARED_EXPORT double texturesGetMaximalDisplacement(TexturesDefinition* textures);
#endif

155
src/rendering/textures/tex_definition.cpp
View file

@ -1,155 +0,0 @@
#include "private.h"
#include "Scenery.h"
#include "NoiseGenerator.h"
#include "PackStream.h"
/******************** Global definition ********************/
static void _validateDefinition(TexturesDefinition* definition)
{
layersValidate(definition->layers);
}
static TexturesDefinition* _createDefinition()
{
TexturesDefinition* definition = new TexturesDefinition;
definition->layers = layersCreate(texturesGetLayerType(), TEXTURES_MAX_LAYERS);
return definition;
}
static void _deleteDefinition(TexturesDefinition* definition)
{
layersDelete(definition->layers);
delete definition;
}
static void _copyDefinition(TexturesDefinition* source, TexturesDefinition* destination)
{
layersCopy(source->layers, destination->layers);
}
static void _saveDefinition(PackStream* stream, TexturesDefinition* definition)
{
layersSave(stream, definition->layers);
}
static void _loadDefinition(PackStream* stream, TexturesDefinition* definition)
{
layersLoad(stream, definition->layers);
}
StandardDefinition TexturesDefinitionClass = {
(FuncObjectCreate)_createDefinition,
(FuncObjectDelete)_deleteDefinition,
(FuncObjectCopy)_copyDefinition,
(FuncObjectValidate)_validateDefinition,
(FuncObjectSave)_saveDefinition,
(FuncObjectLoad)_loadDefinition
};
/*** Layer definition ***/
static void _layerValidateDefinition(TexturesLayerDefinition* definition)
{
if (definition->displacement_scaling < 0.000001)
{
definition->displacement_scaling = 0.000001;
}
definition->_displacement_noise->clearLevels();
definition->_displacement_noise->addLevelsSimple(9, 1.0, -1.0, 1.0, 0.0);
definition->_displacement_noise->normalizeAmplitude(-1.0, 1.0, 0);
definition->_displacement_noise->validate();
definition->_detail_noise->clearLevels();
definition->_detail_noise->addLevelsSimple(7, 0.01, -1.0, 1.0, 0.0);
definition->_detail_noise->normalizeAmplitude(-0.008, 0.008, 0);
definition->_detail_noise->validate();
materialValidate(&definition->material);
/* Update zone height range */
TerrainDefinition* terrain = Scenery::getCurrent()->getTerrain();
if (terrain)
{
HeightInfo height_info = terrainGetHeightInfo(terrain);
zoneSetRelativeHeight(definition->terrain_zone, height_info.min_height, height_info.base_height, height_info.max_height);
}
}
static TexturesLayerDefinition* _layerCreateDefinition()
{
TexturesLayerDefinition* result;
result = new TexturesLayerDefinition;
result->terrain_zone = zoneCreate();
result->_displacement_noise = new NoiseGenerator();
result->_detail_noise = new NoiseGenerator();
texturesLayerAutoPreset(result, TEXTURES_LAYER_PRESET_ROCK);
_layerValidateDefinition(result);
return result;
}
static void _layerDeleteDefinition(TexturesLayerDefinition* definition)
{
zoneDelete(definition->terrain_zone);
delete definition->_displacement_noise;
delete definition->_detail_noise;
delete definition;
}
static void _layerCopyDefinition(TexturesLayerDefinition* source, TexturesLayerDefinition* destination)
{
zoneCopy(source->terrain_zone, destination->terrain_zone);
destination->displacement_scaling = source->displacement_scaling;
destination->displacement_height = source->displacement_height;
destination->displacement_offset = source->displacement_offset;
destination->material = source->material;
source->_displacement_noise->copy(destination->_displacement_noise);
source->_detail_noise->copy(destination->_detail_noise);
}
static void _layerSave(PackStream* stream, TexturesLayerDefinition* layer)
{
zoneSave(stream, layer->terrain_zone);
stream->write(&layer->displacement_scaling);
stream->write(&layer->displacement_height);
stream->write(&layer->displacement_offset);
materialSave(stream, &layer->material);
layer->_displacement_noise->save(stream);
layer->_detail_noise->save(stream);
}
static void _layerLoad(PackStream* stream, TexturesLayerDefinition* layer)
{
zoneLoad(stream, layer->terrain_zone);
stream->read(&layer->displacement_scaling);
stream->read(&layer->displacement_height);
stream->read(&layer->displacement_offset);
materialLoad(stream, &layer->material);
layer->_displacement_noise->load(stream);
layer->_detail_noise->load(stream);
}
LayerType texturesGetLayerType()
{
LayerType result;
result.callback_create = (LayerCallbackCreate)_layerCreateDefinition;
result.callback_delete = (LayerCallbackDelete)_layerDeleteDefinition;
result.callback_copy = (LayerCallbackCopy)_layerCopyDefinition;
result.callback_validate = (LayerCallbackValidate)_layerValidateDefinition;
result.callback_save = (LayerCallbackSave)_layerSave;
result.callback_load = (LayerCallbackLoad)_layerLoad;
return result;
}

119
src/rendering/textures/tex_presets.cpp
View file

@ -1,119 +0,0 @@
#include "private.h"
#include "NoiseGenerator.h"
void texturesAutoPreset(TexturesDefinition* definition, TexturesPreset preset)
{
TexturesLayerDefinition* layer;
layersClear(definition->layers);
layer = (TexturesLayerDefinition*)layersGetLayer(definition->layers, layersAddLayer(definition->layers, NULL));
texturesLayerAutoPreset(layer, TEXTURES_LAYER_PRESET_MUD);
layersSetName(definition->layers, 0, "Mud");
if (preset == TEXTURES_PRESET_FULL)
{
layer = (TexturesLayerDefinition*)layersGetLayer(definition->layers, layersAddLayer(definition->layers, NULL));
texturesLayerAutoPreset(layer, TEXTURES_LAYER_PRESET_ROCK);
layersSetName(definition->layers, 1, "Ground");
layer = (TexturesLayerDefinition*)layersGetLayer(definition->layers, layersAddLayer(definition->layers, NULL));
texturesLayerAutoPreset(layer, TEXTURES_LAYER_PRESET_GRASS);
layersSetName(definition->layers, 2, "Grass");
layer = (TexturesLayerDefinition*)layersGetLayer(definition->layers, layersAddLayer(definition->layers, NULL));
texturesLayerAutoPreset(layer, TEXTURES_LAYER_PRESET_SAND);
layersSetName(definition->layers, 3, "Sand");
layer = (TexturesLayerDefinition*)layersGetLayer(definition->layers, layersAddLayer(definition->layers, NULL));
texturesLayerAutoPreset(layer, TEXTURES_LAYER_PRESET_SNOW);
layersSetName(definition->layers, 4, "Snow");
}
else if (preset == TEXTURES_PRESET_IRELAND)
{
layer = (TexturesLayerDefinition*)layersGetLayer(definition->layers, layersAddLayer(definition->layers, NULL));
texturesLayerAutoPreset(layer, TEXTURES_LAYER_PRESET_ROCK);
layersSetName(definition->layers, 1, "Ground");
layer = (TexturesLayerDefinition*)layersGetLayer(definition->layers, layersAddLayer(definition->layers, NULL));
texturesLayerAutoPreset(layer, TEXTURES_LAYER_PRESET_GRASS);
layersSetName(definition->layers, 2, "Grass");
}
else if (preset == TEXTURES_PRESET_ALPS)
{
layer = (TexturesLayerDefinition*)layersGetLayer(definition->layers, layersAddLayer(definition->layers, NULL));
texturesLayerAutoPreset(layer, TEXTURES_LAYER_PRESET_ROCK);
layersSetName(definition->layers, 1, "Ground");
layer = (TexturesLayerDefinition*)layersGetLayer(definition->layers, layersAddLayer(definition->layers, NULL));
texturesLayerAutoPreset(layer, TEXTURES_LAYER_PRESET_SNOW);
layersSetName(definition->layers, 2, "Snow");
}
else if (preset == TEXTURES_PRESET_CANYON)
{
/* TODO */
}
}
void texturesLayerAutoPreset(TexturesLayerDefinition* definition, TexturesLayerPreset preset)
{
definition->_displacement_noise->randomizeOffsets();
definition->_detail_noise->randomizeOffsets();
zoneClear(definition->terrain_zone);
switch (preset)
{
case TEXTURES_LAYER_PRESET_MUD:
definition->displacement_height = 0.05;
definition->displacement_scaling = 3.0;
definition->displacement_offset = 0.0;
definition->material.base = colorToHSL(colorFromValues(0.4, 0.38, 0.35, 1.0));
definition->material.reflection = 0.003;
definition->material.shininess = 4.0;
break;
case TEXTURES_LAYER_PRESET_ROCK:
zoneAddHeightRangeQuick(definition->terrain_zone, 1.0, 0.5, 0.55, 1.0, 1.0);
definition->displacement_height = 0.3;
definition->displacement_scaling = 2.0;
definition->displacement_offset = 0.0;
definition->material.base = colorToHSL(colorFromValues(0.6, 0.55, 0.57, 1.0));
definition->material.reflection = 0.006;
definition->material.shininess = 6.0;
break;
case TEXTURES_LAYER_PRESET_GRASS:
zoneAddHeightRangeQuick(definition->terrain_zone, 1.0, 0.45, 0.5, 0.8, 1.0);
zoneAddSlopeRangeQuick(definition->terrain_zone, 1.0, 0.0, 0.0, 0.05, 0.4);
definition->displacement_height = 0.0;
definition->displacement_scaling = 1.0;
definition->displacement_offset = 0.0;
definition->material.base = colorToHSL(colorFromValues(0.12, 0.19, 0.035, 1.0));
definition->material.reflection = 0.001;
definition->material.shininess = 4.0;
break;
case TEXTURES_LAYER_PRESET_SAND:
zoneAddHeightRangeQuick(definition->terrain_zone, 1.0, 0.498, 0.502, 0.505, 0.51);
zoneAddSlopeRangeQuick(definition->terrain_zone, 1.0, 0.0, 0.0, 0.7, 0.1);
definition->displacement_height = 0.02;
definition->displacement_scaling = 5.0;
definition->displacement_offset = 0.0;
definition->material.base = colorToHSL(colorFromValues(0.93, 0.9, 0.8, 1.0));
definition->material.reflection = 0.008;
definition->material.shininess = 1.0;
break;
case TEXTURES_LAYER_PRESET_SNOW:
zoneAddHeightRangeQuick(definition->terrain_zone, 1.0, 0.77, 0.85, 1.0, 1.0);
zoneAddSlopeRangeQuick(definition->terrain_zone, 1.0, 0.0, 0.0, 0.2, 1.0);
definition->displacement_height = 0.1;
definition->displacement_scaling = 1.0;
definition->displacement_offset = 0.0;
definition->material.base = colorToHSL(colorFromValues(1.0, 1.0, 1.0, 1.0));
definition->material.reflection = 0.25;
definition->material.shininess = 0.6;
break;
default:
break;
}
texturesGetLayerType().callback_validate(definition);
}

26
src/rendering/textures/tex_preview.cpp
View file

@ -2,7 +2,7 @@
#include "private.h"
#include "Scenery.h"
#include "tools.h"
#include "TexturesDefinition.h"
void TexturesPreviewLayerCoverage_bind(Renderer* renderer, TexturesDefinition* definition)
{
@ -10,16 +10,14 @@ void TexturesPreviewLayerCoverage_bind(Renderer* renderer, TexturesDefinition* d
TexturesRendererClass.bind(renderer, definition);
}
Color TexturesPreviewLayerCoverage_getColor(Renderer* renderer, double x, double y, double scaling, int layer)
Color TexturesPreviewLayerCoverage_getColor(Renderer* renderer, double x, double y, double, int layer)
{
UNUSED(scaling);
TexturesLayerDefinition* layerdef;
TextureLayerDefinition* layerdef;
TerrainResult terrain;
double presence;
Color result;
layerdef = (TexturesLayerDefinition*)layersGetLayer(renderer->textures->definition->layers, layer);
layerdef = renderer->textures->definition->getTextureLayer(layer);
if (layerdef)
{
terrain = renderer->terrain->getResult(renderer, x, y, 1, 1);
@ -36,12 +34,8 @@ Color TexturesPreviewLayerCoverage_getColor(Renderer* renderer, double x, double
return result;
}
static double _getPresenceFull(Renderer* renderer, int layer, TerrainResult terrain)
static double _getPresenceFull(Renderer*, int, TerrainResult)
{
UNUSED(renderer);
UNUSED(layer);
UNUSED(terrain);
return 1.0;
}
@ -51,11 +45,8 @@ void TexturesPreviewLayerLook_bind(Renderer* renderer, TexturesDefinition* defin
renderer->textures->getBasePresence = _getPresenceFull;
}
Color TexturesPreviewLayerLook_getColor(Renderer* renderer, double x, double y, double scaling, int layer)
Color TexturesPreviewLayerLook_getColor(Renderer* renderer, double x, double y, double, int layer)
{
UNUSED(scaling);
UNUSED(layer);
TexturesResult result = renderer->textures->applyToTerrain(renderer, x, y);
if (layer >= 0 && layer < result.layer_count)
{
@ -74,10 +65,7 @@ void TexturesPreviewCumul_bind(Renderer* renderer, TexturesDefinition* definitio
TexturesRendererClass.bind(renderer, definition);
}
Color TexturesPreviewCumul_getColor(Renderer* renderer, double x, double y, double scaling, int layer)
Color TexturesPreviewCumul_getColor(Renderer* renderer, double x, double y, double, int)
{
UNUSED(scaling);
UNUSED(layer);
return renderer->textures->applyToTerrain(renderer, x, y).final_color;
}

39
src/rendering/textures/tex_rendering.cpp
View file

@ -1,7 +1,8 @@
#include "private.h"
#include <stdlib.h>
#include "../tools.h"
#include <cstdlib>
#include "TexturesDefinition.h"
#include "TextureLayerDefinition.h"
#include "../renderer.h"
/******************** Tools ********************/
@ -29,7 +30,7 @@ static inline Vector3 _getNormal2(Vector3 center, Vector3 east, Vector3 south)
return v3Normalize(v3Cross(v3Sub(south, center), v3Sub(east, center)));
}
static Vector3 _getDetailNormal(Renderer* renderer, Vector3 base_location, Vector3 base_normal, TexturesLayerDefinition* layer)
static Vector3 _getDetailNormal(Renderer* renderer, Vector3 base_location, Vector3 base_normal, TextureLayerDefinition* layer)
{
Vector3 result;
double offset = 0.01;
@ -88,10 +89,10 @@ static Vector3 _realDisplaceTerrain(Renderer* renderer, TerrainResult terrain)
double offset = 0.0;
int i, n;
n = layersCount(textures->layers);
n = textures->count();
for (i = 0; i < n; i++)
{
TexturesLayerDefinition* layer = (TexturesLayerDefinition*)layersGetLayer(textures->layers, i);
TextureLayerDefinition* layer = textures->getTextureLayer(i);
if (layer->displacement_height > 0.0)
{
@ -106,7 +107,7 @@ static Vector3 _realDisplaceTerrain(Renderer* renderer, TerrainResult terrain)
static double _realGetBasePresence(Renderer* renderer, int layer, TerrainResult terrain)
{
TexturesLayerDefinition* layerdef = (TexturesLayerDefinition*)layersGetLayer(renderer->textures->definition->layers, layer);
TextureLayerDefinition* layerdef = renderer->textures->definition->getTextureLayer(layer);
return texturesGetLayerBasePresence(layerdef, terrain);
}
@ -122,16 +123,16 @@ static TexturesResult _realApplyToTerrain(Renderer* renderer, double x, double z
/* Find presence of each layer */
int i, n;
n = layersCount(textures->layers);
n = textures->count();
for (i = 0; i < n; i++)
{
TexturesLayerResult* info = result.layers + i;
info->layer = (TexturesLayerDefinition*)layersGetLayer(textures->layers, i);
info->layer = textures->getTextureLayer(i);
info->presence = renderer->textures->getBasePresence(renderer, i, terrain);
if (info->presence > 0.0)
{
Vector3 normal = _getDetailNormal(renderer, terrain.location, terrain.normal, info->layer);
info->color = renderer->applyLightingToSurface(renderer, terrain.location, normal, &info->layer->material);
info->color = renderer->applyLightingToSurface(renderer, terrain.location, normal, info->layer->material);
}
else
{
@ -157,26 +158,18 @@ static TexturesResult _realApplyToTerrain(Renderer* renderer, double x, double z
}
/******************** Fake ********************/
static Vector3 _fakeDisplaceTerrain(Renderer* renderer, TerrainResult terrain)
static Vector3 _fakeDisplaceTerrain(Renderer*, TerrainResult terrain)
{
UNUSED(renderer);
return terrain.location;
}
static double _fakeGetBasePresence(Renderer* renderer, int layer, TerrainResult terrain)
static double _fakeGetBasePresence(Renderer*, int, TerrainResult)
{
UNUSED(renderer);
UNUSED(layer);
UNUSED(terrain);
return 1.0;
}
static TexturesResult _fakeApplyToTerrain(Renderer* renderer, double x, double z)
static TexturesResult _fakeApplyToTerrain(Renderer*, double x, double z)
{
UNUSED(renderer);
TexturesResult result;
result.base_location.x = x;
@ -196,7 +189,7 @@ static TexturesRenderer* _createRenderer()
TexturesRenderer* result;
result = new TexturesRenderer;
result->definition = (TexturesDefinition*)TexturesDefinitionClass.create();
result->definition = new TexturesDefinition(NULL);
result->displaceTerrain = _fakeDisplaceTerrain;
result->getBasePresence = _fakeGetBasePresence;
@ -207,13 +200,13 @@ static TexturesRenderer* _createRenderer()
static void _deleteRenderer(TexturesRenderer* renderer)
{
TexturesDefinitionClass.destroy(renderer->definition);
delete renderer->definition;
delete renderer;
}
static void _bindRenderer(Renderer* renderer, TexturesDefinition* definition)
{
TexturesDefinitionClass.copy(definition, renderer->textures->definition);
definition->copy(renderer->textures->definition);
renderer->textures->displaceTerrain = _realDisplaceTerrain;
renderer->textures->getBasePresence = _realGetBasePresence;

11
src/rendering/textures/tex_tools.cpp
View file

@ -2,13 +2,16 @@
#include <cmath>
#include "NoiseGenerator.h"
#include "TexturesDefinition.h"
#include "TextureLayerDefinition.h"
#include "Zone.h"
/*
* Get the base presence factor of a layer, not accounting for other layers.
*/
double texturesGetLayerBasePresence(TexturesLayerDefinition* layer, TerrainResult terrain)
double texturesGetLayerBasePresence(TextureLayerDefinition* layer, TerrainResult terrain)
{
return zoneGetValue(layer->terrain_zone, terrain.location, terrain.normal);
return layer->terrain_zone->getValue(terrain.location, terrain.normal);
}
/*
@ -35,10 +38,10 @@ double texturesGetMaximalDisplacement(TexturesDefinition* textures)
{
int i, n;
double disp = 0.0;
n = layersCount(textures->layers);
n = textures->count();
for (i = 0; i < n; i++)
{
TexturesLayerDefinition* layer = (TexturesLayerDefinition*)layersGetLayer(textures->layers, i);
TextureLayerDefinition* layer = textures->getTextureLayer(i);
if (layer->displacement_height > 0.0)
{

290
src/rendering/tools/zone.cpp
View file

@ -1,290 +0,0 @@
#include "zone.h"
#include <cstring>
#include <cstdlib>
#include <cmath>
#include "PackStream.h"
#include "Curve.h"
#include "tools.h"
#define MAX_CIRCLES 20
typedef struct
{
double value;
double centerx;
double centerz;
double softradius;
double hardradius;
} Circle;
struct Zone {
int absolute_height;
double relative_height_min;
double relative_height_middle;
double relative_height_max;
Curve* value_by_height;
Curve* value_by_slope;
Circle circles_included[MAX_CIRCLES];
int circles_included_count;
};
Zone* zoneCreate()
{
Zone* result;
result = (Zone*)malloc(sizeof(Zone));
result->value_by_height = new Curve;
result->absolute_height = 1;
result->value_by_height->setDefault(1.0);
result->value_by_slope = new Curve;
result->value_by_slope->setDefault(1.0);
result->circles_included_count = 0;
return result;
}
void zoneDelete(Zone* zone)
{
delete zone->value_by_height;
delete zone->value_by_slope;
free(zone);
}
void zoneSave(PackStream* stream, Zone* zone)
{
int i;
stream->write(&zone->absolute_height);
stream->write(&zone->relative_height_min);
stream->write(&zone->relative_height_middle);
stream->write(&zone->relative_height_max);
zone->value_by_height->save(stream);
zone->value_by_slope->save(stream);
stream->write(&zone->circles_included_count);
for (i = 0; i < zone->circles_included_count; i++)
{
stream->write(&zone->circles_included[i].value);
stream->write(&zone->circles_included[i].centerx);
stream->write(&zone->circles_included[i].centerz);
stream->write(&zone->circles_included[i].softradius);
stream->write(&zone->circles_included[i].hardradius);
}
}
void zoneLoad(PackStream* stream, Zone* zone)
{
int i;
stream->read(&zone->absolute_height);
stream->read(&zone->relative_height_min);
stream->read(&zone->relative_height_middle);
stream->read(&zone->relative_height_max);
zone->value_by_height->load(stream);
zone->value_by_slope->load(stream);
stream->read(&zone->circles_included_count);
for (i = 0; i < zone->circles_included_count; i++)
{
stream->read(&zone->circles_included[i].value);
stream->read(&zone->circles_included[i].centerx);
stream->read(&zone->circles_included[i].centerz);
stream->read(&zone->circles_included[i].softradius);
stream->read(&zone->circles_included[i].hardradius);
}
}
void zoneCopy(Zone* source, Zone* destination)
{
destination->absolute_height = source->absolute_height;
destination->relative_height_min = source->relative_height_min;
destination->relative_height_middle = source->relative_height_middle;
destination->relative_height_max = source->relative_height_max;
source->value_by_height->copy(destination->value_by_height);
source->value_by_slope->copy(destination->value_by_slope);
memcpy(destination->circles_included, source->circles_included, sizeof(Circle) * source->circles_included_count);
destination->circles_included_count = source->circles_included_count;
}
void zoneClear(Zone* zone)
{
zone->value_by_height->clear();
zone->value_by_slope->clear();
zone->circles_included_count = 0;
}
void zoneSetAbsoluteHeight(Zone* zone)
{
zone->absolute_height = 1;
}
void zoneSetRelativeHeight(Zone* zone, double min, double middle, double max)
{
if (max < min)
{
max = min;
}
if (middle < min)
{
middle = min;
}
if (middle > max)
{
middle = max;
}
zone->absolute_height = 0;
zone->relative_height_min = min;
zone->relative_height_middle = middle;
zone->relative_height_max = max;
}
void zoneIncludeCircleArea(Zone* zone, double value, double centerx, double centerz, double softradius, double hardradius)
{
Circle circle = {value, centerx, centerz, softradius, hardradius};
if (zone->circles_included_count < MAX_CIRCLES)
{
zone->circles_included[zone->circles_included_count++] = circle;
}
}
void zoneGetHeightCurve(Zone* zone, Curve* curve)
{
zone->value_by_height->copy(curve);
}
void zoneSetHeightCurve(Zone* zone, Curve* curve)
{
curve->copy(zone->value_by_height);
}
void zoneAddHeightRangeQuick(Zone* zone, double value, double hardmin, double softmin, double softmax, double hardmax)
{
zone->value_by_height->addPoint(hardmin, 0.0);
zone->value_by_height->addPoint(softmin, value);
zone->value_by_height->addPoint(softmax, value);
zone->value_by_height->addPoint(hardmax, 0.0);
}
void zoneGetSlopeCurve(Zone* zone, Curve* curve)
{
zone->value_by_slope->copy(curve);
}
void zoneSetSlopeCurve(Zone* zone, Curve* curve)
{
curve->copy(zone->value_by_slope);
}
void zoneAddSlopeRangeQuick(Zone* zone, double value, double hardmin, double softmin, double softmax, double hardmax)
{
zone->value_by_slope->addPoint(hardmin, 0.0);
zone->value_by_slope->addPoint(softmin, value);
zone->value_by_slope->addPoint(softmax, value);
zone->value_by_slope->addPoint(hardmax, 0.0);
}
static inline double _getCircleInfluence(Circle circle, Vector3 position)
{
double radius, dx, dz;
dx = position.x - circle.centerx;
dz = position.z - circle.centerz;
radius = sqrt(dx * dx + dz * dz);
if (radius > circle.hardradius)
{
return 0.0;
}
else if (radius < circle.softradius)
{
return circle.value;
}
else
{
return circle.value * (circle.hardradius - radius) / (circle.hardradius - circle.softradius);
}
}
double zoneGetValue(Zone* zone, Vector3 location, Vector3 normal)
{
int i;
double final_height;
double value, value_height, value_steepness, value_circle;
if (zone->circles_included_count > 0)
{
value_circle = 0.0;
for (i = 0; i < zone->circles_included_count; i++)
{
value = _getCircleInfluence(zone->circles_included[i], location);
if (value > value_circle)
{
value_circle = value;
}
}
}
else
{
value_circle = 1.0;
}
if (zone->absolute_height)
{
final_height = location.y;
}
else
{
if (location.y >= zone->relative_height_max)
{
final_height = 1.0;
}
else if (location.y <= zone->relative_height_min)
{
final_height = 0.0;
}
else if (location.y <= zone->relative_height_middle)
{
final_height = 0.5 * (location.y - zone->relative_height_min) / (zone->relative_height_middle - zone->relative_height_min);
}
else
{
final_height = 0.5 + 0.5 * (location.y - zone->relative_height_middle) / (zone->relative_height_max - zone->relative_height_middle);
}
}
value_height = zone->value_by_height->getValue(final_height);
value_steepness = zone->value_by_slope->getValue(1.0 - normal.y);
if (value_steepness < value_height)
{
if (value_circle < value_steepness)
{
return value_circle;
}
else
{
return value_steepness;
}
}
else
{
if (value_circle < value_height)
{
return value_circle;
}
else
{
return value_height;
}
}
}

36
src/rendering/tools/zone.h
View file

@ -1,36 +0,0 @@
#ifndef _RENDERING_TOOLS_ZONE_H_
#define _RENDERING_TOOLS_ZONE_H_
/**
* Definition of a geographic area.
*/
#include "../rendering_global.h"
#include "../tools/euclid.h"
typedef struct Zone Zone;
RENDERINGSHARED_EXPORT Zone* zoneCreate();
RENDERINGSHARED_EXPORT void zoneDelete(Zone* zone);
RENDERINGSHARED_EXPORT void zoneSave(PackStream* stream, Zone* zone);
RENDERINGSHARED_EXPORT void zoneLoad(PackStream* stream, Zone* zone);
RENDERINGSHARED_EXPORT void zoneCopy(Zone* source, Zone* destination);
RENDERINGSHARED_EXPORT void zoneClear(Zone* zone);
RENDERINGSHARED_EXPORT void zoneSetAbsoluteHeight(Zone* zone);
RENDERINGSHARED_EXPORT void zoneSetRelativeHeight(Zone* zone, double min, double middle, double max);
RENDERINGSHARED_EXPORT void zoneIncludeCircleArea(Zone* zone, double value, double centerx, double centerz, double softradius, double hardradius);
RENDERINGSHARED_EXPORT void zoneExcludeCircleArea(Zone* zone, double centerx, double centerz, double softradius, double hardradius);
RENDERINGSHARED_EXPORT void zoneGetHeightCurve(Zone* zone, Curve* curve);
RENDERINGSHARED_EXPORT void zoneSetHeightCurve(Zone* zone, Curve* curve);
RENDERINGSHARED_EXPORT void zoneAddHeightRangeQuick(Zone* zone, double value, double hardmin, double softmin, double softmax, double hardmax);
RENDERINGSHARED_EXPORT void zoneGetSlopeCurve(Zone* zone, Curve* curve);
RENDERINGSHARED_EXPORT void zoneSetSlopeCurve(Zone* zone, Curve* curve);
RENDERINGSHARED_EXPORT void zoneAddSlopeRangeQuick(Zone* zone, double value, double hardmin, double softmin, double softmax, double hardmax);
RENDERINGSHARED_EXPORT double zoneGetValue(Zone* zone, Vector3 location, Vector3 normal);
#endif

89
src/tests/Layers_Test.cpp
View file

@ -78,92 +78,3 @@ TEST(Layers, maxLayerCount)
layers1.addLayer();
EXPECT_EQ(2, layers1.count());
}
static int _legacy_instance_count = 0;
typedef struct
{
int a;
} LegacyData;
static void* _legacy_create()
{
LegacyData* data = new LegacyData;
data->a = 2;
_legacy_instance_count++;
return data;
}
static void _legacy_delete(void* data)
{
delete (LegacyData*)data;
_legacy_instance_count--;
}
static void _legacy_save(PackStream* stream, void* data)
{
stream->write(&((LegacyData*)data)->a);
}
static void _legacy_load(PackStream* stream, void* data)
{
stream->read(&((LegacyData*)data)->a);
}
static void _legacy_validate(void* data)
{
LegacyData* ldata = (LegacyData*)data;
if (ldata->a > 5)
{
ldata->a = 5;
}
}
static void _legacy_copy(void* source, void* destination)
{
((LegacyData*)destination)->a = ((LegacyData*)source)->a;
}
TEST(Layers, LegacyLayers)
{
LayerType type;
type.callback_create = _legacy_create;
type.callback_delete = _legacy_delete;
type.callback_save = _legacy_save;
type.callback_load = _legacy_load;
type.callback_validate = _legacy_validate;
type.callback_copy = _legacy_copy;
Layers* layers1 = layersCreate(type, 3);
LegacyData* data1;
// Test the null layer
EXPECT_EQ(0, layersCount(layers1));
EXPECT_EQ(1, _legacy_instance_count);
data1 = (LegacyData*)layersGetLayer(layers1, 0);
EXPECT_EQ(2, data1->a);
data1->a = 3;
data1 = (LegacyData*)layersGetLayer(layers1, 0);
EXPECT_EQ(3, data1->a);
// Add an empty layer
layersAddLayer(layers1, NULL);
EXPECT_EQ(1, layersCount(layers1));
data1 = (LegacyData*)layersGetLayer(layers1, 0);
EXPECT_EQ(2, data1->a);
EXPECT_EQ(2, _legacy_instance_count);
// Validation
data1->a = 6;
layersValidate(layers1);
EXPECT_EQ(5, data1->a);
// Naming
layersSetName(layers1, 0, "test1");
EXPECT_EQ(QString("test1"), QString(layersGetName(layers1, 0)));
// Deletion
delete layers1;
EXPECT_EQ(0, _legacy_instance_count);
}

65
src/tests/Zone_Test.cpp
View file

@ -1,16 +1,17 @@
#include "BaseTestCase.h"
#include "tools/zone.h"
#include "Zone.h"
#include "Vector3.h"
class Zone_Test : public BaseTestCase {
protected:
virtual void SetUp() {
zone = zoneCreate();
zone = new Zone;
}
virtual void TearDown()
{
zoneDelete(zone);
delete zone;
}
Zone* zone;
@ -18,39 +19,39 @@ protected:
TEST_F(Zone_Test, absolute_height)
{
zoneAddHeightRangeQuick(zone, 1.0, -1.0, 2.0, 5.0, 6.0);
zone->addHeightRangeQuick(1.0, -1.0, 2.0, 5.0, 6.0);
EXPECT_DOUBLE_EQ(zoneGetValue(zone, v3(0.0, -10.0, 0.0), VECTOR_UP), 0.0);
EXPECT_DOUBLE_EQ(zoneGetValue(zone, v3(0.0, -2.0, 0.0), VECTOR_UP), 0.0);
EXPECT_DOUBLE_EQ(zoneGetValue(zone, v3(0.0, -1.0, 0.0), VECTOR_UP), 0.0);
EXPECT_DOUBLE_EQ(zoneGetValue(zone, v3(0.0, -0.5, 0.0), VECTOR_UP), 1.0 / 6.0);
EXPECT_DOUBLE_EQ(zoneGetValue(zone, v3(0.0, 0.0, 0.0), VECTOR_UP), 1.0 / 3.0);
EXPECT_DOUBLE_EQ(zoneGetValue(zone, v3(0.0, 0.5, 0.0), VECTOR_UP), 0.5);
EXPECT_DOUBLE_EQ(zoneGetValue(zone, v3(0.0, 2.0, 0.0), VECTOR_UP), 1.0);
EXPECT_DOUBLE_EQ(zoneGetValue(zone, v3(0.0, 2.1, 0.0), VECTOR_UP), 1.0);
EXPECT_DOUBLE_EQ(zoneGetValue(zone, v3(0.0, 3.5, 0.0), VECTOR_UP), 1.0);
EXPECT_DOUBLE_EQ(zoneGetValue(zone, v3(0.0, 4.9, 0.0), VECTOR_UP), 1.0);
EXPECT_DOUBLE_EQ(zoneGetValue(zone, v3(0.0, 5.0, 0.0), VECTOR_UP), 1.0);
EXPECT_DOUBLE_EQ(zoneGetValue(zone, v3(0.0, 5.2, 0.0), VECTOR_UP), 0.8);
EXPECT_DOUBLE_EQ(zoneGetValue(zone, v3(0.0, 5.7, 0.0), VECTOR_UP), 0.3);
EXPECT_DOUBLE_EQ(zoneGetValue(zone, v3(0.0, 6.0, 0.0), VECTOR_UP), 0.0);
EXPECT_DOUBLE_EQ(zoneGetValue(zone, v3(0.0, 15.0, 0.0), VECTOR_UP), 0.0);
EXPECT_DOUBLE_EQ(zoneGetValue(zone, v3(0.0, 150.0, 0.0), VECTOR_UP), 0.0);
EXPECT_DOUBLE_EQ(zone->getValue(Vector3(0.0, -10.0, 0.0), VECTOR_UP), 0.0);
EXPECT_DOUBLE_EQ(zone->getValue(Vector3(0.0, -2.0, 0.0), VECTOR_UP), 0.0);
EXPECT_DOUBLE_EQ(zone->getValue(Vector3(0.0, -1.0, 0.0), VECTOR_UP), 0.0);
EXPECT_DOUBLE_EQ(zone->getValue(Vector3(0.0, -0.5, 0.0), VECTOR_UP), 1.0 / 6.0);
EXPECT_DOUBLE_EQ(zone->getValue(Vector3(0.0, 0.0, 0.0), VECTOR_UP), 1.0 / 3.0);
EXPECT_DOUBLE_EQ(zone->getValue(Vector3(0.0, 0.5, 0.0), VECTOR_UP), 0.5);
EXPECT_DOUBLE_EQ(zone->getValue(Vector3(0.0, 2.0, 0.0), VECTOR_UP), 1.0);
EXPECT_DOUBLE_EQ(zone->getValue(Vector3(0.0, 2.1, 0.0), VECTOR_UP), 1.0);
EXPECT_DOUBLE_EQ(zone->getValue(Vector3(0.0, 3.5, 0.0), VECTOR_UP), 1.0);
EXPECT_DOUBLE_EQ(zone->getValue(Vector3(0.0, 4.9, 0.0), VECTOR_UP), 1.0);
EXPECT_DOUBLE_EQ(zone->getValue(Vector3(0.0, 5.0, 0.0), VECTOR_UP), 1.0);
EXPECT_DOUBLE_EQ(zone->getValue(Vector3(0.0, 5.2, 0.0), VECTOR_UP), 0.8);
EXPECT_DOUBLE_EQ(zone->getValue(Vector3(0.0, 5.7, 0.0), VECTOR_UP), 0.3);
EXPECT_DOUBLE_EQ(zone->getValue(Vector3(0.0, 6.0, 0.0), VECTOR_UP), 0.0);
EXPECT_DOUBLE_EQ(zone->getValue(Vector3(0.0, 15.0, 0.0), VECTOR_UP), 0.0);
EXPECT_DOUBLE_EQ(zone->getValue(Vector3(0.0, 150.0, 0.0), VECTOR_UP), 0.0);
}
TEST_F(Zone_Test, relative_height)
{
zoneAddHeightRangeQuick(zone, 1.0, 0.2, 0.3, 0.6, 0.9);
zoneSetRelativeHeight(zone, -2.0, 2.0, 8.0);
zone->addHeightRangeQuick(1.0, 0.2, 0.3, 0.6, 0.9);
zone->setRelativeHeight(-2.0, 2.0, 8.0);
EXPECT_DOUBLE_EQ(zoneGetValue(zone, v3(0.0, -10.0, 0.0), VECTOR_UP), 0.0);
EXPECT_DOUBLE_EQ(zoneGetValue(zone, v3(0.0, -2.1, 0.0), VECTOR_UP), 0.0);
EXPECT_DOUBLE_EQ(zoneGetValue(zone, v3(0.0, -2.0, 0.0), VECTOR_UP), 0.0);
EXPECT_DOUBLE_EQ(zoneGetValue(zone, v3(0.0, -1.0, 0.0), VECTOR_UP), 0.0);
EXPECT_DOUBLE_EQ(zoneGetValue(zone, v3(0.0, -0.5, 0.0), VECTOR_UP), 0.0);
EXPECT_DOUBLE_EQ(zoneGetValue(zone, v3(0.0, -0.2, 0.0), VECTOR_UP), 0.25);
EXPECT_DOUBLE_EQ(zoneGetValue(zone, v3(0.0, 0.0, 0.0), VECTOR_UP), 0.5);
EXPECT_DOUBLE_EQ(zoneGetValue(zone, v3(0.0, 0.3, 0.0), VECTOR_UP), 0.875);
EXPECT_DOUBLE_EQ(zoneGetValue(zone, v3(0.0, 0.5, 0.0), VECTOR_UP), 1.0);
EXPECT_DOUBLE_EQ(zoneGetValue(zone, v3(0.0, 1.0, 0.0), VECTOR_UP), 1.0);
EXPECT_DOUBLE_EQ(zone->getValue(Vector3(0.0, -10.0, 0.0), VECTOR_UP), 0.0);
EXPECT_DOUBLE_EQ(zone->getValue(Vector3(0.0, -2.1, 0.0), VECTOR_UP), 0.0);
EXPECT_DOUBLE_EQ(zone->getValue(Vector3(0.0, -2.0, 0.0), VECTOR_UP), 0.0);
EXPECT_DOUBLE_EQ(zone->getValue(Vector3(0.0, -1.0, 0.0), VECTOR_UP), 0.0);
EXPECT_DOUBLE_EQ(zone->getValue(Vector3(0.0, -0.5, 0.0), VECTOR_UP), 0.0);
EXPECT_DOUBLE_EQ(zone->getValue(Vector3(0.0, -0.2, 0.0), VECTOR_UP), 0.25);
EXPECT_DOUBLE_EQ(zone->getValue(Vector3(0.0, 0.0, 0.0), VECTOR_UP), 0.5);
EXPECT_DOUBLE_EQ(zone->getValue(Vector3(0.0, 0.3, 0.0), VECTOR_UP), 0.875);
EXPECT_DOUBLE_EQ(zone->getValue(Vector3(0.0, 0.5, 0.0), VECTOR_UP), 1.0);
EXPECT_DOUBLE_EQ(zone->getValue(Vector3(0.0, 1.0, 0.0), VECTOR_UP), 1.0);
}