paysages: Big big refactoring for scenery and renderer (WIP - Clouds still broken).

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

cli/main.c

@@ -3,11 +3,14 @@
 #include <string.h>
 
 #include "../lib_paysages/shared/functions.h"
+#include "../lib_paysages/auto.h"
+#include "../lib_paysages/render.h"
+#include "../lib_paysages/scenery.h"
 
-void startRender(char* outputpath)
+void startRender(Renderer* renderer, char* outputpath)
 {
     printf("\rRendering %s ...                   \n", outputpath);
-    autoRenderSceneTwoPass(0);
+    autoRenderSceneTwoPass(renderer, 0);
     printf("\rSaving %s ...                      \n", outputpath);
     remove(outputpath);
     renderSaveToFile(outputpath);
@@ -26,6 +29,7 @@ void _previewUpdate(double progress)
 
 int main(int argc, char** argv)
 {
+    Renderer renderer;
     int conf_render_width = 800;
     int conf_render_height = 600;
     int conf_render_quality = 5;
@@ -94,8 +98,8 @@ int main(int argc, char** argv)
     printf("Initializing ...\n");
     paysagesInit();
 
+    renderer = sceneryGetStandardRenderer(conf_render_quality);
     renderSetSize(conf_render_width, conf_render_height);
-    renderSetQuality(conf_render_quality);
     renderSetPreviewCallbacks(NULL, NULL, NULL, _previewUpdate);
 
     for (outputcount = 0; outputcount < conf_nb_pictures; outputcount++)
@@ -103,7 +107,7 @@ int main(int argc, char** argv)
         autoSetDaytimeFraction(conf_daytime_start);
 
         sprintf(outputpath, "output/pic%05d.png", outputcount);
-        startRender(outputpath);
+        startRender(&renderer, outputpath);
 
         conf_daytime_start += conf_daytime_step;
     }

gui_qt/dialogrender.cpp

@@ -5,15 +5,25 @@
 #include <QColor>
 #include <QPainter>
 
+#include "../lib_paysages/render.h"
+#include "../lib_paysages/renderer.h"
+#include "../lib_paysages/scenery.h"
+#include "../lib_paysages/auto.h"
 #include "../lib_paysages/shared/functions.h"
 
 class RenderThread:public QThread
 {
 public:
+    RenderThread(Renderer* renderer):QThread()
+    {
+        _renderer = renderer;
+    }
     void run()
     {
-        autoRenderSceneTwoPass(0);
+        autoRenderSceneTwoPass(_renderer, 0);
     }
+private:
+    Renderer* _renderer;
 };
 
 static DialogRender* _current_dialog;
@@ -89,12 +99,13 @@ DialogRender::DialogRender(QWidget *parent):
 
 void DialogRender::startRender(int quality, int width, int height)
 {
-    renderSetSize(width, height);
+    Renderer renderer;
-    autoSetRenderQuality(quality);
 
+    renderer = sceneryGetStandardRenderer(quality);
+    renderSetSize(width, height);
     renderSetPreviewCallbacks(_renderResize, _renderClear, _renderDraw, _renderUpdate);
 
-    render_thread = new RenderThread();
+    render_thread = new RenderThread(&renderer);
     render_thread->start();
 
     exec();

gui_qt/formrender.cpp

@@ -4,6 +4,7 @@
 #include <QMessageBox>
 
 #include "dialogrender.h"
+#include "../lib_paysages/render.h"
 #include "../lib_paysages/shared/functions.h"
 
 /**************** Form ****************/

gui_qt/formsky.cpp

@@ -7,6 +7,8 @@
 #include <math.h>
 
 #include "../lib_paysages/sky.h"
+#include "../lib_paysages/scenery.h"
+#include "../lib_paysages/renderer.h"
 #include "../lib_paysages/shared/functions.h"
 #include "../lib_paysages/shared/constants.h"
 
@@ -19,6 +21,7 @@ public:
     PreviewEast(QWidget* parent):
         Preview(parent)
     {
+        _renderer = rendererGetFake();
     }
 protected:
     QColor getColor(double x, double y)
@@ -30,8 +33,10 @@ protected:
         look.y = -y;
         look.z = x;
 
-        return colorToQColor(skyGetColorCustom(eye, look, &_definition, NULL, NULL));
+        return colorToQColor(skyGetColor(&_definition, &_renderer, eye, look));
     }
+private:
+    Renderer _renderer;
 };
 
 class PreviewWest:public Preview
@@ -40,6 +45,7 @@ public:
     PreviewWest(QWidget* parent):
         Preview(parent)
     {
+        _renderer = rendererGetFake();
     }
 protected:
     QColor getColor(double x, double y)
@@ -51,8 +57,10 @@ protected:
         look.y = -y;
         look.z = -x;
 
-        return colorToQColor(skyGetColorCustom(eye, look, &_definition, NULL, NULL));
+        return colorToQColor(skyGetColor(&_definition, &_renderer, eye, look));
     }
+private:
+    Renderer _renderer;
 };
 
 /**************** Form ****************/
@@ -79,13 +87,13 @@ FormSky::FormSky(QWidget *parent):
 
 void FormSky::revertConfig()
 {
-    skyCopyDefinition(skyGetDefinition(), &_definition);
+    sceneryGetSky(&_definition);
     BaseForm::revertConfig();
 }
 
 void FormSky::applyConfig()
 {
-    skySetDefinition(_definition);
+    scenerySetSky(&_definition);
     BaseForm::applyConfig();
 }
 

gui_qt/formterrain.cpp

@@ -6,6 +6,7 @@
 #include <math.h>
 
 #include "../lib_paysages/terrain.h"
+#include "../lib_paysages/scenery.h"
 #include "../lib_paysages/shared/functions.h"
 #include "../lib_paysages/shared/constants.h"
 
@@ -15,8 +16,7 @@ static TerrainDefinition _definition;
 class PreviewTerrainHeight:public Preview
 {
 public:
-    PreviewTerrainHeight(QWidget* parent):
+    PreviewTerrainHeight(QWidget* parent):Preview(parent)
-        Preview(parent)
     {
     }
 protected:
@@ -24,7 +24,7 @@ protected:
     {
         double height;
 
-        height = terrainGetHeightNormalizedCustom(x, y, &_definition);
+        height = terrainGetHeightNormalized(&_definition, x, y);
         return QColor((int)(255.0 * height), (int)(255.0 * height), (int)(255.0 * height));
     }
 };
@@ -32,23 +32,18 @@ protected:
 class PreviewTerrainColor:public Preview
 {
 public:
-    PreviewTerrainColor(QWidget* parent):
+    PreviewTerrainColor(QWidget* parent):Preview(parent)
-        Preview(parent)
     {
-        _lighting_environment.filter = NULL;
+        // TODO Use custom renderer
-
+        _renderer = sceneryGetStandardRenderer(3);
-        _environment.toggle_fog = 0;
-        _environment.lighting_definition = NULL;
-        _environment.lighting_environment = &_lighting_environment;
     }
 protected:
     QColor getColor(double x, double y)
     {
-        return colorToQColor(terrainGetColorCustom(x, y, scaling, &_definition, NULL, &_environment));
+        return colorToQColor(terrainGetColor(&_definition, &_renderer, x, y, scaling));
     }
 private:
-    LightingEnvironment _lighting_environment;
+    Renderer _renderer;
-    TerrainEnvironment _environment;
 };
 
 /**************** Form ****************/
@@ -71,13 +66,13 @@ FormTerrain::FormTerrain(QWidget *parent):
 
 void FormTerrain::revertConfig()
 {
-    terrainCopyDefinition(terrainGetDefinition(), &_definition);
+    sceneryGetTerrain(&_definition);
     BaseForm::revertConfig();
 }
 
 void FormTerrain::applyConfig()
 {
-    terrainSetDefinition(_definition);
+    scenerySetTerrain(&_definition);
     BaseForm::applyConfig();
 }
 

gui_qt/formwater.cpp

@@ -7,6 +7,8 @@
 
 #include "../lib_paysages/terrain.h"
 #include "../lib_paysages/water.h"
+#include "../lib_paysages/scenery.h"
+#include "../lib_paysages/renderer.h"
 #include "../lib_paysages/shared/functions.h"
 #include "../lib_paysages/shared/constants.h"
 
