paysages : Clouds are now on the new layers system.

git-svn-id: https://subversion.assembla.com/svn/thunderk/paysages@420 b1fd45b6-86a6-48da-8261-f70d1f35bdcc

gui_qt/formclouds.cpp

@@ -7,23 +7,25 @@
 
 #include "tools.h"
 
-static CloudsDefinition _definition;
-static CloudsLayerDefinition _layer;
-
 /**************** Previews ****************/
 class PreviewCloudsCoverage:public BasePreview
 {
 public:
-    PreviewCloudsCoverage(QWidget* parent):BasePreview(parent)
+    PreviewCloudsCoverage(QWidget* parent, CloudsLayerDefinition* layer):BasePreview(parent)
     {
         _renderer = rendererCreate();
         _renderer.render_quality = 3;
         _renderer.applyLightStatus = _applyLightStatus;
         
+        _original_layer = layer;
         _preview_layer = cloudsLayerCreateDefinition();
         
         configScaling(100.0, 1000.0, 20.0, 200.0);
     }
+    ~PreviewCloudsCoverage()
+    {
+        cloudsLayerDeleteDefinition(_preview_layer);
+    }
 protected:
     QColor getColor(double x, double y)
     {
@@ -38,12 +40,12 @@ protected:
         look.z = 1.0;
         look = v3Normalize(look);
 
-        color_layer = cloudsApplyLayer(&_preview_layer, COLOR_BLUE, &_renderer, eye, v3Add(eye, v3Scale(look, 1000.0)));
+        color_layer = cloudsApplyLayer(_preview_layer, COLOR_BLUE, &_renderer, eye, v3Add(eye, v3Scale(look, 1000.0)));
         return colorToQColor(color_layer);
     }
     void updateData()
     {
-        cloudsLayerCopyDefinition(&_layer, &_preview_layer);
+        cloudsLayerCopyDefinition(_original_layer, _preview_layer);
     }
     static Color _applyLightStatus(Renderer* renderer, LightStatus* status, Vector3 location, Vector3 normal, SurfaceMaterial material)
     {
@@ -52,16 +54,18 @@ protected:
 
 private:
     Renderer _renderer;
-    CloudsLayerDefinition _preview_layer;
+    CloudsLayerDefinition* _original_layer;
+    CloudsLayerDefinition* _preview_layer;
 };
 
 class PreviewCloudsColor:public BasePreview
 {
 public:
-    PreviewCloudsColor(QWidget* parent):BasePreview(parent)
+    PreviewCloudsColor(QWidget* parent, CloudsLayerDefinition* layer):BasePreview(parent)
     {
         LightDefinition light;
         
+        _original_layer = layer;
         _preview_layer = cloudsLayerCreateDefinition();
 
         _lighting = lightingCreateDefinition();
@@ -80,7 +84,7 @@ public:
         _renderer.render_quality = 3;
         _renderer.alterLight = _alterLight;
         _renderer.getLightStatus = _getLightStatus;
-        _renderer.customData[0] = &_preview_layer;
+        _renderer.customData[0] = _preview_layer;
         _renderer.customData[1] = &_lighting;
         
         configScaling(0.5, 2.0, 0.1, 2.0);
@@ -91,29 +95,30 @@ protected:
         Vector3 start, end;
         Color color_layer;
 
-        start.x = x * _preview_layer.thickness * 0.5;
+        start.x = x * _preview_layer->thickness * 0.5;
-        start.y = -y * _preview_layer.thickness * 0.5;
+        start.y = -y * _preview_layer->thickness * 0.5;
-        start.z = _preview_layer.thickness * 0.5;
+        start.z = _preview_layer->thickness * 0.5;
         
-        end.x = x * _preview_layer.thickness * 0.5;
+        end.x = x * _preview_layer->thickness * 0.5;
-        end.y = -y * _preview_layer.thickness * 0.5;
+        end.y = -y * _preview_layer->thickness * 0.5;
-        end.z = -_preview_layer.thickness * 0.5;
+        end.z = -_preview_layer->thickness * 0.5;
 
-        color_layer = cloudsApplyLayer(&_preview_layer, COLOR_BLUE, &_renderer, start, end);
+        color_layer = cloudsApplyLayer(_preview_layer, COLOR_BLUE, &_renderer, start, end);
         return colorToQColor(color_layer);
     }
     void updateData()
     {
-        cloudsLayerCopyDefinition(&_layer, &_preview_layer);
+        cloudsLayerCopyDefinition(_original_layer, _preview_layer);
         //noiseForceValue(_preview_layer.shape_noise, 1.0);
-        _preview_layer.lower_altitude = -_preview_layer.thickness * 0.5;
+        _preview_layer->lower_altitude = -_preview_layer->thickness * 0.5;
         //curveClear(_preview_layer.coverage_by_altitude);
-        _preview_layer.base_coverage = 1.0;
+        _preview_layer->base_coverage = 1.0;
-        _preview_layer._custom_coverage = _coverageFunc;
+        _preview_layer->_custom_coverage = _coverageFunc;
     }
 private:
     Renderer _renderer;
-    CloudsLayerDefinition _preview_layer;
+    CloudsLayerDefinition* _original_layer;
+    CloudsLayerDefinition* _preview_layer;
     LightingDefinition _lighting;
 
     static double _coverageFunc(CloudsLayerDefinition* layer, Vector3 position)
@@ -146,102 +151,52 @@ private:
 
 /**************** Form ****************/
 FormClouds::FormClouds(QWidget *parent):
-    BaseForm(parent, false, true)
+    BaseFormLayer(parent)
 {
     _definition = cloudsCreateDefinition();
     _layer = cloudsLayerCreateDefinition();
     
-    addPreview(new PreviewCloudsCoverage(parent), tr("Layer coverage (no lighting)"));
+    _previewCoverage = new PreviewCloudsCoverage(parent, _layer);
-    addPreview(new PreviewCloudsColor(parent), tr("Appearance"));
+    _previewColor = new PreviewCloudsColor(parent, _layer);
+    addPreview(_previewCoverage, tr("Layer coverage (no lighting)"));
+    addPreview(_previewColor, tr("Appearance"));
 
-    addInputDouble(tr("Lower altitude"), &_layer.lower_altitude, -10.0, 50.0, 0.5, 5.0);
+    addInputDouble(tr("Lower altitude"), &_layer->lower_altitude, -10.0, 50.0, 0.5, 5.0);
-    addInputDouble(tr("Layer thickness"), &_layer.thickness, 0.0, 20.0, 0.1, 1.0);
+    addInputDouble(tr("Layer thickness"), &_layer->thickness, 0.0, 20.0, 0.1, 1.0);
-    addInputDouble(tr("Max coverage"), &_layer.base_coverage, 0.0, 1.0, 0.01, 0.1);
+    addInputDouble(tr("Max coverage"), &_layer->base_coverage, 0.0, 1.0, 0.01, 0.1);
-    addInputCurve(tr("Coverage by altitude"), _layer.coverage_by_altitude, 0.0, 1.0, 0.0, 1.0, tr("Altitude in cloud layer"), tr("Coverage value"));
+    addInputCurve(tr("Coverage by altitude"), _layer->coverage_by_altitude, 0.0, 1.0, 0.0, 1.0, tr("Altitude in cloud layer"), tr("Coverage value"));
-    addInputNoise(tr("Shape noise"), _layer.shape_noise);
+    addInputNoise(tr("Shape noise"), _layer->shape_noise);
-    addInputDouble(tr("Shape scaling"), &_layer.shape_scaling, 1.0, 10.0, 0.1, 1.0);
+    addInputDouble(tr("Shape scaling"), &_layer->shape_scaling, 1.0, 10.0, 0.1, 1.0);
-    addInputNoise(tr("Edge noise"), _layer.edge_noise);
+    addInputNoise(tr("Edge noise"), _layer->edge_noise);
-    addInputDouble(tr("Edge scaling"), &_layer.edge_scaling, 0.02, 0.5, 0.01, 0.1);
+    addInputDouble(tr("Edge scaling"), &_layer->edge_scaling, 0.02, 0.5, 0.01, 0.1);
-    addInputDouble(tr("Edge length"), &_layer.edge_length, 0.0, 1.0, 0.01, 0.1);
+    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("Hardness to light"), &_layer->hardness, 0.0, 1.0, 0.01, 0.1);
-    addInputDouble(tr("Transparency depth"), &_layer.transparencydepth, 0.0, 100.0, 0.5, 5.0);
+    addInputDouble(tr("Transparency depth"), &_layer->transparencydepth, 0.0, 100.0, 0.5, 5.0);
-    addInputDouble(tr("Light traversal depth"), &_layer.lighttraversal, 0.0, 100.0, 0.5, 5.0);
+    addInputDouble(tr("Light traversal depth"), &_layer->lighttraversal, 0.0, 100.0, 0.5, 5.0);
-    addInputDouble(tr("Minimum lighting"), &_layer.minimumlight, 0.0, 1.0, 0.01, 0.1);
+    addInputDouble(tr("Minimum lighting"), &_layer->minimumlight, 0.0, 1.0, 0.01, 0.1);
 
-    revertConfig();
+    setLayers(_definition.layers);
 }
 
 void FormClouds::revertConfig()
 {
     sceneryGetClouds(&_definition);
-    BaseForm::revertConfig();
+    BaseFormLayer::revertConfig();
 }
 
 void FormClouds::applyConfig()
 {
+    BaseFormLayer::applyConfig();
     scenerySetClouds(&_definition);
-    BaseForm::applyConfig();
 }
 
-void FormClouds::configChangeEvent()
+void FormClouds::layerGetCopy(void* layer_definition)
 {
-    cloudsLayerCopyDefinition(&_layer, cloudsGetLayer(&_definition, currentLayer()));
+    cloudsLayerCopyDefinition((CloudsLayerDefinition*)layer_definition, _layer);
-    cloudsValidateDefinition(&_definition);
-    BaseForm::configChangeEvent();
 }
 
-QStringList FormClouds::getLayers()
+void FormClouds::layerApply(void* layer_definition)
 {
-    QStringList result;
+    cloudsLayerCopyDefinition(_layer, (CloudsLayerDefinition*)layer_definition);
-    CloudsLayerDefinition* layer;
-    int i, n;
-    
-    n = cloudsGetLayerCount(&_definition);
-    for (i = 0; i < n; i++)
-    {
-        layer = cloudsGetLayer(&_definition, i);
-        result << QString::fromUtf8(layer->name);
-    }
-    
-    return result;
-}
-
-void FormClouds::layerAddedEvent()
-{
-    if (cloudsAddLayer(&_definition) >= 0)
-    {
-        BaseForm::layerAddedEvent();
-    }
-}
-
-void FormClouds::layerMovedEvent(int layer, int new_position)
-{
-    cloudsMoveLayer(&_definition, layer, new_position);
-    
-    BaseForm::layerMovedEvent(layer, new_position);
-}
-
-void FormClouds::layerDeletedEvent(int layer)
-{
-    cloudsDeleteLayer(&_definition, layer);
-    
-    BaseForm::layerDeletedEvent(layer);
-}
-
-void FormClouds::layerRenamedEvent(int layer, QString new_name)
-{
-    CloudsLayerDefinition* layer_def;
-    
-    layer_def = cloudsGetLayer(&_definition, layer);
-    cloudsLayerSetName(layer_def, new_name.toUtf8().data());
-    
-    BaseForm::layerRenamedEvent(layer, new_name);
-}
-
-void FormClouds::layerSelectedEvent(int layer)
-{
-    cloudsLayerCopyDefinition(cloudsGetLayer(&_definition, layer), &_layer);
-    
-    BaseForm::layerSelectedEvent(layer);
 }

gui_qt/formclouds.h

@@ -3,9 +3,10 @@
 
 #include <QWidget>
 #include "basepreview.h"
-#include "baseform.h"
+#include "baseformlayer.h"
+#include "../lib_paysages/clouds.h"
 
-class FormClouds : public BaseForm
+class FormClouds : public BaseFormLayer
 {
     Q_OBJECT
 
@@ -16,20 +17,15 @@ public slots:
     virtual void revertConfig();
     virtual void applyConfig();
 
-protected slots:
-    virtual void configChangeEvent();
-    
 protected:
-    virtual QStringList getLayers();
+    virtual void layerGetCopy(void* layer_definition);
-    virtual void layerAddedEvent();
+    virtual void layerApply(void* layer_definition);
-    virtual void layerDeletedEvent(int layer);
-    virtual void layerMovedEvent(int layer, int new_position);
-    virtual void layerRenamedEvent(int layer, QString new_name);
-    virtual void layerSelectedEvent(int layer);
 
 private:
-    BasePreview* previewCoverage;
+    CloudsDefinition _definition;
-    BasePreview* previewColor;
+    CloudsLayerDefinition* _layer;
+    BasePreview* _previewCoverage;
+    BasePreview* _previewColor;
 };
 
 #endif

gui_qt/formtextures.cpp

@@ -139,10 +139,10 @@ FormTextures::FormTextures(QWidget *parent):
     _supp.height_curve = curveCreate();
     _supp.slope_curve = curveCreate();
 
-    previewCoverage = new PreviewTexturesCoverage(this, _layer);
+    _previewCoverage = new PreviewTexturesCoverage(this, _layer);
-    previewColor = new PreviewTexturesColor(this, _layer);
+    _previewColor = new PreviewTexturesColor(this, _layer);
-    addPreview(previewCoverage, tr("Coverage preview"));
+    addPreview(_previewCoverage, tr("Coverage preview"));
-    addPreview(previewColor, tr("Lighted sample"));
+    addPreview(_previewColor, tr("Lighted sample"));
 
     addInputNoise(tr("Surface noise"), _layer->bump_noise);
     addInputDouble(tr("Surface noise height"), &_layer->bump_height, 0.0, 0.1, 0.001, 0.01);

gui_qt/formtextures.h

@@ -25,8 +25,8 @@ protected:
 private:
     TexturesDefinition _definition;
     TextureLayerDefinition* _layer;
-    BasePreview* previewCoverage;
+    BasePreview* _previewCoverage;
-    BasePreview* previewColor;
+    BasePreview* _previewColor;
 };
 
 #endif

