Refactored CloudsDefinition

2013-11-15 23:26:44 +01:00 · 2013-11-15 23:26:44 +01:00 · 1cccae90be
commit 1cccae90be
parent dc679500fa
47 changed files with 948 additions and 956 deletions
--- a/src/basics/Curve.cpp
+++ b/src/basics/Curve.cpp
@ -0,0 +1,174 @@
+#include "Curve.h"
+
+const int MAX_NB_POINTS = 30;
+
+#include "PackStream.h"
+
+Curve::Curve()
+{
+    nbpoints = 0;
+    default_value = 0.0;
+    points = new CurvePoint[MAX_NB_POINTS];
+}
+
+Curve::~Curve()
+{
+    delete[] points;
+}
+
+void Curve::copy(Curve* destination) const
+{
+    destination->nbpoints = nbpoints;
+    destination->default_value = default_value;
+    for (int i = 0; i < nbpoints; i++)
+    {
+        destination->points[i] = points[i];
+    }
+}
+
+void Curve::save(PackStream* stream) const
+{
+    stream->write(&default_value);
+    stream->write(&nbpoints);
+    for (int i = 0; i < nbpoints; i++)
+    {
+        stream->write(&points[i].position);
+        stream->write(&points[i].value);
+    }
+}
+
+void Curve::load(PackStream* stream)
+{
+    stream->read(&default_value);
+    stream->read(&nbpoints);
+    for (int i = 0; i < nbpoints; i++)
+    {
+        stream->read(&points[i].position);
+        stream->read(&points[i].value);
+    }
+}
+
+void Curve::clear()
+{
+    nbpoints = 0;
+}
+
+void Curve::setDefault(double value)
+{
+    default_value = value;
+}
+
+int Curve::addPoint(const CurvePoint &point)
+{
+    if (nbpoints < MAX_NB_POINTS)
+    {
+        points[nbpoints] = point;
+        return nbpoints++;
+    }
+    else
+    {
+        return -1;
+    }
+}
+
+int Curve::addPoint(double position, double value)
+{
+    CurvePoint point = {position, value};
+    return addPoint(point);
+}
+
+CurvePoint Curve::getPoint(int number) const
+{
+    if (number >= 0 && number < nbpoints)
+    {
+        return points[number];
+    }
+    else
+    {
+        return {0.0, 0.0};
+    }
+}
+
+bool Curve::getPoint(int number, CurvePoint *point) const
+{
+    if (number >= 0 && number < nbpoints)
+    {
+        *point = points[number];
+        return true;
+    }
+    else
+    {
+        return false;
+    }
+}
+
+void Curve::setPoint(int number, const CurvePoint &point)
+{
+    if (number >= 0 && number < nbpoints)
+    {
+        points[number] = point;
+    }
+}
+
+void Curve::removePoint(int number)
+{
+    if (number >= 0 && number < nbpoints)
+    {
+        if (nbpoints > 0 && number < nbpoints - 1)
+        {
+            memmove(points + number, points + number + 1, sizeof(CurvePoint) * (nbpoints - number - 1));
+        }
+        nbpoints--;
+    }
+}
+
+int _point_compare(const void* part1, const void* part2)
+{
+    if (((CurvePoint*)part1)->position > ((CurvePoint*)part2)->position)
+    {
+        return 1;
+    }
+    else
+    {
+        return -1;
+    }
+}
+
+void Curve::validate()
+{
+    if (nbpoints > 1)
+    {
+        qsort(points, nbpoints, sizeof(CurvePoint), _point_compare);
+    }
+}
+
+double Curve::getValue(double position) const
+{
+    int i;
+    double fact;
+
+    if (nbpoints == 0)
+    {
+        return default_value;
+    }
+    else if (nbpoints == 1 || position <= points[0].position)
+    {
+        return points[0].value;
+    }
+    else if (position >= points[nbpoints - 1].position)
+    {
+        return points[nbpoints - 1].value;
+    }
+    else
+    {
+        for (i = 1; i < nbpoints; i++)
+        {
+            if (position < points[i].position)
+            {
+                fact = (position - points[i - 1].position) / (points[i].position - points[i - 1].position);
+                return points[i - 1].value + (points[i].value - points[i - 1].value) * fact;
+            }
+        }
+        return points[nbpoints - 1].value;
+    }
+}
--- a/src/basics/Curve.h
+++ b/src/basics/Curve.h
@ -0,0 +1,47 @@
+#ifndef CURVE_H
+#define CURVE_H
+
+#include "basics_global.h"
+
+namespace paysages {
+namespace basics {
+
+typedef struct {
+    double position;
+    double value;
+} CurvePoint;
+
+class BASICSSHARED_EXPORT Curve
+{
+public:
+    Curve();
+    ~Curve();
+
+    void copy(Curve* destination) const;
+    void save(PackStream* stream) const;
+    void load(PackStream* stream);
+    void validate();
+
+    inline int getPointCount() const {return nbpoints;}
+    CurvePoint getPoint(int number) const;
+    bool getPoint(int number, CurvePoint *point) const;
+
+    double getValue(double position) const;
+
+    void clear();
+    void setDefault(double value);
+    int addPoint(const CurvePoint &point);
+    int addPoint(double position, double value);
+    void setPoint(int number, const CurvePoint &point);
+    void removePoint(int number);
+
+private:
+    double default_value;
+    int nbpoints;
+    CurvePoint* points;
+};
+
+}
+}
+
+#endif // CURVE_H
--- a/src/basics/basics.pro
+++ b/src/basics/basics.pro
@ -26,7 +26,8 @@ SOURCES += \
    Color.inline.cpp \
    ColorHSL.cpp \
    BoundingBox.cpp \
-    Matrix4.cpp
+    Matrix4.cpp \
+    Curve.cpp

 HEADERS +=\
        basics_global.h \
@ -40,7 +41,8 @@ HEADERS +=\
    Color.h \
    ColorHSL.h \
    BoundingBox.h \
-    Matrix4.h
+    Matrix4.h \
+    Curve.h

 unix:!symbian {
    maemo5 {
--- a/src/basics/basics_global.h
+++ b/src/basics/basics_global.h
@ -18,6 +18,7 @@ namespace basics {
    class SpaceSegment;
    class Color;
    class NoiseGenerator;
+    class Curve;
 }
 }
 using namespace paysages::basics;
--- a/src/definition/CloudLayerDefinition.cpp
+++ b/src/definition/CloudLayerDefinition.cpp
@ -0,0 +1,257 @@
+#include "CloudLayerDefinition.h"
+
+#include "Curve.h"
+#include "NoiseGenerator.h"
+#include "SurfaceMaterial.h"
+#include "PackStream.h"
+
+CloudLayerDefinition::CloudLayerDefinition(BaseDefinition* parent):
+    BaseDefinition(parent)
+{
+    _coverage_by_altitude = new Curve;
+    _coverage_noise = new NoiseGenerator();
+    _shape_noise = new NoiseGenerator();
+    _edge_noise = new NoiseGenerator();
+    material = new SurfaceMaterial;
+}
+
+CloudLayerDefinition::~CloudLayerDefinition()
+{
+    delete _coverage_by_altitude;
+    delete _coverage_noise;
+    delete _shape_noise;
+    delete _edge_noise;
+    delete material;
+}
+
+CloudLayerDefinition* CloudLayerDefinition::newCopy(const CloudLayerDefinition& other, BaseDefinition* parent)
+{
+    CloudLayerDefinition* layer = new CloudLayerDefinition(parent);
+    other.copy(layer);
+    return layer;
+}
+
+CloudLayerDefinition* CloudLayerDefinition::newCopy(BaseDefinition* parent) const
+{
+    CloudLayerDefinition* layer = new CloudLayerDefinition(parent);
+    copy(layer);
+    return layer;
+}
+
+void CloudLayerDefinition::save(PackStream* stream) const
+{
+    int clouds_type = (int)type;
+
+    stream->write(&clouds_type);
+    stream->write(&lower_altitude);
+    stream->write(&thickness);
+    _coverage_by_altitude->save(stream);
+    _coverage_noise->save(stream);
+    _shape_noise->save(stream);
+    _edge_noise->save(stream);
+    materialSave(stream, material);
+    stream->write(&hardness);
+    stream->write(&transparencydepth);
+    stream->write(&lighttraversal);
+    stream->write(&minimumlight);
+    stream->write(&shape_scaling);
+    stream->write(&edge_scaling);
+    stream->write(&edge_length);
+    stream->write(&base_coverage);
+}
+
+void CloudLayerDefinition::load(PackStream* stream)
+{
+    int clouds_type;
+
+    stream->read(&clouds_type);
+    type = (CloudsType)clouds_type;
+    stream->read(&lower_altitude);
+    stream->read(&thickness);
+    _coverage_by_altitude->load(stream);
+    _coverage_noise->load(stream);
+    _shape_noise->load(stream);
+    _edge_noise->load(stream);
+    materialLoad(stream, material);
+    stream->read(&hardness);
+    stream->read(&transparencydepth);
+    stream->read(&lighttraversal);
+    stream->read(&minimumlight);
+    stream->read(&shape_scaling);
+    stream->read(&edge_scaling);
+    stream->read(&edge_length);
+    stream->read(&base_coverage);
+
+    validate();
+}
+
+void CloudLayerDefinition::copy(BaseDefinition* _destination) const
+{
+    CloudLayerDefinition* destination = (CloudLayerDefinition*)_destination;
+
+    destination->type = type;
+    destination->lower_altitude = lower_altitude;
+    destination->thickness = thickness;
+    _coverage_by_altitude->copy(destination->_coverage_by_altitude);
+    _coverage_noise->copy(destination->_coverage_noise);
+    _shape_noise->copy(destination->_shape_noise);
+    _edge_noise->copy(destination->_edge_noise);
+    *destination->material = *material;
+    destination->hardness = hardness;
+    destination->transparencydepth = transparencydepth;
+    destination->lighttraversal = lighttraversal;
+    destination->minimumlight = minimumlight;
+    destination->shape_scaling = shape_scaling;
+    destination->edge_scaling = edge_scaling;
+    destination->edge_length = edge_length;
+    destination->base_coverage = base_coverage;
+}
+
+void CloudLayerDefinition::validate()
+{
+    if (shape_scaling < 0.0001)
+    {
+        shape_scaling = 0.00001;
+    }
+    if (edge_scaling < 0.0001)
+    {
+        edge_scaling = 0.00001;
+    }
+
+    _coverage_by_altitude->clear();
+    _shape_noise->clearLevels();
+    _edge_noise->clearLevels();
+    _coverage_noise->clearLevels();
+
+    _coverage_noise->addLevelsSimple(2, 10.0, 0.0, 1.0, 0.0);
+    _coverage_noise->addLevelsSimple(2, 1.0, 0.0, 1.0, 0.0);
+    _coverage_noise->setFunctionParams(NOISE_FUNCTION_NAIVE, 0.0, 0.0);
+    switch (type)
+    {
+        case CLOUDS_TYPE_CIRRUS:
+            _coverage_by_altitude->addPoint(0.0, 0.0);
+            _coverage_by_altitude->addPoint(0.5, 1.0);
+            _coverage_by_altitude->addPoint(1.0, 0.0);
+            _shape_noise->addLevelsSimple(3, 1.0, 0.0, 1.0, 0.5);
+            _shape_noise->setFunctionParams(NOISE_FUNCTION_SIMPLEX, 0.0, 0.0);
+            _edge_noise->addLevelsSimple(4, 1.0, -0.5, 0.5, 0.5);
+            _edge_noise->setFunctionParams(NOISE_FUNCTION_SIMPLEX, -0.2, 0.0);
+            break;
+        case CLOUDS_TYPE_CUMULUS:
+            _coverage_by_altitude->addPoint(0.0, 0.0);
+            _coverage_by_altitude->addPoint(0.1, 1.0);
+            _coverage_by_altitude->addPoint(0.4, 0.8);
+            _coverage_by_altitude->addPoint(0.7, 1.0);
+            _coverage_by_altitude->addPoint(1.0, 0.0);
+            _shape_noise->addLevelsSimple(7, 1.0, 0.0, 1.0, 0.5);
+            _shape_noise->setFunctionParams(NOISE_FUNCTION_SIMPLEX, 0.4, 0.0);
+            _edge_noise->addLevelsSimple(4, 1.0, -0.5, 0.5, 0.5);
+            _edge_noise->setFunctionParams(NOISE_FUNCTION_SIMPLEX, 0.8, 0.0);
+            break;
+        case CLOUDS_TYPE_STRATOCUMULUS:
+            _coverage_by_altitude->addPoint(0.0, 0.0);
+            _coverage_by_altitude->addPoint(0.2, 1.0);
+            _coverage_by_altitude->addPoint(0.5, 1.0);
+            _coverage_by_altitude->addPoint(1.0, 0.0);
+            _shape_noise->addLevelsSimple(4, 1.0, 0.0, 1.0, 0.5);
+            _shape_noise->setFunctionParams(NOISE_FUNCTION_SIMPLEX, 0.3, 0.0);
+            _edge_noise->addLevelsSimple(6, 1.0, -0.5, 0.5, 0.5);
+            _edge_noise->setFunctionParams(NOISE_FUNCTION_SIMPLEX, 0.5, 0.0);
+            break;
+        case CLOUDS_TYPE_STRATUS:
+            _coverage_by_altitude->addPoint(0.0, 0.0);
+            _coverage_by_altitude->addPoint(0.2, 1.0);
+            _coverage_by_altitude->addPoint(0.8, 1.0);
+            _coverage_by_altitude->addPoint(1.0, 0.0);
+            _shape_noise->addLevelsSimple(3, 1.0, 0.0, 1.0, 0.5);
+            _shape_noise->setFunctionParams(NOISE_FUNCTION_SIMPLEX, -0.3, 0.0);
+            _edge_noise->addLevelsSimple(4, 1.0, -0.5, 0.5, 0.5);
+            _edge_noise->setFunctionParams(NOISE_FUNCTION_SIMPLEX, -0.5, 0.0);
+            break;
+        default:
+            break;
+    }
+
+    _coverage_noise->normalizeAmplitude(-1.0, 3.0, 0);
+    _shape_noise->normalizeAmplitude(-0.5, 0.5, 0);
+    _edge_noise->normalizeAmplitude(-0.5, 0.5, 0);
+
+    materialValidate(material);
+}
+
+void CloudLayerDefinition::applyPreset(CloudsLayerPreset preset)
+{
+    _coverage_noise->randomizeOffsets();
+    _edge_noise->randomizeOffsets();
+    _shape_noise->randomizeOffsets();
+
+    material->base = colorToHSL(colorFromValues(0.7, 0.7, 0.7, 1.0));
+
+    switch (preset)
+    {
+        case CLOUDS_LAYER_PRESET_CIRRUS:
+            type = CLOUDS_TYPE_CIRRUS;
+            lower_altitude = 25.0;
+            thickness = 2.0;
+            material->reflection = 0.4;
+            material->shininess = 0.5;
+            hardness = 0.0;
+            transparencydepth = 3.0;
+            lighttraversal = 10.0;
+            minimumlight = 0.6;
+            shape_scaling = 8.0;
+            edge_scaling = 2.0;
+            edge_length = 0.8;
+            base_coverage = 0.6;
+            break;
+        case CLOUDS_LAYER_PRESET_CUMULUS:
+            type = CLOUDS_TYPE_CUMULUS;
+            lower_altitude = 15.0;
+            thickness = 15.0;
+            material->reflection = 0.5;
+            material->shininess = 1.2;
+            hardness = 0.25;
+            transparencydepth = 1.5;
+            lighttraversal = 8.0;
+            minimumlight = 0.4;
+            shape_scaling = 20.0;
+            edge_scaling = 2.0;
+            edge_length = 0.0;
+            base_coverage = 0.7;
+            break;
+        case CLOUDS_LAYER_PRESET_STRATOCUMULUS:
+            type = CLOUDS_TYPE_STRATOCUMULUS;
+            lower_altitude = 5.0;
+            thickness = 6.0;
+            material->reflection = 0.3;
+            material->shininess = 0.8;
+            hardness = 0.25;
+            transparencydepth = 1.5;
+            lighttraversal = 7.0;
+            minimumlight = 0.4;
+            shape_scaling = 10.0;
+            edge_scaling = 0.8;
+            edge_length = 0.3;
+            base_coverage = 0.4;
+            break;
+        case CLOUDS_LAYER_PRESET_STRATUS:
+            type = CLOUDS_TYPE_STRATUS;
+            lower_altitude = 3.0;
+            thickness = 4.0;
+            material->reflection = 0.1;
+            material->shininess = 0.8;
+            hardness = 0.1;
+            transparencydepth = 3.0;
+            lighttraversal = 10.0;
+            minimumlight = 0.6;
+            shape_scaling = 8.0;
+            edge_scaling = 2.0;
+            edge_length = 1.0;
+            base_coverage = 0.4;
+            break;
+        default:
+            break;
+    }
+
+    validate();
+}
--- a/src/definition/CloudLayerDefinition.h
+++ b/src/definition/CloudLayerDefinition.h
@ -0,0 +1,67 @@
+#ifndef CLOUDLAYERDEFINITION_H
+#define CLOUDLAYERDEFINITION_H
+
+#include "definition_global.h"
+
+#include "BaseDefinition.h"
+
+namespace paysages {
+namespace definition {
+
+class DEFINITIONSHARED_EXPORT CloudLayerDefinition : public BaseDefinition
+{
+public:
+    CloudLayerDefinition(BaseDefinition* parent);
+    virtual ~CloudLayerDefinition();
+
+    static CloudLayerDefinition* newCopy(const CloudLayerDefinition& other, BaseDefinition* parent);
+    CloudLayerDefinition* newCopy(BaseDefinition* parent) const;
+
+    virtual void save(PackStream* pack) const override;
+    virtual void load(PackStream* pack) override;
+
+    virtual void copy(BaseDefinition* destination) const override;
+    virtual void validate() override;
+
+public:
+    typedef enum
+    {
+        CLOUDS_TYPE_CIRRUS,
+        CLOUDS_TYPE_CUMULUS,
+        CLOUDS_TYPE_STRATOCUMULUS,
+        CLOUDS_TYPE_STRATUS
+    } CloudsType;
+
+    typedef enum
+    {
+        CLOUDS_LAYER_PRESET_CIRRUS,
+        CLOUDS_LAYER_PRESET_CUMULUS,
+        CLOUDS_LAYER_PRESET_STRATOCUMULUS,
+        CLOUDS_LAYER_PRESET_STRATUS
+    } CloudsLayerPreset;
+    void applyPreset(CloudsLayerPreset preset);
+
+public:
+    CloudsType type;
+    double lower_altitude;
+    double thickness;
+    double base_coverage;
+    double shape_scaling;
+    double edge_scaling;
+    double edge_length;
+    SurfaceMaterial* material;
+    double hardness;
+    double transparencydepth;
+    double lighttraversal;
+    double minimumlight;
+
+    Curve* _coverage_by_altitude;
+    NoiseGenerator* _coverage_noise;
+    NoiseGenerator* _shape_noise;
+    NoiseGenerator* _edge_noise;
+};
+
+}
+}
+
+#endif // CLOUDLAYERDEFINITION_H
--- a/src/definition/CloudsDefinition.cpp
+++ b/src/definition/CloudsDefinition.cpp
@ -0,0 +1,25 @@
+#include "CloudsDefinition.h"
+
+#include "CloudLayerDefinition.h"
+
+static BaseDefinition* _layerConstructor(Layers* parent)
+{
+    return new CloudLayerDefinition(parent);
+}
+
+CloudsDefinition::CloudsDefinition(BaseDefinition* parent):
+    Layers(parent, _layerConstructor)
+{
+}
+
+void CloudsDefinition::applyPreset(CloudsPreset preset)
+{
+    clear();
+
+    if (preset == CLOUDS_PRESET_PARTLY_CLOUDY)
+    {
+        CloudLayerDefinition* layer = new CloudLayerDefinition(this);
+        layer->applyPreset(CloudLayerDefinition::CLOUDS_LAYER_PRESET_CIRRUS);
+        addLayer(layer);
+    }
+}
--- a/src/definition/CloudsDefinition.h
+++ b/src/definition/CloudsDefinition.h
@ -0,0 +1,28 @@
+#ifndef CLOUDSDEFINITION_H
+#define CLOUDSDEFINITION_H
+
+#include "definition_global.h"
+
+#include "Layers.h"
+
+namespace paysages {
+namespace definition {
+
+class DEFINITIONSHARED_EXPORT CloudsDefinition : public Layers
+{
+public:
+    CloudsDefinition(BaseDefinition* parent);
+
+    inline CloudLayerDefinition* getCloudLayer(int position) const {return (CloudLayerDefinition*)getLayer(position);}
+
+    typedef enum
+    {
+        CLOUDS_PRESET_PARTLY_CLOUDY
+    } CloudsPreset;
+    void applyPreset(CloudsPreset preset);
+};
+
+}
+}
+
+#endif // CLOUDSDEFINITION_H
--- a/src/definition/Layers.cpp
+++ b/src/definition/Layers.cpp
@ -7,6 +7,10 @@ Layers::Layers(BaseDefinition* parent, LayerConstructor layer_constructor, Layer
    {
        this->legacy_type = *legacy_type;
    }
+    else
+    {
+        this->legacy_type.callback_create = NULL;
+    }
    max_layer_count = 100;
    null_layer = layer_constructor(this);
 }
@ -46,12 +50,12 @@ void Layers::setMaxLayerCount(int max_layer_count)
    // TODO Delete overlimit layers ?
 }