@@ -16,19 +18,20 @@ static WaterDefinition _definition;
 class PreviewWaterCoverage:public Preview
 {
 public:
-    PreviewWaterCoverage(QWidget* parent):
+    PreviewWaterCoverage(QWidget* parent):Preview(parent)
-        Preview(parent)
     {
+        _terrain = terrainCreateDefinition();
+        sceneryGetTerrain(&_terrain);
     }
 protected:
     QColor getColor(double x, double y)
     {
         double height;
 
-        height = terrainGetHeight(x, y);
+        height = terrainGetHeight(&_terrain, x, y);
         if (height > _definition.height)
         {
-            height = terrainGetHeightNormalized(x, y);
+            height = terrainGetHeightNormalized(&_terrain, x, y);
             return QColor((int)(255.0 * height), (int)(255.0 * height), (int)(255.0 * height));
         }
         else
@@ -36,24 +39,24 @@ protected:
             return colorToQColor(_definition.main_color);
         }
     }
+private:
+    TerrainDefinition _terrain;
 };
 
 class PreviewWaterColor:public Preview
 {
 public:
-    PreviewWaterColor(QWidget* parent):
+    PreviewWaterColor(QWidget* parent):Preview(parent)
-        Preview(parent)
     {
+        _water = waterCreateDefinition();
+        _renderer = rendererGetFake();
+        _renderer.rayWalking = _rayWalking;
+        // TODO Lighting
     }
 protected:
     QColor getColor(double x, double y)
     {
         Vector3 eye, look, location;
-        WaterDefinition definition;
-        WaterEnvironment environment;
-        LightingEnvironment lighting_environment;
-        WaterQuality quality;
-        Color result;
 
         eye.x = 0.0;
         eye.y = scaling;
@@ -65,8 +68,7 @@ protected:
 
         if (look.y > -0.0001)
         {
-            result = this->rayCastFromWater(eye, look).hit_color;
+            return colorToQColor(_rayWalking(&_renderer, eye, look, 0, 0, 0, 0).hit_color);
-            return colorToQColor(result);
         }
 
         location.x = eye.x - look.x * eye.y / look.y;
@@ -75,27 +77,17 @@ protected:
 
         if (location.z > 0.0)
         {
-            result = this->rayCastFromWater(eye, look).hit_color;
+            return colorToQColor(_rayWalking(&_renderer, eye, look, 0, 0, 0, 0).hit_color);
-            return colorToQColor(result);
         }
 
-        definition = _definition;
+        _water.height = 0.0;
-        definition.height = 0.0;
+        return colorToQColor(waterGetColor(&_definition, &_renderer, location, look));
-        lighting_environment.filter = NULL;
-        environment.reflection_function = (RayCastingFunction)(&this->rayCastFromWater);
-        environment.refraction_function = (RayCastingFunction)(&this->rayCastFromWater);
-        environment.toggle_fog = 0;
-        environment.lighting_definition = NULL;
-        environment.lighting_environment = &lighting_environment;
-        quality.force_detail = 0.0001;
-        quality.detail_boost = 1.0;
-
-        result = waterGetColorCustom(location, look, &definition, &quality, &environment).final;
-        return colorToQColor(result);
     }
 
 private:
-    static RayCastingResult rayCastFromWater(Vector3 start, Vector3 direction)
+    Renderer _renderer;
+    WaterDefinition _water;
+    static RayCastingResult _rayWalking(Renderer* renderer, Vector3 location, Vector3 direction, int terrain, int water, int sky, int clouds)
     {
         RayCastingResult result;
         double x, y;
@@ -104,12 +96,12 @@ private:
         if (direction.z < 0.0001)
         {
             result.hit_color = COLOR_WHITE;
-            result.hit_location = start;
+            result.hit_location = location;
         }
         else
         {
-            x = start.x + direction.x * (0.0 - start.z) / direction.z;
+            x = location.x + direction.x * (0.0 - location.z) / direction.z;
-            y = start.y + direction.y * (0.0 - start.z) / direction.z;
+            y = location.y + direction.y * (0.0 - location.z) / direction.z;
 
             if (((int)ceil(x * 0.2) % 2 == 0) ^ ((int)ceil(y * 0.2 - 0.5) % 2 == 0))
             {
@@ -154,12 +146,12 @@ FormWater::FormWater(QWidget *parent):
 
 void FormWater::revertConfig()
 {
-    waterCopyDefinition(waterGetDefinition(), &_definition);
+    sceneryGetWater(&_definition);
     BaseForm::revertConfig();
 }
 
 void FormWater::applyConfig()
 {
-    waterSetDefinition(_definition);
+    scenerySetWater(&_definition);
     BaseForm::applyConfig();
 }

gui_qt/mainwindow.cpp

@@ -12,6 +12,7 @@
 #include "formrender.h"
 #include "dialogrender.h"
 
+#include "../lib_paysages/auto.h"
 #include "../lib_paysages/shared/functions.h"
 
 int main(int argc, char** argv)

gui_qt/tools.h

@@ -12,4 +12,4 @@ static inline QColor colorToQColor(Color color)
     return QColor(color.r * 255.0, color.g * 255.0, color.b * 255.0, color.a * 255.0);
 }
 
-#endif // _PAYSAGES_QT_TOOLS_H_
+#endif

lib_paysages/auto.c

@@ -1,4 +1,5 @@
-#include <unistd.h>
+#include "auto.h"
+
 #include <math.h>
 #include <stdlib.h>
 #include <time.h>
@@ -7,8 +8,8 @@
 #include "shared/functions.h"
 #include "shared/constants.h"
 #include "shared/globals.h"
-#include "shared/system.h"
 
+#include "system.h"
 #include "water.h"
 #include "clouds.h"
 #include "sky.h"
@@ -17,40 +18,10 @@
 #include "textures.h"
 #include "lighting.h"
 #include "scenery.h"
+#include "render.h"
 
-#ifdef WIN32
-#include <windows.h>
-#endif
-
-static int _cpu_count = 1;
 static int _is_rendering = 0;
 
-void autoInit()
-{
-#ifdef WIN32
-    DWORD processAffinityMask;
-    DWORD systemAffinityMask;
-
-    if (GetProcessAffinityMask( GetCurrentProcess(),
-                                &processAffinityMask,
-                                &systemAffinityMask)){
-        processAffinityMask = (processAffinityMask & 0x55555555)
-            + (processAffinityMask >> 1 & 0x55555555);
-        processAffinityMask = (processAffinityMask & 0x33333333)
-            + (processAffinityMask >> 2 & 0x33333333);
-        processAffinityMask = (processAffinityMask & 0x0f0f0f0f)
-            + (processAffinityMask >> 4 & 0x0f0f0f0f);
-        processAffinityMask = (processAffinityMask & 0x00ff00ff)
-            + (processAffinityMask >> 8 & 0x00ff00ff);
-        _cpu_count          = (processAffinityMask & 0x0000ffff)
-            + (processAffinityMask >>16 & 0x0000ffff);
-    }
-#endif
-#ifdef _SC_NPROCESSORS_ONLN
-    _cpu_count = (int)sysconf(_SC_NPROCESSORS_ONLN);
-#endif
-}
-
 void autoSetDaytime(int hour, int minute)
 {
     autoSetDaytimeFraction((double)hour / 24.0 + (double)minute / 1440.0);
@@ -252,29 +223,12 @@ void autoGenRealisticLandscape(int seed)
 
 void* _renderFirstPass(void* data)
 {
-    if (!renderSetNextProgressStep(0.0, 0.01))
+    sceneryRenderFirstPass((Renderer*)data);
-    {
-        _is_rendering = 0;
-        return NULL;
-    }
-    skyRender(renderTellProgress);
-    if (!renderSetNextProgressStep(0.01, 0.085))
-    {
-        _is_rendering = 0;
-        return NULL;
-    }
-    terrainRender(renderTellProgress);
-    if (!renderSetNextProgressStep(0.085, 0.1))
-    {
-        _is_rendering = 0;
-        return NULL;
-    }
-    waterRender(renderTellProgress);
     _is_rendering = 0;
     return NULL;
 }
 
-void autoRenderSceneTwoPass(int postonly)
+void autoRenderSceneTwoPass(Renderer* renderer, int postonly)
 {
     Thread* thread;
     int loops;
@@ -284,7 +238,7 @@ void autoRenderSceneTwoPass(int postonly)
         renderClear();
 
         _is_rendering = 1;
-        thread = threadCreate(_renderFirstPass, NULL);
+        thread = threadCreate(_renderFirstPass, renderer);
         loops = 0;
 
         while (_is_rendering)
@@ -300,10 +254,7 @@ void autoRenderSceneTwoPass(int postonly)
 
         threadJoin(thread);
     }
-    if (renderSetNextProgressStep(0.1, 1.0))
+    sceneryRenderSecondPass(renderer);
-    {
-        renderPostProcess(_cpu_count);
-    }
 }
 
 static int _postProcessRayTracingOverlay(RenderFragment* fragment)

lib_paysages/auto.h

@@ -0,0 +1,20 @@
+#ifndef _PAYSAGES_AUTO_H_
+#define _PAYSAGES_AUTO_H_
+
+#include "renderer.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+void autoSetDaytime(int hour, int minute);
+void autoSetDaytimeFraction(double daytime);
+void autoGenRealisticLandscape(int seed);
+void autoRenderSceneTwoPass(Renderer* renderer, int postonly);
+void autoRenderSceneRayTracing();
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

lib_paysages/camera.c

@@ -3,6 +3,7 @@
 #include <stdlib.h>
 #include <math.h>
 
+#include "render.h"
 #include "shared/types.h"
 #include "shared/globals.h"
 #include "shared/constants.h"
@@ -118,7 +119,7 @@ void cameraProjectToFragment(CameraDefinition* camera, double x, double y, doubl
  */
 void cameraPushOverlay(CameraDefinition* camera, Color col, f_RenderFragmentCallback callback)
 {
-    Vertex v1, v2, v3, v4;
+    /*Vertex v1, v2, v3, v4;
     Vector3 v;
 
     v.x = 0.0;
@@ -149,5 +150,5 @@ void cameraPushOverlay(CameraDefinition* camera, Color col, f_RenderFragmentCall
     v4.color = col;
     v4.callback = callback;
 
-    renderPushQuad(&v1, &v2, &v3, &v4);
+    renderPushQuad(&v1, &v2, &v3, &v4);*/
 }

lib_paysages/clouds.c

@@ -480,8 +480,7 @@ Color cloudsGetLayerColor(CloudsLayerDefinition* definition, Renderer* renderer,
     direction = v3Normalize(direction);
     result = COLOR_TRANSPARENT;
 
-    /* TODO Flexible precision */
+    detail = renderer->getPrecision(renderer, start) / definition->scaling;
-    detail = renderGetPrecision(start) / definition->scaling;
 
     segment_count = _findSegments(definition, renderer, start, direction, detail, 20, 60.0, max_length, &inside_length, &total_length, segments);
     for (i = 0; i < segment_count; i++)

lib_paysages/color.c

@@ -1,4 +1,5 @@
 #include <stdlib.h>
+#include <assert.h>
 
 #include "shared/types.h"
 #include "shared/constants.h"
@@ -72,6 +73,11 @@ double colorNormalize(Color* col)
 {
     double max = colorGetValue(col);
 
+    assert(col->r >= 0.0);
+    assert(col->g >= 0.0);
+    assert(col->b >= 0.0);
+    assert(col->a >= 0.0);
+
     if (max > 1.0)
     {
         col->r /= max;

lib_paysages/fog.c

@@ -27,6 +27,7 @@ void fogSetDistance(double near, double far)
 
 Color fogApplyToLocation(Vector3 location, Color base)
 {
+    return base;
     // TODO Don't use camera_location
     /*Color mask = _col;
     double distance = v3Norm(v3Sub(camera_location, location));

lib_paysages/lighting.c

@@ -25,14 +25,34 @@ void lightingInit()
     _LIGHT_NULL.direction.z = 0.0;
 }
 
-void lightingSave(FILE* f)
+void lightingSave(FILE* f, LightingDefinition* definition)
 {
-    // TODO
+    int i;
+
+    toolsSaveInt(f, definition->autosetfromsky);
+    toolsSaveInt(f, definition->nblights);
+    for (i = 0; i < definition->nblights; i++)
+    {
+        colorSave(definition->lights[i].color, f);
+        v3Save(definition->lights[i].direction, f);
+        toolsSaveDouble(f, definition->lights[i].maxshadow);
+    }
 }
 
-void lightingLoad(FILE* f)
+void lightingLoad(FILE* f, LightingDefinition* definition)
 {
-    // TODO
+    int i;
+
+    definition->autosetfromsky = toolsLoadInt(f);
+    definition->nblights = toolsLoadInt(f);
+    for (i = 0; i < definition->nblights; i++)
+    {
+        definition->lights[i].color = colorLoad(f);
+        definition->lights[i].direction = v3Load(f);
+        definition->lights[i].maxshadow = toolsLoadDouble(f);
+    }
+
+    lightingValidateDefinition(definition);
 }
 
 LightingDefinition lightingCreateDefinition()

lib_paysages/lighting.h

@@ -27,16 +27,9 @@ typedef struct
     LightDefinition _autolights[LIGHTING_MAX_LIGHTS];
 } LightingDefinition;
 
-typedef struct
-{
-    Color base;
-    double reflection;
-    double shininess;
-} SurfaceMaterial;
-
 void lightingInit();
-void lightingSave(FILE* f);
+void lightingSave(FILE* f, LightingDefinition* definition);
-void lightingLoad(FILE* f);
+void lightingLoad(FILE* f, LightingDefinition* definition);
 
 LightingDefinition lightingCreateDefinition();
 void lightingDeleteDefinition(LightingDefinition* definition);

lib_paysages/main.c

@@ -8,28 +8,30 @@
 #include "shared/constants.h"
 #include "shared/functions.h"
 #include "shared/globals.h"
-#include "shared/system.h"
 
-#include "terrain.h"
+#include "auto.h"
-#include "water.h"
+#include "system.h"
-#include "lighting.h"
+#include "camera.h"
-#include "textures.h"
+#include "scenery.h"
-#include "sky.h"
+#include "render.h"
-#include "clouds.h"
 
 void paysagesInit()
 {
+    CameraDefinition camera;
+
     systemInit();
     ilInit();
     iluInit();
 
-    autoInit();
+    sceneryInit();
     renderInit();
 
-    cameraSetLocation(-12.0, 5.0, 2.0);
+    camera = cameraCreateDefinition();
-    cameraSetTarget(0.0, 5.0, 0.0);
+    cameraSetLocation(&camera, -12.0, 5.0, 2.0);
+    cameraSetTarget(&camera, 0.0, 5.0, 0.0);
+    scenerySetCamera(&camera);
+    cameraDeleteDefinition(&camera);
 
-    autoSetRenderQuality(5);
     autoGenRealisticLandscape(0);
     autoSetDaytime(8, 30);
 

lib_paysages/render.c

@@ -1,7 +1,4 @@
-#include "shared/types.h"
+#include "render.h"
-#include "shared/constants.h"
-#include "shared/functions.h"
-#include "shared/system.h"
 
 #include <stdlib.h>
 #include <math.h>
@@ -9,6 +6,11 @@
 #include "IL/il.h"
 #include "IL/ilu.h"
 
+#include "shared/types.h"
+#include "shared/constants.h"
+#include "shared/functions.h"
+#include "system.h"
+
 int render_width;
 int render_height;
 int render_quality;
@@ -166,17 +168,6 @@ void renderSetBackgroundColor(Color* col)
     background_color = *col;
 }
 
-double renderGetPrecision(Vector3 location)
-{
-    Vector3 projected;
-
-    projected = cameraProject(location);
-    projected.x += 1.0;
-    //projected.y += 1.0;
-
-    return v3Norm(v3Sub(cameraUnproject(projected), location)); // / (double)render_quality;
-}
-
 int _sortRenderFragment(void const* a, void const* b)
 {
     double za, zb;
@@ -375,6 +366,7 @@ static void __vertexGetDiff(Vertex* v1, Vertex* v2, Vertex* result)
     result->color.b = v2->color.b - v1->color.b;
     result->color.a = v2->color.a - v1->color.a;
     result->callback = v1->callback;
+    result->callback_data = v1->callback_data;
 }
 
 static void __vertexInterpolate(Vertex* v1, Vertex* diff, double value, Vertex* result)
@@ -390,6 +382,7 @@ static void __vertexInterpolate(Vertex* v1, Vertex* diff, double value, Vertex*
     result->color.b = v1->color.b + diff->color.b * value;
     result->color.a = v1->color.a + diff->color.a * value;
     result->callback = v1->callback;
+    result->callback_data = v1->callback_data;
 }
 
 static void __pushScanLinePoint(RenderFragment point)
@@ -567,15 +560,15 @@ static void __renderScanLines()
     }
 }
 
-void renderPushTriangle(Vertex* v1, Vertex* v2, Vertex* v3)
+void renderPushTriangle(Renderer* renderer, Vertex* v1, Vertex* v2, Vertex* v3)
 {
     Vector3 p1, p2, p3;
     double limit_width = (double)(render_width - 1);
     double limit_height = (double)(render_height - 1);
 
-    p1 = cameraProject(v1->location);
+    p1 = renderer->projectPoint(renderer, v1->location);
-    p2 = cameraProject(v2->location);
+    p2 = renderer->projectPoint(renderer, v2->location);
-    p3 = cameraProject(v3->location);
+    p3 = renderer->projectPoint(renderer, v3->location);
 
     /* Filter if outside screen */
     if (p1.z < 1.0 || p2.z < 1.0 || p3.z < 1.0 || (p1.x < 0.0 && p2.x < 0.0 && p3.x < 0.0) || (p1.y < 0.0 && p2.y < 0.0 && p3.y < 0.0) || (p1.x > limit_width && p2.x > limit_width && p3.x > limit_width) || (p1.y > limit_height && p2.y > limit_height && p3.y > limit_height))
@@ -592,10 +585,10 @@ void renderPushTriangle(Vertex* v1, Vertex* v2, Vertex* v3)
     mutexRelease(_lock);
 }
 
-void renderPushQuad(Vertex* v1, Vertex* v2, Vertex* v3, Vertex* v4)
+void renderPushQuad(Renderer* renderer, Vertex* v1, Vertex* v2, Vertex* v3, Vertex* v4)
 {
-    renderPushTriangle(v2, v3, v1);
+    renderPushTriangle(renderer, v2, v3, v1);
-    renderPushTriangle(v4, v1, v3);
+    renderPushTriangle(renderer, v4, v1, v3);
 }
 
 typedef struct {
@@ -606,6 +599,7 @@ typedef struct {
     int finished;
     int interrupt;
     Thread* thread;
+    Renderer* renderer;
 } RenderChunk;
 
 void* _renderPostProcessChunk(void* data)
@@ -631,7 +625,7 @@ void* _renderPostProcessChunk(void* data)
             {
                 if (fragments[i].vertex.callback)
                 {
-                    if (fragments[i].vertex.callback(fragments + i))
+                    if (fragments[i].vertex.callback(fragments + i, chunk->renderer, fragments[i].vertex.callback_data))
                     {
                         /* TODO Store over-exposure */
                         colorNormalize(&fragments[i].vertex.color);
@@ -658,7 +652,7 @@ void* _renderPostProcessChunk(void* data)
 }
 
 #define MAX_CHUNKS 8
-void renderPostProcess(int nbchunks)
+void renderPostProcess(Renderer* renderer, int nbchunks)
 {
     volatile RenderChunk chunks[MAX_CHUNKS];
     int i;
@@ -685,6 +679,7 @@ void renderPostProcess(int nbchunks)
     for (i = 0; i < nbchunks; i++)
     {
         chunks[i].thread = NULL;
+        chunks[i].renderer = renderer;
     }
 
     running = 0;

lib_paysages/render.h

@@ -0,0 +1,36 @@
+#ifndef _PAYSAGES_RENDER_H_
+#define _PAYSAGES_RENDER_H_
+
+#include <stdio.h>
+#include "shared/types.h"
+#include "renderer.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+void renderInit();
+void renderSave(FILE* f);
+void renderLoad(FILE* f);
+void renderSetSize(int width, int height);
+int renderSetQuality(int quality);
+void renderClear();
+void renderUpdate();
+void renderInterrupt();
+void renderSetBackgroundColor(Color* col);
+void renderAddFragment(RenderFragment* fragment);
+void renderPushFragment(int x, int y, double z, Vertex* vertex);
+void renderPushTriangle(Renderer* renderer, Vertex* v1, Vertex* v2, Vertex* v3);
+void renderPushQuad(Renderer* renderer, Vertex* v1, Vertex* v2, Vertex* v3, Vertex* v4);
+void renderPostProcess(Renderer* renderer, int nbchunks);
+void renderSaveToFile(const char* path);
+void renderSetPreviewCallbacks(PreviewCallbackResize resize, PreviewCallbackClear clear, PreviewCallbackDraw draw, PreviewCallbackUpdate update);
+int renderSetNextProgressStep(double start, double end);
+int renderTellProgress(double progress);
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

lib_paysages/renderer.c

@@ -1,11 +1,59 @@
 #include "renderer.h"
 #include "shared/constants.h"
+#include "lighting.h"
 
-static Color _fakeFilterLight(Renderer* renderer, Color light_color, Vector3 at_location, Vector3 light_location, Vector3 direction_to_light)
+RayCastingResult _RAYCASTING_NULL = {0};
+
+static Color _filterLight(Renderer* renderer, Color light_color, Vector3 at_location, Vector3 light_location, Vector3 direction_to_light)
 {
     return light_color;
 }
 
+static Color _applyLightingToSurface(Renderer* renderer, Vector3 location, Vector3 normal, SurfaceMaterial material)
+{
+    return material.base;
+}
+
+static RayCastingResult _rayWalking(Renderer* renderer, Vector3 location, Vector3 direction, int terrain, int water, int sky, int clouds)
+{
+    return _RAYCASTING_NULL;
+}
+
+static double _getTerrainHeight(Renderer* renderer, double x, double z)
+{
+    return 0.0;
+}
+
+static Color _applyTextures(Renderer* renderer, Vector3 location, double precision)
+{
+    return COLOR_TRANSPARENT;
+}
+
+static Color _applyAtmosphere(Renderer* renderer, Vector3 location, Color base)
+{
+    return base;
+}
+
+static Color _applyClouds(Renderer* renderer, Color base, Vector3 start, Vector3 end)
+{
+    return base;
+}
+
+static Vector3 _projectPoint(Renderer* renderer, Vector3 point)
+{
+    return point;
+}
+
+static Vector3 _unprojectPoint(Renderer* renderer, Vector3 point)
+{
+    return point;
+}
+
+static double _getPrecision(Renderer* renderer, Vector3 location)
+{
+    return 0.001;
+}
+
 Renderer rendererGetFake()
 {
     Renderer result;
@@ -13,7 +61,16 @@ Renderer rendererGetFake()
     result.render_quality = 5;
     result.camera_location = VECTOR_ZERO;
 
-    result.filterLight = _fakeFilterLight;
+    result.filterLight = _filterLight;
+    result.applyLightingToSurface = _applyLightingToSurface;
+    result.rayWalking = _rayWalking;
+    result.getTerrainHeight = _getTerrainHeight;
+    result.applyTextures = _applyTextures;
+    result.applyAtmosphere = _applyAtmosphere;
+    result.applyClouds = _applyClouds;
+    result.projectPoint = _projectPoint;
+    result.unprojectPoint = _unprojectPoint;
+    result.getPrecision = _getPrecision;
 
     return result;
 }

lib_paysages/renderer.h

@@ -15,8 +15,21 @@ struct Renderer
     int render_quality;
     Vector3 camera_location;
 
+    /* Render related */
+    double (*getPrecision)(Renderer* renderer, Vector3 location);
+    Vector3 (*projectPoint)(Renderer* renderer, Vector3 point);
+    Vector3 (*unprojectPoint)(Renderer* renderer, Vector3 point);
+
+    /* Scenery related */
+    RayCastingResult (*rayWalking)(Renderer* renderer, Vector3 location, Vector3 direction, int terrain, int water, int sky, int clouds);
+    double (*getTerrainHeight)(Renderer* renderer, double x, double z);
+    Color (*applyTextures)(Renderer* renderer, Vector3 location, double precision);
+    Color (*applyAtmosphere)(Renderer* renderer, Vector3 location, Color base);
+    Color (*applyClouds)(Renderer* renderer, Color base, Vector3 start, Vector3 end);
+
     /* Lighting related */
     Color (*filterLight)(Renderer* renderer, Color light_color, Vector3 at_location, Vector3 light_location, Vector3 direction_to_light);
+    Color (*applyLightingToSurface)(Renderer* renderer, Vector3 location, Vector3 normal, SurfaceMaterial material);
 
     /* Custom data */
     void* customData[10];

lib_paysages/scenery.c

@@ -1,6 +1,9 @@
 #include "scenery.h"
 
 #include <stdio.h>
+#include "shared/functions.h"
+#include "system.h"
+#include "render.h"
 
 CameraDefinition _camera;
 CloudsDefinition _clouds;
@@ -10,41 +13,6 @@ TerrainDefinition _terrain;
 TexturesDefinition _textures;
 WaterDefinition _water;
 
-static Color _filterLight(Renderer* renderer, Color light_color, Vector3 at_location, Vector3 light_location, Vector3 direction_to_light)
-{
-    Color result;
-
-    result = waterLightFilter(&_water, renderer, light_color, at_location, light_location, direction_to_light);
-    result = terrainLightFilter(&_terrain, renderer, result, at_location, light_location, direction_to_light);
-    // TODO atmosphere filter
-    // TODO clouds filter
-
-    return result;
-}
-
-static RayCastingResult _reflectionFunction(Vector3 start, Vector3 direction)
-{
-    RayCastingResult result;
-
-    if (!terrainProjectRay(start, direction, &result.hit_location, &result.hit_color))
-    {
-        result.hit_color = skyProjectRay(start, direction);
-        /* TODO hit_location */
-    }
-
-    result.hit = 1;
-    return result;
-}
-
-static RayCastingResult _refractionFunction(Vector3 start, Vector3 direction)
-{
-    RayCastingResult result;
-
-    result.hit = terrainProjectRay(start, direction, &result.hit_location, &result.hit_color);
-
-    return result;
-}
-
 void sceneryInit()
 {
     cameraInit();
@@ -128,7 +96,7 @@ void scenerySetClouds(CloudsDefinition* clouds)
 
 void sceneryGetClouds(CloudsDefinition* clouds)
 {
-    cloudsCopyDefinition(_clouds, clouds);
+    cloudsCopyDefinition(&_clouds, clouds);
 }
 
 void scenerySetLighting(LightingDefinition* lighting)
@@ -188,10 +156,134 @@ void sceneryGetWater(WaterDefinition* water)
     waterCopyDefinition(&_water, water);
 }
 
-Renderer sceneryGetStandardRenderer()
+void sceneryRenderFirstPass(Renderer* renderer)
 {
+    if (!renderSetNextProgressStep(0.0, 0.01))
+    {
+        return;
+    }
+    skyRender(&_sky, renderer, renderTellProgress);
+    if (!renderSetNextProgressStep(0.01, 0.085))
+    {
+        return;
+    }
+    terrainRender(&_terrain, renderer, renderTellProgress);
+    if (!renderSetNextProgressStep(0.085, 0.1))
+    {
+        return;
+    }
+    waterRender(&_water, renderer, renderTellProgress);
 }
 
-void sceneryRender()
+void sceneryRenderSecondPass(Renderer* renderer)
 {
+    if (renderSetNextProgressStep(0.1, 1.0))
+    {
+        renderPostProcess(renderer, systemGetCoreCount());
+    }
 }
+
+
+
+
+
+
+/******* Standard renderer *********/
+static Color _filterLight(Renderer* renderer, Color light_color, Vector3 at_location, Vector3 light_location, Vector3 direction_to_light)
+{
+    Color result;
+
+    result = waterLightFilter(&_water, renderer, light_color, at_location, light_location, direction_to_light);
+    result = terrainLightFilter(&_terrain, renderer, result, at_location, light_location, direction_to_light);
+    // TODO atmosphere filter
+    // TODO clouds filter
+
+    return result;
+}
+
+static Color _applyLightingToSurface(Renderer* renderer, Vector3 location, Vector3 normal, SurfaceMaterial material)
+{
+    return lightingApplyToSurface(&_lighting, renderer, location, normal, material);
+}
+
+static RayCastingResult _rayWalking(Renderer* renderer, Vector3 location, Vector3 direction, int terrain, int water, int sky, int clouds)
+{
+    RayCastingResult result;
+
+    if (!terrainProjectRay(&_terrain, renderer, location, direction, &result.hit_location, &result.hit_color))
+    {
+        result.hit_color = skyGetColor(&_sky, renderer, location, direction);
+        /* TODO hit_location */
+    }
+
+    result.hit = 1;
+    return result;
+}
+
+static double _getTerrainHeight(Renderer* renderer, double x, double z)
+{
+    return terrainGetHeight(&_terrain, x, z);
+}
+
+static Color _applyTextures(Renderer* renderer, Vector3 location, double precision)
+{
+    return texturesGetColor(&_textures, renderer, location, precision);
+}
+
+static Color _applyAtmosphere(Renderer* renderer, Vector3 location, Color base)
+{
+    return base;
+}
+
+static Color _applyClouds(Renderer* renderer, Color base, Vector3 start, Vector3 end)
+{
+    Color clouds;
+
+    clouds = cloudsGetColor(&_clouds, renderer, start, end);
+    colorMask(&base, &clouds);
+
+    return base;
+}
+
+static Vector3 _projectPoint(Renderer* renderer, Vector3 point)
+{
+    return cameraProject(&_camera, point);
+}
+
+static Vector3 _unprojectPoint(Renderer* renderer, Vector3 point)
+{
+    return cameraUnproject(&_camera, point);
+}
+
+static double _getPrecision(Renderer* renderer, Vector3 location)
+{
+    Vector3 projected;
+
+    projected = cameraProject(&_camera, location);
+    projected.x += 1.0;
+    //projected.y += 1.0;
+
+    return v3Norm(v3Sub(cameraUnproject(&_camera, projected), location)); // / (double)render_quality;
+}
+
+Renderer sceneryGetStandardRenderer(int quality)
+{
+    Renderer result;
+
+    result.camera_location = _camera.location;
+    result.render_quality = quality;
+
+    result.filterLight = _filterLight;
+    result.applyLightingToSurface = _applyLightingToSurface;
+    result.rayWalking = _rayWalking;
+    result.getTerrainHeight = _getTerrainHeight;
+    result.applyTextures = _applyTextures;
+    result.applyAtmosphere = _applyAtmosphere;
+    result.applyClouds = _applyClouds;
+    result.projectPoint = _projectPoint;
+    result.unprojectPoint = _unprojectPoint;
+    result.getPrecision = _getPrecision;
+
+    return result;
+}
+

lib_paysages/scenery.h

@@ -47,8 +47,9 @@ void sceneryGetTextures(TexturesDefinition* textures);
 void scenerySetWater(WaterDefinition* water);
 void sceneryGetWater(WaterDefinition* water);
 
-Renderer sceneryGetStandardRenderer();
+Renderer sceneryGetStandardRenderer(int quality);
-void sceneryRender();
+void sceneryRenderFirstPass(Renderer* renderer);
+void sceneryRenderSecondPass(Renderer* renderer);
 
 #ifdef __cplusplus
 }

lib_paysages/shared/functions.h

@@ -21,14 +21,6 @@ void arrayReplace(Array* array, void* item, int position);
 void arrayLStrip(Array* array, int count);
 void arrayClear(Array* array);
 
-/* auto.c */
-void autoInit();
-void autoSetDaytime(int hour, int minute);
-void autoSetDaytimeFraction(double daytime);
-void autoGenRealisticLandscape(int seed);
-void autoRenderSceneTwoPass(int postonly);
-void autoRenderSceneRayTracing();
-
 /* color.c */
 void colorSave(Color col, FILE* f);
 Color colorLoad(FILE* f);
@@ -85,27 +77,6 @@ void fogSetColor(Color col);
 void fogSetDistance(double near, double far);
 Color fogApplyToLocation(Vector3 location, Color base);
 
-/* render.c */
-void renderInit();
-void renderSave(FILE* f);
-void renderLoad(FILE* f);
-void renderSetSize(int width, int height);
-int renderSetQuality(int quality);
-void renderClear();
-void renderUpdate();
-void renderInterrupt();
-void renderSetBackgroundColor(Color* col);
-double renderGetPrecision(Vector3 location);
-void renderAddFragment(RenderFragment* fragment);
-void renderPushFragment(int x, int y, double z, Vertex* vertex);
-void renderPushTriangle(Vertex* v1, Vertex* v2, Vertex* v3);
-void renderPushQuad(Vertex* v1, Vertex* v2, Vertex* v3, Vertex* v4);
-void renderPostProcess(int nbchunks);
-void renderSaveToFile(const char* path);
-void renderSetPreviewCallbacks(PreviewCallbackResize resize, PreviewCallbackClear clear, PreviewCallbackDraw draw, PreviewCallbackUpdate update);
-int renderSetNextProgressStep(double start, double end);
-int renderTellProgress(double progress);
-
 /* tools.c */
 double toolsRandom();
 double toolsBicubicInterpolate(double stencil[16], double x, double y);

lib_paysages/shared/types.h

@@ -53,8 +53,9 @@ typedef struct
 } ColorGradation;
 
 struct RenderFragment;
+struct Renderer;
 
-typedef int(*f_RenderFragmentCallback)(struct RenderFragment*);
+typedef int(*f_RenderFragmentCallback)(struct RenderFragment*, struct Renderer* renderer, void* data);
 
 typedef struct
 {
@@ -62,6 +63,7 @@ typedef struct
     Vector3 normal;
     Color color;
     f_RenderFragmentCallback callback;
+    void* callback_data;
 } Vertex;
 
 typedef struct RenderFragment
@@ -87,6 +89,13 @@ typedef struct
     void* data;
 } Array;
 
+typedef struct
+{
+    Color base;
+    double reflection;
+    double shininess;
+} SurfaceMaterial;
+
 typedef struct Zone Zone;
 
 typedef void (*PreviewCallbackResize)(int width, int height);

lib_paysages/sky.c

@@ -5,6 +5,7 @@
 #include "shared/functions.h"
 #include "shared/globals.h"
 #include "shared/constants.h"
+#include "render.h"
 #include "clouds.h"
 #include "sky.h"
 #include "lighting.h"
@@ -92,7 +93,7 @@ int skyGetLights(SkyDefinition* sky, LightDefinition* lights, int max_lights)
 
     if (max_lights > 0)
     {
-        lights[0].color = colorGradationGet(sky->sun_color, sky->daytime);
+        lights[0].color = colorGradationGet(&sky->sun_color, sky->daytime);
         lights[0].direction = v3Scale(sun_direction, -1.0);
         lights[0].maxshadow = 1.0;
         nblights = 1;
@@ -137,20 +138,21 @@ Color skyGetColor(SkyDefinition* definition, Renderer* renderer, Vector3 eye, Ve
     }
 }
 
-static int _postProcessFragment(RenderFragment* fragment, Renderer* renderer)
+static int _postProcessFragment(RenderFragment* fragment, Renderer* renderer, void* data)
 {
-    // TODO
+    Vector3 location, direction;
-    /*Vector3 location, direction;
+    Color result;
-    Color color_sky, color_clouds;
+    SkyDefinition* definition;
+
+    definition = (SkyDefinition*)data;
 
     location = fragment->vertex.location;
-    direction = v3Sub(location, camera_location);
+    direction = v3Sub(location, renderer->camera_location);
 
-    color_sky = skyGetColor(camera_location, v3Normalize(direction));
+    result = skyGetColor(definition, renderer, renderer->camera_location, v3Normalize(direction));
-    color_clouds = cloudsGetColor(camera_location, v3Add(camera_location, v3Scale(direction, 10.0)));
+    result = renderer->applyClouds(renderer, result, renderer->camera_location, v3Add(renderer->camera_location, v3Scale(direction, 10.0)));
 
-    colorMask(&color_sky, &color_clouds);
+    fragment->vertex.color = result;
-    fragment->vertex.color = color_sky;*/
 
     return 1;
 }
@@ -194,6 +196,7 @@ void skyRender(SkyDefinition* definition, Renderer* renderer, RenderProgressCall
             col.b = sin(direction.x) * sin(direction.x) * cos(direction.z) * cos(direction.z);
             vertex1.color = col;
             vertex1.callback = _postProcessFragment;
+            vertex1.callback_data = definition;
 
             direction.x = SPHERE_SIZE * cos(current_i + step_i) * cos(current_j);
             direction.y = SPHERE_SIZE * sin(current_j);
@@ -202,6 +205,7 @@ void skyRender(SkyDefinition* definition, Renderer* renderer, RenderProgressCall
             col.b = sin(direction.x) * sin(direction.x) * cos(direction.z) * cos(direction.z);
             vertex2.color = col;
             vertex2.callback = _postProcessFragment;
+            vertex2.callback_data = definition;
 
             direction.x = SPHERE_SIZE * cos(current_i + step_i) * cos(current_j + step_j);
             direction.y = SPHERE_SIZE * sin(current_j + step_j);
@@ -210,6 +214,7 @@ void skyRender(SkyDefinition* definition, Renderer* renderer, RenderProgressCall
             col.b = sin(direction.x) * sin(direction.x) * cos(direction.z) * cos(direction.z);
             vertex3.color = col;
             vertex3.callback = _postProcessFragment;
+            vertex3.callback_data = definition;
 
             direction.x = SPHERE_SIZE * cos(current_i) * cos(current_j + step_j);
             direction.y = SPHERE_SIZE * sin(current_j + step_j);
@@ -218,9 +223,10 @@ void skyRender(SkyDefinition* definition, Renderer* renderer, RenderProgressCall
             col.b = sin(direction.x) * sin(direction.x) * cos(direction.z) * cos(direction.z);
             vertex4.color = col;
             vertex4.callback = _postProcessFragment;
+            vertex4.callback_data = definition;
 
             /* TODO Triangles at poles */
-            renderPushQuad(&vertex1, &vertex4, &vertex3, &vertex2);
+            renderPushQuad(renderer, &vertex1, &vertex4, &vertex3, &vertex2);
         }
     }
 }

lib_paysages/sky.h

@@ -31,10 +31,7 @@ void skyCopyDefinition(SkyDefinition* source, SkyDefinition* destination);
 void skyValidateDefinition(SkyDefinition* definition);
 
 int skyGetLights(SkyDefinition* sky, LightDefinition* lights, int max_lights);
-
 Color skyGetColor(SkyDefinition* definition, Renderer* renderer, Vector3 eye, Vector3 look);
-Color skyProjectRay(SkyDefinition* definition, Renderer* renderer, Vector3 start, Vector3 direction);
-
 void skyRender(SkyDefinition* definition, Renderer* renderer, RenderProgressCallback callback);
 
 #ifdef __cplusplus

lib_paysages/system.c

@@ -0,0 +1,47 @@
+#include "system.h"
+#include <unistd.h>
+
+#ifdef WIN32
+#include <windows.h>
+#endif
+
+static int _core_count = 1;
+
+static int _getCoreCount()
+{
+    int core_count = 1;
+#ifdef WIN32
+    DWORD processAffinityMask;
+    DWORD systemAffinityMask;
+
+    if (GetProcessAffinityMask( GetCurrentProcess(),
+                                &processAffinityMask,
+                                &systemAffinityMask)){
+        processAffinityMask = (processAffinityMask & 0x55555555)
+            + (processAffinityMask >> 1 & 0x55555555);
+        processAffinityMask = (processAffinityMask & 0x33333333)
+            + (processAffinityMask >> 2 & 0x33333333);
+        processAffinityMask = (processAffinityMask & 0x0f0f0f0f)
+            + (processAffinityMask >> 4 & 0x0f0f0f0f);
+        processAffinityMask = (processAffinityMask & 0x00ff00ff)
+            + (processAffinityMask >> 8 & 0x00ff00ff);
+        core_count          = (processAffinityMask & 0x0000ffff)
+            + (processAffinityMask >>16 & 0x0000ffff);
+    }
+#endif
+#ifdef _SC_NPROCESSORS_ONLN
+    core_count = (int)sysconf(_SC_NPROCESSORS_ONLN);
+#endif
+    return core_count;
+}
+
+void systemInit()
+{
+    g_thread_init(NULL);
+    _core_count = _getCoreCount();
+}
+
+int systemGetCoreCount()
+{
+    return _core_count;
+}

lib_paysages/system.h

@@ -10,10 +10,8 @@ extern "C" {
 typedef GThread Thread;
 typedef void*(*ThreadFunction)(void* data);
 
-static inline void systemInit()
+void systemInit();
-{
+int systemGetCoreCount();
-    g_thread_init(NULL);
-}
 
 static inline Thread* threadCreate(ThreadFunction function, void* data)
 {

lib_paysages/terrain.c

@@ -10,6 +10,7 @@
 #include "shared/globals.h"
 #include "shared/constants.h"
 
+#include "render.h"
 #include "textures.h"
 #include "water.h"
 
@@ -50,7 +51,7 @@ void terrainLoad(FILE* f, TerrainDefinition* definition)
     {
         modifier = modifierCreate();
         modifierLoad(modifier, f);
-        terrainAddModifier(&definition, modifier);
+        terrainAddModifier(definition, modifier);
         modifierDelete(modifier);
     }
 
@@ -86,7 +87,7 @@ void terrainCopyDefinition(TerrainDefinition* source, TerrainDefinition* destina
 {
     int i;
 
-    noiseCopy(source.height_noise, destination->height_noise);
+    noiseCopy(source->height_noise, destination->height_noise);
     destination->height_factor = source->height_factor;
     destination->scaling = source->scaling;
 
@@ -201,7 +202,7 @@ Color terrainLightFilter(TerrainDefinition* definition, Renderer* renderer, Colo
         {
             inc_value = diff;
         }
-    } while (light_factor > 0.0 && length < 50.0 && location.y <= definition._max_height);
+    } while (light_factor > 0.0 && length < 50.0 && location.y <= definition->_max_height);
 
     if (light_factor <= 0.0)
     {
@@ -220,15 +221,9 @@ Color terrainLightFilter(TerrainDefinition* definition, Renderer* renderer, Colo
 static Color _getColor(TerrainDefinition* definition, Renderer* renderer, Vector3 point, double precision)
 {
     Color color;
-    TextureEnvironment texenv;
 
-    color = COLOR_RED;
+    color = renderer->applyTextures(renderer, point, precision);
-    //color = texturesGetColorCustom(point, precision, NULL, &texenv);
+    color = renderer->applyAtmosphere(renderer, point, color);
-    /*if (environment->toggle_fog)
-    {
-        color = fogApplyToLocation(point, color);
-    }*/
-    //color = cloudsApplySegmentResult(color, camera_location, point);
 
     return color;
 }
@@ -271,22 +266,25 @@ int terrainProjectRay(TerrainDefinition* definition, Renderer* renderer, Vector3
         {
             inc_value = diff;
         }
-    } while (length < 50.0 && start.y <= definition._max_height);
+    } while (length < 50.0 && start.y <= definition->_max_height);
 
     return 0;
 }
 
-static int _postProcessFragment(RenderFragment* fragment)
+static int _postProcessFragment(RenderFragment* fragment, Renderer* renderer, void* data)
 {
-    /*Vector3 point;
+    Vector3 point;
     double precision;
+    TerrainDefinition* definition;
+
+    definition = (TerrainDefinition*)data;
 
     point = fragment->vertex.location;
-    precision = renderGetPrecision(point);
+    precision = renderer->getPrecision(renderer, point);
 
-    point = _getPoint(&_definition, point.x, point.z, precision);
+    point = _getPoint(definition, point.x, point.z, precision);
 
-    fragment->vertex.color = _getColor(&_definition, &_environment, point, precision);*/
+    fragment->vertex.color = _getColor(definition, renderer, point, precision);
 
     return 1;
 }
@@ -304,11 +302,12 @@ static Vertex _getFirstPassVertex(TerrainDefinition* definition, double x, doubl
     result.color.a = 1.0;
     result.normal.x = result.normal.y = result.normal.z = 0.0;
     result.callback = _postProcessFragment;
+    result.callback_data = definition;
 
     return result;
 }
 
-static void _renderQuad(TerrainDefinition* definition, double x, double z, double size)
+static void _renderQuad(TerrainDefinition* definition, Renderer* renderer, double x, double z, double size)
 {
     Vertex v1, v2, v3, v4;
 
@@ -316,7 +315,7 @@ static void _renderQuad(TerrainDefinition* definition, double x, double z, doubl
     v2 = _getFirstPassVertex(definition, x, z + size, size);
     v3 = _getFirstPassVertex(definition, x + size, z + size, size);
     v4 = _getFirstPassVertex(definition, x + size, z, size);
-    renderPushQuad(&v1, &v2, &v3, &v4);
+    renderPushQuad(renderer, &v1, &v2, &v3, &v4);
 }
 
 double terrainGetHeight(TerrainDefinition* definition, double x, double z)
@@ -326,7 +325,14 @@ double terrainGetHeight(TerrainDefinition* definition, double x, double z)
 
 double terrainGetHeightNormalized(TerrainDefinition* definition, double x, double z)
 {
+    if (definition->_max_height == 0.0)
+    {
+        return 0.5;
+    }
+    else
+    {
         return 0.5 + _getHeight(definition, x, z, 0.0) / (definition->_max_height * 2.0);
+    }
 }
 
 Color terrainGetColor(TerrainDefinition* definition, Renderer* renderer, double x, double z, double detail)
@@ -362,10 +368,10 @@ void terrainRender(TerrainDefinition* definition, Renderer* renderer, RenderProg
 
         for (i = 0; i < chunk_count - 1; i++)
         {
-            _renderQuad(definition, cx - radius_ext + chunk_size * i, cz - radius_ext, chunk_size);
+            _renderQuad(definition, renderer, cx - radius_ext + chunk_size * i, cz - radius_ext, chunk_size);
-            _renderQuad(definition, cx + radius_int, cz - radius_ext + chunk_size * i, chunk_size);
+            _renderQuad(definition, renderer, cx + radius_int, cz - radius_ext + chunk_size * i, chunk_size);
-            _renderQuad(definition, cx + radius_int - chunk_size * i, cz + radius_int, chunk_size);
+            _renderQuad(definition, renderer, cx + radius_int - chunk_size * i, cz + radius_int, chunk_size);
-            _renderQuad(definition, cx - radius_ext, cz + radius_int - chunk_size * i, chunk_size);
+            _renderQuad(definition, renderer, cx - radius_ext, cz + radius_int - chunk_size * i, chunk_size);
         }
 
         if (chunk_count % 64 == 0 && chunk_size / radius_int < visible_chunk_size)

lib_paysages/textures.c

@@ -45,7 +45,7 @@ void texturesLoad(FILE* f, TexturesDefinition* definition)
     n = toolsLoadInt(f);
     for (i = 0; i < n; i++)
     {
-        layer = definition->nbtextures + texturesAddLayer(definition);
+        layer = definition->textures + texturesAddLayer(definition);
 
         zoneLoad(layer->zone, f);
         noiseLoad(layer->bump_noise, f);
@@ -110,15 +110,15 @@ TextureLayerDefinition texturesLayerCreateDefinition()
 
 void texturesLayerDeleteDefinition(TextureLayerDefinition* definition)
 {
-    zoneDelete(definition.zone);
+    zoneDelete(definition->zone);
-    noiseDeleteGenerator(definition.bump_noise);
+    noiseDeleteGenerator(definition->bump_noise);
 }
 
 void texturesLayerCopyDefinition(TextureLayerDefinition* source, TextureLayerDefinition* destination)
 {
-    destination->color = source.color;
+    destination->color = source->color;
-    noiseCopy(source.bump_noise, destination->bump_noise);
+    noiseCopy(source->bump_noise, destination->bump_noise);
-    zoneCopy(source.zone, destination->zone);
+    zoneCopy(source->zone, destination->zone);
 }
 
 void texturesLayerValidateDefinition(TextureLayerDefinition* definition)
@@ -146,7 +146,7 @@ int texturesAddLayer(TexturesDefinition* definition)
 {
     if (definition->nbtextures < TEXTURES_MAX_LAYERS)
     {
-        _textures[definition->nbtextures] = texturesCreateDefinition();
+        definition->textures[definition->nbtextures] = texturesLayerCreateDefinition();
 
         return definition->nbtextures++;
     }
@@ -169,23 +169,23 @@ void texturesDeleteLayer(TexturesDefinition* definition, int layer)
     }
 }
 
-static inline Vector3 _getNormal(TextureLayerDefinition* definition, Vector3 point, double scale)
+static inline Vector3 _getNormal(TextureLayerDefinition* definition, Renderer* renderer, Vector3 point, double scale)
 {
     Vector3 dpoint, ref, normal;
 
     ref.x = 0.0;
     ref.y = 0.0;
-    point.y = terrainGetHeight(point.x, point.z) + noiseGet2DTotal(definition->bump_noise, point.x, point.z);
+    point.y = renderer->getTerrainHeight(renderer, point.x, point.z) + noiseGet2DTotal(definition->bump_noise, point.x, point.z);
 
     dpoint.x = point.x - scale;
     dpoint.z = point.z;
-    dpoint.y = terrainGetHeight(dpoint.x, dpoint.z) + noiseGet2DTotal(definition->bump_noise, dpoint.x, dpoint.z);
+    dpoint.y = renderer->getTerrainHeight(renderer, dpoint.x, dpoint.z) + noiseGet2DTotal(definition->bump_noise, dpoint.x, dpoint.z);
     ref.z = -1.0;
     normal = v3Normalize(v3Cross(ref, v3Sub(dpoint, point)));
 
     dpoint.x = point.x + scale;
     dpoint.z = point.z;
-    dpoint.y = terrainGetHeight(dpoint.x, dpoint.z) + noiseGet2DTotal(definition->bump_noise, dpoint.x, dpoint.z);
+    dpoint.y = renderer->getTerrainHeight(renderer, dpoint.x, dpoint.z) + noiseGet2DTotal(definition->bump_noise, dpoint.x, dpoint.z);
     ref.z = 1.0;
     normal = v3Add(normal, v3Normalize(v3Cross(ref, v3Sub(dpoint, point))));
 
@@ -193,13 +193,13 @@ static inline Vector3 _getNormal(TextureLayerDefinition* definition, Vector3 poi
 
     dpoint.x = point.x;
     dpoint.z = point.z - scale;
-    dpoint.y = terrainGetHeight(dpoint.x, dpoint.z) + noiseGet2DTotal(definition->bump_noise, dpoint.x, dpoint.z);
+    dpoint.y = renderer->getTerrainHeight(renderer, dpoint.x, dpoint.z) + noiseGet2DTotal(definition->bump_noise, dpoint.x, dpoint.z);
     ref.x = 1.0;
     normal = v3Add(normal, v3Normalize(v3Cross(ref, v3Sub(dpoint, point))));
 
     dpoint.x = point.x;
     dpoint.z = point.z + scale;
-    dpoint.y = terrainGetHeight(dpoint.x, dpoint.z) + noiseGet2DTotal(definition->bump_noise, dpoint.x, dpoint.z);
+    dpoint.y = renderer->getTerrainHeight(renderer, dpoint.x, dpoint.z) + noiseGet2DTotal(definition->bump_noise, dpoint.x, dpoint.z);
     ref.x = -1.0;
     normal = v3Add(normal, v3Normalize(v3Cross(ref, v3Sub(dpoint, point))));
 
@@ -214,7 +214,7 @@ Color texturesGetLayerColor(TextureLayerDefinition* definition, Renderer* render
     SurfaceMaterial material;
 
     result = COLOR_TRANSPARENT;
-    normal = _getNormal(definition, location, detail * 0.3);
+    normal = _getNormal(definition, renderer, location, detail * 0.3);
 
     coverage = zoneGetValue(definition->zone, location, normal);
     if (coverage > 0.0)
@@ -229,7 +229,7 @@ Color texturesGetLayerColor(TextureLayerDefinition* definition, Renderer* render
     return result;
 }
 
-Color texturesGetColorCustom(TexturesDefinition* definition, Renderer* renderer, Vector3 location, double detail)
+Color texturesGetColor(TexturesDefinition* definition, Renderer* renderer, Vector3 location, double detail)
 {
     Color result, tex_color;
     int i;
@@ -238,7 +238,7 @@ Color texturesGetColorCustom(TexturesDefinition* definition, Renderer* renderer,
     for (i = 0; i < definition->nbtextures; i++)
     {
         /* TODO Do not compute layers fully covered */
-        tex_color = texturesGetLayerColor(_textures + i, renderer, location, detail);
+        tex_color = texturesGetLayerColor(definition->textures + i, renderer, location, detail);
         if (tex_color.a > 0.0001)
         {
             colorMask(&result, &tex_color);

lib_paysages/textures.h

@@ -45,7 +45,7 @@ int texturesAddLayer(TexturesDefinition* definition);
 void texturesDeleteLayer(TexturesDefinition* definition, int layer);
 
 Color texturesGetLayerColor(TextureLayerDefinition* definition, Renderer* renderer, Vector3 location, double detail);
-Color texturesGetColorCustom(TexturesDefinition* definition, Renderer* renderer, Vector3 location, double detail);
+Color texturesGetColor(TexturesDefinition* definition, Renderer* renderer, Vector3 location, double detail);
 
 #ifdef __cplusplus
 }

lib_paysages/water.c

@@ -4,7 +4,7 @@
 #include "shared/functions.h"
 #include "shared/constants.h"
 #include "shared/globals.h"
-
+#include "render.h"
 #include "terrain.h"
 #include "lighting.h"
 
@@ -16,7 +16,7 @@ void waterInit()
 
 void waterSave(FILE* f, WaterDefinition* definition)
 {
-    toolsSaveDouble(f, definition.height);
+    toolsSaveDouble(f, definition->height);
     colorSave(definition->main_color, f);
     colorSave(definition->depth_color, f);
     toolsSaveDouble(f, definition->transparency_depth);
@@ -69,7 +69,7 @@ void waterCopyDefinition(WaterDefinition* source, WaterDefinition* destination)
     NoiseGenerator* noise;
 
     noise = destination->waves_noise;
-    *destination = source;
+    *destination = *source;
     destination->waves_noise = noise;
     noiseCopy(source->waves_noise, destination->waves_noise);
 }
@@ -177,8 +177,8 @@ WaterResult waterGetColorDetail(WaterDefinition* definition, Renderer* renderer,
 
     normal = _getNormal(definition, location, detail);
     look = v3Normalize(look);
-    result.reflected = renderer->rayWalking(renderer, location, _reflectRay(look, normal), 0).hit_color;
+    result.reflected = renderer->rayWalking(renderer, location, _reflectRay(look, normal), 1, 0, 1, 1).hit_color;
-    refracted = renderer->rayWalking(renderer, location, _refractRay(look, normal), 0);
+    refracted = renderer->rayWalking(renderer, location, _refractRay(look, normal), 1, 0, 1, 1);
     depth = v3Norm(v3Sub(location, refracted.hit_location));
     if (depth > definition->transparency_depth)
     {
@@ -202,10 +202,7 @@ WaterResult waterGetColorDetail(WaterDefinition* definition, Renderer* renderer,
     material.reflection = 0.8;
     material.shininess = 0.6;
     color = renderer->applyLightingToSurface(renderer, location, normal, material);
-    /*if (environment->toggle_fog)
+    color = renderer->applyAtmosphere(renderer, location, color);
-    {
-        color = fogApplyToLocation(location, color);
-    }*/
 
     result.base = definition->main_color;
     result.final = color;
@@ -218,19 +215,19 @@ Color waterGetColor(WaterDefinition* definition, Renderer* renderer, Vector3 loc
     return waterGetColorDetail(definition, renderer, location, look).final;
 }
 
-static int _postProcessFragment(RenderFragment* fragment)
+static int _postProcessFragment(RenderFragment* fragment, Renderer* renderer, void* data)
 {
-    /* fragment->vertex.color = waterGetColor(fragment->vertex.location, v3Sub(fragment->vertex.location, camera_location)); */
+    fragment->vertex.color = waterGetColor((WaterDefinition*)data, renderer, fragment->vertex.location, v3Sub(fragment->vertex.location, renderer->camera_location));
     return 1;
 }
 
-static Vertex _getFirstPassVertex(double x, double z, double precision)
+static Vertex _getFirstPassVertex(WaterDefinition* definition, double x, double z, double precision)
 {
     Vertex result;
     double value;
 
     result.location.x = x;
-    result.location.y = _getHeight(&_definition, x, z, 0.0);
+    result.location.y = _getHeight(definition, x, z, 0.0);
     result.location.z = z;
     value = sin(x) * sin(x) * cos(z) * cos(z);
     result.color.r = 0.0;
@@ -239,19 +236,20 @@ static Vertex _getFirstPassVertex(double x, double z, double precision)
     result.color.a = 1.0;
     result.normal.x = result.normal.y = result.normal.z = 0.0;
     result.callback = _postProcessFragment;
+    result.callback_data = definition;
 
     return result;
 }
 
-static void _renderQuad(double x, double z, double size)
+static void _renderQuad(WaterDefinition* definition, Renderer* renderer, double x, double z, double size)
 {
     Vertex v1, v2, v3, v4;
 
-    v1 = _getFirstPassVertex(x, z, size);
+    v1 = _getFirstPassVertex(definition, x, z, size);
-    v2 = _getFirstPassVertex(x, z + size, size);
+    v2 = _getFirstPassVertex(definition, x, z + size, size);
-    v3 = _getFirstPassVertex(x + size, z + size, size);
+    v3 = _getFirstPassVertex(definition, x + size, z + size, size);
-    v4 = _getFirstPassVertex(x + size, z, size);
+    v4 = _getFirstPassVertex(definition, x + size, z, size);
-    renderPushQuad(&v1, &v2, &v3, &v4);
+    renderPushQuad(renderer, &v1, &v2, &v3, &v4);
 }
 
 void waterRender(WaterDefinition* definition, Renderer* renderer, RenderProgressCallback callback)
@@ -278,10 +276,10 @@ void waterRender(WaterDefinition* definition, Renderer* renderer, RenderProgress
 
         for (i = 0; i < chunk_count - 1; i++)
         {
-            _renderQuad(cx - radius_ext + chunk_size * i, cz - radius_ext, chunk_size);
+            _renderQuad(definition, renderer, cx - radius_ext + chunk_size * i, cz - radius_ext, chunk_size);
-            _renderQuad(cx + radius_int, cz - radius_ext + chunk_size * i, chunk_size);
+            _renderQuad(definition, renderer, cx + radius_int, cz - radius_ext + chunk_size * i, chunk_size);
-            _renderQuad(cx + radius_int - chunk_size * i, cz + radius_int, chunk_size);
+            _renderQuad(definition, renderer, cx + radius_int - chunk_size * i, cz + radius_int, chunk_size);
-            _renderQuad(cx - radius_ext, cz + radius_int - chunk_size * i, chunk_size);
+            _renderQuad(definition, renderer, cx - radius_ext, cz + radius_int - chunk_size * i, chunk_size);
         }
 
         if (radius_int > 20.0 && chunk_count % 64 == 0 && (double)chunk_factor < radius_int / 20.0)