lib_paysages/auto.c

@@ -74,7 +74,7 @@ void autoGenRealisticLandscape(int seed)
 
     /* Cloud layer */
     clouds = cloudsCreateDefinition();
-    cloudsAddLayer(&clouds);
+    layersAddLayer(clouds.layers, NULL);
     scenerySetClouds(&clouds);
     cloudsDeleteDefinition(&clouds);
 

lib_paysages/clouds.c

@@ -9,6 +9,7 @@
 #include "tools.h"
 #include "shared/types.h"
 
+#define CLOUDS_MAX_LAYERS 6
 #define MAX_SEGMENT_COUNT 30
 
 typedef struct
@@ -18,120 +19,38 @@ typedef struct
     double length;
 } CloudSegment;
 
-static CloudsLayerDefinition NULL_LAYER;
-
-void cloudsInit()
-{
-    NULL_LAYER = cloudsLayerCreateDefinition();;
-    cloudsLayerValidateDefinition(&NULL_LAYER);
-}
-
-void cloudsQuit()
-{
-    cloudsLayerDeleteDefinition(&NULL_LAYER);
-}
-
-void cloudsSave(PackStream* stream, CloudsDefinition* definition)
-{
-    int i;
-    CloudsLayerDefinition* layer;
-
-    packWriteInt(stream, &definition->nblayers);
-    for (i = 0; i < definition->nblayers; i++)
-    {
-        layer = definition->layers + i;
-        
-        packWriteString(stream, layer->name, CLOUDS_MAX_NAME_LENGTH);
-        packWriteDouble(stream, &layer->lower_altitude);
-        packWriteDouble(stream, &layer->thickness);
-        curveSave(stream, layer->coverage_by_altitude);
-        noiseSaveGenerator(stream, layer->shape_noise);
-        noiseSaveGenerator(stream, layer->edge_noise);
-        materialSave(stream, &layer->material);
-        packWriteDouble(stream, &layer->hardness);
-        packWriteDouble(stream, &layer->transparencydepth);
-        packWriteDouble(stream, &layer->lighttraversal);
-        packWriteDouble(stream, &layer->minimumlight);
-        packWriteDouble(stream, &layer->shape_scaling);
-        packWriteDouble(stream, &layer->edge_scaling);
-        packWriteDouble(stream, &layer->edge_length);
-        packWriteDouble(stream, &layer->base_coverage);
-    }
-}
-
-void cloudsLoad(PackStream* stream, CloudsDefinition* definition)
-{
-    int i, n;
-    CloudsLayerDefinition* layer;
-
-    while (definition->nblayers > 0)
-    {
-        cloudsDeleteLayer(definition, 0);
-    }
-
-    packReadInt(stream, &n);
-    for (i = 0; i < n; i++)
-    {
-        layer = definition->layers + cloudsAddLayer(definition);
-
-        packReadString(stream, layer->name, CLOUDS_MAX_NAME_LENGTH);
-        packReadDouble(stream, &layer->lower_altitude);
-        packReadDouble(stream, &layer->thickness);
-        curveLoad(stream, layer->coverage_by_altitude);
-        noiseLoadGenerator(stream, layer->shape_noise);
-        noiseLoadGenerator(stream, layer->edge_noise);
-        materialLoad(stream, &layer->material);
-        packReadDouble(stream, &layer->hardness);
-        packReadDouble(stream, &layer->transparencydepth);
-        packReadDouble(stream, &layer->lighttraversal);
-        packReadDouble(stream, &layer->minimumlight);
-        packReadDouble(stream, &layer->shape_scaling);
-        packReadDouble(stream, &layer->edge_scaling);
-        packReadDouble(stream, &layer->edge_length);
-        packReadDouble(stream, &layer->base_coverage);
-    }
-}
-
 CloudsDefinition cloudsCreateDefinition()
 {
     CloudsDefinition result;
 
-    result.nblayers = 0;
+    result.layers = layersCreate(cloudsGetLayerType(), CLOUDS_MAX_LAYERS);
 
     return result;
 }
 
 void cloudsDeleteDefinition(CloudsDefinition* definition)
 {
-    while (definition->nblayers > 0)
+    layersDelete(definition->layers);
-    {
-        cloudsDeleteLayer(definition, 0);
-    }
 }
 
 void cloudsCopyDefinition(CloudsDefinition* source, CloudsDefinition* destination)
 {
-    CloudsLayerDefinition* layer;
+    layersCopy(source->layers, destination->layers);
-    int i;
-
-    while (destination->nblayers > 0)
-    {
-        cloudsDeleteLayer(destination, 0);
-    }
-    for (i = 0; i < source->nblayers; i++)
-    {
-        layer = cloudsGetLayer(destination, cloudsAddLayer(destination));
-        cloudsLayerCopyDefinition(source->layers + i, layer);
-    }
 }
 
 void cloudsValidateDefinition(CloudsDefinition* definition)
 {
-    int i;
+    layersValidate(definition->layers);
-    for (i = 0; i < definition->nblayers; i++)
+}
-    {
+
-        cloudsLayerValidateDefinition(&definition->layers[i]);
+void cloudsSave(PackStream* stream, CloudsDefinition* definition)
-    }
+{
+    layersSave(stream, definition->layers);
+}
+
+void cloudsLoad(PackStream* stream, CloudsDefinition* definition)
+{
+    layersLoad(stream, definition->layers);
 }
 
 static double _standardCoverageFunc(CloudsLayerDefinition* layer, Vector3 position)