-int Layers::count()
+int Layers::count() const
 {
    return layers.count();
 }

-BaseDefinition* Layers::getLayer(int position)
+BaseDefinition* Layers::getLayer(int position) const
 {
    if (position >= 0 and position < layers.size())
    {
@ -64,7 +68,7 @@ BaseDefinition* Layers::getLayer(int position)
    }
 }

-int Layers::findLayer(BaseDefinition* layer)
+int Layers::findLayer(BaseDefinition* layer) const
 {
    int result = layers.indexOf(layer);
    if (result < 0)
@ -145,11 +149,20 @@ Layers* layersCreate(LayerType type, int max_layer_count)
 }

 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)
 {
@ -177,9 +190,16 @@ void layersLoad(PackStream* stream, Layers* layers)
 }

 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)
 {
@ -197,12 +217,21 @@ int layersCount(Layers* layers)
 }

 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);
@ -213,6 +242,13 @@ int layersAddLayer(Layers* layers, void* definition)
        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)
 {
--- a/src/definition/Layers.h
+++ b/src/definition/Layers.h
@ -26,9 +26,9 @@ public:

    void setMaxLayerCount(int max_layer_count);

-    int count();
-    BaseDefinition* getLayer(int position);
-    int findLayer(BaseDefinition* layer);
+    int count() const;
+    BaseDefinition* getLayer(int position) const;
+    int findLayer(BaseDefinition* layer) const;

    /**
     * @brief Add a new layer
@ -47,9 +47,10 @@ public:

    // Transitional data storage
    LayerType legacy_type;
-
-private:
+    // TODO make private when there is no more legacy layer
    LayerConstructor layer_constructor;
+
+public:
    int max_layer_count;
    QList<BaseDefinition*> layers;
    BaseDefinition* null_layer;
--- a/src/definition/definition.pro
+++ b/src/definition/definition.pro
@ -19,7 +19,9 @@ SOURCES += \
    LegacyLayer.cpp \
    WaterDefinition.cpp \
    SurfaceMaterial.cpp \
-    CameraDefinition.cpp
+    CameraDefinition.cpp \
+    CloudsDefinition.cpp \
+    CloudLayerDefinition.cpp

 HEADERS +=\
        definition_global.h \
@ -28,7 +30,9 @@ HEADERS +=\
    LegacyLayer.h \
    WaterDefinition.h \
    SurfaceMaterial.h \
-    CameraDefinition.h
+    CameraDefinition.h \
+    CloudsDefinition.h \
+    CloudLayerDefinition.h

 unix:!symbian {
    maemo5 {
--- a/src/definition/definition_global.h
+++ b/src/definition/definition_global.h
@ -17,6 +17,8 @@ namespace definition {
    class SurfaceMaterial;
    class WaterDefinition;
    class Layers;
+    class CloudsDefinition;
+    class CloudLayerDefinition;
 }
 }
 using namespace paysages::definition;
--- a/src/interface/desktop/baseform.h
+++ b/src/interface/desktop/baseform.h
@ -9,7 +9,6 @@
 class QPushButton;
 class QComboBox;
 class ColorGradation;
-class Curve;

 namespace paysages {
 namespace desktop {
--- a/src/interface/desktop/dialogcolorgradation.cpp
+++ b/src/interface/desktop/dialogcolorgradation.cpp
@ -10,7 +10,9 @@
 #include <QSlider>
 #include <QScrollArea>
 #include <QPushButton>
+#include "Curve.h"
 #include "tools.h"
+#include "previewcolorgradation.h"
 #include "widgetcurveeditor.h"

 /**************** Dialog ****************/
@ -111,7 +113,7 @@ DialogColorGradation::DialogColorGradation(QWidget *parent, ColorGradation* grad
    buttons->layout()->addWidget(_button_cancel);
    QObject::connect(_button_cancel, SIGNAL(clicked()), this, SLOT(reject()));

-    _curve = curveCreate();
+    _curve = new Curve;

    setWindowTitle(tr("Paysages 3D - Color gradation editor"));
    resize(900, 600);
@ -122,7 +124,7 @@ DialogColorGradation::DialogColorGradation(QWidget *parent, ColorGradation* grad
 DialogColorGradation::~DialogColorGradation()
 {
    colorGradationDelete(_current);
-    curveDelete(_curve);
+    delete _curve;
 }

 bool DialogColorGradation::getGradation(QWidget* parent, ColorGradation* gradation)
@ -181,10 +183,9 @@ void DialogColorGradation::selectBlue()

 void DialogColorGradation::updateColors()
 {
-    Curve* curve;
+    Curve curve;

-    curve = curveCreate();
-    _curve_editor->getCurve(curve);
+    _curve_editor->getCurve(&curve);

    switch (_selected)
    {
@ -194,23 +195,21 @@ void DialogColorGradation::updateColors()
        _preview_blue->update();
        break;
    case 1:
-        colorGradationSetRedCurve(_current, curve);
+        colorGradationSetRedCurve(_current, &curve);
        _preview_red->update();
        break;
    case 2:
-        colorGradationSetGreenCurve(_current, curve);
+        colorGradationSetGreenCurve(_current, &curve);
        _preview_green->update();
        break;
    case 3:
-        colorGradationSetBlueCurve(_current, curve);
+        colorGradationSetBlueCurve(_current, &curve);
        _preview_blue->update();
        break;
    default:
        ;
    }
    _preview_final->update();
-
-    curveDelete(curve);
 }

 void DialogColorGradation::revertToCurrent()
--- a/src/interface/desktop/dialogcolorgradation.h
+++ b/src/interface/desktop/dialogcolorgradation.h
@ -1,14 +1,15 @@
 #ifndef _PAYSAGES_QT_DIALOGCOLORGRADATION_H_
 #define _PAYSAGES_QT_DIALOGCOLORGRADATION_H_

+#include "desktop_global.h"
+
 #include <QDialog>
-#include "widgetcurveeditor.h"
-#include "previewcolorgradation.h"

 #include "tools/color.h"
-#include "tools/curve.h"

 class QPushButton;
+class WidgetCurveEditor;
+class PreviewColorGradation;

 class DialogColorGradation : public QDialog
 {
--- a/src/interface/desktop/dialogcurve.cpp
+++ b/src/interface/desktop/dialogcurve.cpp
@ -1,15 +1,9 @@
 #include "dialogcurve.h"

-#include <QVBoxLayout>
-#include <QHBoxLayout>
 #include <QGridLayout>
-#include <QImage>
 #include <QLabel>
-#include <QColor>
-#include <QPainter>
-#include <QSlider>
-#include <QScrollArea>
 #include <QPushButton>
+#include "Curve.h"
 #include "baseform.h"
 #include "tools.h"
 #include "widgetcurveeditor.h"
@ -23,8 +17,8 @@ DialogCurve::DialogCurve(QWidget *parent, Curve* curve, double xmin, double xmax
    QLabel* label;

    _base = curve;
-    _current = curveCreate();
-    curveCopy(_base, _current);
+    _current = new Curve;
+    _base->copy(_current);

    setLayout(new QVBoxLayout());

@ -71,7 +65,7 @@ DialogCurve::DialogCurve(QWidget *parent, Curve* curve, double xmin, double xmax

 DialogCurve::~DialogCurve()
 {
-    curveDelete(_current);
+    delete _current;
 }

 bool DialogCurve::getCurve(QWidget* parent, Curve* curve, double xmin, double xmax, double ymin, double ymax, QString xlabel, QString ylabel)
@ -94,13 +88,13 @@ void DialogCurve::closeEvent(QCloseEvent*)
 void DialogCurve::accept()
 {
    _curve_editor->getCurve(_current);
-    curveCopy(_current, _base);
+    _current->copy(_base);
    QDialog::accept();
 }

 void DialogCurve::revert()
 {
-    curveCopy(_base, _current);
+    _base->copy(_current);
    revertToCurrent();
 }

--- a/src/interface/desktop/dialogcurve.h
+++ b/src/interface/desktop/dialogcurve.h
@ -1,11 +1,12 @@
 #ifndef _PAYSAGES_QT_DIALOGCURVE_H_
 #define _PAYSAGES_QT_DIALOGCURVE_H_

-#include <QDialog>
-#include <QPushButton>
-#include "widgetcurveeditor.h"
+#include "desktop_global.h"

-#include "tools/curve.h"
+#include <QDialog>
+
+class QPushButton;
+class WidgetCurveEditor;

 class DialogCurve : public QDialog
 {
--- a/src/interface/desktop/formclouds.cpp
+++ b/src/interface/desktop/formclouds.cpp
@ -6,6 +6,8 @@
 #include "Scenery.h"
 #include "BasePreview.h"
 #include "renderer.h"
+#include "CloudsDefinition.h"
+#include "CloudLayerDefinition.h"

 #include "tools.h"

@ -13,7 +15,7 @@
 class PreviewCloudsCoverage:public BasePreview
 {
 public:
-    PreviewCloudsCoverage(QWidget* parent, CloudsLayerDefinition* layer):BasePreview(parent)
+    PreviewCloudsCoverage(QWidget* parent, CloudLayerDefinition* layer):BasePreview(parent)
    {
        _renderer = cloudsPreviewCoverageCreateRenderer();
        _3d = true;
@ -47,14 +49,14 @@ protected:

 private:
    Renderer* _renderer;
-    CloudsLayerDefinition* _original_layer;
+    CloudLayerDefinition* _original_layer;
    bool _3d;
 };

 class PreviewCloudsColor:public BasePreview
 {
 public:
-    PreviewCloudsColor(QWidget* parent, CloudsLayerDefinition* layer):BasePreview(parent)
+    PreviewCloudsColor(QWidget* parent, CloudLayerDefinition* layer):BasePreview(parent)
    {
        _original_layer = layer;

@ -78,7 +80,7 @@ protected:
    }
 private:
    Renderer* _renderer;
-    CloudsLayerDefinition* _original_layer;
+    CloudLayerDefinition* _original_layer;
 };

 /**************** Form ****************/
@ -90,8 +92,8 @@ FormClouds::FormClouds(QWidget *parent):
    addAutoPreset(tr("Stratocumulus"));
    addAutoPreset(tr("Stratus"));

-    _definition = (CloudsDefinition*)CloudsDefinitionClass.create();
-    _layer = (CloudsLayerDefinition*)cloudsGetLayerType().callback_create();
+    _definition = new CloudsDefinition(NULL);
+    _layer = new CloudLayerDefinition(NULL);

    _previewCoverage = new PreviewCloudsCoverage(parent, _layer);
    _previewColor = new PreviewCloudsColor(parent, _layer);
@ -105,19 +107,19 @@ FormClouds::FormClouds(QWidget *parent):
    addInputDouble(tr("Shape scaling"), &_layer->shape_scaling, 3.0, 30.0, 0.3, 3.0);
    addInputDouble(tr("Edge scaling"), &_layer->edge_scaling, 0.5, 5.0, 0.05, 0.5);
    addInputDouble(tr("Edge length"), &_layer->edge_length, 0.0, 1.0, 0.01, 0.1);
-    addInputMaterial(tr("Material"), &_layer->material);
+    addInputMaterial(tr("Material"), _layer->material);
    addInputDouble(tr("Hardness to light"), &_layer->hardness, 0.0, 1.0, 0.01, 0.1);
    addInputDouble(tr("Transparency depth"), &_layer->transparencydepth, 0.0, 10.0, 0.1, 1.0);
    addInputDouble(tr("Light traversal depth"), &_layer->lighttraversal, 0.0, 10.0, 0.1, 1.0);
    addInputDouble(tr("Minimum lighting"), &_layer->minimumlight, 0.0, 1.0, 0.01, 0.1);

-    setLayers(_definition->layers);
+    setLayers(_definition);
 }

 FormClouds::~FormClouds()
 {
-    CloudsDefinitionClass.destroy(_definition);
-    cloudsGetLayerType().callback_delete(_layer);
+    delete _layer;
+    delete _definition;

    delete _previewCoverage;
    delete _previewColor;
@ -137,16 +139,16 @@ void FormClouds::applyConfig()

 void FormClouds::layerReadCurrentFrom(void* layer_definition)
 {
-    cloudsGetLayerType().callback_copy((CloudsLayerDefinition*)layer_definition, _layer);
+    ((CloudLayerDefinition*)layer_definition)->copy(_layer);
 }

 void FormClouds::layerWriteCurrentTo(void* layer_definition)
 {
-    cloudsGetLayerType().callback_copy(_layer, (CloudsLayerDefinition*)layer_definition);
+    _layer->copy((CloudLayerDefinition*)layer_definition);
 }

 void FormClouds::autoPresetSelected(int preset)
 {
-    cloudsLayerAutoPreset(_layer, (CloudsLayerPreset)preset);
+    _layer->applyPreset((CloudLayerDefinition::CloudsLayerPreset)preset);
    BaseForm::autoPresetSelected(preset);
 }
--- a/src/interface/desktop/formclouds.h
+++ b/src/interface/desktop/formclouds.h
@ -26,7 +26,7 @@ protected:

 private:
    CloudsDefinition* _definition;
-    CloudsLayerDefinition* _layer;
+    CloudLayerDefinition* _layer;
    BasePreview* _previewCoverage;
    BasePreview* _previewColor;
 };
--- a/src/interface/desktop/formrender.cpp
+++ b/src/interface/desktop/formrender.cpp
@ -14,20 +14,20 @@
 #include "PackStream.h"
 #include "SoftwareRenderer.h"
 #include "BasePreview.h"
+#include "CloudsDefinition.h"
 #include "CameraDefinition.h"

 /**************** Previews ****************/
 class PreviewRenderLandscape : public BasePreview
 {
 public:
-
    PreviewRenderLandscape(QWidget* parent) : BasePreview(parent)
    {
        _renderer = new SoftwareRenderer();
        _renderer->getCameraLocation = _getCameraLocation;
        lightingManagerDisableSpecularity(_renderer->lighting);

-        _no_clouds = (CloudsDefinition*) CloudsDefinitionClass.create();
+        _no_clouds = new CloudsDefinition(NULL);
        _clouds_enabled = true;

        addOsd(QString("geolocation"));
@ -40,11 +40,10 @@ public:
    ~PreviewRenderLandscape()
    {
        delete _renderer;
-        CloudsDefinitionClass.destroy(_no_clouds);
+        delete _no_clouds;
    }

 protected:
-
    Color getColor(double x, double y)
    {
        Vector3 location;
@ -84,6 +83,7 @@ protected:
            redraw();
        }
    }
+
 private:
    Renderer* _renderer;
    bool _clouds_enabled;
--- a/src/interface/desktop/inputcurve.cpp
+++ b/src/interface/desktop/inputcurve.cpp
@ -3,8 +3,8 @@
 #include <QLabel>
 #include <QPushButton>
 #include <QPainter>
+#include "Curve.h"
 #include "dialogcurve.h"
-#include "tools.h"

 class CurveSmallPreview:public QWidget
 {
@ -35,9 +35,9 @@ public:
        {
            painter.setPen(QColor(0, 0, 0));
            position = _xmin + (_xmax - _xmin) * (double)x / (double)(width - 1);
-            value = (curveGetValue(_curve, position) - _ymin) * (_ymax - _ymin);
-            prev_value = (curveGetValue(_curve, position - (_xmax - _xmin) / (double)(width - 1)) - _ymin) * (_ymax - _ymin);
-            next_value = (curveGetValue(_curve, position + (_xmax - _xmin) / (double)(width - 1)) - _ymin) * (_ymax - _ymin);
+            value = (_curve->getValue(position) - _ymin) * (_ymax - _ymin);
+            prev_value = (_curve->getValue(position - (_xmax - _xmin) / (double)(width - 1)) - _ymin) * (_ymax - _ymin);
+            next_value = (_curve->getValue(position + (_xmax - _xmin) / (double)(width - 1)) - _ymin) * (_ymax - _ymin);

            painter.drawLine(x, height - 1 - (int)((value + (prev_value - value) / 2.0) * (double)(height - 1)), x, height - 1 - (int)((value + (next_value - value) / 2.0) * (double)(height - 1)));
            painter.drawPoint(x, height - 1 - (int)(value * (double)(height - 1)));
--- a/src/interface/desktop/inputcurve.h
+++ b/src/interface/desktop/inputcurve.h
@ -1,11 +1,11 @@
 #ifndef _PAYSAGES_QT_INPUTCURVE_H_
 #define _PAYSAGES_QT_INPUTCURVE_H_

+#include "desktop_global.h"
+
 #include <QWidget>
 #include "baseinput.h"

-#include "tools/curve.h"
-
 class InputCurve:public BaseInput
 {
    Q_OBJECT
--- a/src/interface/desktop/previewcolorgradation.cpp
+++ b/src/interface/desktop/previewcolorgradation.cpp
@ -8,6 +8,7 @@
 #include <QSlider>
 #include <QScrollArea>
 #include <QPushButton>
+#include "Curve.h"
 #include "baseform.h"
 #include "tools.h"
 #include "widgetcurveeditor.h"
@ -21,24 +22,21 @@ PreviewColorGradation::PreviewColorGradation(QWidget* parent, ColorGradation* gr

 void PreviewColorGradation::paintEvent(QPaintEvent*)
 {
-    Curve* curve;
-
+    Curve curve;
    QPainter painter(this);
    int width = this->width();
    int height = this->height();

-    curve = curveCreate();
-
    switch (band)
    {
        case COLORGRADATIONBAND_RED:
-            colorGradationGetRedCurve(gradation, curve);
+            colorGradationGetRedCurve(gradation, &curve);
            break;
        case COLORGRADATIONBAND_GREEN:
-            colorGradationGetGreenCurve(gradation, curve);
+            colorGradationGetGreenCurve(gradation, &curve);
            break;
        case COLORGRADATIONBAND_BLUE:
-            colorGradationGetBlueCurve(gradation, curve);
+            colorGradationGetBlueCurve(gradation, &curve);
            break;
        default:
            break;
@ -49,13 +47,13 @@ void PreviewColorGradation::paintEvent(QPaintEvent*)
        switch (band)
        {
            case COLORGRADATIONBAND_RED:
-                painter.setPen(QColor::fromRgbF(curveGetValue(curve, (double)x / (double)width), 0.0, 0.0));
+                painter.setPen(QColor::fromRgbF(curve.getValue((double)x / (double)width), 0.0, 0.0));
                break;
            case COLORGRADATIONBAND_GREEN:
-                painter.setPen(QColor::fromRgbF(0.0, curveGetValue(curve, (double)x / (double)width), 0.0));
+                painter.setPen(QColor::fromRgbF(0.0, curve.getValue((double)x / (double)width), 0.0));
                break;
            case COLORGRADATIONBAND_BLUE:
-                painter.setPen(QColor::fromRgbF(0.0, 0.0, curveGetValue(curve, (double)x / (double)width)));
+                painter.setPen(QColor::fromRgbF(0.0, 0.0, curve.getValue((double)x / (double)width)));
                break;
            case COLORGRADATIONBAND_FINAL:
                painter.setPen(colorToQColor(colorGradationGet(gradation, (double)x / (double)width)));
@ -63,8 +61,6 @@ void PreviewColorGradation::paintEvent(QPaintEvent*)
        }
        painter.drawLine(x, 0, x, height - 1);
    }
-
-    curveDelete(curve);
 }

 void PreviewColorGradation::mouseReleaseEvent(QMouseEvent*)
--- a/src/interface/desktop/widgetcurveeditor.cpp
+++ b/src/interface/desktop/widgetcurveeditor.cpp
@ -3,11 +3,12 @@
 #include <QPainter>
 #include <QPaintEngine>
 #include <QMouseEvent>
-#include "tools.h"
+#include "Curve.h"
+#include "tools/euclid.h"

 WidgetCurveEditor::WidgetCurveEditor(QWidget *parent, double xmin, double xmax, double ymin, double ymax) : QWidget(parent)
 {
-    _curve = curveCreate();
+    _curve = new Curve;
    _dragged = -1;
    _pen = QColor(0, 0, 0);

@ -21,7 +22,7 @@ WidgetCurveEditor::WidgetCurveEditor(QWidget *parent, double xmin, double xmax,

 WidgetCurveEditor::~WidgetCurveEditor()
 {
-    curveDelete(_curve);
+    delete _curve;
 }

 void WidgetCurveEditor::setAxisLabels(QString xlabel, QString ylabel)
@ -32,13 +33,13 @@ void WidgetCurveEditor::setAxisLabels(QString xlabel, QString ylabel)

 void WidgetCurveEditor::setCurve(Curve* curve)
 {
-    curveCopy(curve, _curve);
+    curve->copy(_curve);
    update();
 }

 void WidgetCurveEditor::getCurve(Curve* curve)
 {
-    curveCopy(_curve, curve);
+    _curve->copy(curve);
 }

 void WidgetCurveEditor::setPenColor(QColor color)
@ -94,20 +95,20 @@ void WidgetCurveEditor::paintEvent(QPaintEvent*)
    {
        position = ((double)x / dwidth) * (_xmax - _xmin) + _xmin;

-        value = (curveGetValue(_curve, position) - _ymin) / (_ymax - _ymin);
-        prev_value = curveGetValue(_curve, position - (_xmax - _xmin) / dwidth);
-        next_value = curveGetValue(_curve, position + (_xmax - _xmin) / dwidth);
+        value = (_curve->getValue(position) - _ymin) / (_ymax - _ymin);
+        prev_value = _curve->getValue(position - (_xmax - _xmin) / dwidth);
+        next_value = _curve->getValue(position + (_xmax - _xmin) / dwidth);

        painter.drawLine(x, height - 1 - (int)((value + (prev_value - value) / 2.0) * dheight), x, height - 1 - (int)((value + (next_value - value) / 2.0) * dheight));
        painter.drawPoint(x, height - 1 - (int)(value * dheight));
    }

    // Draw handles
-    n = curveGetPointCount(_curve);
+    n = _curve->getPointCount();
    painter.setRenderHints(QPainter::Antialiasing | QPainter::HighQualityAntialiasing, true);
    for (i = 0; i < n; i++)
    {
-        curveGetPoint(_curve, i, &point);
+        _curve->getPoint(i, &point);
        painter.drawEllipse(QPointF((int)((point.position - _xmin) / (_xmax - _xmin) * dwidth), height - 1 - (int)((point.value - _ymin) / (_ymax - _ymin) * dheight)), 4.0, 4.0);
    }
 }
@ -135,7 +136,7 @@ void WidgetCurveEditor::mouseMoveEvent(QMouseEvent* event)
        point.value = (point.value < _ymin) ? _ymin : point.value;
        point.value = (point.value > _ymax) ? _ymax : point.value;

-        curveSetPoint(_curve, _dragged, &point);
+        _curve->setPoint(_dragged, point);

        update();

@ -154,7 +155,7 @@ void WidgetCurveEditor::mouseReleaseEvent(QMouseEvent* event)
        clicked = getPointAt(event->x(), event->y());
        if (clicked >= 0)
        {
-            curveRemovePoint(_curve, clicked);
+            _curve->removePoint(clicked);
            update();
            emit liveChanged();
        }
@ -162,7 +163,7 @@ void WidgetCurveEditor::mouseReleaseEvent(QMouseEvent* event)
    else if (event->button() == Qt::LeftButton && _dragged >= 0)
    {
        _dragged = -1;
-        curveValidate(_curve);
+        _curve->validate();
        update();
    }

@ -178,8 +179,8 @@ void WidgetCurveEditor::mouseDoubleClickEvent(QMouseEvent* event)
        if (getPointAt(event->x(), event->y()) < 0)
        {
            screenToCurve(event->x(), event->y(), &point.position, &point.value);
-            curveAddPoint(_curve, &point);
-            curveValidate(_curve);
+            _curve->addPoint(point);
+            _curve->validate();
            update();
            emit liveChanged();
        }
@ -206,7 +207,7 @@ int WidgetCurveEditor::getPointAt(int x, int y)
    CurvePoint point;
    int dx, dy;

-    n = curveGetPointCount(_curve);
+    n = _curve->getPointCount();
    if (n < 1)
    {
        return -1;
@ -217,7 +218,7 @@ int WidgetCurveEditor::getPointAt(int x, int y)
    distance = 0.0;
    for (int i = 0; i < n; i++)
    {
-        curveGetPoint(_curve, i, &point);
+        _curve->getPoint(i, &point);
        curveToScreen(point.position, point.value, &dx, &dy);
        ndistance = euclidGetDistance2D((double)x, (double)y, (double)dx, (double)dy);
        if (nearest < 0 || ndistance < distance)
--- a/src/interface/desktop/widgetcurveeditor.h
+++ b/src/interface/desktop/widgetcurveeditor.h
@ -1,9 +1,10 @@
 #ifndef _PAYSAGES_QT_WIDGETCURVEEDITOR_H_
 #define _PAYSAGES_QT_WIDGETCURVEEDITOR_H_

+#include "desktop_global.h"
+
 #include <QWidget>
 #include <QColor>
-#include "tools/curve.h"

 class WidgetCurveEditor : public QWidget
 {
--- a/src/rendering/Scenery.cpp
+++ b/src/rendering/Scenery.cpp
@ -6,7 +6,7 @@
 #include "PackStream.h"
 #include "atmosphere/public.h"
 #include "CameraDefinition.h"
-#include "clouds/public.h"
+#include "CloudsDefinition.h"
 #include "terrain/public.h"
 #include "textures/public.h"
 #include "water/public.h"
@ -21,13 +21,14 @@ Scenery::Scenery():
 {
    atmosphere = (AtmosphereDefinition*)AtmosphereDefinitionClass.create();
    camera = new CameraDefinition;
-    clouds = (CloudsDefinition*)CloudsDefinitionClass.create();
+    clouds = new CloudsDefinition(this);
    terrain = (TerrainDefinition*)TerrainDefinitionClass.create();
    textures = (TexturesDefinition*)TexturesDefinitionClass.create();
    water = new WaterDefinition(this);

    addChild(camera);
    addChild(water);
+    addChild(clouds);

    _custom_load = NULL;
    _custom_save = NULL;
@ -37,7 +38,6 @@ Scenery::Scenery():
 Scenery::~Scenery()
 {
    AtmosphereDefinitionClass.destroy(atmosphere);
-    CloudsDefinitionClass.destroy(clouds);
    TerrainDefinitionClass.destroy(terrain);
    TexturesDefinitionClass.destroy(textures);
 }
@ -61,7 +61,6 @@ void Scenery::save(PackStream* stream) const
    noiseSave(stream);

    AtmosphereDefinitionClass.save(stream, atmosphere);
-    CloudsDefinitionClass.save(stream, clouds);
    TerrainDefinitionClass.save(stream, terrain);
    TexturesDefinitionClass.save(stream, textures);

@ -78,7 +77,6 @@ void Scenery::load(PackStream* stream)
    noiseLoad(stream);

    AtmosphereDefinitionClass.load(stream, atmosphere);
-    CloudsDefinitionClass.load(stream, clouds);
    TerrainDefinitionClass.load(stream, terrain);
    TexturesDefinitionClass.load(stream, textures);

@ -109,7 +107,7 @@ void Scenery::autoPreset(int seed)
    texturesAutoPreset(textures, TEXTURES_PRESET_FULL);
    atmosphereAutoPreset(atmosphere, ATMOSPHERE_PRESET_CLEAR_DAY);
    water->applyPreset(WATER_PRESET_LAKE);
-    cloudsAutoPreset(clouds, CLOUDS_PRESET_PARTLY_CLOUDY);
+    clouds->applyPreset(CloudsDefinition::CLOUDS_PRESET_PARTLY_CLOUDY);

    camera->setLocation(VECTOR_ZERO);
    camera->setTarget(VECTOR_NORTH);
@ -140,12 +138,12 @@ void Scenery::getCamera(CameraDefinition* camera)

 void Scenery::setClouds(CloudsDefinition* clouds)
 {
-    CloudsDefinitionClass.copy(clouds, this->clouds);
+    clouds->copy(this->clouds);
 }

 void Scenery::getClouds(CloudsDefinition* clouds)
 {
-    CloudsDefinitionClass.copy(this->clouds, clouds);
+    this->clouds->copy(clouds);
 }

 void Scenery::setTerrain(TerrainDefinition* terrain)
@ -178,6 +176,11 @@ void Scenery::getWater(WaterDefinition* water)
    this->water->copy(water);
 }

+
+
+
+#include "clouds/public.h"
+
 static RayCastingResult _rayWalking(Renderer* renderer, Vector3 location, Vector3 direction, int, int, int, int)
 {
    RayCastingResult result;
--- a/src/rendering/Scenery.h
+++ b/src/rendering/Scenery.h
@ -6,7 +6,6 @@
 #include "BaseDefinition.h"

 class AtmosphereDefinition;
-class CloudsDefinition;
 class TerrainDefinition;
 class TexturesDefinition;
 class Renderer;
--- a/src/rendering/clouds/clo_definition.cpp
+++ b/src/rendering/clouds/clo_definition.cpp
@ -1,229 +0,0 @@
-#include "private.h"
-
-#include <stdlib.h>
-#include "PackStream.h"
-#include "NoiseGenerator.h"
-
-/******************** Global definition ********************/
-static void _validateDefinition(CloudsDefinition* definition)
-{
-    layersValidate(definition->layers);
-}
-
-static CloudsDefinition* _createDefinition()
-{
-    CloudsDefinition* definition = new CloudsDefinition;
-
-    definition->layers = layersCreate(cloudsGetLayerType(), CLOUDS_MAX_LAYERS);
-
-    return definition;
-}
-
-static void _deleteDefinition(CloudsDefinition* definition)
-{
-    layersDelete(definition->layers);
-    delete definition;
-}
-
-static void _copyDefinition(CloudsDefinition* source, CloudsDefinition* destination)
-{
-    layersCopy(source->layers, destination->layers);
-}
-
-static void _saveDefinition(PackStream* stream, CloudsDefinition* definition)
-{
-    layersSave(stream, definition->layers);
-}
-
-static void _loadDefinition(PackStream* stream, CloudsDefinition* definition)
-{
-    layersLoad(stream, definition->layers);
-}
-
-StandardDefinition CloudsDefinitionClass = {
-    (FuncObjectCreate)_createDefinition,
-    (FuncObjectDelete)_deleteDefinition,
-    (FuncObjectCopy)_copyDefinition,
-    (FuncObjectValidate)_validateDefinition,
-    (FuncObjectSave)_saveDefinition,
-    (FuncObjectLoad)_loadDefinition
-};
-
-/*** Layer definition ***/
-
-void cloudsLayerValidateDefinition(CloudsLayerDefinition* definition)
-{
-    if (definition->shape_scaling < 0.0001)
-    {
-        definition->shape_scaling = 0.00001;
-    }
-    if (definition->edge_scaling < 0.0001)
-    {
-        definition->edge_scaling = 0.00001;
-    }
-
-    curveClear(definition->_coverage_by_altitude);
-    definition->_shape_noise->clearLevels();
-    definition->_edge_noise->clearLevels();
-    definition->_coverage_noise->clearLevels();
-
-    definition->_coverage_noise->addLevelsSimple(2, 10.0, 0.0, 1.0, 0.0);
-    definition->_coverage_noise->addLevelsSimple(2, 1.0, 0.0, 1.0, 0.0);
-    definition->_coverage_noise->setFunctionParams(NOISE_FUNCTION_NAIVE, 0.0, 0.0);
-    switch (definition->type)
-    {
-        case CLOUDS_TYPE_CIRRUS:
-            curveQuickAddPoint(definition->_coverage_by_altitude, 0.0, 0.0);
-            curveQuickAddPoint(definition->_coverage_by_altitude, 0.5, 1.0);
-            curveQuickAddPoint(definition->_coverage_by_altitude, 1.0, 0.0);
-            definition->_shape_noise->addLevelsSimple(3, 1.0, 0.0, 1.0, 0.5);
-            definition->_shape_noise->setFunctionParams(NOISE_FUNCTION_SIMPLEX, 0.0, 0.0);
-            definition->_edge_noise->addLevelsSimple(4, 1.0, -0.5, 0.5, 0.5);
-            definition->_edge_noise->setFunctionParams(NOISE_FUNCTION_SIMPLEX, -0.2, 0.0);
-            break;
-        case CLOUDS_TYPE_CUMULUS:
-            curveQuickAddPoint(definition->_coverage_by_altitude, 0.0, 0.0);
-            curveQuickAddPoint(definition->_coverage_by_altitude, 0.1, 1.0);
-            curveQuickAddPoint(definition->_coverage_by_altitude, 0.4, 0.8);
-            curveQuickAddPoint(definition->_coverage_by_altitude, 0.7, 1.0);
-            curveQuickAddPoint(definition->_coverage_by_altitude, 1.0, 0.0);
-            definition->_shape_noise->addLevelsSimple(7, 1.0, 0.0, 1.0, 0.5);
-            definition->_shape_noise->setFunctionParams(NOISE_FUNCTION_SIMPLEX, 0.4, 0.0);
-            definition->_edge_noise->addLevelsSimple(4, 1.0, -0.5, 0.5, 0.5);
-            definition->_edge_noise->setFunctionParams(NOISE_FUNCTION_SIMPLEX, 0.8, 0.0);
-            break;
-        case CLOUDS_TYPE_STRATOCUMULUS:
-            curveQuickAddPoint(definition->_coverage_by_altitude, 0.0, 0.0);
-            curveQuickAddPoint(definition->_coverage_by_altitude, 0.2, 1.0);
-            curveQuickAddPoint(definition->_coverage_by_altitude, 0.5, 1.0);
-            curveQuickAddPoint(definition->_coverage_by_altitude, 1.0, 0.0);
-            definition->_shape_noise->addLevelsSimple(4, 1.0, 0.0, 1.0, 0.5);
-            definition->_shape_noise->setFunctionParams(NOISE_FUNCTION_SIMPLEX, 0.3, 0.0);
-            definition->_edge_noise->addLevelsSimple(6, 1.0, -0.5, 0.5, 0.5);
-            definition->_edge_noise->setFunctionParams(NOISE_FUNCTION_SIMPLEX, 0.5, 0.0);
-            break;
-        case CLOUDS_TYPE_STRATUS:
-            curveQuickAddPoint(definition->_coverage_by_altitude, 0.0, 0.0);
-            curveQuickAddPoint(definition->_coverage_by_altitude, 0.2, 1.0);
-            curveQuickAddPoint(definition->_coverage_by_altitude, 0.8, 1.0);
-            curveQuickAddPoint(definition->_coverage_by_altitude, 1.0, 0.0);
-            definition->_shape_noise->addLevelsSimple(3, 1.0, 0.0, 1.0, 0.5);
-            definition->_shape_noise->setFunctionParams(NOISE_FUNCTION_SIMPLEX, -0.3, 0.0);
-            definition->_edge_noise->addLevelsSimple(4, 1.0, -0.5, 0.5, 0.5);
-            definition->_edge_noise->setFunctionParams(NOISE_FUNCTION_SIMPLEX, -0.5, 0.0);
-            break;
-        default:
-            break;
-    }
-
-    definition->_coverage_noise->normalizeAmplitude(-1.0, 3.0, 0);
-    definition->_shape_noise->normalizeAmplitude(-0.5, 0.5, 0);
-    definition->_edge_noise->normalizeAmplitude(-0.5, 0.5, 0);
-
-    materialValidate(&definition->material);
-}
-
-CloudsLayerDefinition* cloudsLayerCreateDefinition()
-{
-    CloudsLayerDefinition* result;
-
-    result = new CloudsLayerDefinition;
-    result->_coverage_by_altitude = curveCreate();
-    result->_coverage_noise = new NoiseGenerator();
-    result->_shape_noise = new NoiseGenerator();
-    result->_edge_noise = new NoiseGenerator();
-
-    cloudsLayerAutoPreset(result, CLOUDS_LAYER_PRESET_CIRRUS);
-
-    return result;
-}
-
-void cloudsLayerDeleteDefinition(CloudsLayerDefinition* definition)
-{
-    curveDelete(definition->_coverage_by_altitude);
-    delete definition->_coverage_noise;
-    delete definition->_shape_noise;
-    delete definition->_edge_noise;
-    delete definition;
-}
-
-void cloudsLayerCopyDefinition(CloudsLayerDefinition* source, CloudsLayerDefinition* destination)
-{
-    CloudsLayerDefinition temp;
-
-    temp = *destination;
-    *destination = *source;
-
-    destination->_coverage_by_altitude = temp._coverage_by_altitude;
-    curveCopy(source->_coverage_by_altitude, destination->_coverage_by_altitude);
-
-    destination->_coverage_noise = temp._coverage_noise;
-    source->_coverage_noise->copy(destination->_coverage_noise);
-
-    destination->_shape_noise = temp._shape_noise;
-    source->_shape_noise->copy(destination->_shape_noise);
-
-    destination->_edge_noise = temp._edge_noise;
-    source->_edge_noise->copy(destination->_edge_noise);
-}
-
-void _cloudsLayerSave(PackStream* stream, CloudsLayerDefinition* layer)
-{
-    int clouds_type = (int)layer->type;
-
-    stream->write(&clouds_type);
-    stream->write(&layer->lower_altitude);
-    stream->write(&layer->thickness);
-    curveSave(stream, layer->_coverage_by_altitude);
-    layer->_coverage_noise->save(stream);
-    layer->_shape_noise->save(stream);
-    layer->_edge_noise->save(stream);
-    materialSave(stream, &layer->material);
-    stream->write(&layer->hardness);
-    stream->write(&layer->transparencydepth);
-    stream->write(&layer->lighttraversal);
-    stream->write(&layer->minimumlight);
-    stream->write(&layer->shape_scaling);
-    stream->write(&layer->edge_scaling);
-    stream->write(&layer->edge_length);
-    stream->write(&layer->base_coverage);
-}
-
-void _cloudsLayerLoad(PackStream* stream, CloudsLayerDefinition* layer)
-{
-    int clouds_type;
-
-    stream->read(&clouds_type);
-    layer->type = (CloudsType)clouds_type;
-    stream->read(&layer->lower_altitude);
-    stream->read(&layer->thickness);
-    curveLoad(stream, layer->_coverage_by_altitude);
-    layer->_coverage_noise->load(stream);
-    layer->_shape_noise->load(stream);
-    layer->_edge_noise->load(stream);
-    materialLoad(stream, &layer->material);
-    stream->read(&layer->hardness);
-    stream->read(&layer->transparencydepth);
-    stream->read(&layer->lighttraversal);
-    stream->read(&layer->minimumlight);
-    stream->read(&layer->shape_scaling);
-    stream->read(&layer->edge_scaling);
-    stream->read(&layer->edge_length);
-    stream->read(&layer->base_coverage);
-
-    cloudsLayerValidateDefinition(layer);
-}
-
-LayerType cloudsGetLayerType()
-{
-    LayerType result;
-
-    result.callback_create = (LayerCallbackCreate)cloudsLayerCreateDefinition;
-    result.callback_delete = (LayerCallbackDelete)cloudsLayerDeleteDefinition;
-    result.callback_copy = (LayerCallbackCopy)cloudsLayerCopyDefinition;
-    result.callback_validate = (LayerCallbackValidate)cloudsLayerValidateDefinition;
-    result.callback_save = (LayerCallbackSave)_cloudsLayerSave;
-    result.callback_load = (LayerCallbackLoad)_cloudsLayerLoad;
-
-    return result;
-}
--- a/src/rendering/clouds/clo_density.cpp
+++ b/src/rendering/clouds/clo_density.cpp
@ -1,9 +1,10 @@
 #include "clo_density.h"

-#include "../tools.h"
 #include "NoiseGenerator.h"
+#include "CloudLayerDefinition.h"
+#include "Curve.h"

-double cloudsGetLayerCoverage(CloudsLayerDefinition* layer, Vector3 location)
+double cloudsGetLayerCoverage(CloudLayerDefinition* layer, Vector3 location)
 {
    if (layer->base_coverage <= 0.0)
    {
@ -14,7 +15,7 @@ double cloudsGetLayerCoverage(CloudsLayerDefinition* layer, Vector3 location)
        double coverage = 0.5 + layer->_coverage_noise->get2DTotal(location.x / layer->shape_scaling, location.z / layer->shape_scaling);
        coverage -= (1.0 - layer->base_coverage);

-        coverage *= curveGetValue(layer->_coverage_by_altitude, (location.y - layer->lower_altitude) / layer->thickness);
+        coverage *= layer->_coverage_by_altitude->getValue((location.y - layer->lower_altitude) / layer->thickness);

        if (coverage < 0.0)
        {
@ -31,7 +32,7 @@ double cloudsGetLayerCoverage(CloudsLayerDefinition* layer, Vector3 location)
    }
 }

-double cloudsGetLayerDensity(CloudsLayerDefinition* layer, Vector3 location, double coverage)
+double cloudsGetLayerDensity(CloudLayerDefinition* layer, Vector3 location, double coverage)
 {
    if (coverage <= 0.0)
    {
@ -49,7 +50,7 @@ double cloudsGetLayerDensity(CloudsLayerDefinition* layer, Vector3 location, dou
    }
 }

-double cloudsGetEdgeDensity(CloudsLayerDefinition* layer, Vector3 location, double layer_density)
+double cloudsGetEdgeDensity(CloudLayerDefinition* layer, Vector3 location, double layer_density)
 {
    if (layer_density <= 0.0)
    {
@ -67,22 +68,13 @@ double cloudsGetEdgeDensity(CloudsLayerDefinition* layer, Vector3 location, doub
    }
 }

-static double _fakeGetDensity(Renderer* renderer, CloudsLayerDefinition* layer, Vector3 location)
+static double _fakeGetDensity(Renderer*, CloudLayerDefinition*, Vector3)
 {
-    UNUSED(layer);
-    UNUSED(renderer);
-    UNUSED(location);
-
    return 0.0;
 }

-static double _fakeGetEdgeDensity(Renderer* renderer, CloudsLayerDefinition* layer, Vector3 location, double layer_density)
+static double _fakeGetEdgeDensity(Renderer*, CloudLayerDefinition*, Vector3, double)
 {
-    UNUSED(layer);
-    UNUSED(renderer);
-    UNUSED(location);
-    UNUSED(layer_density);
-
    return 0.0;
 }

@ -92,19 +84,15 @@ void cloudsBindFakeDensityToRenderer(CloudsRenderer* renderer)
    renderer->getEdgeDensity = _fakeGetEdgeDensity;
 }

-static double _realGetDensity(Renderer* renderer, CloudsLayerDefinition* layer, Vector3 location)
+static double _realGetDensity(Renderer*, CloudLayerDefinition* layer, Vector3 location)
 {
-    UNUSED(renderer);
-
    double coverage = cloudsGetLayerCoverage(layer, location);

    return cloudsGetLayerDensity(layer, location, coverage);
 }

-static double _realGetEdgeDensity(Renderer* renderer, CloudsLayerDefinition* layer, Vector3 location, double layer_density)
+static double _realGetEdgeDensity(Renderer*, CloudLayerDefinition* layer, Vector3 location, double layer_density)
 {
-    UNUSED(renderer);
-
    return cloudsGetEdgeDensity(layer, location, layer_density);
 }

--- a/src/rendering/clouds/clo_density.h
+++ b/src/rendering/clouds/clo_density.h
@ -13,7 +13,7 @@
 * 0.0 means no cloud is present.
 * 1.0 means full layer.
 */
-RENDERINGSHARED_EXPORT double cloudsGetLayerCoverage(CloudsLayerDefinition* layer, Vector3 location);
+RENDERINGSHARED_EXPORT double cloudsGetLayerCoverage(CloudLayerDefinition* layer, Vector3 location);

 /**
 * Get the global density of a cloud layer at a given point [0.0;1.0].
@ -21,12 +21,12 @@ RENDERINGSHARED_EXPORT double cloudsGetLayerCoverage(CloudsLayerDefinition* laye
 * 0.0 means no cloud is present.
 * 1.0 means full density (deep inside cloud).
 */
-RENDERINGSHARED_EXPORT double cloudsGetLayerDensity(CloudsLayerDefinition* layer, Vector3 location, double coverage);
+RENDERINGSHARED_EXPORT double cloudsGetLayerDensity(CloudLayerDefinition* layer, Vector3 location, double coverage);

 /**
 * Get the local density of a cloud layer at a given point inside an edge [0.0;1.0].
 */
-RENDERINGSHARED_EXPORT double cloudsGetEdgeDensity(CloudsLayerDefinition* layer, Vector3 location, double layer_density);
+RENDERINGSHARED_EXPORT double cloudsGetEdgeDensity(CloudLayerDefinition* layer, Vector3 location, double layer_density);

 /*
 * Bind fake density functions to a renderer.
--- a/src/rendering/clouds/clo_presets.cpp
+++ b/src/rendering/clouds/clo_presets.cpp
@ -1,99 +0,0 @@
-#include "private.h"
-
-#include <cmath>
-#include <cstdlib>
-#include "NoiseGenerator.h"
-
-/*
- * Clouds presets.
- */
-
-void cloudsAutoPreset(CloudsDefinition* definition, CloudsPreset preset)
-{
-    int layer;
-
-    layersClear(definition->layers);
-
-    if (preset == CLOUDS_PRESET_PARTLY_CLOUDY)
-    {
-        layer = layersAddLayer(definition->layers, NULL);
-        cloudsLayerAutoPreset((CloudsLayerDefinition*)layersGetLayer(definition->layers, layer), CLOUDS_LAYER_PRESET_CIRRUS);
-    }
-}
-
-void cloudsLayerAutoPreset(CloudsLayerDefinition* definition, CloudsLayerPreset preset)
-{
-    definition->_coverage_noise->randomizeOffsets();
-    definition->_edge_noise->randomizeOffsets();
-    definition->_shape_noise->randomizeOffsets();
-
-    definition->material.base = colorToHSL(colorFromValues(0.7, 0.7, 0.7, 1.0));
-
-    switch (preset)
-    {
-        case CLOUDS_LAYER_PRESET_CIRRUS:
-            definition->type = CLOUDS_TYPE_CIRRUS;
-            definition->lower_altitude = 25.0;
-            definition->thickness = 2.0;
-            definition->material.reflection = 0.4;
-            definition->material.shininess = 0.5;
-            definition->hardness = 0.0;
-            definition->transparencydepth = 3.0;
-            definition->lighttraversal = 10.0;
-            definition->minimumlight = 0.6;
-            definition->shape_scaling = 8.0;
-            definition->edge_scaling = 2.0;
-            definition->edge_length = 0.8;
-            definition->base_coverage = 0.6;
-            break;
-        case CLOUDS_LAYER_PRESET_CUMULUS:
-            definition->type = CLOUDS_TYPE_CUMULUS;
-            definition->lower_altitude = 15.0;
-            definition->thickness = 15.0;
-            definition->material.reflection = 0.5;
-            definition->material.shininess = 1.2;
-            definition->hardness = 0.25;
-            definition->transparencydepth = 1.5;
-            definition->lighttraversal = 8.0;
-            definition->minimumlight = 0.4;
-            definition->shape_scaling = 20.0;
-            definition->edge_scaling = 2.0;
-            definition->edge_length = 0.0;
-            definition->base_coverage = 0.7;
-            break;
-        case CLOUDS_LAYER_PRESET_STRATOCUMULUS:
-            definition->type = CLOUDS_TYPE_STRATOCUMULUS;
-            definition->lower_altitude = 5.0;
-            definition->thickness = 6.0;
-            definition->material.reflection = 0.3;
-            definition->material.shininess = 0.8;
-            definition->hardness = 0.25;
-            definition->transparencydepth = 1.5;
-            definition->lighttraversal = 7.0;
-            definition->minimumlight = 0.4;
-            definition->shape_scaling = 10.0;
-            definition->edge_scaling = 0.8;
-            definition->edge_length = 0.3;
-            definition->base_coverage = 0.4;
-            break;
-        case CLOUDS_LAYER_PRESET_STRATUS:
-            definition->type = CLOUDS_TYPE_STRATUS;
-            definition->lower_altitude = 3.0;
-            definition->thickness = 4.0;
-            definition->material.reflection = 0.1;
-            definition->material.shininess = 0.8;
-            definition->hardness = 0.1;
-            definition->transparencydepth = 3.0;
-            definition->lighttraversal = 10.0;
-            definition->minimumlight = 0.6;
-            definition->shape_scaling = 8.0;
-            definition->edge_scaling = 2.0;
-            definition->edge_length = 1.0;
-            definition->base_coverage = 0.4;
-            break;
-        default:
-            break;
-    }
-
-    cloudsLayerValidateDefinition(definition);
-}
--- a/src/rendering/clouds/clo_preview.cpp
+++ b/src/rendering/clouds/clo_preview.cpp
@ -3,20 +3,16 @@

 #include "../tools/euclid.h"
 #include "../renderer.h"
-#include "../tools.h"
 #include "atmosphere/public.h"
+#include "CloudsDefinition.h"
+#include "CloudLayerDefinition.h"

 /*
 * Clouds previews.
 */

-Color _fakeApplyLightingToSurface(Renderer* renderer, Vector3 location, Vector3 normal, SurfaceMaterial* material)
+Color _fakeApplyLightingToSurface(Renderer*, Vector3, Vector3, SurfaceMaterial*)
 {
-    UNUSED(renderer);
-    UNUSED(location);
-    UNUSED(normal);
-    UNUSED(material);
-
    return COLOR_WHITE;
 }

@ -28,12 +24,11 @@ Renderer* cloudsPreviewCoverageCreateRenderer()
    return result;
 }

-void cloudsPreviewCoverageBindLayer(Renderer* renderer, CloudsLayerDefinition* layer)
+void cloudsPreviewCoverageBindLayer(Renderer* renderer, CloudLayerDefinition* layer)
 {
-    CloudsDefinition* definition = (CloudsDefinition*)CloudsDefinitionClass.create();
-    layersAddLayer(definition->layers, layer);
-    CloudsRendererClass.bind(renderer, definition);
-    CloudsDefinitionClass.destroy(definition);
+    CloudsDefinition clouds(NULL);
+    clouds.addLayer(layer->newCopy(&clouds));
+    CloudsRendererClass.bind(renderer, &clouds);
 }

 Color cloudsPreviewCoverageGetPixel(Renderer* renderer, double x, double y, double scaling, int perspective)
@ -65,14 +60,10 @@ Color cloudsPreviewCoverageGetPixel(Renderer* renderer, double x, double y, doub
    }
 }

-static void _getLightingStatus(Renderer* renderer, LightStatus* status, Vector3 normal, int opaque)
+static void _getLightingStatus(Renderer*, LightStatus* status, Vector3, int)
 {
    LightDefinition light;

-    UNUSED(renderer);
-    UNUSED(normal);
-    UNUSED(opaque);
-
    light.color.r = 0.5;
    light.color.g = 0.5;
    light.color.b = 0.5;
@ -104,11 +95,8 @@ Renderer* cloudsPreviewMaterialCreateRenderer()
    return result;
 }

-static double _getDensity(Renderer* renderer, CloudsLayerDefinition* layer, Vector3 location)
+static double _getDensity(Renderer*, CloudLayerDefinition* layer, Vector3 location)
 {
-    UNUSED(renderer);
-    UNUSED(layer);
-
    double distance = 2.0 * v3Norm(location) / layer->thickness;
    if (distance > 1.0)
    {
@ -124,14 +112,13 @@ static double _getDensity(Renderer* renderer, CloudsLayerDefinition* layer, Vect
    }
 }

-void cloudsPreviewMaterialBindLayer(Renderer* renderer, CloudsLayerDefinition* layer)
+void cloudsPreviewMaterialBindLayer(Renderer* renderer, CloudLayerDefinition* layer)
 {
-    CloudsDefinition* definition = (CloudsDefinition*)CloudsDefinitionClass.create();
-    layersAddLayer(definition->layers, layer);
-    CloudsRendererClass.bind(renderer, definition);
-    CloudsDefinitionClass.destroy(definition);
+    CloudsDefinition clouds(NULL);
+    clouds.addLayer(layer->newCopy(&clouds));
+    CloudsRendererClass.bind(renderer, &clouds);

-    layer = (CloudsLayerDefinition*)layersGetLayer(renderer->clouds->definition->layers, 0);
+    layer = renderer->clouds->definition->getCloudLayer(0);
    layer->thickness = layer->shape_scaling;
    layer->lower_altitude = -layer->thickness / 2.0;

@ -141,7 +128,7 @@ void cloudsPreviewMaterialBindLayer(Renderer* renderer, CloudsLayerDefinition* l
 Color cloudsPreviewMaterialGetPixel(Renderer* renderer, double x, double y)
 {
    Vector3 start, end;
-    CloudsLayerDefinition* layer = (CloudsLayerDefinition*)layersGetLayer(renderer->clouds->definition->layers, 0);
+    CloudLayerDefinition* layer = renderer->clouds->definition->getCloudLayer(0);
    double thickness = layer->thickness;

    start.x = x * thickness * 0.5;
--- a/src/rendering/clouds/clo_preview.h
+++ b/src/rendering/clouds/clo_preview.h
@ -2,18 +2,17 @@
 #define _PAYSAGES_CLOUDS_PREVIEW_H_

 #include "public.h"
-#include "../tools/euclid.h"

 /**
 * Cloud preview helpers.
 */

 RENDERINGSHARED_EXPORT Renderer* cloudsPreviewCoverageCreateRenderer();
-RENDERINGSHARED_EXPORT void cloudsPreviewCoverageBindLayer(Renderer* renderer, CloudsLayerDefinition* layer);
+RENDERINGSHARED_EXPORT void cloudsPreviewCoverageBindLayer(Renderer* renderer, CloudLayerDefinition* layer);
 RENDERINGSHARED_EXPORT Color cloudsPreviewCoverageGetPixel(Renderer* renderer, double x, double y, double scaling, int perspective);

 RENDERINGSHARED_EXPORT Renderer* cloudsPreviewMaterialCreateRenderer();
-RENDERINGSHARED_EXPORT void cloudsPreviewMaterialBindLayer(Renderer* renderer, CloudsLayerDefinition* layer);
+RENDERINGSHARED_EXPORT void cloudsPreviewMaterialBindLayer(Renderer* renderer, CloudLayerDefinition* layer);
 RENDERINGSHARED_EXPORT Color cloudsPreviewMaterialGetPixel(Renderer* renderer, double x, double y);

 #endif
--- a/src/rendering/clouds/clo_rendering.cpp
+++ b/src/rendering/clouds/clo_rendering.cpp
@ -7,6 +7,8 @@
 #include "clo_density.h"
 #include "clo_walking.h"
 #include "atmosphere/public.h"
+#include "CloudsDefinition.h"
+#include "CloudLayerDefinition.h"

 /******************** Fake ********************/
 static int _fakeAlterLight(Renderer* renderer, LightDefinition* light, Vector3 location)
@ -80,10 +82,10 @@ static int _alterLight(Renderer* renderer, LightDefinition* light, Vector3 locat
    data.light_power = colorGetPower(&light->color);

    /* TODO Iter layers in sorted order */
-    n = layersCount(definition->layers);
+    n = definition->count();
    for (i = 0; i < n; i++)
    {
-        CloudsLayerDefinition* layer = (CloudsLayerDefinition*)layersGetLayer(renderer->clouds->definition->layers, i);
+        CloudLayerDefinition* layer = definition->getCloudLayer(i);
        Vector3 ostart, oend;

        ostart = location;
@ -144,7 +146,7 @@ static void _walkerMaterialCallback(CloudsWalker* walker)
    CloudWalkerStepInfo* segment = cloudsWalkerGetLastSegment(walker);
    AccumulatedMaterialData* data = (AccumulatedMaterialData*)segment->data;
    Renderer* renderer = segment->renderer;
-    CloudsLayerDefinition* layer = segment->layer;
+    CloudLayerDefinition* layer = segment->layer;

    assert(data != NULL);

@ -172,7 +174,7 @@ static void _walkerMaterialCallback(CloudsWalker* walker)
    {
        data->out_scattering += 0.3 * density_integral;

-        Color in_scattering = renderer->applyLightingToSurface(renderer, segment->start.location, VECTOR_ZERO, &layer->material);
+        Color in_scattering = renderer->applyLightingToSurface(renderer, segment->start.location, VECTOR_ZERO, layer->material);
        in_scattering.r *= density_integral * 5.0;
        in_scattering.g *= density_integral * 5.0;
        in_scattering.b *= density_integral * 5.0;
@ -195,7 +197,7 @@ static Color _getColor(Renderer* renderer, Color base, Vector3 start, Vector3 en
    CloudsDefinition* definition = renderer->clouds->definition;
    int i, n;

-    n = layersCount(definition->layers);
+    n = definition->count();
    if (n < 1)
    {
        return base;
@ -204,7 +206,7 @@ static Color _getColor(Renderer* renderer, Color base, Vector3 start, Vector3 en
    /* TODO Iter layers in sorted order */
    for (i = 0; i < n; i++)
    {
-        CloudsLayerDefinition* layer = (CloudsLayerDefinition*)layersGetLayer(renderer->clouds->definition->layers, i);
+        CloudLayerDefinition* layer = definition->getCloudLayer(i);
        Vector3 ostart, oend;

        ostart = start;
@ -250,7 +252,7 @@ static CloudsRenderer* _createRenderer()
    CloudsRenderer* result;

    result = new CloudsRenderer;
-    result->definition = (CloudsDefinition*)CloudsDefinitionClass.create();
+    result->definition = new CloudsDefinition(NULL);

    result->getColor = _fakeGetColor;
    result->alterLight = (FuncLightingAlterLight)_fakeAlterLight;
@ -262,13 +264,13 @@ static CloudsRenderer* _createRenderer()

 static void _deleteRenderer(CloudsRenderer* renderer)
 {
-    CloudsDefinitionClass.destroy(renderer->definition);
+    delete renderer->definition;
    delete renderer;
 }

 static void _bindRenderer(Renderer* renderer, CloudsDefinition* definition)
 {
-    CloudsDefinitionClass.copy(definition, renderer->clouds->definition);
+    definition->copy(renderer->clouds->definition);

    renderer->clouds->getColor = _getColor;
    renderer->clouds->alterLight = (FuncLightingAlterLight)_alterLight;
--- a/src/rendering/clouds/clo_walking.cpp
+++ b/src/rendering/clouds/clo_walking.cpp
@ -1,6 +1,7 @@
 #include "clo_walking.h"

 #include "../renderer.h"
+#include "CloudLayerDefinition.h"

 /**
 * Control of the next walking order.
@ -49,7 +50,7 @@ struct CloudsWalker
 };


-int cloudsOptimizeWalkingBounds(CloudsLayerDefinition* layer, Vector3* start, Vector3* end)
+int cloudsOptimizeWalkingBounds(CloudLayerDefinition* layer, Vector3* start, Vector3* end)
 {
    Vector3 diff;

@ -101,7 +102,7 @@ int cloudsOptimizeWalkingBounds(CloudsLayerDefinition* layer, Vector3* start, Ve
    return 1;
 }

-CloudsWalker* cloudsCreateWalker(Renderer* renderer, CloudsLayerDefinition* layer, Vector3 start, Vector3 end)
+CloudsWalker* cloudsCreateWalker(Renderer* renderer, CloudLayerDefinition* layer, Vector3 start, Vector3 end)
 {
    CloudsWalker* result;

@ -160,7 +161,7 @@ static void _getPoint(CloudsWalker* walker, double cursor, CloudWalkerPoint* out
    out_point->location = v3Add(walker->start, v3Scale(walker->diff, out_point->distance_from_start / walker->max_length));

    Renderer* renderer = walker->last_segment.renderer;
-    CloudsLayerDefinition* layer = walker->last_segment.layer;
+    CloudLayerDefinition* layer = walker->last_segment.layer;
    out_point->global_density = renderer->clouds->getLayerDensity(renderer, layer, out_point->location);

    if (walker->local_density > 0 || (walker->local_density < 0 && walker->subdivision_count > 0))
--- a/src/rendering/clouds/clo_walking.h
+++ b/src/rendering/clouds/clo_walking.h
@ -22,7 +22,7 @@ typedef struct
 typedef struct
 {
    Renderer* renderer;
-    CloudsLayerDefinition* layer;
+    CloudLayerDefinition* layer;

    CloudWalkerPoint start;
    CloudWalkerPoint end;
@ -46,7 +46,7 @@ typedef void (*FuncCloudsWalkingCallback)(CloudsWalker* walker);
 * @param end End of the search to optimize
 * @return 0 if the search is useless
 */
-RENDERINGSHARED_EXPORT int cloudsOptimizeWalkingBounds(CloudsLayerDefinition* layer, Vector3* start, Vector3* end);
+RENDERINGSHARED_EXPORT int cloudsOptimizeWalkingBounds(CloudLayerDefinition* layer, Vector3* start, Vector3* end);

 /**
 * Create a cloud walker.
@ -57,7 +57,7 @@ RENDERINGSHARED_EXPORT int cloudsOptimizeWalkingBounds(CloudsLayerDefinition* la
 * @param start Start of the walk
 * @param end End of the walk
 */
-RENDERINGSHARED_EXPORT CloudsWalker* cloudsCreateWalker(Renderer* renderer, CloudsLayerDefinition* layer, Vector3 start, Vector3 end);
+RENDERINGSHARED_EXPORT CloudsWalker* cloudsCreateWalker(Renderer* renderer, CloudLayerDefinition* layer, Vector3 start, Vector3 end);

 /**
 * Delete a cloud walker.
--- a/src/rendering/clouds/private.h
+++ b/src/rendering/clouds/private.h
@ -6,9 +6,9 @@
 #define CLOUDS_MAX_LAYERS 6
 #define MAX_SEGMENT_COUNT 100

-void cloudsLayerValidateDefinition(CloudsLayerDefinition* definition);
+void cloudsLayerValidateDefinition(CloudLayerDefinition* definition);

-Color cloudsLayerFilterLight(CloudsLayerDefinition* definition, Renderer* renderer, Color light, Vector3 location, Vector3 light_location, Vector3 direction_to_light);
-Color cloudsApplyLayer(CloudsLayerDefinition* definition, Color base, Renderer* renderer, Vector3 start, Vector3 end);
+Color cloudsLayerFilterLight(CloudLayerDefinition* definition, Renderer* renderer, Color light, Vector3 location, Vector3 light_location, Vector3 direction_to_light);
+Color cloudsApplyLayer(CloudLayerDefinition* definition, Color base, Renderer* renderer, Vector3 start, Vector3 end);

 #endif
--- a/src/rendering/clouds/public.h
+++ b/src/rendering/clouds/public.h
@ -2,70 +2,15 @@
 #define _PAYSAGES_CLOUDS_PUBLIC_H_

 #include "../rendering_global.h"
+
 #include "../shared/types.h"
 #include "../tools/lighting.h"
-#include "../tools/curve.h"
 #include "../tools/euclid.h"
-#include "Layers.h"
 #include "SurfaceMaterial.h"

-namespace paysages {
-namespace basics {
-    class NoiseGenerator;
-}
-}
-
-typedef enum
-{
-    CLOUDS_TYPE_CIRRUS,
-    CLOUDS_TYPE_CUMULUS,
-    CLOUDS_TYPE_STRATOCUMULUS,
-    CLOUDS_TYPE_STRATUS
-} CloudsType;
-
-typedef enum
-{
-    CLOUDS_PRESET_PARTLY_CLOUDY,
-} CloudsPreset;
-
-typedef enum
-{
-    CLOUDS_LAYER_PRESET_CIRRUS,
-    CLOUDS_LAYER_PRESET_CUMULUS,
-    CLOUDS_LAYER_PRESET_STRATOCUMULUS,
-    CLOUDS_LAYER_PRESET_STRATUS
-} CloudsLayerPreset;
-
-typedef struct
-{
-    CloudsType type;
-    double lower_altitude;
-    double thickness;
-    double base_coverage;
-    double shape_scaling;
-    double edge_scaling;
-    double edge_length;
-    SurfaceMaterial material;
-    double hardness;
-    double transparencydepth;
-    double lighttraversal;
-    double minimumlight;
-
-    Curve* _coverage_by_altitude;
-    NoiseGenerator* _coverage_noise;
-    NoiseGenerator* _shape_noise;
-    NoiseGenerator* _edge_noise;
-} CloudsLayerDefinition;
-
-class CloudsDefinition
-{
-public:
-    Layers* layers;
-};
-
 typedef Color (*FuncCloudsGetColor)(Renderer* renderer, Color base, Vector3 start, Vector3 end);
-typedef double (*FuncCloudsGetLayerDensity)(Renderer* renderer, CloudsLayerDefinition* layer, Vector3 location);
-typedef double (*FuncCloudsGetEdgeDensity)(Renderer* renderer, CloudsLayerDefinition* layer, Vector3 location, double layer_density);
+typedef double (*FuncCloudsGetLayerDensity)(Renderer* renderer, CloudLayerDefinition* layer, Vector3 location);
+typedef double (*FuncCloudsGetEdgeDensity)(Renderer* renderer, CloudLayerDefinition* layer, Vector3 location, double layer_density);

 class CloudsRenderer
 {
@ -79,11 +24,6 @@ public:
 };


-RENDERINGSHARED_EXPORT extern StandardDefinition CloudsDefinitionClass;
 RENDERINGSHARED_EXPORT extern StandardRenderer CloudsRendererClass;

-RENDERINGSHARED_EXPORT LayerType cloudsGetLayerType();
-RENDERINGSHARED_EXPORT void cloudsAutoPreset(CloudsDefinition* definition, CloudsPreset preset);
-RENDERINGSHARED_EXPORT void cloudsLayerAutoPreset(CloudsLayerDefinition* definition, CloudsLayerPreset preset);
-
 #endif
--- a/src/rendering/rendering.pro
+++ b/src/rendering/rendering.pro
@ -22,9 +22,7 @@ SOURCES += main.cpp \
    clouds/clo_walking.cpp \
    clouds/clo_rendering.cpp \
    clouds/clo_preview.cpp \
-    clouds/clo_presets.cpp \
    clouds/clo_density.cpp \
-    clouds/clo_definition.cpp \
    terrain/ter_render.cpp \
    terrain/ter_raster.cpp \
    terrain/ter_preview.cpp \
@ -43,7 +41,6 @@ SOURCES += main.cpp \
    tools/lighting.cpp \
    tools/euclid.cpp \
    tools/data.cpp \
-    tools/curve.cpp \
    tools/color.cpp \
    tools/cache.cpp \
    water/wat_render.cpp \
@ -80,7 +77,6 @@ HEADERS += \
    tools/lighting.h \
    tools/euclid.h \
    tools/data.h \
-    tools/curve.h \
    tools/color.h \
    tools/cache.h \
    water/public.h \
--- a/src/rendering/tools/color.cpp
+++ b/src/rendering/tools/color.cpp
@ -1,11 +1,11 @@
 #include "color.h"

-#include <stdlib.h>
-#include <assert.h>
-#include <string.h>
-#include <math.h>
-#include "../tools.h"
+#include <cstdlib>
+#include <cassert>
+#include <cstring>
+#include <cmath>
 #include "PackStream.h"
+#include "Curve.h"

 /******************************** ColorProfile ********************************/
 class ColorProfile
@ -67,10 +67,8 @@ static Color _toneMappingReinhard(Color pixel, double exposure)
    return pixel;
 }

-static Color _toneMappingClamp(Color pixel, double exposure)
+static Color _toneMappingClamp(Color pixel, double)
 {
-    UNUSED(exposure);
-
    pixel.r = pixel.r > 1.0 ? 1.0 : pixel.r;
    pixel.g = pixel.g > 1.0 ? 1.0 : pixel.g;
    pixel.b = pixel.b > 1.0 ? 1.0 : pixel.b;
@ -146,80 +144,80 @@ ColorGradation* colorGradationCreate()
    ColorGradation* result;

    result = new ColorGradation;
-    result->red = curveCreate();
-    result->green = curveCreate();
-    result->blue = curveCreate();
+    result->red = new Curve;
+    result->green = new Curve;
+    result->blue = new Curve;

    return result;
 }

 void colorGradationDelete(ColorGradation* gradation)
 {
-    curveDelete(gradation->red);
-    curveDelete(gradation->green);
-    curveDelete(gradation->blue);
+    delete gradation->red;
+    delete gradation->green;
+    delete gradation->blue;
    delete gradation;
 }

 void colorGradationCopy(ColorGradation* source, ColorGradation* destination)
 {
-    curveCopy(source->red, destination->red);
-    curveCopy(source->green, destination->green);
-    curveCopy(source->blue, destination->blue);
+    source->red->copy(destination->red);
+    source->green->copy(destination->green);
+    source->blue->copy(destination->blue);
 }

 void colorGradationClear(ColorGradation* gradation)
 {
-    curveClear(gradation->red);
-    curveClear(gradation->green);
-    curveClear(gradation->blue);
+    gradation->red->clear();
+    gradation->green->clear();
+    gradation->blue->clear();
 }

 void colorGradationSave(PackStream* stream, ColorGradation* gradation)
 {
-    curveSave(stream, gradation->red);
-    curveSave(stream, gradation->green);
-    curveSave(stream, gradation->blue);
+    gradation->red->save(stream);
+    gradation->green->save(stream);
+    gradation->blue->save(stream);
 }

 void colorGradationLoad(PackStream* stream, ColorGradation* gradation)
 {
-    curveLoad(stream, gradation->red);
-    curveLoad(stream, gradation->green);
-    curveLoad(stream, gradation->blue);
+    gradation->red->load(stream);
+    gradation->green->load(stream);
+    gradation->blue->load(stream);
 }

 void colorGradationGetRedCurve(ColorGradation* gradation, Curve* curve)
 {
-    curveCopy(gradation->red, curve);
+    gradation->red->copy(curve);
 }

 void colorGradationGetGreenCurve(ColorGradation* gradation, Curve* curve)
 {
-    curveCopy(gradation->green, curve);
+    gradation->green->copy(curve);
 }

 void colorGradationGetBlueCurve(ColorGradation* gradation, Curve* curve)
 {
-    curveCopy(gradation->blue, curve);
+    gradation->blue->copy(curve);
 }

 void colorGradationSetRedCurve(ColorGradation* gradation, Curve* curve)
 {
-    curveCopy(curve, gradation->red);
-    curveValidate(gradation->red);
+    curve->copy(gradation->red);
+    gradation->red->validate();
 }

 void colorGradationSetGreenCurve(ColorGradation* gradation, Curve* curve)
 {
-    curveCopy(curve, gradation->green);
-    curveValidate(gradation->green);
+    curve->copy(gradation->green);
+    gradation->green->validate();
 }

 void colorGradationSetBlueCurve(ColorGradation* gradation, Curve* curve)
 {
-    curveCopy(curve, gradation->blue);
-    curveValidate(gradation->blue);
+    curve->copy(gradation->blue);
+    gradation->blue->validate();
 }

 void colorGradationQuickAdd(ColorGradation* gradation, double value, Color* col)
@ -229,23 +227,23 @@ void colorGradationQuickAdd(ColorGradation* gradation, double value, Color* col)

 void colorGradationQuickAddRgb(ColorGradation* gradation, double value, double r, double g, double b)
 {
-    curveQuickAddPoint(gradation->red, value, r);
-    curveValidate(gradation->red);
+    gradation->red->addPoint(value, r);
+    gradation->red->validate();

-    curveQuickAddPoint(gradation->green, value, g);
-    curveValidate(gradation->green);
+    gradation->green->addPoint(value, g);
+    gradation->green->validate();

-    curveQuickAddPoint(gradation->blue, value, b);
-    curveValidate(gradation->blue);
+    gradation->blue->addPoint(value, b);
+    gradation->blue->validate();
 }

 Color colorGradationGet(ColorGradation* gradation, double value)
 {
    Color result;

-    result.r = curveGetValue(gradation->red, value);
-    result.g = curveGetValue(gradation->green, value);
-    result.b = curveGetValue(gradation->blue, value);
+    result.r = gradation->red->getValue(value);
+    result.g = gradation->green->getValue(value);
+    result.b = gradation->blue->getValue(value);
    result.a = 1.0;

    return result;
--- a/src/rendering/tools/color.h
+++ b/src/rendering/tools/color.h
@ -2,7 +2,6 @@
 #define _PAYSAGES_TOOLS_COLOR_H_

 #include "../rendering_global.h"
-#include "curve.h"

 /* HDR profile for tone-mapping */
 class ColorProfile;
--- a/src/rendering/tools/curve.cpp
+++ b/src/rendering/tools/curve.cpp
@ -1,179 +0,0 @@
-#include "curve.h"
-
-#include <stdlib.h>
-#include <string.h>
-#include "../tools.h"
-#include "PackStream.h"
-
-#define MAX_NB_POINTS 40
-
-struct Curve
-{
-    double default_value;
-    int nbpoints;
-    CurvePoint points[MAX_NB_POINTS];
-};
-
-Curve* curveCreate()
-{
-    Curve* result;
-
-    result = new Curve;
-    result->nbpoints = 0;
-    result->default_value = 0.0;
-
-    return result;
-}
-
-void curveDelete(Curve* curve)
-{
-    delete curve;
-}
-
-void curveCopy(Curve* source, Curve* destination)
-{
-    *destination = *source;
-}
-
-void curveSave(PackStream* stream, Curve* curve)
-{
-    int i;
-
-    stream->write(&curve->default_value);
-    stream->write(&curve->nbpoints);
-    for (i = 0; i < curve->nbpoints; i++)
-    {
-        stream->write(&curve->points[i].position);
-        stream->write(&curve->points[i].value);
-    }
-}
-
-void curveLoad(PackStream* stream, Curve* curve)
-{
-    int i;
-
-    stream->read(&curve->default_value);
-    stream->read(&curve->nbpoints);
-    for (i = 0; i < curve->nbpoints; i++)
-    {
-        stream->read(&curve->points[i].position);
-        stream->read(&curve->points[i].value);
-    }
-}
-
-void curveClear(Curve* curve)
-{
-    curve->nbpoints = 0;
-}
-
-void curveSetDefault(Curve* curve, double value)
-{
-    curve->default_value = value;
-}
-
-int curveAddPoint(Curve* curve, CurvePoint* point)
-{
-    if (curve->nbpoints < MAX_NB_POINTS)
-    {
-        curve->points[curve->nbpoints] = *point;
-        return curve->nbpoints++;
-    }
-    else
-    {
-        return -1;
-    }
-}
-
-int curveQuickAddPoint(Curve* curve, double position, double value)
-{
-    CurvePoint point;
-
-    point.position = position;
-    point.value = value;
-
-    return curveAddPoint(curve, &point);
-}
-
-int curveGetPointCount(Curve* curve)
-{
-    return curve->nbpoints;
-}
-
-void curveGetPoint(Curve* curve, int number, CurvePoint* point)
-{
-    if (number >= 0 && number < curve->nbpoints)
-    {
-        *point = curve->points[number];
-    }
-}
-
-void curveSetPoint(Curve* curve, int number, CurvePoint* point)
-{
-    if (number >= 0 && number < curve->nbpoints)
-    {
-        curve->points[number] = *point;
-    }
-}
-
-void curveRemovePoint(Curve* curve, int number)
-{
-    if (number >= 0 && number < curve->nbpoints)
-    {
-        if (curve->nbpoints > 0 && number < curve->nbpoints - 1)
-        {
-            memmove(curve->points + number, curve->points + number + 1, sizeof(CurvePoint) * (curve->nbpoints - number - 1));
-        }
-        curve->nbpoints--;
-    }
-}
-
-int _point_compare(const void* part1, const void* part2)
-{
-    if (((CurvePoint*)part1)->position > ((CurvePoint*)part2)->position)
-    {
-        return 1;
-    }
-    else
-    {
-        return -1;
-    }
-}
-
-void curveValidate(Curve* curve)
-{
-    if (curve->nbpoints > 1)
-    {
-        qsort(curve->points, curve->nbpoints, sizeof(CurvePoint), _point_compare);
-    }
-}
-
-double curveGetValue(Curve* curve, double position)
-{
-    int i;
-    double fact;
-
-    if (curve->nbpoints == 0)
-    {
-        return curve->default_value;
-    }
-    else if (curve->nbpoints == 1 || position <= curve->points[0].position)
-    {
-        return curve->points[0].value;
-    }
-    else if (position >= curve->points[curve->nbpoints - 1].position)
-    {
-        return curve->points[curve->nbpoints - 1].value;
-    }
-    else
-    {
-        for (i = 1; i < curve->nbpoints; i++)
-        {
-            if (position < curve->points[i].position)
-            {
-                fact = (position - curve->points[i - 1].position) / (curve->points[i].position - curve->points[i - 1].position);
-                return curve->points[i - 1].value + (curve->points[i].value - curve->points[i - 1].value) * fact;
-            }
-        }
-        return curve->points[curve->nbpoints - 1].value;
-    }
-}
--- a/src/rendering/tools/curve.h
+++ b/src/rendering/tools/curve.h
@ -1,35 +0,0 @@
-#ifndef _PAYSAGES_TOOLS_CURVE_H_
-#define _PAYSAGES_TOOLS_CURVE_H_
-
-#include "../rendering_global.h"
-
-namespace paysages {
-namespace system {class PackStream;}
-}
-
-typedef struct {
-    double position;
-    double value;
-} CurvePoint;
-typedef struct Curve Curve;
-
-RENDERINGSHARED_EXPORT Curve* curveCreate();
-RENDERINGSHARED_EXPORT void curveDelete(Curve* curve);
-RENDERINGSHARED_EXPORT void curveCopy(Curve* source, Curve* destination);
-
-RENDERINGSHARED_EXPORT void curveSave(PackStream* stream, Curve* curve);
-RENDERINGSHARED_EXPORT void curveLoad(PackStream* stream, Curve* curve);
-
-RENDERINGSHARED_EXPORT void curveClear(Curve* curve);
-RENDERINGSHARED_EXPORT void curveSetDefault(Curve* curve, double value);
-RENDERINGSHARED_EXPORT int curveAddPoint(Curve* curve, CurvePoint* point);
-RENDERINGSHARED_EXPORT int curveQuickAddPoint(Curve* curve, double position, double value);
-RENDERINGSHARED_EXPORT int curveGetPointCount(Curve* curve);
-RENDERINGSHARED_EXPORT void curveGetPoint(Curve* curve, int number, CurvePoint* point);
-RENDERINGSHARED_EXPORT void curveSetPoint(Curve* curve, int number, CurvePoint* point);
-RENDERINGSHARED_EXPORT void curveRemovePoint(Curve* curve, int number);
-RENDERINGSHARED_EXPORT void curveValidate(Curve* curve);
-
-RENDERINGSHARED_EXPORT double curveGetValue(Curve* curve, double position);
-
-#endif
--- a/src/rendering/tools/zone.cpp
+++ b/src/rendering/tools/zone.cpp
@ -4,6 +4,7 @@
 #include <cstdlib>
 #include <cmath>
 #include "PackStream.h"
+#include "Curve.h"
 #include "tools.h"

 #define MAX_CIRCLES 20
@ -35,11 +36,11 @@ Zone* zoneCreate()
    Zone* result;

    result = (Zone*)malloc(sizeof(Zone));
-    result->value_by_height = curveCreate();
+    result->value_by_height = new Curve;
    result->absolute_height = 1;
-    curveSetDefault(result->value_by_height, 1.0);
-    result->value_by_slope = curveCreate();
-    curveSetDefault(result->value_by_slope, 1.0);
+    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;
@ -47,8 +48,8 @@ Zone* zoneCreate()

 void zoneDelete(Zone* zone)
 {
-    curveDelete(zone->value_by_height);
-    curveDelete(zone->value_by_slope);
+    delete zone->value_by_height;
+    delete zone->value_by_slope;
    free(zone);
 }

@ -61,8 +62,8 @@ void zoneSave(PackStream* stream, Zone* zone)
    stream->write(&zone->relative_height_middle);
    stream->write(&zone->relative_height_max);

-    curveSave(stream, zone->value_by_height);
-    curveSave(stream, zone->value_by_slope);
+    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++)
@ -84,8 +85,8 @@ void zoneLoad(PackStream* stream, Zone* zone)
    stream->read(&zone->relative_height_middle);
    stream->read(&zone->relative_height_max);

-    curveLoad(stream, zone->value_by_height);
-    curveLoad(stream, zone->value_by_slope);
+    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++)
@ -105,8 +106,8 @@ void zoneCopy(Zone* source, Zone* destination)
    destination->relative_height_middle = source->relative_height_middle;
    destination->relative_height_max = source->relative_height_max;

-    curveCopy(source->value_by_height, destination->value_by_height);
-    curveCopy(source->value_by_slope, destination->value_by_slope);
+    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;
@ -114,8 +115,8 @@ void zoneCopy(Zone* source, Zone* destination)

 void zoneClear(Zone* zone)
 {
-    curveClear(zone->value_by_height);
-    curveClear(zone->value_by_slope);
+    zone->value_by_height->clear();
+    zone->value_by_slope->clear();
    zone->circles_included_count = 0;
 }

@ -157,38 +158,38 @@ void zoneIncludeCircleArea(Zone* zone, double value, double centerx, double cent

 void zoneGetHeightCurve(Zone* zone, Curve* curve)
 {
-    curveCopy(zone->value_by_height, curve);
+    zone->value_by_height->copy(curve);
 }

 void zoneSetHeightCurve(Zone* zone, Curve* curve)
 {
-    curveCopy(curve, zone->value_by_height);
+    curve->copy(zone->value_by_height);
 }

 void zoneAddHeightRangeQuick(Zone* zone, double value, double hardmin, double softmin, double softmax, double hardmax)
 {
-    curveQuickAddPoint(zone->value_by_height, hardmin, 0.0);
-    curveQuickAddPoint(zone->value_by_height, softmin, value);
-    curveQuickAddPoint(zone->value_by_height, softmax, value);
-    curveQuickAddPoint(zone->value_by_height, hardmax, 0.0);
+    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)
 {
-    curveCopy(zone->value_by_slope, curve);
+    zone->value_by_slope->copy(curve);
 }

 void zoneSetSlopeCurve(Zone* zone, Curve* curve)
 {
-    curveCopy(curve, zone->value_by_slope);
+    curve->copy(zone->value_by_slope);
 }

 void zoneAddSlopeRangeQuick(Zone* zone, double value, double hardmin, double softmin, double softmax, double hardmax)
 {
-    curveQuickAddPoint(zone->value_by_slope, hardmin, 0.0);
-    curveQuickAddPoint(zone->value_by_slope, softmin, value);
-    curveQuickAddPoint(zone->value_by_slope, softmax, value);
-    curveQuickAddPoint(zone->value_by_slope, hardmax, 0.0);
+    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)
@ -260,8 +261,8 @@ double zoneGetValue(Zone* zone, Vector3 location, Vector3 normal)
        }
    }

-    value_height = curveGetValue(zone->value_by_height, final_height);
-    value_steepness = curveGetValue(zone->value_by_slope, (1.0 - normal.y));
+    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)
    {
--- a/src/rendering/tools/zone.h
+++ b/src/rendering/tools/zone.h
@ -7,13 +7,6 @@

 #include "../rendering_global.h"
 #include "../tools/euclid.h"
-#include "../tools/curve.h"
-
-namespace paysages {
-namespace system {
-class PackStream;
-}
-}

 typedef struct Zone Zone;

--- a/src/rendering/water/public.h
+++ b/src/rendering/water/public.h
@ -4,7 +4,6 @@
 #include "../rendering_global.h"
 #include "../shared/types.h"
 #include "../tools/lighting.h"
-#include "../tools/curve.h"
 #include "../tools/euclid.h"

 typedef struct
--- a/src/tests/Clouds_Test.cpp
+++ b/src/tests/Clouds_Test.cpp
@ -5,14 +5,14 @@
 #include "clouds/public.h"
 #include "clouds/clo_density.h"
 #include "clouds/clo_walking.h"
+#include "CloudLayerDefinition.h"
 #include "NoiseGenerator.h"

 TEST(Clouds, Density)
 {
    /* Setup */
    double x, y, z;
-    CloudsLayerDefinition* layer;
-    layer = (CloudsLayerDefinition*)cloudsGetLayerType().callback_create();
+    CloudLayerDefinition layer(NULL);

    /* Test default coverage (empty) */
    for (x = -10.0; x < 10.0; x += 10.0)
@ -21,109 +21,105 @@ TEST(Clouds, Density)
        {
            for (z = -10.0; z < 10.0; z += 10.0)
            {
-                ASSERT_DOUBLE_EQ(cloudsGetLayerCoverage(layer, v3(x, y, z)), 0.0);
+                ASSERT_DOUBLE_EQ(cloudsGetLayerCoverage(&layer, v3(x, y, z)), 0.0);
            }
        }
    }

    /* Test coverage by altitude */
-    layer->base_coverage = 1.0;
-    layer->lower_altitude = -1.0;
-    layer->thickness = 2.0;
-    cloudsGetLayerType().callback_validate(layer);
-    layer->base_coverage = 1.0;
-    layer->_coverage_noise->forceValue(1.0);
+    layer.base_coverage = 1.0;
+    layer.lower_altitude = -1.0;
+    layer.thickness = 2.0;
+    layer.validate();
+    layer.base_coverage = 1.0;
+    layer._coverage_noise->forceValue(1.0);
    for (x = -10.0; x < 10.0; x += 10.0)
    {
        for (z = -10.0; z < 10.0; z += 10.0)
        {
-            ASSERT_DOUBLE_EQ(cloudsGetLayerCoverage(layer, v3(x, 0.0, z)), 1.0);
-            ASSERT_DOUBLE_EQ(cloudsGetLayerCoverage(layer, v3(x, 0.5, z)), 0.5);
-            ASSERT_DOUBLE_EQ(cloudsGetLayerCoverage(layer, v3(x, 1.0, z)), 0.0);
-            ASSERT_DOUBLE_EQ(cloudsGetLayerCoverage(layer, v3(x, 1.5, z)), 0.0);
-            ASSERT_DOUBLE_EQ(cloudsGetLayerCoverage(layer, v3(x, -0.5, z)), 0.5);
-            ASSERT_DOUBLE_EQ(cloudsGetLayerCoverage(layer, v3(x, -1.0, z)), 0.0);
-            ASSERT_DOUBLE_EQ(cloudsGetLayerCoverage(layer, v3(x, -1.5, z)), 0.0);
+            ASSERT_DOUBLE_EQ(cloudsGetLayerCoverage(&layer, v3(x, 0.0, z)), 1.0);
+            ASSERT_DOUBLE_EQ(cloudsGetLayerCoverage(&layer, v3(x, 0.5, z)), 0.5);
+            ASSERT_DOUBLE_EQ(cloudsGetLayerCoverage(&layer, v3(x, 1.0, z)), 0.0);
+            ASSERT_DOUBLE_EQ(cloudsGetLayerCoverage(&layer, v3(x, 1.5, z)), 0.0);
+            ASSERT_DOUBLE_EQ(cloudsGetLayerCoverage(&layer, v3(x, -0.5, z)), 0.5);
+            ASSERT_DOUBLE_EQ(cloudsGetLayerCoverage(&layer, v3(x, -1.0, z)), 0.0);
+            ASSERT_DOUBLE_EQ(cloudsGetLayerCoverage(&layer, v3(x, -1.5, z)), 0.0);
        }
    }
-    layer->base_coverage = 0.5;
-    layer->_coverage_noise->forceValue(1.0);
+    layer.base_coverage = 0.5;
+    layer._coverage_noise->forceValue(1.0);
    for (x = -10.0; x < 10.0; x += 10.0)
    {
        for (z = -10.0; z < 10.0; z += 10.0)
        {
-            ASSERT_DOUBLE_EQ(cloudsGetLayerCoverage(layer, v3(x, 0.0, z)), 0.5);
-            ASSERT_DOUBLE_EQ(cloudsGetLayerCoverage(layer, v3(x, 0.5, z)), 0.25);
-            ASSERT_DOUBLE_EQ(cloudsGetLayerCoverage(layer, v3(x, 1.0, z)), 0.0);
-            ASSERT_DOUBLE_EQ(cloudsGetLayerCoverage(layer, v3(x, 1.5, z)), 0.0);
-            ASSERT_DOUBLE_EQ(cloudsGetLayerCoverage(layer, v3(x, -0.5, z)), 0.25);
-            ASSERT_DOUBLE_EQ(cloudsGetLayerCoverage(layer, v3(x, -1.0, z)), 0.0);
-            ASSERT_DOUBLE_EQ(cloudsGetLayerCoverage(layer, v3(x, -1.5, z)), 0.0);
+            ASSERT_DOUBLE_EQ(cloudsGetLayerCoverage(&layer, v3(x, 0.0, z)), 0.5);
+            ASSERT_DOUBLE_EQ(cloudsGetLayerCoverage(&layer, v3(x, 0.5, z)), 0.25);
+            ASSERT_DOUBLE_EQ(cloudsGetLayerCoverage(&layer, v3(x, 1.0, z)), 0.0);
+            ASSERT_DOUBLE_EQ(cloudsGetLayerCoverage(&layer, v3(x, 1.5, z)), 0.0);
+            ASSERT_DOUBLE_EQ(cloudsGetLayerCoverage(&layer, v3(x, -0.5, z)), 0.25);
+            ASSERT_DOUBLE_EQ(cloudsGetLayerCoverage(&layer, v3(x, -1.0, z)), 0.0);
+            ASSERT_DOUBLE_EQ(cloudsGetLayerCoverage(&layer, v3(x, -1.5, z)), 0.0);
        }
    }
-    layer->base_coverage = 1.0;
-    layer->_coverage_noise->forceValue(0.5);
+    layer.base_coverage = 1.0;
+    layer._coverage_noise->forceValue(0.5);
    for (x = -10.0; x < 10.0; x += 10.0)
    {
        for (z = -10.0; z < 10.0; z += 10.0)
        {
-            ASSERT_DOUBLE_EQ(cloudsGetLayerCoverage(layer, v3(x, 0.0, z)), 0.5);
-            ASSERT_DOUBLE_EQ(cloudsGetLayerCoverage(layer, v3(x, 0.5, z)), 0.25);
-            ASSERT_DOUBLE_EQ(cloudsGetLayerCoverage(layer, v3(x, 1.0, z)), 0.0);
-            ASSERT_DOUBLE_EQ(cloudsGetLayerCoverage(layer, v3(x, 1.5, z)), 0.0);
-            ASSERT_DOUBLE_EQ(cloudsGetLayerCoverage(layer, v3(x, -0.5, z)), 0.25);
-            ASSERT_DOUBLE_EQ(cloudsGetLayerCoverage(layer, v3(x, -1.0, z)), 0.0);
-            ASSERT_DOUBLE_EQ(cloudsGetLayerCoverage(layer, v3(x, -1.5, z)), 0.0);
+            ASSERT_DOUBLE_EQ(cloudsGetLayerCoverage(&layer, v3(x, 0.0, z)), 0.5);
+            ASSERT_DOUBLE_EQ(cloudsGetLayerCoverage(&layer, v3(x, 0.5, z)), 0.25);
+            ASSERT_DOUBLE_EQ(cloudsGetLayerCoverage(&layer, v3(x, 1.0, z)), 0.0);
+            ASSERT_DOUBLE_EQ(cloudsGetLayerCoverage(&layer, v3(x, 1.5, z)), 0.0);
+            ASSERT_DOUBLE_EQ(cloudsGetLayerCoverage(&layer, v3(x, -0.5, z)), 0.25);
+            ASSERT_DOUBLE_EQ(cloudsGetLayerCoverage(&layer, v3(x, -1.0, z)), 0.0);
+            ASSERT_DOUBLE_EQ(cloudsGetLayerCoverage(&layer, v3(x, -1.5, z)), 0.0);
        }
    }

    /* TODO Test fake renderer */

    /* TODO Test real renderer */
-
-    /* Teardown */
-    cloudsGetLayerType().callback_delete(layer);
 }

 TEST(Clouds, WalkingBoundaries)
 {
    Vector3 start, end;
    int result;
-    CloudsLayerDefinition* layer;
-    layer = (CloudsLayerDefinition*)cloudsGetLayerType().callback_create();
-    layer->base_coverage = 1.0;
-    layer->lower_altitude = -1.0;
-    layer->thickness = 2.0;
-    cloudsGetLayerType().callback_validate(layer);
+    CloudLayerDefinition layer(NULL);
+    layer.base_coverage = 1.0;
+    layer.lower_altitude = -1.0;
+    layer.thickness = 2.0;
+    layer.validate();

    /* Basic cases */
    start = v3(0.0, -3.0, 0.0);
    end = v3(0.0, -2.0, 0.0);
-    result = cloudsOptimizeWalkingBounds(layer, &start, &end);
+    result = cloudsOptimizeWalkingBounds(&layer, &start, &end);
    ASSERT_EQ(result, 0);

    start = v3(0.0, 2.0, 0.0);
    end = v3(0.0, 3.0, 0.0);
-    result = cloudsOptimizeWalkingBounds(layer, &start, &end);
+    result = cloudsOptimizeWalkingBounds(&layer, &start, &end);
    ASSERT_EQ(result, 0);

    start = v3(0.0, -2.0, 0.0);
    end = v3(0.0, 2.0, 0.0);
-    result = cloudsOptimizeWalkingBounds(layer, &start, &end);
+    result = cloudsOptimizeWalkingBounds(&layer, &start, &end);
    ASSERT_EQ(result, 1);
    ASSERT_VECTOR3_COORDS(start, 0.0, -1.0, 0.0);
    ASSERT_VECTOR3_COORDS(end, 0.0, 1.0, 0.0);

    start = v3(0.0, 0.0, 0.0);
    end = v3(0.0, 2.0, 0.0);
-    result = cloudsOptimizeWalkingBounds(layer, &start, &end);
+    result = cloudsOptimizeWalkingBounds(&layer, &start, &end);
    ASSERT_EQ(result, 1);
    ASSERT_VECTOR3_COORDS(start, 0.0, 0.0, 0.0);
    ASSERT_VECTOR3_COORDS(end, 0.0, 1.0, 0.0);

    start = v3(0.0, -2.0, 0.0);
    end = v3(0.0, 0.0, 0.0);
-    result = cloudsOptimizeWalkingBounds(layer, &start, &end);
+    result = cloudsOptimizeWalkingBounds(&layer, &start, &end);
    ASSERT_EQ(result, 1);
    ASSERT_VECTOR3_COORDS(start, 0.0, -1.0, 0.0);
    ASSERT_VECTOR3_COORDS(end, 0.0, 0.0, 0.0);
@ -131,31 +127,31 @@ TEST(Clouds, WalkingBoundaries)
    /* Basic cases (inverted) */
    start = v3(0.0, -2.0, 0.0);
    end = v3(0.0, -3.0, 0.0);
-    result = cloudsOptimizeWalkingBounds(layer, &start, &end);
+    result = cloudsOptimizeWalkingBounds(&layer, &start, &end);
    ASSERT_EQ(result, 0);

    start = v3(0.0, 3.0, 0.0);
    end = v3(0.0, 2.0, 0.0);
-    result = cloudsOptimizeWalkingBounds(layer, &start, &end);
+    result = cloudsOptimizeWalkingBounds(&layer, &start, &end);
    ASSERT_EQ(result, 0);

    start = v3(0.0, 2.0, 0.0);
    end = v3(0.0, -2.0, 0.0);
-    result = cloudsOptimizeWalkingBounds(layer, &start, &end);
+    result = cloudsOptimizeWalkingBounds(&layer, &start, &end);
    ASSERT_EQ(result, 1);
    ASSERT_VECTOR3_COORDS(start, 0.0, 1.0, 0.0);
    ASSERT_VECTOR3_COORDS(end, 0.0, -1.0, 0.0);

    start = v3(0.0, 2.0, 0.0);
    end = v3(0.0, 0.0, 0.0);
-    result = cloudsOptimizeWalkingBounds(layer, &start, &end);
+    result = cloudsOptimizeWalkingBounds(&layer, &start, &end);
    ASSERT_EQ(result, 1);
    ASSERT_VECTOR3_COORDS(start, 0.0, 1.0, 0.0);
    ASSERT_VECTOR3_COORDS(end, 0.0, 0.0, 0.0);

    start = v3(0.0, 0.0, 0.0);
    end = v3(0.0, -2.0, 0.0);
-    result = cloudsOptimizeWalkingBounds(layer, &start, &end);
+    result = cloudsOptimizeWalkingBounds(&layer, &start, &end);
    ASSERT_EQ(result, 1);
    ASSERT_VECTOR3_COORDS(start, 0.0, 0.0, 0.0);
    ASSERT_VECTOR3_COORDS(end, 0.0, -1.0, 0.0);
@ -163,41 +159,39 @@ TEST(Clouds, WalkingBoundaries)
    /* Horizontal cases */
    start = v3(0.0, 2.0, 0.0);
    end = v3(10.0, 2.0, 0.0);
-    result = cloudsOptimizeWalkingBounds(layer, &start, &end);
+    result = cloudsOptimizeWalkingBounds(&layer, &start, &end);
    ASSERT_EQ(result, 0);

    start = v3(0.0, 1.00001, 0.0);
    end = v3(10.0, 1.00001, 0.0);
-    result = cloudsOptimizeWalkingBounds(layer, &start, &end);
+    result = cloudsOptimizeWalkingBounds(&layer, &start, &end);
    ASSERT_EQ(result, 0);

    start = v3(0.0, -1.00001, 0.0);
    end = v3(10.0, -1.00001, 0.0);
-    result = cloudsOptimizeWalkingBounds(layer, &start, &end);
+    result = cloudsOptimizeWalkingBounds(&layer, &start, &end);
    ASSERT_EQ(result, 0);

    start = v3(0.0, -2.0, 0.0);
    end = v3(10.0, -2.0, 0.0);
-    result = cloudsOptimizeWalkingBounds(layer, &start, &end);
+    result = cloudsOptimizeWalkingBounds(&layer, &start, &end);
    ASSERT_EQ(result, 0);

    start = v3(0.0, 0.0, 0.0);
    end = v3(10.0, 0.0, 0.0);
-    result = cloudsOptimizeWalkingBounds(layer, &start, &end);
+    result = cloudsOptimizeWalkingBounds(&layer, &start, &end);
    ASSERT_EQ(result, 1);
    ASSERT_VECTOR3_COORDS(start, 0.0, 0.0, 0.0);
    ASSERT_VECTOR3_COORDS(end, 10.0, 0.0, 0.0);
-
-    cloudsGetLayerType().callback_delete(layer);
 }

-static double _getLayerDensitySinX(Renderer*, CloudsLayerDefinition*, Vector3 location)
+static double _getLayerDensitySinX(Renderer*, CloudLayerDefinition*, Vector3 location)
 {
    double density = sin(location.x * (2.0 * M_PI));
    return (density > 0.0) ? density : 0.0;
 }

-static double _getEdgeDensitySquared(Renderer*, CloudsLayerDefinition*, Vector3, double edge_density)
+static double _getEdgeDensitySquared(Renderer*, CloudLayerDefinition*, Vector3, double edge_density)
 {
    return edge_density * edge_density;
 }
@ -205,11 +199,10 @@ static double _getEdgeDensitySquared(Renderer*, CloudsLayerDefinition*, Vector3,
 TEST(Clouds, Walking)
 {
    /* Init */
-    CloudsLayerDefinition* layer;
-    layer = (CloudsLayerDefinition*)cloudsGetLayerType().callback_create();
-    layer->lower_altitude = -1.0;
-    layer->thickness = 2.0;
-    cloudsGetLayerType().callback_validate(layer);
+    CloudLayerDefinition layer(NULL);
+    layer.lower_altitude = -1.0;
+    layer.thickness = 2.0;
+    layer.validate();

    Renderer* renderer;
    renderer = rendererCreate();
@ -217,7 +210,7 @@ TEST(Clouds, Walking)
    renderer->render_quality = 8;
    renderer->clouds->getLayerDensity = _getLayerDensitySinX;

-    CloudsWalker* walker = cloudsCreateWalker(renderer, layer, v3(-0.4, 0.0, 0.0), v3(1.75, 0.0, 0.0));
+    CloudsWalker* walker = cloudsCreateWalker(renderer, &layer, v3(-0.4, 0.0, 0.0), v3(1.75, 0.0, 0.0));
    CloudWalkerStepInfo* segment;
    int result;

@ -411,18 +404,16 @@ TEST(Clouds, Walking)
    /* Clean up */
    cloudsDeleteWalker(walker);

-    cloudsGetLayerType().callback_delete(layer);
    rendererDelete(renderer);
 }

 TEST(Clouds, WalkingLocal)
 {
    /* Init */
-    CloudsLayerDefinition* layer;
-    layer = (CloudsLayerDefinition*)cloudsGetLayerType().callback_create();
-    layer->lower_altitude = -1.0;
-    layer->thickness = 2.0;
-    cloudsGetLayerType().callback_validate(layer);
+    CloudLayerDefinition layer(NULL);
+    layer.lower_altitude = -1.0;
+    layer.thickness = 2.0;
+    layer.validate();

    Renderer* renderer;
    renderer = rendererCreate();
@ -431,7 +422,7 @@ TEST(Clouds, WalkingLocal)
    renderer->clouds->getLayerDensity = _getLayerDensitySinX;
    renderer->clouds->getEdgeDensity = _getEdgeDensitySquared;

-    CloudsWalker* walker = cloudsCreateWalker(renderer, layer, v3(0.0, 0.0, 0.0), v3(1.0, 0.0, 0.0));
+    CloudsWalker* walker = cloudsCreateWalker(renderer, &layer, v3(0.0, 0.0, 0.0), v3(1.0, 0.0, 0.0));
    CloudWalkerStepInfo* segment;
    int result;