graphics/paysages3d
1
0
Fork 0
Code Releases Activity

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

Browse source 
git-svn-id: https://subversion.assembla.com/svn/thunderk/paysages@233 b1fd45b6-86a6-48da-8261-f70d1f35bdcc
This commit is contained in:
Michaël Lemaire 2012-01-24 13:16:20 +00:00 committed by ThunderK
parent 48ea553f49
commit 4e70d8ca8c
33 changed files with 571 additions and 340 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

32
cli/main.c
View file

@ -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;
@ -34,10 +38,10 @@ int main(int argc, char** argv)
double conf_daytime_step = 0.0;
int outputcount;
char outputpath[500];
argc--;
argv++;
while (argc--)
{
if (strcmp(*argv, "-h") == 0 || strcmp(*argv, "--help") == 0)
@ -87,28 +91,28 @@ int main(int argc, char** argv)
conf_daytime_step = atof(*(++argv));
}
}
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++)
{
autoSetDaytimeFraction(conf_daytime_start);
sprintf(outputpath, "output/pic%05d.png", outputcount);
startRender(outputpath);
startRender(&renderer, outputpath);
conf_daytime_start += conf_daytime_step;
}
printf("\rDone. \n");
return 0;
}

23
gui_qt/dialogrender.cpp
View file

@ -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,14 +99,15 @@ DialogRender::DialogRender(QWidget *parent):
void DialogRender::startRender(int quality, int width, int height)
{
renderSetSize(width, height);
autoSetRenderQuality(quality);
Renderer renderer;
renderer = sceneryGetStandardRenderer(quality);
renderSetSize(width, height);
renderSetPreviewCallbacks(_renderResize, _renderClear, _renderDraw, _renderUpdate);
render_thread = new RenderThread();
render_thread = new RenderThread(&renderer);
render_thread->start();
exec();
}
@ -104,7 +115,7 @@ void DialogRender::loadLastRender()
{
progress->hide();
renderSetPreviewCallbacks(_renderResize, _renderClear, _renderDraw, _renderUpdate);
exec();
}

7
gui_qt/formrender.cpp
View file

@ -4,6 +4,7 @@
#include <QMessageBox>
#include "dialogrender.h"
#include "../lib_paysages/render.h"
#include "../lib_paysages/shared/functions.h"
/**************** Form ****************/
@ -33,7 +34,7 @@ void FormRender::startRender()
{
DialogRender* dialog = new DialogRender(this);
dialog->startRender(_quality, _width, _height);
delete dialog;
}
@ -41,14 +42,14 @@ void FormRender::showRender()
{
DialogRender* dialog = new DialogRender(this);
dialog->loadLastRender();
delete dialog;
}
void FormRender::saveRender()
{
QString filepath;
filepath = QFileDialog::getSaveFileName(this, "Choose a filename to save the last render");
if (!filepath.isNull())
{

16
gui_qt/formsky.cpp
View file

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

25
gui_qt/formterrain.cpp
View file

@ -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):
Preview(parent)
PreviewTerrainHeight(QWidget* 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):
Preview(parent)
PreviewTerrainColor(QWidget* parent):Preview(parent)
{
_lighting_environment.filter = NULL;
_environment.toggle_fog = 0;
_environment.lighting_definition = NULL;
_environment.lighting_environment = &_lighting_environment;
// TODO Use custom renderer
_renderer = sceneryGetStandardRenderer(3);
}
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;
TerrainEnvironment _environment;
Renderer _renderer;
};
/**************** 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();
}

60
gui_qt/formwater.cpp
View file

@ -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):
Preview(parent)
PreviewWaterCoverage(QWidget* 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):
Preview(parent)
PreviewWaterColor(QWidget* 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(result);
return colorToQColor(_rayWalking(&_renderer, eye, look, 0, 0, 0, 0).hit_color);
}
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(result);
return colorToQColor(_rayWalking(&_renderer, eye, look, 0, 0, 0, 0).hit_color);
}
definition = _definition;
definition.height = 0.0;
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);
_water.height = 0.0;
return colorToQColor(waterGetColor(&_definition, &_renderer, location, look));
}
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;
y = start.y + direction.y * (0.0 - start.z) / direction.z;
x = location.x + direction.x * (0.0 - location.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();
}

1
gui_qt/mainwindow.cpp
View file

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

2
gui_qt/tools.h
View file

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

65
lib_paysages/auto.c
View file

@ -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))
{
_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);
sceneryRenderFirstPass((Renderer*)data);
_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))
{
renderPostProcess(_cpu_count);
}
sceneryRenderSecondPass(renderer);
}
static int _postProcessRayTracingOverlay(RenderFragment* fragment)

20
lib_paysages/auto.h Normal file
View file

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

5
lib_paysages/camera.c
View file

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

3
lib_paysages/clouds.c
View file

@ -480,8 +480,7 @@ Color cloudsGetLayerColor(CloudsLayerDefinition* definition, Renderer* renderer,
direction = v3Normalize(direction);
result = COLOR_TRANSPARENT;
/* TODO Flexible precision */
detail = renderGetPrecision(start) / definition->scaling;
detail = renderer->getPrecision(renderer, 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++)

6
lib_paysages/color.c
View file

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

1
lib_paysages/fog.c
View file

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

28
lib_paysages/lighting.c
View file

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

11
lib_paysages/lighting.h
View file