@@ -146,58 +65,57 @@ static double _standardCoverageFunc(CloudsLayerDefinition* layer, Vector3 positi
     }
 }
 
-CloudsLayerDefinition cloudsLayerCreateDefinition()
+CloudsLayerDefinition* cloudsLayerCreateDefinition()
 {
-    CloudsLayerDefinition result;
+    CloudsLayerDefinition* result;
-
-    cloudsLayerSetName(&result, "Unnamed");
-    result.lower_altitude = 4.0;
-    result.thickness = 6.0;
-    result.coverage_by_altitude = curveCreate();
-    curveQuickAddPoint(result.coverage_by_altitude, 0.0, 0.0);
-    curveQuickAddPoint(result.coverage_by_altitude, 0.3, 1.0);
-    curveQuickAddPoint(result.coverage_by_altitude, 0.5, 1.0);
-    curveQuickAddPoint(result.coverage_by_altitude, 1.0, 0.0);
-    result.material.base.r = 0.7;
-    result.material.base.g = 0.7;
-    result.material.base.b = 0.7;
-    result.material.base.a = 1.0;
-    result.material.reflection = 0.3;
-    result.material.shininess = 0.8;
-    result.hardness = 0.25;
-    result.transparencydepth = 1.5;
-    result.lighttraversal = 7.0;
-    result.minimumlight = 0.4;
-    result.shape_scaling = 3.5;
-    result.edge_scaling = 0.07;
-    result.edge_length = 0.2;
-    result.base_coverage = 0.35;
-    result.shape_noise = noiseCreateGenerator();
-    noiseGenerateBaseNoise(result.shape_noise, 200000);
-    noiseAddLevelsSimple(result.shape_noise, 5, 1.0, 1.0);
-    result.edge_noise = noiseCreateGenerator();
-    noiseGenerateBaseNoise(result.edge_noise, 800000);
-    noiseAddLevelsSimple(result.edge_noise, 8, 1.0, 1.0);
     
-    result._custom_coverage = _standardCoverageFunc;
+    result = malloc(sizeof(CloudsLayerDefinition));
+
+    result->lower_altitude = 4.0;
+    result->thickness = 6.0;
+    result->coverage_by_altitude = curveCreate();
+    curveQuickAddPoint(result->coverage_by_altitude, 0.0, 0.0);
+    curveQuickAddPoint(result->coverage_by_altitude, 0.3, 1.0);
+    curveQuickAddPoint(result->coverage_by_altitude, 0.5, 1.0);
+    curveQuickAddPoint(result->coverage_by_altitude, 1.0, 0.0);
+    result->material.base.r = 0.7;
+    result->material.base.g = 0.7;
+    result->material.base.b = 0.7;
+    result->material.base.a = 1.0;
+    result->material.reflection = 0.3;
+    result->material.shininess = 0.8;
+    result->hardness = 0.25;
+    result->transparencydepth = 1.5;
+    result->lighttraversal = 7.0;
+    result->minimumlight = 0.4;
+    result->shape_scaling = 3.5;
+    result->edge_scaling = 0.07;
+    result->edge_length = 0.2;
+    result->base_coverage = 0.35;
+    result->shape_noise = noiseCreateGenerator();
+    noiseGenerateBaseNoise(result->shape_noise, 200000);
+    noiseAddLevelsSimple(result->shape_noise, 5, 1.0, 1.0);
+    result->edge_noise = noiseCreateGenerator();
+    noiseGenerateBaseNoise(result->edge_noise, 800000);
+    noiseAddLevelsSimple(result->edge_noise, 8, 1.0, 1.0);
+    
+    result->_custom_coverage = _standardCoverageFunc;
 
     return result;
 }
 
 void cloudsLayerDeleteDefinition(CloudsLayerDefinition* definition)
 {
+    curveDelete(definition->coverage_by_altitude);
     noiseDeleteGenerator(definition->shape_noise);
+    noiseDeleteGenerator(definition->edge_noise);
+    free(definition);
 }
 
 void cloudsLayerCopyDefinition(CloudsLayerDefinition* source, CloudsLayerDefinition* destination)
 {
     CloudsLayerDefinition temp;
     
-    if (destination == &NULL_LAYER)
-    {
-        return;
-    }
-
     temp = *destination;
     *destination = *source;
     
@@ -213,7 +131,6 @@ void cloudsLayerCopyDefinition(CloudsLayerDefinition* source, CloudsLayerDefinit
 
 void cloudsLayerValidateDefinition(CloudsLayerDefinition* definition)
 {
-    definition->name[CLOUDS_MAX_NAME_LENGTH] = '\0';
     if (definition->shape_scaling < 0.0001)
     {
         definition->shape_scaling = 0.00001;
@@ -228,74 +145,54 @@ void cloudsLayerValidateDefinition(CloudsLayerDefinition* definition)
     }
 }
 
-void cloudsLayerSetName(CloudsLayerDefinition* definition, const char* name)
+void _cloudsLayerSave(PackStream* stream, CloudsLayerDefinition* layer)
 {
-    strncpy(definition->name, name, CLOUDS_MAX_NAME_LENGTH);
+    packWriteDouble(stream, &layer->lower_altitude);
+    packWriteDouble(stream, &layer->thickness);
+    curveSave(stream, layer->coverage_by_altitude);
+    noiseSaveGenerator(stream, layer->shape_noise);
+    noiseSaveGenerator(stream, layer->edge_noise);
+    materialSave(stream, &layer->material);
+    packWriteDouble(stream, &layer->hardness);
+    packWriteDouble(stream, &layer->transparencydepth);
+    packWriteDouble(stream, &layer->lighttraversal);
+    packWriteDouble(stream, &layer->minimumlight);
+    packWriteDouble(stream, &layer->shape_scaling);
+    packWriteDouble(stream, &layer->edge_scaling);
+    packWriteDouble(stream, &layer->edge_length);
+    packWriteDouble(stream, &layer->base_coverage);
 }
 
-int cloudsGetLayerCount(CloudsDefinition* definition)
+void _cloudsLayerLoad(PackStream* stream, CloudsLayerDefinition* layer)
 {
-    return definition->nblayers;
+    packReadDouble(stream, &layer->lower_altitude);
+    packReadDouble(stream, &layer->thickness);
+    curveLoad(stream, layer->coverage_by_altitude);
+    noiseLoadGenerator(stream, layer->shape_noise);
+    noiseLoadGenerator(stream, layer->edge_noise);
+    materialLoad(stream, &layer->material);
+    packReadDouble(stream, &layer->hardness);
+    packReadDouble(stream, &layer->transparencydepth);
+    packReadDouble(stream, &layer->lighttraversal);
+    packReadDouble(stream, &layer->minimumlight);
+    packReadDouble(stream, &layer->shape_scaling);
+    packReadDouble(stream, &layer->edge_scaling);
+    packReadDouble(stream, &layer->edge_length);
+    packReadDouble(stream, &layer->base_coverage);
 }
 
-CloudsLayerDefinition* cloudsGetLayer(CloudsDefinition* definition, int layer)
+LayerType cloudsGetLayerType()
 {
-    if (layer >= 0 && layer < definition->nblayers)
+    LayerType result;
-    {
+    
-        return definition->layers + layer;
+    result.callback_create = (LayerCallbackCreate)cloudsLayerCreateDefinition;
-    }
+    result.callback_delete = (LayerCallbackDelete)cloudsLayerDeleteDefinition;
-    else
+    result.callback_copy = (LayerCallbackCopy)cloudsLayerCopyDefinition;
-    {
+    result.callback_validate = (LayerCallbackValidate)cloudsLayerValidateDefinition;
-        return &NULL_LAYER;
+    result.callback_save = (LayerCallbackSave)_cloudsLayerSave;
-    }
+    result.callback_load = (LayerCallbackLoad)_cloudsLayerLoad;
-}
+    
-
+    return result;
-int cloudsAddLayer(CloudsDefinition* definition)
-{
-    CloudsLayerDefinition* layer;
-
-    if (definition->nblayers < CLOUDS_MAX_LAYERS)
-    {
-        layer = definition->layers + definition->nblayers;
-        *layer = cloudsLayerCreateDefinition();
-
-        return definition->nblayers++;
-    }
-    else
-    {
-        return -1;
-    }
-}
-
-void cloudsDeleteLayer(CloudsDefinition* definition, int layer)
-{
-    if (layer >= 0 && layer < definition->nblayers)
-    {
-        cloudsLayerDeleteDefinition(definition->layers + layer);
-        if (definition->nblayers > 1 && layer < definition->nblayers - 1)
-        {
-            memmove(definition->layers + layer, definition->layers + layer + 1, sizeof(CloudsLayerDefinition) * (definition->nblayers - layer - 1));
-        }
-        definition->nblayers--;
-    }
-}
-
-void cloudsMoveLayer(CloudsDefinition* definition, int layer, int new_position)
-{
-    if (layer >= 0 && layer < definition->nblayers && new_position != layer && new_position >= 0 && new_position < definition->nblayers)
-    {
-        CloudsLayerDefinition temp;
-        temp = definition->layers[layer];
-        if (new_position > layer)
-        {
-            memmove(definition->layers + layer, definition->layers + layer + 1, sizeof(CloudsLayerDefinition) * (new_position - layer));
-        }
-        else
-        {
-            memmove(definition->layers + new_position + 1, definition->layers + new_position, sizeof(CloudsLayerDefinition) * (layer - new_position));
-        }
-        definition->layers[new_position] = temp;
-    }
 }
 
 static inline double _getDistanceToBorder(CloudsLayerDefinition* layer, Vector3 position)
@@ -613,26 +510,25 @@ Color cloudsApplyLayer(CloudsLayerDefinition* definition, Color base, Renderer*
     return base;
 }
 
-static int _cmpLayer(const void* layer1, const void* layer2)
+/*static int _cmpLayer(const void* layer1, const void* layer2)
 {
     return (((CloudsLayerDefinition*)layer1)->lower_altitude > ((CloudsLayerDefinition*)layer2)->lower_altitude) ? -1 : 1;
-}
+}*/
 
 Color cloudsApply(CloudsDefinition* definition, Color base, Renderer* renderer, Vector3 start, Vector3 end)
 {
-    int i;
+    int i, n;
-    CloudsLayerDefinition layers[CLOUDS_MAX_LAYERS];
 
-    if (definition->nblayers < 1)
+    n = layersCount(definition->layers);
+    if (n < 1)
     {
         return base;
     }
 
-    memcpy(layers, definition->layers, sizeof(CloudsLayerDefinition) * definition->nblayers);
+    /* TODO Iter layers in sorted order */
-    qsort(layers, definition->nblayers, sizeof(CloudsLayerDefinition), _cmpLayer);
+    for (i = 0; i < n; i++)
-    for (i = 0; i < definition->nblayers; i++)
     {
-        base = cloudsApplyLayer(layers + i, base, renderer, start, end);
+        base = cloudsApplyLayer(layersGetLayer(definition->layers, i), base, renderer, start, end);
     }
 
     return base;
@@ -671,11 +567,13 @@ Color cloudsLayerFilterLight(CloudsLayerDefinition* definition, Renderer* render
 
 Color cloudsFilterLight(CloudsDefinition* definition, Renderer* renderer, Color light, Vector3 location, Vector3 light_location, Vector3 direction_to_light)
 {
-    int i;
+    int i, n;
-    /* TODO Order layers ? */
+    
-    for (i = 0; i < definition->nblayers; i++)
+    /* TODO Iter layers in sorted order */
+    n = layersCount(definition->layers);
+    for (i = 0; i < n; i++)
     {
-        light = cloudsLayerFilterLight(definition->layers + i, renderer, light, location, light_location, direction_to_light);
+        light = cloudsLayerFilterLight(layersGetLayer(definition->layers, i), renderer, light, location, light_location, direction_to_light);
     }
     return light;
 }

lib_paysages/clouds.h

@@ -2,24 +2,20 @@
 #define _PAYSAGES_CLOUDS_H_
 
 #include "shared/types.h"
+#include "layers.h"
 #include "noise.h"
 #include "renderer.h"
-#include <stdio.h>
 
 #ifdef __cplusplus
 extern "C" {
 #endif
 
-#define CLOUDS_MAX_LAYERS 6
-#define CLOUDS_MAX_NAME_LENGTH 50
-
 typedef struct CloudsLayerDefinition CloudsLayerDefinition;
     
 typedef double (*CloudCoverageFunc)(CloudsLayerDefinition* definition, Vector3 position);
 
 struct CloudsLayerDefinition
 {
-    char name[CLOUDS_MAX_NAME_LENGTH + 1];
     double lower_altitude;
     double thickness;
     double base_coverage;
@@ -39,31 +35,22 @@ struct CloudsLayerDefinition
 
 typedef struct
 {
-    int nblayers;
+    Layers* layers;
-    CloudsLayerDefinition layers[CLOUDS_MAX_LAYERS];
 } CloudsDefinition;
 
-void cloudsInit();
-void cloudsQuit();
-void cloudsSave(PackStream* stream, CloudsDefinition* definition);
-void cloudsLoad(PackStream* stream, CloudsDefinition* definition);
-
 CloudsDefinition cloudsCreateDefinition();
 void cloudsDeleteDefinition(CloudsDefinition* definition);
 void cloudsCopyDefinition(CloudsDefinition* source, CloudsDefinition* destination);
 void cloudsValidateDefinition(CloudsDefinition* definition);
+void cloudsSave(PackStream* stream, CloudsDefinition* definition);
+void cloudsLoad(PackStream* stream, CloudsDefinition* definition);
 
-CloudsLayerDefinition cloudsLayerCreateDefinition();
+CloudsLayerDefinition* cloudsLayerCreateDefinition();
 void cloudsLayerDeleteDefinition(CloudsLayerDefinition* definition);
 void cloudsLayerCopyDefinition(CloudsLayerDefinition* source, CloudsLayerDefinition* destination);
 void cloudsLayerValidateDefinition(CloudsLayerDefinition* definition);
 void cloudsLayerSetName(CloudsLayerDefinition* definition, const char* name);
-
+LayerType cloudsGetLayerType();
-int cloudsGetLayerCount(CloudsDefinition* definition);
-CloudsLayerDefinition* cloudsGetLayer(CloudsDefinition* definition, int layer);
-int cloudsAddLayer(CloudsDefinition* definition);
-void cloudsDeleteLayer(CloudsDefinition* definition, int layer);
-void cloudsMoveLayer(CloudsDefinition* definition, int layer, int new_position);
 
 Color cloudsApplyLayer(CloudsLayerDefinition* definition, Color base, Renderer* renderer, Vector3 start, Vector3 end);
 Color cloudsApply(CloudsDefinition* definition, Color base, Renderer* renderer, Vector3 start, Vector3 end);

lib_paysages/scenery.c

@@ -24,7 +24,6 @@ static void* _custom_data = NULL;
 void sceneryInit()
 {
     noiseInit();
-    cloudsInit();
     lightingInit();
 
     _atmosphere = atmosphereCreateDefinition();
@@ -53,7 +52,6 @@ void sceneryQuit()
     vegetationDeleteDefinition(_vegetation);
     waterDeleteDefinition(&_water);
 
-    cloudsQuit();
     lightingQuit();
     noiseQuit();
 }

lib_paysages/textures.c

@@ -22,30 +22,6 @@ typedef struct
     TextureLayerDefinition* definition;
 } TextureResult;
 
-static void texturesLayerSave(PackStream* stream, TextureLayerDefinition* layer)
-{
-    zoneSave(stream, layer->zone);
-    noiseSaveGenerator(stream, layer->bump_noise);
-    packWriteDouble(stream, &layer->bump_height);
-    packWriteDouble(stream, &layer->bump_scaling);
-    materialSave(stream, &layer->material);
-    packWriteDouble(stream, &layer->thickness);
-    packWriteDouble(stream, &layer->slope_range);
-    packWriteDouble(stream, &layer->thickness_transparency);
-}
-
-static void texturesLayerLoad(PackStream* stream, TextureLayerDefinition* layer)
-{
-    zoneLoad(stream, layer->zone);
-    noiseLoadGenerator(stream, layer->bump_noise);
-    packReadDouble(stream, &layer->bump_height);
-    packReadDouble(stream, &layer->bump_scaling);
-    materialLoad(stream, &layer->material);
-    packReadDouble(stream, &layer->thickness);
-    packReadDouble(stream, &layer->slope_range);
-    packReadDouble(stream, &layer->thickness_transparency);
-}
-
 TexturesDefinition texturesCreateDefinition()
 {
     TexturesDefinition result;
@@ -80,20 +56,6 @@ void texturesLoad(PackStream* stream, TexturesDefinition* definition)
     layersLoad(stream, definition->layers);
 }
 
-LayerType texturesGetLayerType()
-{
-    LayerType result;
-    
-    result.callback_create = (LayerCallbackCreate)texturesLayerCreateDefinition;
-    result.callback_delete = (LayerCallbackDelete)texturesLayerDeleteDefinition;
-    result.callback_copy = (LayerCallbackCopy)texturesLayerCopyDefinition;
-    result.callback_validate = (LayerCallbackValidate)texturesLayerValidateDefinition;
-    result.callback_save = (LayerCallbackSave)texturesLayerSave;
-    result.callback_load = (LayerCallbackLoad)texturesLayerLoad;
-    
-    return result;
-}
-
 TextureLayerDefinition* texturesLayerCreateDefinition()
 {
     TextureLayerDefinition* result;
@@ -147,6 +109,44 @@ void texturesLayerValidateDefinition(TextureLayerDefinition* definition)
     }
 }
 
+static void _texturesLayerSave(PackStream* stream, TextureLayerDefinition* layer)
+{
+    zoneSave(stream, layer->zone);
+    noiseSaveGenerator(stream, layer->bump_noise);
+    packWriteDouble(stream, &layer->bump_height);
+    packWriteDouble(stream, &layer->bump_scaling);
+    materialSave(stream, &layer->material);
+    packWriteDouble(stream, &layer->thickness);
+    packWriteDouble(stream, &layer->slope_range);
+    packWriteDouble(stream, &layer->thickness_transparency);
+}
+
+static void _texturesLayerLoad(PackStream* stream, TextureLayerDefinition* layer)
+{
+    zoneLoad(stream, layer->zone);
+    noiseLoadGenerator(stream, layer->bump_noise);
+    packReadDouble(stream, &layer->bump_height);
+    packReadDouble(stream, &layer->bump_scaling);
+    materialLoad(stream, &layer->material);
+    packReadDouble(stream, &layer->thickness);
+    packReadDouble(stream, &layer->slope_range);
+    packReadDouble(stream, &layer->thickness_transparency);
+}
+
+LayerType texturesGetLayerType()
+{
+    LayerType result;
+    
+    result.callback_create = (LayerCallbackCreate)texturesLayerCreateDefinition;
+    result.callback_delete = (LayerCallbackDelete)texturesLayerDeleteDefinition;
+    result.callback_copy = (LayerCallbackCopy)texturesLayerCopyDefinition;
+    result.callback_validate = (LayerCallbackValidate)texturesLayerValidateDefinition;
+    result.callback_save = (LayerCallbackSave)_texturesLayerSave;
+    result.callback_load = (LayerCallbackLoad)_texturesLayerLoad;
+    
+    return result;
+}
+
 static inline Vector3 _getNormal4(Vector3 center, Vector3 north, Vector3 east, Vector3 south, Vector3 west)
 {
     Vector3 dnorth, deast, dsouth, dwest, normal;

lib_paysages/textures.h

@@ -37,11 +37,11 @@ void texturesValidateDefinition(TexturesDefinition* definition);
 void texturesSave(PackStream* stream, TexturesDefinition* definition);
 void texturesLoad(PackStream* stream, TexturesDefinition* definition);
 
-LayerType texturesGetLayerType();
 TextureLayerDefinition* texturesLayerCreateDefinition();
 void texturesLayerDeleteDefinition(TextureLayerDefinition* definition);
 void texturesLayerCopyDefinition(TextureLayerDefinition* source, TextureLayerDefinition* destination);
 void texturesLayerValidateDefinition(TextureLayerDefinition* definition);
+LayerType texturesGetLayerType();
 
 double texturesGetLayerCoverage(TextureLayerDefinition* definition, Renderer* renderer, Vector3 location, double detail);
 Color texturesGetLayerColor(TextureLayerDefinition* definition, Renderer* renderer, Vector3 location, double detail);