commit 17ac410c1412561a16ce03c57cd9192c12acbab6
parent 01c724ebf0020983e1244d7cf3c379fdd7d50768
Author: Christophe Coustet <christophe.coustet@meso-star.com>
Date: Tue, 28 Mar 2017 18:49:47 +0200
Merge remote-tracking branch 'origin/develop' into feature_outputs
Diffstat:
21 files changed, 478 insertions(+), 161 deletions(-)
diff --git a/cmake/CMakeLists.txt b/cmake/CMakeLists.txt
@@ -27,7 +27,7 @@ find_package(RCMake 0.2.3 REQUIRED)
find_package(RSys 0.4 REQUIRED)
find_package(Star3D 0.4 REQUIRED)
find_package(StarCPR REQUIRED)
-find_package(StarSF 0.0 REQUIRED)
+find_package(StarSF 0.1 REQUIRED)
find_package(StarSP 0.4 REQUIRED)
find_package(OpenMP 1.2 REQUIRED)
diff --git a/src/ssol.h b/src/ssol.h
@@ -73,6 +73,7 @@ enum ssol_path_type {
};
enum ssol_material_type {
+ SSOL_MATERIAL_DIELECTRIC,
SSOL_MATERIAL_MATTE,
SSOL_MATERIAL_MIRROR,
SSOL_MATERIAL_THIN_DIELECTRIC,
@@ -226,6 +227,13 @@ struct ssol_punched_surface {
static const struct ssol_punched_surface SSOL_PUNCHED_SURFACE_NULL =
SSOL_PUNCHED_SURFACE_NULL__;
+struct ssol_medium {
+ double absorptivity;
+ double refractive_index;
+};
+#define SSOL_MEDIUM_VACUUM__ { 0, 1 }
+static const struct ssol_medium SSOL_MEDIUM_VACUUM = SSOL_MEDIUM_VACUUM__;
+
typedef void
(*ssol_shader_getter_T)
(struct ssol_device* dev,
@@ -238,6 +246,14 @@ typedef void
const double w[3], /* Incoming direction. Point toward the surface */
double* val); /* Returned value */
+/* Dielectric material shader */
+struct ssol_dielectric_shader {
+ ssol_shader_getter_T normal;
+};
+#define SSOL_DIELECTRIC_SHADER_NULL__ { NULL }
+static const struct ssol_dielectric_shader SSOL_DIELECTRIC_SHADER_NULL =
+ SSOL_DIELECTRIC_SHADER_NULL__;
+
/* Mirror material shader */
struct ssol_mirror_shader {
ssol_shader_getter_T normal;
@@ -260,11 +276,8 @@ static const struct ssol_matte_shader SSOL_MATTE_SHADER_NULL =
/* Thin dielectric shader */
struct ssol_thin_dielectric_shader {
ssol_shader_getter_T normal;
- ssol_shader_getter_T absorption;
- ssol_shader_getter_T thickness;
- ssol_shader_getter_T refractive_index;
};
-#define SSOL_THIN_DIELECTRIC_SHADER_NULL__ { NULL, NULL, NULL, NULL }
+#define SSOL_THIN_DIELECTRIC_SHADER_NULL__ { NULL }
static const struct ssol_thin_dielectric_shader
SSOL_THIN_DIELECTRIC_SHADER_NULL = SSOL_THIN_DIELECTRIC_SHADER_NULL__;
@@ -666,6 +679,11 @@ ssol_mesh_setup
* (e.g.: refractive index) properties of a geometry.
******************************************************************************/
SSOL_API res_T
+ssol_material_create_dielectric
+ (struct ssol_device* dev,
+ struct ssol_material** mtl);
+
+SSOL_API res_T
ssol_material_create_mirror
(struct ssol_device* dev,
struct ssol_material** mtl);
@@ -704,19 +722,29 @@ ssol_material_set_param_buffer
struct ssol_param_buffer* buf);
SSOL_API res_T
-ssol_mirror_set_shader
+ssol_dielectric_setup
+ (struct ssol_material* mtl,
+ const struct ssol_dielectric_shader* shader,
+ const struct ssol_medium* outside_medium,
+ const struct ssol_medium* inside_medium);
+
+SSOL_API res_T
+ssol_mirror_setup
(struct ssol_material* mtl,
const struct ssol_mirror_shader* shader);
SSOL_API res_T
-ssol_matte_set_shader
+ssol_matte_setup
(struct ssol_material* mtl,
const struct ssol_matte_shader* shader);
SSOL_API res_T
-ssol_thin_dielectric_set_shader
+ssol_thin_dielectric_setup
(struct ssol_material* mtl,
- const struct ssol_thin_dielectric_shader* shader);
+ const struct ssol_thin_dielectric_shader* shader,
+ const struct ssol_medium* outside_medium,
+ const struct ssol_medium* slab_medium,
+ const double thickness);
/*******************************************************************************
* Object API - Opaque abstraction of a geometry with its associated properties.
@@ -1047,7 +1075,7 @@ SSOL_API res_T
ssol_path_get_type
(const struct ssol_path* path,
enum ssol_path_type* type);
-
+
/*******************************************************************************
* Per receiver MC estimations
******************************************************************************/
diff --git a/src/ssol_atmosphere.c b/src/ssol_atmosphere.c
@@ -123,24 +123,13 @@ ssol_atmosphere_set_uniform_absorption
* Local functions
******************************************************************************/
double
-compute_atmosphere_transmissivity
+atmosphere_uniform_get_absorption
(const struct ssol_atmosphere* atmosphere,
- const double distance,
const double wavelength)
{
- double ka;
const struct ssol_spectrum* spectrum;
- if (!atmosphere)
- return 1;
-
- ASSERT(distance >= 0 && wavelength >= 0);
- switch (atmosphere->type) {
- case ATMOS_UNIFORM:
- spectrum = atmosphere->data.uniform.spectrum;
- ka = spectrum_interpolate(spectrum, wavelength);
- break;
- default: FATAL("Unreachable code\n"); break;
- }
- return exp(-ka * distance);
+ ASSERT(atmosphere && atmosphere->type == ATMOS_UNIFORM && wavelength >= 0);
+ spectrum = atmosphere->data.uniform.spectrum;
+ return spectrum_interpolate(spectrum, wavelength);
}
diff --git a/src/ssol_atmosphere_c.h b/src/ssol_atmosphere_c.h
@@ -42,9 +42,8 @@ struct ssol_atmosphere {
};
extern LOCAL_SYM double
-compute_atmosphere_transmissivity
+atmosphere_uniform_get_absorption
(const struct ssol_atmosphere* atmosphere,
- const double distance,
const double wavelength);
#endif /* SSOL_ATMOSPHERE_C_H */
diff --git a/src/ssol_draw_pt.c b/src/ssol_draw_pt.c
@@ -121,7 +121,7 @@ sun_lighting
return 0;
}
-static void
+static res_T
Li(struct ssol_scene* scn,
struct thread_context* ctx,
struct s3d_scene_view* view,
@@ -129,6 +129,7 @@ Li(struct ssol_scene* scn,
const float dir[3],
double val[3])
{
+ struct ssol_medium medium;
struct s3d_hit hit;
struct ray_data ray_data = RAY_DATA_NULL;
struct ssol_instance* inst;
@@ -148,6 +149,7 @@ Li(struct ssol_scene* scn,
float ray_dir[3];
enum ssol_side_flag side;
int russian_roulette = 0;
+ int type;
res_T res = RES_OK;
ASSERT(scn && view && org && dir && val);
@@ -157,10 +159,17 @@ Li(struct ssol_scene* scn,
f3_set(ray_org, org);
f3_set(ray_dir, dir);
+ /* Assume that the path starts from vacuum */
+ medium = SSOL_MEDIUM_VACUUM;
+
for(;;) {
S3D(scene_view_trace_ray
(view, ray_org, ray_dir, ray_range, &ray_data, &hit));
+ if(medium.absorptivity > 0) {
+ throughput *= exp(-medium.absorptivity * hit.distance);
+ }
+
if(S3D_HIT_NONE(&hit)) { /* Background lighting */
if(ray_dir[2] > 0) L += throughput * 1.e-1;
break;
@@ -195,8 +204,9 @@ Li(struct ssol_scene* scn,
surface_fragment_setup(&frag, o, wo, N, &hit.prim, hit.uv);
SSF(bsdf_clear(ctx->bsdf));
- res = material_shade_rendering(mtl, &frag, 1/*TODO wavelength*/, ctx->bsdf);
- CHECK(res, RES_OK);
+ res = material_shade_rendering
+ (mtl, &frag, 1/*TODO wavelength*/, &medium, ctx->bsdf);
+ if(res != RES_OK) goto error;
/* Update the ray */
ray_data.prim_from = hit.prim;
@@ -211,12 +221,13 @@ Li(struct ssol_scene* scn,
(scn->sun, view, &ray_data, ctx->bsdf, wo, N, ray_org);
}
- R = ssf_bsdf_sample(ctx->bsdf, ctx->rng, wo, frag.Ns, wi, &pdf);
+ R = ssf_bsdf_sample(ctx->bsdf, ctx->rng, wo, frag.Ns, wi, &type, &pdf);
ASSERT(0 <= R && R <= 1);
f3_set_d3(ray_dir, wi);
+ if(type & SSF_TRANSMISSION) material_get_next_medium(mtl, &medium, &medium);
if(!russian_roulette) {
- throughput *= d3_dot(wi, N) * R;
+ throughput *= fabs(d3_dot(wi, N)) * R;
} else {
if(ssp_rng_canonical(ctx->rng) >= R) break;
throughput *= d3_dot(wi, N);
@@ -229,6 +240,12 @@ Li(struct ssol_scene* scn,
}
}
d3_splat(val, L);
+
+exit:
+ return res;
+error:
+ d3(val, 1, 1, 0);
+ goto exit;
}
static void
@@ -247,30 +264,43 @@ draw_pixel
struct thread_context* ctx;
double sum[3] = {0, 0, 0};
size_t isample;
+ res_T res = RES_OK;
ASSERT(scn && cam && pix_coords && pix_sz && nsamples && pixel && data);
ASSERT((size_t)ithread < darray_thread_context_size_get(thread_ctxs));
ctx = darray_thread_context_data_get(thread_ctxs) + ithread;
FOR_EACH(isample, 0, nsamples) {
+ const int MAX_NFAILURES = 10;
double weight[3];
float samp[2]; /* Pixel sample */
float ray_org[3], ray_dir[3];
+ int nfailures = 0;
/* Generate a sample into the pixel */
samp[0] = ((float)pix_coords[0]+ssp_rng_canonical_float(ctx->rng))*pix_sz[0];
samp[1] = ((float)pix_coords[1]+ssp_rng_canonical_float(ctx->rng))*pix_sz[1];
- /* Generate a ray starting from the pinhole camera and passing through the
- * pixel sample */
- camera_ray(cam, samp, ray_org, ray_dir);
+ do {
+ /* Generate a ray starting from the pinhole camera and passing through the
+ * pixel sample */
+ camera_ray(cam, samp, ray_org, ray_dir);
+
+ /* Compute the radiance arriving through the sampled camera ray */
+ res = Li(scn, ctx, view, ray_org, ray_dir, weight);
+ } while(res == RES_BAD_OP && ++nfailures < MAX_NFAILURES);
+ if(res != RES_OK) goto error;
- /* Compute the radiance arriving through the sampled camera ray */
- Li(scn, ctx, view, ray_org, ray_dir, weight);
d3_add(sum, sum, weight);
}
d3_divd(pixel, sum, (double)nsamples);
+exit:
+ return;
+error:
+ log_error(scn->dev, "Path tracing integrator error.\n");
+ d3(pixel, 1, 1, 0);
+ goto exit;
}
/*******************************************************************************
diff --git a/src/ssol_material.c b/src/ssol_material.c
@@ -34,6 +34,63 @@
* Helper functions
******************************************************************************/
static res_T
+dielectric_shade
+ (const struct ssol_material* mtl,
+ const struct surface_fragment* fragment,
+ const double wavelength, /* In nanometer */
+ const struct ssol_medium* medium,
+ struct ssf_bsdf* bsdf)
+{
+ struct ssf_bxdf* brdf = NULL;
+ struct ssf_bxdf* btdf = NULL;
+ struct ssf_fresnel* fresnel = NULL;
+ const struct ssol_dielectric_shader* shader;
+ double eta_i, eta_t;
+ double N[3];
+ res_T res = RES_OK;
+ ASSERT(mtl && fragment && mtl->type == SSOL_MATERIAL_DIELECTRIC);
+ ASSERT(medium && bsdf);
+
+ shader = &mtl->data.dielectric;
+
+ /* Fetch material attribs */
+ shader->normal(mtl->dev, mtl->buf, wavelength, fragment->pos, fragment->Ng,
+ fragment->Ns, fragment->uv, fragment->dir, N);
+
+ if(!MEDIA_EQ(medium, &mtl->out_medium)) {
+ log_error(mtl->dev, "Inconsistent medium description.\n");
+ res = RES_BAD_OP;
+ goto error;
+ }
+
+ eta_i = mtl->out_medium.refractive_index;
+ eta_t = mtl->in_medium.refractive_index;
+
+ #define CALL(Func) { res = Func; if(res != RES_OK) goto error; } (void)0
+ /* Setup the reflective part */
+ CALL(ssf_fresnel_create
+ (mtl->dev->allocator, &ssf_fresnel_dielectric_dielectric, &fresnel));
+ CALL(ssf_fresnel_dielectric_dielectric_setup(fresnel, eta_i, eta_t));
+ CALL(ssf_bxdf_create(mtl->dev->allocator, &ssf_specular_reflection, &brdf));
+ CALL(ssf_specular_reflection_setup(brdf, fresnel));
+ /* Setup the transmissive part */
+ CALL(ssf_bxdf_create(mtl->dev->allocator, &ssf_specular_transmission, &btdf));
+ CALL(ssf_specular_transmission_setup(btdf, eta_i, eta_t));
+ /* Setup the scattering function */
+ CALL(ssf_bsdf_add(bsdf, brdf, 0.5));
+ CALL(ssf_bsdf_add(bsdf, btdf, 0.5));
+ #undef CALL
+
+exit:
+ if(brdf) SSF(bxdf_ref_put(brdf));
+ if(btdf) SSF(bxdf_ref_put(btdf));
+ if(fresnel) SSF(fresnel_ref_put(fresnel));
+ return res;
+error:
+ goto exit;
+}
+
+static res_T
matte_shade
(const struct ssol_material* mtl,
const struct surface_fragment* fragment,
@@ -160,31 +217,29 @@ thin_dielectric_shade
const struct ssol_thin_dielectric_shader* shader;
double N[3];
double thickness;
- double absorption;
- const double eta_i = 1.0002772; /* Refractive index of the air */
+ double absorptivity;
+ double eta_i;
double eta_t;
res_T res = RES_OK;
ASSERT(mtl && fragment && mtl->type == SSOL_MATERIAL_THIN_DIELECTRIC);
ASSERT(bsdf);
- shader = &mtl->data.thin_dielectric;
+ shader = &mtl->data.thin_dielectric.shader;
/* Fetch material attribs */
- #define FETCH(Attr, Dst) \
- shader->Attr(mtl->dev, mtl->buf, wavelength, fragment->pos, \
- fragment->Ng, fragment->Ns, fragment->uv, fragment->dir, Dst)
- FETCH(normal, N);
- FETCH(thickness, &thickness);
- FETCH(absorption, &absorption);
- FETCH(refractive_index, &eta_t);
- #undef FETCH
+ shader->normal(mtl->dev, mtl->buf, wavelength, fragment->pos,
+ fragment->Ng, fragment->Ns, fragment->uv, fragment->dir, N);
+ eta_i = mtl->out_medium.refractive_index;
+ eta_t = mtl->data.thin_dielectric.slab_medium.refractive_index;
+ absorptivity = mtl->data.thin_dielectric.slab_medium.absorptivity;
+ thickness = mtl->data.thin_dielectric.thickness;
/* Setup the BxDF */
res = ssf_bxdf_create
(mtl->dev->allocator, &ssf_thin_specular_dielectric, &bxdf);
if(res != RES_OK) goto error;
res = ssf_thin_specular_dielectric_setup
- (bxdf, absorption, eta_i, eta_t, thickness);
+ (bxdf, absorptivity, eta_i, eta_t, thickness);
if(res != RES_OK) goto error;
/* Setup the BSDF */
@@ -204,6 +259,7 @@ shade
const struct surface_fragment* fragment,
const double wavelength, /* In nanometer */
const int rendering, /* Is material used for rendering */
+ const struct ssol_medium* medium,
struct ssf_bsdf* bsdf)
{
res_T res = RES_OK;
@@ -211,6 +267,10 @@ shade
/* Specific material shading */
switch(mtl->type) {
+ case SSOL_MATERIAL_DIELECTRIC:
+ res = dielectric_shade
+ (mtl, fragment, wavelength, medium, bsdf);
+ break;
case SSOL_MATERIAL_MATTE:
res = matte_shade(mtl, fragment, wavelength, bsdf);
break;
@@ -227,6 +287,12 @@ shade
}
static INLINE int
+check_shader_dielectric(const struct ssol_dielectric_shader* shader)
+{
+ return shader && shader->normal;
+}
+
+static INLINE int
check_shader_mirror(const struct ssol_mirror_shader* shader)
{
return shader
@@ -246,11 +312,15 @@ check_shader_matte(const struct ssol_matte_shader* shader)
static INLINE int
check_shader_thin_differential(const struct ssol_thin_dielectric_shader* shader)
{
- return shader
- && shader->normal
- && shader->absorption
- && shader->thickness
- && shader->refractive_index;
+ return shader && shader->normal;
+}
+
+static INLINE int
+check_medium(const struct ssol_medium* medium)
+{
+ return medium
+ && medium->refractive_index > 0
+ && medium->absorptivity >= 0;
}
static void
@@ -294,6 +364,8 @@ ssol_material_create
material->dev = dev;
ref_init(&material->ref);
material->type = type;
+ material->in_medium = SSOL_MEDIUM_VACUUM;
+ material->out_medium = SSOL_MEDIUM_VACUUM;
exit:
if (out_material) *out_material = material;
@@ -349,6 +421,13 @@ ssol_material_set_param_buffer
}
res_T
+ssol_material_create_dielectric
+ (struct ssol_device* dev, struct ssol_material** out_material)
+{
+ return ssol_material_create(dev, out_material, SSOL_MATERIAL_DIELECTRIC);
+}
+
+res_T
ssol_material_create_mirror
(struct ssol_device* dev, struct ssol_material** out_material)
{
@@ -370,7 +449,26 @@ ssol_material_create_thin_dielectric
}
res_T
-ssol_mirror_set_shader
+ssol_dielectric_setup
+ (struct ssol_material* material,
+ const struct ssol_dielectric_shader* shader,
+ const struct ssol_medium* outside_medium,
+ const struct ssol_medium* inside_medium)
+{
+ if(!material
+ || material->type != SSOL_MATERIAL_DIELECTRIC
+ || !check_shader_dielectric(shader)
+ || !check_medium(outside_medium)
+ || !check_medium(inside_medium))
+ return RES_BAD_ARG;
+ material->data.dielectric = *shader;
+ material->out_medium = *outside_medium;
+ material->in_medium = *inside_medium;
+ return RES_OK;
+}
+
+res_T
+ssol_mirror_setup
(struct ssol_material* material, const struct ssol_mirror_shader* shader)
{
if(!material
@@ -382,7 +480,7 @@ ssol_mirror_set_shader
}
res_T
-ssol_matte_set_shader
+ssol_matte_setup
(struct ssol_material* material, const struct ssol_matte_shader* shader)
{
if(!material
@@ -394,15 +492,25 @@ ssol_matte_set_shader
}
res_T
-ssol_thin_dielectric_set_shader
+ssol_thin_dielectric_setup
(struct ssol_material* material,
- const struct ssol_thin_dielectric_shader* shader)
+ const struct ssol_thin_dielectric_shader* shader,
+ const struct ssol_medium* outside_medium,
+ const struct ssol_medium* slab_medium,
+ const double thickness)
{
if(!material
|| material->type != SSOL_MATERIAL_THIN_DIELECTRIC
- || !check_shader_thin_differential(shader))
+ || !check_shader_thin_differential(shader)
+ || !check_medium(outside_medium)
+ || !check_medium(slab_medium)
+ || thickness < 0)
return RES_BAD_ARG;
- material->data.thin_dielectric = *shader;
+ material->data.thin_dielectric.shader = *shader;
+ material->data.thin_dielectric.slab_medium = *slab_medium;
+ material->data.thin_dielectric.thickness = thickness;
+ material->out_medium = *outside_medium;
+ material->in_medium = *outside_medium;
return RES_OK;
}
@@ -490,9 +598,10 @@ material_shade
(const struct ssol_material* mtl,
const struct surface_fragment* fragment,
const double wavelength, /* In nanometer */
+ const struct ssol_medium* medium,
struct ssf_bsdf* bsdf)
{
- return shade(mtl, fragment, wavelength, 0, bsdf);
+ return shade(mtl, fragment, wavelength, 0, medium, bsdf);
}
res_T
@@ -500,8 +609,36 @@ material_shade_rendering
(const struct ssol_material* mtl,
const struct surface_fragment* fragment,
const double wavelength, /* In nanometer */
+ const struct ssol_medium* medium,
struct ssf_bsdf* bsdf)
{
- return shade(mtl, fragment, wavelength, 1, bsdf);
+ return shade(mtl, fragment, wavelength, 1, medium, bsdf);
+}
+
+res_T
+material_get_next_medium
+ (const struct ssol_material* mtl,
+ const struct ssol_medium* medium,
+ struct ssol_medium* next_medium)
+{
+ ASSERT(mtl && medium && next_medium);
+ switch(mtl->type) {
+ /* The material is an interface between 2 media */
+ case SSOL_MATERIAL_DIELECTRIC:
+ if(MEDIA_EQ(&mtl->out_medium, medium)) {
+ *next_medium = mtl->in_medium;
+ } else {
+ *next_medium = mtl->out_medium;
+ }
+ break;
+ /* The material is not an interface between 2 media */
+ case SSOL_MATERIAL_MATTE:
+ case SSOL_MATERIAL_MIRROR:
+ case SSOL_MATERIAL_THIN_DIELECTRIC:
+ *next_medium = *medium;
+ break;
+ default: FATAL("Unreachable code\n"); break;
+ }
+ return RES_OK;
}
diff --git a/src/ssol_material_c.h b/src/ssol_material_c.h
@@ -23,6 +23,10 @@ struct s3d_primitive;
struct ssf_bsdf;
struct ssol_device;
+#define MEDIA_EQ(A, B) \
+ ( ((A)->refractive_index == (B)->refractive_index) \
+ && ((A)->absorptivity == (B)->absorptivity))
+
struct surface_fragment {
double dir[3]; /* World space incoming direction */
double pos[3]; /* World space position */
@@ -34,15 +38,25 @@ struct surface_fragment {
static const struct surface_fragment SURFACE_FRAGMENT_NULL =
SURFACE_FRAGMENT_NULL__;
+struct thin_dielectric {
+ struct ssol_thin_dielectric_shader shader;
+ struct ssol_medium slab_medium;
+ double thickness;
+};
+
struct ssol_material {
enum ssol_material_type type;
union {
+ struct ssol_dielectric_shader dielectric;
struct ssol_matte_shader matte;
struct ssol_mirror_shader mirror;
- struct ssol_thin_dielectric_shader thin_dielectric;
+ struct thin_dielectric thin_dielectric;
} data;
+ struct ssol_medium out_medium;
+ struct ssol_medium in_medium;
+
struct ssol_param_buffer* buf;
struct ssol_device* dev;
ref_T ref;
@@ -62,6 +76,7 @@ material_shade
(const struct ssol_material* mtl,
const struct surface_fragment* fragment,
const double wavelength, /* In nanometer */
+ const struct ssol_medium* medium, /* Current medium */
struct ssf_bsdf* bsdf); /* Bidirectional Scattering Distribution Function */
/* Material shading for rendering purposes */
@@ -70,6 +85,13 @@ material_shade_rendering
(const struct ssol_material* mtl,
const struct surface_fragment* fragment,
const double wavelength, /* In nanometer */
+ const struct ssol_medium* medium,
struct ssf_bsdf* bsdf); /* Bidirectional Scattering Distribution Function */
+extern LOCAL_SYM res_T
+material_get_next_medium
+ (const struct ssol_material* mtl,
+ const struct ssol_medium* medium, /* Current mediu */
+ struct ssol_medium* next_medium);
+
#endif /* SSOL_MATERIAL_C_H */
diff --git a/src/ssol_solver.c b/src/ssol_solver.c
@@ -241,7 +241,11 @@ point_init
ranst_sun_dir_get(ran_sun_dir, rng, pt->dir);
/* Initialise the Monte Carlo weight */
- if(pt->sshape->shape->type == SHAPE_PUNCHED) {
+ if(pt->sshape->shape->type != SHAPE_PUNCHED) {
+ double surface_sun_cos = fabs(d3_dot(pt->N, pt->dir));
+ pt->weight = scn->sun->dni * sampled_area_proxy * surface_sun_cos;
+ pt->cos_factor = surface_sun_cos;
+ } else {
double cos_ratio, surface_proxy_cos, surface_sun_cos, tmp_n[3];
/* For punched surface, retrieve the sampled position and normal onto the
* quadric surface */
@@ -253,10 +257,6 @@ point_init
d3_set(pt->N, tmp_n);
pt->weight = scn->sun->dni * sampled_area_proxy * cos_ratio;
pt->cos_factor = surface_sun_cos;
- } else {
- double surface_sun_cos = fabs(d3_dot(pt->N, pt->dir));
- pt->weight = scn->sun->dni * sampled_area_proxy * surface_sun_cos;
- pt->cos_factor = surface_sun_cos;
}
pt->absorptivity_loss = pt->reflectivity_loss = 0;
@@ -353,11 +353,19 @@ point_get_material(const struct point* pt)
static FINLINE res_T
point_shade
- (struct point* pt, struct ssf_bsdf* bsdf, struct ssp_rng* rng, double dir[3])
+ (struct point* pt,
+ struct ssf_bsdf* bsdf,
+ struct ssol_medium* medium,
+ struct ssp_rng* rng,
+ double dir[3])
{
+ struct ssol_material* mtl;
struct surface_fragment frag;
- double wi[3], pdf, r;
+ double r = 1;
+ double wi[3], pdf;
+ int type;
res_T res;
+ ASSERT(pt && bsdf && medium && rng && dir);
/* TODO ensure that if `prim' was sampled, then the surface fragment setup
* remains valid in *all* situations, i.e. even though the point primitive
@@ -373,16 +381,21 @@ point_shade
surface_fragment_setup(&frag, pt->pos, pt->dir, pt->N, &pt->prim, pt->uv);
/* Shade the surface fragment */
+ mtl = point_get_material(pt);
SSF(bsdf_clear(bsdf));
- res = material_shade(point_get_material(pt), &frag, pt->wl, bsdf);
+ res = material_shade(mtl, &frag, pt->wl, medium, bsdf);
if(res != RES_OK) return res;
/* By convention, Star-SF assumes that incoming and reflected
* directions point outward the surface => negate incoming dir */
d3_minus(wi, pt->dir);
- r = ssf_bsdf_sample(bsdf, rng, wi, frag.Ns, dir, &pdf);
- ASSERT(0 <= r && r <= 1);
+ if(d3_dot(wi, frag.Ns) <= 0) {
+ r = 0;
+ } else {
+ r = ssf_bsdf_sample(bsdf, rng, wi, frag.Ns, dir, &type, &pdf);
+ ASSERT(0 <= r && r <= 1);
+ }
pt->incoming_weight = pt->weight;
pt->absorptivity_loss_before = pt->absorptivity_loss;
pt->reflectivity_loss_before = pt->reflectivity_loss;
@@ -390,6 +403,7 @@ point_shade
pt->reflectivity_loss += pt->absorbed_irradiance;
pt->weight = pt->incoming_weight - pt->absorbed_irradiance;
+ if(type & SSF_TRANSMISSION) material_get_next_medium(mtl, medium, medium);
return RES_OK;
}
@@ -719,6 +733,7 @@ trace_radiative_path
const struct ssol_path_tracker* tracker, /* May be NULL */
FILE* output) /* May be NULL */
{
+ struct ssol_medium medium = SSOL_MEDIUM_VACUUM;
struct path path;
struct s3d_hit hit = S3D_HIT_NULL;
struct point pt;
@@ -735,6 +750,12 @@ trace_radiative_path
view_samp, view_rt, ran_sun_dir, ran_sun_wl, thread_ctx->rng, &is_lit);
if(res != RES_OK) goto error;
+ if(scn->atmosphere) {
+ /* Assume that the path starts from an uniform atmosphere */
+ medium.absorptivity = atmosphere_uniform_get_absorption
+ (scn->atmosphere, pt.wl);
+ }
+
if(tracker) {
/* Add the first point of the starting segment */
if(tracker->sun_ray_length > 0) {
@@ -780,7 +801,7 @@ trace_radiative_path
} else {
/* Modulate the point weight wrt to its scattering functions and
* generate an outgoing direction */
- res = point_shade(&pt, thread_ctx->bsdf, thread_ctx->rng, pt.dir);
+ res = point_shade(&pt, thread_ctx->bsdf, &medium, thread_ctx->rng, pt.dir);
if(res != RES_OK) goto error;
}
@@ -829,10 +850,9 @@ trace_radiative_path
depth += mtl->type != SSOL_MATERIAL_VIRTUAL;
- /* Take into account the atmosphere attenuation along the new ray */
- if(scn->atmosphere) {
- const double transmissivity = compute_atmosphere_transmissivity
- (scn->atmosphere, hit.distance, pt.wl);
+ /* Take into account the medium attenuation */
+ if(medium.absorptivity > 0 && hit.distance > 0) {
+ const double transmissivity = exp(-medium.absorptivity * hit.distance);
ASSERT(0 < transmissivity && transmissivity <= 1);
pt.absorptivity_loss += (1 - transmissivity) * pt.weight;
pt.weight *= transmissivity;
diff --git a/src/test_ssol_by_receiver_integration.c b/src/test_ssol_by_receiver_integration.c
@@ -114,7 +114,7 @@ main(int argc, char** argv)
shader.normal = get_shader_normal;
shader.reflectivity = get_shader_reflectivity;
shader.roughness = get_shader_roughness;
- CHECK(ssol_mirror_set_shader(m_mtl, &shader), RES_OK);
+ CHECK(ssol_mirror_setup(m_mtl, &shader), RES_OK);
CHECK(ssol_material_create_virtual(dev, &v_mtl), RES_OK);
CHECK(ssol_object_create(dev, &m_object), RES_OK);
diff --git a/src/test_ssol_draw.c b/src/test_ssol_draw.c
@@ -126,7 +126,7 @@ setup_cornell_box(struct ssol_device* dev, struct ssol_scene* scn)
shader.normal = get_shader_normal;
shader.reflectivity = get_shader_reflectivity;
CHECK(ssol_material_create_matte(dev, &mtl), RES_OK);
- CHECK(ssol_matte_set_shader(mtl, &shader), RES_OK);
+ CHECK(ssol_matte_setup(mtl, &shader), RES_OK);
vdata.usage = SSOL_POSITION;
vdata.get = get_position;
diff --git a/src/test_ssol_material.c b/src/test_ssol_material.c
@@ -48,10 +48,10 @@ test_mirror(struct ssol_device* dev)
mirror.reflectivity = get_shader_reflectivity;
mirror.roughness = get_shader_roughness;
- CHECK(ssol_mirror_set_shader(NULL, &mirror), RES_BAD_ARG);
- CHECK(ssol_mirror_set_shader(material, NULL), RES_BAD_ARG);
- CHECK(ssol_mirror_set_shader(material, &mirror), RES_OK);
- CHECK(ssol_mirror_set_shader(material, &mirror), RES_OK);
+ CHECK(ssol_mirror_setup(NULL, &mirror), RES_BAD_ARG);
+ CHECK(ssol_mirror_setup(material, NULL), RES_BAD_ARG);
+ CHECK(ssol_mirror_setup(material, &mirror), RES_OK);
+ CHECK(ssol_mirror_setup(material, &mirror), RES_OK);
CHECK(ssol_material_set_param_buffer(NULL, NULL), RES_BAD_ARG);
CHECK(ssol_material_set_param_buffer(material, NULL), RES_BAD_ARG);
@@ -59,15 +59,15 @@ test_mirror(struct ssol_device* dev)
CHECK(ssol_material_set_param_buffer(material, pbuf), RES_OK);
mirror.normal = NULL;
- CHECK(ssol_mirror_set_shader(material, &mirror), RES_BAD_ARG);
+ CHECK(ssol_mirror_setup(material, &mirror), RES_BAD_ARG);
mirror.normal = get_shader_normal;
mirror.reflectivity = NULL;
- CHECK(ssol_mirror_set_shader(material, &mirror), RES_BAD_ARG);
+ CHECK(ssol_mirror_setup(material, &mirror), RES_BAD_ARG);
mirror.reflectivity = get_shader_reflectivity;
mirror.roughness = NULL;
- CHECK(ssol_mirror_set_shader(material, &mirror), RES_BAD_ARG);
+ CHECK(ssol_mirror_setup(material, &mirror), RES_BAD_ARG);
mirror.roughness = get_shader_roughness;
CHECK(ssol_material_ref_put(material), RES_OK);
@@ -91,16 +91,16 @@ test_matte(struct ssol_device* dev)
matte.normal = get_shader_normal;
matte.reflectivity = get_shader_reflectivity;
- CHECK(ssol_matte_set_shader(NULL, NULL), RES_BAD_ARG);
- CHECK(ssol_matte_set_shader(material, NULL), RES_BAD_ARG);
- CHECK(ssol_matte_set_shader(NULL, &matte), RES_BAD_ARG);
- CHECK(ssol_matte_set_shader(material, &matte), RES_OK);
+ CHECK(ssol_matte_setup(NULL, NULL), RES_BAD_ARG);
+ CHECK(ssol_matte_setup(material, NULL), RES_BAD_ARG);
+ CHECK(ssol_matte_setup(NULL, &matte), RES_BAD_ARG);
+ CHECK(ssol_matte_setup(material, &matte), RES_OK);
matte.normal = NULL;
- CHECK(ssol_matte_set_shader(material, &matte), RES_BAD_ARG);
+ CHECK(ssol_matte_setup(material, &matte), RES_BAD_ARG);
matte.normal = get_shader_normal;
matte.reflectivity = NULL;
- CHECK(ssol_matte_set_shader(material, &matte), RES_BAD_ARG);
+ CHECK(ssol_matte_setup(material, &matte), RES_BAD_ARG);
CHECK(ssol_material_ref_put(material), RES_OK);
}
@@ -108,44 +108,134 @@ test_matte(struct ssol_device* dev)
static void
test_thin_dielectric(struct ssol_device* dev)
{
- struct ssol_thin_dielectric_shader thin_dielectric =
+ struct ssol_thin_dielectric_shader shader =
SSOL_THIN_DIELECTRIC_SHADER_NULL;
- struct ssol_material* material;
+ struct ssol_material* mtl;
+ struct ssol_medium mdm0 = SSOL_MEDIUM_VACUUM;
+ struct ssol_medium mdm1 = SSOL_MEDIUM_VACUUM;
enum ssol_material_type type;
CHECK(ssol_material_create_thin_dielectric(NULL, NULL), RES_BAD_ARG);
CHECK(ssol_material_create_thin_dielectric(dev, NULL), RES_BAD_ARG);
- CHECK(ssol_material_create_thin_dielectric(NULL, &material), RES_BAD_ARG);
- CHECK(ssol_material_create_thin_dielectric(dev, &material), RES_OK);
+ CHECK(ssol_material_create_thin_dielectric(NULL, &mtl), RES_BAD_ARG);
+ CHECK(ssol_material_create_thin_dielectric(dev, &mtl), RES_OK);
- CHECK(ssol_material_get_type(material, &type), RES_OK);
+ CHECK(ssol_material_get_type(mtl, &type), RES_OK);
CHECK(type, SSOL_MATERIAL_THIN_DIELECTRIC);
- thin_dielectric.normal = get_shader_normal;
- thin_dielectric.absorption = get_shader_absorption;
- thin_dielectric.thickness = get_shader_thickness;
- thin_dielectric.refractive_index = get_shader_refractive_index;
-
- CHECK(ssol_thin_dielectric_set_shader(NULL, NULL), RES_BAD_ARG);
- CHECK(ssol_thin_dielectric_set_shader(material, NULL), RES_BAD_ARG);
- CHECK(ssol_thin_dielectric_set_shader(NULL, &thin_dielectric), RES_BAD_ARG);
- CHECK(ssol_thin_dielectric_set_shader(material, &thin_dielectric), RES_OK);
-
- thin_dielectric.normal = NULL;
- CHECK(ssol_thin_dielectric_set_shader(material, &thin_dielectric), RES_BAD_ARG);
- thin_dielectric.normal = get_shader_normal;
+ shader.normal = get_shader_normal;
+
+ CHECK(ssol_thin_dielectric_setup(NULL, NULL, NULL, NULL, -1), RES_BAD_ARG);
+ CHECK(ssol_thin_dielectric_setup(mtl, NULL, NULL, NULL, -1), RES_BAD_ARG);
+ CHECK(ssol_thin_dielectric_setup(NULL, &shader, NULL, NULL, -1), RES_BAD_ARG);
+ CHECK(ssol_thin_dielectric_setup(mtl, &shader, NULL, NULL, -1), RES_BAD_ARG);
+ CHECK(ssol_thin_dielectric_setup(NULL, NULL, &mdm0, NULL, -1), RES_BAD_ARG);
+ CHECK(ssol_thin_dielectric_setup(mtl, NULL, &mdm0, NULL, -1), RES_BAD_ARG);
+ CHECK(ssol_thin_dielectric_setup(NULL, &shader, &mdm0, NULL, -1), RES_BAD_ARG);
+ CHECK(ssol_thin_dielectric_setup(mtl, &shader, &mdm0, NULL, -1), RES_BAD_ARG);
+ CHECK(ssol_thin_dielectric_setup(NULL, NULL, NULL, NULL, 1), RES_BAD_ARG);
+ CHECK(ssol_thin_dielectric_setup(mtl, NULL, NULL, NULL, 1), RES_BAD_ARG);
+ CHECK(ssol_thin_dielectric_setup(NULL, &shader, NULL, NULL, 1), RES_BAD_ARG);
+ CHECK(ssol_thin_dielectric_setup(mtl, &shader, NULL, NULL, 1), RES_BAD_ARG);
+ CHECK(ssol_thin_dielectric_setup(NULL, NULL, &mdm0, NULL, 1), RES_BAD_ARG);
+ CHECK(ssol_thin_dielectric_setup(mtl, NULL, &mdm0, NULL, 1), RES_BAD_ARG);
+ CHECK(ssol_thin_dielectric_setup(NULL, &shader, &mdm0, NULL, 1), RES_BAD_ARG);
+ CHECK(ssol_thin_dielectric_setup(mtl, &shader, &mdm0, NULL, 1), RES_BAD_ARG);
+ CHECK(ssol_thin_dielectric_setup(NULL, NULL, NULL, &mdm1, -1), RES_BAD_ARG);
+ CHECK(ssol_thin_dielectric_setup(mtl, NULL, NULL, &mdm1, -1), RES_BAD_ARG);
+ CHECK(ssol_thin_dielectric_setup(NULL, &shader, NULL, &mdm1, -1), RES_BAD_ARG);
+ CHECK(ssol_thin_dielectric_setup(mtl, &shader, NULL, &mdm1, -1), RES_BAD_ARG);
+ CHECK(ssol_thin_dielectric_setup(NULL, NULL, &mdm0, &mdm1, -1), RES_BAD_ARG);
+ CHECK(ssol_thin_dielectric_setup(mtl, NULL, &mdm0, &mdm1, -1), RES_BAD_ARG);
+ CHECK(ssol_thin_dielectric_setup(NULL, &shader, &mdm0, &mdm1, -1), RES_BAD_ARG);
+ CHECK(ssol_thin_dielectric_setup(mtl, &shader, &mdm0, &mdm1, -1), RES_BAD_ARG);
+ CHECK(ssol_thin_dielectric_setup(NULL, NULL, NULL, &mdm1, 1), RES_BAD_ARG);
+ CHECK(ssol_thin_dielectric_setup(mtl, NULL, NULL, &mdm1, 1), RES_BAD_ARG);
+ CHECK(ssol_thin_dielectric_setup(NULL, &shader, NULL, &mdm1, 1), RES_BAD_ARG);
+ CHECK(ssol_thin_dielectric_setup(mtl, &shader, NULL, &mdm1, 1), RES_BAD_ARG);
+ CHECK(ssol_thin_dielectric_setup(NULL, NULL, &mdm0, &mdm1, 1), RES_BAD_ARG);
+ CHECK(ssol_thin_dielectric_setup(mtl, NULL, &mdm0, &mdm1, 1), RES_BAD_ARG);
+ CHECK(ssol_thin_dielectric_setup(NULL, &shader, &mdm0, &mdm1, 1), RES_BAD_ARG);
+ CHECK(ssol_thin_dielectric_setup(mtl, &shader, &mdm0, &mdm1, 1), RES_OK);
+
+ shader.normal = NULL;
+ CHECK(ssol_thin_dielectric_setup(mtl, &shader, &mdm0, &mdm1, 1), RES_BAD_ARG);
+ shader.normal = get_shader_normal;
+
+ mdm0.absorptivity = -1;
+ CHECK(ssol_thin_dielectric_setup(mtl, &shader, &mdm0, &mdm1, 1), RES_BAD_ARG);
+ mdm0.absorptivity = SSOL_MEDIUM_VACUUM.absorptivity;
+
+ mdm0.refractive_index = 0;
+ CHECK(ssol_thin_dielectric_setup(mtl, &shader, &mdm0, &mdm1, 1), RES_BAD_ARG);
+ mdm0.refractive_index = SSOL_MEDIUM_VACUUM.refractive_index;
+
+ mdm1.absorptivity = -1;
+ CHECK(ssol_thin_dielectric_setup(mtl, &shader, &mdm0, &mdm1, 1), RES_BAD_ARG);
+ mdm1.absorptivity = SSOL_MEDIUM_VACUUM.absorptivity;
+
+ mdm1.refractive_index = 0;
+ CHECK(ssol_thin_dielectric_setup(mtl, &shader, &mdm0, &mdm1, 1), RES_BAD_ARG);
+ mdm1.refractive_index = SSOL_MEDIUM_VACUUM.refractive_index;
+
+ CHECK(ssol_material_ref_put(mtl), RES_OK);
+}
- thin_dielectric.absorption = NULL;
- CHECK(ssol_thin_dielectric_set_shader(material, &thin_dielectric), RES_BAD_ARG);
- thin_dielectric.absorption = get_shader_absorption;
+static void
+test_dielectric(struct ssol_device* dev)
+{
+ struct ssol_dielectric_shader dielectric = SSOL_DIELECTRIC_SHADER_NULL;
+ struct ssol_material* material;
+ struct ssol_medium mdm0 = SSOL_MEDIUM_VACUUM;
+ struct ssol_medium mdm1 = SSOL_MEDIUM_VACUUM;
+ enum ssol_material_type type;
- thin_dielectric.thickness = NULL;
- CHECK(ssol_thin_dielectric_set_shader(material, &thin_dielectric), RES_BAD_ARG);
- thin_dielectric.thickness = get_shader_thickness;
+ CHECK(ssol_material_create_dielectric(NULL, NULL), RES_BAD_ARG);
+ CHECK(ssol_material_create_dielectric(dev, NULL), RES_BAD_ARG);
+ CHECK(ssol_material_create_dielectric(NULL, &material), RES_BAD_ARG);
+ CHECK(ssol_material_create_dielectric(dev, &material), RES_OK);
- thin_dielectric.refractive_index = NULL;
- CHECK(ssol_thin_dielectric_set_shader(material, &thin_dielectric), RES_BAD_ARG);
- thin_dielectric.thickness = get_shader_refractive_index;
+ CHECK(ssol_material_get_type(material, &type), RES_OK);
+ CHECK(type, SSOL_MATERIAL_DIELECTRIC);
+
+ dielectric.normal = get_shader_normal;
+
+ CHECK(ssol_dielectric_setup(NULL, NULL, NULL, NULL), RES_BAD_ARG);
+ CHECK(ssol_dielectric_setup(material, NULL, NULL, NULL), RES_BAD_ARG);
+ CHECK(ssol_dielectric_setup(NULL, &dielectric, NULL, NULL), RES_BAD_ARG);
+ CHECK(ssol_dielectric_setup(material, &dielectric, NULL, NULL), RES_BAD_ARG);
+ CHECK(ssol_dielectric_setup(NULL, NULL, &mdm0, NULL), RES_BAD_ARG);
+ CHECK(ssol_dielectric_setup(material, NULL, &mdm0, NULL), RES_BAD_ARG);
+ CHECK(ssol_dielectric_setup(NULL, &dielectric, &mdm0, NULL), RES_BAD_ARG);
+ CHECK(ssol_dielectric_setup(material, &dielectric, &mdm0, NULL), RES_BAD_ARG);
+ CHECK(ssol_dielectric_setup(NULL, NULL, NULL, &mdm1), RES_BAD_ARG);
+ CHECK(ssol_dielectric_setup(material, NULL, NULL, &mdm1), RES_BAD_ARG);
+ CHECK(ssol_dielectric_setup(NULL, &dielectric, NULL, &mdm1), RES_BAD_ARG);
+ CHECK(ssol_dielectric_setup(material, &dielectric, NULL, &mdm1), RES_BAD_ARG);
+ CHECK(ssol_dielectric_setup(NULL, NULL, &mdm0, &mdm1), RES_BAD_ARG);
+ CHECK(ssol_dielectric_setup(material, NULL, &mdm0, &mdm1), RES_BAD_ARG);
+ CHECK(ssol_dielectric_setup(NULL, &dielectric, &mdm0, &mdm1), RES_BAD_ARG);
+ CHECK(ssol_dielectric_setup(material, &dielectric, &mdm0, &mdm1), RES_OK);
+
+ dielectric.normal = NULL;
+ CHECK(ssol_dielectric_setup(NULL, &dielectric, &mdm0, &mdm1), RES_BAD_ARG);
+ dielectric.normal = get_shader_normal;
+
+ mdm0.refractive_index = 0;
+ CHECK(ssol_dielectric_setup(NULL, &dielectric, &mdm0, &mdm1), RES_BAD_ARG);
+ mdm0.refractive_index = SSOL_MEDIUM_VACUUM.refractive_index;
+
+ mdm1.refractive_index = 0;
+ CHECK(ssol_dielectric_setup(NULL, &dielectric, &mdm0, &mdm1), RES_BAD_ARG);
+ mdm1.refractive_index = SSOL_MEDIUM_VACUUM.refractive_index;
+
+ mdm0.absorptivity = -1;
+ CHECK(ssol_dielectric_setup(NULL, &dielectric, &mdm0, &mdm1), RES_BAD_ARG);
+ mdm0.absorptivity = SSOL_MEDIUM_VACUUM.refractive_index;
+
+ mdm1.absorptivity = -1;
+ CHECK(ssol_dielectric_setup(NULL, &dielectric, &mdm0, &mdm1), RES_BAD_ARG);
+ mdm1.refractive_index = SSOL_MEDIUM_VACUUM.refractive_index;
CHECK(ssol_material_ref_put(material), RES_OK);
}
@@ -182,6 +272,7 @@ main(int argc, char** argv)
test_mirror(dev);
test_matte(dev);
test_thin_dielectric(dev);
+ test_dielectric(dev);
test_virtual(dev);
CHECK(ssol_device_ref_put(dev), RES_OK);
diff --git a/src/test_ssol_solver1.c b/src/test_ssol_solver1.c
@@ -144,7 +144,7 @@ main(int argc, char** argv)
shader.normal = get_shader_normal;
shader.reflectivity = get_shader_reflectivity;
shader.roughness = get_shader_roughness;
- CHECK(ssol_mirror_set_shader(m_mtl, &shader), RES_OK);
+ CHECK(ssol_mirror_setup(m_mtl, &shader), RES_OK);
CHECK(ssol_material_create_virtual(dev, &v_mtl), RES_OK);
CHECK(ssol_object_create(dev, &m_object), RES_OK);
@@ -282,7 +282,7 @@ main(int argc, char** argv)
CHECK(ssol_instance_set_receiver(target, SSOL_FRONT, 0), RES_OK);
CHECK(ssol_estimator_ref_put(estimator), RES_OK);
- /* Spectra mismatch */
+ /* Spectra mismatch */
desc.wavelengths = mismatch;
desc.wavelengths = ka;
desc.count = 2;
@@ -417,7 +417,7 @@ main(int argc, char** argv)
shader.normal = get_shader_normal;
shader.reflectivity = get_shader_reflectivity_2;
shader.roughness = get_shader_roughness;
- CHECK(ssol_mirror_set_shader(m_mtl2, &shader), RES_OK);
+ CHECK(ssol_mirror_setup(m_mtl2, &shader), RES_OK);
CHECK(ssol_object_create(dev, &m_object2), RES_OK);
CHECK(ssol_object_add_shaded_shape(m_object2, square, m_mtl2, m_mtl2), RES_OK);
diff --git a/src/test_ssol_solver2.c b/src/test_ssol_solver2.c
@@ -145,7 +145,7 @@ main(int argc, char** argv)
shader.normal = get_shader_normal;
shader.reflectivity = get_shader_reflectivity;
shader.roughness = get_shader_roughness;
- CHECK(ssol_mirror_set_shader(m_mtl, &shader), RES_OK);
+ CHECK(ssol_mirror_setup(m_mtl, &shader), RES_OK);
CHECK(ssol_material_create_virtual(dev, &v_mtl), RES_OK);
CHECK(ssol_object_create(dev, &m_object), RES_OK);
diff --git a/src/test_ssol_solver2b.c b/src/test_ssol_solver2b.c
@@ -149,7 +149,7 @@ main(int argc, char** argv)
shader.normal = get_shader_normal;
shader.reflectivity = get_shader_reflectivity;
shader.roughness = get_shader_roughness;
- CHECK(ssol_mirror_set_shader(m_mtl, &shader), RES_OK);
+ CHECK(ssol_mirror_setup(m_mtl, &shader), RES_OK);
CHECK(ssol_material_create_virtual(dev, &v_mtl), RES_OK);
CHECK(ssol_object_create(dev, &m_object), RES_OK);
diff --git a/src/test_ssol_solver3.c b/src/test_ssol_solver3.c
@@ -119,7 +119,7 @@ main(int argc, char** argv)
shader.normal = get_shader_normal;
shader.reflectivity = get_shader_reflectivity;
shader.roughness = get_shader_roughness;
- CHECK(ssol_mirror_set_shader(m_mtl, &shader), RES_OK);
+ CHECK(ssol_mirror_setup(m_mtl, &shader), RES_OK);
CHECK(ssol_material_create_virtual(dev, &v_mtl), RES_OK);
CHECK(ssol_object_create(dev, &m_object), RES_OK);
diff --git a/src/test_ssol_solver4.c b/src/test_ssol_solver4.c
@@ -122,7 +122,7 @@ main(int argc, char** argv)
shader.normal = get_shader_normal;
shader.reflectivity = get_shader_reflectivity;
shader.roughness = get_shader_roughness;
- CHECK(ssol_mirror_set_shader(m_mtl, &shader), RES_OK);
+ CHECK(ssol_mirror_setup(m_mtl, &shader), RES_OK);
CHECK(ssol_material_create_virtual(dev, &v_mtl), RES_OK);
CHECK(ssol_object_create(dev, &m_object), RES_OK);
diff --git a/src/test_ssol_solver5.c b/src/test_ssol_solver5.c
@@ -120,7 +120,7 @@ main(int argc, char** argv)
shader.normal = get_shader_normal;
shader.reflectivity = get_shader_reflectivity;
shader.roughness = get_shader_roughness;
- CHECK(ssol_mirror_set_shader(m_mtl, &shader), RES_OK);
+ CHECK(ssol_mirror_setup(m_mtl, &shader), RES_OK);
CHECK(ssol_material_create_virtual(dev, &v_mtl), RES_OK);
CHECK(ssol_object_create(dev, &m_object), RES_OK);
diff --git a/src/test_ssol_solver6.c b/src/test_ssol_solver6.c
@@ -120,11 +120,11 @@ main(int argc, char** argv)
m_shader.normal = get_shader_normal;
m_shader.reflectivity = get_shader_reflectivity;
m_shader.roughness = get_shader_roughness;
- CHECK(ssol_mirror_set_shader(m_mtl, &m_shader), RES_OK);
+ CHECK(ssol_mirror_setup(m_mtl, &m_shader), RES_OK);
CHECK(ssol_material_create_matte(dev, &bck_mtl), RES_OK);
bck_shader.normal = get_shader_normal;
bck_shader.reflectivity = get_shader_reflectivity_2;
- CHECK(ssol_matte_set_shader(bck_mtl, &bck_shader), RES_OK);
+ CHECK(ssol_matte_setup(bck_mtl, &bck_shader), RES_OK);
CHECK(ssol_material_create_virtual(dev, &v_mtl), RES_OK);
/* 1st reflector */
diff --git a/src/test_ssol_solver7.c b/src/test_ssol_solver7.c
@@ -126,11 +126,11 @@ main(int argc, char** argv)
m_shader.normal = get_shader_normal;
m_shader.reflectivity = get_shader_reflectivity;
m_shader.roughness = get_shader_roughness;
- CHECK(ssol_mirror_set_shader(m_mtl, &m_shader), RES_OK);
+ CHECK(ssol_mirror_setup(m_mtl, &m_shader), RES_OK);
CHECK(ssol_material_create_matte(dev, &bck_mtl), RES_OK);
bck_shader.normal = get_shader_normal;
bck_shader.reflectivity = get_shader_reflectivity_2;
- CHECK(ssol_matte_set_shader(bck_mtl, &bck_shader), RES_OK);
+ CHECK(ssol_matte_setup(bck_mtl, &bck_shader), RES_OK);
CHECK(ssol_material_create_virtual(dev, &v_mtl), RES_OK);
carving1.get = get_polygon_vertices;
diff --git a/src/test_ssol_solver8.c b/src/test_ssol_solver8.c
@@ -1,17 +1,17 @@
/* Copyright (C) CNRS 2016-2017
-*
-* This program is free software: you can redistribute it and/or modify
-* it under the terms of the GNU General Public License as published by
-* the Free Software Foundation, either version 3 of the License, or
-* (at your option) any later version.
-*
-* This program is distributed in the hope that it will be useful,
-* but WITHOUT ANY WARRANTY; without even the implied warranty of
-* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-* GNU General Public License for more details.
-*
-* You should have received a copy of the GNU General Public License
-* along with this program. If not, see <http://www.gnu.org/licenses/>. */
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>. */
#include "ssol.h"
#include "test_ssol_utils.h"
@@ -123,7 +123,7 @@ main(int argc, char** argv)
shader.normal = get_shader_normal;
shader.reflectivity = get_shader_reflectivity;
shader.roughness = get_shader_roughness;
- CHECK(ssol_mirror_set_shader(m_mtl, &shader), RES_OK);
+ CHECK(ssol_mirror_setup(m_mtl, &shader), RES_OK);
CHECK(ssol_material_create_virtual(dev, &v_mtl), RES_OK);
CHECK(ssol_object_create(dev, &m_object), RES_OK);
@@ -160,7 +160,8 @@ main(int argc, char** argv)
CHECK(GET_MC_RCV(estimator, target, SSOL_FRONT, &mc_rcv), RES_OK);
printf("Ir(target1) = %g +/- %g\n",
mc_rcv.integrated_irradiance.E, mc_rcv.integrated_irradiance.SE);
- CHECK(eq_eps(mc_rcv.integrated_irradiance.E, S * DNI, 2 * mc_rcv.integrated_irradiance.SE), 1);
+ CHECK(eq_eps(mc_rcv.integrated_irradiance.E, S * DNI,
+ 2 * mc_rcv.integrated_irradiance.SE), 1);
/* Free data */
CHECK(ssol_instance_ref_put(heliostat), RES_OK);
diff --git a/src/test_ssol_solver9.c b/src/test_ssol_solver9.c
@@ -1,17 +1,17 @@
/* Copyright (C) CNRS 2016-2017
-*
-* This program is free software: you can redistribute it and/or modify
-* it under the terms of the GNU General Public License as published by
-* the Free Software Foundation, either version 3 of the License, or
-* (at your option) any later version.
-*
-* This program is distributed in the hope that it will be useful,
-* but WITHOUT ANY WARRANTY; without even the implied warranty of
-* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-* GNU General Public License for more details.
-*
-* You should have received a copy of the GNU General Public License
-* along with this program. If not, see <http://www.gnu.org/licenses/>. */
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>. */
#include "ssol.h"
#include "test_ssol_utils.h"
@@ -117,7 +117,7 @@ main(int argc, char** argv)
shader.normal = get_shader_normal;
shader.reflectivity = get_shader_reflectivity;
shader.roughness = get_shader_roughness;
- CHECK(ssol_mirror_set_shader(m_mtl, &shader), RES_OK);
+ CHECK(ssol_mirror_setup(m_mtl, &shader), RES_OK);
CHECK(ssol_material_create_virtual(dev, &v_mtl), RES_OK);
CHECK(ssol_object_create(dev, &m_object), RES_OK);
