graphics/paysages3d
1
0
Fork 0
Code Releases Activity

paysages : Clouds are now on the new layers system.

Browse source 
git-svn-id: https://subversion.assembla.com/svn/thunderk/paysages@420 b1fd45b6-86a6-48da-8261-f70d1f35bdcc
This commit is contained in:
Michaël Lemaire 2012-08-26 13:36:46 +00:00 committed by ThunderK
parent a98185c5e1
commit 8101669544
10 changed files with 219 additions and 385 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

149
gui_qt/formclouds.cpp
View file

@ -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.y = -y * _preview_layer.thickness * 0.5;
start.z = _preview_layer.thickness * 0.5;
start.x = x * _preview_layer->thickness * 0.5;
start.y = -y * _preview_layer->thickness * 0.5;
start.z = _preview_layer->thickness * 0.5;
end.x = x * _preview_layer.thickness * 0.5;
end.y = -y * _preview_layer.thickness * 0.5;
end.z = -_preview_layer.thickness * 0.5;
end.x = x * _preview_layer->thickness * 0.5;
end.y = -y * _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._custom_coverage = _coverageFunc;
_preview_layer->base_coverage = 1.0;
_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)"));
addPreview(new PreviewCloudsColor(parent), tr("Appearance"));
_previewCoverage = new PreviewCloudsCoverage(parent, _layer);
_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("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);
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);
addInputDouble(tr("Shape scaling"), &_layer.shape_scaling, 1.0, 10.0, 0.1, 1.0);
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 length"), &_layer.edge_length, 0.0, 1.0, 0.01, 0.1);
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, 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("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("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"));
addInputNoise(tr("Shape noise"), _layer->shape_noise);
addInputDouble(tr("Shape scaling"), &_layer->shape_scaling, 1.0, 10.0, 0.1, 1.0);
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 length"), &_layer->edge_length, 0.0, 1.0, 0.01, 0.1);
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, 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);
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()));
cloudsValidateDefinition(&_definition);
BaseForm::configChangeEvent();
cloudsLayerCopyDefinition((CloudsLayerDefinition*)layer_definition, _layer);
}
QStringList FormClouds::getLayers()
void FormClouds::layerApply(void* layer_definition)
{
QStringList result;
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);
cloudsLayerCopyDefinition(_layer, (CloudsLayerDefinition*)layer_definition);
}

22
gui_qt/formclouds.h
View file

@ -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 layerAddedEvent();
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);
virtual void layerGetCopy(void* layer_definition);
virtual void layerApply(void* layer_definition);
private:
BasePreview* previewCoverage;
BasePreview* previewColor;
CloudsDefinition _definition;
CloudsLayerDefinition* _layer;
BasePreview* _previewCoverage;
BasePreview* _previewColor;
};
#endif

8
gui_qt/formtextures.cpp
View file

@ -139,10 +139,10 @@ FormTextures::FormTextures(QWidget *parent):
_supp.height_curve = curveCreate();
_supp.slope_curve = curveCreate();
previewCoverage = new PreviewTexturesCoverage(this, _layer);
previewColor = new PreviewTexturesColor(this, _layer);
addPreview(previewCoverage, tr("Coverage preview"));
addPreview(previewColor, tr("Lighted sample"));
_previewCoverage = new PreviewTexturesCoverage(this, _layer);
_previewColor = new PreviewTexturesColor(this, _layer);
addPreview(_previewCoverage, tr("Coverage preview"));
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);

4
gui_qt/formtextures.h
View file

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

2
lib_paysages/auto.c
View file

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

314
lib_paysages/clouds.c
View file

@ -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)
{
cloudsDeleteLayer(definition, 0);
}
layersDelete(definition->layers);
}
void cloudsCopyDefinition(CloudsDefinition* source, CloudsDefinition* destination)
{
CloudsLayerDefinition* layer;
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);
}
layersCopy(source->layers, destination->layers);
}
void cloudsValidateDefinition(CloudsDefinition* definition)
{
int i;
for (i = 0; i < definition->nblayers; i++)
{
cloudsLayerValidateDefinition(&definition->layers[i]);
}
layersValidate(definition->layers);
}
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;
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);
CloudsLayerDefinition* result;
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)
{
return definition->layers + layer;
}
else
{
return &NULL_LAYER;
}
}
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;
}
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;
}
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;
CloudsLayerDefinition layers[CLOUDS_MAX_LAYERS];
int i, n;
if (definition->nblayers < 1)
n = layersCount(definition->layers);
if (n < 1)
{
return base;
}
memcpy(layers, definition->layers, sizeof(CloudsLayerDefinition) * definition->nblayers);
qsort(layers, definition->nblayers, sizeof(CloudsLayerDefinition), _cmpLayer);
for (i = 0; i < definition->nblayers; i++)
/* TODO Iter layers in sorted order */
for (i = 0; i < n; 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;
/* TODO Order layers ? */
for (i = 0; i < definition->nblayers; i++)
int i, n;
/* 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;
}

25
lib_paysages/clouds.h
View file

@ -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;
CloudsLayerDefinition layers[CLOUDS_MAX_LAYERS];
Layers* 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);
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);
LayerType cloudsGetLayerType();
Color cloudsApplyLayer(CloudsLayerDefinition* definition, Color base, Renderer* renderer, Vector3 start, Vector3 end);
Color cloudsApply(CloudsDefinition* definition, Color base, Renderer* renderer, Vector3 start, Vector3 end);

2
lib_paysages/scenery.c
View file

@ -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();
}

76
lib_paysages/textures.c
View file

@ -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;

2
lib_paysages/textures.h
View file

@ -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);