@ -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 lightingLoad(FILE* f);
void lightingSave(FILE* f, LightingDefinition* definition);
void lightingLoad(FILE* f, LightingDefinition* definition);
LightingDefinition lightingCreateDefinition();
void lightingDeleteDefinition(LightingDefinition* definition);

24
lib_paysages/main.c
View file

@ -8,28 +8,30 @@
#include "shared/constants.h"
#include "shared/functions.h"
#include "shared/globals.h"
#include "shared/system.h"
#include "terrain.h"
#include "water.h"
#include "lighting.h"
#include "textures.h"
#include "sky.h"
#include "clouds.h"
#include "auto.h"
#include "system.h"
#include "camera.h"
#include "scenery.h"
#include "render.h"
void paysagesInit()
{
CameraDefinition camera;
systemInit();
ilInit();
iluInit();
autoInit();
sceneryInit();
renderInit();
cameraSetLocation(-12.0, 5.0, 2.0);
cameraSetTarget(0.0, 5.0, 0.0);
camera = cameraCreateDefinition();
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);

43
lib_paysages/render.c
View file

@ -1,7 +1,4 @@
#include "shared/types.h"
#include "shared/constants.h"
#include "shared/functions.h"
#include "shared/system.h"
#include "render.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);
p2 = cameraProject(v2->location);
p3 = cameraProject(v3->location);
p1 = renderer->projectPoint(renderer, v1->location);
p2 = renderer->projectPoint(renderer, v2->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(v4, v1, v3);
renderPushTriangle(renderer, v2, v3, v1);
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;

36
lib_paysages/render.h Normal file
View file

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

61
lib_paysages/renderer.c
View file

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

13
lib_paysages/renderer.h
View file

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

168
lib_paysages/scenery.c
View file

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

5
lib_paysages/scenery.h
View file

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

29
lib_paysages/shared/functions.h
View file

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

11
lib_paysages/shared/types.h
View file

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

28
lib_paysages/sky.c
View file

@ -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;
Color color_sky, color_clouds;
Vector3 location, direction;
Color result;
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));
color_clouds = cloudsGetColor(camera_location, v3Add(camera_location, v3Scale(direction, 10.0)));
result = skyGetColor(definition, renderer, renderer->camera_location, v3Normalize(direction));
result = renderer->applyClouds(renderer, result, renderer->camera_location, v3Add(renderer->camera_location, v3Scale(direction, 10.0)));
colorMask(&color_sky, &color_clouds);
fragment->vertex.color = color_sky;*/
fragment->vertex.color = result;
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);
}
}
}

3
lib_paysages/sky.h
View file

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

47
lib_paysages/system.c Normal file
View file

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

6
lib_paysages/shared/system.h → lib_paysages/system.h
View file

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

54
lib_paysages/terrain.c
View file

@ -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 = texturesGetColorCustom(point, precision, NULL, &texenv);
/*if (environment->toggle_fog)
{
color = fogApplyToLocation(point, color);
}*/
//color = cloudsApplySegmentResult(color, camera_location, point);
color = renderer->applyTextures(renderer, point, precision);
color = renderer->applyAtmosphere(renderer, point, color);
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)
{
return 0.5 + _getHeight(definition, x, z, 0.0) / (definition->_max_height * 2.0);
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, 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, cx - radius_ext, cz + radius_int - chunk_size * i, chunk_size);
_renderQuad(definition, renderer, cx - radius_ext + chunk_size * i, cz - radius_ext, chunk_size);
_renderQuad(definition, renderer, cx + radius_int, cz - radius_ext + chunk_size * i, chunk_size);
_renderQuad(definition, renderer, cx + radius_int - chunk_size * i, cz + radius_int, 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)

32
lib_paysages/textures.c
View file

@ -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);
noiseDeleteGenerator(definition.bump_noise);
zoneDelete(definition->zone);
noiseDeleteGenerator(definition->bump_noise);
}
void texturesLayerCopyDefinition(TextureLayerDefinition* source, TextureLayerDefinition* destination)
{
destination->color = source.color;
noiseCopy(source.bump_noise, destination->bump_noise);
zoneCopy(source.zone, destination->zone);
destination->color = source->color;
noiseCopy(source->bump_noise, destination->bump_noise);
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);

2
lib_paysages/textures.h
View file

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

44
lib_paysages/water.c
View file

@ -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;
refracted = renderer->rayWalking(renderer, location, _refractRay(look, normal), 0);
result.reflected = renderer->rayWalking(renderer, location, _reflectRay(look, normal), 1, 0, 1, 1).hit_color;
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 = fogApplyToLocation(location, color);
}*/
color = renderer->applyAtmosphere(renderer, 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);
v2 = _getFirstPassVertex(x, z + size, size);
v3 = _getFirstPassVertex(x + size, z + size, size);
v4 = _getFirstPassVertex(x + size, z, size);
renderPushQuad(&v1, &v2, &v3, &v4);
v1 = _getFirstPassVertex(definition, x, z, size);
v2 = _getFirstPassVertex(definition, x, z + size, size);
v3 = _getFirstPassVertex(definition, x + size, z + size, size);
v4 = _getFirstPassVertex(definition, x + size, z, size);
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(cx + radius_int, cz - radius_ext + chunk_size * i, chunk_size);
_renderQuad(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 + chunk_size * i, cz - radius_ext, chunk_size);
_renderQuad(definition, renderer, cx + radius_int, cz - radius_ext + chunk_size * i, chunk_size);
_renderQuad(definition, renderer, cx + radius_int - chunk_size * i, cz + radius_int, 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)