commit 0e0e19d032035812014aeb9b0e4640eb08a22156
parent f1235b6fa475d3b4e8c92bf116d7793c5f3c66a9
Author: Vincent Forest <vincent.forest@meso-star.com>
Date: Wed, 13 Dec 2017 11:38:23 +0100
Merge branch 'release_0.7'
Diffstat:
39 files changed, 2827 insertions(+), 2229 deletions(-)
diff --git a/README.md b/README.md
@@ -26,6 +26,12 @@ variable the install directories of its dependencies.
## Release notes
+### Version 0.7
+
+- Add the Gaussian sun shape.
+- Add the microfacet distribution parameter to the mirror material: one can
+ choose either the Beckmann or the pillbox distribution.
+
### Version 0.6.1
- Rename the `ssol_sun_pillbox_set_theta_max` function in
diff --git a/cmake/CMakeLists.txt b/cmake/CMakeLists.txt
@@ -24,11 +24,11 @@ option(NO_TEST "Do not build tests" OFF)
# Check dependencies
################################################################################
find_package(RCMake 0.3 REQUIRED)
-find_package(RSys 0.5 REQUIRED)
+find_package(RSys 0.6 REQUIRED)
find_package(Star3D 0.4.1 REQUIRED)
find_package(Star3DUT 0.2 REQUIRED)
find_package(StarCPR 0.1 REQUIRED)
-find_package(StarSF 0.3 REQUIRED)
+find_package(StarSF 0.4 REQUIRED)
find_package(StarSP 0.4 REQUIRED)
find_package(OpenMP 1.2 REQUIRED)
@@ -50,8 +50,8 @@ rcmake_append_runtime_dirs(_runtime_dirs RSys Star3D Star3DUT StarCPR StarSF Sta
# Configure and define targets
################################################################################
set(VERSION_MAJOR 0)
-set(VERSION_MINOR 6)
-set(VERSION_PATCH 1)
+set(VERSION_MINOR 7)
+set(VERSION_PATCH 0)
set(VERSION ${VERSION_MAJOR}.${VERSION_MINOR}.${VERSION_PATCH})
set(SSOL_FILES_SRC
@@ -182,6 +182,8 @@ if(NOT NO_TEST)
new_test(test_ssol_solver8)
new_test(test_ssol_solver9)
new_test(test_ssol_solver10)
+ new_test(test_ssol_solver11)
+ new_test(test_ssol_solver12)
new_test(test_ssol_sun)
build_test(test_ssol_draw)
diff --git a/src/ssol.h b/src/ssol.h
@@ -82,6 +82,12 @@ enum ssol_material_type {
SSOL_MATERIAL_TYPES_COUNT__
};
+enum ssol_microfacet_distribution {
+ SSOL_MICROFACET_BECKMANN,
+ SSOL_MICROFACET_PILLBOX,
+ SSOL_MICROFACET_DISTRIBUTIONS_COUNT__
+};
+
enum ssol_clipping_op {
SSOL_AND,
SSOL_SUB,
@@ -799,7 +805,8 @@ ssol_dielectric_setup
SSOL_API res_T
ssol_mirror_setup
(struct ssol_material* mtl,
- const struct ssol_mirror_shader* shader);
+ const struct ssol_mirror_shader* shader,
+ const enum ssol_microfacet_distribution distrib);
SSOL_API res_T
ssol_matte_setup
@@ -996,6 +1003,12 @@ ssol_sun_create_pillbox
(struct ssol_device* dev,
struct ssol_sun** sun);
+/* The sun disk intensity has a gaussian shape */
+SSOL_API res_T
+ssol_sun_create_gaussian
+ (struct ssol_device* dev,
+ struct ssol_sun** sun);
+
/* The sun disk intensity is controlled by a circumsolar ratio. From the paper
* "Sunshape distributions for terrestrial solar simulations". D. Buie, A.G.
* Monger, C.J. Dey */
@@ -1042,7 +1055,12 @@ ssol_sun_set_spectrum
SSOL_API res_T
ssol_sun_pillbox_set_half_angle
(struct ssol_sun* sun,
- const double half_angle); /* In radian */
+ const double half_angle); /* In ]0, PI/2], in radian */
+
+SSOL_API res_T
+ssol_sun_gaussian_set_std_dev
+ (struct ssol_sun* sun,
+ const double std_dev); /* In ]0, +Inf[, in radian */
SSOL_API res_T
ssol_sun_set_buie_param
diff --git a/src/ssol_material.c b/src/ssol_material.c
@@ -183,11 +183,24 @@ create_mirror_bsdf
res = ssf_specular_reflection_setup(*bsdf, fresnel);
if(res != RES_OK) goto error;
} else { /* Glossy reflection */
- res = ssf_microfacet_distribution_create
- (mtl->dev->allocator, &ssf_beckmann_distribution, &distrib);
- if(res != RES_OK) goto error;
- res = ssf_beckmann_distribution_setup(distrib, roughness);
- if(res != RES_OK) goto error;
+ switch(mtl->data.mirror.distrib) {
+ /* Setup the microfacet distribution */
+ case SSOL_MICROFACET_BECKMANN:
+ res = ssf_microfacet_distribution_create
+ (mtl->dev->allocator, &ssf_beckmann_distribution, &distrib);
+ if(res != RES_OK) goto error;
+ res = ssf_beckmann_distribution_setup(distrib, roughness);
+ if(res != RES_OK) goto error;
+ break;
+ case SSOL_MICROFACET_PILLBOX:
+ res = ssf_microfacet_distribution_create
+ (mtl->dev->allocator, &ssf_pillbox_distribution, &distrib);
+ if(res != RES_OK) goto error;
+ res = ssf_beckmann_distribution_setup(distrib, roughness);
+ if(res != RES_OK) goto error;
+ break;
+ default: FATAL("Unreachable code.\n"); break;
+ }
/* Microfacet2 is not well suited for rendering since it cannot be
* evaluated and consequently it returns an invalid result for direct
@@ -472,15 +485,19 @@ ssol_dielectric_setup
res_T
ssol_mirror_setup
- (struct ssol_material* material, const struct ssol_mirror_shader* shader)
+ (struct ssol_material* material,
+ const struct ssol_mirror_shader* shader,
+ const enum ssol_microfacet_distribution distrib)
{
if(!material
|| material->type != SSOL_MATERIAL_MIRROR
- || !check_shader_mirror(shader))
+ || !check_shader_mirror(shader)
+ || (unsigned)distrib >= SSOL_MICROFACET_DISTRIBUTIONS_COUNT__)
return RES_BAD_ARG;
material->normal = shader->normal;
material->data.mirror.reflectivity = shader->reflectivity;
material->data.mirror.roughness = shader->roughness;
+ material->data.mirror.distrib = distrib;
return RES_OK;
}
diff --git a/src/ssol_material_c.h b/src/ssol_material_c.h
@@ -34,6 +34,7 @@ struct matte {
struct mirror {
ssol_shader_getter_T reflectivity;
ssol_shader_getter_T roughness;
+ enum ssol_microfacet_distribution distrib;
};
struct thin_dielectric {
diff --git a/src/ssol_ranst_sun_dir.c b/src/ssol_ranst_sun_dir.c
@@ -44,6 +44,11 @@ struct ran_pillbox_state {
double basis[9];
};
+struct ran_gaussian_state {
+ double std_dev;
+ double basis[9];
+};
+
struct ran_dirac_state {
double dir[3];
};
@@ -56,6 +61,7 @@ struct ranst_sun_dir {
union {
struct ran_buie_state buie;
struct ran_pillbox_state pillbox;
+ struct ran_gaussian_state gaussian;
struct ran_dirac_state dirac;
} state;
@@ -260,6 +266,30 @@ ran_pillbox_get
}
/*******************************************************************************
+* Gaussian random variate
+******************************************************************************/
+static double*
+ran_gaussian_get
+ (const struct ranst_sun_dir* ran,
+ struct ssp_rng* rng,
+ double dir[3])
+{
+ double pt[3];
+ double phi, theta, sin_theta;
+
+ ASSERT(ran && 0 <= ran->state.gaussian.std_dev);
+ theta = ssp_ran_gaussian(rng, 0, ran->state.gaussian.std_dev);
+ sin_theta = sin(theta);
+ phi = ssp_rng_uniform_double(rng, 0, 2 * PI);
+ pt[0] = cos(phi) * sin_theta;
+ pt[1] = sin(phi) * sin_theta;
+ pt[2] = cos(theta);
+ d33_muld3(dir, ran->state.pillbox.basis, pt);
+ d3_normalize(dir, dir);
+ return dir;
+}
+
+/*******************************************************************************
* Dirac distribution
******************************************************************************/
static double*
@@ -358,6 +388,19 @@ ranst_sun_dir_pillbox_setup
}
res_T
+ranst_sun_dir_gaussian_setup
+ (struct ranst_sun_dir* ran,
+ const double std_dev,
+ const double dir[3])
+{
+ if(!ran || !dir || std_dev <= 0) return RES_BAD_ARG;
+ ran->get = ran_gaussian_get;
+ ran->state.gaussian.std_dev = std_dev;
+ d33_basis(ran->state.pillbox.basis, dir);
+ return RES_OK;
+}
+
+res_T
ranst_sun_dir_dirac_setup
(struct ranst_sun_dir* ran,
const double dir[3])
diff --git a/src/ssol_ranst_sun_dir.h b/src/ssol_ranst_sun_dir.h
@@ -55,6 +55,12 @@ ranst_sun_dir_pillbox_setup
const double dir[3]);
extern LOCAL_SYM res_T
+ranst_sun_dir_gaussian_setup
+ (struct ranst_sun_dir* ran,
+ const double std_dev,
+ const double dir[3]);
+
+extern LOCAL_SYM res_T
ranst_sun_dir_dirac_setup
(struct ranst_sun_dir* ran,
const double dir[3]);
diff --git a/src/ssol_solver.c b/src/ssol_solver.c
@@ -871,7 +871,7 @@ trace_radiative_path
struct ssol_medium in_medium = SSOL_MEDIUM_VACUUM;
struct ssol_medium out_medium = SSOL_MEDIUM_VACUUM;
struct s3d_hit hit = S3D_HIT_NULL;
- struct point pt;
+ struct point pt = POINT_NULL;
float org[3], dir[3], range[2] = { 0, FLT_MAX };
size_t depth = 0;
size_t roulette_interval, typical_max_depth;
diff --git a/src/ssol_sun.c b/src/ssol_sun.c
@@ -93,6 +93,12 @@ ssol_sun_create_pillbox(struct ssol_device* dev, struct ssol_sun** out_sun)
}
res_T
+ssol_sun_create_gaussian(struct ssol_device* dev, struct ssol_sun** out_sun)
+{
+ return sun_create(dev, out_sun, SUN_GAUSSIAN);
+}
+
+res_T
ssol_sun_create_buie
(struct ssol_device* dev, struct ssol_sun** out_sun)
{
@@ -172,13 +178,22 @@ ssol_sun_set_spectrum(struct ssol_sun* sun, struct ssol_spectrum* spectrum)
res_T
ssol_sun_pillbox_set_half_angle(struct ssol_sun* sun, const double half_angle)
{
- if(!sun || half_angle <= 0 || half_angle > PI || sun->type != SUN_PILLBOX)
+ if(!sun || half_angle <= 0 || half_angle > PI * 0.5 || sun->type != SUN_PILLBOX)
return RES_BAD_ARG;
sun->data.pillbox.half_angle = half_angle;
return RES_OK;
}
res_T
+ssol_sun_gaussian_set_std_dev(struct ssol_sun* sun, const double std_dev)
+{
+ if(!sun || std_dev <= 0 || sun->type != SUN_GAUSSIAN)
+ return RES_BAD_ARG;
+ sun->data.gaussian.std_dev = std_dev;
+ return RES_OK;
+}
+
+res_T
ssol_sun_set_buie_param
(struct ssol_sun* sun,
const double ratio)
@@ -213,6 +228,10 @@ sun_create_direction_distribution
res = ranst_sun_dir_pillbox_setup
(ran_dir, sun->data.pillbox.half_angle, sun->direction);
break;
+ case SUN_GAUSSIAN:
+ res = ranst_sun_dir_gaussian_setup
+ (ran_dir, sun->data.gaussian.std_dev, sun->direction);
+ break;
case SUN_BUIE:
res = ranst_sun_dir_buie_setup
(ran_dir, sun->data.csr.ratio, sun->direction);
@@ -224,7 +243,7 @@ exit:
return res;
error:
if(ran_dir) {
- CHECK(ranst_sun_dir_ref_put(ran_dir), RES_OK);
+ CHK(ranst_sun_dir_ref_put(ran_dir) == RES_OK);
ran_dir = NULL;
}
goto exit;
@@ -252,7 +271,7 @@ exit:
return res;
error:
if(ran_wl) {
- CHECK(ranst_sun_wl_ref_put(ran_wl), RES_OK);
+ CHK(ranst_sun_wl_ref_put(ran_wl) == RES_OK);
ran_wl = NULL;
}
goto exit;
diff --git a/src/ssol_sun_c.h b/src/ssol_sun_c.h
@@ -26,6 +26,7 @@ struct ranst_sun_wl;
enum sun_type {
SUN_DIRECTIONAL,
SUN_PILLBOX,
+ SUN_GAUSSIAN,
SUN_BUIE,
SUN_TYPES_COUNT__
};
@@ -34,6 +35,10 @@ struct pillbox {
double half_angle;
};
+struct gaussian {
+ double std_dev;
+};
+
struct buie {
double ratio;
};
@@ -46,6 +51,7 @@ struct ssol_sun {
enum sun_type type;
union {
struct pillbox pillbox;
+ struct gaussian gaussian;
struct buie csr;
} data;
diff --git a/src/test_ssol_atmosphere.c b/src/test_ssol_atmosphere.c
@@ -39,46 +39,46 @@ main(int argc, char** argv)
mem_init_proxy_allocator(&allocator, &mem_default_allocator);
- CHECK(ssol_device_create
- (NULL, &allocator, SSOL_NTHREADS_DEFAULT, 0, &dev), RES_OK);
+ CHK(ssol_device_create
+ (NULL, &allocator, SSOL_NTHREADS_DEFAULT, 0, &dev) == RES_OK);
extinction2.type = SSOL_DATA_SPECTRUM;
- CHECK(ssol_spectrum_create(dev, &spectrum), RES_OK);
- CHECK(ssol_spectrum_setup(spectrum, get_wlen, 2, NULL), RES_OK);
+ CHK(ssol_spectrum_create(dev, &spectrum) == RES_OK);
+ CHK(ssol_spectrum_setup(spectrum, get_wlen, 2, NULL) == RES_OK);
extinction2.type = SSOL_DATA_SPECTRUM;
extinction2.value.spectrum = spectrum;
- CHECK(ssol_atmosphere_create(NULL, &atm), RES_BAD_ARG);
- CHECK(ssol_atmosphere_create(dev, NULL), RES_BAD_ARG);
- CHECK(ssol_atmosphere_create(dev, &atm), RES_OK);
+ CHK(ssol_atmosphere_create(NULL, &atm) == RES_BAD_ARG);
+ CHK(ssol_atmosphere_create(dev, NULL) == RES_BAD_ARG);
+ CHK(ssol_atmosphere_create(dev, &atm) == RES_OK);
- CHECK(ssol_atmosphere_ref_get(NULL), RES_BAD_ARG);
- CHECK(ssol_atmosphere_ref_get(atm), RES_OK);
+ CHK(ssol_atmosphere_ref_get(NULL) == RES_BAD_ARG);
+ CHK(ssol_atmosphere_ref_get(atm) == RES_OK);
- CHECK(ssol_atmosphere_ref_put(NULL), RES_BAD_ARG);
- CHECK(ssol_atmosphere_ref_put(atm), RES_OK);
+ CHK(ssol_atmosphere_ref_put(NULL) == RES_BAD_ARG);
+ CHK(ssol_atmosphere_ref_put(atm) == RES_OK);
extinction.type = SSOL_DATA_REAL;
extinction.value.real = 0.1;
- CHECK(ssol_atmosphere_set_extinction(NULL, &extinction), RES_BAD_ARG);
- CHECK(ssol_atmosphere_set_extinction(atm, NULL), RES_BAD_ARG);
- CHECK(ssol_atmosphere_set_extinction(atm, &extinction), RES_OK);
- CHECK(ssol_atmosphere_set_extinction(atm, &extinction), RES_OK);
- CHECK(ssol_atmosphere_set_extinction(atm, &extinction2), RES_OK);
+ CHK(ssol_atmosphere_set_extinction(NULL, &extinction) == RES_BAD_ARG);
+ CHK(ssol_atmosphere_set_extinction(atm, NULL) == RES_BAD_ARG);
+ CHK(ssol_atmosphere_set_extinction(atm, &extinction) == RES_OK);
+ CHK(ssol_atmosphere_set_extinction(atm, &extinction) == RES_OK);
+ CHK(ssol_atmosphere_set_extinction(atm, &extinction2) == RES_OK);
/* extinction values out of range */
extinction.value.real = 2;
- CHECK(ssol_atmosphere_set_extinction(atm, &extinction), RES_BAD_ARG);
- CHECK(ssol_spectrum_setup(spectrum, get_wlen, 3, NULL), RES_OK);
- CHECK(ssol_atmosphere_set_extinction(atm, &extinction2), RES_BAD_ARG);
+ CHK(ssol_atmosphere_set_extinction(atm, &extinction) == RES_BAD_ARG);
+ CHK(ssol_spectrum_setup(spectrum, get_wlen, 3, NULL) == RES_OK);
+ CHK(ssol_atmosphere_set_extinction(atm, &extinction2) == RES_BAD_ARG);
- CHECK(ssol_spectrum_ref_put(extinction2.value.spectrum), RES_OK);
- CHECK(ssol_device_ref_put(dev), RES_OK);
- CHECK(ssol_atmosphere_ref_put(atm), RES_OK);
+ CHK(ssol_spectrum_ref_put(extinction2.value.spectrum) == RES_OK);
+ CHK(ssol_device_ref_put(dev) == RES_OK);
+ CHK(ssol_atmosphere_ref_put(atm) == RES_OK);
check_memory_allocator(&allocator);
mem_shutdown_proxy_allocator(&allocator);
- CHECK(mem_allocated_size(), 0);
+ CHK(mem_allocated_size() == 0);
return 0;
}
diff --git a/src/test_ssol_by_receiver_integration.c b/src/test_ssol_by_receiver_integration.c
@@ -37,7 +37,7 @@ get_wlen(const size_t i, double* wlen, double* data, void* ctx)
{
double wavelengths[3] = { 1, 2, 3 };
double intensities[3] = { 1, 0.8, 1 };
- CHECK(i < 3, 1);
+ CHK(i < 3);
(void)ctx;
*wlen = wavelengths[i];
*data = intensities[i];
@@ -78,28 +78,28 @@ main(int argc, char** argv)
mem_init_proxy_allocator(&allocator, &mem_default_allocator);
- CHECK(ssol_device_create
- (NULL, &allocator, SSOL_NTHREADS_DEFAULT, 0, &dev), RES_OK);
+ CHK(ssol_device_create
+ (NULL, &allocator, SSOL_NTHREADS_DEFAULT, 0, &dev) == RES_OK);
- CHECK(ssp_rng_create(&allocator, &ssp_rng_threefry, &rng), RES_OK);
- CHECK(ssol_spectrum_create(dev, &spectrum), RES_OK);
- CHECK(ssol_spectrum_setup(spectrum, get_wlen, 3, NULL), RES_OK);
- CHECK(ssol_sun_create_directional(dev, &sun), RES_OK);
- CHECK(ssol_sun_set_direction(sun, d3(dir, 1, 0, -1)), RES_OK);
- CHECK(ssol_sun_set_spectrum(sun, spectrum), RES_OK);
- CHECK(ssol_sun_set_dni(sun, 1000), RES_OK);
- CHECK(ssol_scene_create(dev, &scene), RES_OK);
- CHECK(ssol_scene_attach_sun(scene, sun), RES_OK);
+ CHK(ssp_rng_create(&allocator, &ssp_rng_threefry, &rng) == RES_OK);
+ CHK(ssol_spectrum_create(dev, &spectrum) == RES_OK);
+ CHK(ssol_spectrum_setup(spectrum, get_wlen, 3, NULL) == RES_OK);
+ CHK(ssol_sun_create_directional(dev, &sun) == RES_OK);
+ CHK(ssol_sun_set_direction(sun, d3(dir, 1, 0, -1)) == RES_OK);
+ CHK(ssol_sun_set_spectrum(sun, spectrum) == RES_OK);
+ CHK(ssol_sun_set_dni(sun, 1000) == RES_OK);
+ CHK(ssol_scene_create(dev, &scene) == RES_OK);
+ CHK(ssol_scene_attach_sun(scene, sun) == RES_OK);
/* Create scene content */
- CHECK(ssol_shape_create_mesh(dev, &square), RES_OK);
+ CHK(ssol_shape_create_mesh(dev, &square) == RES_OK);
attribs[0].usage = SSOL_POSITION;
attribs[0].get = get_position;
- CHECK(ssol_mesh_setup(square, SQUARE_NTRIS__, get_ids,
- SQUARE_NVERTS__, attribs, 1, (void*) &SQUARE_DESC__), RES_OK);
+ CHK(ssol_mesh_setup(square, SQUARE_NTRIS__, get_ids,
+ SQUARE_NVERTS__, attribs, 1, (void*) &SQUARE_DESC__) == RES_OK);
- CHECK(ssol_shape_create_punched_surface(dev, &quad_square), RES_OK);
+ CHK(ssol_shape_create_punched_surface(dev, &quad_square) == RES_OK);
carving.get = get_polygon_vertices;
carving.operation = SSOL_AND;
carving.nb_vertices = POLY_NVERTS__;
@@ -108,78 +108,78 @@ main(int argc, char** argv)
punched.nb_carvings = 1;
punched.quadric = &quadric;
punched.carvings = &carving;
- CHECK(ssol_punched_surface_setup(quad_square, &punched), RES_OK);
+ CHK(ssol_punched_surface_setup(quad_square, &punched) == RES_OK);
- CHECK(ssol_material_create_mirror(dev, &m_mtl), RES_OK);
+ CHK(ssol_material_create_mirror(dev, &m_mtl) == RES_OK);
shader.normal = get_shader_normal;
shader.reflectivity = get_shader_reflectivity;
shader.roughness = get_shader_roughness;
- 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);
- CHECK(ssol_object_add_shaded_shape(m_object, quad_square, m_mtl, m_mtl), RES_OK);
- CHECK(ssol_object_instantiate(m_object, &heliostat), RES_OK);
- CHECK(ssol_scene_attach_instance(scene, heliostat), RES_OK);
-
- CHECK(ssol_object_create(dev, &t_object), RES_OK);
- CHECK(ssol_object_add_shaded_shape(t_object, square, v_mtl, v_mtl), RES_OK);
- CHECK(ssol_object_instantiate(t_object, &target), RES_OK);
- CHECK(ssol_instance_set_transform(target, transform), RES_OK);
- CHECK(ssol_instance_set_receiver(target, SSOL_FRONT, 0), RES_OK);
- CHECK(ssol_instance_sample(target, 0), RES_OK);
- CHECK(ssol_scene_attach_instance(scene, target), RES_OK);
+ CHK(ssol_mirror_setup(m_mtl, &shader, SSOL_MICROFACET_BECKMANN) == RES_OK);
+ CHK(ssol_material_create_virtual(dev, &v_mtl) == RES_OK);
+
+ CHK(ssol_object_create(dev, &m_object) == RES_OK);
+ CHK(ssol_object_add_shaded_shape(m_object, quad_square, m_mtl, m_mtl) == RES_OK);
+ CHK(ssol_object_instantiate(m_object, &heliostat) == RES_OK);
+ CHK(ssol_scene_attach_instance(scene, heliostat) == RES_OK);
+
+ CHK(ssol_object_create(dev, &t_object) == RES_OK);
+ CHK(ssol_object_add_shaded_shape(t_object, square, v_mtl, v_mtl) == RES_OK);
+ CHK(ssol_object_instantiate(t_object, &target) == RES_OK);
+ CHK(ssol_instance_set_transform(target, transform) == RES_OK);
+ CHK(ssol_instance_set_receiver(target, SSOL_FRONT, 0) == RES_OK);
+ CHK(ssol_instance_sample(target, 0) == RES_OK);
+ CHK(ssol_scene_attach_instance(scene, target) == RES_OK);
#define N__ 10000
#define S_DNI_cos (4 * 1000 * cos(PI / 4))
#define GET_MC_RCV ssol_estimator_get_mc_receiver
#define GET_MC_SAMP_X_RCV ssol_estimator_get_mc_sampled_x_receiver
- CHECK(ssol_solve(scene, rng, N__, 0, NULL, &estimator1), RES_OK);
- CHECK(GET_MC_RCV(estimator1, target, SSOL_FRONT, &mc_rcv), RES_OK);
+ CHK(ssol_solve(scene, rng, N__, 0, NULL, &estimator1) == RES_OK);
+ CHK(GET_MC_RCV(estimator1, target, SSOL_FRONT, &mc_rcv) == RES_OK);
printf("Ir(target) = %g +/- %g\n",
mc_rcv.incoming_flux.E, mc_rcv.incoming_flux.SE);
- CHECK(ssol_instance_set_receiver(heliostat, SSOL_FRONT, 0), RES_OK);
- CHECK(eq_eps
+ CHK(ssol_instance_set_receiver(heliostat, SSOL_FRONT, 0) == RES_OK);
+ CHK(eq_eps
(mc_rcv.incoming_flux.E, S_DNI_cos,
- mc_rcv.incoming_flux.SE*3), 1);
- CHECK(ssol_solve(scene, rng, 8 * N__, 0, NULL, &estimator2), RES_OK);
- CHECK(GET_MC_RCV(estimator2, target, SSOL_FRONT, &mc_rcv), RES_OK);
+ mc_rcv.incoming_flux.SE*3));
+ CHK(ssol_solve(scene, rng, 8 * N__, 0, NULL, &estimator2) == RES_OK);
+ CHK(GET_MC_RCV(estimator2, target, SSOL_FRONT, &mc_rcv) == RES_OK);
printf("Ir(target) = %g +/- %g\n",
mc_rcv.incoming_flux.E, mc_rcv.incoming_flux.SE);
- CHECK(eq_eps(mc_rcv.incoming_flux.E, S_DNI_cos, mc_rcv.incoming_flux.SE*3), 1);
- CHECK(ssol_estimator_ref_put(estimator1), RES_OK);
- CHECK(ssol_solve(scene, rng, 3 * N__, 0, NULL, &estimator1), RES_OK);
- CHECK(GET_MC_RCV(estimator1, target, SSOL_FRONT, &mc_rcv), RES_OK);
+ CHK(eq_eps(mc_rcv.incoming_flux.E, S_DNI_cos, mc_rcv.incoming_flux.SE*3) == 1);
+ CHK(ssol_estimator_ref_put(estimator1) == RES_OK);
+ CHK(ssol_solve(scene, rng, 3 * N__, 0, NULL, &estimator1) == RES_OK);
+ CHK(GET_MC_RCV(estimator1, target, SSOL_FRONT, &mc_rcv) == RES_OK);
printf("Ir(target) = %g +/- %g\n",
mc_rcv.incoming_flux.E, mc_rcv.incoming_flux.SE);
- CHECK(eq_eps
+ CHK(eq_eps
(mc_rcv.incoming_flux.E, S_DNI_cos,
- mc_rcv.incoming_flux.SE*3), 1);
- CHECK(GET_MC_SAMP_X_RCV(estimator1, heliostat, target, SSOL_FRONT, &mc_rcv), RES_OK);
+ mc_rcv.incoming_flux.SE*3));
+ CHK(GET_MC_SAMP_X_RCV(estimator1, heliostat, target, SSOL_FRONT, &mc_rcv) == RES_OK);
printf("Ir(heliostat=>target) = %g +/- %g\n",
mc_rcv.incoming_flux.E, mc_rcv.incoming_flux.SE);
- CHECK(eq_eps(mc_rcv.incoming_flux.E, S_DNI_cos, mc_rcv.incoming_flux.SE*3), 1);
+ CHK(eq_eps(mc_rcv.incoming_flux.E, S_DNI_cos, mc_rcv.incoming_flux.SE*3) == 1);
/* Free data */
- CHECK(ssol_instance_ref_put(heliostat), RES_OK);
- CHECK(ssol_instance_ref_put(target), RES_OK);
- CHECK(ssol_object_ref_put(m_object), RES_OK);
- CHECK(ssol_object_ref_put(t_object), RES_OK);
- CHECK(ssol_shape_ref_put(square), RES_OK);
- CHECK(ssol_shape_ref_put(quad_square), RES_OK);
- CHECK(ssol_material_ref_put(m_mtl), RES_OK);
- CHECK(ssol_material_ref_put(v_mtl), RES_OK);
- CHECK(ssol_device_ref_put(dev), RES_OK);
- CHECK(ssol_estimator_ref_put(estimator1), RES_OK);
- CHECK(ssol_estimator_ref_put(estimator2), RES_OK);
- CHECK(ssol_scene_ref_put(scene), RES_OK);
- CHECK(ssp_rng_ref_put(rng), RES_OK);
- CHECK(ssol_spectrum_ref_put(spectrum), RES_OK);
- CHECK(ssol_sun_ref_put(sun), RES_OK);
+ CHK(ssol_instance_ref_put(heliostat) == RES_OK);
+ CHK(ssol_instance_ref_put(target) == RES_OK);
+ CHK(ssol_object_ref_put(m_object) == RES_OK);
+ CHK(ssol_object_ref_put(t_object) == RES_OK);
+ CHK(ssol_shape_ref_put(square) == RES_OK);
+ CHK(ssol_shape_ref_put(quad_square) == RES_OK);
+ CHK(ssol_material_ref_put(m_mtl) == RES_OK);
+ CHK(ssol_material_ref_put(v_mtl) == RES_OK);
+ CHK(ssol_device_ref_put(dev) == RES_OK);
+ CHK(ssol_estimator_ref_put(estimator1) == RES_OK);
+ CHK(ssol_estimator_ref_put(estimator2) == RES_OK);
+ CHK(ssol_scene_ref_put(scene) == RES_OK);
+ CHK(ssp_rng_ref_put(rng) == RES_OK);
+ CHK(ssol_spectrum_ref_put(spectrum) == RES_OK);
+ CHK(ssol_sun_ref_put(sun) == RES_OK);
check_memory_allocator(&allocator);
mem_shutdown_proxy_allocator(&allocator);
- CHECK(mem_allocated_size(), 0);
+ CHK(mem_allocated_size() == 0);
return 0;
}
diff --git a/src/test_ssol_camera.c b/src/test_ssol_camera.c
@@ -29,66 +29,66 @@ main(int argc, char** argv)
double up[3] = {0};
(void)argc, (void)argv;
- CHECK(mem_init_proxy_allocator(&allocator, &mem_default_allocator), RES_OK);
+ CHK(mem_init_proxy_allocator(&allocator, &mem_default_allocator) == RES_OK);
- CHECK(ssol_device_create
- (NULL, &allocator, SSOL_NTHREADS_DEFAULT, 0, &dev), RES_OK);
+ CHK(ssol_device_create
+ (NULL, &allocator, SSOL_NTHREADS_DEFAULT, 0, &dev) == RES_OK);
- CHECK(ssol_camera_create(NULL, NULL), RES_BAD_ARG);
- CHECK(ssol_camera_create(dev, NULL), RES_BAD_ARG);
- CHECK(ssol_camera_create(NULL, &cam), RES_BAD_ARG);
- CHECK(ssol_camera_create(dev, &cam), RES_OK);
+ CHK(ssol_camera_create(NULL, NULL) == RES_BAD_ARG);
+ CHK(ssol_camera_create(dev, NULL) == RES_BAD_ARG);
+ CHK(ssol_camera_create(NULL, &cam) == RES_BAD_ARG);
+ CHK(ssol_camera_create(dev, &cam) == RES_OK);
- CHECK(ssol_camera_ref_get(NULL), RES_BAD_ARG);
- CHECK(ssol_camera_ref_get(cam), RES_OK);
- CHECK(ssol_camera_ref_put(NULL), RES_BAD_ARG);
- CHECK(ssol_camera_ref_put(cam), RES_OK);
- CHECK(ssol_camera_ref_put(cam), RES_OK);
+ CHK(ssol_camera_ref_get(NULL) == RES_BAD_ARG);
+ CHK(ssol_camera_ref_get(cam) == RES_OK);
+ CHK(ssol_camera_ref_put(NULL) == RES_BAD_ARG);
+ CHK(ssol_camera_ref_put(cam) == RES_OK);
+ CHK(ssol_camera_ref_put(cam) == RES_OK);
- CHECK(ssol_camera_create(dev, &cam), RES_OK);
- CHECK(ssol_camera_set_proj_ratio(NULL, 0), RES_BAD_ARG);
- CHECK(ssol_camera_set_proj_ratio(cam, 0), RES_BAD_ARG);
- CHECK(ssol_camera_set_proj_ratio(NULL, 4.0/3.0), RES_BAD_ARG);
- CHECK(ssol_camera_set_proj_ratio(cam, 4.0/3.0), RES_OK);
- CHECK(ssol_camera_set_proj_ratio(cam, -4.0/3.0), RES_BAD_ARG);
+ CHK(ssol_camera_create(dev, &cam) == RES_OK);
+ CHK(ssol_camera_set_proj_ratio(NULL, 0) == RES_BAD_ARG);
+ CHK(ssol_camera_set_proj_ratio(cam, 0) == RES_BAD_ARG);
+ CHK(ssol_camera_set_proj_ratio(NULL, 4.0/3.0) == RES_BAD_ARG);
+ CHK(ssol_camera_set_proj_ratio(cam, 4.0/3.0) == RES_OK);
+ CHK(ssol_camera_set_proj_ratio(cam, -4.0/3.0) == RES_BAD_ARG);
- CHECK(ssol_camera_set_fov(NULL, 0), RES_BAD_ARG);
- CHECK(ssol_camera_set_fov(cam, 0), RES_BAD_ARG);
- CHECK(ssol_camera_set_fov(NULL, PI/4.0), RES_BAD_ARG);
- CHECK(ssol_camera_set_fov(cam, PI/4.0), RES_OK);
- CHECK(ssol_camera_set_fov(cam, -PI/4.0), RES_BAD_ARG);
+ CHK(ssol_camera_set_fov(NULL, 0) == RES_BAD_ARG);
+ CHK(ssol_camera_set_fov(cam, 0) == RES_BAD_ARG);
+ CHK(ssol_camera_set_fov(NULL, PI/4.0) == RES_BAD_ARG);
+ CHK(ssol_camera_set_fov(cam, PI/4.0) == RES_OK);
+ CHK(ssol_camera_set_fov(cam, -PI/4.0) == RES_BAD_ARG);
pos[0] = 0, pos[1] = 0, pos[2] = 0;
tgt[0] = 0, tgt[1] = 0, tgt[2] = -1;
up[0] = 0, up[1] = 1, up[2] = 0;
- CHECK(ssol_camera_look_at(NULL, NULL, NULL, NULL), RES_BAD_ARG);
- CHECK(ssol_camera_look_at(cam, NULL, NULL, NULL), RES_BAD_ARG);
- CHECK(ssol_camera_look_at(NULL, pos, NULL, NULL), RES_BAD_ARG);
- CHECK(ssol_camera_look_at(cam, pos, NULL, NULL), RES_BAD_ARG);
- CHECK(ssol_camera_look_at(NULL, NULL, tgt, NULL), RES_BAD_ARG);
- CHECK(ssol_camera_look_at(cam, NULL, tgt, NULL), RES_BAD_ARG);
- CHECK(ssol_camera_look_at(NULL, pos, tgt, NULL), RES_BAD_ARG);
- CHECK(ssol_camera_look_at(cam, pos, tgt, NULL), RES_BAD_ARG);
- CHECK(ssol_camera_look_at(NULL, NULL, NULL, up), RES_BAD_ARG);
- CHECK(ssol_camera_look_at(cam, NULL, NULL, up), RES_BAD_ARG);
- CHECK(ssol_camera_look_at(NULL, pos, NULL, up), RES_BAD_ARG);
- CHECK(ssol_camera_look_at(cam, pos, NULL, up), RES_BAD_ARG);
- CHECK(ssol_camera_look_at(NULL, NULL, tgt, up), RES_BAD_ARG);
- CHECK(ssol_camera_look_at(cam, NULL, tgt, up), RES_BAD_ARG);
- CHECK(ssol_camera_look_at(NULL, pos, tgt, up), RES_BAD_ARG);
- CHECK(ssol_camera_look_at(cam, pos, tgt, up), RES_OK);
+ CHK(ssol_camera_look_at(NULL, NULL, NULL, NULL) == RES_BAD_ARG);
+ CHK(ssol_camera_look_at(cam, NULL, NULL, NULL) == RES_BAD_ARG);
+ CHK(ssol_camera_look_at(NULL, pos, NULL, NULL) == RES_BAD_ARG);
+ CHK(ssol_camera_look_at(cam, pos, NULL, NULL) == RES_BAD_ARG);
+ CHK(ssol_camera_look_at(NULL, NULL, tgt, NULL) == RES_BAD_ARG);
+ CHK(ssol_camera_look_at(cam, NULL, tgt, NULL) == RES_BAD_ARG);
+ CHK(ssol_camera_look_at(NULL, pos, tgt, NULL) == RES_BAD_ARG);
+ CHK(ssol_camera_look_at(cam, pos, tgt, NULL) == RES_BAD_ARG);
+ CHK(ssol_camera_look_at(NULL, NULL, NULL, up) == RES_BAD_ARG);
+ CHK(ssol_camera_look_at(cam, NULL, NULL, up) == RES_BAD_ARG);
+ CHK(ssol_camera_look_at(NULL, pos, NULL, up) == RES_BAD_ARG);
+ CHK(ssol_camera_look_at(cam, pos, NULL, up) == RES_BAD_ARG);
+ CHK(ssol_camera_look_at(NULL, NULL, tgt, up) == RES_BAD_ARG);
+ CHK(ssol_camera_look_at(cam, NULL, tgt, up) == RES_BAD_ARG);
+ CHK(ssol_camera_look_at(NULL, pos, tgt, up) == RES_BAD_ARG);
+ CHK(ssol_camera_look_at(cam, pos, tgt, up) == RES_OK);
tgt[0] = 0, tgt[1] = 0, tgt[2] = 0;
- CHECK(ssol_camera_look_at(cam, pos, tgt, up), RES_BAD_ARG);
+ CHK(ssol_camera_look_at(cam, pos, tgt, up) == RES_BAD_ARG);
tgt[0] = 0, tgt[1] = 0, tgt[2] = -1;
up[0] = 0, up[1] = 0, up[2] = 0;
- CHECK(ssol_camera_look_at(cam, pos, tgt, up), RES_BAD_ARG);
+ CHK(ssol_camera_look_at(cam, pos, tgt, up) == RES_BAD_ARG);
- CHECK(ssol_device_ref_put(dev), RES_OK);
- CHECK(ssol_camera_ref_put(cam), RES_OK);
+ CHK(ssol_device_ref_put(dev) == RES_OK);
+ CHK(ssol_camera_ref_put(cam) == RES_OK);
check_memory_allocator(&allocator);
mem_shutdown_proxy_allocator(&allocator);
- CHECK(mem_allocated_size(), 0);
+ CHK(mem_allocated_size() == 0);
return 0;
}
diff --git a/src/test_ssol_data.c b/src/test_ssol_data.c
@@ -21,8 +21,8 @@
static void
get_wlen(const size_t i, double* wlen, double* data, void* ctx)
{
- NCHECK(wlen, NULL);
- NCHECK(data, NULL);
+ CHK(wlen != NULL);
+ CHK(data != NULL);
*wlen = (double)(i+1);
*data = (double)(i+2);
(void)ctx;
@@ -38,48 +38,48 @@ main(int argc, char** argv)
size_t i;
(void)argc, (void)argv;
- CHECK(mem_init_proxy_allocator(&allocator, &mem_default_allocator), RES_OK);
+ CHK(mem_init_proxy_allocator(&allocator, &mem_default_allocator) == RES_OK);
- CHECK(ssol_device_create
- (NULL, &allocator, SSOL_NTHREADS_DEFAULT, 0, &dev), RES_OK);
- CHECK(ssol_spectrum_create(dev, &spectrum), RES_OK);
- CHECK(ssol_spectrum_setup(spectrum, get_wlen, 10, NULL), RES_OK);
+ CHK(ssol_device_create
+ (NULL, &allocator, SSOL_NTHREADS_DEFAULT, 0, &dev) == RES_OK);
+ CHK(ssol_spectrum_create(dev, &spectrum) == RES_OK);
+ CHK(ssol_spectrum_setup(spectrum, get_wlen, 10, NULL) == RES_OK);
- CHECK(ssol_data_get_value(&data, 1), ssol_data_get_value(&SSOL_DATA_NULL, 1));
- CHECK(ssol_data_get_value(&data, 4), ssol_data_get_value(&SSOL_DATA_NULL, 4));
- CHECK(ssol_data_get_value(&data, 2), ssol_data_get_value(&SSOL_DATA_NULL, 2));
- CHECK(ssol_data_get_value(&data, 7), ssol_data_get_value(&SSOL_DATA_NULL, 7));
+ CHK(ssol_data_get_value(&data, 1) == ssol_data_get_value(&SSOL_DATA_NULL, 1));
+ CHK(ssol_data_get_value(&data, 4) == ssol_data_get_value(&SSOL_DATA_NULL, 4));
+ CHK(ssol_data_get_value(&data, 2) == ssol_data_get_value(&SSOL_DATA_NULL, 2));
+ CHK(ssol_data_get_value(&data, 7) == ssol_data_get_value(&SSOL_DATA_NULL, 7));
- CHECK(ssol_data_set_real(&data, 1.25), &data);
- CHECK(ssol_data_get_value(&data, 1), 1.25);
- CHECK(ssol_data_get_value(&data, 1.234), 1.25);
- CHECK(data.type, SSOL_DATA_REAL);
- CHECK(data.value.real, 1.25);
+ CHK(ssol_data_set_real(&data, 1.25) == &data);
+ CHK(ssol_data_get_value(&data, 1) == 1.25);
+ CHK(ssol_data_get_value(&data, 1.234) == 1.25);
+ CHK(data.type == SSOL_DATA_REAL);
+ CHK(data.value.real == 1.25);
- CHECK(ssol_data_set_spectrum(&data, spectrum), &data);
- CHECK(ssol_data_set_spectrum(&data, spectrum), &data);
+ CHK(ssol_data_set_spectrum(&data, spectrum) == &data);
+ CHK(ssol_data_set_spectrum(&data, spectrum) == &data);
- CHECK(data.type, SSOL_DATA_SPECTRUM);
- CHECK(data.value.spectrum, spectrum);
- CHECK(ssol_spectrum_ref_put(spectrum), RES_OK);
+ CHK(data.type == SSOL_DATA_SPECTRUM);
+ CHK(data.value.spectrum == spectrum);
+ CHK(ssol_spectrum_ref_put(spectrum) == RES_OK);
FOR_EACH(i, 0, 10) {
- CHECK(ssol_data_get_value(&data, (double)(i+1)), (double)(i+2));
+ CHK(ssol_data_get_value(&data, (double)(i+1)) == (double)(i+2));
}
- CHECK(eq_eps(ssol_data_get_value(&data, 1.5), 2.5, 1.e-6), 1);
- CHECK(eq_eps(ssol_data_get_value(&data, 1.25), 2.25, 1.e-6), 1);
- CHECK(ssol_data_get_value(&data, 0.5), 2);
- CHECK(ssol_data_get_value(&data, 0.1), 2);
- CHECK(ssol_data_get_value(&data, 10), 11);
- CHECK(ssol_data_get_value(&data, 10.1), 11);
+ CHK(eq_eps(ssol_data_get_value(&data, 1.5), 2.5, 1.e-6) == 1);
+ CHK(eq_eps(ssol_data_get_value(&data, 1.25), 2.25, 1.e-6) == 1);
+ CHK(ssol_data_get_value(&data, 0.5) == 2);
+ CHK(ssol_data_get_value(&data, 0.1) == 2);
+ CHK(ssol_data_get_value(&data, 10) == 11);
+ CHK(ssol_data_get_value(&data, 10.1) == 11);
- CHECK(ssol_device_ref_put(dev), RES_OK);
+ CHK(ssol_device_ref_put(dev) == RES_OK);
ssol_data_clear(&data);
check_memory_allocator(&allocator);
mem_shutdown_proxy_allocator(&allocator);
- CHECK(mem_allocated_size(), 0);
+ CHK(mem_allocated_size() == 0);
return 0;
}
diff --git a/src/test_ssol_device.c b/src/test_ssol_device.c
@@ -34,47 +34,47 @@ main(int argc, char** argv)
struct ssol_device* dev;
(void)argc, (void)argv;
- CHECK(ssol_device_create(NULL, NULL, 0, 0, NULL), RES_BAD_ARG);
- CHECK(ssol_device_create(NULL, NULL, SSOL_NTHREADS_DEFAULT, 0, &dev), RES_OK);
+ CHK(ssol_device_create(NULL, NULL, 0, 0, NULL) == RES_BAD_ARG);
+ CHK(ssol_device_create(NULL, NULL, SSOL_NTHREADS_DEFAULT, 0, &dev) == RES_OK);
- CHECK(ssol_device_ref_get(NULL), RES_BAD_ARG);
- CHECK(ssol_device_ref_get(dev), RES_OK);
- CHECK(ssol_device_ref_put(NULL), RES_BAD_ARG);
- CHECK(ssol_device_ref_put(dev), RES_OK);
- CHECK(ssol_device_ref_put(dev), RES_OK);
+ CHK(ssol_device_ref_get(NULL) == RES_BAD_ARG);
+ CHK(ssol_device_ref_get(dev) == RES_OK);
+ CHK(ssol_device_ref_put(NULL) == RES_BAD_ARG);
+ CHK(ssol_device_ref_put(dev) == RES_OK);
+ CHK(ssol_device_ref_put(dev) == RES_OK);
mem_init_proxy_allocator(&allocator, &mem_default_allocator);
- CHECK(MEM_ALLOCATED_SIZE(&allocator), 0);
- CHECK(ssol_device_create(NULL, &allocator, 2, 0, NULL), RES_BAD_ARG);
- CHECK(ssol_device_create
- (NULL, &allocator, SSOL_NTHREADS_DEFAULT, 0, &dev), RES_OK);
- CHECK(ssol_device_ref_put(dev), RES_OK);
- CHECK(MEM_ALLOCATED_SIZE(&allocator), 0);
+ CHK(MEM_ALLOCATED_SIZE(&allocator) == 0);
+ CHK(ssol_device_create(NULL, &allocator, 2, 0, NULL) == RES_BAD_ARG);
+ CHK(ssol_device_create
+ (NULL, &allocator, SSOL_NTHREADS_DEFAULT, 0, &dev) == RES_OK);
+ CHK(ssol_device_ref_put(dev) == RES_OK);
+ CHK(MEM_ALLOCATED_SIZE(&allocator) == 0);
- CHECK(logger_init(&allocator, &logger), RES_OK);
+ CHK(logger_init(&allocator, &logger) == RES_OK);
logger_set_stream(&logger, LOG_OUTPUT, log_stream, NULL);
logger_set_stream(&logger, LOG_ERROR, log_stream, NULL);
logger_set_stream(&logger, LOG_WARNING, log_stream, NULL);
- CHECK(ssol_device_create(&logger, NULL, 4, 0, NULL), RES_BAD_ARG);
- CHECK(ssol_device_create
- (&logger, NULL, SSOL_NTHREADS_DEFAULT, 0, &dev), RES_OK);
- CHECK(ssol_device_ref_put(dev), RES_OK);
+ CHK(ssol_device_create(&logger, NULL, 4, 0, NULL) == RES_BAD_ARG);
+ CHK(ssol_device_create
+ (&logger, NULL, SSOL_NTHREADS_DEFAULT, 0, &dev) == RES_OK);
+ CHK(ssol_device_ref_put(dev) == RES_OK);
- CHECK(ssol_device_create(&logger, &allocator, 2, 0, NULL), RES_BAD_ARG);
- CHECK(ssol_device_create
- (&logger, &allocator, SSOL_NTHREADS_DEFAULT, 0, &dev), RES_OK);
- CHECK(ssol_device_ref_put(dev), RES_OK);
+ CHK(ssol_device_create(&logger, &allocator, 2, 0, NULL) == RES_BAD_ARG);
+ CHK(ssol_device_create
+ (&logger, &allocator, SSOL_NTHREADS_DEFAULT, 0, &dev) == RES_OK);
+ CHK(ssol_device_ref_put(dev) == RES_OK);
- CHECK(ssol_device_create(&logger, &allocator, 0, 0, &dev), RES_BAD_ARG);
- CHECK(ssol_device_create
- (&logger, &allocator, SSOL_NTHREADS_DEFAULT, 0, &dev), RES_OK);
- CHECK(ssol_device_ref_put(dev), RES_OK);
+ CHK(ssol_device_create(&logger, &allocator, 0, 0, &dev) == RES_BAD_ARG);
+ CHK(ssol_device_create
+ (&logger, &allocator, SSOL_NTHREADS_DEFAULT, 0, &dev) == RES_OK);
+ CHK(ssol_device_ref_put(dev) == RES_OK);
logger_release(&logger);
check_memory_allocator(&allocator);
mem_shutdown_proxy_allocator(&allocator);
- CHECK(mem_allocated_size(), 0);
+ CHK(mem_allocated_size() == 0);
return 0;
}
diff --git a/src/test_ssol_draw.c b/src/test_ssol_draw.c
@@ -35,7 +35,7 @@ get_wlen(const size_t i, double* wlen, double* data, void* ctx)
{
double wavelengths[3] = { 1, 2, 3 };
double intensities[3] = { 1, 0.8, 1 };
- CHECK(i < 3, 1);
+ CHK(i < 3);
(void)ctx;
*wlen = wavelengths[i];
*data = intensities[i];
@@ -54,8 +54,8 @@ write_RGB8
size_t src_pitch = ssol_sizeof_pixel_format(fmt) * sz[0];
size_t x, y;
- CHECK(org[0] + sz[0] <= WIDTH, 1);
- CHECK(org[1] + sz[1] <= HEIGHT, 1);
+ CHK(org[0] + sz[0] <= WIDTH);
+ CHK(org[1] + sz[1] <= HEIGHT);
FOR_EACH(y, 0, sz[1]) {
unsigned char* row_dst = img + (y + org[1]) * PITCH;
@@ -136,8 +136,8 @@ 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_setup(mtl, &shader), RES_OK);
+ CHK(ssol_material_create_matte(dev, &mtl) == RES_OK);
+ CHK(ssol_matte_setup(mtl, &shader) == RES_OK);
vdata.usage = SSOL_POSITION;
vdata.get = get_position;
@@ -145,45 +145,45 @@ setup_cornell_box(struct ssol_device* dev, struct ssol_scene* scn)
desc.vertices = walls;
desc.indices = walls_ids;
- CHECK(ssol_shape_create_mesh(dev, &shape), RES_OK);
- CHECK(ssol_mesh_setup(shape, 10, get_ids, 8, &vdata, 1, &desc), RES_OK);
- CHECK(ssol_object_create(dev, &obj), RES_OK);
- CHECK(ssol_object_add_shaded_shape(obj, shape, mtl, mtl), RES_OK);
- CHECK(ssol_object_instantiate(obj, &inst), RES_OK);
- CHECK(ssol_scene_attach_instance(scn, inst), RES_OK);
- CHECK(ssol_instance_ref_put(inst), RES_OK);
- CHECK(ssol_shape_ref_put(shape), RES_OK);
- CHECK(ssol_object_ref_put(obj), RES_OK);
+ CHK(ssol_shape_create_mesh(dev, &shape) == RES_OK);
+ CHK(ssol_mesh_setup(shape, 10, get_ids, 8, &vdata, 1, &desc) == RES_OK);
+ CHK(ssol_object_create(dev, &obj) == RES_OK);
+ CHK(ssol_object_add_shaded_shape(obj, shape, mtl, mtl) == RES_OK);
+ CHK(ssol_object_instantiate(obj, &inst) == RES_OK);
+ CHK(ssol_scene_attach_instance(scn, inst) == RES_OK);
+ CHK(ssol_instance_ref_put(inst) == RES_OK);
+ CHK(ssol_shape_ref_put(shape) == RES_OK);
+ CHK(ssol_object_ref_put(obj) == RES_OK);
desc.vertices = short_block;
desc.indices = block_ids;
- CHECK(ssol_shape_create_mesh(dev, &shape), RES_OK);
- CHECK(ssol_mesh_setup(shape, 10, get_ids, 8, &vdata, 1, &desc), RES_OK);
- CHECK(ssol_object_create(dev, &obj), RES_OK);
- CHECK(ssol_object_add_shaded_shape(obj, shape, mtl, mtl), RES_OK);
- CHECK(ssol_object_instantiate(obj, &inst), RES_OK);
- CHECK(ssol_scene_attach_instance(scn, inst), RES_OK);
- CHECK(ssol_instance_ref_put(inst), RES_OK);
- CHECK(ssol_shape_ref_put(shape), RES_OK);
- CHECK(ssol_object_ref_put(obj), RES_OK);
+ CHK(ssol_shape_create_mesh(dev, &shape) == RES_OK);
+ CHK(ssol_mesh_setup(shape, 10, get_ids, 8, &vdata, 1, &desc) == RES_OK);
+ CHK(ssol_object_create(dev, &obj) == RES_OK);
+ CHK(ssol_object_add_shaded_shape(obj, shape, mtl, mtl) == RES_OK);
+ CHK(ssol_object_instantiate(obj, &inst) == RES_OK);
+ CHK(ssol_scene_attach_instance(scn, inst) == RES_OK);
+ CHK(ssol_instance_ref_put(inst) == RES_OK);
+ CHK(ssol_shape_ref_put(shape) == RES_OK);
+ CHK(ssol_object_ref_put(obj) == RES_OK);
desc.vertices = tall_block;
desc.indices = block_ids;
- CHECK(ssol_shape_create_mesh(dev, &shape), RES_OK);
- CHECK(ssol_mesh_setup(shape, 10, get_ids, 8, &vdata, 1, &desc), RES_OK);
- CHECK(ssol_object_create(dev, &obj), RES_OK);
- CHECK(ssol_object_add_shaded_shape(obj, shape, mtl, mtl), RES_OK);
- CHECK(ssol_object_instantiate(obj, &inst), RES_OK);
- CHECK(ssol_scene_attach_instance(scn, inst), RES_OK);
- CHECK(ssol_instance_ref_put(inst), RES_OK);
- CHECK(ssol_shape_ref_put(shape), RES_OK);
- CHECK(ssol_object_ref_put(obj), RES_OK);
-
- CHECK(ssol_material_ref_put(mtl), RES_OK);
-
- CHECK(ssol_scene_compute_aabb(scn, lower, upper), RES_OK);
- CHECK(f3_eq_eps(lower, f3(tmp, 0, 0, 0), 1.e-6f), 1);
- CHECK(f3_eq_eps(upper, f3(tmp, 552.f, 559.f, 548.f), 1.e-6f), 1);
+ CHK(ssol_shape_create_mesh(dev, &shape) == RES_OK);
+ CHK(ssol_mesh_setup(shape, 10, get_ids, 8, &vdata, 1, &desc) == RES_OK);
+ CHK(ssol_object_create(dev, &obj) == RES_OK);
+ CHK(ssol_object_add_shaded_shape(obj, shape, mtl, mtl) == RES_OK);
+ CHK(ssol_object_instantiate(obj, &inst) == RES_OK);
+ CHK(ssol_scene_attach_instance(scn, inst) == RES_OK);
+ CHK(ssol_instance_ref_put(inst) == RES_OK);
+ CHK(ssol_shape_ref_put(shape) == RES_OK);
+ CHK(ssol_object_ref_put(obj) == RES_OK);
+
+ CHK(ssol_material_ref_put(mtl) == RES_OK);
+
+ CHK(ssol_scene_compute_aabb(scn, lower, upper) == RES_OK);
+ CHK(f3_eq_eps(lower, f3(tmp, 0, 0, 0), 1.e-6f) == 1);
+ CHK(f3_eq_eps(upper, f3(tmp, 552.f, 559.f, 548.f), 1.e-6f) == 1);
}
@@ -242,121 +242,121 @@ main(int argc, char** argv)
return -1;
}
- CHECK(mem_init_proxy_allocator(&allocator, &mem_default_allocator), RES_OK);
+ CHK(mem_init_proxy_allocator(&allocator, &mem_default_allocator) == RES_OK);
- CHECK(ssol_device_create
- (NULL, &allocator, SSOL_NTHREADS_DEFAULT, 0, &dev), RES_OK);
+ CHK(ssol_device_create
+ (NULL, &allocator, SSOL_NTHREADS_DEFAULT, 0, &dev) == RES_OK);
- CHECK(ssol_scene_create(dev, &scn), RES_OK);
+ CHK(ssol_scene_create(dev, &scn) == RES_OK);
setup_cornell_box(dev, scn);
- CHECK(ssol_camera_create(dev, &cam), RES_OK);
- CHECK(ssol_camera_set_proj_ratio(cam, PROJ_RATIO), RES_OK);
- CHECK(ssol_camera_set_fov(cam, PI/4.0), RES_OK);
- CHECK(ssol_camera_look_at(cam, pos, tgt, up), RES_OK);
+ CHK(ssol_camera_create(dev, &cam) == RES_OK);
+ CHK(ssol_camera_set_proj_ratio(cam, PROJ_RATIO) == RES_OK);
+ CHK(ssol_camera_set_fov(cam, PI/4.0) == RES_OK);
+ CHK(ssol_camera_look_at(cam, pos, tgt, up) == RES_OK);
d3(dir, 1, 1, -1);
d3_normalize(dir, dir);
- CHECK(ssol_sun_create_directional(dev, &sun), RES_OK);
- CHECK(ssol_sun_set_direction(sun, dir), RES_OK);
- CHECK(ssol_sun_set_dni(sun, 1000), RES_OK);
- CHECK(ssol_scene_attach_sun(scn, sun), RES_OK);
+ CHK(ssol_sun_create_directional(dev, &sun) == RES_OK);
+ CHK(ssol_sun_set_direction(sun, dir) == RES_OK);
+ CHK(ssol_sun_set_dni(sun, 1000) == RES_OK);
+ CHK(ssol_scene_attach_sun(scn, sun) == RES_OK);
pitch = WIDTH * sizeof_image_format(IMAGE_RGB8);
image_init(&allocator, &img);
image_setup(&img, WIDTH, HEIGHT, pitch, IMAGE_RGB8, NULL);
pixels = (uint8_t*)img.pixels;
- CHECK(draw_func(NULL, NULL, 0, 0, 0, NULL, pixels), RES_BAD_ARG);
- CHECK(draw_func(scn, NULL, 0, 0, 0, NULL, pixels), RES_BAD_ARG);
- CHECK(draw_func(NULL, cam, 0, 0, 0, NULL, pixels), RES_BAD_ARG);
- CHECK(draw_func(scn, cam, 0, 0, 0, NULL, pixels), RES_BAD_ARG);
- CHECK(draw_func(NULL, NULL, WIDTH, 0, 0, NULL, pixels), RES_BAD_ARG);
- CHECK(draw_func(scn, NULL, WIDTH, 0, 0, NULL, pixels), RES_BAD_ARG);
- CHECK(draw_func(NULL, cam, WIDTH, 0, 0, NULL, pixels), RES_BAD_ARG);
- CHECK(draw_func(scn, cam, WIDTH, 0, 0, NULL, pixels), RES_BAD_ARG);
- CHECK(draw_func(NULL, NULL, 0, HEIGHT, 0, NULL, pixels), RES_BAD_ARG);
- CHECK(draw_func(scn, NULL, 0, HEIGHT, 0, NULL, pixels), RES_BAD_ARG);
- CHECK(draw_func(NULL, cam, 0, HEIGHT, 0, NULL, pixels), RES_BAD_ARG);
- CHECK(draw_func(scn, cam, 0, HEIGHT, 0, NULL, pixels), RES_BAD_ARG);
- CHECK(draw_func(NULL, NULL, WIDTH, HEIGHT, 0, NULL, pixels), RES_BAD_ARG);
- CHECK(draw_func(scn, NULL, WIDTH, HEIGHT, 0, NULL, pixels), RES_BAD_ARG);
- CHECK(draw_func(NULL, cam, WIDTH, WIDTH, 0, NULL, pixels), RES_BAD_ARG);
- CHECK(draw_func(scn, cam, WIDTH, HEIGHT, 0, NULL, pixels), RES_BAD_ARG);
- CHECK(draw_func(NULL, NULL, 0, 0, 0, write_RGB8, pixels), RES_BAD_ARG);
- CHECK(draw_func(scn, NULL, 0, 0, 0, write_RGB8, pixels), RES_BAD_ARG);
- CHECK(draw_func(NULL, cam, 0, 0, 0, write_RGB8, pixels), RES_BAD_ARG);
- CHECK(draw_func(scn, cam, 0, 0, 0, write_RGB8, pixels), RES_BAD_ARG);
- CHECK(draw_func(NULL, NULL, WIDTH, 0, 0, write_RGB8, pixels), RES_BAD_ARG);
- CHECK(draw_func(scn, NULL, WIDTH, 0, 0, write_RGB8, pixels), RES_BAD_ARG);
- CHECK(draw_func(NULL, cam, WIDTH, 0, 0, write_RGB8, pixels), RES_BAD_ARG);
- CHECK(draw_func(scn, cam, WIDTH, 0, 0, write_RGB8, pixels), RES_BAD_ARG);
- CHECK(draw_func(NULL, NULL, 0, HEIGHT, 0, write_RGB8, pixels), RES_BAD_ARG);
- CHECK(draw_func(scn, NULL, 0, HEIGHT, 0, write_RGB8, pixels), RES_BAD_ARG);
- CHECK(draw_func(NULL, cam, 0, HEIGHT, 0, write_RGB8, pixels), RES_BAD_ARG);
- CHECK(draw_func(scn, cam, 0, HEIGHT, 0, write_RGB8, pixels), RES_BAD_ARG);
- CHECK(draw_func(NULL, NULL, WIDTH, HEIGHT, 0, write_RGB8, pixels), RES_BAD_ARG);
- CHECK(draw_func(scn, NULL, WIDTH, HEIGHT, 0, write_RGB8, pixels), RES_BAD_ARG);
- CHECK(draw_func(NULL, cam, WIDTH, WIDTH, 0, write_RGB8, pixels), RES_BAD_ARG);
- CHECK(draw_func(scn, cam, WIDTH, HEIGHT, 0, write_RGB8, pixels), RES_BAD_ARG);
- CHECK(draw_func(NULL, NULL, 0, 0, 4, NULL, pixels), RES_BAD_ARG);
- CHECK(draw_func(scn, NULL, 0, 0, 4, NULL, pixels), RES_BAD_ARG);
- CHECK(draw_func(NULL, cam, 0, 0, 4, NULL, pixels), RES_BAD_ARG);
- CHECK(draw_func(scn, cam, 0, 0, 4, NULL, pixels), RES_BAD_ARG);
- CHECK(draw_func(NULL, NULL, WIDTH, 0, 4, NULL, pixels), RES_BAD_ARG);
- CHECK(draw_func(scn, NULL, WIDTH, 0, 4, NULL, pixels), RES_BAD_ARG);
- CHECK(draw_func(NULL, cam, WIDTH, 0, 4, NULL, pixels), RES_BAD_ARG);
- CHECK(draw_func(scn, cam, WIDTH, 0, 4, NULL, pixels), RES_BAD_ARG);
- CHECK(draw_func(NULL, NULL, 0, HEIGHT, 4, NULL, pixels), RES_BAD_ARG);
- CHECK(draw_func(scn, NULL, 0, HEIGHT, 4, NULL, pixels), RES_BAD_ARG);
- CHECK(draw_func(NULL, cam, 0, HEIGHT, 4, NULL, pixels), RES_BAD_ARG);
- CHECK(draw_func(scn, cam, 0, HEIGHT, 4, NULL, pixels), RES_BAD_ARG);
- CHECK(draw_func(NULL, NULL, WIDTH, HEIGHT, 4, NULL, pixels), RES_BAD_ARG);
- CHECK(draw_func(scn, NULL, WIDTH, HEIGHT, 4, NULL, pixels), RES_BAD_ARG);
- CHECK(draw_func(NULL, cam, WIDTH, WIDTH, 4, NULL, pixels), RES_BAD_ARG);
- CHECK(draw_func(scn, cam, WIDTH, HEIGHT, 4, NULL, pixels), RES_BAD_ARG);
- CHECK(draw_func(NULL, NULL, 0, 0, 4, write_RGB8, pixels), RES_BAD_ARG);
- CHECK(draw_func(scn, NULL, 0, 0, 4, write_RGB8, pixels), RES_BAD_ARG);
- CHECK(draw_func(NULL, cam, 0, 0, 4, write_RGB8, pixels), RES_BAD_ARG);
- CHECK(draw_func(scn, cam, 0, 0, 4, write_RGB8, pixels), RES_BAD_ARG);
- CHECK(draw_func(NULL, NULL, WIDTH, 0, 4, write_RGB8, pixels), RES_BAD_ARG);
- CHECK(draw_func(scn, NULL, WIDTH, 0, 4, write_RGB8, pixels), RES_BAD_ARG);
- CHECK(draw_func(NULL, cam, WIDTH, 0, 4, write_RGB8, pixels), RES_BAD_ARG);
- CHECK(draw_func(scn, cam, WIDTH, 0, 4, write_RGB8, pixels), RES_BAD_ARG);
- CHECK(draw_func(NULL, NULL, 0, HEIGHT, 4, write_RGB8, pixels), RES_BAD_ARG);
- CHECK(draw_func(scn, NULL, 0, HEIGHT, 4, write_RGB8, pixels), RES_BAD_ARG);
- CHECK(draw_func(NULL, cam, 0, HEIGHT, 4, write_RGB8, pixels), RES_BAD_ARG);
- CHECK(draw_func(scn, cam, 0, HEIGHT, 4, write_RGB8, pixels), RES_BAD_ARG);
- CHECK(draw_func(NULL, NULL, WIDTH, HEIGHT, 4, write_RGB8, pixels), RES_BAD_ARG);
- CHECK(draw_func(scn, NULL, WIDTH, HEIGHT, 4, write_RGB8, pixels), RES_BAD_ARG);
- CHECK(draw_func(NULL, cam, WIDTH, WIDTH, 4, write_RGB8, pixels), RES_BAD_ARG);
+ CHK(draw_func(NULL, NULL, 0, 0, 0, NULL, pixels) == RES_BAD_ARG);
+ CHK(draw_func(scn, NULL, 0, 0, 0, NULL, pixels) == RES_BAD_ARG);
+ CHK(draw_func(NULL, cam, 0, 0, 0, NULL, pixels) == RES_BAD_ARG);
+ CHK(draw_func(scn, cam, 0, 0, 0, NULL, pixels) == RES_BAD_ARG);
+ CHK(draw_func(NULL, NULL, WIDTH, 0, 0, NULL, pixels) == RES_BAD_ARG);
+ CHK(draw_func(scn, NULL, WIDTH, 0, 0, NULL, pixels) == RES_BAD_ARG);
+ CHK(draw_func(NULL, cam, WIDTH, 0, 0, NULL, pixels) == RES_BAD_ARG);
+ CHK(draw_func(scn, cam, WIDTH, 0, 0, NULL, pixels) == RES_BAD_ARG);
+ CHK(draw_func(NULL, NULL, 0, HEIGHT, 0, NULL, pixels) == RES_BAD_ARG);
+ CHK(draw_func(scn, NULL, 0, HEIGHT, 0, NULL, pixels) == RES_BAD_ARG);
+ CHK(draw_func(NULL, cam, 0, HEIGHT, 0, NULL, pixels) == RES_BAD_ARG);
+ CHK(draw_func(scn, cam, 0, HEIGHT, 0, NULL, pixels) == RES_BAD_ARG);
+ CHK(draw_func(NULL, NULL, WIDTH, HEIGHT, 0, NULL, pixels) == RES_BAD_ARG);
+ CHK(draw_func(scn, NULL, WIDTH, HEIGHT, 0, NULL, pixels) == RES_BAD_ARG);
+ CHK(draw_func(NULL, cam, WIDTH, WIDTH, 0, NULL, pixels) == RES_BAD_ARG);
+ CHK(draw_func(scn, cam, WIDTH, HEIGHT, 0, NULL, pixels) == RES_BAD_ARG);
+ CHK(draw_func(NULL, NULL, 0, 0, 0, write_RGB8, pixels) == RES_BAD_ARG);
+ CHK(draw_func(scn, NULL, 0, 0, 0, write_RGB8, pixels) == RES_BAD_ARG);
+ CHK(draw_func(NULL, cam, 0, 0, 0, write_RGB8, pixels) == RES_BAD_ARG);
+ CHK(draw_func(scn, cam, 0, 0, 0, write_RGB8, pixels) == RES_BAD_ARG);
+ CHK(draw_func(NULL, NULL, WIDTH, 0, 0, write_RGB8, pixels) == RES_BAD_ARG);
+ CHK(draw_func(scn, NULL, WIDTH, 0, 0, write_RGB8, pixels) == RES_BAD_ARG);
+ CHK(draw_func(NULL, cam, WIDTH, 0, 0, write_RGB8, pixels) == RES_BAD_ARG);
+ CHK(draw_func(scn, cam, WIDTH, 0, 0, write_RGB8, pixels) == RES_BAD_ARG);
+ CHK(draw_func(NULL, NULL, 0, HEIGHT, 0, write_RGB8, pixels) == RES_BAD_ARG);
+ CHK(draw_func(scn, NULL, 0, HEIGHT, 0, write_RGB8, pixels) == RES_BAD_ARG);
+ CHK(draw_func(NULL, cam, 0, HEIGHT, 0, write_RGB8, pixels) == RES_BAD_ARG);
+ CHK(draw_func(scn, cam, 0, HEIGHT, 0, write_RGB8, pixels) == RES_BAD_ARG);
+ CHK(draw_func(NULL, NULL, WIDTH, HEIGHT, 0, write_RGB8, pixels) == RES_BAD_ARG);
+ CHK(draw_func(scn, NULL, WIDTH, HEIGHT, 0, write_RGB8, pixels) == RES_BAD_ARG);
+ CHK(draw_func(NULL, cam, WIDTH, WIDTH, 0, write_RGB8, pixels) == RES_BAD_ARG);
+ CHK(draw_func(scn, cam, WIDTH, HEIGHT, 0, write_RGB8, pixels) == RES_BAD_ARG);
+ CHK(draw_func(NULL, NULL, 0, 0, 4, NULL, pixels) == RES_BAD_ARG);
+ CHK(draw_func(scn, NULL, 0, 0, 4, NULL, pixels) == RES_BAD_ARG);
+ CHK(draw_func(NULL, cam, 0, 0, 4, NULL, pixels) == RES_BAD_ARG);
+ CHK(draw_func(scn, cam, 0, 0, 4, NULL, pixels) == RES_BAD_ARG);
+ CHK(draw_func(NULL, NULL, WIDTH, 0, 4, NULL, pixels) == RES_BAD_ARG);
+ CHK(draw_func(scn, NULL, WIDTH, 0, 4, NULL, pixels) == RES_BAD_ARG);
+ CHK(draw_func(NULL, cam, WIDTH, 0, 4, NULL, pixels) == RES_BAD_ARG);
+ CHK(draw_func(scn, cam, WIDTH, 0, 4, NULL, pixels) == RES_BAD_ARG);
+ CHK(draw_func(NULL, NULL, 0, HEIGHT, 4, NULL, pixels) == RES_BAD_ARG);
+ CHK(draw_func(scn, NULL, 0, HEIGHT, 4, NULL, pixels) == RES_BAD_ARG);
+ CHK(draw_func(NULL, cam, 0, HEIGHT, 4, NULL, pixels) == RES_BAD_ARG);
+ CHK(draw_func(scn, cam, 0, HEIGHT, 4, NULL, pixels) == RES_BAD_ARG);
+ CHK(draw_func(NULL, NULL, WIDTH, HEIGHT, 4, NULL, pixels) == RES_BAD_ARG);
+ CHK(draw_func(scn, NULL, WIDTH, HEIGHT, 4, NULL, pixels) == RES_BAD_ARG);
+ CHK(draw_func(NULL, cam, WIDTH, WIDTH, 4, NULL, pixels) == RES_BAD_ARG);
+ CHK(draw_func(scn, cam, WIDTH, HEIGHT, 4, NULL, pixels) == RES_BAD_ARG);
+ CHK(draw_func(NULL, NULL, 0, 0, 4, write_RGB8, pixels) == RES_BAD_ARG);
+ CHK(draw_func(scn, NULL, 0, 0, 4, write_RGB8, pixels) == RES_BAD_ARG);
+ CHK(draw_func(NULL, cam, 0, 0, 4, write_RGB8, pixels) == RES_BAD_ARG);
+ CHK(draw_func(scn, cam, 0, 0, 4, write_RGB8, pixels) == RES_BAD_ARG);
+ CHK(draw_func(NULL, NULL, WIDTH, 0, 4, write_RGB8, pixels) == RES_BAD_ARG);
+ CHK(draw_func(scn, NULL, WIDTH, 0, 4, write_RGB8, pixels) == RES_BAD_ARG);
+ CHK(draw_func(NULL, cam, WIDTH, 0, 4, write_RGB8, pixels) == RES_BAD_ARG);
+ CHK(draw_func(scn, cam, WIDTH, 0, 4, write_RGB8, pixels) == RES_BAD_ARG);
+ CHK(draw_func(NULL, NULL, 0, HEIGHT, 4, write_RGB8, pixels) == RES_BAD_ARG);
+ CHK(draw_func(scn, NULL, 0, HEIGHT, 4, write_RGB8, pixels) == RES_BAD_ARG);
+ CHK(draw_func(NULL, cam, 0, HEIGHT, 4, write_RGB8, pixels) == RES_BAD_ARG);
+ CHK(draw_func(scn, cam, 0, HEIGHT, 4, write_RGB8, pixels) == RES_BAD_ARG);
+ CHK(draw_func(NULL, NULL, WIDTH, HEIGHT, 4, write_RGB8, pixels) == RES_BAD_ARG);
+ CHK(draw_func(scn, NULL, WIDTH, HEIGHT, 4, write_RGB8, pixels) == RES_BAD_ARG);
+ CHK(draw_func(NULL, cam, WIDTH, WIDTH, 4, write_RGB8, pixels) == RES_BAD_ARG);
/* No sun spectrum */
- CHECK(draw_func(scn, cam, WIDTH, HEIGHT, 4, write_RGB8, pixels), RES_BAD_ARG);
+ CHK(draw_func(scn, cam, WIDTH, HEIGHT, 4, write_RGB8, pixels) == RES_BAD_ARG);
- CHECK(ssol_spectrum_create(dev, &spectrum), RES_OK);
- CHECK(ssol_spectrum_setup(spectrum, get_wlen, 3, NULL), RES_OK);
- CHECK(ssol_sun_set_spectrum(sun, spectrum), RES_OK);
- CHECK(draw_func(scn, cam, WIDTH, HEIGHT, 4, write_RGB8, pixels), RES_OK);
+ CHK(ssol_spectrum_create(dev, &spectrum) == RES_OK);
+ CHK(ssol_spectrum_setup(spectrum, get_wlen, 3, NULL) == RES_OK);
+ CHK(ssol_sun_set_spectrum(sun, spectrum) == RES_OK);
+ CHK(draw_func(scn, cam, WIDTH, HEIGHT, 4, write_RGB8, pixels) == RES_OK);
- CHECK(image_write_ppm_stream(&img, 0, stdout), RES_OK);
+ CHK(image_write_ppm_stream(&img, 0, stdout) == RES_OK);
if(draw_func == draw_pt) {
- CHECK(ssol_draw_pt
- (scn, cam, WIDTH, HEIGHT, 4, NULL, write_RGB8, pixels), RES_BAD_ARG);
+ CHK(ssol_draw_pt
+ (scn, cam, WIDTH, HEIGHT, 4, NULL, write_RGB8, pixels) == RES_BAD_ARG);
}
- CHECK(image_release(&img), RES_OK);
- CHECK(ssol_device_ref_put(dev), RES_OK);
- CHECK(ssol_camera_ref_put(cam), RES_OK);
- CHECK(ssol_scene_ref_put(scn), RES_OK);
- CHECK(ssol_spectrum_ref_put(spectrum), RES_OK);
- CHECK(ssol_sun_ref_put(sun), RES_OK);
+ CHK(image_release(&img) == RES_OK);
+ CHK(ssol_device_ref_put(dev) == RES_OK);
+ CHK(ssol_camera_ref_put(cam) == RES_OK);
+ CHK(ssol_scene_ref_put(scn) == RES_OK);
+ CHK(ssol_spectrum_ref_put(spectrum) == RES_OK);
+ CHK(ssol_sun_ref_put(sun) == RES_OK);
check_memory_allocator(&allocator);
mem_shutdown_proxy_allocator(&allocator);
- CHECK(mem_allocated_size(), 0);
+ CHK(mem_allocated_size() == 0);
return 0;
}
diff --git a/src/test_ssol_geometries.h b/src/test_ssol_geometries.h
@@ -29,8 +29,8 @@ get_ids(const unsigned itri, unsigned ids[3], void* data)
{
const unsigned id = itri * 3;
struct desc* desc = data;
- NCHECK(desc, NULL);
- NCHECK(ids, NULL);
+ CHK(desc != NULL);
+ CHK(ids != NULL);
ids[0] = desc->indices[id + 0];
ids[1] = desc->indices[id + 1];
ids[2] = desc->indices[id + 2];
@@ -40,8 +40,8 @@ static INLINE void
get_position(const unsigned ivert, float position[3], void* data)
{
struct desc* desc = data;
- NCHECK(desc, NULL);
- NCHECK(position, NULL);
+ CHK(desc != NULL);
+ CHK(position != NULL);
position[0] = desc->vertices[ivert * 3 + 0];
position[1] = desc->vertices[ivert * 3 + 1];
position[2] = desc->vertices[ivert * 3 + 2];
@@ -51,7 +51,7 @@ static INLINE void
get_normal(const unsigned ivert, float normal[3], void* data)
{
(void)ivert, (void)data;
- NCHECK(normal, NULL);
+ CHK(normal != NULL);
normal[0] = 1.f;
normal[1] = 0.f;
normal[2] = 0.f;
@@ -61,7 +61,7 @@ static INLINE void
get_uv(const unsigned ivert, float uv[2], void* data)
{
(void)ivert, (void)data;
- NCHECK(uv, NULL);
+ CHK(uv != NULL);
uv[0] = -1.f;
uv[1] = 1.f;
}
@@ -70,8 +70,8 @@ static INLINE void
get_polygon_vertices(const size_t ivert, double position[2], void* ctx)
{
const double* verts = ctx;
- NCHECK(position, NULL);
- NCHECK(ctx, NULL);
+ CHK(position != NULL);
+ CHK(ctx != NULL);
position[0] = verts[ivert*2+0];
position[1] = verts[ivert*2+1];
}
diff --git a/src/test_ssol_image.c b/src/test_ssol_image.c
@@ -31,13 +31,13 @@ check_sampling(struct ssol_device* dev)
double pix[3];
double tmp[3];
- CHECK(ssol_image_create(dev, &img), RES_OK);
- CHECK(ssol_image_setup(img, 4, 2, SSOL_PIXEL_DOUBLE3), RES_OK);
- CHECK(ssol_image_get_layout(img, &layout), RES_OK);
+ CHK(ssol_image_create(dev, &img) == RES_OK);
+ CHK(ssol_image_setup(img, 4, 2, SSOL_PIXEL_DOUBLE3) == RES_OK);
+ CHK(ssol_image_get_layout(img, &layout) == RES_OK);
pixsz = ssol_sizeof_pixel_format(layout.pixel_format);
- CHECK(ssol_image_map(img, &mem), RES_OK);
+ CHK(ssol_image_map(img, &mem) == RES_OK);
d3((double*)(mem + layout.offset + 0*pixsz + 0*layout.row_pitch), 1, 0, 0);
d3((double*)(mem + layout.offset + 1*pixsz + 0*layout.row_pitch), 1, 0, 0);
d3((double*)(mem + layout.offset + 2*pixsz + 0*layout.row_pitch), 1, 1, 0);
@@ -46,7 +46,7 @@ check_sampling(struct ssol_device* dev)
d3((double*)(mem + layout.offset + 1*pixsz + 1*layout.row_pitch), 1, 0, 1);
d3((double*)(mem + layout.offset + 2*pixsz + 1*layout.row_pitch), 0, 1, 1);
d3((double*)(mem + layout.offset + 3*pixsz + 1*layout.row_pitch), 0, 1, 1);
- CHECK(ssol_image_unmap(img), RES_OK);
+ CHK(ssol_image_unmap(img) == RES_OK);
#define CLAMPED SSOL_ADDRESS_CLAMP
#define REPEAT SSOL_ADDRESS_REPEAT
@@ -54,54 +54,54 @@ check_sampling(struct ssol_device* dev)
#define LINEAR SSOL_FILTER_LINEAR
d2_splat(uv, 0);
- CHECK(ssol_image_sample(NULL, NEAREST, CLAMPED, CLAMPED, NULL, NULL), RES_BAD_ARG);
- CHECK(ssol_image_sample(img, NEAREST, CLAMPED, CLAMPED, NULL, NULL), RES_BAD_ARG);
- CHECK(ssol_image_sample(NULL, NEAREST, CLAMPED, CLAMPED, uv, NULL), RES_BAD_ARG);
- CHECK(ssol_image_sample(img, NEAREST, CLAMPED, CLAMPED, uv, NULL), RES_BAD_ARG);
- CHECK(ssol_image_sample(NULL, NEAREST, CLAMPED, CLAMPED, NULL, pix), RES_BAD_ARG);
- CHECK(ssol_image_sample(img, NEAREST, CLAMPED, CLAMPED, NULL, pix), RES_BAD_ARG);
- CHECK(ssol_image_sample(NULL, NEAREST, CLAMPED, CLAMPED, uv, pix), RES_BAD_ARG);
- CHECK(ssol_image_sample(img, NEAREST, CLAMPED, CLAMPED, uv, pix), RES_OK);
- CHECK(d3_eq(pix, d3(tmp,1,0,0)), 1);
+ CHK(ssol_image_sample(NULL, NEAREST, CLAMPED, CLAMPED, NULL, NULL) == RES_BAD_ARG);
+ CHK(ssol_image_sample(img, NEAREST, CLAMPED, CLAMPED, NULL, NULL) == RES_BAD_ARG);
+ CHK(ssol_image_sample(NULL, NEAREST, CLAMPED, CLAMPED, uv, NULL) == RES_BAD_ARG);
+ CHK(ssol_image_sample(img, NEAREST, CLAMPED, CLAMPED, uv, NULL) == RES_BAD_ARG);
+ CHK(ssol_image_sample(NULL, NEAREST, CLAMPED, CLAMPED, NULL, pix) == RES_BAD_ARG);
+ CHK(ssol_image_sample(img, NEAREST, CLAMPED, CLAMPED, NULL, pix) == RES_BAD_ARG);
+ CHK(ssol_image_sample(NULL, NEAREST, CLAMPED, CLAMPED, uv, pix) == RES_BAD_ARG);
+ CHK(ssol_image_sample(img, NEAREST, CLAMPED, CLAMPED, uv, pix) == RES_OK);
+ CHK(d3_eq(pix, d3(tmp,1,0,0)) == 1);
uv[0] = 1.0/4.0;
- CHECK(ssol_image_sample(img, NEAREST, CLAMPED, CLAMPED, uv, pix), RES_OK);
- CHECK(d3_eq(pix, d3(tmp,1,0,0)), 1);
+ CHK(ssol_image_sample(img, NEAREST, CLAMPED, CLAMPED, uv, pix) == RES_OK);
+ CHK(d3_eq(pix, d3(tmp,1,0,0)) == 1);
uv[0] = 2.0/4.0;
- CHECK(ssol_image_sample(img, NEAREST, CLAMPED, CLAMPED, uv, pix), RES_OK);
- CHECK(d3_eq(pix, d3(tmp,1,1,0)), 1);
+ CHK(ssol_image_sample(img, NEAREST, CLAMPED, CLAMPED, uv, pix) == RES_OK);
+ CHK(d3_eq(pix, d3(tmp,1,1,0)) == 1);
uv[0] = 3.0/4.0;
- CHECK(ssol_image_sample(img, NEAREST, CLAMPED, CLAMPED, uv, pix), RES_OK);
- CHECK(d3_eq(pix, d3(tmp,1,1,0)), 1);
+ CHK(ssol_image_sample(img, NEAREST, CLAMPED, CLAMPED, uv, pix) == RES_OK);
+ CHK(d3_eq(pix, d3(tmp,1,1,0)) == 1);
uv[0] = -1.0/4.0;
- CHECK(ssol_image_sample(img, NEAREST, CLAMPED, CLAMPED, uv, pix), RES_OK);
- CHECK(d3_eq(pix, d3(tmp,1,0,0)), 1);
- CHECK(ssol_image_sample(img, NEAREST, REPEAT, CLAMPED, uv, pix), RES_OK);
- CHECK(d3_eq(pix, d3(tmp,1,1,0)), 1);
+ CHK(ssol_image_sample(img, NEAREST, CLAMPED, CLAMPED, uv, pix) == RES_OK);
+ CHK(d3_eq(pix, d3(tmp,1,0,0)) == 1);
+ CHK(ssol_image_sample(img, NEAREST, REPEAT, CLAMPED, uv, pix) == RES_OK);
+ CHK(d3_eq(pix, d3(tmp,1,1,0)) == 1);
uv[0] = 4.0/4.0;
- CHECK(ssol_image_sample(img, NEAREST, CLAMPED, CLAMPED, uv, pix), RES_OK);
- CHECK(d3_eq(pix, d3(tmp,1,1,0)), 1);
- CHECK(ssol_image_sample(img, NEAREST, REPEAT, CLAMPED, uv, pix), RES_OK);
- CHECK(d3_eq(pix, d3(tmp,1,0,0)), 1);
+ CHK(ssol_image_sample(img, NEAREST, CLAMPED, CLAMPED, uv, pix) == RES_OK);
+ CHK(d3_eq(pix, d3(tmp,1,1,0)) == 1);
+ CHK(ssol_image_sample(img, NEAREST, REPEAT, CLAMPED, uv, pix) == RES_OK);
+ CHK(d3_eq(pix, d3(tmp,1,0,0)) == 1);
uv[1] = 1.0/2.0;
- CHECK(ssol_image_sample(img, NEAREST, CLAMPED, CLAMPED, uv, pix), RES_OK);
- CHECK(d3_eq(pix, d3(tmp,0,1,1)), 1);
+ CHK(ssol_image_sample(img, NEAREST, CLAMPED, CLAMPED, uv, pix) == RES_OK);
+ CHK(d3_eq(pix, d3(tmp,0,1,1)) == 1);
uv[1] = 2.0/2.0;
- CHECK(ssol_image_sample(img, NEAREST, REPEAT, CLAMPED, uv, pix), RES_OK);
- CHECK(d3_eq(pix, d3(tmp,1,0,1)), 1);
- CHECK(ssol_image_sample(img, NEAREST, REPEAT, REPEAT, uv, pix), RES_OK);
- CHECK(d3_eq(pix, d3(tmp,1,0,0)), 1);
- CHECK(ssol_image_sample(img, NEAREST, CLAMPED, REPEAT, uv, pix), RES_OK);
- CHECK(d3_eq(pix, d3(tmp,1,1,0)), 1);
+ CHK(ssol_image_sample(img, NEAREST, REPEAT, CLAMPED, uv, pix) == RES_OK);
+ CHK(d3_eq(pix, d3(tmp,1,0,1)) == 1);
+ CHK(ssol_image_sample(img, NEAREST, REPEAT, REPEAT, uv, pix) == RES_OK);
+ CHK(d3_eq(pix, d3(tmp,1,0,0)) == 1);
+ CHK(ssol_image_sample(img, NEAREST, CLAMPED, REPEAT, uv, pix) == RES_OK);
+ CHK(d3_eq(pix, d3(tmp,1,1,0)) == 1);
uv[0] = 1.0/4.0 + 1.0/8.0;
uv[1] = 0.0/2.0 + 1.0/4.0;
- CHECK(ssol_image_sample(img, LINEAR, CLAMPED, CLAMPED, uv, pix), RES_OK);
- CHECK(d3_eq(pix, d3(tmp,0.75,0.5,0.5)), 1);
+ CHK(ssol_image_sample(img, LINEAR, CLAMPED, CLAMPED, uv, pix) == RES_OK);
+ CHK(d3_eq(pix, d3(tmp,0.75,0.5,0.5)) == 1);
- CHECK(ssol_image_ref_put(img), RES_OK);
+ CHK(ssol_image_ref_put(img) == RES_OK);
}
int
@@ -120,74 +120,74 @@ main(int argc, char** argv)
mem_init_proxy_allocator(&allocator, &mem_default_allocator);
- CHECK(ssol_device_create
- (NULL, &allocator, SSOL_NTHREADS_DEFAULT, 0, &dev), RES_OK);
+ CHK(ssol_device_create
+ (NULL, &allocator, SSOL_NTHREADS_DEFAULT, 0, &dev) == RES_OK);
- CHECK(ssol_image_create(dev, &img), RES_OK);
+ CHK(ssol_image_create(dev, &img) == RES_OK);
- CHECK(ssol_image_ref_get(NULL), RES_BAD_ARG);
- CHECK(ssol_image_ref_get(img), RES_OK);
+ CHK(ssol_image_ref_get(NULL) == RES_BAD_ARG);
+ CHK(ssol_image_ref_get(img) == RES_OK);
- CHECK(ssol_image_ref_put(NULL), RES_BAD_ARG);
- CHECK(ssol_image_ref_put(img), RES_OK);
+ CHK(ssol_image_ref_put(NULL) == RES_BAD_ARG);
+ CHK(ssol_image_ref_put(img) == RES_OK);
- CHECK(ssol_image_setup(NULL, 128, 128, SSOL_PIXEL_DOUBLE3), RES_BAD_ARG);
- CHECK(ssol_image_setup(img, 0, 128, SSOL_PIXEL_DOUBLE3), RES_BAD_ARG);
- CHECK(ssol_image_setup(img, 32, 32, (enum ssol_pixel_format)99), RES_BAD_ARG);
- CHECK(ssol_image_setup(img, 128, 128, SSOL_PIXEL_DOUBLE3), RES_OK);
- CHECK(ssol_image_setup(img, 128, 128, SSOL_PIXEL_DOUBLE3), RES_OK);
- CHECK(ssol_image_setup(img, 16, 16, SSOL_PIXEL_DOUBLE3), RES_OK);
+ CHK(ssol_image_setup(NULL, 128, 128, SSOL_PIXEL_DOUBLE3) == RES_BAD_ARG);
+ CHK(ssol_image_setup(img, 0, 128, SSOL_PIXEL_DOUBLE3) == RES_BAD_ARG);
+ CHK(ssol_image_setup(img, 32, 32, (enum ssol_pixel_format)99) == RES_BAD_ARG);
+ CHK(ssol_image_setup(img, 128, 128, SSOL_PIXEL_DOUBLE3) == RES_OK);
+ CHK(ssol_image_setup(img, 128, 128, SSOL_PIXEL_DOUBLE3) == RES_OK);
+ CHK(ssol_image_setup(img, 16, 16, SSOL_PIXEL_DOUBLE3) == RES_OK);
org[0] = 0, org[1] = 0;
sz[0] = 8, sz[1] = 8;
#define WRITE ssol_image_write
FOR_EACH(i, 0, sizeof(block)/sizeof(double)) block[i] = 1.0;
- CHECK(WRITE(NULL, NULL, NULL, SSOL_PIXEL_DOUBLE3, NULL), RES_BAD_ARG);
- CHECK(WRITE(img, NULL, NULL, SSOL_PIXEL_DOUBLE3, NULL), RES_BAD_ARG);
- CHECK(WRITE(NULL, org, NULL, SSOL_PIXEL_DOUBLE3, NULL), RES_BAD_ARG);
- CHECK(WRITE(img, org, NULL, SSOL_PIXEL_DOUBLE3, NULL), RES_BAD_ARG);
- CHECK(WRITE(NULL, NULL, sz, SSOL_PIXEL_DOUBLE3, NULL), RES_BAD_ARG);
- CHECK(WRITE(img, NULL, sz, SSOL_PIXEL_DOUBLE3, NULL), RES_BAD_ARG);
- CHECK(WRITE(NULL, org, sz, SSOL_PIXEL_DOUBLE3, NULL), RES_BAD_ARG);
- CHECK(WRITE(img, org, sz, SSOL_PIXEL_DOUBLE3, NULL), RES_BAD_ARG);
- CHECK(WRITE(NULL, NULL, NULL, SSOL_PIXEL_DOUBLE3, block), RES_BAD_ARG);
- CHECK(WRITE(img, NULL, NULL, SSOL_PIXEL_DOUBLE3, block), RES_BAD_ARG);
- CHECK(WRITE(NULL, org, NULL, SSOL_PIXEL_DOUBLE3, block), RES_BAD_ARG);
- CHECK(WRITE(img, org, NULL, SSOL_PIXEL_DOUBLE3, block), RES_BAD_ARG);
- CHECK(WRITE(NULL, NULL, sz, SSOL_PIXEL_DOUBLE3, block), RES_BAD_ARG);
- CHECK(WRITE(img, NULL, sz, SSOL_PIXEL_DOUBLE3, block), RES_BAD_ARG);
- CHECK(WRITE(NULL, org, sz, SSOL_PIXEL_DOUBLE3, block), RES_BAD_ARG);
- CHECK(WRITE(img, org, sz, SSOL_PIXEL_DOUBLE3, block), RES_OK);
+ CHK(WRITE(NULL, NULL, NULL, SSOL_PIXEL_DOUBLE3, NULL) == RES_BAD_ARG);
+ CHK(WRITE(img, NULL, NULL, SSOL_PIXEL_DOUBLE3, NULL) == RES_BAD_ARG);
+ CHK(WRITE(NULL, org, NULL, SSOL_PIXEL_DOUBLE3, NULL) == RES_BAD_ARG);
+ CHK(WRITE(img, org, NULL, SSOL_PIXEL_DOUBLE3, NULL) == RES_BAD_ARG);
+ CHK(WRITE(NULL, NULL, sz, SSOL_PIXEL_DOUBLE3, NULL) == RES_BAD_ARG);
+ CHK(WRITE(img, NULL, sz, SSOL_PIXEL_DOUBLE3, NULL) == RES_BAD_ARG);
+ CHK(WRITE(NULL, org, sz, SSOL_PIXEL_DOUBLE3, NULL) == RES_BAD_ARG);
+ CHK(WRITE(img, org, sz, SSOL_PIXEL_DOUBLE3, NULL) == RES_BAD_ARG);
+ CHK(WRITE(NULL, NULL, NULL, SSOL_PIXEL_DOUBLE3, block) == RES_BAD_ARG);
+ CHK(WRITE(img, NULL, NULL, SSOL_PIXEL_DOUBLE3, block) == RES_BAD_ARG);
+ CHK(WRITE(NULL, org, NULL, SSOL_PIXEL_DOUBLE3, block) == RES_BAD_ARG);
+ CHK(WRITE(img, org, NULL, SSOL_PIXEL_DOUBLE3, block) == RES_BAD_ARG);
+ CHK(WRITE(NULL, NULL, sz, SSOL_PIXEL_DOUBLE3, block) == RES_BAD_ARG);
+ CHK(WRITE(img, NULL, sz, SSOL_PIXEL_DOUBLE3, block) == RES_BAD_ARG);
+ CHK(WRITE(NULL, org, sz, SSOL_PIXEL_DOUBLE3, block) == RES_BAD_ARG);
+ CHK(WRITE(img, org, sz, SSOL_PIXEL_DOUBLE3, block) == RES_OK);
org[0] = 14, org[1] = 0;
- CHECK(WRITE(img, org, sz, SSOL_PIXEL_DOUBLE3, block), RES_BAD_ARG);
+ CHK(WRITE(img, org, sz, SSOL_PIXEL_DOUBLE3, block) == RES_BAD_ARG);
org[0] = 8, org[1] = 0;
FOR_EACH(i, 0, sizeof(block)/sizeof(double)) block[i] = 2.0;
- CHECK(WRITE(img, org, sz, SSOL_PIXEL_DOUBLE3, block), RES_OK);
+ CHK(WRITE(img, org, sz, SSOL_PIXEL_DOUBLE3, block) == RES_OK);
org[0] = 0, org[1] = 8;
FOR_EACH(i, 0, sizeof(block)/sizeof(double)) block[i] = 3.0;
- CHECK(WRITE(img, org, sz, SSOL_PIXEL_DOUBLE3, block), RES_OK);
+ CHK(WRITE(img, org, sz, SSOL_PIXEL_DOUBLE3, block) == RES_OK);
org[0] = 8, org[1] = 8;
FOR_EACH(i, 0, sizeof(block)/sizeof(double)) block[i] = 4.0;
- CHECK(WRITE(img, org, sz, SSOL_PIXEL_DOUBLE3, block), RES_OK);
+ CHK(WRITE(img, org, sz, SSOL_PIXEL_DOUBLE3, block) == RES_OK);
#undef WRITE
- CHECK(ssol_image_get_layout(NULL, NULL), RES_BAD_ARG);
- CHECK(ssol_image_get_layout(img, NULL), RES_BAD_ARG);
- CHECK(ssol_image_get_layout(NULL, &layout), RES_BAD_ARG);
- CHECK(ssol_image_get_layout(img, &layout), RES_OK);
+ CHK(ssol_image_get_layout(NULL, NULL) == RES_BAD_ARG);
+ CHK(ssol_image_get_layout(img, NULL) == RES_BAD_ARG);
+ CHK(ssol_image_get_layout(NULL, &layout) == RES_BAD_ARG);
+ CHK(ssol_image_get_layout(img, &layout) == RES_OK);
- CHECK(layout.size > layout.offset, 1);
- CHECK(layout.width, 16);
- CHECK(layout.height, 16);
- CHECK(layout.size - layout.offset >= 16*16, 1);
- CHECK(layout.row_pitch >= 16, 1);
- CHECK(layout.pixel_format, SSOL_PIXEL_DOUBLE3);
+ CHK(layout.size > layout.offset);
+ CHK(layout.width == 16);
+ CHK(layout.height == 16);
+ CHK(layout.size - layout.offset >= 16*16);
+ CHK(layout.row_pitch >= 16);
+ CHK(layout.pixel_format == SSOL_PIXEL_DOUBLE3);
- CHECK(ssol_image_map(NULL, NULL), RES_BAD_ARG);
- CHECK(ssol_image_map(img, NULL), RES_BAD_ARG);
- CHECK(ssol_image_map(NULL, &mem), RES_BAD_ARG);
- CHECK(ssol_image_map(img, &mem), RES_OK);
+ CHK(ssol_image_map(NULL, NULL) == RES_BAD_ARG);
+ CHK(ssol_image_map(img, NULL) == RES_BAD_ARG);
+ CHK(ssol_image_map(NULL, &mem) == RES_BAD_ARG);
+ CHK(ssol_image_map(img, &mem) == RES_OK);
FOR_EACH(y, 0, layout.height) {
const double* row = (const double*)
@@ -196,38 +196,38 @@ main(int argc, char** argv)
const double* pixel = row + x*3;
if(y < 8) {
if(x < 8) {
- CHECK(pixel[0], 1);
- CHECK(pixel[1], 1);
- CHECK(pixel[2], 1);
+ CHK(pixel[0] == 1);
+ CHK(pixel[1] == 1);
+ CHK(pixel[2] == 1);
} else {
- CHECK(pixel[0], 2);
- CHECK(pixel[1], 2);
- CHECK(pixel[2], 2);
+ CHK(pixel[0] == 2);
+ CHK(pixel[1] == 2);
+ CHK(pixel[2] == 2);
}
} else {
if(x < 8) {
- CHECK(pixel[0], 3);
- CHECK(pixel[1], 3);
- CHECK(pixel[2], 3);
+ CHK(pixel[0] == 3);
+ CHK(pixel[1] == 3);
+ CHK(pixel[2] == 3);
} else {
- CHECK(pixel[0], 4);
- CHECK(pixel[1], 4);
- CHECK(pixel[2], 4);
+ CHK(pixel[0] == 4);
+ CHK(pixel[1] == 4);
+ CHK(pixel[2] == 4);
}
}
}
}
- CHECK(ssol_image_unmap(NULL), RES_BAD_ARG);
- CHECK(ssol_image_unmap(img), RES_OK);
+ CHK(ssol_image_unmap(NULL) == RES_BAD_ARG);
+ CHK(ssol_image_unmap(img) == RES_OK);
- CHECK(ssol_image_ref_put(img), RES_OK);
+ CHK(ssol_image_ref_put(img) == RES_OK);
check_sampling(dev);
- CHECK(ssol_device_ref_put(dev), RES_OK);
+ CHK(ssol_device_ref_put(dev) == RES_OK);
check_memory_allocator(&allocator);
mem_shutdown_proxy_allocator(&allocator);
- CHECK(mem_allocated_size(), 0);
+ CHK(mem_allocated_size() == 0);
return 0;
}
diff --git a/src/test_ssol_instance.c b/src/test_ssol_instance.c
@@ -44,146 +44,146 @@ main(int argc, char** argv)
mem_init_proxy_allocator(&allocator, &mem_default_allocator);
- CHECK(ssol_device_create
- (NULL, &allocator, SSOL_NTHREADS_DEFAULT, 0, &dev), RES_OK);
+ CHK(ssol_device_create
+ (NULL, &allocator, SSOL_NTHREADS_DEFAULT, 0, &dev) == RES_OK);
- CHECK(ssol_material_create_virtual(dev, &material), RES_OK);
+ CHK(ssol_material_create_virtual(dev, &material) == RES_OK);
attrib.usage = SSOL_POSITION;
attrib.get = get_position;
- CHECK(ssol_shape_create_mesh(dev, &shape), RES_OK);
- CHECK(ssol_mesh_setup(shape, SQUARE_NTRIS__, get_ids, SQUARE_NVERTS__,
- &attrib, 1, (void*)&SQUARE_DESC__), RES_OK);
-
- CHECK(ssol_object_create(dev, &object), RES_OK);
- CHECK(ssol_object_add_shaded_shape(object, shape, material, material), RES_OK);
-
- CHECK(ssol_object_instantiate(object, &instance), RES_OK);
- CHECK(ssol_object_instantiate(object, &instance1), RES_OK);
-
- CHECK(ssol_instance_get_id(NULL, NULL), RES_BAD_ARG);
- CHECK(ssol_instance_get_id(instance, NULL), RES_BAD_ARG);
- CHECK(ssol_instance_get_id(NULL, &id), RES_BAD_ARG);
- CHECK(ssol_instance_get_id(instance, &id), RES_OK);
- CHECK(ssol_instance_get_id(instance1, &id1), RES_OK);
- NCHECK(id, id1);
-
- CHECK(ssol_instance_ref_get(NULL), RES_BAD_ARG);
- CHECK(ssol_instance_ref_get(instance), RES_OK);
-
- CHECK(ssol_instance_ref_put(NULL), RES_BAD_ARG);
- CHECK(ssol_instance_ref_put(instance), RES_OK);
-
- CHECK(ssol_instance_set_transform(NULL, transform), RES_BAD_ARG);
- CHECK(ssol_instance_set_transform(instance, NULL), RES_BAD_ARG);
- CHECK(ssol_instance_set_transform(instance, transform), RES_OK);
- CHECK(ssol_instance_set_transform(instance, transform), RES_OK);
-
- CHECK(ssol_instance_get_area(instance, NULL), RES_BAD_ARG);
- CHECK(ssol_instance_get_area(NULL, &area), RES_BAD_ARG);
- CHECK(ssol_instance_get_area(instance, &area), RES_OK);
-
- CHECK(ssol_instance_set_receiver(NULL, 0, 0), RES_BAD_ARG);
- CHECK(ssol_instance_set_receiver(instance, 0, 0), RES_OK);
-
- CHECK(ssol_instance_is_receiver(NULL, NULL, NULL), RES_BAD_ARG);
- CHECK(ssol_instance_is_receiver(instance, NULL, NULL), RES_BAD_ARG);
- CHECK(ssol_instance_is_receiver(NULL, &mask, NULL), RES_BAD_ARG);
- CHECK(ssol_instance_is_receiver(instance, &mask, NULL), RES_BAD_ARG);
- CHECK(ssol_instance_is_receiver(NULL, NULL, &prim), RES_BAD_ARG);
- CHECK(ssol_instance_is_receiver(instance, NULL, &prim), RES_BAD_ARG);
- CHECK(ssol_instance_is_receiver(NULL, &mask, &prim), RES_BAD_ARG);
- CHECK(ssol_instance_is_receiver(instance, &mask, &prim), RES_OK);
- CHECK(mask, 0);
- CHECK(prim, 0);
-
- CHECK(ssol_instance_set_receiver(instance, SSOL_FRONT, 0), RES_OK);
- CHECK(ssol_instance_is_receiver(instance, &mask, &prim), RES_OK);
- CHECK(mask, SSOL_FRONT);
- CHECK(prim, 0);
- CHECK(ssol_instance_set_receiver(instance, SSOL_FRONT|SSOL_BACK, 1), RES_OK);
- CHECK(ssol_instance_is_receiver(instance, &mask, &prim), RES_OK);
- CHECK(mask, SSOL_FRONT|SSOL_BACK);
- CHECK(prim, 1);
-
- CHECK(ssol_instance_sample(NULL, 0), RES_BAD_ARG);
- CHECK(ssol_instance_sample(instance, 0), RES_OK);
- CHECK(ssol_instance_sample(instance, 1), RES_OK);
-
- CHECK(ssol_instance_get_shaded_shapes_count(NULL, NULL), RES_BAD_ARG);
- CHECK(ssol_instance_get_shaded_shapes_count(instance, NULL), RES_BAD_ARG);
- CHECK(ssol_instance_get_shaded_shapes_count(NULL, &n), RES_BAD_ARG);
- CHECK(ssol_instance_get_shaded_shapes_count(instance, &n), RES_OK);
- CHECK(n, 1);
-
- CHECK(ssol_instance_get_shaded_shape(NULL, n, NULL), RES_BAD_ARG);
- CHECK(ssol_instance_get_shaded_shape(instance, n, NULL), RES_BAD_ARG);
- CHECK(ssol_instance_get_shaded_shape(NULL, 0, NULL), RES_BAD_ARG);
- CHECK(ssol_instance_get_shaded_shape(instance, 0, NULL), RES_BAD_ARG);
- CHECK(ssol_instance_get_shaded_shape(NULL, n, &sshape), RES_BAD_ARG);
- CHECK(ssol_instance_get_shaded_shape(instance, n, &sshape), RES_BAD_ARG);
- CHECK(ssol_instance_get_shaded_shape(NULL, 0, &sshape), RES_BAD_ARG);
- CHECK(ssol_instance_get_shaded_shape(instance, 0, &sshape), RES_OK);
-
- CHECK(sshape.shape, shape);
- CHECK(sshape.mtl_front, material);
- CHECK(sshape.mtl_back, material);
-
- CHECK(ssol_shape_get_vertices_count(sshape.shape, &count), RES_OK);
+ CHK(ssol_shape_create_mesh(dev, &shape) == RES_OK);
+ CHK(ssol_mesh_setup(shape, SQUARE_NTRIS__, get_ids, SQUARE_NVERTS__,
+ &attrib, 1, (void*)&SQUARE_DESC__) == RES_OK);
+
+ CHK(ssol_object_create(dev, &object) == RES_OK);
+ CHK(ssol_object_add_shaded_shape(object, shape, material, material) == RES_OK);
+
+ CHK(ssol_object_instantiate(object, &instance) == RES_OK);
+ CHK(ssol_object_instantiate(object, &instance1) == RES_OK);
+
+ CHK(ssol_instance_get_id(NULL, NULL) == RES_BAD_ARG);
+ CHK(ssol_instance_get_id(instance, NULL) == RES_BAD_ARG);
+ CHK(ssol_instance_get_id(NULL, &id) == RES_BAD_ARG);
+ CHK(ssol_instance_get_id(instance, &id) == RES_OK);
+ CHK(ssol_instance_get_id(instance1, &id1) == RES_OK);
+ CHK(id != id1);
+
+ CHK(ssol_instance_ref_get(NULL) == RES_BAD_ARG);
+ CHK(ssol_instance_ref_get(instance) == RES_OK);
+
+ CHK(ssol_instance_ref_put(NULL) == RES_BAD_ARG);
+ CHK(ssol_instance_ref_put(instance) == RES_OK);
+
+ CHK(ssol_instance_set_transform(NULL, transform) == RES_BAD_ARG);
+ CHK(ssol_instance_set_transform(instance, NULL) == RES_BAD_ARG);
+ CHK(ssol_instance_set_transform(instance, transform) == RES_OK);
+ CHK(ssol_instance_set_transform(instance, transform) == RES_OK);
+
+ CHK(ssol_instance_get_area(instance, NULL) == RES_BAD_ARG);
+ CHK(ssol_instance_get_area(NULL, &area) == RES_BAD_ARG);
+ CHK(ssol_instance_get_area(instance, &area) == RES_OK);
+
+ CHK(ssol_instance_set_receiver(NULL, 0, 0) == RES_BAD_ARG);
+ CHK(ssol_instance_set_receiver(instance, 0, 0) == RES_OK);
+
+ CHK(ssol_instance_is_receiver(NULL, NULL, NULL) == RES_BAD_ARG);
+ CHK(ssol_instance_is_receiver(instance, NULL, NULL) == RES_BAD_ARG);
+ CHK(ssol_instance_is_receiver(NULL, &mask, NULL) == RES_BAD_ARG);
+ CHK(ssol_instance_is_receiver(instance, &mask, NULL) == RES_BAD_ARG);
+ CHK(ssol_instance_is_receiver(NULL, NULL, &prim) == RES_BAD_ARG);
+ CHK(ssol_instance_is_receiver(instance, NULL, &prim) == RES_BAD_ARG);
+ CHK(ssol_instance_is_receiver(NULL, &mask, &prim) == RES_BAD_ARG);
+ CHK(ssol_instance_is_receiver(instance, &mask, &prim) == RES_OK);
+ CHK(mask == 0);
+ CHK(prim == 0);
+
+ CHK(ssol_instance_set_receiver(instance, SSOL_FRONT, 0) == RES_OK);
+ CHK(ssol_instance_is_receiver(instance, &mask, &prim) == RES_OK);
+ CHK(mask == SSOL_FRONT);
+ CHK(prim == 0);
+ CHK(ssol_instance_set_receiver(instance, SSOL_FRONT|SSOL_BACK, 1) == RES_OK);
+ CHK(ssol_instance_is_receiver(instance, &mask, &prim) == RES_OK);
+ CHK(mask == (SSOL_FRONT|SSOL_BACK));
+ CHK(prim == 1);
+
+ CHK(ssol_instance_sample(NULL, 0) == RES_BAD_ARG);
+ CHK(ssol_instance_sample(instance, 0) == RES_OK);
+ CHK(ssol_instance_sample(instance, 1) == RES_OK);
+
+ CHK(ssol_instance_get_shaded_shapes_count(NULL, NULL) == RES_BAD_ARG);
+ CHK(ssol_instance_get_shaded_shapes_count(instance, NULL) == RES_BAD_ARG);
+ CHK(ssol_instance_get_shaded_shapes_count(NULL, &n) == RES_BAD_ARG);
+ CHK(ssol_instance_get_shaded_shapes_count(instance, &n) == RES_OK);
+ CHK(n == 1);
+
+ CHK(ssol_instance_get_shaded_shape(NULL, n, NULL) == RES_BAD_ARG);
+ CHK(ssol_instance_get_shaded_shape(instance, n, NULL) == RES_BAD_ARG);
+ CHK(ssol_instance_get_shaded_shape(NULL, 0, NULL) == RES_BAD_ARG);
+ CHK(ssol_instance_get_shaded_shape(instance, 0, NULL) == RES_BAD_ARG);
+ CHK(ssol_instance_get_shaded_shape(NULL, n, &sshape) == RES_BAD_ARG);
+ CHK(ssol_instance_get_shaded_shape(instance, n, &sshape) == RES_BAD_ARG);
+ CHK(ssol_instance_get_shaded_shape(NULL, 0, &sshape) == RES_BAD_ARG);
+ CHK(ssol_instance_get_shaded_shape(instance, 0, &sshape) == RES_OK);
+
+ CHK(sshape.shape == shape);
+ CHK(sshape.mtl_front == material);
+ CHK(sshape.mtl_back == material);
+
+ CHK(ssol_shape_get_vertices_count(sshape.shape, &count) == RES_OK);
#define GET_ATTR ssol_instantiated_shaded_shape_get_vertex_attrib
- CHECK(GET_ATTR(NULL, count, (unsigned)-1, NULL), RES_BAD_ARG);
- CHECK(GET_ATTR(&sshape, count, (unsigned)-1, NULL), RES_BAD_ARG);
- CHECK(GET_ATTR(NULL, 0, (unsigned)-1, NULL), RES_BAD_ARG);
- CHECK(GET_ATTR(&sshape, 0, (unsigned)-1, NULL), RES_BAD_ARG);
- CHECK(GET_ATTR(NULL, count, SSOL_POSITION, NULL), RES_BAD_ARG);
- CHECK(GET_ATTR(&sshape, count, SSOL_POSITION, NULL), RES_BAD_ARG);
- CHECK(GET_ATTR(NULL, 0, SSOL_POSITION, NULL), RES_BAD_ARG);
- CHECK(GET_ATTR(&sshape, 0, SSOL_POSITION, NULL), RES_BAD_ARG);
- CHECK(GET_ATTR(NULL, count, (unsigned)-1, val), RES_BAD_ARG);
- CHECK(GET_ATTR(&sshape, count, (unsigned)-1, val), RES_BAD_ARG);
- CHECK(GET_ATTR(NULL, 0, (unsigned)-1, val), RES_BAD_ARG);
- CHECK(GET_ATTR(&sshape, 0, (unsigned)-1, val), RES_BAD_ARG);
- CHECK(GET_ATTR(NULL, count, SSOL_POSITION, val), RES_BAD_ARG);
- CHECK(GET_ATTR(&sshape, count, SSOL_POSITION, val), RES_BAD_ARG);
- CHECK(GET_ATTR(NULL, 0, SSOL_POSITION, val), RES_BAD_ARG);
+ CHK(GET_ATTR(NULL, count, (unsigned)-1, NULL) == RES_BAD_ARG);
+ CHK(GET_ATTR(&sshape, count, (unsigned)-1, NULL) == RES_BAD_ARG);
+ CHK(GET_ATTR(NULL, 0, (unsigned)-1, NULL) == RES_BAD_ARG);
+ CHK(GET_ATTR(&sshape, 0, (unsigned)-1, NULL) == RES_BAD_ARG);
+ CHK(GET_ATTR(NULL, count, SSOL_POSITION, NULL) == RES_BAD_ARG);
+ CHK(GET_ATTR(&sshape, count, SSOL_POSITION, NULL) == RES_BAD_ARG);
+ CHK(GET_ATTR(NULL, 0, SSOL_POSITION, NULL) == RES_BAD_ARG);
+ CHK(GET_ATTR(&sshape, 0, SSOL_POSITION, NULL) == RES_BAD_ARG);
+ CHK(GET_ATTR(NULL, count, (unsigned)-1, val) == RES_BAD_ARG);
+ CHK(GET_ATTR(&sshape, count, (unsigned)-1, val) == RES_BAD_ARG);
+ CHK(GET_ATTR(NULL, 0, (unsigned)-1, val) == RES_BAD_ARG);
+ CHK(GET_ATTR(&sshape, 0, (unsigned)-1, val) == RES_BAD_ARG);
+ CHK(GET_ATTR(NULL, count, SSOL_POSITION, val) == RES_BAD_ARG);
+ CHK(GET_ATTR(&sshape, count, SSOL_POSITION, val) == RES_BAD_ARG);
+ CHK(GET_ATTR(NULL, 0, SSOL_POSITION, val) == RES_BAD_ARG);
FOR_EACH(i, 0, count) {
float valf[3];
double val2[3];
- CHECK(GET_ATTR(&sshape, i, SSOL_POSITION, val), RES_OK);
+ CHK(GET_ATTR(&sshape, i, SSOL_POSITION, val) == RES_OK);
get_position(i, valf, (void*)&SQUARE_DESC__);
d3_set_f3(val2, valf);
d33_muld3(val2, transform, val2);
d3_add(val2, transform+9, val2);
- CHECK(eq_eps(val[0], val2[0], 1.e-6), 1);
- CHECK(eq_eps(val[1], val2[1], 1.e-6), 1);
- CHECK(eq_eps(val[2], val2[2], 1.e-6), 1);
+ CHK(eq_eps(val[0], val2[0], 1.e-6) == 1);
+ CHK(eq_eps(val[1], val2[1], 1.e-6) == 1);
+ CHK(eq_eps(val[2], val2[2], 1.e-6) == 1);
}
- CHECK(ssol_instance_get_shaded_shape(instance1, 0, &sshape), RES_OK);
+ CHK(ssol_instance_get_shaded_shape(instance1, 0, &sshape) == RES_OK);
FOR_EACH(i, 0, count) {
float valf[3];
- CHECK(GET_ATTR(&sshape, i, SSOL_POSITION, val), RES_OK);
+ CHK(GET_ATTR(&sshape, i, SSOL_POSITION, val) == RES_OK);
get_position(i, valf, (void*)&SQUARE_DESC__);
- CHECK((float)val[0], valf[0]);
- CHECK((float)val[1], valf[1]);
- CHECK((float)val[2], valf[2]);
+ CHK((float)val[0] == valf[0]);
+ CHK((float)val[1] == valf[1]);
+ CHK((float)val[2] == valf[2]);
}
#undef GET_ATTR
- CHECK(ssol_instance_ref_put(instance), RES_OK);
- CHECK(ssol_instance_ref_put(instance1), RES_OK);
- CHECK(ssol_object_ref_put(object), RES_OK);
- CHECK(ssol_shape_ref_put(shape), RES_OK);
- CHECK(ssol_material_ref_put(material), RES_OK);
+ CHK(ssol_instance_ref_put(instance) == RES_OK);
+ CHK(ssol_instance_ref_put(instance1) == RES_OK);
+ CHK(ssol_object_ref_put(object) == RES_OK);
+ CHK(ssol_shape_ref_put(shape) == RES_OK);
+ CHK(ssol_material_ref_put(material) == RES_OK);
- CHECK(ssol_device_ref_put(dev), RES_OK);
+ CHK(ssol_device_ref_put(dev) == RES_OK);
check_memory_allocator(&allocator);
mem_shutdown_proxy_allocator(&allocator);
- CHECK(mem_allocated_size(), 0);
+ CHK(mem_allocated_size() == 0);
return 0;
}
diff --git a/src/test_ssol_material.c b/src/test_ssol_material.c
@@ -25,53 +25,64 @@ test_mirror(struct ssol_device* dev)
struct ssol_material* material;
enum ssol_material_type type;
- CHECK(ssol_material_create_mirror(NULL, NULL), RES_BAD_ARG);
- CHECK(ssol_material_create_mirror(NULL, &material), RES_BAD_ARG);
- CHECK(ssol_material_create_mirror(dev, NULL), RES_BAD_ARG);
- CHECK(ssol_material_create_mirror(dev, &material), RES_OK);
+ CHK(ssol_material_create_mirror(NULL, NULL) == RES_BAD_ARG);
+ CHK(ssol_material_create_mirror(NULL, &material) == RES_BAD_ARG);
+ CHK(ssol_material_create_mirror(dev, NULL) == RES_BAD_ARG);
+ CHK(ssol_material_create_mirror(dev, &material) == RES_OK);
- CHECK(ssol_material_get_type(NULL, NULL), RES_BAD_ARG);
- CHECK(ssol_material_get_type(material, NULL), RES_BAD_ARG);
- CHECK(ssol_material_get_type(NULL, &type), RES_BAD_ARG);
- CHECK(ssol_material_get_type(material, &type), RES_OK);
- CHECK(type, SSOL_MATERIAL_MIRROR);
+ CHK(ssol_material_get_type(NULL, NULL) == RES_BAD_ARG);
+ CHK(ssol_material_get_type(material, NULL) == RES_BAD_ARG);
+ CHK(ssol_material_get_type(NULL, &type) == RES_BAD_ARG);
+ CHK(ssol_material_get_type(material, &type) == RES_OK);
+ CHK(type == SSOL_MATERIAL_MIRROR);
- CHECK(ssol_material_ref_get(NULL), RES_BAD_ARG);
- CHECK(ssol_material_ref_get(material), RES_OK);
+ CHK(ssol_material_ref_get(NULL) == RES_BAD_ARG);
+ CHK(ssol_material_ref_get(material) == RES_OK);
- CHECK(ssol_material_ref_put(NULL), RES_BAD_ARG);
- CHECK(ssol_material_ref_put(material), RES_OK);
+ CHK(ssol_material_ref_put(NULL) == RES_BAD_ARG);
+ CHK(ssol_material_ref_put(material) == RES_OK);
- CHECK(ssol_param_buffer_create(dev, 32, &pbuf), RES_OK);
+ CHK(ssol_param_buffer_create(dev, 32, &pbuf) == RES_OK);
mirror.normal = get_shader_normal;
mirror.reflectivity = get_shader_reflectivity;
mirror.roughness = get_shader_roughness;
- 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);
- CHECK(ssol_material_set_param_buffer(NULL, pbuf), RES_BAD_ARG);
- CHECK(ssol_material_set_param_buffer(material, pbuf), RES_OK);
+ CHK(ssol_mirror_setup(NULL, NULL, SSOL_MICROFACET_DISTRIBUTIONS_COUNT__)
+ == RES_BAD_ARG);
+ CHK(ssol_mirror_setup(material, NULL, SSOL_MICROFACET_DISTRIBUTIONS_COUNT__)
+ == RES_BAD_ARG);
+ CHK(ssol_mirror_setup(NULL, &mirror, SSOL_MICROFACET_DISTRIBUTIONS_COUNT__)
+ == RES_BAD_ARG);
+ CHK(ssol_mirror_setup(material, &mirror, SSOL_MICROFACET_DISTRIBUTIONS_COUNT__)
+ == RES_BAD_ARG);
+ CHK(ssol_mirror_setup(NULL, NULL, SSOL_MICROFACET_BECKMANN) == RES_BAD_ARG);
+ CHK(ssol_mirror_setup(material, NULL, SSOL_MICROFACET_BECKMANN) == RES_BAD_ARG);
+ CHK(ssol_mirror_setup(NULL, &mirror, SSOL_MICROFACET_BECKMANN) == RES_BAD_ARG);
+ CHK(ssol_mirror_setup(material, &mirror, SSOL_MICROFACET_BECKMANN) == RES_OK);
+
+ CHK(ssol_material_set_param_buffer(NULL, NULL) == RES_BAD_ARG);
+ CHK(ssol_material_set_param_buffer(material, NULL) == RES_BAD_ARG);
+ CHK(ssol_material_set_param_buffer(NULL, pbuf) == RES_BAD_ARG);
+ CHK(ssol_material_set_param_buffer(material, pbuf) == RES_OK);
mirror.normal = NULL;
- CHECK(ssol_mirror_setup(material, &mirror), RES_BAD_ARG);
+ CHK(ssol_mirror_setup(material, &mirror, SSOL_MICROFACET_BECKMANN)
+ == RES_BAD_ARG);
mirror.normal = get_shader_normal;
mirror.reflectivity = NULL;
- CHECK(ssol_mirror_setup(material, &mirror), RES_BAD_ARG);
+ CHK(ssol_mirror_setup(material, &mirror, SSOL_MICROFACET_BECKMANN)
+ == RES_BAD_ARG);
mirror.reflectivity = get_shader_reflectivity;
mirror.roughness = NULL;
- CHECK(ssol_mirror_setup(material, &mirror), RES_BAD_ARG);
+ CHK(ssol_mirror_setup(material, &mirror, SSOL_MICROFACET_BECKMANN)
+ == RES_BAD_ARG);
mirror.roughness = get_shader_roughness;
- CHECK(ssol_material_ref_put(material), RES_OK);
- CHECK(ssol_param_buffer_ref_put(pbuf), RES_OK);
+ CHK(ssol_material_ref_put(material) == RES_OK);
+ CHK(ssol_param_buffer_ref_put(pbuf) == RES_OK);
}
static void
@@ -81,28 +92,28 @@ test_matte(struct ssol_device* dev)
struct ssol_material* material;
enum ssol_material_type type;
- CHECK(ssol_material_create_matte(NULL, NULL), RES_BAD_ARG);
- CHECK(ssol_material_create_matte(dev, NULL), RES_BAD_ARG);
- CHECK(ssol_material_create_matte(NULL, &material), RES_BAD_ARG);
- CHECK(ssol_material_create_matte(dev, &material), RES_OK);
+ CHK(ssol_material_create_matte(NULL, NULL) == RES_BAD_ARG);
+ CHK(ssol_material_create_matte(dev, NULL) == RES_BAD_ARG);
+ CHK(ssol_material_create_matte(NULL, &material) == RES_BAD_ARG);
+ CHK(ssol_material_create_matte(dev, &material) == RES_OK);
- CHECK(ssol_material_get_type(material, &type), RES_OK);
- CHECK(type, SSOL_MATERIAL_MATTE);
+ CHK(ssol_material_get_type(material, &type) == RES_OK);
+ CHK(type == SSOL_MATERIAL_MATTE);
matte.normal = get_shader_normal;
matte.reflectivity = get_shader_reflectivity;
- 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);
+ CHK(ssol_matte_setup(NULL, NULL) == RES_BAD_ARG);
+ CHK(ssol_matte_setup(material, NULL) == RES_BAD_ARG);
+ CHK(ssol_matte_setup(NULL, &matte) == RES_BAD_ARG);
+ CHK(ssol_matte_setup(material, &matte) == RES_OK);
matte.normal = NULL;
- CHECK(ssol_matte_setup(material, &matte), RES_BAD_ARG);
+ CHK(ssol_matte_setup(material, &matte) == RES_BAD_ARG);
matte.normal = get_shader_normal;
matte.reflectivity = NULL;
- CHECK(ssol_matte_setup(material, &matte), RES_BAD_ARG);
+ CHK(ssol_matte_setup(material, &matte) == RES_BAD_ARG);
- CHECK(ssol_material_ref_put(material), RES_OK);
+ CHK(ssol_material_ref_put(material) == RES_OK);
}
static void
@@ -115,70 +126,70 @@ test_thin_dielectric(struct ssol_device* dev)
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, &mtl), RES_BAD_ARG);
- CHECK(ssol_material_create_thin_dielectric(dev, &mtl), RES_OK);
+ CHK(ssol_material_create_thin_dielectric(NULL, NULL) == RES_BAD_ARG);
+ CHK(ssol_material_create_thin_dielectric(dev, NULL) == RES_BAD_ARG);
+ CHK(ssol_material_create_thin_dielectric(NULL, &mtl) == RES_BAD_ARG);
+ CHK(ssol_material_create_thin_dielectric(dev, &mtl) == RES_OK);
- CHECK(ssol_material_get_type(mtl, &type), RES_OK);
- CHECK(type, SSOL_MATERIAL_THIN_DIELECTRIC);
+ CHK(ssol_material_get_type(mtl, &type) == RES_OK);
+ CHK(type == SSOL_MATERIAL_THIN_DIELECTRIC);
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);
+ CHK(ssol_thin_dielectric_setup(NULL, NULL, NULL, NULL, -1) == RES_BAD_ARG);
+ CHK(ssol_thin_dielectric_setup(mtl, NULL, NULL, NULL, -1) == RES_BAD_ARG);
+ CHK(ssol_thin_dielectric_setup(NULL, &shader, NULL, NULL, -1) == RES_BAD_ARG);
+ CHK(ssol_thin_dielectric_setup(mtl, &shader, NULL, NULL, -1) == RES_BAD_ARG);
+ CHK(ssol_thin_dielectric_setup(NULL, NULL, &mdm0, NULL, -1) == RES_BAD_ARG);
+ CHK(ssol_thin_dielectric_setup(mtl, NULL, &mdm0, NULL, -1) == RES_BAD_ARG);
+ CHK(ssol_thin_dielectric_setup(NULL, &shader, &mdm0, NULL, -1) == RES_BAD_ARG);
+ CHK(ssol_thin_dielectric_setup(mtl, &shader, &mdm0, NULL, -1) == RES_BAD_ARG);
+ CHK(ssol_thin_dielectric_setup(NULL, NULL, NULL, NULL, 1) == RES_BAD_ARG);
+ CHK(ssol_thin_dielectric_setup(mtl, NULL, NULL, NULL, 1) == RES_BAD_ARG);
+ CHK(ssol_thin_dielectric_setup(NULL, &shader, NULL, NULL, 1) == RES_BAD_ARG);
+ CHK(ssol_thin_dielectric_setup(mtl, &shader, NULL, NULL, 1) == RES_BAD_ARG);
+ CHK(ssol_thin_dielectric_setup(NULL, NULL, &mdm0, NULL, 1) == RES_BAD_ARG);
+ CHK(ssol_thin_dielectric_setup(mtl, NULL, &mdm0, NULL, 1) == RES_BAD_ARG);
+ CHK(ssol_thin_dielectric_setup(NULL, &shader, &mdm0, NULL, 1) == RES_BAD_ARG);
+ CHK(ssol_thin_dielectric_setup(mtl, &shader, &mdm0, NULL, 1) == RES_BAD_ARG);
+ CHK(ssol_thin_dielectric_setup(NULL, NULL, NULL, &mdm1, -1) == RES_BAD_ARG);
+ CHK(ssol_thin_dielectric_setup(mtl, NULL, NULL, &mdm1, -1) == RES_BAD_ARG);
+ CHK(ssol_thin_dielectric_setup(NULL, &shader, NULL, &mdm1, -1) == RES_BAD_ARG);
+ CHK(ssol_thin_dielectric_setup(mtl, &shader, NULL, &mdm1, -1) == RES_BAD_ARG);
+ CHK(ssol_thin_dielectric_setup(NULL, NULL, &mdm0, &mdm1, -1) == RES_BAD_ARG);
+ CHK(ssol_thin_dielectric_setup(mtl, NULL, &mdm0, &mdm1, -1) == RES_BAD_ARG);
+ CHK(ssol_thin_dielectric_setup(NULL, &shader, &mdm0, &mdm1, -1) == RES_BAD_ARG);
+ CHK(ssol_thin_dielectric_setup(mtl, &shader, &mdm0, &mdm1, -1) == RES_BAD_ARG);
+ CHK(ssol_thin_dielectric_setup(NULL, NULL, NULL, &mdm1, 1) == RES_BAD_ARG);
+ CHK(ssol_thin_dielectric_setup(mtl, NULL, NULL, &mdm1, 1) == RES_BAD_ARG);
+ CHK(ssol_thin_dielectric_setup(NULL, &shader, NULL, &mdm1, 1) == RES_BAD_ARG);
+ CHK(ssol_thin_dielectric_setup(mtl, &shader, NULL, &mdm1, 1) == RES_BAD_ARG);
+ CHK(ssol_thin_dielectric_setup(NULL, NULL, &mdm0, &mdm1, 1) == RES_BAD_ARG);
+ CHK(ssol_thin_dielectric_setup(mtl, NULL, &mdm0, &mdm1, 1) == RES_BAD_ARG);
+ CHK(ssol_thin_dielectric_setup(NULL, &shader, &mdm0, &mdm1, 1) == RES_BAD_ARG);
+ CHK(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);
+ CHK(ssol_thin_dielectric_setup(mtl, &shader, &mdm0, &mdm1, 1) == RES_BAD_ARG);
shader.normal = get_shader_normal;
ssol_data_set_real(&mdm0.extinction, -1);
- CHECK(ssol_thin_dielectric_setup(mtl, &shader, &mdm0, &mdm1, 1), RES_BAD_ARG);
+ CHK(ssol_thin_dielectric_setup(mtl, &shader, &mdm0, &mdm1, 1) == RES_BAD_ARG);
ssol_data_copy(&mdm0.extinction, &SSOL_MEDIUM_VACUUM.extinction);
ssol_data_set_real(&mdm0.refractive_index, 0);
- CHECK(ssol_thin_dielectric_setup(mtl, &shader, &mdm0, &mdm1, 1), RES_BAD_ARG);
+ CHK(ssol_thin_dielectric_setup(mtl, &shader, &mdm0, &mdm1, 1) == RES_BAD_ARG);
ssol_data_copy(&mdm0.refractive_index, &SSOL_MEDIUM_VACUUM.refractive_index);
ssol_data_set_real(&mdm1.extinction, -1);
- CHECK(ssol_thin_dielectric_setup(mtl, &shader, &mdm0, &mdm1, 1), RES_BAD_ARG);
+ CHK(ssol_thin_dielectric_setup(mtl, &shader, &mdm0, &mdm1, 1) == RES_BAD_ARG);
ssol_data_copy(&mdm1.extinction, &SSOL_MEDIUM_VACUUM.extinction);
ssol_data_set_real(&mdm1.refractive_index, 0);
- CHECK(ssol_thin_dielectric_setup(mtl, &shader, &mdm0, &mdm1, 1), RES_BAD_ARG);
+ CHK(ssol_thin_dielectric_setup(mtl, &shader, &mdm0, &mdm1, 1) == RES_BAD_ARG);
ssol_data_copy(&mdm1.refractive_index, &SSOL_MEDIUM_VACUUM.refractive_index);
- CHECK(ssol_material_ref_put(mtl), RES_OK);
+ CHK(ssol_material_ref_put(mtl) == RES_OK);
}
static void
@@ -190,54 +201,54 @@ test_dielectric(struct ssol_device* dev)
struct ssol_medium mdm1 = SSOL_MEDIUM_VACUUM;
enum ssol_material_type type;
- 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);
+ CHK(ssol_material_create_dielectric(NULL, NULL) == RES_BAD_ARG);
+ CHK(ssol_material_create_dielectric(dev, NULL) == RES_BAD_ARG);
+ CHK(ssol_material_create_dielectric(NULL, &material) == RES_BAD_ARG);
+ CHK(ssol_material_create_dielectric(dev, &material) == RES_OK);
- CHECK(ssol_material_get_type(material, &type), RES_OK);
- CHECK(type, SSOL_MATERIAL_DIELECTRIC);
+ CHK(ssol_material_get_type(material, &type) == RES_OK);
+ CHK(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);
+ CHK(ssol_dielectric_setup(NULL, NULL, NULL, NULL) == RES_BAD_ARG);
+ CHK(ssol_dielectric_setup(material, NULL, NULL, NULL) == RES_BAD_ARG);
+ CHK(ssol_dielectric_setup(NULL, &dielectric, NULL, NULL) == RES_BAD_ARG);
+ CHK(ssol_dielectric_setup(material, &dielectric, NULL, NULL) == RES_BAD_ARG);
+ CHK(ssol_dielectric_setup(NULL, NULL, &mdm0, NULL) == RES_BAD_ARG);
+ CHK(ssol_dielectric_setup(material, NULL, &mdm0, NULL) == RES_BAD_ARG);
+ CHK(ssol_dielectric_setup(NULL, &dielectric, &mdm0, NULL) == RES_BAD_ARG);
+ CHK(ssol_dielectric_setup(material, &dielectric, &mdm0, NULL) == RES_BAD_ARG);
+ CHK(ssol_dielectric_setup(NULL, NULL, NULL, &mdm1) == RES_BAD_ARG);
+ CHK(ssol_dielectric_setup(material, NULL, NULL, &mdm1) == RES_BAD_ARG);
+ CHK(ssol_dielectric_setup(NULL, &dielectric, NULL, &mdm1) == RES_BAD_ARG);
+ CHK(ssol_dielectric_setup(material, &dielectric, NULL, &mdm1) == RES_BAD_ARG);
+ CHK(ssol_dielectric_setup(NULL, NULL, &mdm0, &mdm1) == RES_BAD_ARG);
+ CHK(ssol_dielectric_setup(material, NULL, &mdm0, &mdm1) == RES_BAD_ARG);
+ CHK(ssol_dielectric_setup(NULL, &dielectric, &mdm0, &mdm1) == RES_BAD_ARG);
+ CHK(ssol_dielectric_setup(material, &dielectric, &mdm0, &mdm1) == RES_OK);
dielectric.normal = NULL;
- CHECK(ssol_dielectric_setup(NULL, &dielectric, &mdm0, &mdm1), RES_BAD_ARG);
+ CHK(ssol_dielectric_setup(NULL, &dielectric, &mdm0, &mdm1) == RES_BAD_ARG);
dielectric.normal = get_shader_normal;
ssol_data_set_real(&mdm0.refractive_index, 0);
- CHECK(ssol_dielectric_setup(NULL, &dielectric, &mdm0, &mdm1), RES_BAD_ARG);
+ CHK(ssol_dielectric_setup(NULL, &dielectric, &mdm0, &mdm1) == RES_BAD_ARG);
ssol_data_copy(&mdm0.refractive_index, &SSOL_MEDIUM_VACUUM.refractive_index);
ssol_data_set_real(&mdm1.refractive_index, 0);
- CHECK(ssol_dielectric_setup(NULL, &dielectric, &mdm0, &mdm1), RES_BAD_ARG);
+ CHK(ssol_dielectric_setup(NULL, &dielectric, &mdm0, &mdm1) == RES_BAD_ARG);
ssol_data_copy(&mdm1.refractive_index, &SSOL_MEDIUM_VACUUM.refractive_index);
ssol_data_set_real(&mdm0.extinction, -1);
- CHECK(ssol_dielectric_setup(NULL, &dielectric, &mdm0, &mdm1), RES_BAD_ARG);
+ CHK(ssol_dielectric_setup(NULL, &dielectric, &mdm0, &mdm1) == RES_BAD_ARG);
ssol_data_copy(&mdm0.extinction, &SSOL_MEDIUM_VACUUM.refractive_index);
ssol_data_set_real(&mdm1.extinction, -1);
- CHECK(ssol_dielectric_setup(NULL, &dielectric, &mdm0, &mdm1), RES_BAD_ARG);
+ CHK(ssol_dielectric_setup(NULL, &dielectric, &mdm0, &mdm1) == RES_BAD_ARG);
ssol_data_copy(&mdm1.refractive_index, &SSOL_MEDIUM_VACUUM.refractive_index);
- CHECK(ssol_material_ref_put(material), RES_OK);
+ CHK(ssol_material_ref_put(material) == RES_OK);
}
static void
@@ -246,15 +257,15 @@ test_virtual(struct ssol_device* dev)
struct ssol_material* material;
enum ssol_material_type type;
- CHECK(ssol_material_create_virtual(NULL, NULL), RES_BAD_ARG);
- CHECK(ssol_material_create_virtual(NULL, &material), RES_BAD_ARG);
- CHECK(ssol_material_create_virtual(dev, NULL), RES_BAD_ARG);
- CHECK(ssol_material_create_virtual(dev, &material), RES_OK);
+ CHK(ssol_material_create_virtual(NULL, NULL) == RES_BAD_ARG);
+ CHK(ssol_material_create_virtual(NULL, &material) == RES_BAD_ARG);
+ CHK(ssol_material_create_virtual(dev, NULL) == RES_BAD_ARG);
+ CHK(ssol_material_create_virtual(dev, &material) == RES_OK);
- CHECK(ssol_material_get_type(material, &type), RES_OK);
- CHECK(type, SSOL_MATERIAL_VIRTUAL);
+ CHK(ssol_material_get_type(material, &type) == RES_OK);
+ CHK(type == SSOL_MATERIAL_VIRTUAL);
- CHECK(ssol_material_ref_put(material), RES_OK);
+ CHK(ssol_material_ref_put(material) == RES_OK);
}
int
@@ -266,8 +277,8 @@ main(int argc, char** argv)
mem_init_proxy_allocator(&allocator, &mem_default_allocator);
- CHECK(ssol_device_create
- (NULL, &allocator, SSOL_NTHREADS_DEFAULT, 0, &dev), RES_OK);
+ CHK(ssol_device_create
+ (NULL, &allocator, SSOL_NTHREADS_DEFAULT, 0, &dev) == RES_OK);
test_mirror(dev);
test_matte(dev);
@@ -275,11 +286,11 @@ main(int argc, char** argv)
test_dielectric(dev);
test_virtual(dev);
- CHECK(ssol_device_ref_put(dev), RES_OK);
+ CHK(ssol_device_ref_put(dev) == RES_OK);
check_memory_allocator(&allocator);
mem_shutdown_proxy_allocator(&allocator);
- CHECK(mem_allocated_size(), 0);
+ CHK(mem_allocated_size() == 0);
return 0;
}
diff --git a/src/test_ssol_object.c b/src/test_ssol_object.c
@@ -31,63 +31,63 @@ main(int argc, char** argv)
mem_init_proxy_allocator(&allocator, &mem_default_allocator);
- CHECK(ssol_device_create
- (NULL, &allocator, SSOL_NTHREADS_DEFAULT, 0, &dev), RES_OK);
- CHECK(ssol_material_create_virtual(dev, &mtl), RES_OK);
- CHECK(ssol_material_create_virtual(dev, &mtl2), RES_OK);
- CHECK(ssol_shape_create_punched_surface(dev, &shape), RES_OK);
- CHECK(ssol_shape_create_punched_surface(dev, &shape2), RES_OK);
+ CHK(ssol_device_create
+ (NULL, &allocator, SSOL_NTHREADS_DEFAULT, 0, &dev) == RES_OK);
+ CHK(ssol_material_create_virtual(dev, &mtl) == RES_OK);
+ CHK(ssol_material_create_virtual(dev, &mtl2) == RES_OK);
+ CHK(ssol_shape_create_punched_surface(dev, &shape) == RES_OK);
+ CHK(ssol_shape_create_punched_surface(dev, &shape2) == RES_OK);
- CHECK(ssol_object_create(NULL, NULL), RES_BAD_ARG);
- CHECK(ssol_object_create(dev, NULL), RES_BAD_ARG);
- CHECK(ssol_object_create(NULL, &object), RES_BAD_ARG);
- CHECK(ssol_object_create(dev, &object), RES_OK);
+ CHK(ssol_object_create(NULL, NULL) == RES_BAD_ARG);
+ CHK(ssol_object_create(dev, NULL) == RES_BAD_ARG);
+ CHK(ssol_object_create(NULL, &object) == RES_BAD_ARG);
+ CHK(ssol_object_create(dev, &object) == RES_OK);
- CHECK(ssol_object_add_shaded_shape(NULL, NULL, NULL, NULL), RES_BAD_ARG);
- CHECK(ssol_object_add_shaded_shape(object, NULL, NULL, NULL), RES_BAD_ARG);
- CHECK(ssol_object_add_shaded_shape(NULL, shape, NULL, NULL), RES_BAD_ARG);
- CHECK(ssol_object_add_shaded_shape(object, shape, NULL, NULL), RES_BAD_ARG);
- CHECK(ssol_object_add_shaded_shape(NULL, NULL, mtl, NULL), RES_BAD_ARG);
- CHECK(ssol_object_add_shaded_shape(object, NULL, mtl, NULL), RES_BAD_ARG);
- CHECK(ssol_object_add_shaded_shape(NULL, shape, mtl, NULL), RES_BAD_ARG);
- CHECK(ssol_object_add_shaded_shape(object, shape, mtl, NULL), RES_BAD_ARG);
- CHECK(ssol_object_add_shaded_shape(NULL, NULL, NULL, mtl), RES_BAD_ARG);
- CHECK(ssol_object_add_shaded_shape(object, NULL, NULL, mtl), RES_BAD_ARG);
- CHECK(ssol_object_add_shaded_shape(NULL, shape, NULL, mtl), RES_BAD_ARG);
- CHECK(ssol_object_add_shaded_shape(object, shape, NULL, mtl), RES_BAD_ARG);
- CHECK(ssol_object_add_shaded_shape(NULL, NULL, mtl, mtl), RES_BAD_ARG);
- CHECK(ssol_object_add_shaded_shape(object, NULL, mtl, mtl), RES_BAD_ARG);
- CHECK(ssol_object_add_shaded_shape(NULL, shape, mtl, mtl), RES_BAD_ARG);
- CHECK(ssol_object_add_shaded_shape(object, shape, mtl, mtl), RES_OK);
- CHECK(ssol_object_add_shaded_shape(object, shape2, mtl2, mtl2), RES_OK);
+ CHK(ssol_object_add_shaded_shape(NULL, NULL, NULL, NULL) == RES_BAD_ARG);
+ CHK(ssol_object_add_shaded_shape(object, NULL, NULL, NULL) == RES_BAD_ARG);
+ CHK(ssol_object_add_shaded_shape(NULL, shape, NULL, NULL) == RES_BAD_ARG);
+ CHK(ssol_object_add_shaded_shape(object, shape, NULL, NULL) == RES_BAD_ARG);
+ CHK(ssol_object_add_shaded_shape(NULL, NULL, mtl, NULL) == RES_BAD_ARG);
+ CHK(ssol_object_add_shaded_shape(object, NULL, mtl, NULL) == RES_BAD_ARG);
+ CHK(ssol_object_add_shaded_shape(NULL, shape, mtl, NULL) == RES_BAD_ARG);
+ CHK(ssol_object_add_shaded_shape(object, shape, mtl, NULL) == RES_BAD_ARG);
+ CHK(ssol_object_add_shaded_shape(NULL, NULL, NULL, mtl) == RES_BAD_ARG);
+ CHK(ssol_object_add_shaded_shape(object, NULL, NULL, mtl) == RES_BAD_ARG);
+ CHK(ssol_object_add_shaded_shape(NULL, shape, NULL, mtl) == RES_BAD_ARG);
+ CHK(ssol_object_add_shaded_shape(object, shape, NULL, mtl) == RES_BAD_ARG);
+ CHK(ssol_object_add_shaded_shape(NULL, NULL, mtl, mtl) == RES_BAD_ARG);
+ CHK(ssol_object_add_shaded_shape(object, NULL, mtl, mtl) == RES_BAD_ARG);
+ CHK(ssol_object_add_shaded_shape(NULL, shape, mtl, mtl) == RES_BAD_ARG);
+ CHK(ssol_object_add_shaded_shape(object, shape, mtl, mtl) == RES_OK);
+ CHK(ssol_object_add_shaded_shape(object, shape2, mtl2, mtl2) == RES_OK);
- CHECK(ssol_object_ref_get(NULL), RES_BAD_ARG);
- CHECK(ssol_object_ref_get(object), RES_OK);
- CHECK(ssol_object_ref_put(NULL), RES_BAD_ARG);
- CHECK(ssol_object_ref_put(object), RES_OK);
- CHECK(ssol_object_ref_put(object), RES_OK);
+ CHK(ssol_object_ref_get(NULL) == RES_BAD_ARG);
+ CHK(ssol_object_ref_get(object) == RES_OK);
+ CHK(ssol_object_ref_put(NULL) == RES_BAD_ARG);
+ CHK(ssol_object_ref_put(object) == RES_OK);
+ CHK(ssol_object_ref_put(object) == RES_OK);
- CHECK(ssol_object_create(dev, &object), RES_OK);
- CHECK(ssol_object_add_shaded_shape(object, shape, mtl, mtl2), RES_OK);
- CHECK(ssol_object_add_shaded_shape(object, shape, mtl2, mtl), RES_OK);
+ CHK(ssol_object_create(dev, &object) == RES_OK);
+ CHK(ssol_object_add_shaded_shape(object, shape, mtl, mtl2) == RES_OK);
+ CHK(ssol_object_add_shaded_shape(object, shape, mtl2, mtl) == RES_OK);
- CHECK(ssol_object_clear(NULL), RES_BAD_ARG);
- CHECK(ssol_object_clear(object), RES_OK);
+ CHK(ssol_object_clear(NULL) == RES_BAD_ARG);
+ CHK(ssol_object_clear(object) == RES_OK);
- CHECK(ssol_object_get_area(object, NULL), RES_BAD_ARG);
- CHECK(ssol_object_get_area(NULL, &a), RES_BAD_ARG);
- CHECK(ssol_object_get_area(object, &a), RES_OK);
+ CHK(ssol_object_get_area(object, NULL) == RES_BAD_ARG);
+ CHK(ssol_object_get_area(NULL, &a) == RES_BAD_ARG);
+ CHK(ssol_object_get_area(object, &a) == RES_OK);
- CHECK(ssol_object_ref_put(object), RES_OK);
- CHECK(ssol_shape_ref_put(shape), RES_OK);
- CHECK(ssol_shape_ref_put(shape2), RES_OK);
- CHECK(ssol_material_ref_put(mtl), RES_OK);
- CHECK(ssol_material_ref_put(mtl2), RES_OK);
- CHECK(ssol_device_ref_put(dev), RES_OK);
+ CHK(ssol_object_ref_put(object) == RES_OK);
+ CHK(ssol_shape_ref_put(shape) == RES_OK);
+ CHK(ssol_shape_ref_put(shape2) == RES_OK);
+ CHK(ssol_material_ref_put(mtl) == RES_OK);
+ CHK(ssol_material_ref_put(mtl2) == RES_OK);
+ CHK(ssol_device_ref_put(dev) == RES_OK);
check_memory_allocator(&allocator);
mem_shutdown_proxy_allocator(&allocator);
- CHECK(mem_allocated_size(), 0);
+ CHK(mem_allocated_size() == 0);
return 0;
}
diff --git a/src/test_ssol_param_buffer.c b/src/test_ssol_param_buffer.c
@@ -47,130 +47,130 @@ main(int argc, char** argv)
void* mem;
(void)argc, (void)argv;
- CHECK(mem_init_proxy_allocator(&allocator, &mem_default_allocator), RES_OK);
+ CHK(mem_init_proxy_allocator(&allocator, &mem_default_allocator) == RES_OK);
- CHECK(ssol_device_create
- (NULL, &allocator, SSOL_NTHREADS_DEFAULT, 0, &dev), RES_OK);
+ CHK(ssol_device_create
+ (NULL, &allocator, SSOL_NTHREADS_DEFAULT, 0, &dev) == RES_OK);
- CHECK(ssol_param_buffer_create(NULL, 0, NULL), RES_BAD_ARG);
- CHECK(ssol_param_buffer_create(dev, 0, NULL), RES_BAD_ARG);
- CHECK(ssol_param_buffer_create(NULL, 0, &pbuf), RES_BAD_ARG);
- CHECK(ssol_param_buffer_create(dev, 0, &pbuf), RES_BAD_ARG);
- CHECK(ssol_param_buffer_create(NULL, 1024, NULL), RES_BAD_ARG);
- CHECK(ssol_param_buffer_create(dev, 1024, NULL), RES_BAD_ARG);
- CHECK(ssol_param_buffer_create(NULL, 1024, &pbuf), RES_BAD_ARG);
- CHECK(ssol_param_buffer_create(dev, 1024, &pbuf), RES_OK);
+ CHK(ssol_param_buffer_create(NULL, 0, NULL) == RES_BAD_ARG);
+ CHK(ssol_param_buffer_create(dev, 0, NULL) == RES_BAD_ARG);
+ CHK(ssol_param_buffer_create(NULL, 0, &pbuf) == RES_BAD_ARG);
+ CHK(ssol_param_buffer_create(dev, 0, &pbuf) == RES_BAD_ARG);
+ CHK(ssol_param_buffer_create(NULL, 1024, NULL) == RES_BAD_ARG);
+ CHK(ssol_param_buffer_create(dev, 1024, NULL) == RES_BAD_ARG);
+ CHK(ssol_param_buffer_create(NULL, 1024, &pbuf) == RES_BAD_ARG);
+ CHK(ssol_param_buffer_create(dev, 1024, &pbuf) == RES_OK);
- CHECK(ssol_param_buffer_get(pbuf), NULL);
+ CHK(ssol_param_buffer_get(pbuf) == NULL);
sz = sizeof(intptr_t);
al = ALIGNOF(intptr_t);
- CHECK(mem = ssol_param_buffer_allocate(NULL, 0, 0, NULL), NULL);
- CHECK(mem = ssol_param_buffer_allocate(pbuf, 0, 0, NULL), NULL);
- CHECK(mem = ssol_param_buffer_allocate(NULL, sz, 0, NULL), NULL);
- CHECK(mem = ssol_param_buffer_allocate(pbuf, sz, 0, NULL), NULL);
- CHECK(mem = ssol_param_buffer_allocate(NULL, 0, al, NULL), NULL);
- CHECK(mem = ssol_param_buffer_allocate(pbuf, 0, al, NULL), NULL);
- CHECK(mem = ssol_param_buffer_allocate(NULL, sz, al, NULL), NULL);
- NCHECK(mem = ssol_param_buffer_allocate(pbuf, sz, al, NULL), NULL);
+ CHK((mem = ssol_param_buffer_allocate(NULL, 0, 0, NULL)) == NULL);
+ CHK((mem = ssol_param_buffer_allocate(pbuf, 0, 0, NULL)) == NULL);
+ CHK((mem = ssol_param_buffer_allocate(NULL, sz, 0, NULL)) == NULL);
+ CHK((mem = ssol_param_buffer_allocate(pbuf, sz, 0, NULL)) == NULL);
+ CHK((mem = ssol_param_buffer_allocate(NULL, 0, al, NULL)) == NULL);
+ CHK((mem = ssol_param_buffer_allocate(pbuf, 0, al, NULL)) == NULL);
+ CHK((mem = ssol_param_buffer_allocate(NULL, sz, al, NULL)) == NULL);
+ CHK((mem = ssol_param_buffer_allocate(pbuf, sz, al, NULL)) != NULL);
*(intptr_t*)mem = 0xDECAFBAD;
- CHECK(*(intptr_t*)ssol_param_buffer_get(pbuf), 0xDECAFBAD);
+ CHK(*(intptr_t*)ssol_param_buffer_get(pbuf) == 0xDECAFBAD);
*(intptr_t*)mem = 0XDEADBEEF;
- CHECK(*(intptr_t*)ssol_param_buffer_get(pbuf), 0XDEADBEEF);
+ CHK(*(intptr_t*)ssol_param_buffer_get(pbuf) == 0XDEADBEEF);
- CHECK(ssol_param_buffer_clear(NULL), RES_BAD_ARG);
- CHECK(ssol_param_buffer_clear(pbuf), RES_OK);
- CHECK(ssol_param_buffer_get(pbuf), NULL);
+ CHK(ssol_param_buffer_clear(NULL) == RES_BAD_ARG);
+ CHK(ssol_param_buffer_clear(pbuf) == RES_OK);
+ CHK(ssol_param_buffer_get(pbuf) == NULL);
sz = strlen("Foo") + 1;
al = 4;
- NCHECK(mem = ssol_param_buffer_allocate(pbuf, sz, al, NULL), NULL);
+ CHK((mem = ssol_param_buffer_allocate(pbuf, sz, al, NULL)) != NULL);
strcpy(mem, "Foo");
- CHECK(strcmp(ssol_param_buffer_get(pbuf), "Foo"), 0);
+ CHK(strcmp(ssol_param_buffer_get(pbuf), "Foo") == 0);
strcpy(mem, "Bar");
- CHECK(strcmp(ssol_param_buffer_get(pbuf), "Bar"), 0);
- CHECK(IS_ALIGNED(ssol_param_buffer_get(pbuf), al), 1);
+ CHK(strcmp(ssol_param_buffer_get(pbuf), "Bar") == 0);
+ CHK(IS_ALIGNED(ssol_param_buffer_get(pbuf), al) == 1);
- CHECK(ssol_param_buffer_clear(pbuf), RES_OK);
+ CHK(ssol_param_buffer_clear(pbuf) == RES_OK);
sz = sizeof(struct param);
al = ALIGNOF(struct param);
- NCHECK(param = ssol_param_buffer_allocate(pbuf, sz, al, NULL), NULL);
- NCHECK(param->name = ssol_param_buffer_allocate(pbuf, 7, 64, NULL), NULL);
+ CHK((param = ssol_param_buffer_allocate(pbuf, sz, al, NULL)) != NULL);
+ CHK((param->name = ssol_param_buffer_allocate(pbuf, 7, 64, NULL)) != NULL);
strcpy(param->name, "0123456");
- NCHECK(param->ptr = ssol_param_buffer_allocate(pbuf, 4, 16, NULL), NULL);
+ CHK((param->ptr = ssol_param_buffer_allocate(pbuf, 4, 16, NULL)) != NULL);
param->d = PI;
param->i = -123;
param->img = NULL;
strcpy(param->ptr, "abc");
- NCHECK(param = ssol_param_buffer_get(pbuf), NULL);
- CHECK(IS_ALIGNED(param, ALIGNOF(struct param)), 1);
- CHECK(IS_ALIGNED(param->name, 64), 1);
- CHECK(IS_ALIGNED(param->ptr, 16), 1);
- CHECK(param->d, PI);
- CHECK(param->i, -123);
- CHECK(strcmp(param->name, "0123456"), 0);
- CHECK(strcmp(param->ptr, "abc"), 0);
+ CHK((param = ssol_param_buffer_get(pbuf)) != NULL);
+ CHK(IS_ALIGNED(param, ALIGNOF(struct param)) == 1);
+ CHK(IS_ALIGNED(param->name, 64) == 1);
+ CHK(IS_ALIGNED(param->ptr, 16) == 1);
+ CHK(param->d == PI);
+ CHK(param->i == -123);
+ CHK(strcmp(param->name, "0123456") == 0);
+ CHK(strcmp(param->ptr, "abc") == 0);
- CHECK(ssol_param_buffer_clear(pbuf), RES_OK);
+ CHK(ssol_param_buffer_clear(pbuf) == RES_OK);
sz = sizeof(struct param);
al = ALIGNOF(struct param);
- CHECK(ssol_image_create(dev, &img), RES_OK);
- CHECK(ssol_image_setup(img, 1280, 720, SSOL_PIXEL_DOUBLE3), RES_OK);
- NCHECK(param = ssol_param_buffer_allocate(pbuf, sz, al, ¶m_release), NULL);
+ CHK(ssol_image_create(dev, &img) == RES_OK);
+ CHK(ssol_image_setup(img, 1280, 720, SSOL_PIXEL_DOUBLE3) == RES_OK);
+ CHK((param = ssol_param_buffer_allocate(pbuf, sz, al, ¶m_release)) != NULL);
param->d = PI;
param->i = -123;
param->name = NULL;
param->ptr = NULL;
param->img = img;
- CHECK(ssol_image_ref_get(img), RES_OK);
+ CHK(ssol_image_ref_get(img) == RES_OK);
- NCHECK(param = ssol_param_buffer_allocate(pbuf, sz, al, ¶m_release), NULL);
+ CHK((param = ssol_param_buffer_allocate(pbuf, sz, al, ¶m_release)) != NULL);
param->d = 123.456;
param->i = -1;
param->name = NULL;
param->ptr = NULL;
param->img = img;
- CHECK(ssol_image_ref_get(img), RES_OK);
+ CHK(ssol_image_ref_get(img) == RES_OK);
- NCHECK(param = ssol_param_buffer_allocate(pbuf, sz, al, ¶m_release), NULL);
+ CHK((param = ssol_param_buffer_allocate(pbuf, sz, al, ¶m_release)) != NULL);
param->d = 0.1;
param->i = 789;
param->name = NULL;
param->ptr = NULL;
param->img = img;
- CHECK(ssol_image_ref_get(img), RES_OK);
+ CHK(ssol_image_ref_get(img) == RES_OK);
- CHECK(ssol_param_buffer_clear(pbuf), RES_OK);
+ CHK(ssol_param_buffer_clear(pbuf) == RES_OK);
- NCHECK(param = ssol_param_buffer_allocate(pbuf, sz, al, ¶m_release), NULL);
+ CHK((param = ssol_param_buffer_allocate(pbuf, sz, al, ¶m_release)) != NULL);
param->d = 0.1;
param->i = 789;
param->name = NULL;
param->ptr = NULL;
param->img = img;
- CHECK(ssol_image_ref_get(img), RES_OK);
+ CHK(ssol_image_ref_get(img) == RES_OK);
- CHECK(ssol_param_buffer_ref_get(NULL), RES_BAD_ARG);
- CHECK(ssol_param_buffer_ref_get(pbuf), RES_OK);
- CHECK(ssol_param_buffer_ref_put(NULL), RES_BAD_ARG);
- CHECK(ssol_param_buffer_ref_put(pbuf), RES_OK);
- CHECK(ssol_param_buffer_ref_put(pbuf), RES_OK);
+ CHK(ssol_param_buffer_ref_get(NULL) == RES_BAD_ARG);
+ CHK(ssol_param_buffer_ref_get(pbuf) == RES_OK);
+ CHK(ssol_param_buffer_ref_put(NULL) == RES_BAD_ARG);
+ CHK(ssol_param_buffer_ref_put(pbuf) == RES_OK);
+ CHK(ssol_param_buffer_ref_put(pbuf) == RES_OK);
- CHECK(ssol_param_buffer_create(dev, 8, &pbuf), RES_OK);
- NCHECK(mem = ssol_param_buffer_allocate(pbuf, 2, 1, NULL), NULL);
- CHECK(mem = ssol_param_buffer_allocate(pbuf, 1, 16, NULL), NULL);
+ CHK(ssol_param_buffer_create(dev, 8, &pbuf) == RES_OK);
+ CHK((mem = ssol_param_buffer_allocate(pbuf, 2, 1, NULL)) != NULL);
+ CHK((mem = ssol_param_buffer_allocate(pbuf, 1, 16, NULL)) == NULL);
- CHECK(ssol_image_ref_put(img), RES_OK);
- CHECK(ssol_param_buffer_ref_put(pbuf), RES_OK);
- CHECK(ssol_device_ref_put(dev), RES_OK);
+ CHK(ssol_image_ref_put(img) == RES_OK);
+ CHK(ssol_param_buffer_ref_put(pbuf) == RES_OK);
+ CHK(ssol_device_ref_put(dev) == RES_OK);
check_memory_allocator(&allocator);
mem_shutdown_proxy_allocator(&allocator);
- CHECK(mem_allocated_size(), 0);
+ CHK(mem_allocated_size() == 0);
return 0;
}
diff --git a/src/test_ssol_scene.c b/src/test_ssol_scene.c
@@ -30,14 +30,14 @@ static res_T
instance_func(struct ssol_instance* inst, void* context)
{
struct scene_ctx* ctx = context;
- NCHECK(inst, NULL);
+ CHK(inst != NULL);
if(!ctx) return RES_BAD_ARG;
if(inst == ctx->instance) {
- CHECK(ctx->instance_found, 0);
+ CHK(ctx->instance_found == 0);
ctx->instance_found = 1;
} else if(inst == ctx->instance2) {
- CHECK(ctx->instance2_found, 0);
+ CHK(ctx->instance2_found == 0);
ctx->instance2_found = 1;
} else {
FATAL("Unreachable code.\n");
@@ -88,182 +88,182 @@ main(int argc, char** argv)
mem_init_proxy_allocator(&allocator, &mem_default_allocator);
- CHECK(ssol_device_create
- (NULL, &allocator, SSOL_NTHREADS_DEFAULT, 0, &dev), RES_OK);
+ CHK(ssol_device_create
+ (NULL, &allocator, SSOL_NTHREADS_DEFAULT, 0, &dev) == RES_OK);
- CHECK(ssol_material_create_virtual(dev, &material), RES_OK);
+ CHK(ssol_material_create_virtual(dev, &material) == RES_OK);
- CHECK(ssol_shape_create_punched_surface(dev, &shape), RES_OK);
- CHECK(ssol_object_create(dev, &object), RES_OK);
- CHECK(ssol_object_add_shaded_shape(object, shape, material, material), RES_OK);
- CHECK(ssol_object_instantiate(object, &instance), RES_OK);
- CHECK(ssol_object_instantiate(object, &instance2), RES_OK);
- CHECK(ssol_instance_set_transform(instance, transform), RES_OK);
- CHECK(ssol_sun_create_directional(dev, &sun), RES_OK);
- CHECK(ssol_sun_create_directional(dev, &sun2), RES_OK);
+ CHK(ssol_shape_create_punched_surface(dev, &shape) == RES_OK);
+ CHK(ssol_object_create(dev, &object) == RES_OK);
+ CHK(ssol_object_add_shaded_shape(object, shape, material, material) == RES_OK);
+ CHK(ssol_object_instantiate(object, &instance) == RES_OK);
+ CHK(ssol_object_instantiate(object, &instance2) == RES_OK);
+ CHK(ssol_instance_set_transform(instance, transform) == RES_OK);
+ CHK(ssol_sun_create_directional(dev, &sun) == RES_OK);
+ CHK(ssol_sun_create_directional(dev, &sun2) == RES_OK);
- CHECK(ssol_scene_create(dev, &scene), RES_OK);
- CHECK(ssol_scene_create(dev, &scene2), RES_OK);
+ CHK(ssol_scene_create(dev, &scene) == RES_OK);
+ CHK(ssol_scene_create(dev, &scene2) == RES_OK);
- CHECK(ssol_scene_ref_get(NULL), RES_BAD_ARG);
- CHECK(ssol_scene_ref_get(scene), RES_OK);
+ CHK(ssol_scene_ref_get(NULL) == RES_BAD_ARG);
+ CHK(ssol_scene_ref_get(scene) == RES_OK);
- CHECK(ssol_scene_ref_put(NULL), RES_BAD_ARG);
- CHECK(ssol_scene_ref_put(scene), RES_OK);
+ CHK(ssol_scene_ref_put(NULL) == RES_BAD_ARG);
+ CHK(ssol_scene_ref_put(scene) == RES_OK);
- CHECK(ssol_scene_clear(NULL), RES_BAD_ARG);
- CHECK(ssol_scene_clear(scene), RES_OK);
+ CHK(ssol_scene_clear(NULL) == RES_BAD_ARG);
+ CHK(ssol_scene_clear(scene) == RES_OK);
- CHECK(ssol_scene_attach_instance(NULL, instance), RES_BAD_ARG);
- CHECK(ssol_scene_attach_instance(scene, NULL), RES_BAD_ARG);
- CHECK(ssol_scene_attach_instance(scene, instance), RES_OK);
- CHECK(ssol_scene_attach_instance(scene, instance), RES_OK);
- CHECK(ssol_scene_attach_instance(scene, instance2), RES_OK);
+ CHK(ssol_scene_attach_instance(NULL, instance) == RES_BAD_ARG);
+ CHK(ssol_scene_attach_instance(scene, NULL) == RES_BAD_ARG);
+ CHK(ssol_scene_attach_instance(scene, instance) == RES_OK);
+ CHK(ssol_scene_attach_instance(scene, instance) == RES_OK);
+ CHK(ssol_scene_attach_instance(scene, instance2) == RES_OK);
ctx.instance = instance;
ctx.instance2 = instance2;
ctx.instance_found = 0;
ctx.instance2_found = 0;
- CHECK(ssol_scene_for_each_instance(NULL, NULL, NULL), RES_BAD_ARG);
- CHECK(ssol_scene_for_each_instance(scene, NULL, NULL), RES_BAD_ARG);
- CHECK(ssol_scene_for_each_instance(NULL, instance_func, NULL), RES_BAD_ARG);
- CHECK(ssol_scene_for_each_instance(scene, instance_func, NULL), RES_BAD_ARG);
- CHECK(ssol_scene_for_each_instance(NULL, NULL, &ctx), RES_BAD_ARG);
- CHECK(ssol_scene_for_each_instance(scene, NULL, &ctx), RES_BAD_ARG);
- CHECK(ssol_scene_for_each_instance(NULL, instance_func, &ctx), RES_BAD_ARG);
- CHECK(ssol_scene_for_each_instance(scene, instance_func, &ctx), RES_OK);
- CHECK(ctx.instance_found, 1);
- CHECK(ctx.instance2_found, 1);
-
- CHECK(ssol_scene_detach_instance(NULL, instance), RES_BAD_ARG);
- CHECK(ssol_scene_detach_instance(scene, NULL), RES_BAD_ARG);
- CHECK(ssol_scene_detach_instance(scene, instance), RES_OK);
- CHECK(ssol_scene_detach_instance(scene, instance), RES_BAD_ARG);
- CHECK(ssol_scene_detach_instance(scene, instance2), RES_OK);
-
- CHECK(ssol_scene_attach_instance(scene, instance), RES_OK);
- CHECK(ssol_scene_attach_instance(scene2, instance), RES_OK);
- CHECK(ssol_scene_detach_instance(scene2, instance), RES_OK);
- CHECK(ssol_scene_detach_instance(scene, instance), RES_OK);
- CHECK(ssol_scene_attach_instance(scene, instance), RES_OK);
- CHECK(ssol_scene_detach_instance(scene2, instance), RES_BAD_ARG);
- CHECK(ssol_scene_detach_instance(scene, instance), RES_OK);
-
- CHECK(ssol_scene_attach_sun(NULL, sun), RES_BAD_ARG);
- CHECK(ssol_scene_attach_sun(scene, NULL), RES_BAD_ARG);
- CHECK(ssol_scene_attach_sun(scene, sun), RES_OK);
- CHECK(ssol_scene_attach_sun(scene, sun), RES_OK);
- CHECK(ssol_scene_attach_sun(scene, sun2), RES_BAD_ARG);
-
- CHECK(ssol_scene_detach_sun(NULL, sun), RES_BAD_ARG);
- CHECK(ssol_scene_detach_sun(scene, NULL), RES_BAD_ARG);
- CHECK(ssol_scene_detach_sun(scene, sun), RES_OK);
- CHECK(ssol_scene_detach_sun(scene, sun), RES_BAD_ARG);
-
- CHECK(ssol_scene_attach_sun(scene, sun), RES_OK);
- CHECK(ssol_scene_attach_sun(scene2, sun), RES_BAD_ARG);
- CHECK(ssol_scene_detach_sun(scene2, sun), RES_BAD_ARG);
- CHECK(ssol_scene_detach_sun(scene, sun), RES_OK);
- CHECK(ssol_scene_attach_sun(scene2, sun), RES_OK);
- CHECK(ssol_scene_detach_sun(scene, sun), RES_BAD_ARG);
- CHECK(ssol_scene_detach_sun(scene2, sun), RES_OK);
-
- CHECK(ssol_atmosphere_create(dev, &atm), RES_OK);
+ CHK(ssol_scene_for_each_instance(NULL, NULL, NULL) == RES_BAD_ARG);
+ CHK(ssol_scene_for_each_instance(scene, NULL, NULL) == RES_BAD_ARG);
+ CHK(ssol_scene_for_each_instance(NULL, instance_func, NULL) == RES_BAD_ARG);
+ CHK(ssol_scene_for_each_instance(scene, instance_func, NULL) == RES_BAD_ARG);
+ CHK(ssol_scene_for_each_instance(NULL, NULL, &ctx) == RES_BAD_ARG);
+ CHK(ssol_scene_for_each_instance(scene, NULL, &ctx) == RES_BAD_ARG);
+ CHK(ssol_scene_for_each_instance(NULL, instance_func, &ctx) == RES_BAD_ARG);
+ CHK(ssol_scene_for_each_instance(scene, instance_func, &ctx) == RES_OK);
+ CHK(ctx.instance_found == 1);
+ CHK(ctx.instance2_found == 1);
+
+ CHK(ssol_scene_detach_instance(NULL, instance) == RES_BAD_ARG);
+ CHK(ssol_scene_detach_instance(scene, NULL) == RES_BAD_ARG);
+ CHK(ssol_scene_detach_instance(scene, instance) == RES_OK);
+ CHK(ssol_scene_detach_instance(scene, instance) == RES_BAD_ARG);
+ CHK(ssol_scene_detach_instance(scene, instance2) == RES_OK);
+
+ CHK(ssol_scene_attach_instance(scene, instance) == RES_OK);
+ CHK(ssol_scene_attach_instance(scene2, instance) == RES_OK);
+ CHK(ssol_scene_detach_instance(scene2, instance) == RES_OK);
+ CHK(ssol_scene_detach_instance(scene, instance) == RES_OK);
+ CHK(ssol_scene_attach_instance(scene, instance) == RES_OK);
+ CHK(ssol_scene_detach_instance(scene2, instance) == RES_BAD_ARG);
+ CHK(ssol_scene_detach_instance(scene, instance) == RES_OK);
+
+ CHK(ssol_scene_attach_sun(NULL, sun) == RES_BAD_ARG);
+ CHK(ssol_scene_attach_sun(scene, NULL) == RES_BAD_ARG);
+ CHK(ssol_scene_attach_sun(scene, sun) == RES_OK);
+ CHK(ssol_scene_attach_sun(scene, sun) == RES_OK);
+ CHK(ssol_scene_attach_sun(scene, sun2) == RES_BAD_ARG);
+
+ CHK(ssol_scene_detach_sun(NULL, sun) == RES_BAD_ARG);
+ CHK(ssol_scene_detach_sun(scene, NULL) == RES_BAD_ARG);
+ CHK(ssol_scene_detach_sun(scene, sun) == RES_OK);
+ CHK(ssol_scene_detach_sun(scene, sun) == RES_BAD_ARG);
+
+ CHK(ssol_scene_attach_sun(scene, sun) == RES_OK);
+ CHK(ssol_scene_attach_sun(scene2, sun) == RES_BAD_ARG);
+ CHK(ssol_scene_detach_sun(scene2, sun) == RES_BAD_ARG);
+ CHK(ssol_scene_detach_sun(scene, sun) == RES_OK);
+ CHK(ssol_scene_attach_sun(scene2, sun) == RES_OK);
+ CHK(ssol_scene_detach_sun(scene, sun) == RES_BAD_ARG);
+ CHK(ssol_scene_detach_sun(scene2, sun) == RES_OK);
+
+ CHK(ssol_atmosphere_create(dev, &atm) == RES_OK);
extinction.type = SSOL_DATA_REAL;
extinction.value.real = 0.1;
- CHECK(ssol_atmosphere_set_extinction(atm, &extinction), RES_OK);
- CHECK(ssol_atmosphere_create(dev, &atm2), RES_OK);
- CHECK(ssol_atmosphere_set_extinction(atm2, &extinction), RES_OK);
-
- CHECK(ssol_scene_attach_atmosphere(NULL, atm), RES_BAD_ARG);
- CHECK(ssol_scene_attach_atmosphere(scene, NULL), RES_BAD_ARG);
- CHECK(ssol_scene_attach_atmosphere(scene, atm), RES_OK);
- CHECK(ssol_scene_attach_atmosphere(scene, atm), RES_OK);
- CHECK(ssol_scene_attach_atmosphere(scene, atm2), RES_BAD_ARG);
-
- CHECK(ssol_scene_detach_atmosphere(NULL, atm), RES_BAD_ARG);
- CHECK(ssol_scene_detach_atmosphere(scene, NULL), RES_BAD_ARG);
- CHECK(ssol_scene_detach_atmosphere(scene, atm), RES_OK);
- CHECK(ssol_scene_detach_atmosphere(scene, atm), RES_BAD_ARG);
-
- CHECK(ssol_scene_attach_atmosphere(scene, atm), RES_OK);
- CHECK(ssol_scene_attach_atmosphere(scene2, atm), RES_BAD_ARG);
- CHECK(ssol_scene_detach_atmosphere(scene2, atm), RES_BAD_ARG);
- CHECK(ssol_scene_detach_atmosphere(scene, atm), RES_OK);
- CHECK(ssol_scene_attach_atmosphere(scene2, atm), RES_OK);
- CHECK(ssol_scene_detach_atmosphere(scene, atm), RES_BAD_ARG);
- CHECK(ssol_scene_detach_atmosphere(scene2, atm), RES_OK);
-
- CHECK(ssol_scene_detach_sun(scene, sun2), RES_BAD_ARG);
- CHECK(ssol_sun_ref_put(sun2), RES_OK);
-
- CHECK(ssol_scene_attach_instance(scene, instance), RES_OK);
- CHECK(ssol_scene_attach_sun(scene, sun), RES_OK);
- CHECK(ssol_scene_attach_atmosphere(scene, atm), RES_OK);
- CHECK(ssol_scene_clear(scene), RES_OK);
-
- CHECK(ssol_scene_ref_put(scene), RES_OK);
- CHECK(ssol_scene_ref_put(scene2), RES_OK);
- CHECK(ssol_shape_ref_put(shape), RES_OK);
- CHECK(ssol_object_ref_put(object), RES_OK);
- CHECK(ssol_instance_ref_put(instance), RES_OK);
-
- CHECK(ssol_scene_create(dev, &scene), RES_OK);
- CHECK(ssol_shape_create_mesh(dev, &shape), RES_OK);
- CHECK(ssol_object_create(dev, &object), RES_OK);
+ CHK(ssol_atmosphere_set_extinction(atm, &extinction) == RES_OK);
+ CHK(ssol_atmosphere_create(dev, &atm2) == RES_OK);
+ CHK(ssol_atmosphere_set_extinction(atm2, &extinction) == RES_OK);
+
+ CHK(ssol_scene_attach_atmosphere(NULL, atm) == RES_BAD_ARG);
+ CHK(ssol_scene_attach_atmosphere(scene, NULL) == RES_BAD_ARG);
+ CHK(ssol_scene_attach_atmosphere(scene, atm) == RES_OK);
+ CHK(ssol_scene_attach_atmosphere(scene, atm) == RES_OK);
+ CHK(ssol_scene_attach_atmosphere(scene, atm2) == RES_BAD_ARG);
+
+ CHK(ssol_scene_detach_atmosphere(NULL, atm) == RES_BAD_ARG);
+ CHK(ssol_scene_detach_atmosphere(scene, NULL) == RES_BAD_ARG);
+ CHK(ssol_scene_detach_atmosphere(scene, atm) == RES_OK);
+ CHK(ssol_scene_detach_atmosphere(scene, atm) == RES_BAD_ARG);
+
+ CHK(ssol_scene_attach_atmosphere(scene, atm) == RES_OK);
+ CHK(ssol_scene_attach_atmosphere(scene2, atm) == RES_BAD_ARG);
+ CHK(ssol_scene_detach_atmosphere(scene2, atm) == RES_BAD_ARG);
+ CHK(ssol_scene_detach_atmosphere(scene, atm) == RES_OK);
+ CHK(ssol_scene_attach_atmosphere(scene2, atm) == RES_OK);
+ CHK(ssol_scene_detach_atmosphere(scene, atm) == RES_BAD_ARG);
+ CHK(ssol_scene_detach_atmosphere(scene2, atm) == RES_OK);
+
+ CHK(ssol_scene_detach_sun(scene, sun2) == RES_BAD_ARG);
+ CHK(ssol_sun_ref_put(sun2) == RES_OK);
+
+ CHK(ssol_scene_attach_instance(scene, instance) == RES_OK);
+ CHK(ssol_scene_attach_sun(scene, sun) == RES_OK);
+ CHK(ssol_scene_attach_atmosphere(scene, atm) == RES_OK);
+ CHK(ssol_scene_clear(scene) == RES_OK);
+
+ CHK(ssol_scene_ref_put(scene) == RES_OK);
+ CHK(ssol_scene_ref_put(scene2) == RES_OK);
+ CHK(ssol_shape_ref_put(shape) == RES_OK);
+ CHK(ssol_object_ref_put(object) == RES_OK);
+ CHK(ssol_instance_ref_put(instance) == RES_OK);
+
+ CHK(ssol_scene_create(dev, &scene) == RES_OK);
+ CHK(ssol_shape_create_mesh(dev, &shape) == RES_OK);
+ CHK(ssol_object_create(dev, &object) == RES_OK);
vdata.usage = SSOL_POSITION;
vdata.get = get_position;
desc.vertices = tall_block;;
desc.indices = block_ids;
- CHECK(ssol_mesh_setup(shape, 10, get_ids, 8, &vdata, 1, &desc), RES_OK);
- CHECK(ssol_object_add_shaded_shape(object, shape, material, material), RES_OK);
- CHECK(ssol_object_instantiate(object, &instance), RES_OK);
+ CHK(ssol_mesh_setup(shape, 10, get_ids, 8, &vdata, 1, &desc) == RES_OK);
+ CHK(ssol_object_add_shaded_shape(object, shape, material, material) == RES_OK);
+ CHK(ssol_object_instantiate(object, &instance) == RES_OK);
- CHECK(ssol_scene_compute_aabb(NULL, NULL, NULL), RES_BAD_ARG);
- CHECK(ssol_scene_compute_aabb(scene, NULL, NULL), RES_BAD_ARG);
- CHECK(ssol_scene_compute_aabb(NULL, lower, NULL), RES_BAD_ARG);
- CHECK(ssol_scene_compute_aabb(scene, lower, NULL), RES_BAD_ARG);
- CHECK(ssol_scene_compute_aabb(NULL, NULL, upper), RES_BAD_ARG);
- CHECK(ssol_scene_compute_aabb(scene, NULL, upper), RES_BAD_ARG);
- CHECK(ssol_scene_compute_aabb(NULL, lower, upper), RES_BAD_ARG);
- CHECK(ssol_scene_compute_aabb(scene, lower, upper), RES_OK);
+ CHK(ssol_scene_compute_aabb(NULL, NULL, NULL) == RES_BAD_ARG);
+ CHK(ssol_scene_compute_aabb(scene, NULL, NULL) == RES_BAD_ARG);
+ CHK(ssol_scene_compute_aabb(NULL, lower, NULL) == RES_BAD_ARG);
+ CHK(ssol_scene_compute_aabb(scene, lower, NULL) == RES_BAD_ARG);
+ CHK(ssol_scene_compute_aabb(NULL, NULL, upper) == RES_BAD_ARG);
+ CHK(ssol_scene_compute_aabb(scene, NULL, upper) == RES_BAD_ARG);
+ CHK(ssol_scene_compute_aabb(NULL, lower, upper) == RES_BAD_ARG);
+ CHK(ssol_scene_compute_aabb(scene, lower, upper) == RES_OK);
/* Empty scene */
- CHECK(lower[0] > upper[0], 1);
- CHECK(lower[1] > upper[1], 1);
- CHECK(lower[2] > upper[2], 1);
+ CHK(lower[0] > upper[0]);
+ CHK(lower[1] > upper[1]);
+ CHK(lower[2] > upper[2]);
- CHECK(ssol_scene_attach_instance(scene, instance), RES_OK);
- CHECK(ssol_scene_compute_aabb(scene, lower, upper), RES_OK);
- CHECK(f3_eq_eps(lower, f3(tmp, 265.f, 247.f, 0.f), 1.e-6f), 1);
- CHECK(f3_eq_eps(upper, f3(tmp, 472.f, 456.f, 330.f), 1.e-6f), 1);
+ CHK(ssol_scene_attach_instance(scene, instance) == RES_OK);
+ CHK(ssol_scene_compute_aabb(scene, lower, upper) == RES_OK);
+ CHK(f3_eq_eps(lower, f3(tmp, 265.f, 247.f, 0.f), 1.e-6f) == 1);
+ CHK(f3_eq_eps(upper, f3(tmp, 472.f, 456.f, 330.f), 1.e-6f) == 1);
- CHECK(ssol_scene_clear(scene), RES_OK);
- CHECK(ssol_scene_compute_aabb(scene, lower, upper), RES_OK);
+ CHK(ssol_scene_clear(scene) == RES_OK);
+ CHK(ssol_scene_compute_aabb(scene, lower, upper) == RES_OK);
/* Empty scene */
- CHECK(lower[0] > upper[0], 1);
- CHECK(lower[1] > upper[1], 1);
- CHECK(lower[2] > upper[2], 1);
+ CHK(lower[0] > upper[0]);
+ CHK(lower[1] > upper[1]);
+ CHK(lower[2] > upper[2]);
- CHECK(ssol_scene_ref_put(scene), RES_OK);
+ CHK(ssol_scene_ref_put(scene) == RES_OK);
- CHECK(ssol_instance_ref_put(instance), RES_OK);
- CHECK(ssol_instance_ref_put(instance2), RES_OK);
- CHECK(ssol_object_ref_put(object), RES_OK);
- CHECK(ssol_shape_ref_put(shape), RES_OK);
- CHECK(ssol_sun_ref_put(sun), RES_OK);
- CHECK(ssol_atmosphere_ref_put(atm), RES_OK);
- CHECK(ssol_atmosphere_ref_put(atm2), RES_OK);
- CHECK(ssol_material_ref_put(material), RES_OK);
+ CHK(ssol_instance_ref_put(instance) == RES_OK);
+ CHK(ssol_instance_ref_put(instance2) == RES_OK);
+ CHK(ssol_object_ref_put(object) == RES_OK);
+ CHK(ssol_shape_ref_put(shape) == RES_OK);
+ CHK(ssol_sun_ref_put(sun) == RES_OK);
+ CHK(ssol_atmosphere_ref_put(atm) == RES_OK);
+ CHK(ssol_atmosphere_ref_put(atm2) == RES_OK);
+ CHK(ssol_material_ref_put(material) == RES_OK);
- CHECK(ssol_device_ref_put(dev), RES_OK);
+ CHK(ssol_device_ref_put(dev) == RES_OK);
check_memory_allocator(&allocator);
mem_shutdown_proxy_allocator(&allocator);
- CHECK(mem_allocated_size(), 0);
+ CHK(mem_allocated_size() == 0);
return 0;
}
diff --git a/src/test_ssol_shape.c b/src/test_ssol_shape.c
@@ -43,19 +43,19 @@ main(int argc, char** argv)
mem_init_proxy_allocator(&allocator, &mem_default_allocator);
- CHECK(ssol_device_create
- (NULL, &allocator, SSOL_NTHREADS_DEFAULT, 0, &dev), RES_OK);
+ CHK(ssol_device_create
+ (NULL, &allocator, SSOL_NTHREADS_DEFAULT, 0, &dev) == RES_OK);
- CHECK(ssol_shape_create_mesh(NULL, NULL), RES_BAD_ARG);
- CHECK(ssol_shape_create_mesh(dev, NULL), RES_BAD_ARG);
- CHECK(ssol_shape_create_mesh(NULL, &shape), RES_BAD_ARG);
- CHECK(ssol_shape_create_mesh(dev, &shape), RES_OK);
+ CHK(ssol_shape_create_mesh(NULL, NULL) == RES_BAD_ARG);
+ CHK(ssol_shape_create_mesh(dev, NULL) == RES_BAD_ARG);
+ CHK(ssol_shape_create_mesh(NULL, &shape) == RES_BAD_ARG);
+ CHK(ssol_shape_create_mesh(dev, &shape) == RES_OK);
- CHECK(ssol_shape_ref_get(NULL), RES_BAD_ARG);
- CHECK(ssol_shape_ref_get(shape), RES_OK);
+ CHK(ssol_shape_ref_get(NULL) == RES_BAD_ARG);
+ CHK(ssol_shape_ref_get(shape) == RES_OK);
- CHECK(ssol_shape_ref_put(NULL), RES_BAD_ARG);
- CHECK(ssol_shape_ref_put(shape), RES_OK);
+ CHK(ssol_shape_ref_put(NULL) == RES_BAD_ARG);
+ CHK(ssol_shape_ref_put(shape) == RES_OK);
attribs[0].usage = SSOL_POSITION;
attribs[0].get = get_position;
@@ -64,93 +64,93 @@ main(int argc, char** argv)
attribs[2].usage = SSOL_TEXCOORD;
attribs[2].get = get_uv;
- CHECK(ssol_mesh_setup(NULL, SQUARE_NTRIS__, get_ids, SQUARE_NVERTS__,
- attribs, 1, (void*)&SQUARE_DESC__), RES_BAD_ARG);
- CHECK(ssol_mesh_setup(shape, 0, get_ids, SQUARE_NVERTS__, attribs, 1,
- (void*)&SQUARE_DESC__), RES_BAD_ARG);
- CHECK(ssol_mesh_setup(shape, SQUARE_NTRIS__, NULL, SQUARE_NVERTS__,
- attribs, 1, (void*)&SQUARE_DESC__), RES_BAD_ARG);
- CHECK(ssol_mesh_setup(shape, SQUARE_NTRIS__, get_ids, 0, attribs, 1,
- (void*)&SQUARE_DESC__), RES_BAD_ARG);
- CHECK(ssol_mesh_setup(shape, SQUARE_NTRIS__, get_ids, SQUARE_NVERTS__,
- NULL, 1, (void*)&SQUARE_DESC__), RES_BAD_ARG);
- CHECK(ssol_mesh_setup(shape, SQUARE_NTRIS__, get_ids, SQUARE_NVERTS__,
- attribs, 0, (void*)&SQUARE_DESC__), RES_BAD_ARG);
- CHECK(ssol_mesh_setup(shape, SQUARE_NTRIS__, get_ids, SQUARE_NVERTS__,
- attribs, 3, (void*)&SQUARE_DESC__), RES_OK);
-
- CHECK(ssol_shape_get_vertices_count(NULL, NULL), RES_BAD_ARG);
- CHECK(ssol_shape_get_vertices_count(shape, NULL), RES_BAD_ARG);
- CHECK(ssol_shape_get_vertices_count(NULL, &n), RES_BAD_ARG);
- CHECK(ssol_shape_get_vertices_count(shape, &n), RES_OK);
- CHECK(n, SQUARE_NVERTS__);
-
- CHECK(ssol_shape_get_vertex_attrib(NULL, n, (unsigned)-1, NULL), RES_BAD_ARG);
- CHECK(ssol_shape_get_vertex_attrib(shape, n, (unsigned)-1, NULL), RES_BAD_ARG);
- CHECK(ssol_shape_get_vertex_attrib(NULL, 0, (unsigned)-1, NULL), RES_BAD_ARG);
- CHECK(ssol_shape_get_vertex_attrib(shape, 0, (unsigned)-1, NULL), RES_BAD_ARG);
- CHECK(ssol_shape_get_vertex_attrib(NULL, n, SSOL_POSITION, NULL), RES_BAD_ARG);
- CHECK(ssol_shape_get_vertex_attrib(shape, n, SSOL_POSITION, NULL), RES_BAD_ARG);
- CHECK(ssol_shape_get_vertex_attrib(NULL, 0, SSOL_POSITION, NULL), RES_BAD_ARG);
- CHECK(ssol_shape_get_vertex_attrib(shape, 0, SSOL_POSITION, NULL), RES_BAD_ARG);
- CHECK(ssol_shape_get_vertex_attrib(NULL, n, (unsigned)-1, val), RES_BAD_ARG);
- CHECK(ssol_shape_get_vertex_attrib(shape, n, (unsigned)-1, val), RES_BAD_ARG);
- CHECK(ssol_shape_get_vertex_attrib(NULL, 0, (unsigned)-1, val), RES_BAD_ARG);
- CHECK(ssol_shape_get_vertex_attrib(shape, 0, (unsigned)-1,val), RES_BAD_ARG);
- CHECK(ssol_shape_get_vertex_attrib(NULL, n, SSOL_POSITION, val), RES_BAD_ARG);
- CHECK(ssol_shape_get_vertex_attrib(shape, n, SSOL_POSITION, val), RES_BAD_ARG);
- CHECK(ssol_shape_get_vertex_attrib(NULL, 0, SSOL_POSITION, val), RES_BAD_ARG);
+ CHK(ssol_mesh_setup(NULL, SQUARE_NTRIS__, get_ids, SQUARE_NVERTS__,
+ attribs, 1, (void*)&SQUARE_DESC__) == RES_BAD_ARG);
+ CHK(ssol_mesh_setup(shape, 0, get_ids, SQUARE_NVERTS__, attribs, 1,
+ (void*)&SQUARE_DESC__) == RES_BAD_ARG);
+ CHK(ssol_mesh_setup(shape, SQUARE_NTRIS__, NULL, SQUARE_NVERTS__,
+ attribs, 1, (void*)&SQUARE_DESC__) == RES_BAD_ARG);
+ CHK(ssol_mesh_setup(shape, SQUARE_NTRIS__, get_ids, 0, attribs, 1,
+ (void*)&SQUARE_DESC__) == RES_BAD_ARG);
+ CHK(ssol_mesh_setup(shape, SQUARE_NTRIS__, get_ids, SQUARE_NVERTS__,
+ NULL, 1, (void*)&SQUARE_DESC__) == RES_BAD_ARG);
+ CHK(ssol_mesh_setup(shape, SQUARE_NTRIS__, get_ids, SQUARE_NVERTS__,
+ attribs, 0, (void*)&SQUARE_DESC__) == RES_BAD_ARG);
+ CHK(ssol_mesh_setup(shape, SQUARE_NTRIS__, get_ids, SQUARE_NVERTS__,
+ attribs, 3, (void*)&SQUARE_DESC__) == RES_OK);
+
+ CHK(ssol_shape_get_vertices_count(NULL, NULL) == RES_BAD_ARG);
+ CHK(ssol_shape_get_vertices_count(shape, NULL) == RES_BAD_ARG);
+ CHK(ssol_shape_get_vertices_count(NULL, &n) == RES_BAD_ARG);
+ CHK(ssol_shape_get_vertices_count(shape, &n) == RES_OK);
+ CHK(n == SQUARE_NVERTS__);
+
+ CHK(ssol_shape_get_vertex_attrib(NULL, n, (unsigned)-1, NULL) == RES_BAD_ARG);
+ CHK(ssol_shape_get_vertex_attrib(shape, n, (unsigned)-1, NULL) == RES_BAD_ARG);
+ CHK(ssol_shape_get_vertex_attrib(NULL, 0, (unsigned)-1, NULL) == RES_BAD_ARG);
+ CHK(ssol_shape_get_vertex_attrib(shape, 0, (unsigned)-1, NULL) == RES_BAD_ARG);
+ CHK(ssol_shape_get_vertex_attrib(NULL, n, SSOL_POSITION, NULL) == RES_BAD_ARG);
+ CHK(ssol_shape_get_vertex_attrib(shape, n, SSOL_POSITION, NULL) == RES_BAD_ARG);
+ CHK(ssol_shape_get_vertex_attrib(NULL, 0, SSOL_POSITION, NULL) == RES_BAD_ARG);
+ CHK(ssol_shape_get_vertex_attrib(shape, 0, SSOL_POSITION, NULL) == RES_BAD_ARG);
+ CHK(ssol_shape_get_vertex_attrib(NULL, n, (unsigned)-1, val) == RES_BAD_ARG);
+ CHK(ssol_shape_get_vertex_attrib(shape, n, (unsigned)-1, val) == RES_BAD_ARG);
+ CHK(ssol_shape_get_vertex_attrib(NULL, 0, (unsigned)-1, val) == RES_BAD_ARG);
+ CHK(ssol_shape_get_vertex_attrib(shape, 0, (unsigned)-1,val) == RES_BAD_ARG);
+ CHK(ssol_shape_get_vertex_attrib(NULL, n, SSOL_POSITION, val) == RES_BAD_ARG);
+ CHK(ssol_shape_get_vertex_attrib(shape, n, SSOL_POSITION, val) == RES_BAD_ARG);
+ CHK(ssol_shape_get_vertex_attrib(NULL, 0, SSOL_POSITION, val) == RES_BAD_ARG);
FOR_EACH(i, 0, n) {
float valf[3];
- CHECK(ssol_shape_get_vertex_attrib(shape, i, SSOL_POSITION, val), RES_OK);
+ CHK(ssol_shape_get_vertex_attrib(shape, i, SSOL_POSITION, val) == RES_OK);
get_position(i, valf, (void*)&SQUARE_DESC__);
- CHECK((float)val[0], valf[0]);
- CHECK((float)val[1], valf[1]);
- CHECK((float)val[2], valf[2]);
+ CHK((float)val[0] == valf[0]);
+ CHK((float)val[1] == valf[1]);
+ CHK((float)val[2] == valf[2]);
- CHECK(ssol_shape_get_vertex_attrib(shape, i, SSOL_NORMAL, val), RES_OK);
+ CHK(ssol_shape_get_vertex_attrib(shape, i, SSOL_NORMAL, val) == RES_OK);
get_normal(i, valf, (void*)&SQUARE_DESC__);
- CHECK((float)val[0], valf[0]);
- CHECK((float)val[1], valf[1]);
- CHECK((float)val[2], valf[2]);
+ CHK((float)val[0] == valf[0]);
+ CHK((float)val[1] == valf[1]);
+ CHK((float)val[2] == valf[2]);
- CHECK(ssol_shape_get_vertex_attrib(shape, i, SSOL_TEXCOORD, val), RES_OK);
+ CHK(ssol_shape_get_vertex_attrib(shape, i, SSOL_TEXCOORD, val) == RES_OK);
get_uv(i, valf, (void*)&SQUARE_DESC__);
- CHECK((float)val[0], valf[0]);
- CHECK((float)val[1], valf[1]);
+ CHK((float)val[0] == valf[0]);
+ CHK((float)val[1] == valf[1]);
}
- CHECK(ssol_shape_get_triangles_count(NULL, NULL), RES_BAD_ARG);
- CHECK(ssol_shape_get_triangles_count(shape, NULL), RES_BAD_ARG);
- CHECK(ssol_shape_get_triangles_count(NULL, &n), RES_BAD_ARG);
- CHECK(ssol_shape_get_triangles_count(shape, &n), RES_OK);
- CHECK(n, SQUARE_NTRIS__);
+ CHK(ssol_shape_get_triangles_count(NULL, NULL) == RES_BAD_ARG);
+ CHK(ssol_shape_get_triangles_count(shape, NULL) == RES_BAD_ARG);
+ CHK(ssol_shape_get_triangles_count(NULL, &n) == RES_BAD_ARG);
+ CHK(ssol_shape_get_triangles_count(shape, &n) == RES_OK);
+ CHK(n == SQUARE_NTRIS__);
- CHECK(ssol_shape_get_triangle_indices(NULL, n, NULL), RES_BAD_ARG);
- CHECK(ssol_shape_get_triangle_indices(shape, n, NULL), RES_BAD_ARG);
- CHECK(ssol_shape_get_triangle_indices(NULL, 0, NULL), RES_BAD_ARG);
- CHECK(ssol_shape_get_triangle_indices(shape, 0, NULL), RES_BAD_ARG);
- CHECK(ssol_shape_get_triangle_indices(NULL, n, ids), RES_BAD_ARG);
- CHECK(ssol_shape_get_triangle_indices(shape, n, ids), RES_BAD_ARG);
- CHECK(ssol_shape_get_triangle_indices(NULL, 0, ids), RES_BAD_ARG);
+ CHK(ssol_shape_get_triangle_indices(NULL, n, NULL) == RES_BAD_ARG);
+ CHK(ssol_shape_get_triangle_indices(shape, n, NULL) == RES_BAD_ARG);
+ CHK(ssol_shape_get_triangle_indices(NULL, 0, NULL) == RES_BAD_ARG);
+ CHK(ssol_shape_get_triangle_indices(shape, 0, NULL) == RES_BAD_ARG);
+ CHK(ssol_shape_get_triangle_indices(NULL, n, ids) == RES_BAD_ARG);
+ CHK(ssol_shape_get_triangle_indices(shape, n, ids) == RES_BAD_ARG);
+ CHK(ssol_shape_get_triangle_indices(NULL, 0, ids) == RES_BAD_ARG);
FOR_EACH(i, 0, n) {
unsigned ids2[3];
- CHECK(ssol_shape_get_triangle_indices(shape, i, ids), RES_OK);
+ CHK(ssol_shape_get_triangle_indices(shape, i, ids) == RES_OK);
get_ids(i, ids2, (void*)&SQUARE_DESC__);
- CHECK(ids[0], ids2[0]);
- CHECK(ids[1], ids2[1]);
- CHECK(ids[2], ids2[2]);
+ CHK(ids[0] == ids2[0]);
+ CHK(ids[1] == ids2[1]);
+ CHK(ids[2] == ids2[2]);
}
- CHECK(ssol_shape_ref_put(shape), RES_OK);
+ CHK(ssol_shape_ref_put(shape) == RES_OK);
- CHECK(ssol_shape_create_punched_surface(NULL, NULL), RES_BAD_ARG);
- CHECK(ssol_shape_create_punched_surface(dev, NULL), RES_BAD_ARG);
- CHECK(ssol_shape_create_punched_surface(NULL, &shape), RES_BAD_ARG);
- CHECK(ssol_shape_create_punched_surface(dev, &shape), RES_OK);
+ CHK(ssol_shape_create_punched_surface(NULL, NULL) == RES_BAD_ARG);
+ CHK(ssol_shape_create_punched_surface(dev, NULL) == RES_BAD_ARG);
+ CHK(ssol_shape_create_punched_surface(NULL, &shape) == RES_BAD_ARG);
+ CHK(ssol_shape_create_punched_surface(dev, &shape) == RES_OK);
carving.get = get_polygon_vertices;
carving.operation = SSOL_AND;
@@ -160,91 +160,91 @@ main(int argc, char** argv)
punched_surface.nb_carvings = 1;
punched_surface.quadric = &quadric;
punched_surface.carvings = &carving;
- CHECK(ssol_punched_surface_setup(shape, &punched_surface), RES_OK);
+ CHK(ssol_punched_surface_setup(shape, &punched_surface) == RES_OK);
punched_surface.nb_carvings = 0;
- CHECK(ssol_punched_surface_setup(shape, &punched_surface), RES_BAD_ARG);
+ CHK(ssol_punched_surface_setup(shape, &punched_surface) == RES_BAD_ARG);
punched_surface.nb_carvings = 1;
punched_surface.carvings = NULL;
- CHECK(ssol_punched_surface_setup(shape, &punched_surface), RES_BAD_ARG);
+ CHK(ssol_punched_surface_setup(shape, &punched_surface) == RES_BAD_ARG);
punched_surface.carvings = &carving;
punched_surface.quadric = NULL;
- CHECK(ssol_punched_surface_setup(shape, &punched_surface), RES_BAD_ARG);
+ CHK(ssol_punched_surface_setup(shape, &punched_surface) == RES_BAD_ARG);
punched_surface.quadric = &quadric;
quadric.type = (enum ssol_quadric_type)999;
- CHECK(ssol_punched_surface_setup(shape, &punched_surface), RES_BAD_ARG);
+ CHK(ssol_punched_surface_setup(shape, &punched_surface) == RES_BAD_ARG);
quadric.type = SSOL_QUADRIC_PLANE;
carving.nb_vertices = 0;
- CHECK(ssol_punched_surface_setup(shape, &punched_surface), RES_BAD_ARG);
+ CHK(ssol_punched_surface_setup(shape, &punched_surface) == RES_BAD_ARG);
carving.nb_vertices = npolygon_verts;
carving.get = NULL;
- CHECK(ssol_punched_surface_setup(shape, &punched_surface), RES_BAD_ARG);
+ CHK(ssol_punched_surface_setup(shape, &punched_surface) == RES_BAD_ARG);
carving.get = get_polygon_vertices;
quadric.type = SSOL_QUADRIC_PARABOL;
quadric.data.parabol.focal = 1;
- CHECK(ssol_punched_surface_setup(shape, &punched_surface), RES_OK);
+ CHK(ssol_punched_surface_setup(shape, &punched_surface) == RES_OK);
punched_surface.nb_carvings = 0;
- CHECK(ssol_punched_surface_setup(shape, &punched_surface), RES_BAD_ARG);
+ CHK(ssol_punched_surface_setup(shape, &punched_surface) == RES_BAD_ARG);
punched_surface.nb_carvings = 1;
quadric.data.parabol.focal = 0;
- CHECK(ssol_punched_surface_setup(shape, &punched_surface), RES_BAD_ARG);
+ CHK(ssol_punched_surface_setup(shape, &punched_surface) == RES_BAD_ARG);
quadric.data.parabol.focal = 1;
quadric.type = SSOL_QUADRIC_HYPERBOL;
quadric.data.hyperbol.real_focal = 1;
quadric.data.hyperbol.img_focal = 1;
- CHECK(ssol_punched_surface_setup(shape, &punched_surface), RES_OK);
+ CHK(ssol_punched_surface_setup(shape, &punched_surface) == RES_OK);
punched_surface.nb_carvings = 0;
- CHECK(ssol_punched_surface_setup(shape, &punched_surface), RES_BAD_ARG);
+ CHK(ssol_punched_surface_setup(shape, &punched_surface) == RES_BAD_ARG);
punched_surface.nb_carvings = 1;
quadric.data.hyperbol.real_focal = 0;
- CHECK(ssol_punched_surface_setup(shape, &punched_surface), RES_BAD_ARG);
+ CHK(ssol_punched_surface_setup(shape, &punched_surface) == RES_BAD_ARG);
quadric.data.hyperbol.real_focal = 1;
quadric.data.hyperbol.img_focal = 0;
- CHECK(ssol_punched_surface_setup(shape, &punched_surface), RES_BAD_ARG);
+ CHK(ssol_punched_surface_setup(shape, &punched_surface) == RES_BAD_ARG);
quadric.data.hyperbol.img_focal = 1;
quadric.type = SSOL_QUADRIC_PARABOLIC_CYLINDER;
quadric.data.parabolic_cylinder.focal = 1;
- CHECK(ssol_punched_surface_setup(shape, &punched_surface), RES_OK);
+ CHK(ssol_punched_surface_setup(shape, &punched_surface) == RES_OK);
punched_surface.nb_carvings = 0;
- CHECK(ssol_punched_surface_setup(shape, &punched_surface), RES_BAD_ARG);
+ CHK(ssol_punched_surface_setup(shape, &punched_surface) == RES_BAD_ARG);
punched_surface.nb_carvings = 1;
quadric.data.parabolic_cylinder.focal = 0;
- CHECK(ssol_punched_surface_setup(shape, &punched_surface), RES_BAD_ARG);
+ CHK(ssol_punched_surface_setup(shape, &punched_surface) == RES_BAD_ARG);
quadric.data.parabolic_cylinder.focal = 1;
quadric.type = SSOL_QUADRIC_HEMISPHERE;
quadric.data.hemisphere.radius = 10;
- CHECK(ssol_punched_surface_setup(shape, &punched_surface), RES_OK);
+ CHK(ssol_punched_surface_setup(shape, &punched_surface) == RES_OK);
punched_surface.nb_carvings = 0;
- CHECK(ssol_punched_surface_setup(shape, &punched_surface), RES_OK);
+ CHK(ssol_punched_surface_setup(shape, &punched_surface) == RES_OK);
punched_surface.nb_carvings = 1;
quadric.data.hemisphere.radius = 0;
- CHECK(ssol_punched_surface_setup(shape, &punched_surface), RES_BAD_ARG);
+ CHK(ssol_punched_surface_setup(shape, &punched_surface) == RES_BAD_ARG);
quadric.data.hemisphere.radius = 10;
- CHECK(ssol_shape_ref_put(shape), RES_OK);
- CHECK(ssol_device_ref_put(dev), RES_OK);
+ CHK(ssol_shape_ref_put(shape) == RES_OK);
+ CHK(ssol_device_ref_put(dev) == RES_OK);
check_memory_allocator(&allocator);
mem_shutdown_proxy_allocator(&allocator);
- CHECK(mem_allocated_size(), 0);
+ CHK(mem_allocated_size() == 0);
return 0;
}
diff --git a/src/test_ssol_solver1.c b/src/test_ssol_solver1.c
@@ -39,7 +39,7 @@ static void
get_wlen(const size_t i, double* wlen, double* data, void* ctx)
{
const struct spectrum_desc* desc = ctx;
- CHECK(i < desc->count, 1);
+ CHK(i < desc->count);
*wlen = desc->wavelengths[i];
*data = desc->intensities[i];
}
@@ -103,198 +103,198 @@ main(int argc, char** argv)
mem_init_proxy_allocator(&allocator, &mem_default_allocator);
- CHECK(ssol_device_create
- (NULL, &allocator, SSOL_NTHREADS_DEFAULT, 0, &dev), RES_OK);
+ CHK(ssol_device_create
+ (NULL, &allocator, SSOL_NTHREADS_DEFAULT, 0, &dev) == RES_OK);
- CHECK(ssp_rng_create(&allocator, &ssp_rng_threefry, &rng), RES_OK);
+ CHK(ssp_rng_create(&allocator, &ssp_rng_threefry, &rng) == RES_OK);
desc.wavelengths = wavelengths;
desc.intensities = intensities;
desc.count = 3;
- CHECK(ssol_spectrum_create(dev, &spectrum), RES_OK);
- CHECK(ssol_spectrum_setup(spectrum, get_wlen, 3, &desc), RES_OK);
- CHECK(ssol_sun_create_directional(dev, &sun), RES_OK);
- CHECK(ssol_sun_set_direction(sun, d3(dir, 1, 0, -1)), RES_OK);
- CHECK(ssol_sun_set_spectrum(sun, spectrum), RES_OK);
+ CHK(ssol_spectrum_create(dev, &spectrum) == RES_OK);
+ CHK(ssol_spectrum_setup(spectrum, get_wlen, 3, &desc) == RES_OK);
+ CHK(ssol_sun_create_directional(dev, &sun) == RES_OK);
+ CHK(ssol_sun_set_direction(sun, d3(dir, 1, 0, -1)) == RES_OK);
+ CHK(ssol_sun_set_spectrum(sun, spectrum) == RES_OK);
#define DNI 1000
- CHECK(ssol_sun_set_dni(sun, DNI), RES_OK);
- CHECK(ssol_scene_create(dev, &scene), RES_OK);
+ CHK(ssol_sun_set_dni(sun, DNI) == RES_OK);
+ CHK(ssol_scene_create(dev, &scene) == RES_OK);
- CHECK(ssol_solve(NULL, rng, 10, 0, NULL, &estimator), RES_BAD_ARG);
- CHECK(ssol_solve(scene, NULL, 10, 0, NULL, &estimator), RES_BAD_ARG);
- CHECK(ssol_solve(scene, rng, 0, 0, NULL, &estimator), RES_BAD_ARG);
- CHECK(ssol_solve(scene, rng, 10, 0, NULL, &estimator), RES_BAD_ARG);
- CHECK(ssol_solve(scene, rng, 10, 0, NULL, NULL), RES_BAD_ARG);
+ CHK(ssol_solve(NULL, rng, 10, 0, NULL, &estimator) == RES_BAD_ARG);
+ CHK(ssol_solve(scene, NULL, 10, 0, NULL, &estimator) == RES_BAD_ARG);
+ CHK(ssol_solve(scene, rng, 0, 0, NULL, &estimator) == RES_BAD_ARG);
+ CHK(ssol_solve(scene, rng, 10, 0, NULL, &estimator) == RES_BAD_ARG);
+ CHK(ssol_solve(scene, rng, 10, 0, NULL, NULL) == RES_BAD_ARG);
/* No geometry */
- CHECK(ssol_solve(scene, rng, 10, 0, NULL, &estimator), RES_BAD_ARG);
+ CHK(ssol_solve(scene, rng, 10, 0, NULL, &estimator) == RES_BAD_ARG);
/* Create scene content */
- CHECK(ssol_shape_create_mesh(dev, &dummy), RES_OK);
- CHECK(ssol_shape_create_mesh(dev, &square), RES_OK);
+ CHK(ssol_shape_create_mesh(dev, &dummy) == RES_OK);
+ CHK(ssol_shape_create_mesh(dev, &square) == RES_OK);
attribs[0].usage = SSOL_POSITION;
attribs[0].get = get_position;
- CHECK(ssol_mesh_setup(square, SQUARE_NTRIS__, get_ids,
- SQUARE_NVERTS__, attribs, 1, (void*)&SQUARE_DESC__), RES_OK);
+ CHK(ssol_mesh_setup(square, SQUARE_NTRIS__, get_ids,
+ SQUARE_NVERTS__, attribs, 1, (void*)&SQUARE_DESC__) == RES_OK);
- CHECK(ssol_material_create_mirror(dev, &m_mtl), RES_OK);
+ CHK(ssol_material_create_mirror(dev, &m_mtl) == RES_OK);
shader.normal = get_shader_normal;
shader.reflectivity = get_shader_reflectivity;
shader.roughness = get_shader_roughness;
- 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);
- CHECK(ssol_object_add_shaded_shape(m_object, square, m_mtl, m_mtl), RES_OK);
- CHECK(ssol_object_instantiate(m_object, &heliostat), RES_OK);
- CHECK(ssol_instance_set_receiver(heliostat, SSOL_FRONT, 0), RES_OK);
- CHECK(ssol_scene_attach_instance(scene, heliostat), RES_OK);
-
- CHECK(ssol_object_instantiate(m_object, &secondary), RES_OK);
- CHECK(ssol_instance_set_receiver(secondary, SSOL_FRONT, 0), RES_OK);
- CHECK(ssol_instance_set_transform(secondary, transform1), RES_OK);
- CHECK(ssol_scene_attach_instance(scene, secondary), RES_OK);
-
- CHECK(ssol_object_create(dev, &t_object), RES_OK);
- CHECK(ssol_object_add_shaded_shape(t_object, square, v_mtl, v_mtl), RES_OK);
- CHECK(ssol_object_instantiate(t_object, &target), RES_OK);
- CHECK(ssol_instance_set_transform(target, transform2), RES_OK);
- CHECK(ssol_instance_set_receiver(target, SSOL_FRONT, 0), RES_OK);
- CHECK(ssol_scene_attach_instance(scene, target), RES_OK);
+ CHK(ssol_mirror_setup(m_mtl, &shader, SSOL_MICROFACET_BECKMANN) == RES_OK);
+ CHK(ssol_material_create_virtual(dev, &v_mtl) == RES_OK);
+
+ CHK(ssol_object_create(dev, &m_object) == RES_OK);
+ CHK(ssol_object_add_shaded_shape(m_object, square, m_mtl, m_mtl) == RES_OK);
+ CHK(ssol_object_instantiate(m_object, &heliostat) == RES_OK);
+ CHK(ssol_instance_set_receiver(heliostat, SSOL_FRONT, 0) == RES_OK);
+ CHK(ssol_scene_attach_instance(scene, heliostat) == RES_OK);
+
+ CHK(ssol_object_instantiate(m_object, &secondary) == RES_OK);
+ CHK(ssol_instance_set_receiver(secondary, SSOL_FRONT, 0) == RES_OK);
+ CHK(ssol_instance_set_transform(secondary, transform1) == RES_OK);
+ CHK(ssol_scene_attach_instance(scene, secondary) == RES_OK);
+
+ CHK(ssol_object_create(dev, &t_object) == RES_OK);
+ CHK(ssol_object_add_shaded_shape(t_object, square, v_mtl, v_mtl) == RES_OK);
+ CHK(ssol_object_instantiate(t_object, &target) == RES_OK);
+ CHK(ssol_instance_set_transform(target, transform2) == RES_OK);
+ CHK(ssol_instance_set_receiver(target, SSOL_FRONT, 0) == RES_OK);
+ CHK(ssol_scene_attach_instance(scene, target) == RES_OK);
/* No sun */
- CHECK(ssol_solve(scene, rng, 10, 0, NULL, &estimator), RES_BAD_ARG);
-
- CHECK(ssol_scene_attach_sun(scene, sun), RES_OK);
- CHECK(ssol_solve(scene, rng, 10, 0, NULL, &estimator), RES_OK);
- CHECK(ssol_estimator_ref_put(estimator), RES_OK);
-
- CHECK(ssol_solve
- (scene, rng, 1, 0, &SSOL_PATH_TRACKER_DEFAULT, &estimator), RES_OK);
-
- CHECK(ssol_estimator_get_tracked_paths_count(NULL, NULL), RES_BAD_ARG);
- CHECK(ssol_estimator_get_tracked_paths_count(estimator, NULL), RES_BAD_ARG);
- CHECK(ssol_estimator_get_tracked_paths_count(NULL, &count), RES_BAD_ARG);
- CHECK(ssol_estimator_get_tracked_paths_count(estimator, &count), RES_OK);
- CHECK(count, 1);
-
- CHECK(ssol_estimator_get_tracked_path(NULL, count, NULL), RES_BAD_ARG);
- CHECK(ssol_estimator_get_tracked_path(estimator, count, NULL), RES_BAD_ARG);
- CHECK(ssol_estimator_get_tracked_path(NULL, 0, NULL), RES_BAD_ARG);
- CHECK(ssol_estimator_get_tracked_path(estimator, 0, NULL), RES_BAD_ARG);
- CHECK(ssol_estimator_get_tracked_path(NULL, count, &path), RES_BAD_ARG);
- CHECK(ssol_estimator_get_tracked_path(estimator, count, &path), RES_BAD_ARG);
- CHECK(ssol_estimator_get_tracked_path(NULL, 0, &path), RES_BAD_ARG);
- CHECK(ssol_estimator_get_tracked_path(estimator, 0, &path), RES_OK);
-
- CHECK(ssol_path_get_vertices_count(NULL, NULL), RES_BAD_ARG);
- CHECK(ssol_path_get_vertices_count(&path, NULL), RES_BAD_ARG);
- CHECK(ssol_path_get_vertices_count(NULL, &count), RES_BAD_ARG);
- CHECK(ssol_path_get_vertices_count(&path, &count), RES_OK);
- NCHECK(count, 0);
-
- CHECK(ssol_path_get_vertex(NULL, count, NULL), RES_BAD_ARG);
- CHECK(ssol_path_get_vertex(&path, count, NULL), RES_BAD_ARG);
- CHECK(ssol_path_get_vertex(NULL, 0, NULL), RES_BAD_ARG);
- CHECK(ssol_path_get_vertex(&path, 0, NULL), RES_BAD_ARG);
- CHECK(ssol_path_get_vertex(NULL, count, &vertex), RES_BAD_ARG);
- CHECK(ssol_path_get_vertex(&path, count, &vertex), RES_BAD_ARG);
- CHECK(ssol_path_get_vertex(NULL, 0, &vertex), RES_BAD_ARG);
+ CHK(ssol_solve(scene, rng, 10, 0, NULL, &estimator) == RES_BAD_ARG);
+
+ CHK(ssol_scene_attach_sun(scene, sun) == RES_OK);
+ CHK(ssol_solve(scene, rng, 10, 0, NULL, &estimator) == RES_OK);
+ CHK(ssol_estimator_ref_put(estimator) == RES_OK);
+
+ CHK(ssol_solve
+ (scene, rng, 1, 0, &SSOL_PATH_TRACKER_DEFAULT, &estimator) == RES_OK);
+
+ CHK(ssol_estimator_get_tracked_paths_count(NULL, NULL) == RES_BAD_ARG);
+ CHK(ssol_estimator_get_tracked_paths_count(estimator, NULL) == RES_BAD_ARG);
+ CHK(ssol_estimator_get_tracked_paths_count(NULL, &count) == RES_BAD_ARG);
+ CHK(ssol_estimator_get_tracked_paths_count(estimator, &count) == RES_OK);
+ CHK(count == 1);
+
+ CHK(ssol_estimator_get_tracked_path(NULL, count, NULL) == RES_BAD_ARG);
+ CHK(ssol_estimator_get_tracked_path(estimator, count, NULL) == RES_BAD_ARG);
+ CHK(ssol_estimator_get_tracked_path(NULL, 0, NULL) == RES_BAD_ARG);
+ CHK(ssol_estimator_get_tracked_path(estimator, 0, NULL) == RES_BAD_ARG);
+ CHK(ssol_estimator_get_tracked_path(NULL, count, &path) == RES_BAD_ARG);
+ CHK(ssol_estimator_get_tracked_path(estimator, count, &path) == RES_BAD_ARG);
+ CHK(ssol_estimator_get_tracked_path(NULL, 0, &path) == RES_BAD_ARG);
+ CHK(ssol_estimator_get_tracked_path(estimator, 0, &path) == RES_OK);
+
+ CHK(ssol_path_get_vertices_count(NULL, NULL) == RES_BAD_ARG);
+ CHK(ssol_path_get_vertices_count(&path, NULL) == RES_BAD_ARG);
+ CHK(ssol_path_get_vertices_count(NULL, &count) == RES_BAD_ARG);
+ CHK(ssol_path_get_vertices_count(&path, &count) == RES_OK);
+ CHK(count != 0);
+
+ CHK(ssol_path_get_vertex(NULL, count, NULL) == RES_BAD_ARG);
+ CHK(ssol_path_get_vertex(&path, count, NULL) == RES_BAD_ARG);
+ CHK(ssol_path_get_vertex(NULL, 0, NULL) == RES_BAD_ARG);
+ CHK(ssol_path_get_vertex(&path, 0, NULL) == RES_BAD_ARG);
+ CHK(ssol_path_get_vertex(NULL, count, &vertex) == RES_BAD_ARG);
+ CHK(ssol_path_get_vertex(&path, count, &vertex) == RES_BAD_ARG);
+ CHK(ssol_path_get_vertex(NULL, 0, &vertex) == RES_BAD_ARG);
FOR_EACH(i, 0, count) {
- CHECK(ssol_path_get_vertex(&path, i, &vertex), RES_OK);
+ CHK(ssol_path_get_vertex(&path, i, &vertex) == RES_OK);
}
- CHECK(ssol_estimator_get_sampled_area(NULL, NULL), RES_BAD_ARG);
- CHECK(ssol_estimator_get_sampled_area(estimator, NULL), RES_BAD_ARG);
- CHECK(ssol_estimator_get_sampled_area(NULL, &dbl), RES_BAD_ARG);
- CHECK(ssol_estimator_get_sampled_area(estimator, &dbl), RES_OK);
- CHECK(eq_eps(dbl, 12, DBL_EPSILON), 1);
-
- CHECK(ssol_estimator_get_realisation_count(NULL, NULL), RES_BAD_ARG);
- CHECK(ssol_estimator_get_realisation_count(estimator, NULL), RES_BAD_ARG);
- CHECK(ssol_estimator_get_realisation_count(NULL, &count), RES_BAD_ARG);
- CHECK(ssol_estimator_get_realisation_count(estimator, &count), RES_OK);
- CHECK(count, 1);
-
- CHECK(ssol_estimator_get_failed_count(NULL, NULL), RES_BAD_ARG);
- CHECK(ssol_estimator_get_failed_count(estimator, NULL), RES_BAD_ARG);
- CHECK(ssol_estimator_get_failed_count(NULL, &count), RES_BAD_ARG);
- CHECK(ssol_estimator_get_failed_count(estimator, &fcount), RES_OK);
- CHECK(fcount, 0);
-
- CHECK(ssol_estimator_get_sampled_count(NULL, NULL), RES_BAD_ARG);
- CHECK(ssol_estimator_get_sampled_count(estimator, NULL), RES_BAD_ARG);
- CHECK(ssol_estimator_get_sampled_count(NULL, &scount), RES_BAD_ARG);
- CHECK(ssol_estimator_get_sampled_count(estimator, &scount), RES_OK);
- CHECK(scount, 3);
-
- CHECK(ssol_estimator_get_mc_sampled(NULL, heliostat, &sampled), RES_BAD_ARG);
- CHECK(ssol_estimator_get_mc_sampled(estimator, NULL, &sampled), RES_BAD_ARG);
- CHECK(ssol_estimator_get_mc_sampled(estimator, heliostat, NULL), RES_BAD_ARG);
- CHECK(ssol_estimator_get_mc_sampled(estimator, heliostat, &sampled), RES_OK);
-
- CHECK(ssol_estimator_get_mc_global(NULL, &mc_global), RES_BAD_ARG);
- CHECK(ssol_estimator_get_mc_global(estimator, NULL), RES_BAD_ARG);
- CHECK(ssol_estimator_get_mc_global(estimator, &mc_global), RES_OK);
-
- CHECK(ssol_estimator_ref_get(NULL), RES_BAD_ARG);
- CHECK(ssol_estimator_ref_get(estimator), RES_OK);
- CHECK(ssol_estimator_ref_put(NULL), RES_BAD_ARG);
- CHECK(ssol_estimator_ref_put(estimator), RES_OK);
- CHECK(ssol_estimator_ref_put(estimator), RES_OK);
+ CHK(ssol_estimator_get_sampled_area(NULL, NULL) == RES_BAD_ARG);
+ CHK(ssol_estimator_get_sampled_area(estimator, NULL) == RES_BAD_ARG);
+ CHK(ssol_estimator_get_sampled_area(NULL, &dbl) == RES_BAD_ARG);
+ CHK(ssol_estimator_get_sampled_area(estimator, &dbl) == RES_OK);
+ CHK(eq_eps(dbl, 12, DBL_EPSILON) == 1);
+
+ CHK(ssol_estimator_get_realisation_count(NULL, NULL) == RES_BAD_ARG);
+ CHK(ssol_estimator_get_realisation_count(estimator, NULL) == RES_BAD_ARG);
+ CHK(ssol_estimator_get_realisation_count(NULL, &count) == RES_BAD_ARG);
+ CHK(ssol_estimator_get_realisation_count(estimator, &count) == RES_OK);
+ CHK(count == 1);
+
+ CHK(ssol_estimator_get_failed_count(NULL, NULL) == RES_BAD_ARG);
+ CHK(ssol_estimator_get_failed_count(estimator, NULL) == RES_BAD_ARG);
+ CHK(ssol_estimator_get_failed_count(NULL, &count) == RES_BAD_ARG);
+ CHK(ssol_estimator_get_failed_count(estimator, &fcount) == RES_OK);
+ CHK(fcount == 0);
+
+ CHK(ssol_estimator_get_sampled_count(NULL, NULL) == RES_BAD_ARG);
+ CHK(ssol_estimator_get_sampled_count(estimator, NULL) == RES_BAD_ARG);
+ CHK(ssol_estimator_get_sampled_count(NULL, &scount) == RES_BAD_ARG);
+ CHK(ssol_estimator_get_sampled_count(estimator, &scount) == RES_OK);
+ CHK(scount == 3);
+
+ CHK(ssol_estimator_get_mc_sampled(NULL, heliostat, &sampled) == RES_BAD_ARG);
+ CHK(ssol_estimator_get_mc_sampled(estimator, NULL, &sampled) == RES_BAD_ARG);
+ CHK(ssol_estimator_get_mc_sampled(estimator, heliostat, NULL) == RES_BAD_ARG);
+ CHK(ssol_estimator_get_mc_sampled(estimator, heliostat, &sampled) == RES_OK);
+
+ CHK(ssol_estimator_get_mc_global(NULL, &mc_global) == RES_BAD_ARG);
+ CHK(ssol_estimator_get_mc_global(estimator, NULL) == RES_BAD_ARG);
+ CHK(ssol_estimator_get_mc_global(estimator, &mc_global) == RES_OK);
+
+ CHK(ssol_estimator_ref_get(NULL) == RES_BAD_ARG);
+ CHK(ssol_estimator_ref_get(estimator) == RES_OK);
+ CHK(ssol_estimator_ref_put(NULL) == RES_BAD_ARG);
+ CHK(ssol_estimator_ref_put(estimator) == RES_OK);
+ CHK(ssol_estimator_ref_put(estimator) == RES_OK);
/* No geometry to sample */
- CHECK(ssol_instance_sample(target, 0), RES_OK);
- CHECK(ssol_instance_sample(secondary, 0), RES_OK);
- CHECK(ssol_instance_sample(heliostat, 0), RES_OK);
- CHECK(ssol_solve(scene, rng, 10, 0, NULL, &estimator), RES_BAD_ARG);
- CHECK(ssol_estimator_get_mc_sampled(estimator, heliostat, &sampled), RES_BAD_ARG);
+ CHK(ssol_instance_sample(target, 0) == RES_OK);
+ CHK(ssol_instance_sample(secondary, 0) == RES_OK);
+ CHK(ssol_instance_sample(heliostat, 0) == RES_OK);
+ CHK(ssol_solve(scene, rng, 10, 0, NULL, &estimator) == RES_BAD_ARG);
+ CHK(ssol_estimator_get_mc_sampled(estimator, heliostat, &sampled) == RES_BAD_ARG);
- CHECK(ssol_instance_sample(target, 1), RES_OK);
- CHECK(ssol_instance_sample(secondary, 1), RES_OK);
- CHECK(ssol_instance_sample(heliostat, 1), RES_OK);
+ CHK(ssol_instance_sample(target, 1) == RES_OK);
+ CHK(ssol_instance_sample(secondary, 1) == RES_OK);
+ CHK(ssol_instance_sample(heliostat, 1) == RES_OK);
/* No attached sun */
- CHECK(ssol_scene_detach_sun(scene, sun), RES_OK);
- CHECK(ssol_solve(scene, rng, 10, 0, NULL, &estimator), RES_BAD_ARG);
- CHECK(ssol_sun_ref_put(sun), RES_OK);
+ CHK(ssol_scene_detach_sun(scene, sun) == RES_OK);
+ CHK(ssol_solve(scene, rng, 10, 0, NULL, &estimator) == RES_BAD_ARG);
+ CHK(ssol_sun_ref_put(sun) == RES_OK);
/* Sun with no spectrum */
- CHECK(ssol_sun_create_directional(dev, &sun), RES_OK);
- CHECK(ssol_sun_set_direction(sun, d3(dir, 1, 0, -1)), RES_OK);
- CHECK(ssol_sun_set_dni(sun, DNI), RES_OK);
- CHECK(ssol_scene_attach_sun(scene, sun), RES_OK);
- CHECK(ssol_solve(scene, rng, 10, 0, NULL, &estimator), RES_BAD_ARG);
- CHECK(ssol_scene_detach_sun(scene, sun), RES_OK);
- CHECK(ssol_sun_ref_put(sun), RES_OK);
+ CHK(ssol_sun_create_directional(dev, &sun) == RES_OK);
+ CHK(ssol_sun_set_direction(sun, d3(dir, 1, 0, -1)) == RES_OK);
+ CHK(ssol_sun_set_dni(sun, DNI) == RES_OK);
+ CHK(ssol_scene_attach_sun(scene, sun) == RES_OK);
+ CHK(ssol_solve(scene, rng, 10, 0, NULL, &estimator) == RES_BAD_ARG);
+ CHK(ssol_scene_detach_sun(scene, sun) == RES_OK);
+ CHK(ssol_sun_ref_put(sun) == RES_OK);
/* Sun with undefined DNI */
- CHECK(ssol_sun_create_directional(dev, &sun), RES_OK);
- CHECK(ssol_sun_set_direction(sun, d3(dir, 1, 0, -1)), RES_OK);
- CHECK(ssol_sun_set_spectrum(sun, spectrum), RES_OK);
- CHECK(ssol_scene_attach_sun(scene, sun), RES_OK);
- CHECK(ssol_solve(scene, rng, 10, 0, NULL, &estimator), RES_BAD_ARG);
- CHECK(ssol_sun_set_dni(sun, DNI), RES_OK);
+ CHK(ssol_sun_create_directional(dev, &sun) == RES_OK);
+ CHK(ssol_sun_set_direction(sun, d3(dir, 1, 0, -1)) == RES_OK);
+ CHK(ssol_sun_set_spectrum(sun, spectrum) == RES_OK);
+ CHK(ssol_scene_attach_sun(scene, sun) == RES_OK);
+ CHK(ssol_solve(scene, rng, 10, 0, NULL, &estimator) == RES_BAD_ARG);
+ CHK(ssol_sun_set_dni(sun, DNI) == RES_OK);
/* No receiver in scene */
- CHECK(ssol_instance_set_receiver(heliostat, 0, 0), RES_OK);
- CHECK(ssol_instance_set_receiver(secondary, 0, 0), RES_OK);
- CHECK(ssol_instance_set_receiver(target, 0, 0), RES_OK);
- CHECK(ssol_solve(scene, rng, 10, 0, NULL, &estimator), RES_OK);
- CHECK(ssol_instance_set_receiver(heliostat, SSOL_FRONT, 0), RES_OK);
- CHECK(ssol_instance_set_receiver(secondary, SSOL_FRONT, 0), RES_OK);
- CHECK(ssol_instance_set_receiver(target, SSOL_FRONT, 0), RES_OK);
- CHECK(ssol_estimator_ref_put(estimator), RES_OK);
+ CHK(ssol_instance_set_receiver(heliostat, 0, 0) == RES_OK);
+ CHK(ssol_instance_set_receiver(secondary, 0, 0) == RES_OK);
+ CHK(ssol_instance_set_receiver(target, 0, 0) == RES_OK);
+ CHK(ssol_solve(scene, rng, 10, 0, NULL, &estimator) == RES_OK);
+ CHK(ssol_instance_set_receiver(heliostat, SSOL_FRONT, 0) == RES_OK);
+ CHK(ssol_instance_set_receiver(secondary, SSOL_FRONT, 0) == RES_OK);
+ CHK(ssol_instance_set_receiver(target, SSOL_FRONT, 0) == RES_OK);
+ CHK(ssol_estimator_ref_put(estimator) == RES_OK);
/* Can sample any geometry; variance is high */
#define N__ 10000
#define GET_MC_RCV ssol_estimator_get_mc_receiver
#define GET_MC_GLOBAL ssol_estimator_get_mc_global
- CHECK(ssol_solve(scene, rng, N__, 0, NULL, &estimator), RES_OK);
- CHECK(ssol_estimator_get_realisation_count(estimator, &count), RES_OK);
- CHECK(count, N__);
- CHECK(ssol_estimator_get_failed_count(estimator, &fcount), RES_OK);
- CHECK(fcount, 0);
+ CHK(ssol_solve(scene, rng, N__, 0, NULL, &estimator) == RES_OK);
+ CHK(ssol_estimator_get_realisation_count(estimator, &count) == RES_OK);
+ CHK(count == N__);
+ CHK(ssol_estimator_get_failed_count(estimator, &fcount) == RES_OK);
+ CHK(fcount == 0);
#define COS cos(PI / 4)
#define DNI_cos (DNI * COS)
m = 4 * DNI_cos;
@@ -302,235 +302,234 @@ main(int argc, char** argv)
dbl = sqrt((SQR(12 * DNI_cos) / 3 - SQR(4 * DNI_cos)) / (double)count);
std = dbl;
/* Target was sampled but shadowed by secondary */
- CHECK(ssol_estimator_get_mc_global(estimator, &mc_global), RES_OK);
+ CHK(ssol_estimator_get_mc_global(estimator, &mc_global) == RES_OK);
PRINT_GLOBAL(mc_global);
- CHECK(eq_eps(mc_global.shadowed.E, m, 2 * dbl), 1);
- CHECK(eq_eps(mc_global.missing.E, 2*m, 2*mc_global.missing.SE), 1);
- CHECK(GET_MC_RCV(NULL, NULL, SSOL_BACK, NULL), RES_BAD_ARG);
- CHECK(GET_MC_RCV(estimator, NULL, SSOL_BACK, NULL), RES_BAD_ARG);
- CHECK(GET_MC_RCV(NULL, target, SSOL_BACK, NULL), RES_BAD_ARG);
- CHECK(GET_MC_RCV(estimator, target, SSOL_BACK, NULL), RES_BAD_ARG);
- CHECK(GET_MC_RCV(NULL, NULL, SSOL_BACK, &mc_rcv), RES_BAD_ARG);
- CHECK(GET_MC_RCV(estimator, NULL, SSOL_BACK, &mc_rcv), RES_BAD_ARG);
- CHECK(GET_MC_RCV(NULL, target, SSOL_BACK, &mc_rcv), RES_BAD_ARG);
- CHECK(GET_MC_RCV(estimator, target, SSOL_BACK, &mc_rcv), RES_BAD_ARG);
- CHECK(GET_MC_RCV(NULL, NULL, SSOL_FRONT, NULL), RES_BAD_ARG);
- CHECK(GET_MC_RCV(estimator, NULL, SSOL_FRONT, NULL), RES_BAD_ARG);
- CHECK(GET_MC_RCV(NULL, target, SSOL_FRONT, NULL), RES_BAD_ARG);
- CHECK(GET_MC_RCV(estimator, target, SSOL_FRONT, NULL), RES_BAD_ARG);
- CHECK(GET_MC_RCV(NULL, NULL, SSOL_FRONT, &mc_rcv), RES_BAD_ARG);
- CHECK(GET_MC_RCV(estimator, NULL, SSOL_FRONT, &mc_rcv), RES_BAD_ARG);
- CHECK(GET_MC_RCV(NULL, target, SSOL_FRONT, &mc_rcv), RES_BAD_ARG);
- CHECK(GET_MC_RCV(estimator, target, SSOL_FRONT, &mc_rcv), RES_OK);
+ CHK(eq_eps(mc_global.shadowed.E, m, 2 * dbl) == 1);
+ CHK(eq_eps(mc_global.missing.E, 2*m, 2*mc_global.missing.SE) == 1);
+ CHK(GET_MC_RCV(NULL, NULL, SSOL_BACK, NULL) == RES_BAD_ARG);
+ CHK(GET_MC_RCV(estimator, NULL, SSOL_BACK, NULL) == RES_BAD_ARG);
+ CHK(GET_MC_RCV(NULL, target, SSOL_BACK, NULL) == RES_BAD_ARG);
+ CHK(GET_MC_RCV(estimator, target, SSOL_BACK, NULL) == RES_BAD_ARG);
+ CHK(GET_MC_RCV(NULL, NULL, SSOL_BACK, &mc_rcv) == RES_BAD_ARG);
+ CHK(GET_MC_RCV(estimator, NULL, SSOL_BACK, &mc_rcv) == RES_BAD_ARG);
+ CHK(GET_MC_RCV(NULL, target, SSOL_BACK, &mc_rcv) == RES_BAD_ARG);
+ CHK(GET_MC_RCV(estimator, target, SSOL_BACK, &mc_rcv) == RES_BAD_ARG);
+ CHK(GET_MC_RCV(NULL, NULL, SSOL_FRONT, NULL) == RES_BAD_ARG);
+ CHK(GET_MC_RCV(estimator, NULL, SSOL_FRONT, NULL) == RES_BAD_ARG);
+ CHK(GET_MC_RCV(NULL, target, SSOL_FRONT, NULL) == RES_BAD_ARG);
+ CHK(GET_MC_RCV(estimator, target, SSOL_FRONT, NULL) == RES_BAD_ARG);
+ CHK(GET_MC_RCV(NULL, NULL, SSOL_FRONT, &mc_rcv) == RES_BAD_ARG);
+ CHK(GET_MC_RCV(estimator, NULL, SSOL_FRONT, &mc_rcv) == RES_BAD_ARG);
+ CHK(GET_MC_RCV(NULL, target, SSOL_FRONT, &mc_rcv) == RES_BAD_ARG);
+ CHK(GET_MC_RCV(estimator, target, SSOL_FRONT, &mc_rcv) == RES_OK);
printf("Ir(target) = %g +/- %g\n",
mc_rcv.incoming_flux.E, mc_rcv.incoming_flux.SE);
- CHECK(eq_eps(mc_rcv.incoming_flux.E, m, 2 * std), 1);
- CHECK(eq_eps(mc_rcv.incoming_flux.SE, std, 1e-1), 1);
- CHECK(ssol_estimator_ref_put(estimator), RES_OK);
+ CHK(eq_eps(mc_rcv.incoming_flux.E, m, 2 * std) == 1);
+ CHK(eq_eps(mc_rcv.incoming_flux.SE, std, 1e-1) == 1);
+ CHK(ssol_estimator_ref_put(estimator) == RES_OK);
/* Sample primary mirror only; variance is low */
- CHECK(ssol_instance_sample(target, 0), RES_OK);
- CHECK(ssol_instance_sample(secondary, 0), RES_OK);
+ CHK(ssol_instance_sample(target, 0) == RES_OK);
+ CHK(ssol_instance_sample(secondary, 0) == RES_OK);
- CHECK(ssol_solve(scene, rng, N__, 0, NULL, &estimator), RES_OK);
- CHECK(ssol_estimator_get_realisation_count(estimator, &count), RES_OK);
- CHECK(count, N__);
+ CHK(ssol_solve(scene, rng, N__, 0, NULL, &estimator) == RES_OK);
+ CHK(ssol_estimator_get_realisation_count(estimator, &count) == RES_OK);
+ CHK(count == N__);
m = 4 * DNI_cos;
std = 0;
- CHECK(ssol_estimator_get_mc_global(estimator, &mc_global), RES_OK);
+ CHK(ssol_estimator_get_mc_global(estimator, &mc_global) == RES_OK);
PRINT_GLOBAL(mc_global);
- CHECK(eq_eps(mc_global.shadowed.E, 0, 1e-4), 1);
- CHECK(eq_eps(mc_global.missing.E, m, 1e-4), 1);
- CHECK(eq_eps(mc_global.cos_factor.E, COS, 1e-4), 1);
- CHECK(GET_MC_RCV(estimator, target, SSOL_FRONT, &mc_rcv), RES_OK);
+ CHK(eq_eps(mc_global.shadowed.E, 0, 1e-4) == 1);
+ CHK(eq_eps(mc_global.missing.E, m, 1e-4) == 1);
+ CHK(eq_eps(mc_global.cos_factor.E, COS, 1e-4) == 1);
+ CHK(GET_MC_RCV(estimator, target, SSOL_FRONT, &mc_rcv) == RES_OK);
printf("Ir(target) = %g +/- %g\n",
mc_rcv.incoming_flux.E, mc_rcv.incoming_flux.SE);
- CHECK(eq_eps(mc_rcv.incoming_flux.E, m, 1e-8), 1);
- CHECK(eq_eps(mc_rcv.incoming_flux.SE, std, 1e-4), 1);
- CHECK(ssol_estimator_ref_put(estimator), RES_OK);
+ CHK(eq_eps(mc_rcv.incoming_flux.E, m, 1e-8) == 1);
+ CHK(eq_eps(mc_rcv.incoming_flux.SE, std, 1e-4) == 1);
+ CHK(ssol_estimator_ref_put(estimator) == RES_OK);
/* Check atmosphere model; with no extinction result is unchanged */
- CHECK(ssol_atmosphere_create(dev, &atm), RES_OK);
+ CHK(ssol_atmosphere_create(dev, &atm) == RES_OK);
extinction.type = SSOL_DATA_REAL;
extinction.value.real = 0;
- CHECK(ssol_atmosphere_set_extinction(atm, &extinction), RES_OK);
- CHECK(ssol_scene_attach_atmosphere(scene, atm), RES_OK);
+ CHK(ssol_atmosphere_set_extinction(atm, &extinction) == RES_OK);
+ CHK(ssol_scene_attach_atmosphere(scene, atm) == RES_OK);
- CHECK(ssol_solve(scene, rng, N__, 0, NULL, &estimator), RES_OK);
- CHECK(ssol_estimator_get_realisation_count(estimator, &count), RES_OK);
- CHECK(count, N__);
+ CHK(ssol_solve(scene, rng, N__, 0, NULL, &estimator) == RES_OK);
+ CHK(ssol_estimator_get_realisation_count(estimator, &count) == RES_OK);
+ CHK(count == N__);
m = 4 * DNI_cos;
std = 0;
- CHECK(ssol_scene_detach_atmosphere(scene, atm), RES_OK);
- CHECK(ssol_atmosphere_ref_put(atm), RES_OK);
- CHECK(ssol_estimator_get_mc_global(estimator, &mc_global), RES_OK);
+ CHK(ssol_scene_detach_atmosphere(scene, atm) == RES_OK);
+ CHK(ssol_atmosphere_ref_put(atm) == RES_OK);
+ CHK(ssol_estimator_get_mc_global(estimator, &mc_global) == RES_OK);
PRINT_GLOBAL(mc_global);
- CHECK(eq_eps(mc_global.shadowed.E, 0, 1e-4), 1);
- CHECK(eq_eps(mc_global.missing.E, m, 1e-4), 1);
- CHECK(eq_eps(mc_global.cos_factor.E, COS, 1e-4), 1);
- CHECK(GET_MC_RCV(estimator, target, SSOL_FRONT, &mc_rcv), RES_OK);
+ CHK(eq_eps(mc_global.shadowed.E, 0, 1e-4) == 1);
+ CHK(eq_eps(mc_global.missing.E, m, 1e-4) == 1);
+ CHK(eq_eps(mc_global.cos_factor.E, COS, 1e-4) == 1);
+ CHK(GET_MC_RCV(estimator, target, SSOL_FRONT, &mc_rcv) == RES_OK);
printf("Ir(target) = %g +/- %g\n",
mc_rcv.incoming_flux.E, mc_rcv.incoming_flux.SE);
- CHECK(eq_eps(mc_rcv.incoming_flux.E, m, 1e-8), 1);
- CHECK(eq_eps(mc_rcv.incoming_flux.SE, std, 1e-4), 1);
- CHECK(eq_eps(mc_global.cos_factor.E, COS, 1e-4), 1);
- CHECK(ssol_estimator_ref_put(estimator), RES_OK);
+ CHK(eq_eps(mc_rcv.incoming_flux.E, m, 1e-8) == 1);
+ CHK(eq_eps(mc_rcv.incoming_flux.SE, std, 1e-4) == 1);
+ CHK(eq_eps(mc_global.cos_factor.E, COS, 1e-4) == 1);
+ CHK(ssol_estimator_ref_put(estimator) == RES_OK);
/* Check atmosphere model and imperfect mirror: there are losses */
- CHECK(ssol_scene_detach_instance(scene, heliostat), RES_OK);
+ CHK(ssol_scene_detach_instance(scene, heliostat) == RES_OK);
- CHECK(ssol_material_create_mirror(dev, &m_mtl2), RES_OK);
+ CHK(ssol_material_create_mirror(dev, &m_mtl2) == RES_OK);
shader.normal = get_shader_normal;
shader.reflectivity = get_shader_reflectivity_2;
shader.roughness = get_shader_roughness;
- CHECK(ssol_mirror_setup(m_mtl2, &shader), RES_OK);
+ CHK(ssol_mirror_setup(m_mtl2, &shader, SSOL_MICROFACET_BECKMANN) == 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);
- CHECK(ssol_object_instantiate(m_object2, &heliostat2), RES_OK);
- CHECK(ssol_instance_set_receiver(heliostat2, SSOL_FRONT, 0), RES_OK);
- CHECK(ssol_scene_attach_instance(scene, heliostat2), RES_OK);
+ CHK(ssol_object_create(dev, &m_object2) == RES_OK);
+ CHK(ssol_object_add_shaded_shape(m_object2, square, m_mtl2, m_mtl2) == RES_OK);
+ CHK(ssol_object_instantiate(m_object2, &heliostat2) == RES_OK);
+ CHK(ssol_instance_set_receiver(heliostat2, SSOL_FRONT, 0) == RES_OK);
+ CHK(ssol_scene_attach_instance(scene, heliostat2) == RES_OK);
#define KA 0.03
extinction.value.real = KA;
- CHECK(ssol_spectrum_create(dev, &abs_spectrum), RES_OK);
- CHECK(ssol_spectrum_setup(abs_spectrum, get_wlen, 3, &desc), RES_OK);
- CHECK(ssol_atmosphere_create(dev, &atm), RES_OK);
- CHECK(ssol_atmosphere_set_extinction(atm, &extinction), RES_OK);
- CHECK(ssol_scene_attach_atmosphere(scene, atm), RES_OK);
- CHECK(ssol_instance_set_receiver(target, SSOL_FRONT, 1), RES_OK);
-
- CHECK(ssol_solve(scene, rng, N__, 0, NULL, &estimator), RES_OK);
- CHECK(ssol_estimator_get_realisation_count(estimator, &count), RES_OK);
- CHECK(count, N__);
+ CHK(ssol_spectrum_create(dev, &abs_spectrum) == RES_OK);
+ CHK(ssol_spectrum_setup(abs_spectrum, get_wlen, 3, &desc) == RES_OK);
+ CHK(ssol_atmosphere_create(dev, &atm) == RES_OK);
+ CHK(ssol_atmosphere_set_extinction(atm, &extinction) == RES_OK);
+ CHK(ssol_scene_attach_atmosphere(scene, atm) == RES_OK);
+ CHK(ssol_instance_set_receiver(target, SSOL_FRONT, 1) == RES_OK);
+
+ CHK(ssol_solve(scene, rng, N__, 0, NULL, &estimator) == RES_OK);
+ CHK(ssol_estimator_get_realisation_count(estimator, &count) == RES_OK);
+ CHK(count == N__);
#define K (exp(-KA * 4 * sqrt(2)))
a_m = REFLECTIVITY * 4 * K * DNI_cos;
a_std = 0;
- CHECK(ssol_estimator_get_mc_global(estimator, &mc_global), RES_OK);
+ CHK(ssol_estimator_get_mc_global(estimator, &mc_global) == RES_OK);
PRINT_GLOBAL(mc_global);
- CHECK(eq_eps(mc_global.shadowed.E, 0, 1e-4), 1);
- CHECK(eq_eps(
+ CHK(eq_eps(mc_global.shadowed.E, 0, 1e-4) == 1);
+ CHK(eq_eps(
mc_global.missing.E + mc_global.shadowed.E + mc_global.absorbed_by_receivers.E
+ mc_global.extinguished_by_atmosphere.E + mc_global.other_absorbed.E,
- m,
- 1e-4), 1);
- CHECK(eq_eps(mc_global.cos_factor.E, COS, 1e-4), 1);
- CHECK(GET_MC_RCV(estimator, target, SSOL_FRONT, &mc_rcv), RES_OK);
+ m, 1e-4));
+ CHK(eq_eps(mc_global.cos_factor.E, COS, 1e-4) == 1);
+ CHK(GET_MC_RCV(estimator, target, SSOL_FRONT, &mc_rcv) == RES_OK);
PRINT_RCV(mc_rcv);
- CHECK(ssol_estimator_get_sampled_count(estimator, &scount), RES_OK);
- CHECK(ssol_estimator_get_mc_sampled(estimator, heliostat, &sampled), RES_BAD_ARG);
- CHECK(ssol_estimator_get_mc_sampled(estimator, heliostat2, &sampled), RES_OK);
-
- CHECK(eq_eps(mc_rcv.incoming_flux.E, a_m, 1e-4), 1);
- CHECK(eq_eps(mc_rcv.incoming_flux.SE, a_std, 1e-4), 1);
-
- CHECK(ssol_mc_receiver_get_mc_shape(NULL, NULL, NULL), RES_BAD_ARG);
- CHECK(ssol_mc_receiver_get_mc_shape(&mc_rcv, NULL, NULL), RES_BAD_ARG);
- CHECK(ssol_mc_receiver_get_mc_shape(NULL, square, NULL), RES_BAD_ARG);
- CHECK(ssol_mc_receiver_get_mc_shape(&mc_rcv, square, NULL), RES_BAD_ARG);
- CHECK(ssol_mc_receiver_get_mc_shape(NULL, NULL, &mc_shape), RES_BAD_ARG);
- CHECK(ssol_mc_receiver_get_mc_shape(&mc_rcv, NULL, &mc_shape), RES_BAD_ARG);
- CHECK(ssol_mc_receiver_get_mc_shape(NULL, square, &mc_shape), RES_BAD_ARG);
- CHECK(ssol_mc_receiver_get_mc_shape(&mc_rcv, dummy, &mc_shape), RES_BAD_ARG);
- CHECK(ssol_mc_receiver_get_mc_shape(&mc_rcv, square, &mc_shape), RES_OK);
-
- CHECK(ssol_shape_get_triangles_count(square, &ntris), RES_OK);
- NCHECK(ntris, 0);
-
- CHECK(ssol_mc_shape_get_mc_primitive(NULL, ntris, NULL), RES_BAD_ARG);
- CHECK(ssol_mc_shape_get_mc_primitive(&mc_shape, ntris, NULL), RES_BAD_ARG);
- CHECK(ssol_mc_shape_get_mc_primitive(NULL, 0, NULL), RES_BAD_ARG);
- CHECK(ssol_mc_shape_get_mc_primitive(&mc_shape, 0, NULL), RES_BAD_ARG);
- CHECK(ssol_mc_shape_get_mc_primitive(NULL, ntris, &mc_prim), RES_BAD_ARG);
- CHECK(ssol_mc_shape_get_mc_primitive(&mc_shape, ntris, &mc_prim), RES_BAD_ARG);
- CHECK(ssol_mc_shape_get_mc_primitive(NULL, 0, &mc_prim), RES_BAD_ARG);
+ CHK(ssol_estimator_get_sampled_count(estimator, &scount) == RES_OK);
+ CHK(ssol_estimator_get_mc_sampled(estimator, heliostat, &sampled) == RES_BAD_ARG);
+ CHK(ssol_estimator_get_mc_sampled(estimator, heliostat2, &sampled) == RES_OK);
+
+ CHK(eq_eps(mc_rcv.incoming_flux.E, a_m, 1e-4) == 1);
+ CHK(eq_eps(mc_rcv.incoming_flux.SE, a_std, 1e-4) == 1);
+
+ CHK(ssol_mc_receiver_get_mc_shape(NULL, NULL, NULL) == RES_BAD_ARG);
+ CHK(ssol_mc_receiver_get_mc_shape(&mc_rcv, NULL, NULL) == RES_BAD_ARG);
+ CHK(ssol_mc_receiver_get_mc_shape(NULL, square, NULL) == RES_BAD_ARG);
+ CHK(ssol_mc_receiver_get_mc_shape(&mc_rcv, square, NULL) == RES_BAD_ARG);
+ CHK(ssol_mc_receiver_get_mc_shape(NULL, NULL, &mc_shape) == RES_BAD_ARG);
+ CHK(ssol_mc_receiver_get_mc_shape(&mc_rcv, NULL, &mc_shape) == RES_BAD_ARG);
+ CHK(ssol_mc_receiver_get_mc_shape(NULL, square, &mc_shape) == RES_BAD_ARG);
+ CHK(ssol_mc_receiver_get_mc_shape(&mc_rcv, dummy, &mc_shape) == RES_BAD_ARG);
+ CHK(ssol_mc_receiver_get_mc_shape(&mc_rcv, square, &mc_shape) == RES_OK);
+
+ CHK(ssol_shape_get_triangles_count(square, &ntris) == RES_OK);
+ CHK(ntris != 0);
+
+ CHK(ssol_mc_shape_get_mc_primitive(NULL, ntris, NULL) == RES_BAD_ARG);
+ CHK(ssol_mc_shape_get_mc_primitive(&mc_shape, ntris, NULL) == RES_BAD_ARG);
+ CHK(ssol_mc_shape_get_mc_primitive(NULL, 0, NULL) == RES_BAD_ARG);
+ CHK(ssol_mc_shape_get_mc_primitive(&mc_shape, 0, NULL) == RES_BAD_ARG);
+ CHK(ssol_mc_shape_get_mc_primitive(NULL, ntris, &mc_prim) == RES_BAD_ARG);
+ CHK(ssol_mc_shape_get_mc_primitive(&mc_shape, ntris, &mc_prim) == RES_BAD_ARG);
+ CHK(ssol_mc_shape_get_mc_primitive(NULL, 0, &mc_prim) == RES_BAD_ARG);
dbl = 0;
FOR_EACH(i, 0, ntris) {
double v0[3], v1[3], v2[3], E1[3], E2[3], N[3], area;
unsigned ids[3];
- CHECK(ssol_shape_get_triangle_indices(square, (unsigned)i, ids), RES_OK);
- CHECK(ssol_shape_get_vertex_attrib(square, ids[0], SSOL_POSITION, v0), RES_OK);
- CHECK(ssol_shape_get_vertex_attrib(square, ids[1], SSOL_POSITION, v1), RES_OK);
- CHECK(ssol_shape_get_vertex_attrib(square, ids[2], SSOL_POSITION, v2), RES_OK);
+ CHK(ssol_shape_get_triangle_indices(square, (unsigned)i, ids) == RES_OK);
+ CHK(ssol_shape_get_vertex_attrib(square, ids[0], SSOL_POSITION, v0) == RES_OK);
+ CHK(ssol_shape_get_vertex_attrib(square, ids[1], SSOL_POSITION, v1) == RES_OK);
+ CHK(ssol_shape_get_vertex_attrib(square, ids[2], SSOL_POSITION, v2) == RES_OK);
area = d3_len(d3_cross(N, d3_sub(E1, v1, v0), d3_sub(E2, v2, v0))) * 0.5;
- CHECK(ssol_mc_shape_get_mc_primitive(&mc_shape, (unsigned)i, &mc_prim), RES_OK);
+ CHK(ssol_mc_shape_get_mc_primitive(&mc_shape, (unsigned)i, &mc_prim) == RES_OK);
dbl += mc_prim.incoming_flux.E * area;
}
- CHECK(eq_eps(dbl, a_m, 1e-4), 1);
- CHECK(ssol_estimator_ref_put(estimator), RES_OK);
+ CHK(eq_eps(dbl, a_m, 1e-4) == 1);
+ CHK(ssol_estimator_ref_put(estimator) == RES_OK);
- CHECK(ssol_scene_detach_instance(scene, heliostat2), RES_OK);
- CHECK(ssol_scene_attach_instance(scene, heliostat), RES_OK);
- CHECK(ssol_instance_set_receiver(target, SSOL_FRONT, 0), RES_OK);
+ CHK(ssol_scene_detach_instance(scene, heliostat2) == RES_OK);
+ CHK(ssol_scene_attach_instance(scene, heliostat) == RES_OK);
+ CHK(ssol_instance_set_receiver(target, SSOL_FRONT, 0) == RES_OK);
/* Check a monochromatic sun */
desc.wavelengths = &mono;
desc.intensities = intensities;
desc.count = 1;
- CHECK(ssol_spectrum_setup(spectrum, get_wlen, 1, &desc), RES_OK);
- CHECK(ssol_sun_create_directional(dev, &sun_mono), RES_OK);
- CHECK(ssol_sun_set_direction(sun_mono, d3(dir, 1, 0, -1)), RES_OK);
- CHECK(ssol_sun_set_spectrum(sun_mono, spectrum), RES_OK);
- CHECK(ssol_sun_set_dni(sun_mono, DNI), RES_OK);
- CHECK(ssol_scene_detach_sun(scene, sun), RES_OK);
- CHECK(ssol_scene_attach_sun(scene, sun_mono), RES_OK);
+ CHK(ssol_spectrum_setup(spectrum, get_wlen, 1, &desc) == RES_OK);
+ CHK(ssol_sun_create_directional(dev, &sun_mono) == RES_OK);
+ CHK(ssol_sun_set_direction(sun_mono, d3(dir, 1, 0, -1)) == RES_OK);
+ CHK(ssol_sun_set_spectrum(sun_mono, spectrum) == RES_OK);
+ CHK(ssol_sun_set_dni(sun_mono, DNI) == RES_OK);
+ CHK(ssol_scene_detach_sun(scene, sun) == RES_OK);
+ CHK(ssol_scene_attach_sun(scene, sun_mono) == RES_OK);
ka[1] = 0.2; ka[0] = ka[2] = 0.1;
desc.wavelengths = wavelengths;
desc.intensities = ka;
desc.count = 3;
- CHECK(ssol_spectrum_setup(abs_spectrum, get_wlen, 3, &desc), RES_OK);
- CHECK(ssol_spectrum_setup(abs_spectrum, get_wlen, 2, &desc), RES_OK);
+ CHK(ssol_spectrum_setup(abs_spectrum, get_wlen, 3, &desc) == RES_OK);
+ CHK(ssol_spectrum_setup(abs_spectrum, get_wlen, 2, &desc) == RES_OK);
extinction.type = SSOL_DATA_SPECTRUM;
extinction.value.spectrum = abs_spectrum;
- CHECK(ssol_atmosphere_set_extinction(atm, &extinction), RES_OK);
+ CHK(ssol_atmosphere_set_extinction(atm, &extinction) == RES_OK);
- CHECK(ssol_solve(scene, rng, N__, 0, NULL, &estimator), RES_OK);
- CHECK(ssol_estimator_get_realisation_count(estimator, &count), RES_OK);
- CHECK(count, N__);
+ CHK(ssol_solve(scene, rng, N__, 0, NULL, &estimator) == RES_OK);
+ CHK(ssol_estimator_get_realisation_count(estimator, &count) == RES_OK);
+ CHK(count == N__);
#define K2 (exp(-0.121 * 4 * sqrt(2)))
m = 4 * K2 * DNI_cos;
std = 0;
- CHECK(ssol_estimator_get_mc_global(estimator, &mc_global), RES_OK);
+ CHK(ssol_estimator_get_mc_global(estimator, &mc_global) == RES_OK);
PRINT_GLOBAL(mc_global);
- CHECK(eq_eps(mc_global.shadowed.E, 0, 1e-4), 1);
- CHECK(eq_eps(mc_global.missing.E, m, 1e-4), 1);
- CHECK(eq_eps(mc_global.cos_factor.E, COS, 1e-4), 1);
- CHECK(GET_MC_RCV(estimator, target, SSOL_FRONT, &mc_rcv), RES_OK);
+ CHK(eq_eps(mc_global.shadowed.E, 0, 1e-4) == 1);
+ CHK(eq_eps(mc_global.missing.E, m, 1e-4) == 1);
+ CHK(eq_eps(mc_global.cos_factor.E, COS, 1e-4) == 1);
+ CHK(GET_MC_RCV(estimator, target, SSOL_FRONT, &mc_rcv) == RES_OK);
printf("Ir(target) = %g +/- %g\n",
mc_rcv.incoming_flux.E, mc_rcv.incoming_flux.SE);
PRINT_RCV(mc_rcv);
- CHECK(eq_eps(mc_rcv.incoming_flux.E, m, 1e-4), 1);
- CHECK(eq_eps(mc_rcv.incoming_flux.SE, std, 1e-4), 1);
+ CHK(eq_eps(mc_rcv.incoming_flux.E, m, 1e-4) == 1);
+ CHK(eq_eps(mc_rcv.incoming_flux.SE, std, 1e-4) == 1);
/* Free data */
- CHECK(ssol_instance_ref_put(heliostat2), RES_OK);
- CHECK(ssol_object_ref_put(m_object2), RES_OK);
- CHECK(ssol_material_ref_put(m_mtl2), RES_OK);
- CHECK(ssol_instance_ref_put(heliostat), RES_OK);
- CHECK(ssol_instance_ref_put(secondary), RES_OK);
- CHECK(ssol_instance_ref_put(target), RES_OK);
- CHECK(ssol_object_ref_put(m_object), RES_OK);
- CHECK(ssol_object_ref_put(t_object), RES_OK);
- CHECK(ssol_shape_ref_put(dummy), RES_OK);
- CHECK(ssol_shape_ref_put(square), RES_OK);
- CHECK(ssol_material_ref_put(m_mtl), RES_OK);
- CHECK(ssol_material_ref_put(v_mtl), RES_OK);
- CHECK(ssol_device_ref_put(dev), RES_OK);
- CHECK(ssol_scene_ref_put(scene), RES_OK);
- CHECK(ssol_atmosphere_ref_put(atm), RES_OK);
- CHECK(ssol_estimator_ref_put(estimator), RES_OK);
- CHECK(ssol_spectrum_ref_put(spectrum), RES_OK);
- CHECK(ssol_spectrum_ref_put(abs_spectrum), RES_OK);
- CHECK(ssol_sun_ref_put(sun), RES_OK);
- CHECK(ssol_sun_ref_put(sun_mono), RES_OK);
- CHECK(ssp_rng_ref_put(rng), RES_OK);
+ CHK(ssol_instance_ref_put(heliostat2) == RES_OK);
+ CHK(ssol_object_ref_put(m_object2) == RES_OK);
+ CHK(ssol_material_ref_put(m_mtl2) == RES_OK);
+ CHK(ssol_instance_ref_put(heliostat) == RES_OK);
+ CHK(ssol_instance_ref_put(secondary) == RES_OK);
+ CHK(ssol_instance_ref_put(target) == RES_OK);
+ CHK(ssol_object_ref_put(m_object) == RES_OK);
+ CHK(ssol_object_ref_put(t_object) == RES_OK);
+ CHK(ssol_shape_ref_put(dummy) == RES_OK);
+ CHK(ssol_shape_ref_put(square) == RES_OK);
+ CHK(ssol_material_ref_put(m_mtl) == RES_OK);
+ CHK(ssol_material_ref_put(v_mtl) == RES_OK);
+ CHK(ssol_device_ref_put(dev) == RES_OK);
+ CHK(ssol_scene_ref_put(scene) == RES_OK);
+ CHK(ssol_atmosphere_ref_put(atm) == RES_OK);
+ CHK(ssol_estimator_ref_put(estimator) == RES_OK);
+ CHK(ssol_spectrum_ref_put(spectrum) == RES_OK);
+ CHK(ssol_spectrum_ref_put(abs_spectrum) == RES_OK);
+ CHK(ssol_sun_ref_put(sun) == RES_OK);
+ CHK(ssol_sun_ref_put(sun_mono) == RES_OK);
+ CHK(ssp_rng_ref_put(rng) == RES_OK);
check_memory_allocator(&allocator);
mem_shutdown_proxy_allocator(&allocator);
- CHECK(mem_allocated_size(), 0);
+ CHK(mem_allocated_size() == 0);
return 0;
}
diff --git a/src/test_ssol_solver10.c b/src/test_ssol_solver10.c
@@ -46,7 +46,7 @@ get_wlen(const size_t i, double* wlen, double* data, void* ctx)
{
double wavelengths[3] = { 1, 2, 3 };
double intensities[3] = { 1, 0.8, 1 };
- CHECK(i < 3, 1);
+ CHK(i < 3);
(void) ctx;
*wlen = wavelengths[i];
*data = intensities[i];
@@ -87,62 +87,62 @@ main(int argc, char** argv)
d33_set_identity(transform);
- CHECK(ssol_device_create
- (NULL, &allocator, SSOL_NTHREADS_DEFAULT, 0, &dev), RES_OK);
+ CHK(ssol_device_create
+ (NULL, &allocator, SSOL_NTHREADS_DEFAULT, 0, &dev) == RES_OK);
#define DNI 1000
- CHECK(ssp_rng_create(&allocator, &ssp_rng_threefry, &rng), RES_OK);
- CHECK(ssol_spectrum_create(dev, &spectrum), RES_OK);
- CHECK(ssol_spectrum_setup(spectrum, get_wlen, 3, NULL), RES_OK);
- CHECK(ssol_sun_create_pillbox(dev, &sun), RES_OK);
- CHECK(ssol_sun_pillbox_set_half_angle(sun, 1), RES_OK);
- CHECK(ssol_sun_set_direction(sun, d3(dir, 0, 0, -1)), RES_OK);
- CHECK(ssol_sun_set_spectrum(sun, spectrum), RES_OK);
- CHECK(ssol_sun_set_dni(sun, DNI), RES_OK);
- CHECK(ssol_scene_create(dev, &scene), RES_OK);
- CHECK(ssol_scene_attach_sun(scene, sun), RES_OK);
+ CHK(ssp_rng_create(&allocator, &ssp_rng_threefry, &rng) == RES_OK);
+ CHK(ssol_spectrum_create(dev, &spectrum) == RES_OK);
+ CHK(ssol_spectrum_setup(spectrum, get_wlen, 3, NULL) == RES_OK);
+ CHK(ssol_sun_create_pillbox(dev, &sun) == RES_OK);
+ CHK(ssol_sun_pillbox_set_half_angle(sun, 1) == RES_OK);
+ CHK(ssol_sun_set_direction(sun, d3(dir, 0, 0, -1)) == RES_OK);
+ CHK(ssol_sun_set_spectrum(sun, spectrum) == RES_OK);
+ CHK(ssol_sun_set_dni(sun, DNI) == RES_OK);
+ CHK(ssol_scene_create(dev, &scene) == RES_OK);
+ CHK(ssol_scene_attach_sun(scene, sun) == RES_OK);
/* Create scene content */
- CHECK(ssol_shape_create_mesh(dev, &square), RES_OK);
+ CHK(ssol_shape_create_mesh(dev, &square) == RES_OK);
attribs[0].usage = SSOL_POSITION;
attribs[0].get = get_position;
- CHECK(ssol_mesh_setup(square, SQUARE_NTRIS__, get_ids,
- SQUARE_NVERTS__, attribs, 1, (void*) &SQUARE_DESC__), RES_OK);
+ CHK(ssol_mesh_setup(square, SQUARE_NTRIS__, get_ids,
+ SQUARE_NVERTS__, attribs, 1, (void*) &SQUARE_DESC__) == RES_OK);
- CHECK(ssol_material_create_matte(dev, &m_mtl), RES_OK);
+ CHK(ssol_material_create_matte(dev, &m_mtl) == RES_OK);
shader.normal = get_shader_normal;
shader.reflectivity = get_shader_reflectivity_2;
- CHECK(ssol_matte_setup(m_mtl, &shader), RES_OK);
+ CHK(ssol_matte_setup(m_mtl, &shader) == RES_OK);
- CHECK(ssol_object_create(dev, &m_object), RES_OK);
- CHECK(ssol_object_add_shaded_shape(m_object, square, m_mtl, m_mtl), RES_OK);
- CHECK(ssol_object_instantiate(m_object, &geom1), RES_OK);
- CHECK(ssol_instance_set_receiver(geom1, SSOL_FRONT, 0), RES_OK);
+ CHK(ssol_object_create(dev, &m_object) == RES_OK);
+ CHK(ssol_object_add_shaded_shape(m_object, square, m_mtl, m_mtl) == RES_OK);
+ CHK(ssol_object_instantiate(m_object, &geom1) == RES_OK);
+ CHK(ssol_instance_set_receiver(geom1, SSOL_FRONT, 0) == RES_OK);
d3_splat(transform + 9, 0);
transform[9] = -10;
- CHECK(ssol_instance_set_transform(geom1, transform), RES_OK);
- CHECK(ssol_scene_attach_instance(scene, geom1), RES_OK);
+ CHK(ssol_instance_set_transform(geom1, transform) == RES_OK);
+ CHK(ssol_scene_attach_instance(scene, geom1) == RES_OK);
#define N1__ 10000
#define GET_MC_RCV ssol_estimator_get_mc_receiver
- CHECK(ssol_solve(scene, rng, N1__, 0, NULL, &estimator), RES_OK);
- CHECK(ssol_estimator_get_realisation_count(estimator, &count), RES_OK);
- CHECK(count, N1__);
- CHECK(ssol_estimator_get_failed_count(estimator, &count), RES_OK);
- CHECK(count, 0);
+ CHK(ssol_solve(scene, rng, N1__, 0, NULL, &estimator) == RES_OK);
+ CHK(ssol_estimator_get_realisation_count(estimator, &count) == RES_OK);
+ CHK(count == N1__);
+ CHK(ssol_estimator_get_failed_count(estimator, &count) == RES_OK);
+ CHK(count == 0);
#define DNI_S (DNI * X_SZ * Y_SZ)
- CHECK(ssol_estimator_get_mc_global(estimator, &mc_global1), RES_OK);
- CHECK(GET_MC_RCV(estimator, geom1, SSOL_FRONT, &mc_rcv1), RES_OK);
+ CHK(ssol_estimator_get_mc_global(estimator, &mc_global1) == RES_OK);
+ CHK(GET_MC_RCV(estimator, geom1, SSOL_FRONT, &mc_rcv1) == RES_OK);
PRINT_GLOBAL(mc_global1);
PRINT_RCV(mc_rcv1);
- CHECK(mc_global1.cos_factor.E, 1);
- CHECK(mc_global1.cos_factor.SE, 0);
- CHECK(mc_global1.absorbed_by_receivers.E, DNI_S);
- CHECK(mc_global1.absorbed_by_receivers.SE, 0);
+ CHK(mc_global1.cos_factor.E == 1);
+ CHK(mc_global1.cos_factor.SE == 0);
+ CHK(mc_global1.absorbed_by_receivers.E == DNI_S);
+ CHK(mc_global1.absorbed_by_receivers.SE == 0);
- CHECK(ssol_shape_create_punched_surface(dev, ¶bol), RES_OK);
+ CHK(ssol_shape_create_punched_surface(dev, ¶bol) == RES_OK);
carving.get = get_polygon_vertices;
carving.operation = SSOL_AND;
carving.nb_vertices = POLY_NVERTS__;
@@ -152,51 +152,51 @@ main(int argc, char** argv)
punched.nb_carvings = 1;
punched.quadric = &quadric;
punched.carvings = &carving;
- CHECK(ssol_punched_surface_setup(parabol, &punched), RES_OK);
+ CHK(ssol_punched_surface_setup(parabol, &punched) == RES_OK);
- CHECK(ssol_object_create(dev, &q_object), RES_OK);
- CHECK(ssol_object_add_shaded_shape(q_object, parabol, m_mtl, m_mtl), RES_OK);
- CHECK(ssol_object_instantiate(q_object, &geom2), RES_OK);
- CHECK(ssol_instance_set_receiver(geom2, SSOL_FRONT, 0), RES_OK);
+ CHK(ssol_object_create(dev, &q_object) == RES_OK);
+ CHK(ssol_object_add_shaded_shape(q_object, parabol, m_mtl, m_mtl) == RES_OK);
+ CHK(ssol_object_instantiate(q_object, &geom2) == RES_OK);
+ CHK(ssol_instance_set_receiver(geom2, SSOL_FRONT, 0) == RES_OK);
d3_splat(transform + 9, 0);
transform[9] = +10;
- CHECK(ssol_instance_set_transform(geom2, transform), RES_OK);
- CHECK(ssol_scene_attach_instance(scene, geom2), RES_OK);
+ CHK(ssol_instance_set_transform(geom2, transform) == RES_OK);
+ CHK(ssol_scene_attach_instance(scene, geom2) == RES_OK);
- CHECK(ssol_scene_detach_instance(scene, geom1), RES_OK);
- CHECK(ssol_estimator_ref_put(estimator), RES_OK);
+ CHK(ssol_scene_detach_instance(scene, geom1) == RES_OK);
+ CHK(ssol_estimator_ref_put(estimator) == RES_OK);
#define N2__ 100000
- CHECK(ssol_solve(scene, rng, N2__, 0, NULL, &estimator), RES_OK);
- CHECK(ssol_estimator_get_realisation_count(estimator, &count), RES_OK);
- CHECK(count, N2__);
- CHECK(ssol_estimator_get_failed_count(estimator, &count), RES_OK);
- CHECK(count, 0);
- CHECK(ssol_estimator_get_mc_global(estimator, &mc_global2), RES_OK);
- CHECK(GET_MC_RCV(estimator, geom2, SSOL_FRONT, &mc_rcv2), RES_OK);
+ CHK(ssol_solve(scene, rng, N2__, 0, NULL, &estimator) == RES_OK);
+ CHK(ssol_estimator_get_realisation_count(estimator, &count) == RES_OK);
+ CHK(count == N2__);
+ CHK(ssol_estimator_get_failed_count(estimator, &count) == RES_OK);
+ CHK(count == 0);
+ CHK(ssol_estimator_get_mc_global(estimator, &mc_global2) == RES_OK);
+ CHK(GET_MC_RCV(estimator, geom2, SSOL_FRONT, &mc_rcv2) == RES_OK);
PRINT_GLOBAL(mc_global2);
PRINT_RCV(mc_rcv2);
- CHECK(eq_eps(mc_global2.absorbed_by_receivers.E, DNI_S, 3 * mc_global2.absorbed_by_receivers.SE), 1);
+ CHK(eq_eps(mc_global2.absorbed_by_receivers.E, DNI_S, 3 * mc_global2.absorbed_by_receivers.SE) == 1);
/* Free data */
- CHECK(ssol_instance_ref_put(geom1), RES_OK);
- CHECK(ssol_instance_ref_put(geom2), RES_OK);
- CHECK(ssol_object_ref_put(m_object), RES_OK);
- CHECK(ssol_object_ref_put(q_object), RES_OK);
- CHECK(ssol_shape_ref_put(square), RES_OK);
- CHECK(ssol_shape_ref_put(parabol), RES_OK);
- CHECK(ssol_material_ref_put(m_mtl), RES_OK);
- CHECK(ssol_estimator_ref_put(estimator), RES_OK);
- CHECK(ssol_device_ref_put(dev), RES_OK);
- CHECK(ssol_scene_ref_put(scene), RES_OK);
- CHECK(ssp_rng_ref_put(rng), RES_OK);
- CHECK(ssol_spectrum_ref_put(spectrum), RES_OK);
- CHECK(ssol_sun_ref_put(sun), RES_OK);
+ CHK(ssol_instance_ref_put(geom1) == RES_OK);
+ CHK(ssol_instance_ref_put(geom2) == RES_OK);
+ CHK(ssol_object_ref_put(m_object) == RES_OK);
+ CHK(ssol_object_ref_put(q_object) == RES_OK);
+ CHK(ssol_shape_ref_put(square) == RES_OK);
+ CHK(ssol_shape_ref_put(parabol) == RES_OK);
+ CHK(ssol_material_ref_put(m_mtl) == RES_OK);
+ CHK(ssol_estimator_ref_put(estimator) == RES_OK);
+ CHK(ssol_device_ref_put(dev) == RES_OK);
+ CHK(ssol_scene_ref_put(scene) == RES_OK);
+ CHK(ssp_rng_ref_put(rng) == RES_OK);
+ CHK(ssol_spectrum_ref_put(spectrum) == RES_OK);
+ CHK(ssol_sun_ref_put(sun) == RES_OK);
check_memory_allocator(&allocator);
mem_shutdown_proxy_allocator(&allocator);
- CHECK(mem_allocated_size(), 0);
+ CHK(mem_allocated_size() == 0);
return 0;
}
diff --git a/src/test_ssol_solver11.c b/src/test_ssol_solver11.c
@@ -0,0 +1,202 @@
+/* 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/>. */
+
+#include "ssol.h"
+#include "test_ssol_utils.h"
+#define REFLECTIVITY 0
+#include "test_ssol_materials.h"
+
+#include <rsys/math.h>
+
+#define X_SZ 10
+#define Y_SZ 10
+#define PLANE_NAME SQUARE
+#define HALF_X (X_SZ / 2)
+#define HALF_Y (Y_SZ / 2)
+STATIC_ASSERT((HALF_X * 2 == X_SZ), ONLY_ENVEN_VALUES_FOR_SQUARE_X);
+STATIC_ASSERT((HALF_Y * 2 == Y_SZ), ONLY_ENVEN_VALUES_FOR_SQUARE_Y);
+#include "test_ssol_rect_geometry.h"
+
+#define POLYGON_NAME POLY
+#define HALF_X (X_SZ / 2)
+#define HALF_Y (Y_SZ / 2)
+STATIC_ASSERT((HALF_X * 2 == X_SZ), ONLY_ENVEN_VALUES_FOR_X_SZ);
+STATIC_ASSERT((HALF_Y * 2 == Y_SZ), ONLY_ENVEN_VALUES_FOR_Y_SZ);
+#include "test_ssol_rect2D_geometry.h"
+
+#include <rsys/double33.h>
+
+#include <star/s3d.h>
+#include <star/ssp.h>
+
+static void
+get_wlen(const size_t i, double* wlen, double* data, void* ctx)
+{
+ double wavelengths[3] = { 1, 2, 3 };
+ double intensities[3] = { 1, 0.8, 1 };
+ CHK(i < 3);
+ (void) ctx;
+ *wlen = wavelengths[i];
+ *data = intensities[i];
+}
+
+int
+main(int argc, char** argv)
+{
+ struct mem_allocator allocator;
+ struct ssol_device* dev;
+ struct ssp_rng* rng;
+ struct ssol_scene* scene;
+ struct ssol_shape* square;
+ struct ssol_shape* parabol;
+ struct ssol_vertex_data attribs[1] = { SSOL_VERTEX_DATA_NULL__ };
+ struct ssol_material* m_mtl;
+ struct ssol_matte_shader shader = SSOL_MATTE_SHADER_NULL;
+ struct ssol_object* m_object;
+ struct ssol_object* q_object;
+ struct ssol_carving carving = SSOL_CARVING_NULL;
+ struct ssol_quadric quadric = SSOL_QUADRIC_DEFAULT;
+ struct ssol_punched_surface punched = SSOL_PUNCHED_SURFACE_NULL;
+ struct ssol_instance* geom1;
+ struct ssol_instance* geom2;
+ struct ssol_sun* sun;
+ struct ssol_spectrum* spectrum;
+ struct ssol_estimator* estimator;
+ struct ssol_mc_global mc_global1;
+ struct ssol_mc_global mc_global2;
+ struct ssol_mc_receiver mc_rcv1;
+ struct ssol_mc_receiver mc_rcv2;
+ double dir[3];
+ double transform[12]; /* 3x4 column major matrix */
+ size_t count;
+
+ (void) argc, (void) argv;
+ mem_init_proxy_allocator(&allocator, &mem_default_allocator);
+
+ d33_set_identity(transform);
+
+ CHK(ssol_device_create
+ (NULL, &allocator, SSOL_NTHREADS_DEFAULT, 0, &dev) == RES_OK);
+
+#define DNI 1000
+ CHK(ssp_rng_create(&allocator, &ssp_rng_threefry, &rng) == RES_OK);
+ CHK(ssol_spectrum_create(dev, &spectrum) == RES_OK);
+ CHK(ssol_spectrum_setup(spectrum, get_wlen, 3, NULL) == RES_OK);
+ CHK(ssol_sun_create_buie(dev, &sun) == RES_OK);
+ CHK(ssol_sun_set_buie_param(sun, 0.1) == RES_OK);
+ CHK(ssol_sun_set_direction(sun, d3(dir, 0, 0, -1)) == RES_OK);
+ CHK(ssol_sun_set_spectrum(sun, spectrum) == RES_OK);
+ CHK(ssol_sun_set_dni(sun, DNI) == RES_OK);
+ CHK(ssol_scene_create(dev, &scene) == RES_OK);
+ CHK(ssol_scene_attach_sun(scene, sun) == RES_OK);
+
+ /* Create scene content */
+
+ CHK(ssol_shape_create_mesh(dev, &square) == RES_OK);
+ attribs[0].usage = SSOL_POSITION;
+ attribs[0].get = get_position;
+ CHK(ssol_mesh_setup(square, SQUARE_NTRIS__, get_ids,
+ SQUARE_NVERTS__, attribs, 1, (void*) &SQUARE_DESC__) == RES_OK);
+
+ CHK(ssol_material_create_matte(dev, &m_mtl) == RES_OK);
+ shader.normal = get_shader_normal;
+ shader.reflectivity = get_shader_reflectivity_2;
+ CHK(ssol_matte_setup(m_mtl, &shader) == RES_OK);
+
+ CHK(ssol_object_create(dev, &m_object) == RES_OK);
+ CHK(ssol_object_add_shaded_shape(m_object, square, m_mtl, m_mtl) == RES_OK);
+ CHK(ssol_object_instantiate(m_object, &geom1) == RES_OK);
+ CHK(ssol_instance_set_receiver(geom1, SSOL_FRONT, 0) == RES_OK);
+ d3_splat(transform + 9, 0);
+ transform[9] = -10;
+ CHK(ssol_instance_set_transform(geom1, transform) == RES_OK);
+ CHK(ssol_scene_attach_instance(scene, geom1) == RES_OK);
+
+#define N1__ 10000
+#define GET_MC_RCV ssol_estimator_get_mc_receiver
+ CHK(ssol_solve(scene, rng, N1__, 0, NULL, &estimator) == RES_OK);
+ CHK(ssol_estimator_get_realisation_count(estimator, &count) == RES_OK);
+ CHK(count == N1__);
+ CHK(ssol_estimator_get_failed_count(estimator, &count) == RES_OK);
+ CHK(count == 0);
+#define DNI_S (DNI * X_SZ * Y_SZ)
+ CHK(ssol_estimator_get_mc_global(estimator, &mc_global1) == RES_OK);
+ CHK(GET_MC_RCV(estimator, geom1, SSOL_FRONT, &mc_rcv1) == RES_OK);
+
+ PRINT_GLOBAL(mc_global1);
+ PRINT_RCV(mc_rcv1);
+ CHK(mc_global1.cos_factor.E == 1);
+ CHK(mc_global1.cos_factor.SE == 0);
+ CHK(mc_global1.absorbed_by_receivers.E == DNI_S);
+ CHK(mc_global1.absorbed_by_receivers.SE == 0);
+
+ CHK(ssol_shape_create_punched_surface(dev, ¶bol) == RES_OK);
+ carving.get = get_polygon_vertices;
+ carving.operation = SSOL_AND;
+ carving.nb_vertices = POLY_NVERTS__;
+ carving.context = &POLY_EDGES__;
+ quadric.type = SSOL_QUADRIC_PARABOL;
+ quadric.data.parabol.focal = 10;
+ punched.nb_carvings = 1;
+ punched.quadric = &quadric;
+ punched.carvings = &carving;
+ CHK(ssol_punched_surface_setup(parabol, &punched) == RES_OK);
+
+ CHK(ssol_object_create(dev, &q_object) == RES_OK);
+ CHK(ssol_object_add_shaded_shape(q_object, parabol, m_mtl, m_mtl) == RES_OK);
+ CHK(ssol_object_instantiate(q_object, &geom2) == RES_OK);
+ CHK(ssol_instance_set_receiver(geom2, SSOL_FRONT, 0) == RES_OK);
+ d3_splat(transform + 9, 0);
+ transform[9] = +10;
+ CHK(ssol_instance_set_transform(geom2, transform) == RES_OK);
+ CHK(ssol_scene_attach_instance(scene, geom2) == RES_OK);
+
+ CHK(ssol_scene_detach_instance(scene, geom1) == RES_OK);
+ CHK(ssol_estimator_ref_put(estimator) == RES_OK);
+
+#define N2__ 100000
+ CHK(ssol_solve(scene, rng, N2__, 0, NULL, &estimator) == RES_OK);
+ CHK(ssol_estimator_get_realisation_count(estimator, &count) == RES_OK);
+ CHK(count == N2__);
+ CHK(ssol_estimator_get_failed_count(estimator, &count) == RES_OK);
+ CHK(count == 0);
+ CHK(ssol_estimator_get_mc_global(estimator, &mc_global2) == RES_OK);
+ CHK(GET_MC_RCV(estimator, geom2, SSOL_FRONT, &mc_rcv2) == RES_OK);
+
+ PRINT_GLOBAL(mc_global2);
+ PRINT_RCV(mc_rcv2);
+ CHK(eq_eps(mc_global2.absorbed_by_receivers.E, DNI_S, 3 * mc_global2.absorbed_by_receivers.SE) == 1);
+
+ /* Free data */
+ CHK(ssol_instance_ref_put(geom1) == RES_OK);
+ CHK(ssol_instance_ref_put(geom2) == RES_OK);
+ CHK(ssol_object_ref_put(m_object) == RES_OK);
+ CHK(ssol_object_ref_put(q_object) == RES_OK);
+ CHK(ssol_shape_ref_put(square) == RES_OK);
+ CHK(ssol_shape_ref_put(parabol) == RES_OK);
+ CHK(ssol_material_ref_put(m_mtl) == RES_OK);
+ CHK(ssol_estimator_ref_put(estimator) == RES_OK);
+ CHK(ssol_device_ref_put(dev) == RES_OK);
+ CHK(ssol_scene_ref_put(scene) == RES_OK);
+ CHK(ssp_rng_ref_put(rng) == RES_OK);
+ CHK(ssol_spectrum_ref_put(spectrum) == RES_OK);
+ CHK(ssol_sun_ref_put(sun) == RES_OK);
+
+ check_memory_allocator(&allocator);
+ mem_shutdown_proxy_allocator(&allocator);
+ CHK(mem_allocated_size() == 0);
+
+ return 0;
+}
diff --git a/src/test_ssol_solver12.c b/src/test_ssol_solver12.c
@@ -0,0 +1,202 @@
+/* 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/>. */
+
+#include "ssol.h"
+#include "test_ssol_utils.h"
+#define REFLECTIVITY 0
+#include "test_ssol_materials.h"
+
+#include <rsys/math.h>
+
+#define X_SZ 10
+#define Y_SZ 10
+#define PLANE_NAME SQUARE
+#define HALF_X (X_SZ / 2)
+#define HALF_Y (Y_SZ / 2)
+STATIC_ASSERT((HALF_X * 2 == X_SZ), ONLY_ENVEN_VALUES_FOR_SQUARE_X);
+STATIC_ASSERT((HALF_Y * 2 == Y_SZ), ONLY_ENVEN_VALUES_FOR_SQUARE_Y);
+#include "test_ssol_rect_geometry.h"
+
+#define POLYGON_NAME POLY
+#define HALF_X (X_SZ / 2)
+#define HALF_Y (Y_SZ / 2)
+STATIC_ASSERT((HALF_X * 2 == X_SZ), ONLY_ENVEN_VALUES_FOR_X_SZ);
+STATIC_ASSERT((HALF_Y * 2 == Y_SZ), ONLY_ENVEN_VALUES_FOR_Y_SZ);
+#include "test_ssol_rect2D_geometry.h"
+
+#include <rsys/double33.h>
+
+#include <star/s3d.h>
+#include <star/ssp.h>
+
+static void
+get_wlen(const size_t i, double* wlen, double* data, void* ctx)
+{
+ double wavelengths[3] = { 1, 2, 3 };
+ double intensities[3] = { 1, 0.8, 1 };
+ CHK(i < 3);
+ (void) ctx;
+ *wlen = wavelengths[i];
+ *data = intensities[i];
+}
+
+int
+main(int argc, char** argv)
+{
+ struct mem_allocator allocator;
+ struct ssol_device* dev;
+ struct ssp_rng* rng;
+ struct ssol_scene* scene;
+ struct ssol_shape* square;
+ struct ssol_shape* parabol;
+ struct ssol_vertex_data attribs[1] = { SSOL_VERTEX_DATA_NULL__ };
+ struct ssol_material* m_mtl;
+ struct ssol_matte_shader shader = SSOL_MATTE_SHADER_NULL;
+ struct ssol_object* m_object;
+ struct ssol_object* q_object;
+ struct ssol_carving carving = SSOL_CARVING_NULL;
+ struct ssol_quadric quadric = SSOL_QUADRIC_DEFAULT;
+ struct ssol_punched_surface punched = SSOL_PUNCHED_SURFACE_NULL;
+ struct ssol_instance* geom1;
+ struct ssol_instance* geom2;
+ struct ssol_sun* sun;
+ struct ssol_spectrum* spectrum;
+ struct ssol_estimator* estimator;
+ struct ssol_mc_global mc_global1;
+ struct ssol_mc_global mc_global2;
+ struct ssol_mc_receiver mc_rcv1;
+ struct ssol_mc_receiver mc_rcv2;
+ double dir[3];
+ double transform[12]; /* 3x4 column major matrix */
+ size_t count;
+
+ (void) argc, (void) argv;
+ mem_init_proxy_allocator(&allocator, &mem_default_allocator);
+
+ d33_set_identity(transform);
+
+ CHK(ssol_device_create
+ (NULL, &allocator, SSOL_NTHREADS_DEFAULT, 0, &dev) == RES_OK);
+
+#define DNI 1000
+ CHK(ssp_rng_create(&allocator, &ssp_rng_threefry, &rng) == RES_OK);
+ CHK(ssol_spectrum_create(dev, &spectrum) == RES_OK);
+ CHK(ssol_spectrum_setup(spectrum, get_wlen, 3, NULL) == RES_OK);
+ CHK(ssol_sun_create_gaussian(dev, &sun) == RES_OK);
+ CHK(ssol_sun_gaussian_set_std_dev(sun, 0.01) == RES_OK);
+ CHK(ssol_sun_set_direction(sun, d3(dir, 0, 0, -1)) == RES_OK);
+ CHK(ssol_sun_set_spectrum(sun, spectrum) == RES_OK);
+ CHK(ssol_sun_set_dni(sun, DNI) == RES_OK);
+ CHK(ssol_scene_create(dev, &scene) == RES_OK);
+ CHK(ssol_scene_attach_sun(scene, sun) == RES_OK);
+
+ /* Create scene content */
+
+ CHK(ssol_shape_create_mesh(dev, &square) == RES_OK);
+ attribs[0].usage = SSOL_POSITION;
+ attribs[0].get = get_position;
+ CHK(ssol_mesh_setup(square, SQUARE_NTRIS__, get_ids,
+ SQUARE_NVERTS__, attribs, 1, (void*) &SQUARE_DESC__) == RES_OK);
+
+ CHK(ssol_material_create_matte(dev, &m_mtl) == RES_OK);
+ shader.normal = get_shader_normal;
+ shader.reflectivity = get_shader_reflectivity_2;
+ CHK(ssol_matte_setup(m_mtl, &shader) == RES_OK);
+
+ CHK(ssol_object_create(dev, &m_object) == RES_OK);
+ CHK(ssol_object_add_shaded_shape(m_object, square, m_mtl, m_mtl) == RES_OK);
+ CHK(ssol_object_instantiate(m_object, &geom1) == RES_OK);
+ CHK(ssol_instance_set_receiver(geom1, SSOL_FRONT, 0) == RES_OK);
+ d3_splat(transform + 9, 0);
+ transform[9] = -10;
+ CHK(ssol_instance_set_transform(geom1, transform) == RES_OK);
+ CHK(ssol_scene_attach_instance(scene, geom1) == RES_OK);
+
+#define N1__ 10000
+#define GET_MC_RCV ssol_estimator_get_mc_receiver
+ CHK(ssol_solve(scene, rng, N1__, 0, NULL, &estimator) == RES_OK);
+ CHK(ssol_estimator_get_realisation_count(estimator, &count) == RES_OK);
+ CHK(count == N1__);
+ CHK(ssol_estimator_get_failed_count(estimator, &count) == RES_OK);
+ CHK(count == 0);
+#define DNI_S (DNI * X_SZ * Y_SZ)
+ CHK(ssol_estimator_get_mc_global(estimator, &mc_global1) == RES_OK);
+ CHK(GET_MC_RCV(estimator, geom1, SSOL_FRONT, &mc_rcv1) == RES_OK);
+
+ PRINT_GLOBAL(mc_global1);
+ PRINT_RCV(mc_rcv1);
+ CHK(mc_global1.cos_factor.E == 1);
+ CHK(mc_global1.cos_factor.SE == 0);
+ CHK(mc_global1.absorbed_by_receivers.E == DNI_S);
+ CHK(mc_global1.absorbed_by_receivers.SE == 0);
+
+ CHK(ssol_shape_create_punched_surface(dev, ¶bol) == RES_OK);
+ carving.get = get_polygon_vertices;
+ carving.operation = SSOL_AND;
+ carving.nb_vertices = POLY_NVERTS__;
+ carving.context = &POLY_EDGES__;
+ quadric.type = SSOL_QUADRIC_PARABOL;
+ quadric.data.parabol.focal = 10;
+ punched.nb_carvings = 1;
+ punched.quadric = &quadric;
+ punched.carvings = &carving;
+ CHK(ssol_punched_surface_setup(parabol, &punched) == RES_OK);
+
+ CHK(ssol_object_create(dev, &q_object) == RES_OK);
+ CHK(ssol_object_add_shaded_shape(q_object, parabol, m_mtl, m_mtl) == RES_OK);
+ CHK(ssol_object_instantiate(q_object, &geom2) == RES_OK);
+ CHK(ssol_instance_set_receiver(geom2, SSOL_FRONT, 0) == RES_OK);
+ d3_splat(transform + 9, 0);
+ transform[9] = +10;
+ CHK(ssol_instance_set_transform(geom2, transform) == RES_OK);
+ CHK(ssol_scene_attach_instance(scene, geom2) == RES_OK);
+
+ CHK(ssol_scene_detach_instance(scene, geom1) == RES_OK);
+ CHK(ssol_estimator_ref_put(estimator) == RES_OK);
+
+#define N2__ 100000
+ CHK(ssol_solve(scene, rng, N2__, 0, NULL, &estimator) == RES_OK);
+ CHK(ssol_estimator_get_realisation_count(estimator, &count) == RES_OK);
+ CHK(count == N2__);
+ CHK(ssol_estimator_get_failed_count(estimator, &count) == RES_OK);
+ CHK(count == 0);
+ CHK(ssol_estimator_get_mc_global(estimator, &mc_global2) == RES_OK);
+ CHK(GET_MC_RCV(estimator, geom2, SSOL_FRONT, &mc_rcv2) == RES_OK);
+
+ PRINT_GLOBAL(mc_global2);
+ PRINT_RCV(mc_rcv2);
+ CHK(eq_eps(mc_global2.absorbed_by_receivers.E, DNI_S, 3 * mc_global2.absorbed_by_receivers.SE) == 1);
+
+ /* Free data */
+ CHK(ssol_instance_ref_put(geom1) == RES_OK);
+ CHK(ssol_instance_ref_put(geom2) == RES_OK);
+ CHK(ssol_object_ref_put(m_object) == RES_OK);
+ CHK(ssol_object_ref_put(q_object) == RES_OK);
+ CHK(ssol_shape_ref_put(square) == RES_OK);
+ CHK(ssol_shape_ref_put(parabol) == RES_OK);
+ CHK(ssol_material_ref_put(m_mtl) == RES_OK);
+ CHK(ssol_estimator_ref_put(estimator) == RES_OK);
+ CHK(ssol_device_ref_put(dev) == RES_OK);
+ CHK(ssol_scene_ref_put(scene) == RES_OK);
+ CHK(ssp_rng_ref_put(rng) == RES_OK);
+ CHK(ssol_spectrum_ref_put(spectrum) == RES_OK);
+ CHK(ssol_sun_ref_put(sun) == RES_OK);
+
+ check_memory_allocator(&allocator);
+ mem_shutdown_proxy_allocator(&allocator);
+ CHK(mem_allocated_size() == 0);
+
+ return 0;
+}
diff --git a/src/test_ssol_solver2.c b/src/test_ssol_solver2.c
@@ -42,7 +42,7 @@ get_wlen(const size_t i, double* wlen, double* data, void* ctx)
{
double wavelengths[3] = { 1, 2, 3 };
double intensities[3] = { 1, 0.8, 1 };
- CHECK(i < 3, 1);
+ CHK(i < 3);
(void)ctx;
*wlen = wavelengths[i];
*data = intensities[i];
@@ -101,34 +101,34 @@ main(int argc, char** argv)
mem_init_proxy_allocator(&allocator, &mem_default_allocator);
- CHECK(ssol_device_create
- (NULL, &allocator, SSOL_NTHREADS_DEFAULT, 0, &dev), RES_OK);
+ CHK(ssol_device_create
+ (NULL, &allocator, SSOL_NTHREADS_DEFAULT, 0, &dev) == RES_OK);
- CHECK(ssp_rng_create(&allocator, &ssp_rng_threefry, &rng), RES_OK);
- CHECK(ssol_spectrum_create(dev, &spectrum), RES_OK);
- CHECK(ssol_spectrum_setup(spectrum, get_wlen, 3, NULL), RES_OK);
- CHECK(ssol_sun_create_directional(dev, &sun), RES_OK);
- CHECK(ssol_sun_set_direction(sun, d3(dir, 1, 0, -1)), RES_OK);
- CHECK(ssol_sun_set_spectrum(sun, spectrum), RES_OK);
- CHECK(ssol_sun_set_dni(sun, 1000), RES_OK);
- CHECK(ssol_scene_create(dev, &scene), RES_OK);
- CHECK(ssol_scene_attach_sun(scene, sun), RES_OK);
+ CHK(ssp_rng_create(&allocator, &ssp_rng_threefry, &rng) == RES_OK);
+ CHK(ssol_spectrum_create(dev, &spectrum) == RES_OK);
+ CHK(ssol_spectrum_setup(spectrum, get_wlen, 3, NULL) == RES_OK);
+ CHK(ssol_sun_create_directional(dev, &sun) == RES_OK);
+ CHK(ssol_sun_set_direction(sun, d3(dir, 1, 0, -1)) == RES_OK);
+ CHK(ssol_sun_set_spectrum(sun, spectrum) == RES_OK);
+ CHK(ssol_sun_set_dni(sun, 1000) == RES_OK);
+ CHK(ssol_scene_create(dev, &scene) == RES_OK);
+ CHK(ssol_scene_attach_sun(scene, sun) == RES_OK);
/* create scene content */
- CHECK(ssol_shape_create_mesh(dev, &square), RES_OK);
+ CHK(ssol_shape_create_mesh(dev, &square) == RES_OK);
attribs[0].usage = SSOL_POSITION;
attribs[0].get = get_position;
- CHECK(ssol_mesh_setup(square, SQUARE_NTRIS__, get_ids,
- SQUARE_NVERTS__, attribs, 1, (void*) &SQUARE_DESC__), RES_OK);
+ CHK(ssol_mesh_setup(square, SQUARE_NTRIS__, get_ids,
+ SQUARE_NVERTS__, attribs, 1, (void*) &SQUARE_DESC__) == RES_OK);
- CHECK(ssol_shape_create_mesh(dev, &rect), RES_OK);
+ CHK(ssol_shape_create_mesh(dev, &rect) == RES_OK);
attribs[0].usage = SSOL_POSITION;
attribs[0].get = get_position;
- CHECK(ssol_mesh_setup(rect, RECT_NTRIS__, get_ids,
- RECT_NVERTS__, attribs, 1, (void*) &RECT_DESC__), RES_OK);
+ CHK(ssol_mesh_setup(rect, RECT_NTRIS__, get_ids,
+ RECT_NVERTS__, attribs, 1, (void*) &RECT_DESC__) == RES_OK);
- CHECK(ssol_shape_create_punched_surface(dev, &quad_square), RES_OK);
+ CHK(ssol_shape_create_punched_surface(dev, &quad_square) == RES_OK);
carving.get = get_polygon_vertices;
carving.operation = SSOL_AND;
carving.nb_vertices = POLY_NVERTS__;
@@ -137,94 +137,94 @@ main(int argc, char** argv)
punched.nb_carvings = 1;
punched.quadric = &quadric;
punched.carvings = &carving;
- CHECK(ssol_punched_surface_setup(quad_square, &punched), RES_OK);
+ CHK(ssol_punched_surface_setup(quad_square, &punched) == RES_OK);
- CHECK(ssol_material_create_mirror(dev, &m_mtl), RES_OK);
+ CHK(ssol_material_create_mirror(dev, &m_mtl) == RES_OK);
shader.normal = get_shader_normal;
shader.reflectivity = get_shader_reflectivity;
shader.roughness = get_shader_roughness;
- 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);
- CHECK(ssol_object_add_shaded_shape(m_object, rect, m_mtl, m_mtl), RES_OK);
- CHECK(ssol_object_instantiate(m_object, &heliostat1), RES_OK);
- CHECK(ssol_object_instantiate(m_object, &heliostat2), RES_OK);
- CHECK(ssol_instance_set_receiver(heliostat1, SSOL_FRONT, 0), RES_OK);
- CHECK(ssol_instance_set_receiver(heliostat2, SSOL_FRONT, 0), RES_OK);
+ CHK(ssol_mirror_setup(m_mtl, &shader, SSOL_MICROFACET_BECKMANN) == RES_OK);
+ CHK(ssol_material_create_virtual(dev, &v_mtl) == RES_OK);
+
+ CHK(ssol_object_create(dev, &m_object) == RES_OK);
+ CHK(ssol_object_add_shaded_shape(m_object, rect, m_mtl, m_mtl) == RES_OK);
+ CHK(ssol_object_instantiate(m_object, &heliostat1) == RES_OK);
+ CHK(ssol_object_instantiate(m_object, &heliostat2) == RES_OK);
+ CHK(ssol_instance_set_receiver(heliostat1, SSOL_FRONT, 0) == RES_OK);
+ CHK(ssol_instance_set_receiver(heliostat2, SSOL_FRONT, 0) == RES_OK);
transform3[9] = -0.5; /* -0.5 offset along X axis */
- CHECK(ssol_instance_set_transform(heliostat1, transform3), RES_OK);
+ CHK(ssol_instance_set_transform(heliostat1, transform3) == RES_OK);
transform3[9] = +0.5; /* +0.5 offset along X axis */
- CHECK(ssol_instance_set_transform(heliostat2, transform3), RES_OK);
- CHECK(ssol_scene_attach_instance(scene, heliostat1), RES_OK);
- CHECK(ssol_scene_attach_instance(scene, heliostat2), RES_OK);
-
- CHECK(ssol_object_create(dev, &s_object), RES_OK);
- CHECK(ssol_object_add_shaded_shape(s_object, quad_square, m_mtl, m_mtl), RES_OK);
- CHECK(ssol_object_instantiate(s_object, &secondary), RES_OK);
- CHECK(ssol_instance_set_receiver(secondary, SSOL_FRONT, 0), RES_OK);
- CHECK(ssol_instance_set_transform(secondary, transform1), RES_OK);
- CHECK(ssol_instance_sample(secondary, 0), RES_OK);
- CHECK(ssol_scene_attach_instance(scene, secondary), RES_OK);
-
- CHECK(ssol_object_create(dev, &t_object), RES_OK);
- CHECK(ssol_object_add_shaded_shape(t_object, square, v_mtl, v_mtl), RES_OK);
- CHECK(ssol_object_instantiate(t_object, &target), RES_OK);
- CHECK(ssol_instance_set_transform(target, transform2), RES_OK);
- CHECK(ssol_instance_set_receiver(target, SSOL_FRONT, 0), RES_OK);
- CHECK(ssol_instance_sample(target, 0), RES_OK);
- CHECK(ssol_scene_attach_instance(scene, target), RES_OK);
+ CHK(ssol_instance_set_transform(heliostat2, transform3) == RES_OK);
+ CHK(ssol_scene_attach_instance(scene, heliostat1) == RES_OK);
+ CHK(ssol_scene_attach_instance(scene, heliostat2) == RES_OK);
+
+ CHK(ssol_object_create(dev, &s_object) == RES_OK);
+ CHK(ssol_object_add_shaded_shape(s_object, quad_square, m_mtl, m_mtl) == RES_OK);
+ CHK(ssol_object_instantiate(s_object, &secondary) == RES_OK);
+ CHK(ssol_instance_set_receiver(secondary, SSOL_FRONT, 0) == RES_OK);
+ CHK(ssol_instance_set_transform(secondary, transform1) == RES_OK);
+ CHK(ssol_instance_sample(secondary, 0) == RES_OK);
+ CHK(ssol_scene_attach_instance(scene, secondary) == RES_OK);
+
+ CHK(ssol_object_create(dev, &t_object) == RES_OK);
+ CHK(ssol_object_add_shaded_shape(t_object, square, v_mtl, v_mtl) == RES_OK);
+ CHK(ssol_object_instantiate(t_object, &target) == RES_OK);
+ CHK(ssol_instance_set_transform(target, transform2) == RES_OK);
+ CHK(ssol_instance_set_receiver(target, SSOL_FRONT, 0) == RES_OK);
+ CHK(ssol_instance_sample(target, 0) == RES_OK);
+ CHK(ssol_scene_attach_instance(scene, target) == RES_OK);
#define N__ 10000
#define GET_MC_RCV ssol_estimator_get_mc_receiver
- CHECK(ssol_solve(scene, rng, N__, 0, NULL, &estimator), RES_OK);
- CHECK(ssol_estimator_get_realisation_count(estimator, &count), RES_OK);
- CHECK(count, N__);
+ CHK(ssol_solve(scene, rng, N__, 0, NULL, &estimator) == RES_OK);
+ CHK(ssol_estimator_get_realisation_count(estimator, &count) == RES_OK);
+ CHK(count == N__);
#define COS cos(PI / 4)
#define DNI_cos (1000 * COS)
m = 4 * DNI_cos;
#define SQR(x) ((x)*(x))
std = 0;
- CHECK(ssol_estimator_get_mc_global(estimator, &mc_global), RES_OK);
+ CHK(ssol_estimator_get_mc_global(estimator, &mc_global) == RES_OK);
printf("Shadows = %g +/- %g\n", mc_global.shadowed.E, mc_global.shadowed.SE);
printf("Missing = %g +/- %g\n", mc_global.missing.E, mc_global.missing.SE);
printf("Cos = %g +/- %g\n", mc_global.cos_factor.E, mc_global.cos_factor.SE);
- CHECK(eq_eps(mc_global.shadowed.E, 0, 1e-4), 1);
- CHECK(eq_eps(mc_global.missing.E, 4 * DNI_cos, 1e-4), 1); /* nothing absorbed */
- CHECK(eq_eps(mc_global.cos_factor.E, COS, 1e-4), 1);
- CHECK(GET_MC_RCV(estimator, heliostat1, SSOL_BACK, &mc_rcv), RES_BAD_ARG);
- CHECK(GET_MC_RCV(estimator, secondary, SSOL_FRONT, &mc_rcv), RES_OK);
+ CHK(eq_eps(mc_global.shadowed.E, 0, 1e-4) == 1);
+ CHK(eq_eps(mc_global.missing.E, 4 * DNI_cos, 1e-4) == 1); /* nothing absorbed */
+ CHK(eq_eps(mc_global.cos_factor.E, COS, 1e-4) == 1);
+ CHK(GET_MC_RCV(estimator, heliostat1, SSOL_BACK, &mc_rcv) == RES_BAD_ARG);
+ CHK(GET_MC_RCV(estimator, secondary, SSOL_FRONT, &mc_rcv) == RES_OK);
printf("Ir(secondary) = %g +/- %g\n",
mc_rcv.incoming_flux.E, mc_rcv.incoming_flux.SE);
- CHECK(GET_MC_RCV(estimator, target, SSOL_FRONT, &mc_rcv), RES_OK);
+ CHK(GET_MC_RCV(estimator, target, SSOL_FRONT, &mc_rcv) == RES_OK);
printf("Ir(target) = %g +/- %g\n",
mc_rcv.incoming_flux.E, mc_rcv.incoming_flux.SE);
- CHECK(eq_eps(mc_rcv.incoming_flux.E, m, 1e-8), 1);
- CHECK(eq_eps(mc_rcv.incoming_flux.SE, std, 1e-4), 1);
+ CHK(eq_eps(mc_rcv.incoming_flux.E, m, 1e-8) == 1);
+ CHK(eq_eps(mc_rcv.incoming_flux.SE, std, 1e-4) == 1);
/* Free data */
- CHECK(ssol_instance_ref_put(heliostat1), RES_OK);
- CHECK(ssol_instance_ref_put(heliostat2), RES_OK);
- CHECK(ssol_instance_ref_put(secondary), RES_OK);
- CHECK(ssol_instance_ref_put(target), RES_OK);
- CHECK(ssol_object_ref_put(m_object), RES_OK);
- CHECK(ssol_object_ref_put(s_object), RES_OK);
- CHECK(ssol_object_ref_put(t_object), RES_OK);
- CHECK(ssol_shape_ref_put(square), RES_OK);
- CHECK(ssol_shape_ref_put(rect), RES_OK);
- CHECK(ssol_shape_ref_put(quad_square), RES_OK);
- CHECK(ssol_material_ref_put(m_mtl), RES_OK);
- CHECK(ssol_material_ref_put(v_mtl), RES_OK);
- CHECK(ssol_device_ref_put(dev), RES_OK);
- CHECK(ssol_estimator_ref_put(estimator), RES_OK);
- CHECK(ssol_scene_ref_put(scene), RES_OK);
- CHECK(ssp_rng_ref_put(rng), RES_OK);
- CHECK(ssol_spectrum_ref_put(spectrum), RES_OK);
- CHECK(ssol_sun_ref_put(sun), RES_OK);
+ CHK(ssol_instance_ref_put(heliostat1) == RES_OK);
+ CHK(ssol_instance_ref_put(heliostat2) == RES_OK);
+ CHK(ssol_instance_ref_put(secondary) == RES_OK);
+ CHK(ssol_instance_ref_put(target) == RES_OK);
+ CHK(ssol_object_ref_put(m_object) == RES_OK);
+ CHK(ssol_object_ref_put(s_object) == RES_OK);
+ CHK(ssol_object_ref_put(t_object) == RES_OK);
+ CHK(ssol_shape_ref_put(square) == RES_OK);
+ CHK(ssol_shape_ref_put(rect) == RES_OK);
+ CHK(ssol_shape_ref_put(quad_square) == RES_OK);
+ CHK(ssol_material_ref_put(m_mtl) == RES_OK);
+ CHK(ssol_material_ref_put(v_mtl) == RES_OK);
+ CHK(ssol_device_ref_put(dev) == RES_OK);
+ CHK(ssol_estimator_ref_put(estimator) == RES_OK);
+ CHK(ssol_scene_ref_put(scene) == RES_OK);
+ CHK(ssp_rng_ref_put(rng) == RES_OK);
+ CHK(ssol_spectrum_ref_put(spectrum) == RES_OK);
+ CHK(ssol_sun_ref_put(sun) == RES_OK);
check_memory_allocator(&allocator);
mem_shutdown_proxy_allocator(&allocator);
- CHECK(mem_allocated_size(), 0);
+ CHK(mem_allocated_size() == 0);
return 0;
}
diff --git a/src/test_ssol_solver2b.c b/src/test_ssol_solver2b.c
@@ -42,7 +42,7 @@ get_wlen(const size_t i, double* wlen, double* data, void* ctx)
{
double wavelengths[3] = { 1, 2, 3 };
double intensities[3] = { 1, 0.8, 1 };
- CHECK(i < 3, 1);
+ CHK(i < 3);
(void)ctx;
*wlen = wavelengths[i];
*data = intensities[i];
@@ -100,28 +100,28 @@ main(int argc, char** argv)
mem_init_proxy_allocator(&allocator, &mem_default_allocator);
- CHECK(ssol_device_create
- (NULL, &allocator, SSOL_NTHREADS_DEFAULT, 0, &dev), RES_OK);
+ CHK(ssol_device_create
+ (NULL, &allocator, SSOL_NTHREADS_DEFAULT, 0, &dev) == RES_OK);
- CHECK(ssp_rng_create(&allocator, &ssp_rng_threefry, &rng), RES_OK);
- CHECK(ssol_spectrum_create(dev, &spectrum), RES_OK);
- CHECK(ssol_spectrum_setup(spectrum, get_wlen, 3, NULL), RES_OK);
- CHECK(ssol_sun_create_directional(dev, &sun), RES_OK);
- CHECK(ssol_sun_set_direction(sun, d3(dir, 1, 0, -1)), RES_OK);
- CHECK(ssol_sun_set_spectrum(sun, spectrum), RES_OK);
- CHECK(ssol_sun_set_dni(sun, 1000), RES_OK);
- CHECK(ssol_scene_create(dev, &scene), RES_OK);
- CHECK(ssol_scene_attach_sun(scene, sun), RES_OK);
+ CHK(ssp_rng_create(&allocator, &ssp_rng_threefry, &rng) == RES_OK);
+ CHK(ssol_spectrum_create(dev, &spectrum) == RES_OK);
+ CHK(ssol_spectrum_setup(spectrum, get_wlen, 3, NULL) == RES_OK);
+ CHK(ssol_sun_create_directional(dev, &sun) == RES_OK);
+ CHK(ssol_sun_set_direction(sun, d3(dir, 1, 0, -1)) == RES_OK);
+ CHK(ssol_sun_set_spectrum(sun, spectrum) == RES_OK);
+ CHK(ssol_sun_set_dni(sun, 1000) == RES_OK);
+ CHK(ssol_scene_create(dev, &scene) == RES_OK);
+ CHK(ssol_scene_attach_sun(scene, sun) == RES_OK);
/* Create scene content */
- CHECK(ssol_shape_create_mesh(dev, &rect), RES_OK);
+ CHK(ssol_shape_create_mesh(dev, &rect) == RES_OK);
attribs[0].usage = SSOL_POSITION;
attribs[0].get = get_position;
- CHECK(ssol_mesh_setup(rect, RECT_NTRIS__, get_ids,
- RECT_NVERTS__, attribs, 1, (void*) &RECT_DESC__), RES_OK);
+ CHK(ssol_mesh_setup(rect, RECT_NTRIS__, get_ids,
+ RECT_NVERTS__, attribs, 1, (void*) &RECT_DESC__) == RES_OK);
- CHECK(ssol_shape_create_punched_surface(dev, &quad_rect), RES_OK);
+ CHK(ssol_shape_create_punched_surface(dev, &quad_rect) == RES_OK);
carving.get = get_polygon_vertices;
carving.operation = SSOL_AND;
carving.nb_vertices = RECT_POLY_NVERTS__;
@@ -130,9 +130,9 @@ main(int argc, char** argv)
punched.nb_carvings = 1;
punched.quadric = &quadric;
punched.carvings = &carving;
- CHECK(ssol_punched_surface_setup(quad_rect, &punched), RES_OK);
+ CHK(ssol_punched_surface_setup(quad_rect, &punched) == RES_OK);
- CHECK(ssol_shape_create_punched_surface(dev, &quad_square), RES_OK);
+ CHK(ssol_shape_create_punched_surface(dev, &quad_square) == RES_OK);
carving.get = get_polygon_vertices;
carving.operation = SSOL_AND;
carving.nb_vertices = SQUARE_POLY_NVERTS__;
@@ -141,92 +141,92 @@ main(int argc, char** argv)
punched.nb_carvings = 1;
punched.quadric = &quadric;
punched.carvings = &carving;
- CHECK(ssol_punched_surface_setup(quad_square, &punched), RES_OK);
+ CHK(ssol_punched_surface_setup(quad_square, &punched) == RES_OK);
- CHECK(ssol_material_create_mirror(dev, &m_mtl), RES_OK);
+ CHK(ssol_material_create_mirror(dev, &m_mtl) == RES_OK);
shader.normal = get_shader_normal;
shader.reflectivity = get_shader_reflectivity;
shader.roughness = get_shader_roughness;
- 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);
- CHECK(ssol_object_add_shaded_shape(m_object, quad_rect, m_mtl, m_mtl), RES_OK);
- CHECK(ssol_object_instantiate(m_object, &heliostat1), RES_OK);
- CHECK(ssol_object_instantiate(m_object, &heliostat2), RES_OK);
- CHECK(ssol_instance_set_receiver(heliostat1, SSOL_FRONT, 0), RES_OK);
- CHECK(ssol_instance_set_receiver(heliostat2, SSOL_FRONT, 0), RES_OK);
+ CHK(ssol_mirror_setup(m_mtl, &shader, SSOL_MICROFACET_BECKMANN) == RES_OK);
+ CHK(ssol_material_create_virtual(dev, &v_mtl) == RES_OK);
+
+ CHK(ssol_object_create(dev, &m_object) == RES_OK);
+ CHK(ssol_object_add_shaded_shape(m_object, quad_rect, m_mtl, m_mtl) == RES_OK);
+ CHK(ssol_object_instantiate(m_object, &heliostat1) == RES_OK);
+ CHK(ssol_object_instantiate(m_object, &heliostat2) == RES_OK);
+ CHK(ssol_instance_set_receiver(heliostat1, SSOL_FRONT, 0) == RES_OK);
+ CHK(ssol_instance_set_receiver(heliostat2, SSOL_FRONT, 0) == RES_OK);
transform3[9] = -0.5; /* -0.5 offset along X axis */
- CHECK(ssol_instance_set_transform(heliostat1, transform3), RES_OK);
+ CHK(ssol_instance_set_transform(heliostat1, transform3) == RES_OK);
transform3[9] = +0.5; /* +0.5 offset along X axis */
- CHECK(ssol_instance_set_transform(heliostat2, transform3), RES_OK);
- CHECK(ssol_scene_attach_instance(scene, heliostat1), RES_OK);
- CHECK(ssol_scene_attach_instance(scene, heliostat2), RES_OK);
-
- CHECK(ssol_object_create(dev, &s_object), RES_OK);
- CHECK(ssol_object_add_shaded_shape(s_object, quad_square, m_mtl, m_mtl), RES_OK);
- CHECK(ssol_object_instantiate(s_object, &secondary), RES_OK);
- CHECK(ssol_instance_set_receiver(secondary, SSOL_FRONT, 0), RES_OK);
- CHECK(ssol_instance_set_transform(secondary, transform1), RES_OK);
- CHECK(ssol_instance_sample(secondary, 0), RES_OK);
- CHECK(ssol_scene_attach_instance(scene, secondary), RES_OK);
-
- CHECK(ssol_object_create(dev, &t_object), RES_OK);
- CHECK(ssol_object_add_shaded_shape(t_object, rect, v_mtl, v_mtl), RES_OK);
- CHECK(ssol_object_instantiate(t_object, &target), RES_OK);
- CHECK(ssol_instance_set_transform(target, transform2), RES_OK);
- CHECK(ssol_instance_set_receiver(target, SSOL_FRONT, 0), RES_OK);
- CHECK(ssol_instance_sample(target, 0), RES_OK);
- CHECK(ssol_scene_attach_instance(scene, target), RES_OK);
+ CHK(ssol_instance_set_transform(heliostat2, transform3) == RES_OK);
+ CHK(ssol_scene_attach_instance(scene, heliostat1) == RES_OK);
+ CHK(ssol_scene_attach_instance(scene, heliostat2) == RES_OK);
+
+ CHK(ssol_object_create(dev, &s_object) == RES_OK);
+ CHK(ssol_object_add_shaded_shape(s_object, quad_square, m_mtl, m_mtl) == RES_OK);
+ CHK(ssol_object_instantiate(s_object, &secondary) == RES_OK);
+ CHK(ssol_instance_set_receiver(secondary, SSOL_FRONT, 0) == RES_OK);
+ CHK(ssol_instance_set_transform(secondary, transform1) == RES_OK);
+ CHK(ssol_instance_sample(secondary, 0) == RES_OK);
+ CHK(ssol_scene_attach_instance(scene, secondary) == RES_OK);
+
+ CHK(ssol_object_create(dev, &t_object) == RES_OK);
+ CHK(ssol_object_add_shaded_shape(t_object, rect, v_mtl, v_mtl) == RES_OK);
+ CHK(ssol_object_instantiate(t_object, &target) == RES_OK);
+ CHK(ssol_instance_set_transform(target, transform2) == RES_OK);
+ CHK(ssol_instance_set_receiver(target, SSOL_FRONT, 0) == RES_OK);
+ CHK(ssol_instance_sample(target, 0) == RES_OK);
+ CHK(ssol_scene_attach_instance(scene, target) == RES_OK);
#define N__ 50000
- CHECK(ssol_solve(scene, rng, N__, 0, NULL, &estimator), RES_OK);
- CHECK(ssol_estimator_get_realisation_count(estimator, &count), RES_OK);
- CHECK(count, N__);
+ CHK(ssol_solve(scene, rng, N__, 0, NULL, &estimator) == RES_OK);
+ CHK(ssol_estimator_get_realisation_count(estimator, &count) == RES_OK);
+ CHK(count == N__);
#define COS cos(PI / 4)
#define DNI_cos (1000 * COS)
m = 2 * DNI_cos;
#define SQR(x) ((x)*(x))
std = sqrt((SQR(4 * DNI_cos) / 2 - SQR(2 * DNI_cos)) / (double)count);
- CHECK(ssol_estimator_get_mc_global(estimator, &mc_global), RES_OK);
+ CHK(ssol_estimator_get_mc_global(estimator, &mc_global) == RES_OK);
printf("Shadows = %g +/- %g\n", mc_global.shadowed.E, mc_global.shadowed.SE);
printf("Missing = %g +/- %g\n", mc_global.missing.E, mc_global.missing.SE);
printf("Cos = %g +/- %g\n", mc_global.cos_factor.E, mc_global.cos_factor.SE);
- CHECK(eq_eps(mc_global.shadowed.E, 0, 1e-4), 1);
- CHECK(eq_eps(mc_global.missing.E, 4 * DNI_cos, 1e-4), 1); /* nothing absorbed */
- CHECK(eq_eps(mc_global.cos_factor.E, COS, 1e-4), 1);
- CHECK(ssol_estimator_get_mc_receiver
- (estimator, target, SSOL_FRONT, &mc_rcv), RES_OK);
+ CHK(eq_eps(mc_global.shadowed.E, 0, 1e-4) == 1);
+ CHK(eq_eps(mc_global.missing.E, 4 * DNI_cos, 1e-4) == 1); /* nothing absorbed */
+ CHK(eq_eps(mc_global.cos_factor.E, COS, 1e-4) == 1);
+ CHK(ssol_estimator_get_mc_receiver
+ (estimator, target, SSOL_FRONT, &mc_rcv) == RES_OK);
printf("Ir(target) = %g +/- %g\n",
mc_rcv.incoming_flux.E, mc_rcv.incoming_flux.SE);
- CHECK(eq_eps(mc_rcv.incoming_flux.E, m, 2 * std), 1);
- CHECK(eq_eps(mc_rcv.incoming_flux.SE, std, 1e-3), 1);
- CHECK(ssol_estimator_get_failed_count(estimator, &count), RES_OK);
- CHECK(count, 0);
+ CHK(eq_eps(mc_rcv.incoming_flux.E, m, 2 * std) == 1);
+ CHK(eq_eps(mc_rcv.incoming_flux.SE, std, 1e-3) == 1);
+ CHK(ssol_estimator_get_failed_count(estimator, &count) == RES_OK);
+ CHK(count == 0);
/* Free data */
- CHECK(ssol_instance_ref_put(heliostat1), RES_OK);
- CHECK(ssol_instance_ref_put(heliostat2), RES_OK);
- CHECK(ssol_instance_ref_put(secondary), RES_OK);
- CHECK(ssol_instance_ref_put(target), RES_OK);
- CHECK(ssol_object_ref_put(m_object), RES_OK);
- CHECK(ssol_object_ref_put(s_object), RES_OK);
- CHECK(ssol_object_ref_put(t_object), RES_OK);
- CHECK(ssol_shape_ref_put(rect), RES_OK);
- CHECK(ssol_shape_ref_put(quad_rect), RES_OK);
- CHECK(ssol_shape_ref_put(quad_square), RES_OK);
- CHECK(ssol_material_ref_put(m_mtl), RES_OK);
- CHECK(ssol_material_ref_put(v_mtl), RES_OK);
- CHECK(ssol_estimator_ref_put(estimator), RES_OK);
- CHECK(ssol_device_ref_put(dev), RES_OK);
- CHECK(ssol_scene_ref_put(scene), RES_OK);
- CHECK(ssp_rng_ref_put(rng), RES_OK);
- CHECK(ssol_spectrum_ref_put(spectrum), RES_OK);
- CHECK(ssol_sun_ref_put(sun), RES_OK);
+ CHK(ssol_instance_ref_put(heliostat1) == RES_OK);
+ CHK(ssol_instance_ref_put(heliostat2) == RES_OK);
+ CHK(ssol_instance_ref_put(secondary) == RES_OK);
+ CHK(ssol_instance_ref_put(target) == RES_OK);
+ CHK(ssol_object_ref_put(m_object) == RES_OK);
+ CHK(ssol_object_ref_put(s_object) == RES_OK);
+ CHK(ssol_object_ref_put(t_object) == RES_OK);
+ CHK(ssol_shape_ref_put(rect) == RES_OK);
+ CHK(ssol_shape_ref_put(quad_rect) == RES_OK);
+ CHK(ssol_shape_ref_put(quad_square) == RES_OK);
+ CHK(ssol_material_ref_put(m_mtl) == RES_OK);
+ CHK(ssol_material_ref_put(v_mtl) == RES_OK);
+ CHK(ssol_estimator_ref_put(estimator) == RES_OK);
+ CHK(ssol_device_ref_put(dev) == RES_OK);
+ CHK(ssol_scene_ref_put(scene) == RES_OK);
+ CHK(ssp_rng_ref_put(rng) == RES_OK);
+ CHK(ssol_spectrum_ref_put(spectrum) == RES_OK);
+ CHK(ssol_sun_ref_put(sun) == RES_OK);
check_memory_allocator(&allocator);
mem_shutdown_proxy_allocator(&allocator);
- CHECK(mem_allocated_size(), 0);
+ CHK(mem_allocated_size() == 0);
return 0;
}
diff --git a/src/test_ssol_solver3.c b/src/test_ssol_solver3.c
@@ -37,7 +37,7 @@ get_wlen(const size_t i, double* wlen, double* data, void* ctx)
{
double wavelengths[3] = { 1, 2, 3 };
double intensities[3] = { 1, 0.8, 1 };
- CHECK(i < 3, 1);
+ CHK(i < 3);
(void)ctx;
*wlen = wavelengths[i];
*data = intensities[i];
@@ -81,28 +81,28 @@ main(int argc, char** argv)
mem_init_proxy_allocator(&allocator, &mem_default_allocator);
- CHECK(ssol_device_create
- (NULL, &allocator, SSOL_NTHREADS_DEFAULT, 0, &dev), RES_OK);
+ CHK(ssol_device_create
+ (NULL, &allocator, SSOL_NTHREADS_DEFAULT, 0, &dev) == RES_OK);
- CHECK(ssp_rng_create(&allocator, &ssp_rng_threefry, &rng), RES_OK);
- CHECK(ssol_spectrum_create(dev, &spectrum), RES_OK);
- CHECK(ssol_spectrum_setup(spectrum, get_wlen, 3, NULL), RES_OK);
- CHECK(ssol_sun_create_directional(dev, &sun), RES_OK);
- CHECK(ssol_sun_set_direction(sun, d3(dir, 1, 0, -1)), RES_OK);
- CHECK(ssol_sun_set_spectrum(sun, spectrum), RES_OK);
- CHECK(ssol_sun_set_dni(sun, 1000), RES_OK);
- CHECK(ssol_scene_create(dev, &scene), RES_OK);
- CHECK(ssol_scene_attach_sun(scene, sun), RES_OK);
+ CHK(ssp_rng_create(&allocator, &ssp_rng_threefry, &rng) == RES_OK);
+ CHK(ssol_spectrum_create(dev, &spectrum) == RES_OK);
+ CHK(ssol_spectrum_setup(spectrum, get_wlen, 3, NULL) == RES_OK);
+ CHK(ssol_sun_create_directional(dev, &sun) == RES_OK);
+ CHK(ssol_sun_set_direction(sun, d3(dir, 1, 0, -1)) == RES_OK);
+ CHK(ssol_sun_set_spectrum(sun, spectrum) == RES_OK);
+ CHK(ssol_sun_set_dni(sun, 1000) == RES_OK);
+ CHK(ssol_scene_create(dev, &scene) == RES_OK);
+ CHK(ssol_scene_attach_sun(scene, sun) == RES_OK);
/* Create scene content */
- CHECK(ssol_shape_create_mesh(dev, &square), RES_OK);
+ CHK(ssol_shape_create_mesh(dev, &square) == RES_OK);
attribs[0].usage = SSOL_POSITION;
attribs[0].get = get_position;
- CHECK(ssol_mesh_setup(square, SQUARE_NTRIS__, get_ids,
- SQUARE_NVERTS__, attribs, 1, (void*) &SQUARE_DESC__), RES_OK);
+ CHK(ssol_mesh_setup(square, SQUARE_NTRIS__, get_ids,
+ SQUARE_NVERTS__, attribs, 1, (void*) &SQUARE_DESC__) == RES_OK);
- CHECK(ssol_shape_create_punched_surface(dev, &quad_square), RES_OK);
+ CHK(ssol_shape_create_punched_surface(dev, &quad_square) == RES_OK);
carving.get = get_polygon_vertices;
carving.operation = SSOL_AND;
carving.nb_vertices = POLY_NVERTS__;
@@ -111,75 +111,75 @@ main(int argc, char** argv)
punched.nb_carvings = 1;
punched.quadric = &quadric;
punched.carvings = &carving;
- CHECK(ssol_punched_surface_setup(quad_square, &punched), RES_OK);
+ CHK(ssol_punched_surface_setup(quad_square, &punched) == RES_OK);
- CHECK(ssol_material_create_mirror(dev, &m_mtl), RES_OK);
+ CHK(ssol_material_create_mirror(dev, &m_mtl) == RES_OK);
shader.normal = get_shader_normal;
shader.reflectivity = get_shader_reflectivity;
shader.roughness = get_shader_roughness;
- 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);
- CHECK(ssol_object_add_shaded_shape(m_object, quad_square, m_mtl, m_mtl), RES_OK);
- CHECK(ssol_object_instantiate(m_object, &heliostat), RES_OK);
- CHECK(ssol_instance_set_receiver(heliostat, SSOL_FRONT, 0), RES_OK);
- CHECK(ssol_scene_attach_instance(scene, heliostat), RES_OK);
-
- CHECK(ssol_object_create(dev, &t_object), RES_OK);
- CHECK(ssol_object_add_shaded_shape(t_object, square, v_mtl, v_mtl), RES_OK);
- CHECK(ssol_object_instantiate(t_object, &target), RES_OK);
- CHECK(ssol_instance_set_transform(target, transform), RES_OK);
- CHECK(ssol_instance_set_receiver(target, SSOL_FRONT, 0), RES_OK);
- CHECK(ssol_instance_sample(target, 0), RES_OK);
- CHECK(ssol_scene_attach_instance(scene, target), RES_OK);
+ CHK(ssol_mirror_setup(m_mtl, &shader, SSOL_MICROFACET_BECKMANN) == RES_OK);
+ CHK(ssol_material_create_virtual(dev, &v_mtl) == RES_OK);
+
+ CHK(ssol_object_create(dev, &m_object) == RES_OK);
+ CHK(ssol_object_add_shaded_shape(m_object, quad_square, m_mtl, m_mtl) == RES_OK);
+ CHK(ssol_object_instantiate(m_object, &heliostat) == RES_OK);
+ CHK(ssol_instance_set_receiver(heliostat, SSOL_FRONT, 0) == RES_OK);
+ CHK(ssol_scene_attach_instance(scene, heliostat) == RES_OK);
+
+ CHK(ssol_object_create(dev, &t_object) == RES_OK);
+ CHK(ssol_object_add_shaded_shape(t_object, square, v_mtl, v_mtl) == RES_OK);
+ CHK(ssol_object_instantiate(t_object, &target) == RES_OK);
+ CHK(ssol_instance_set_transform(target, transform) == RES_OK);
+ CHK(ssol_instance_set_receiver(target, SSOL_FRONT, 0) == RES_OK);
+ CHK(ssol_instance_sample(target, 0) == RES_OK);
+ CHK(ssol_scene_attach_instance(scene, target) == RES_OK);
#define N__ 20000
- CHECK(ssol_solve(scene, rng, N__, 0, NULL, &estimator), RES_OK);
- CHECK(ssol_estimator_get_realisation_count(estimator, &count), RES_OK);
- CHECK(count, N__);
+ CHK(ssol_solve(scene, rng, N__, 0, NULL, &estimator) == RES_OK);
+ CHK(ssol_estimator_get_realisation_count(estimator, &count) == RES_OK);
+ CHK(count == N__);
#define COS cos(PI / 4)
#define DNI_cos (1000 * COS)
m = 4 * DNI_cos;
#define SQR(x) ((x)*(x))
std = sqrt((SQR(400*DNI_cos) / 100 - SQR(4*DNI_cos)) / (double)count);
- CHECK(ssol_estimator_get_mc_global(estimator, &mc_global), RES_OK);
+ CHK(ssol_estimator_get_mc_global(estimator, &mc_global) == RES_OK);
printf("Shadows = %g +/- %g\n", mc_global.shadowed.E, mc_global.shadowed.SE);
printf("Missing = %g +/- %g\n", mc_global.missing.E, mc_global.missing.SE);
printf("Cos = %g +/- %g\n", mc_global.cos_factor.E, mc_global.cos_factor.SE);
- CHECK(eq_eps(mc_global.shadowed.E, 0, 1e-4), 1);
- CHECK(eq_eps(mc_global.missing.E, 400 * DNI_cos, 1e-4), 1); /* nothing absorbed */
- CHECK(eq_eps(mc_global.cos_factor.E, COS, 1e-4), 1);
- CHECK(ssol_estimator_get_mc_receiver
- (estimator, target, SSOL_FRONT, &mc_rcv), RES_OK);
+ CHK(eq_eps(mc_global.shadowed.E, 0, 1e-4) == 1);
+ CHK(eq_eps(mc_global.missing.E, 400 * DNI_cos, 1e-4) == 1); /* nothing absorbed */
+ CHK(eq_eps(mc_global.cos_factor.E, COS, 1e-4) == 1);
+ CHK(ssol_estimator_get_mc_receiver
+ (estimator, target, SSOL_FRONT, &mc_rcv) == RES_OK);
printf("Ir(target) = %g +/- %g\n",
mc_rcv.incoming_flux.E, mc_rcv.incoming_flux.SE);
- CHECK(eq_eps(mc_rcv.incoming_flux.E, m, 2 * std), 1);
- CHECK(eq_eps(mc_rcv.incoming_flux.SE, std, 10), 1);
- CHECK(ssol_estimator_get_failed_count(estimator, &count), RES_OK);
- CHECK(count, 0);
- CHECK(ssol_instance_get_area(heliostat, &area), RES_OK);
- CHECK(eq_eps(area, 400, DBL_EPSILON), 1);
+ CHK(eq_eps(mc_rcv.incoming_flux.E, m, 2 * std) == 1);
+ CHK(eq_eps(mc_rcv.incoming_flux.SE, std, 10) == 1);
+ CHK(ssol_estimator_get_failed_count(estimator, &count) == RES_OK);
+ CHK(count == 0);
+ CHK(ssol_instance_get_area(heliostat, &area) == RES_OK);
+ CHK(eq_eps(area, 400, DBL_EPSILON) == 1);
/* Free data */
- CHECK(ssol_instance_ref_put(heliostat), RES_OK);
- CHECK(ssol_instance_ref_put(target), RES_OK);
- CHECK(ssol_object_ref_put(m_object), RES_OK);
- CHECK(ssol_object_ref_put(t_object), RES_OK);
- CHECK(ssol_shape_ref_put(square), RES_OK);
- CHECK(ssol_shape_ref_put(quad_square), RES_OK);
- CHECK(ssol_material_ref_put(m_mtl), RES_OK);
- CHECK(ssol_material_ref_put(v_mtl), RES_OK);
- CHECK(ssol_device_ref_put(dev), RES_OK);
- CHECK(ssol_estimator_ref_put(estimator), RES_OK);
- CHECK(ssol_scene_ref_put(scene), RES_OK);
- CHECK(ssp_rng_ref_put(rng), RES_OK);
- CHECK(ssol_spectrum_ref_put(spectrum), RES_OK);
- CHECK(ssol_sun_ref_put(sun), RES_OK);
+ CHK(ssol_instance_ref_put(heliostat) == RES_OK);
+ CHK(ssol_instance_ref_put(target) == RES_OK);
+ CHK(ssol_object_ref_put(m_object) == RES_OK);
+ CHK(ssol_object_ref_put(t_object) == RES_OK);
+ CHK(ssol_shape_ref_put(square) == RES_OK);
+ CHK(ssol_shape_ref_put(quad_square) == RES_OK);
+ CHK(ssol_material_ref_put(m_mtl) == RES_OK);
+ CHK(ssol_material_ref_put(v_mtl) == RES_OK);
+ CHK(ssol_device_ref_put(dev) == RES_OK);
+ CHK(ssol_estimator_ref_put(estimator) == RES_OK);
+ CHK(ssol_scene_ref_put(scene) == RES_OK);
+ CHK(ssp_rng_ref_put(rng) == RES_OK);
+ CHK(ssol_spectrum_ref_put(spectrum) == RES_OK);
+ CHK(ssol_sun_ref_put(sun) == RES_OK);
check_memory_allocator(&allocator);
mem_shutdown_proxy_allocator(&allocator);
- CHECK(mem_allocated_size(), 0);
+ CHK(mem_allocated_size() == 0);
return 0;
}
diff --git a/src/test_ssol_solver4.c b/src/test_ssol_solver4.c
@@ -37,7 +37,7 @@ get_wlen(const size_t i, double* wlen, double* data, void* ctx)
{
double wavelengths[3] = { 1, 2, 3 };
double intensities[3] = { 1, 0.8, 1 };
- CHECK(i < 3, 1);
+ CHK(i < 3);
(void)ctx;
*wlen = wavelengths[i];
*data = intensities[i];
@@ -82,28 +82,28 @@ main(int argc, char** argv)
mem_init_proxy_allocator(&allocator, &mem_default_allocator);
- CHECK(ssol_device_create
- (NULL, &allocator, SSOL_NTHREADS_DEFAULT, 0, &dev), RES_OK);
+ CHK(ssol_device_create
+ (NULL, &allocator, SSOL_NTHREADS_DEFAULT, 0, &dev) == RES_OK);
- CHECK(ssp_rng_create(&allocator, &ssp_rng_threefry, &rng), RES_OK);
- CHECK(ssol_spectrum_create(dev, &spectrum), RES_OK);
- CHECK(ssol_spectrum_setup(spectrum, get_wlen, 3, NULL), RES_OK);
- CHECK(ssol_sun_create_directional(dev, &sun), RES_OK);
- CHECK(ssol_sun_set_direction(sun, d3(dir, 0, 0, -1)), RES_OK);
- CHECK(ssol_sun_set_spectrum(sun, spectrum), RES_OK);
- CHECK(ssol_sun_set_dni(sun, 1000), RES_OK);
- CHECK(ssol_scene_create(dev, &scene), RES_OK);
- CHECK(ssol_scene_attach_sun(scene, sun), RES_OK);
+ CHK(ssp_rng_create(&allocator, &ssp_rng_threefry, &rng) == RES_OK);
+ CHK(ssol_spectrum_create(dev, &spectrum) == RES_OK);
+ CHK(ssol_spectrum_setup(spectrum, get_wlen, 3, NULL) == RES_OK);
+ CHK(ssol_sun_create_directional(dev, &sun) == RES_OK);
+ CHK(ssol_sun_set_direction(sun, d3(dir, 0, 0, -1)) == RES_OK);
+ CHK(ssol_sun_set_spectrum(sun, spectrum) == RES_OK);
+ CHK(ssol_sun_set_dni(sun, 1000) == RES_OK);
+ CHK(ssol_scene_create(dev, &scene) == RES_OK);
+ CHK(ssol_scene_attach_sun(scene, sun) == RES_OK);
/* Create scene content */
- CHECK(ssol_shape_create_mesh(dev, &square), RES_OK);
+ CHK(ssol_shape_create_mesh(dev, &square) == RES_OK);
attribs[0].usage = SSOL_POSITION;
attribs[0].get = get_position;
- CHECK(ssol_mesh_setup(square, SQUARE_NTRIS__, get_ids,
- SQUARE_NVERTS__, attribs, 1, (void*) &SQUARE_DESC__), RES_OK);
+ CHK(ssol_mesh_setup(square, SQUARE_NTRIS__, get_ids,
+ SQUARE_NVERTS__, attribs, 1, (void*) &SQUARE_DESC__) == RES_OK);
- CHECK(ssol_shape_create_punched_surface(dev, &quad_square), RES_OK);
+ CHK(ssol_shape_create_punched_surface(dev, &quad_square) == RES_OK);
carving.get = get_polygon_vertices;
carving.operation = SSOL_AND;
carving.nb_vertices = POLY_NVERTS__;
@@ -114,82 +114,82 @@ main(int argc, char** argv)
punched.nb_carvings = 1;
punched.quadric = &quadric;
punched.carvings = &carving;
- CHECK(ssol_punched_surface_setup(quad_square, &punched), RES_OK);
+ CHK(ssol_punched_surface_setup(quad_square, &punched) == RES_OK);
- CHECK(ssol_material_create_mirror(dev, &m_mtl), RES_OK);
+ CHK(ssol_material_create_mirror(dev, &m_mtl) == RES_OK);
shader.normal = get_shader_normal;
shader.reflectivity = get_shader_reflectivity;
shader.roughness = get_shader_roughness;
- 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);
- CHECK(ssol_object_add_shaded_shape(m_object, quad_square, m_mtl, m_mtl), RES_OK);
- CHECK(ssol_object_instantiate(m_object, &heliostat), RES_OK);
- CHECK(ssol_scene_attach_instance(scene, heliostat), RES_OK);
-
- CHECK(ssol_object_create(dev, &t_object), RES_OK);
- CHECK(ssol_object_add_shaded_shape(t_object, square, v_mtl, v_mtl), RES_OK);
- CHECK(ssol_object_instantiate(t_object, &target1), RES_OK);
- CHECK(ssol_instance_set_transform(target1, transform), RES_OK);
- CHECK(ssol_instance_set_receiver(target1, SSOL_FRONT, 0), RES_OK);
- CHECK(ssol_instance_sample(target1, 0), RES_OK);
- CHECK(ssol_scene_attach_instance(scene, target1), RES_OK);
- CHECK(ssol_object_instantiate(t_object, &target2), RES_OK);
+ CHK(ssol_mirror_setup(m_mtl, &shader, SSOL_MICROFACET_BECKMANN) == RES_OK);
+ CHK(ssol_material_create_virtual(dev, &v_mtl) == RES_OK);
+
+ CHK(ssol_object_create(dev, &m_object) == RES_OK);
+ CHK(ssol_object_add_shaded_shape(m_object, quad_square, m_mtl, m_mtl) == RES_OK);
+ CHK(ssol_object_instantiate(m_object, &heliostat) == RES_OK);
+ CHK(ssol_scene_attach_instance(scene, heliostat) == RES_OK);
+
+ CHK(ssol_object_create(dev, &t_object) == RES_OK);
+ CHK(ssol_object_add_shaded_shape(t_object, square, v_mtl, v_mtl) == RES_OK);
+ CHK(ssol_object_instantiate(t_object, &target1) == RES_OK);
+ CHK(ssol_instance_set_transform(target1, transform) == RES_OK);
+ CHK(ssol_instance_set_receiver(target1, SSOL_FRONT, 0) == RES_OK);
+ CHK(ssol_instance_sample(target1, 0) == RES_OK);
+ CHK(ssol_scene_attach_instance(scene, target1) == RES_OK);
+ CHK(ssol_object_instantiate(t_object, &target2) == RES_OK);
transform[11] += 1.e-4;
- CHECK(ssol_instance_set_transform(target2, transform), RES_OK);
- CHECK(ssol_instance_set_receiver(target2, SSOL_FRONT, 0), RES_OK);
- CHECK(ssol_instance_sample(target2, 0), RES_OK);
- CHECK(ssol_scene_attach_instance(scene, target2), RES_OK);
+ CHK(ssol_instance_set_transform(target2, transform) == RES_OK);
+ CHK(ssol_instance_set_receiver(target2, SSOL_FRONT, 0) == RES_OK);
+ CHK(ssol_instance_sample(target2, 0) == RES_OK);
+ CHK(ssol_scene_attach_instance(scene, target2) == RES_OK);
#define N__ 100000
#define GET_MC_RCV ssol_estimator_get_mc_receiver
- CHECK(ssol_solve(scene, rng, N__, 0, NULL, &estimator), RES_OK);
- CHECK(ssol_estimator_get_realisation_count(estimator, &count), RES_OK);
- CHECK(count, N__);
+ CHK(ssol_solve(scene, rng, N__, 0, NULL, &estimator) == RES_OK);
+ CHK(ssol_estimator_get_realisation_count(estimator, &count) == RES_OK);
+ CHK(count == N__);
#define COS cos(0)
#define DNI_cos (1000 * COS)
m1 = 400 * DNI_cos;
std1 = 0;
m2 = m1;
std2 = std1;
- CHECK(ssol_estimator_get_mc_global(estimator, &mc_global), RES_OK);
+ CHK(ssol_estimator_get_mc_global(estimator, &mc_global) == RES_OK);
PRINT_GLOBAL(mc_global);
- CHECK(eq_eps(mc_global.shadowed.E, 0, 1e-4), 1);
- CHECK(eq_eps(mc_global.missing.E, 400 * DNI_cos, 1e-2), 1); /* virtual => 100 % missing */
- CHECK(GET_MC_RCV(estimator, target1, SSOL_FRONT, &mc_rcv), RES_OK);
+ CHK(eq_eps(mc_global.shadowed.E, 0, 1e-4) == 1);
+ CHK(eq_eps(mc_global.missing.E, 400 * DNI_cos, 1e-2) == 1); /* virtual => 100 % missing */
+ CHK(GET_MC_RCV(estimator, target1, SSOL_FRONT, &mc_rcv) == RES_OK);
printf("Ir(target1) = %g +/- %g\n",
mc_rcv.incoming_flux.E, mc_rcv.incoming_flux.SE);
- CHECK(eq_eps(mc_rcv.incoming_flux.E, m1, 1e-2), 1);
- CHECK(eq_eps(mc_rcv.incoming_flux.SE, std1, 1e-2), 1);
- CHECK(GET_MC_RCV(estimator, target2, SSOL_FRONT, &mc_rcv), RES_OK);
+ CHK(eq_eps(mc_rcv.incoming_flux.E, m1, 1e-2) == 1);
+ CHK(eq_eps(mc_rcv.incoming_flux.SE, std1, 1e-2) == 1);
+ CHK(GET_MC_RCV(estimator, target2, SSOL_FRONT, &mc_rcv) == RES_OK);
printf("Ir(target2) = %g +/- %g\n",
mc_rcv.incoming_flux.E, mc_rcv.incoming_flux.SE);
- CHECK(eq_eps(mc_rcv.incoming_flux.E, m2, 1e-2), 1);
- CHECK(eq_eps(mc_rcv.incoming_flux.SE, std2, 1e-2), 1);
- CHECK(ssol_estimator_get_failed_count(estimator, &count), RES_OK);
- CHECK(count, 0);
+ CHK(eq_eps(mc_rcv.incoming_flux.E, m2, 1e-2) == 1);
+ CHK(eq_eps(mc_rcv.incoming_flux.SE, std2, 1e-2) == 1);
+ CHK(ssol_estimator_get_failed_count(estimator, &count) == RES_OK);
+ CHK(count == 0);
/* Free data */
- CHECK(ssol_instance_ref_put(heliostat), RES_OK);
- CHECK(ssol_instance_ref_put(target1), RES_OK);
- CHECK(ssol_instance_ref_put(target2), RES_OK);
- CHECK(ssol_object_ref_put(m_object), RES_OK);
- CHECK(ssol_object_ref_put(t_object), RES_OK);
- CHECK(ssol_shape_ref_put(square), RES_OK);
- CHECK(ssol_shape_ref_put(quad_square), RES_OK);
- CHECK(ssol_material_ref_put(m_mtl), RES_OK);
- CHECK(ssol_material_ref_put(v_mtl), RES_OK);
- CHECK(ssol_estimator_ref_put(estimator), RES_OK);
- CHECK(ssol_device_ref_put(dev), RES_OK);
- CHECK(ssol_scene_ref_put(scene), RES_OK);
- CHECK(ssp_rng_ref_put(rng), RES_OK);
- CHECK(ssol_spectrum_ref_put(spectrum), RES_OK);
- CHECK(ssol_sun_ref_put(sun), RES_OK);
+ CHK(ssol_instance_ref_put(heliostat) == RES_OK);
+ CHK(ssol_instance_ref_put(target1) == RES_OK);
+ CHK(ssol_instance_ref_put(target2) == RES_OK);
+ CHK(ssol_object_ref_put(m_object) == RES_OK);
+ CHK(ssol_object_ref_put(t_object) == RES_OK);
+ CHK(ssol_shape_ref_put(square) == RES_OK);
+ CHK(ssol_shape_ref_put(quad_square) == RES_OK);
+ CHK(ssol_material_ref_put(m_mtl) == RES_OK);
+ CHK(ssol_material_ref_put(v_mtl) == RES_OK);
+ CHK(ssol_estimator_ref_put(estimator) == RES_OK);
+ CHK(ssol_device_ref_put(dev) == RES_OK);
+ CHK(ssol_scene_ref_put(scene) == RES_OK);
+ CHK(ssp_rng_ref_put(rng) == RES_OK);
+ CHK(ssol_spectrum_ref_put(spectrum) == RES_OK);
+ CHK(ssol_sun_ref_put(sun) == RES_OK);
check_memory_allocator(&allocator);
mem_shutdown_proxy_allocator(&allocator);
- CHECK(mem_allocated_size(), 0);
+ CHK(mem_allocated_size() == 0);
return 0;
}
diff --git a/src/test_ssol_solver5.c b/src/test_ssol_solver5.c
@@ -37,7 +37,7 @@ get_wlen(const size_t i, double* wlen, double* data, void* ctx)
{
double wavelengths[3] = { 1, 2, 3 };
double intensities[3] = { 1, 0.8, 1 };
- CHECK(i < 3, 1);
+ CHK(i < 3);
(void)ctx;
*wlen = wavelengths[i];
*data = intensities[i];
@@ -81,28 +81,28 @@ main(int argc, char** argv)
mem_init_proxy_allocator(&allocator, &mem_default_allocator);
- CHECK(ssol_device_create
- (NULL, &allocator, SSOL_NTHREADS_DEFAULT, 0, &dev), RES_OK);
+ CHK(ssol_device_create
+ (NULL, &allocator, SSOL_NTHREADS_DEFAULT, 0, &dev) == RES_OK);
- CHECK(ssp_rng_create(&allocator, &ssp_rng_threefry, &rng), RES_OK);
- CHECK(ssol_spectrum_create(dev, &spectrum), RES_OK);
- CHECK(ssol_spectrum_setup(spectrum, get_wlen, 3, NULL), RES_OK);
- CHECK(ssol_sun_create_directional(dev, &sun), RES_OK);
- CHECK(ssol_sun_set_direction(sun, d3(dir, 0, 0, -1)), RES_OK);
- CHECK(ssol_sun_set_spectrum(sun, spectrum), RES_OK);
- CHECK(ssol_sun_set_dni(sun, 1000), RES_OK);
- CHECK(ssol_scene_create(dev, &scene), RES_OK);
- CHECK(ssol_scene_attach_sun(scene, sun), RES_OK);
+ CHK(ssp_rng_create(&allocator, &ssp_rng_threefry, &rng) == RES_OK);
+ CHK(ssol_spectrum_create(dev, &spectrum) == RES_OK);
+ CHK(ssol_spectrum_setup(spectrum, get_wlen, 3, NULL) == RES_OK);
+ CHK(ssol_sun_create_directional(dev, &sun) == RES_OK);
+ CHK(ssol_sun_set_direction(sun, d3(dir, 0, 0, -1)) == RES_OK);
+ CHK(ssol_sun_set_spectrum(sun, spectrum) == RES_OK);
+ CHK(ssol_sun_set_dni(sun, 1000) == RES_OK);
+ CHK(ssol_scene_create(dev, &scene) == RES_OK);
+ CHK(ssol_scene_attach_sun(scene, sun) == RES_OK);
/* Create scene content */
- CHECK(ssol_shape_create_mesh(dev, &rect), RES_OK);
+ CHK(ssol_shape_create_mesh(dev, &rect) == RES_OK);
attribs[0].usage = SSOL_POSITION;
attribs[0].get = get_position;
- CHECK(ssol_mesh_setup(rect, RECT_NTRIS__, get_ids,
- RECT_NVERTS__, attribs, 1, (void*) &RECT_DESC__), RES_OK);
+ CHK(ssol_mesh_setup(rect, RECT_NTRIS__, get_ids,
+ RECT_NVERTS__, attribs, 1, (void*) &RECT_DESC__) == RES_OK);
- CHECK(ssol_shape_create_punched_surface(dev, &quad_square), RES_OK);
+ CHK(ssol_shape_create_punched_surface(dev, &quad_square) == RES_OK);
carving.get = get_polygon_vertices;
carving.operation = SSOL_AND;
carving.nb_vertices = POLY_NVERTS__;
@@ -112,70 +112,70 @@ main(int argc, char** argv)
punched.nb_carvings = 1;
punched.quadric = &quadric;
punched.carvings = &carving;
- CHECK(ssol_punched_surface_setup(quad_square, &punched), RES_OK);
+ CHK(ssol_punched_surface_setup(quad_square, &punched) == RES_OK);
- CHECK(ssol_material_create_mirror(dev, &m_mtl), RES_OK);
+ CHK(ssol_material_create_mirror(dev, &m_mtl) == RES_OK);
shader.normal = get_shader_normal;
shader.reflectivity = get_shader_reflectivity;
shader.roughness = get_shader_roughness;
- 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);
- CHECK(ssol_object_add_shaded_shape(m_object, quad_square, m_mtl, m_mtl), RES_OK);
- CHECK(ssol_object_instantiate(m_object, &heliostat), RES_OK);
- CHECK(ssol_scene_attach_instance(scene, heliostat), RES_OK);
-
- CHECK(ssol_object_create(dev, &t_object), RES_OK);
- CHECK(ssol_object_add_shaded_shape(t_object, rect, v_mtl, v_mtl), RES_OK);
- CHECK(ssol_object_instantiate(t_object, &target), RES_OK);
- CHECK(ssol_instance_set_transform(target, transform), RES_OK);
- CHECK(ssol_instance_set_receiver(target, SSOL_FRONT, 0), RES_OK);
- CHECK(ssol_instance_sample(target, 0), RES_OK);
- CHECK(ssol_scene_attach_instance(scene, target), RES_OK);
+ CHK(ssol_mirror_setup(m_mtl, &shader, SSOL_MICROFACET_BECKMANN) == RES_OK);
+ CHK(ssol_material_create_virtual(dev, &v_mtl) == RES_OK);
+
+ CHK(ssol_object_create(dev, &m_object) == RES_OK);
+ CHK(ssol_object_add_shaded_shape(m_object, quad_square, m_mtl, m_mtl) == RES_OK);
+ CHK(ssol_object_instantiate(m_object, &heliostat) == RES_OK);
+ CHK(ssol_scene_attach_instance(scene, heliostat) == RES_OK);
+
+ CHK(ssol_object_create(dev, &t_object) == RES_OK);
+ CHK(ssol_object_add_shaded_shape(t_object, rect, v_mtl, v_mtl) == RES_OK);
+ CHK(ssol_object_instantiate(t_object, &target) == RES_OK);
+ CHK(ssol_instance_set_transform(target, transform) == RES_OK);
+ CHK(ssol_instance_set_receiver(target, SSOL_FRONT, 0) == RES_OK);
+ CHK(ssol_instance_sample(target, 0) == RES_OK);
+ CHK(ssol_scene_attach_instance(scene, target) == RES_OK);
#define N__ 10000
- CHECK(ssol_solve(scene, rng, N__, 0, NULL, &estimator), RES_OK);
- CHECK(ssol_estimator_get_realisation_count(estimator, &count), RES_OK);
- CHECK(count, N__);
+ CHK(ssol_solve(scene, rng, N__, 0, NULL, &estimator) == RES_OK);
+ CHK(ssol_estimator_get_realisation_count(estimator, &count) == RES_OK);
+ CHK(count == N__);
#define COS cos(0)
#define DNI_cos (1000 * COS)
m = 400 * DNI_cos;
std = 0;
- CHECK(ssol_estimator_get_mc_global(estimator, &mc_global), RES_OK);
+ CHK(ssol_estimator_get_mc_global(estimator, &mc_global) == RES_OK);
printf("Shadows = %g +/- %g\n", mc_global.shadowed.E, mc_global.shadowed.SE);
printf("Missing = %g +/- %g\n", mc_global.missing.E, mc_global.missing.SE);
printf("Cos = %g +/- %g\n", mc_global.cos_factor.E, mc_global.cos_factor.SE);
- CHECK(eq_eps(mc_global.shadowed.E, 0, 1e-4), 1);
- CHECK(eq_eps(mc_global.missing.E, 400 * DNI_cos, 1e-4), 1); /* nothing absorbed */
- CHECK(ssol_estimator_get_mc_receiver
- (estimator, target, SSOL_FRONT, &mc_rcv), RES_OK);
+ CHK(eq_eps(mc_global.shadowed.E, 0, 1e-4) == 1);
+ CHK(eq_eps(mc_global.missing.E, 400 * DNI_cos, 1e-4) == 1); /* nothing absorbed */
+ CHK(ssol_estimator_get_mc_receiver
+ (estimator, target, SSOL_FRONT, &mc_rcv) == RES_OK);
printf("Ir(target) = %g +/- %g\n",
mc_rcv.incoming_flux.E, mc_rcv.incoming_flux.SE);
- CHECK(eq_eps(mc_rcv.incoming_flux.E, m, 1e-8), 1);
- CHECK(eq_eps(mc_rcv.incoming_flux.SE, std, 1e-4), 1);
- CHECK(ssol_estimator_get_failed_count(estimator, &count), RES_OK);
- CHECK(count, 0);
+ CHK(eq_eps(mc_rcv.incoming_flux.E, m, 1e-8) == 1);
+ CHK(eq_eps(mc_rcv.incoming_flux.SE, std, 1e-4) == 1);
+ CHK(ssol_estimator_get_failed_count(estimator, &count) == RES_OK);
+ CHK(count == 0);
/* Free data */
- CHECK(ssol_instance_ref_put(heliostat), RES_OK);
- CHECK(ssol_instance_ref_put(target), RES_OK);
- CHECK(ssol_object_ref_put(m_object), RES_OK);
- CHECK(ssol_object_ref_put(t_object), RES_OK);
- CHECK(ssol_shape_ref_put(rect), RES_OK);
- CHECK(ssol_shape_ref_put(quad_square), RES_OK);
- CHECK(ssol_estimator_ref_put(estimator), RES_OK);
- CHECK(ssol_material_ref_put(m_mtl), RES_OK);
- CHECK(ssol_material_ref_put(v_mtl), RES_OK);
- CHECK(ssol_device_ref_put(dev), RES_OK);
- CHECK(ssol_scene_ref_put(scene), RES_OK);
- CHECK(ssp_rng_ref_put(rng), RES_OK);
- CHECK(ssol_spectrum_ref_put(spectrum), RES_OK);
- CHECK(ssol_sun_ref_put(sun), RES_OK);
+ CHK(ssol_instance_ref_put(heliostat) == RES_OK);
+ CHK(ssol_instance_ref_put(target) == RES_OK);
+ CHK(ssol_object_ref_put(m_object) == RES_OK);
+ CHK(ssol_object_ref_put(t_object) == RES_OK);
+ CHK(ssol_shape_ref_put(rect) == RES_OK);
+ CHK(ssol_shape_ref_put(quad_square) == RES_OK);
+ CHK(ssol_estimator_ref_put(estimator) == RES_OK);
+ CHK(ssol_material_ref_put(m_mtl) == RES_OK);
+ CHK(ssol_material_ref_put(v_mtl) == RES_OK);
+ CHK(ssol_device_ref_put(dev) == RES_OK);
+ CHK(ssol_scene_ref_put(scene) == RES_OK);
+ CHK(ssp_rng_ref_put(rng) == RES_OK);
+ CHK(ssol_spectrum_ref_put(spectrum) == RES_OK);
+ CHK(ssol_sun_ref_put(sun) == RES_OK);
check_memory_allocator(&allocator);
mem_shutdown_proxy_allocator(&allocator);
- CHECK(mem_allocated_size(), 0);
+ CHK(mem_allocated_size() == 0);
return 0;
}
diff --git a/src/test_ssol_solver6.c b/src/test_ssol_solver6.c
@@ -39,7 +39,7 @@ get_wlen(const size_t i, double* wlen, double* data, void* ctx)
{
double wavelengths[3] = { 1, 2, 3 };
double intensities[3] = { 1, 0.8, 1 };
- CHECK(i < 3, 1);
+ CHK(i < 3);
(void)ctx;
*wlen = wavelengths[i];
*data = intensities[i];
@@ -83,28 +83,28 @@ main(int argc, char** argv)
mem_init_proxy_allocator(&allocator, &mem_default_allocator);
- CHECK(ssol_device_create
- (NULL, &allocator, SSOL_NTHREADS_DEFAULT, 0, &dev), RES_OK);
+ CHK(ssol_device_create
+ (NULL, &allocator, SSOL_NTHREADS_DEFAULT, 0, &dev) == RES_OK);
- CHECK(ssp_rng_create(&allocator, &ssp_rng_threefry, &rng), RES_OK);
- CHECK(ssol_spectrum_create(dev, &spectrum), RES_OK);
- CHECK(ssol_spectrum_setup(spectrum, get_wlen, 3, NULL), RES_OK);
- CHECK(ssol_sun_create_directional(dev, &sun), RES_OK);
- CHECK(ssol_sun_set_direction(sun, d3(dir, 0, 0, -1)), RES_OK);
- CHECK(ssol_sun_set_spectrum(sun, spectrum), RES_OK);
- CHECK(ssol_sun_set_dni(sun, 1000), RES_OK);
- CHECK(ssol_scene_create(dev, &scene), RES_OK);
- CHECK(ssol_scene_attach_sun(scene, sun), RES_OK);
+ CHK(ssp_rng_create(&allocator, &ssp_rng_threefry, &rng) == RES_OK);
+ CHK(ssol_spectrum_create(dev, &spectrum) == RES_OK);
+ CHK(ssol_spectrum_setup(spectrum, get_wlen, 3, NULL) == RES_OK);
+ CHK(ssol_sun_create_directional(dev, &sun) == RES_OK);
+ CHK(ssol_sun_set_direction(sun, d3(dir, 0, 0, -1)) == RES_OK);
+ CHK(ssol_sun_set_spectrum(sun, spectrum) == RES_OK);
+ CHK(ssol_sun_set_dni(sun, 1000) == RES_OK);
+ CHK(ssol_scene_create(dev, &scene) == RES_OK);
+ CHK(ssol_scene_attach_sun(scene, sun) == RES_OK);
/* Create scene content */
- CHECK(ssol_shape_create_mesh(dev, &square), RES_OK);
+ CHK(ssol_shape_create_mesh(dev, &square) == RES_OK);
attribs[0].usage = SSOL_POSITION;
attribs[0].get = get_position;
- CHECK(ssol_mesh_setup(square, SQUARE_NTRIS__, get_ids,
- SQUARE_NVERTS__, attribs, 1, (void*) &SQUARE_DESC__), RES_OK);
+ CHK(ssol_mesh_setup(square, SQUARE_NTRIS__, get_ids,
+ SQUARE_NVERTS__, attribs, 1, (void*) &SQUARE_DESC__) == RES_OK);
- CHECK(ssol_shape_create_punched_surface(dev, &quad_square), RES_OK);
+ CHK(ssol_shape_create_punched_surface(dev, &quad_square) == RES_OK);
carving.get = get_polygon_vertices;
carving.operation = SSOL_AND;
carving.nb_vertices = POLY_NVERTS__;
@@ -113,111 +113,111 @@ main(int argc, char** argv)
punched.nb_carvings = 1;
punched.quadric = &quadric;
punched.carvings = &carving;
- CHECK(ssol_punched_surface_setup(quad_square, &punched), RES_OK);
+ CHK(ssol_punched_surface_setup(quad_square, &punched) == RES_OK);
- CHECK(ssol_material_create_mirror(dev, &m_mtl), RES_OK);
+ CHK(ssol_material_create_mirror(dev, &m_mtl) == RES_OK);
m_shader.normal = get_shader_normal;
m_shader.reflectivity = get_shader_reflectivity;
m_shader.roughness = get_shader_roughness;
- CHECK(ssol_mirror_setup(m_mtl, &m_shader), RES_OK);
- CHECK(ssol_material_create_matte(dev, &bck_mtl), RES_OK);
+ CHK(ssol_mirror_setup(m_mtl, &m_shader, SSOL_MICROFACET_BECKMANN) == RES_OK);
+ CHK(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_setup(bck_mtl, &bck_shader), RES_OK);
- CHECK(ssol_material_create_virtual(dev, &v_mtl), RES_OK);
+ CHK(ssol_matte_setup(bck_mtl, &bck_shader) == RES_OK);
+ CHK(ssol_material_create_virtual(dev, &v_mtl) == RES_OK);
/* 1st reflector */
- CHECK(ssol_object_create(dev, &m_object1), RES_OK);
- CHECK(ssol_object_add_shaded_shape(m_object1, quad_square, m_mtl, m_mtl), RES_OK);
- CHECK(ssol_object_instantiate(m_object1, &heliostat1), RES_OK);
- CHECK(ssol_scene_attach_instance(scene, heliostat1), RES_OK);
+ CHK(ssol_object_create(dev, &m_object1) == RES_OK);
+ CHK(ssol_object_add_shaded_shape(m_object1, quad_square, m_mtl, m_mtl) == RES_OK);
+ CHK(ssol_object_instantiate(m_object1, &heliostat1) == RES_OK);
+ CHK(ssol_scene_attach_instance(scene, heliostat1) == RES_OK);
d33_rotation_pitch(transform, PI); /* flip faces: invert normal */
d3_splat(transform + 9, 0);
transform[9] = -25;
- CHECK(ssol_instance_set_transform(heliostat1, transform), RES_OK);
+ CHK(ssol_instance_set_transform(heliostat1, transform) == RES_OK);
/* 2nd reflector */
- CHECK(ssol_object_create(dev, &m_object2), RES_OK);
- CHECK(ssol_object_add_shaded_shape(m_object2, quad_square, m_mtl, m_mtl), RES_OK);
- CHECK(ssol_object_instantiate(m_object2, &heliostat2), RES_OK);
- CHECK(ssol_scene_attach_instance(scene, heliostat2), RES_OK);
+ CHK(ssol_object_create(dev, &m_object2) == RES_OK);
+ CHK(ssol_object_add_shaded_shape(m_object2, quad_square, m_mtl, m_mtl) == RES_OK);
+ CHK(ssol_object_instantiate(m_object2, &heliostat2) == RES_OK);
+ CHK(ssol_scene_attach_instance(scene, heliostat2) == RES_OK);
d33_rotation_pitch(transform, PI); /* flip faces: invert normal */
d3_splat(transform + 9, 0);
transform[9] = +25;
- CHECK(ssol_instance_set_transform(heliostat2, transform), RES_OK);
+ CHK(ssol_instance_set_transform(heliostat2, transform) == RES_OK);
/* 1st target */
- CHECK(ssol_object_create(dev, &t_object1), RES_OK);
- CHECK(ssol_object_add_shaded_shape(t_object1, square, bck_mtl, v_mtl), RES_OK);
- CHECK(ssol_object_instantiate(t_object1, &target1), RES_OK);
- CHECK(ssol_instance_set_transform(target1, transform), RES_OK);
- CHECK(ssol_instance_set_receiver(target1, SSOL_FRONT, 0), RES_OK);
- CHECK(ssol_instance_sample(target1, 0), RES_OK);
- CHECK(ssol_scene_attach_instance(scene, target1), RES_OK);
+ CHK(ssol_object_create(dev, &t_object1) == RES_OK);
+ CHK(ssol_object_add_shaded_shape(t_object1, square, bck_mtl, v_mtl) == RES_OK);
+ CHK(ssol_object_instantiate(t_object1, &target1) == RES_OK);
+ CHK(ssol_instance_set_transform(target1, transform) == RES_OK);
+ CHK(ssol_instance_set_receiver(target1, SSOL_FRONT, 0) == RES_OK);
+ CHK(ssol_instance_sample(target1, 0) == RES_OK);
+ CHK(ssol_scene_attach_instance(scene, target1) == RES_OK);
d33_rotation_pitch(transform, PI); /* flip faces: invert normal */
d3_splat(transform + 9, 0);
transform[9] = -25;
transform[11] = 10;
- CHECK(ssol_instance_set_transform(target1, transform), RES_OK);
+ CHK(ssol_instance_set_transform(target1, transform) == RES_OK);
/* 2nd target */
- CHECK(ssol_object_create(dev, &t_object2), RES_OK);
- CHECK(ssol_object_add_shaded_shape(t_object2, square, bck_mtl, v_mtl), RES_OK);
- CHECK(ssol_object_instantiate(t_object2, &target2), RES_OK);
- CHECK(ssol_instance_set_transform(target2, transform), RES_OK);
- CHECK(ssol_instance_set_receiver(target2, SSOL_BACK, 0), RES_OK);
- CHECK(ssol_instance_sample(target2, 0), RES_OK);
- CHECK(ssol_scene_attach_instance(scene, target2), RES_OK);
+ CHK(ssol_object_create(dev, &t_object2) == RES_OK);
+ CHK(ssol_object_add_shaded_shape(t_object2, square, bck_mtl, v_mtl) == RES_OK);
+ CHK(ssol_object_instantiate(t_object2, &target2) == RES_OK);
+ CHK(ssol_instance_set_transform(target2, transform) == RES_OK);
+ CHK(ssol_instance_set_receiver(target2, SSOL_BACK, 0) == RES_OK);
+ CHK(ssol_instance_sample(target2, 0) == RES_OK);
+ CHK(ssol_scene_attach_instance(scene, target2) == RES_OK);
d33_set_identity(transform);
d3_splat(transform + 9, 0);
transform[9] = +25;
transform[11] = 10;
- CHECK(ssol_instance_set_transform(target2, transform), RES_OK);
+ CHK(ssol_instance_set_transform(target2, transform) == RES_OK);
#define N__ 10000
#define GET_MC_RCV ssol_estimator_get_mc_receiver
- CHECK(ssol_solve(scene, rng, N__, 0, NULL, &estimator), RES_OK);
- CHECK(ssol_estimator_get_mc_global(estimator, &mc_global), RES_OK);
+ CHK(ssol_solve(scene, rng, N__, 0, NULL, &estimator) == RES_OK);
+ CHK(ssol_estimator_get_mc_global(estimator, &mc_global) == RES_OK);
PRINT_GLOBAL(mc_global);
- CHECK(eq_eps(mc_global.shadowed.E, 100000, 2 * 100000/sqrt(N__)), 1);
- CHECK(eq_eps(mc_global.missing.E, 0, 0), 1);
+ CHK(eq_eps(mc_global.shadowed.E, 100000, 2 * 100000/sqrt(N__)) == 1);
+ CHK(eq_eps(mc_global.missing.E, 0, 0) == 1);
- CHECK(GET_MC_RCV(estimator, target1, SSOL_FRONT, &mc_rcv), RES_OK);
+ CHK(GET_MC_RCV(estimator, target1, SSOL_FRONT, &mc_rcv) == RES_OK);
printf("Ir(target1) = %g +/- %g\n",
mc_rcv.incoming_flux.E, mc_rcv.incoming_flux.SE);
- CHECK(eq_eps(mc_rcv.incoming_flux.E, 100000, 2*100000/sqrt(N__)), 1);
- CHECK(mc_rcv.incoming_flux.E, mc_rcv.absorbed_flux.E);
+ CHK(eq_eps(mc_rcv.incoming_flux.E, 100000, 2*100000/sqrt(N__)) == 1);
+ CHK(mc_rcv.incoming_flux.E == mc_rcv.absorbed_flux.E);
- CHECK(GET_MC_RCV(estimator, target2, SSOL_BACK, &mc_rcv), RES_OK);
+ CHK(GET_MC_RCV(estimator, target2, SSOL_BACK, &mc_rcv) == RES_OK);
printf("Ir(target2) = %g +/- %g\n",
mc_rcv.incoming_flux.E, mc_rcv.incoming_flux.SE);
- CHECK(eq_eps(mc_rcv.incoming_flux.E, 0, 1), 1);
- CHECK(mc_rcv.incoming_flux.E, mc_rcv.absorbed_flux.E);
+ CHK(eq_eps(mc_rcv.incoming_flux.E, 0, 1) == 1);
+ CHK(mc_rcv.incoming_flux.E == mc_rcv.absorbed_flux.E);
/* Free data */
- CHECK(ssol_instance_ref_put(heliostat1), RES_OK);
- CHECK(ssol_instance_ref_put(target1), RES_OK);
- CHECK(ssol_object_ref_put(m_object1), RES_OK);
- CHECK(ssol_object_ref_put(t_object1), RES_OK);
- CHECK(ssol_instance_ref_put(heliostat2), RES_OK);
- CHECK(ssol_instance_ref_put(target2), RES_OK);
- CHECK(ssol_object_ref_put(m_object2), RES_OK);
- CHECK(ssol_object_ref_put(t_object2), RES_OK);
- CHECK(ssol_shape_ref_put(square), RES_OK);
- CHECK(ssol_shape_ref_put(quad_square), RES_OK);
- CHECK(ssol_material_ref_put(m_mtl), RES_OK);
- CHECK(ssol_material_ref_put(bck_mtl), RES_OK);
- CHECK(ssol_material_ref_put(v_mtl), RES_OK);
- CHECK(ssol_device_ref_put(dev), RES_OK);
- CHECK(ssol_estimator_ref_put(estimator), RES_OK);
- CHECK(ssol_scene_ref_put(scene), RES_OK);
- CHECK(ssp_rng_ref_put(rng), RES_OK);
- CHECK(ssol_spectrum_ref_put(spectrum), RES_OK);
- CHECK(ssol_sun_ref_put(sun), RES_OK);
+ CHK(ssol_instance_ref_put(heliostat1) == RES_OK);
+ CHK(ssol_instance_ref_put(target1) == RES_OK);
+ CHK(ssol_object_ref_put(m_object1) == RES_OK);
+ CHK(ssol_object_ref_put(t_object1) == RES_OK);
+ CHK(ssol_instance_ref_put(heliostat2) == RES_OK);
+ CHK(ssol_instance_ref_put(target2) == RES_OK);
+ CHK(ssol_object_ref_put(m_object2) == RES_OK);
+ CHK(ssol_object_ref_put(t_object2) == RES_OK);
+ CHK(ssol_shape_ref_put(square) == RES_OK);
+ CHK(ssol_shape_ref_put(quad_square) == RES_OK);
+ CHK(ssol_material_ref_put(m_mtl) == RES_OK);
+ CHK(ssol_material_ref_put(bck_mtl) == RES_OK);
+ CHK(ssol_material_ref_put(v_mtl) == RES_OK);
+ CHK(ssol_device_ref_put(dev) == RES_OK);
+ CHK(ssol_estimator_ref_put(estimator) == RES_OK);
+ CHK(ssol_scene_ref_put(scene) == RES_OK);
+ CHK(ssp_rng_ref_put(rng) == RES_OK);
+ CHK(ssol_spectrum_ref_put(spectrum) == RES_OK);
+ CHK(ssol_sun_ref_put(sun) == RES_OK);
check_memory_allocator(&allocator);
mem_shutdown_proxy_allocator(&allocator);
- CHECK(mem_allocated_size(), 0);
+ CHK(mem_allocated_size() == 0);
return 0;
}
diff --git a/src/test_ssol_solver7.c b/src/test_ssol_solver7.c
@@ -53,7 +53,7 @@ get_wlen(const size_t i, double* wlen, double* data, void* ctx)
{
double wavelengths[3] = { 1, 2, 3 };
double intensities[3] = { 1, 0.8, 1 };
- CHECK(i < 3, 1);
+ CHK(i < 3);
(void)ctx;
*wlen = wavelengths[i];
*data = intensities[i];
@@ -100,139 +100,138 @@ main(int argc, char** argv)
mem_init_proxy_allocator(&allocator, &mem_default_allocator);
- CHECK(ssol_device_create
- (NULL, &allocator, 1, 0, &dev), RES_OK);
+ CHK(ssol_device_create(NULL, &allocator, 1, 0, &dev) == RES_OK);
- CHECK(ssp_rng_create(&allocator, &ssp_rng_threefry, &rng), RES_OK);
- CHECK(ssol_spectrum_create(dev, &spectrum), RES_OK);
- CHECK(ssol_spectrum_setup(spectrum, get_wlen, 3, NULL), RES_OK);
- CHECK(ssol_sun_create_directional(dev, &sun), RES_OK);
- CHECK(ssol_sun_set_direction(sun, d3(dir, 1, 0, -1)), RES_OK);
- CHECK(ssol_sun_set_spectrum(sun, spectrum), RES_OK);
- CHECK(ssol_sun_set_dni(sun, 1000), RES_OK);
- CHECK(ssol_scene_create(dev, &scene), RES_OK);
- CHECK(ssol_scene_attach_sun(scene, sun), RES_OK);
+ CHK(ssp_rng_create(&allocator, &ssp_rng_threefry, &rng) == RES_OK);
+ CHK(ssol_spectrum_create(dev, &spectrum) == RES_OK);
+ CHK(ssol_spectrum_setup(spectrum, get_wlen, 3, NULL) == RES_OK);
+ CHK(ssol_sun_create_directional(dev, &sun) == RES_OK);
+ CHK(ssol_sun_set_direction(sun, d3(dir, 1, 0, -1)) == RES_OK);
+ CHK(ssol_sun_set_spectrum(sun, spectrum) == RES_OK);
+ CHK(ssol_sun_set_dni(sun, 1000) == RES_OK);
+ CHK(ssol_scene_create(dev, &scene) == RES_OK);
+ CHK(ssol_scene_attach_sun(scene, sun) == RES_OK);
/* create scene content */
- CHECK(ssol_shape_create_mesh(dev, &square), RES_OK);
+ CHK(ssol_shape_create_mesh(dev, &square) == RES_OK);
attribs[0].usage = SSOL_POSITION;
attribs[0].get = get_position;
- CHECK(ssol_mesh_setup(square, TARGET_NTRIS__, get_ids,
- TARGET_NVERTS__, attribs, 1, (void*) &TARGET_DESC__), RES_OK);
+ CHK(ssol_mesh_setup(square, TARGET_NTRIS__, get_ids,
+ TARGET_NVERTS__, attribs, 1, (void*) &TARGET_DESC__) == RES_OK);
- CHECK(ssol_material_create_mirror(dev, &m_mtl), RES_OK);
+ CHK(ssol_material_create_mirror(dev, &m_mtl) == RES_OK);
m_shader.normal = get_shader_normal;
m_shader.reflectivity = get_shader_reflectivity;
m_shader.roughness = get_shader_roughness;
- CHECK(ssol_mirror_setup(m_mtl, &m_shader), RES_OK);
- CHECK(ssol_material_create_matte(dev, &bck_mtl), RES_OK);
+ CHK(ssol_mirror_setup(m_mtl, &m_shader, SSOL_MICROFACET_BECKMANN) == RES_OK);
+ CHK(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_setup(bck_mtl, &bck_shader), RES_OK);
- CHECK(ssol_material_create_virtual(dev, &v_mtl), RES_OK);
+ CHK(ssol_matte_setup(bck_mtl, &bck_shader) == RES_OK);
+ CHK(ssol_material_create_virtual(dev, &v_mtl) == RES_OK);
carving1.get = get_polygon_vertices;
carving1.operation = SSOL_AND;
carving1.nb_vertices = HELIOSTAT_NVERTS__;
carving1.context = &HELIOSTAT_EDGES__;
- CHECK(ssol_shape_create_punched_surface(dev, &quad_square1), RES_OK);
+ CHK(ssol_shape_create_punched_surface(dev, &quad_square1) == RES_OK);
quadric1.type = SSOL_QUADRIC_PARABOL;
quadric1.data.parabol.focal = 10 * sqrt(2) * H;
punched1.nb_carvings = 1;
punched1.quadric = &quadric1;
punched1.carvings = &carving1;
- CHECK(ssol_punched_surface_setup(quad_square1, &punched1), RES_OK);
- CHECK(ssol_object_create(dev, &m_object1), RES_OK);
- CHECK(ssol_object_add_shaded_shape(m_object1, quad_square1, m_mtl, m_mtl), RES_OK);
- CHECK(ssol_object_instantiate(m_object1, &heliostat), RES_OK);
- CHECK(ssol_scene_attach_instance(scene, heliostat), RES_OK);
+ CHK(ssol_punched_surface_setup(quad_square1, &punched1) == RES_OK);
+ CHK(ssol_object_create(dev, &m_object1) == RES_OK);
+ CHK(ssol_object_add_shaded_shape(m_object1, quad_square1, m_mtl, m_mtl) == RES_OK);
+ CHK(ssol_object_instantiate(m_object1, &heliostat) == RES_OK);
+ CHK(ssol_scene_attach_instance(scene, heliostat) == RES_OK);
d33_rotation_yaw(transform, -0.25 * PI);
d3_splat(transform + 9, 0);
transform[9] = 10 * H; /* target the img focal point of the hyperbol */
- CHECK(ssol_instance_set_transform(heliostat, transform), RES_OK);
+ CHK(ssol_instance_set_transform(heliostat, transform) == RES_OK);
carving2.get = get_polygon_vertices;
carving2.operation = SSOL_AND;
carving2.nb_vertices = HYPERBOL_NVERTS__;
carving2.context = &HYPERBOL_EDGES__;
- CHECK(ssol_shape_create_punched_surface(dev, &quad_square2), RES_OK);
+ CHK(ssol_shape_create_punched_surface(dev, &quad_square2) == RES_OK);
quadric2.type = SSOL_QUADRIC_HYPERBOL;
quadric2.data.hyperbol.real_focal = 9 * H;
quadric2.data.hyperbol.img_focal = 1 * H;
punched2.nb_carvings = 1;
punched2.quadric = &quadric2;
punched2.carvings = &carving2;
- CHECK(ssol_punched_surface_setup(quad_square2, &punched2), RES_OK);
- CHECK(ssol_object_create(dev, &m_object2), RES_OK);
- CHECK(ssol_object_add_shaded_shape(m_object2, quad_square2, m_mtl, v_mtl), RES_OK);
- CHECK(ssol_object_instantiate(m_object2, &secondary), RES_OK);
- CHECK(ssol_scene_attach_instance(scene, secondary), RES_OK);
+ CHK(ssol_punched_surface_setup(quad_square2, &punched2) == RES_OK);
+ CHK(ssol_object_create(dev, &m_object2) == RES_OK);
+ CHK(ssol_object_add_shaded_shape(m_object2, quad_square2, m_mtl, v_mtl) == RES_OK);
+ CHK(ssol_object_instantiate(m_object2, &secondary) == RES_OK);
+ CHK(ssol_scene_attach_instance(scene, secondary) == RES_OK);
d33_set_identity(transform);
d3_splat(transform + 9, 0);
transform[11] = 9 * H;
- CHECK(ssol_instance_set_transform(secondary, transform), RES_OK);
- CHECK(ssol_instance_sample(secondary, 0), RES_OK);
-
- CHECK(ssol_object_create(dev, &t_object), RES_OK);
- CHECK(ssol_object_add_shaded_shape(t_object, square, bck_mtl, v_mtl), RES_OK);
- CHECK(ssol_object_instantiate(t_object, &target), RES_OK);
- CHECK(ssol_instance_set_receiver(target, SSOL_FRONT, 0), RES_OK);
- CHECK(ssol_instance_sample(target, 0), RES_OK);
- CHECK(ssol_scene_attach_instance(scene, target), RES_OK);
+ CHK(ssol_instance_set_transform(secondary, transform) == RES_OK);
+ CHK(ssol_instance_sample(secondary, 0) == RES_OK);
+
+ CHK(ssol_object_create(dev, &t_object) == RES_OK);
+ CHK(ssol_object_add_shaded_shape(t_object, square, bck_mtl, v_mtl) == RES_OK);
+ CHK(ssol_object_instantiate(t_object, &target) == RES_OK);
+ CHK(ssol_instance_set_receiver(target, SSOL_FRONT, 0) == RES_OK);
+ CHK(ssol_instance_sample(target, 0) == RES_OK);
+ CHK(ssol_scene_attach_instance(scene, target) == RES_OK);
d33_set_identity(transform);
d3_splat(transform + 9, 0);
- CHECK(ssol_instance_set_transform(target, transform), RES_OK);
+ CHK(ssol_instance_set_transform(target, transform) == RES_OK);
#define N__ 10000
#define DNI_cos (1000 * cos(0))
#define TOTAL (HELIOSTAT_SZ * HELIOSTAT_SZ * DNI_cos)
#define GET_MC_RCV ssol_estimator_get_mc_receiver
- CHECK(ssol_solve(scene, rng, N__, 0, NULL, &estimator), RES_OK);
+ CHK(ssol_solve(scene, rng, N__, 0, NULL, &estimator) == RES_OK);
- CHECK(ssol_estimator_get_mc_global(estimator, &mc_global), RES_OK);
- CHECK(ssol_estimator_get_sampled_area(estimator, &area), RES_OK);
+ CHK(ssol_estimator_get_mc_global(estimator, &mc_global) == RES_OK);
+ CHK(ssol_estimator_get_sampled_area(estimator, &area) == RES_OK);
printf("Total = %g\n", area * DNI_cos);
- CHECK(eq_eps(area * DNI_cos, TOTAL, TOTAL * 1e-4), 1);
+ CHK(eq_eps(area * DNI_cos, TOTAL, TOTAL * 1e-4) == 1);
PRINT_GLOBAL(mc_global);
- CHECK(GET_MC_RCV(estimator, target, SSOL_FRONT, &mc_rcv), RES_OK);
+ CHK(GET_MC_RCV(estimator, target, SSOL_FRONT, &mc_rcv) == RES_OK);
printf("Abs(target1) = %g +/- %g\n",
mc_rcv.absorbed_flux.E,
mc_rcv.absorbed_flux.SE);
printf("Ir(target1) = %g +/- %g\n",
mc_rcv.incoming_flux.E, mc_rcv.incoming_flux.SE);
- CHECK(eq_eps(mc_rcv.incoming_flux.E, TOTAL, TOTAL * 1e-4), 1);
- CHECK(eq_eps(mc_rcv.absorbed_flux.E,
- (1 - REFLECTIVITY) * TOTAL, (1 - REFLECTIVITY) *TOTAL * 1e-4), 1);
- CHECK(eq_eps(mc_rcv.incoming_flux.SE, 0, 1e-2), 1);
+ CHK(eq_eps(mc_rcv.incoming_flux.E, TOTAL, TOTAL * 1e-4));
+ CHK(eq_eps(mc_rcv.absorbed_flux.E,
+ (1 - REFLECTIVITY) * TOTAL, (1 - REFLECTIVITY) *TOTAL * 1e-4));
+ CHK(eq_eps(mc_rcv.incoming_flux.SE, 0, 1e-2) == 1);
/* Free data */
- CHECK(ssol_instance_ref_put(heliostat), RES_OK);
- CHECK(ssol_instance_ref_put(secondary), RES_OK);
- CHECK(ssol_instance_ref_put(target), RES_OK);
- CHECK(ssol_object_ref_put(m_object1), RES_OK);
- CHECK(ssol_object_ref_put(m_object2), RES_OK);
- CHECK(ssol_object_ref_put(t_object), RES_OK);
- CHECK(ssol_shape_ref_put(square), RES_OK);
- CHECK(ssol_shape_ref_put(quad_square1), RES_OK);
- CHECK(ssol_shape_ref_put(quad_square2), RES_OK);
- CHECK(ssol_material_ref_put(m_mtl), RES_OK);
- CHECK(ssol_material_ref_put(bck_mtl), RES_OK);
- CHECK(ssol_material_ref_put(v_mtl), RES_OK);
- CHECK(ssol_estimator_ref_put(estimator), RES_OK);
- CHECK(ssol_device_ref_put(dev), RES_OK);
- CHECK(ssol_scene_ref_put(scene), RES_OK);
- CHECK(ssp_rng_ref_put(rng), RES_OK);
- CHECK(ssol_spectrum_ref_put(spectrum), RES_OK);
- CHECK(ssol_sun_ref_put(sun), RES_OK);
+ CHK(ssol_instance_ref_put(heliostat) == RES_OK);
+ CHK(ssol_instance_ref_put(secondary) == RES_OK);
+ CHK(ssol_instance_ref_put(target) == RES_OK);
+ CHK(ssol_object_ref_put(m_object1) == RES_OK);
+ CHK(ssol_object_ref_put(m_object2) == RES_OK);
+ CHK(ssol_object_ref_put(t_object) == RES_OK);
+ CHK(ssol_shape_ref_put(square) == RES_OK);
+ CHK(ssol_shape_ref_put(quad_square1) == RES_OK);
+ CHK(ssol_shape_ref_put(quad_square2) == RES_OK);
+ CHK(ssol_material_ref_put(m_mtl) == RES_OK);
+ CHK(ssol_material_ref_put(bck_mtl) == RES_OK);
+ CHK(ssol_material_ref_put(v_mtl) == RES_OK);
+ CHK(ssol_estimator_ref_put(estimator) == RES_OK);
+ CHK(ssol_device_ref_put(dev) == RES_OK);
+ CHK(ssol_scene_ref_put(scene) == RES_OK);
+ CHK(ssp_rng_ref_put(rng) == RES_OK);
+ CHK(ssol_spectrum_ref_put(spectrum) == RES_OK);
+ CHK(ssol_sun_ref_put(sun) == RES_OK);
check_memory_allocator(&allocator);
mem_shutdown_proxy_allocator(&allocator);
- CHECK(mem_allocated_size(), 0);
+ CHK(mem_allocated_size() == 0);
return 0;
}
diff --git a/src/test_ssol_solver8.c b/src/test_ssol_solver8.c
@@ -41,7 +41,7 @@ get_wlen(const size_t i, double* wlen, double* data, void* ctx)
{
double wavelengths[3] = { 1, 2, 3 };
double intensities[3] = { 1, 0.8, 1 };
- CHECK(i < 3, 1);
+ CHK(i < 3);
(void) ctx;
*wlen = wavelengths[i];
*data = intensities[i];
@@ -83,29 +83,29 @@ main(int argc, char** argv)
mem_init_proxy_allocator(&allocator, &mem_default_allocator);
- CHECK(ssol_device_create
- (NULL, &allocator, SSOL_NTHREADS_DEFAULT, 0, &dev), RES_OK);
+ CHK(ssol_device_create
+ (NULL, &allocator, SSOL_NTHREADS_DEFAULT, 0, &dev) == RES_OK);
#define DNI 1000
- CHECK(ssp_rng_create(&allocator, &ssp_rng_threefry, &rng), RES_OK);
- CHECK(ssol_spectrum_create(dev, &spectrum), RES_OK);
- CHECK(ssol_spectrum_setup(spectrum, get_wlen, 3, NULL), RES_OK);
- CHECK(ssol_sun_create_directional(dev, &sun), RES_OK);
- CHECK(ssol_sun_set_direction(sun, d3(dir, 0, 1, -1)), RES_OK);
- CHECK(ssol_sun_set_spectrum(sun, spectrum), RES_OK);
- CHECK(ssol_sun_set_dni(sun, DNI), RES_OK);
- CHECK(ssol_scene_create(dev, &scene), RES_OK);
- CHECK(ssol_scene_attach_sun(scene, sun), RES_OK);
+ CHK(ssp_rng_create(&allocator, &ssp_rng_threefry, &rng) == RES_OK);
+ CHK(ssol_spectrum_create(dev, &spectrum) == RES_OK);
+ CHK(ssol_spectrum_setup(spectrum, get_wlen, 3, NULL) == RES_OK);
+ CHK(ssol_sun_create_directional(dev, &sun) == RES_OK);
+ CHK(ssol_sun_set_direction(sun, d3(dir, 0, 1, -1)) == RES_OK);
+ CHK(ssol_sun_set_spectrum(sun, spectrum) == RES_OK);
+ CHK(ssol_sun_set_dni(sun, DNI) == RES_OK);
+ CHK(ssol_scene_create(dev, &scene) == RES_OK);
+ CHK(ssol_scene_attach_sun(scene, sun) == RES_OK);
/* Create scene content */
- CHECK(ssol_shape_create_mesh(dev, &square), RES_OK);
+ CHK(ssol_shape_create_mesh(dev, &square) == RES_OK);
attribs[0].usage = SSOL_POSITION;
attribs[0].get = get_position;
- CHECK(ssol_mesh_setup(square, TARGET_NTRIS__, get_ids,
- TARGET_NVERTS__, attribs, 1, (void*) &TARGET_DESC__), RES_OK);
+ CHK(ssol_mesh_setup(square, TARGET_NTRIS__, get_ids,
+ TARGET_NVERTS__, attribs, 1, (void*) &TARGET_DESC__) == RES_OK);
- CHECK(ssol_shape_create_punched_surface(dev, &quad_square), RES_OK);
+ CHK(ssol_shape_create_punched_surface(dev, &quad_square) == RES_OK);
carving.get = get_polygon_vertices;
carving.operation = SSOL_AND;
carving.nb_vertices = POLY_NVERTS__;
@@ -115,68 +115,68 @@ main(int argc, char** argv)
punched.nb_carvings = 1;
punched.quadric = &quadric;
punched.carvings = &carving;
- CHECK(ssol_punched_surface_setup(quad_square, &punched), RES_OK);
+ CHK(ssol_punched_surface_setup(quad_square, &punched) == RES_OK);
- CHECK(ssol_material_create_mirror(dev, &m_mtl), RES_OK);
+ CHK(ssol_material_create_mirror(dev, &m_mtl) == RES_OK);
shader.normal = get_shader_normal;
shader.reflectivity = get_shader_reflectivity;
shader.roughness = get_shader_roughness;
- 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);
- CHECK(ssol_object_add_shaded_shape(m_object, quad_square, m_mtl, m_mtl), RES_OK);
- CHECK(ssol_object_instantiate(m_object, &heliostat), RES_OK);
- CHECK(ssol_scene_attach_instance(scene, heliostat), RES_OK);
-
- CHECK(ssol_object_create(dev, &t_object), RES_OK);
- CHECK(ssol_object_add_shaded_shape(t_object, square, v_mtl, v_mtl), RES_OK);
- CHECK(ssol_object_instantiate(t_object, &target), RES_OK);
- CHECK(ssol_instance_set_transform(target, transform), RES_OK);
- CHECK(ssol_instance_set_receiver(target, SSOL_FRONT, 0), RES_OK);
- CHECK(ssol_instance_sample(target, 0), RES_OK);
- CHECK(ssol_scene_attach_instance(scene, target), RES_OK);
+ CHK(ssol_mirror_setup(m_mtl, &shader, SSOL_MICROFACET_BECKMANN) == RES_OK);
+ CHK(ssol_material_create_virtual(dev, &v_mtl) == RES_OK);
+
+ CHK(ssol_object_create(dev, &m_object) == RES_OK);
+ CHK(ssol_object_add_shaded_shape(m_object, quad_square, m_mtl, m_mtl) == RES_OK);
+ CHK(ssol_object_instantiate(m_object, &heliostat) == RES_OK);
+ CHK(ssol_scene_attach_instance(scene, heliostat) == RES_OK);
+
+ CHK(ssol_object_create(dev, &t_object) == RES_OK);
+ CHK(ssol_object_add_shaded_shape(t_object, square, v_mtl, v_mtl) == RES_OK);
+ CHK(ssol_object_instantiate(t_object, &target) == RES_OK);
+ CHK(ssol_instance_set_transform(target, transform) == RES_OK);
+ CHK(ssol_instance_set_receiver(target, SSOL_FRONT, 0) == RES_OK);
+ CHK(ssol_instance_sample(target, 0) == RES_OK);
+ CHK(ssol_scene_attach_instance(scene, target) == RES_OK);
#define N__ 100000
#define GET_MC_RCV ssol_estimator_get_mc_receiver
- CHECK(ssol_solve(scene, rng, N__, 0, NULL, &estimator), RES_OK);
- CHECK(ssol_estimator_get_realisation_count(estimator, &count), RES_OK);
- CHECK(count, N__);
- CHECK(ssol_estimator_get_failed_count(estimator, &count), RES_OK);
- CHECK(count, 0);
+ CHK(ssol_solve(scene, rng, N__, 0, NULL, &estimator) == RES_OK);
+ CHK(ssol_estimator_get_realisation_count(estimator, &count) == RES_OK);
+ CHK(count == N__);
+ CHK(ssol_estimator_get_failed_count(estimator, &count) == RES_OK);
+ CHK(count == 0);
#define S (sqrt(2) * X_SZ * Y_SZ)
- CHECK(ssol_estimator_get_mc_global(estimator, &mc_global), RES_OK);
+ CHK(ssol_estimator_get_mc_global(estimator, &mc_global) == RES_OK);
printf("Cos = %g +/- %g\n", mc_global.cos_factor.E, mc_global.cos_factor.SE);
printf("Shadows = %g +/- %g\n", mc_global.shadowed.E, mc_global.shadowed.SE);
printf("Missing = %g +/- %g\n", mc_global.missing.E, mc_global.missing.SE);
- CHECK(eq_eps(mc_global.shadowed.E, 0, 1e-4), 1);
- CHECK(eq_eps(mc_global.missing.E, S * DNI,
- 3 * mc_global.missing.SE), 1); /* nothing absorbed */
- CHECK(GET_MC_RCV(estimator, target, SSOL_FRONT, &mc_rcv), RES_OK);
+ CHK(eq_eps(mc_global.shadowed.E, 0, 1e-4) == 1);
+ CHK(eq_eps(mc_global.missing.E, S * DNI,
+ 3 * mc_global.missing.SE)); /* nothing absorbed */
+ CHK(GET_MC_RCV(estimator, target, SSOL_FRONT, &mc_rcv) == RES_OK);
printf("Ir(target1) = %g +/- %g\n",
mc_rcv.incoming_flux.E, mc_rcv.incoming_flux.SE);
- CHECK(eq_eps(mc_rcv.incoming_flux.E, S * DNI,
- 2 * mc_rcv.incoming_flux.SE), 1);
+ CHK(eq_eps(mc_rcv.incoming_flux.E, S * DNI,
+ 2 * mc_rcv.incoming_flux.SE));
/* Free data */
- CHECK(ssol_instance_ref_put(heliostat), RES_OK);
- CHECK(ssol_instance_ref_put(target), RES_OK);
- CHECK(ssol_object_ref_put(m_object), RES_OK);
- CHECK(ssol_object_ref_put(t_object), RES_OK);
- CHECK(ssol_shape_ref_put(square), RES_OK);
- CHECK(ssol_shape_ref_put(quad_square), RES_OK);
- CHECK(ssol_material_ref_put(m_mtl), RES_OK);
- CHECK(ssol_material_ref_put(v_mtl), RES_OK);
- CHECK(ssol_estimator_ref_put(estimator), RES_OK);
- CHECK(ssol_device_ref_put(dev), RES_OK);
- CHECK(ssol_scene_ref_put(scene), RES_OK);
- CHECK(ssp_rng_ref_put(rng), RES_OK);
- CHECK(ssol_spectrum_ref_put(spectrum), RES_OK);
- CHECK(ssol_sun_ref_put(sun), RES_OK);
+ CHK(ssol_instance_ref_put(heliostat) == RES_OK);
+ CHK(ssol_instance_ref_put(target) == RES_OK);
+ CHK(ssol_object_ref_put(m_object) == RES_OK);
+ CHK(ssol_object_ref_put(t_object) == RES_OK);
+ CHK(ssol_shape_ref_put(square) == RES_OK);
+ CHK(ssol_shape_ref_put(quad_square) == RES_OK);
+ CHK(ssol_material_ref_put(m_mtl) == RES_OK);
+ CHK(ssol_material_ref_put(v_mtl) == RES_OK);
+ CHK(ssol_estimator_ref_put(estimator) == RES_OK);
+ CHK(ssol_device_ref_put(dev) == RES_OK);
+ CHK(ssol_scene_ref_put(scene) == RES_OK);
+ CHK(ssp_rng_ref_put(rng) == RES_OK);
+ CHK(ssol_spectrum_ref_put(spectrum) == RES_OK);
+ CHK(ssol_sun_ref_put(sun) == RES_OK);
check_memory_allocator(&allocator);
mem_shutdown_proxy_allocator(&allocator);
- CHECK(mem_allocated_size(), 0);
+ CHK(mem_allocated_size() == 0);
return 0;
}
diff --git a/src/test_ssol_solver9.c b/src/test_ssol_solver9.c
@@ -46,7 +46,7 @@ get_wlen(const size_t i, double* wlen, double* data, void* ctx)
{
double wavelengths[3] = { 1, 2, 3 };
double intensities[3] = { 1, 0.8, 1 };
- CHECK(i < 3, 1);
+ CHK(i < 3);
(void) ctx;
*wlen = wavelengths[i];
*data = intensities[i];
@@ -85,92 +85,92 @@ main(int argc, char** argv)
mem_init_proxy_allocator(&allocator, &mem_default_allocator);
- CHECK(ssol_device_create
- (NULL, &allocator, SSOL_NTHREADS_DEFAULT, 0, &dev), RES_OK);
+ CHK(ssol_device_create
+ (NULL, &allocator, SSOL_NTHREADS_DEFAULT, 0, &dev) == RES_OK);
#define DNI 1000
- CHECK(ssp_rng_create(&allocator, &ssp_rng_threefry, &rng), RES_OK);
- CHECK(ssol_spectrum_create(dev, &spectrum), RES_OK);
- CHECK(ssol_spectrum_setup(spectrum, get_wlen, 3, NULL), RES_OK);
- CHECK(ssol_sun_create_directional(dev, &sun), RES_OK);
- CHECK(ssol_sun_set_direction(sun, d3(dir, 0, 0, -1)), RES_OK);
- CHECK(ssol_sun_set_spectrum(sun, spectrum), RES_OK);
- CHECK(ssol_sun_set_dni(sun, DNI), RES_OK);
- CHECK(ssol_scene_create(dev, &scene), RES_OK);
- CHECK(ssol_scene_attach_sun(scene, sun), RES_OK);
+ CHK(ssp_rng_create(&allocator, &ssp_rng_threefry, &rng) == RES_OK);
+ CHK(ssol_spectrum_create(dev, &spectrum) == RES_OK);
+ CHK(ssol_spectrum_setup(spectrum, get_wlen, 3, NULL) == RES_OK);
+ CHK(ssol_sun_create_directional(dev, &sun) == RES_OK);
+ CHK(ssol_sun_set_direction(sun, d3(dir, 0, 0, -1)) == RES_OK);
+ CHK(ssol_sun_set_spectrum(sun, spectrum) == RES_OK);
+ CHK(ssol_sun_set_dni(sun, DNI) == RES_OK);
+ CHK(ssol_scene_create(dev, &scene) == RES_OK);
+ CHK(ssol_scene_attach_sun(scene, sun) == RES_OK);
/* Create scene content */
- CHECK(ssol_shape_create_mesh(dev, &square), RES_OK);
+ CHK(ssol_shape_create_mesh(dev, &square) == RES_OK);
attribs[0].usage = SSOL_POSITION;
attribs[0].get = get_position;
- CHECK(ssol_mesh_setup(square, TARGET_NTRIS__, get_ids,
- TARGET_NVERTS__, attribs, 1, (void*) &TARGET_DESC__), RES_OK);
+ CHK(ssol_mesh_setup(square, TARGET_NTRIS__, get_ids,
+ TARGET_NVERTS__, attribs, 1, (void*) &TARGET_DESC__) == RES_OK);
- CHECK(ssol_shape_create_mesh(dev, &cube), RES_OK);
- CHECK(ssol_mesh_setup(cube, CUBE_NTRIS__, get_ids,
- CUBE_NVERTS__, attribs, 1, (void*) &CUBE_DESC__), RES_OK);
+ CHK(ssol_shape_create_mesh(dev, &cube) == RES_OK);
+ CHK(ssol_mesh_setup(cube, CUBE_NTRIS__, get_ids,
+ CUBE_NVERTS__, attribs, 1, (void*) &CUBE_DESC__) == RES_OK);
- CHECK(ssol_material_create_mirror(dev, &m_mtl), RES_OK);
+ CHK(ssol_material_create_mirror(dev, &m_mtl) == RES_OK);
shader.normal = get_shader_normal;
shader.reflectivity = get_shader_reflectivity;
shader.roughness = get_shader_roughness;
- 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);
- CHECK(ssol_object_add_shaded_shape(m_object, cube, m_mtl, m_mtl), RES_OK);
- CHECK(ssol_object_instantiate(m_object, &heliostat), RES_OK);
- CHECK(ssol_scene_attach_instance(scene, heliostat), RES_OK);
-
- CHECK(ssol_object_create(dev, &t_object), RES_OK);
- CHECK(ssol_object_add_shaded_shape(t_object, square, v_mtl, v_mtl), RES_OK);
- CHECK(ssol_object_instantiate(t_object, &target), RES_OK);
- CHECK(ssol_instance_set_transform(target, transform), RES_OK);
- CHECK(ssol_instance_set_receiver(target, SSOL_FRONT, 0), RES_OK);
- CHECK(ssol_instance_sample(target, 0), RES_OK);
- CHECK(ssol_scene_attach_instance(scene, target), RES_OK);
+ CHK(ssol_mirror_setup(m_mtl, &shader, SSOL_MICROFACET_BECKMANN) == RES_OK);
+ CHK(ssol_material_create_virtual(dev, &v_mtl) == RES_OK);
+
+ CHK(ssol_object_create(dev, &m_object) == RES_OK);
+ CHK(ssol_object_add_shaded_shape(m_object, cube, m_mtl, m_mtl) == RES_OK);
+ CHK(ssol_object_instantiate(m_object, &heliostat) == RES_OK);
+ CHK(ssol_scene_attach_instance(scene, heliostat) == RES_OK);
+
+ CHK(ssol_object_create(dev, &t_object) == RES_OK);
+ CHK(ssol_object_add_shaded_shape(t_object, square, v_mtl, v_mtl) == RES_OK);
+ CHK(ssol_object_instantiate(t_object, &target) == RES_OK);
+ CHK(ssol_instance_set_transform(target, transform) == RES_OK);
+ CHK(ssol_instance_set_receiver(target, SSOL_FRONT, 0) == RES_OK);
+ CHK(ssol_instance_sample(target, 0) == RES_OK);
+ CHK(ssol_scene_attach_instance(scene, target) == RES_OK);
#define N__ 100000
#define GET_MC_RCV ssol_estimator_get_mc_receiver
- CHECK(ssol_solve(scene, rng, N__, 0, NULL, &estimator), RES_OK);
- CHECK(ssol_estimator_get_realisation_count(estimator, &count), RES_OK);
- CHECK(count, N__);
- CHECK(ssol_estimator_get_failed_count(estimator, &count), RES_OK);
- CHECK(count, 0);
+ CHK(ssol_solve(scene, rng, N__, 0, NULL, &estimator) == RES_OK);
+ CHK(ssol_estimator_get_realisation_count(estimator, &count) == RES_OK);
+ CHK(count == N__);
+ CHK(ssol_estimator_get_failed_count(estimator, &count) == RES_OK);
+ CHK(count == 0);
#define DNI_TGT_S (DNI * TGT_X * TGT_Y)
#define DNI_S (DNI * SZ * SZ)
- CHECK(ssol_estimator_get_mc_global(estimator, &mc_global), RES_OK);
+ CHK(ssol_estimator_get_mc_global(estimator, &mc_global) == RES_OK);
PRINT_GLOBAL(mc_global);
- CHECK(eq_eps(mc_global.cos_factor.E, 1./3., 3 * mc_global.cos_factor.SE), 1);
- CHECK(eq_eps(mc_global.shadowed.E, DNI_S, 3 * mc_global.shadowed.SE), 1);
- CHECK(eq_eps(mc_global.missing.E, MMAX(DNI_S, DNI_TGT_S),
- 3 * mc_global.missing.SE), 1);
- CHECK(GET_MC_RCV(estimator, target, SSOL_FRONT, &mc_rcv), RES_OK);
+ CHK(eq_eps(mc_global.cos_factor.E, 1./3., 3 * mc_global.cos_factor.SE));
+ CHK(eq_eps(mc_global.shadowed.E, DNI_S, 3 * mc_global.shadowed.SE));
+ CHK(eq_eps(mc_global.missing.E, MMAX(DNI_S, DNI_TGT_S),
+ 3 * mc_global.missing.SE));
+ CHK(GET_MC_RCV(estimator, target, SSOL_FRONT, &mc_rcv) == RES_OK);
printf("Ir(target1) = %g +/- %g\n",
mc_rcv.incoming_flux.E, mc_rcv.incoming_flux.SE);
- CHECK(eq_eps(mc_rcv.incoming_flux.E, MMIN(DNI_S, DNI_TGT_S),
- 3 * mc_rcv.incoming_flux.SE), 1);
+ CHK(eq_eps(mc_rcv.incoming_flux.E, MMIN(DNI_S, DNI_TGT_S),
+ 3 * mc_rcv.incoming_flux.SE));
/* Free data */
- CHECK(ssol_instance_ref_put(heliostat), RES_OK);
- CHECK(ssol_instance_ref_put(target), RES_OK);
- CHECK(ssol_object_ref_put(m_object), RES_OK);
- CHECK(ssol_object_ref_put(t_object), RES_OK);
- CHECK(ssol_shape_ref_put(square), RES_OK);
- CHECK(ssol_shape_ref_put(cube), RES_OK);
- CHECK(ssol_material_ref_put(m_mtl), RES_OK);
- CHECK(ssol_material_ref_put(v_mtl), RES_OK);
- CHECK(ssol_estimator_ref_put(estimator), RES_OK);
- CHECK(ssol_device_ref_put(dev), RES_OK);
- CHECK(ssol_scene_ref_put(scene), RES_OK);
- CHECK(ssp_rng_ref_put(rng), RES_OK);
- CHECK(ssol_spectrum_ref_put(spectrum), RES_OK);
- CHECK(ssol_sun_ref_put(sun), RES_OK);
+ CHK(ssol_instance_ref_put(heliostat) == RES_OK);
+ CHK(ssol_instance_ref_put(target) == RES_OK);
+ CHK(ssol_object_ref_put(m_object) == RES_OK);
+ CHK(ssol_object_ref_put(t_object) == RES_OK);
+ CHK(ssol_shape_ref_put(square) == RES_OK);
+ CHK(ssol_shape_ref_put(cube) == RES_OK);
+ CHK(ssol_material_ref_put(m_mtl) == RES_OK);
+ CHK(ssol_material_ref_put(v_mtl) == RES_OK);
+ CHK(ssol_estimator_ref_put(estimator) == RES_OK);
+ CHK(ssol_device_ref_put(dev) == RES_OK);
+ CHK(ssol_scene_ref_put(scene) == RES_OK);
+ CHK(ssp_rng_ref_put(rng) == RES_OK);
+ CHK(ssol_spectrum_ref_put(spectrum) == RES_OK);
+ CHK(ssol_sun_ref_put(sun) == RES_OK);
check_memory_allocator(&allocator);
mem_shutdown_proxy_allocator(&allocator);
- CHECK(mem_allocated_size(), 0);
+ CHK(mem_allocated_size() == 0);
return 0;
}
diff --git a/src/test_ssol_spectrum.c b/src/test_ssol_spectrum.c
@@ -27,10 +27,10 @@ static void
get_wlen(const size_t i, double* wlen, double* data, void* ctx)
{
struct spectrum_desc* desc = ctx;
- CHECK(i < 3, 1);
- NCHECK(wlen, NULL);
- NCHECK(data, NULL);
- NCHECK(ctx, NULL);
+ CHK(i < 3);
+ CHK(wlen != NULL);
+ CHK(data != NULL);
+ CHK(ctx != NULL);
*wlen = desc->wavelengths[i];
*data = desc->data[i];
++wlens_count;
@@ -47,18 +47,18 @@ main(int argc, char** argv)
mem_init_proxy_allocator(&allocator, &mem_default_allocator);
- CHECK(ssol_device_create
- (NULL, &allocator, SSOL_NTHREADS_DEFAULT, 0, &dev), RES_OK);
+ CHK(ssol_device_create
+ (NULL, &allocator, SSOL_NTHREADS_DEFAULT, 0, &dev) == RES_OK);
- CHECK(ssol_spectrum_create(NULL, &spectrum), RES_BAD_ARG);
- CHECK(ssol_spectrum_create(dev, NULL), RES_BAD_ARG);
- CHECK(ssol_spectrum_create(dev, &spectrum), RES_OK);
+ CHK(ssol_spectrum_create(NULL, &spectrum) == RES_BAD_ARG);
+ CHK(ssol_spectrum_create(dev, NULL) == RES_BAD_ARG);
+ CHK(ssol_spectrum_create(dev, &spectrum) == RES_OK);
- CHECK(ssol_spectrum_ref_get(NULL), RES_BAD_ARG);
- CHECK(ssol_spectrum_ref_get(spectrum), RES_OK);
+ CHK(ssol_spectrum_ref_get(NULL) == RES_BAD_ARG);
+ CHK(ssol_spectrum_ref_get(spectrum) == RES_OK);
- CHECK(ssol_spectrum_ref_put(NULL), RES_BAD_ARG);
- CHECK(ssol_spectrum_ref_put(spectrum), RES_OK);
+ CHK(ssol_spectrum_ref_put(NULL) == RES_BAD_ARG);
+ CHK(ssol_spectrum_ref_put(spectrum) == RES_OK);
desc.wavelengths[0] = 10;
desc.wavelengths[1] = 20;
@@ -67,32 +67,32 @@ main(int argc, char** argv)
desc.data[1] = 2.1;
desc.data[2] = 1.5;
- CHECK(ssol_spectrum_setup(NULL, NULL, 0, &desc), RES_BAD_ARG);
- CHECK(ssol_spectrum_setup(spectrum, NULL, 0, &desc), RES_BAD_ARG);
- CHECK(ssol_spectrum_setup(NULL, get_wlen, 0, &desc), RES_BAD_ARG);
- CHECK(ssol_spectrum_setup(spectrum, get_wlen, 0, &desc), RES_BAD_ARG);
- CHECK(ssol_spectrum_setup(NULL, NULL, 3, &desc), RES_BAD_ARG);
- CHECK(ssol_spectrum_setup(spectrum, NULL, 3, &desc), RES_BAD_ARG);
- CHECK(ssol_spectrum_setup(NULL, get_wlen, 3, &desc), RES_BAD_ARG);
- CHECK(wlens_count, 0);
- CHECK(ssol_spectrum_setup(spectrum, get_wlen, 3, &desc), RES_OK);
- CHECK(wlens_count, 3);
- CHECK(ssol_spectrum_setup(spectrum, get_wlen, 3, &desc), RES_OK);
+ CHK(ssol_spectrum_setup(NULL, NULL, 0, &desc) == RES_BAD_ARG);
+ CHK(ssol_spectrum_setup(spectrum, NULL, 0, &desc) == RES_BAD_ARG);
+ CHK(ssol_spectrum_setup(NULL, get_wlen, 0, &desc) == RES_BAD_ARG);
+ CHK(ssol_spectrum_setup(spectrum, get_wlen, 0, &desc) == RES_BAD_ARG);
+ CHK(ssol_spectrum_setup(NULL, NULL, 3, &desc) == RES_BAD_ARG);
+ CHK(ssol_spectrum_setup(spectrum, NULL, 3, &desc) == RES_BAD_ARG);
+ CHK(ssol_spectrum_setup(NULL, get_wlen, 3, &desc) == RES_BAD_ARG);
+ CHK(wlens_count == 0);
+ CHK(ssol_spectrum_setup(spectrum, get_wlen, 3, &desc) == RES_OK);
+ CHK(wlens_count == 3);
+ CHK(ssol_spectrum_setup(spectrum, get_wlen, 3, &desc) == RES_OK);
desc.wavelengths[1] = 30;
- CHECK(ssol_spectrum_setup(spectrum, get_wlen, 3, &desc), RES_BAD_ARG);
+ CHK(ssol_spectrum_setup(spectrum, get_wlen, 3, &desc) == RES_BAD_ARG);
desc.wavelengths[1] = 20;
desc.data[1] = -2.1;
- CHECK(ssol_spectrum_setup(spectrum, get_wlen, 3, &desc), RES_BAD_ARG);
+ CHK(ssol_spectrum_setup(spectrum, get_wlen, 3, &desc) == RES_BAD_ARG);
- CHECK(ssol_spectrum_ref_put(spectrum), RES_OK);
+ CHK(ssol_spectrum_ref_put(spectrum) == RES_OK);
- CHECK(ssol_device_ref_put(dev), RES_OK);
+ CHK(ssol_device_ref_put(dev) == RES_OK);
check_memory_allocator(&allocator);
mem_shutdown_proxy_allocator(&allocator);
- CHECK(mem_allocated_size(), 0);
+ CHK(mem_allocated_size() == 0);
return 0;
}
diff --git a/src/test_ssol_sun.c b/src/test_ssol_sun.c
@@ -34,166 +34,233 @@ main(int argc, char** argv)
mem_init_proxy_allocator(&allocator, &mem_default_allocator);
- CHECK(ssol_device_create
- (NULL, &allocator, SSOL_NTHREADS_DEFAULT, 0, &dev), RES_OK);
-
- CHECK(ssol_spectrum_create(dev, &spectrum), RES_OK);
- CHECK(ssol_spectrum_create(dev, &spectrum2), RES_OK);
-
- CHECK(ssol_sun_create_directional(NULL, &sun), RES_BAD_ARG);
- CHECK(ssol_sun_create_directional(dev, NULL), RES_BAD_ARG);
- CHECK(ssol_sun_create_directional(dev, &sun), RES_OK);
-
- CHECK(ssol_sun_ref_get(NULL), RES_BAD_ARG);
- CHECK(ssol_sun_ref_get(sun), RES_OK);
-
- CHECK(ssol_sun_ref_put(NULL), RES_BAD_ARG);
- CHECK(ssol_sun_ref_put(sun), RES_OK);
-
- CHECK(ssol_sun_set_spectrum(NULL, spectrum), RES_BAD_ARG);
- CHECK(ssol_sun_set_spectrum(sun, NULL), RES_BAD_ARG);
- CHECK(ssol_sun_set_spectrum(sun, spectrum), RES_OK);
- CHECK(ssol_sun_set_spectrum(sun, spectrum), RES_OK);
-
- CHECK(ssol_sun_set_direction(NULL, dir), RES_BAD_ARG);
- CHECK(ssol_sun_set_direction(sun, NULL), RES_BAD_ARG);
- CHECK(ssol_sun_set_direction(sun, dir0), RES_BAD_ARG);
- CHECK(ssol_sun_set_direction(sun, dir), RES_OK);
- CHECK(ssol_sun_set_direction(sun, dir), RES_OK);
-
- CHECK(ssol_sun_get_direction(NULL, tmp), RES_BAD_ARG);
- CHECK(ssol_sun_get_direction(sun, NULL), RES_BAD_ARG);
- CHECK(ssol_sun_get_direction(sun, tmp), RES_OK);
- CHECK(d3_eq(dir, tmp), 1);
-
- CHECK(ssol_sun_set_dni(NULL, 1000), RES_BAD_ARG);
- CHECK(ssol_sun_set_dni(sun, 0), RES_BAD_ARG);
- CHECK(ssol_sun_set_dni(sun, 1000), RES_OK);
- CHECK(ssol_sun_set_dni(sun, 1000), RES_OK);
-
- CHECK(ssol_sun_get_dni(NULL, &dni), RES_BAD_ARG);
- CHECK(ssol_sun_get_dni(sun, NULL), RES_BAD_ARG);
- CHECK(ssol_sun_get_dni(sun, &dni), RES_OK);
- CHECK(dni, 1000);
-
- CHECK(ssol_sun_pillbox_set_half_angle(NULL, 0.1), RES_BAD_ARG);
- CHECK(ssol_sun_pillbox_set_half_angle(sun, -0.1), RES_BAD_ARG);
- CHECK(ssol_sun_pillbox_set_half_angle(sun, 999), RES_BAD_ARG);
- CHECK(ssol_sun_pillbox_set_half_angle(sun, 0.1), RES_BAD_ARG);
-
- CHECK(ssol_sun_set_buie_param(NULL, 0.1), RES_BAD_ARG);
- CHECK(ssol_sun_set_buie_param(sun, -0.1), RES_BAD_ARG);
- CHECK(ssol_sun_set_buie_param(sun, 999), RES_BAD_ARG);
- CHECK(ssol_sun_set_buie_param(sun, 0.1), RES_BAD_ARG);
-
- CHECK(ssol_sun_ref_put(sun), RES_OK);
-
- CHECK(ssol_sun_create_pillbox(NULL, &sun), RES_BAD_ARG);
- CHECK(ssol_sun_create_pillbox(dev, NULL), RES_BAD_ARG);
- CHECK(ssol_sun_create_pillbox(dev, &sun), RES_OK);
-
- CHECK(ssol_sun_ref_get(NULL), RES_BAD_ARG);
- CHECK(ssol_sun_ref_get(sun), RES_OK);
-
- CHECK(ssol_sun_ref_put(NULL), RES_BAD_ARG);
- CHECK(ssol_sun_ref_put(sun), RES_OK);
-
- CHECK(ssol_sun_set_spectrum(NULL, spectrum), RES_BAD_ARG);
- CHECK(ssol_sun_set_spectrum(sun, NULL), RES_BAD_ARG);
- CHECK(ssol_sun_set_spectrum(sun, spectrum), RES_OK);
- CHECK(ssol_sun_set_spectrum(sun, spectrum2), RES_OK);
- CHECK(ssol_sun_set_spectrum(sun, spectrum2), RES_OK);
-
- CHECK(ssol_sun_set_direction(NULL, dir), RES_BAD_ARG);
- CHECK(ssol_sun_set_direction(sun, NULL), RES_BAD_ARG);
- CHECK(ssol_sun_set_direction(sun, dir0), RES_BAD_ARG);
- CHECK(ssol_sun_set_direction(sun, dir), RES_OK);
- CHECK(ssol_sun_set_direction(sun, dir), RES_OK);
-
- CHECK(ssol_sun_get_direction(NULL, tmp), RES_BAD_ARG);
- CHECK(ssol_sun_get_direction(sun, NULL), RES_BAD_ARG);
- CHECK(ssol_sun_get_direction(sun, tmp), RES_OK);
- CHECK(d3_eq(dir, tmp), 1);
-
- CHECK(ssol_sun_set_dni(NULL, 1000), RES_BAD_ARG);
- CHECK(ssol_sun_set_dni(sun, 0), RES_BAD_ARG);
- CHECK(ssol_sun_set_dni(sun, 1000), RES_OK);
- CHECK(ssol_sun_set_dni(sun, 1000), RES_OK);
-
- CHECK(ssol_sun_get_dni(NULL, &dni), RES_BAD_ARG);
- CHECK(ssol_sun_get_dni(sun, NULL), RES_BAD_ARG);
- CHECK(ssol_sun_get_dni(sun, &dni), RES_OK);
- CHECK(dni, 1000);
-
- CHECK(ssol_sun_pillbox_set_half_angle(NULL, 0.1), RES_BAD_ARG);
- CHECK(ssol_sun_pillbox_set_half_angle(sun, -0.1), RES_BAD_ARG);
- CHECK(ssol_sun_pillbox_set_half_angle(sun, 999), RES_BAD_ARG);
- CHECK(ssol_sun_pillbox_set_half_angle(sun, 0.1), RES_OK);
- CHECK(ssol_sun_pillbox_set_half_angle(sun, 0.1), RES_OK);
-
- CHECK(ssol_sun_set_buie_param(NULL, 0.1), RES_BAD_ARG);
- CHECK(ssol_sun_set_buie_param(sun, -0.1), RES_BAD_ARG);
- CHECK(ssol_sun_set_buie_param(sun, 999), RES_BAD_ARG);
- CHECK(ssol_sun_set_buie_param(sun, 0.1), RES_BAD_ARG);
-
- CHECK(ssol_sun_ref_put(sun), RES_OK);
-
- CHECK(ssol_sun_create_buie(NULL, &sun), RES_BAD_ARG);
- CHECK(ssol_sun_create_buie(dev, NULL), RES_BAD_ARG);
- CHECK(ssol_sun_create_buie(dev, &sun), RES_OK);
-
- CHECK(ssol_sun_ref_get(NULL), RES_BAD_ARG);
- CHECK(ssol_sun_ref_get(sun), RES_OK);
-
- CHECK(ssol_sun_ref_put(NULL), RES_BAD_ARG);
- CHECK(ssol_sun_ref_put(sun), RES_OK);
-
- CHECK(ssol_sun_set_spectrum(NULL, spectrum), RES_BAD_ARG);
- CHECK(ssol_sun_set_spectrum(sun, NULL), RES_BAD_ARG);
- CHECK(ssol_sun_set_spectrum(sun, spectrum), RES_OK);
- CHECK(ssol_sun_set_spectrum(sun, spectrum), RES_OK);
-
- CHECK(ssol_sun_set_direction(NULL, dir), RES_BAD_ARG);
- CHECK(ssol_sun_set_direction(sun, NULL), RES_BAD_ARG);
- CHECK(ssol_sun_set_direction(sun, dir0), RES_BAD_ARG);
- CHECK(ssol_sun_set_direction(sun, dir), RES_OK);
- CHECK(ssol_sun_set_direction(sun, dir), RES_OK);
-
- CHECK(ssol_sun_get_direction(NULL, tmp), RES_BAD_ARG);
- CHECK(ssol_sun_get_direction(sun, NULL), RES_BAD_ARG);
- CHECK(ssol_sun_get_direction(sun, tmp), RES_OK);
- CHECK(d3_eq(dir, tmp), 1);
-
- CHECK(ssol_sun_set_dni(NULL, 1000), RES_BAD_ARG);
- CHECK(ssol_sun_set_dni(sun, 0), RES_BAD_ARG);
- CHECK(ssol_sun_set_dni(sun, 1000), RES_OK);
- CHECK(ssol_sun_set_dni(sun, 1000), RES_OK);
-
- CHECK(ssol_sun_get_dni(NULL, &dni), RES_BAD_ARG);
- CHECK(ssol_sun_get_dni(sun, NULL), RES_BAD_ARG);
- CHECK(ssol_sun_get_dni(sun, &dni), RES_OK);
- CHECK(dni, 1000);
-
- CHECK(ssol_sun_pillbox_set_half_angle(NULL, 0.1), RES_BAD_ARG);
- CHECK(ssol_sun_pillbox_set_half_angle(sun, -0.1), RES_BAD_ARG);
- CHECK(ssol_sun_pillbox_set_half_angle(sun, 999), RES_BAD_ARG);
- CHECK(ssol_sun_pillbox_set_half_angle(sun, 0.1), RES_BAD_ARG);
-
- CHECK(ssol_sun_set_buie_param(NULL, 0.1), RES_BAD_ARG);
- CHECK(ssol_sun_set_buie_param(sun, -0.1), RES_BAD_ARG);
- CHECK(ssol_sun_set_buie_param(sun, 999), RES_BAD_ARG);
- CHECK(ssol_sun_set_buie_param(sun, 0.1), RES_OK);
- CHECK(ssol_sun_set_buie_param(sun, 0.1), RES_OK);
-
- CHECK(ssol_sun_ref_put(sun), RES_OK);
-
- CHECK(ssol_spectrum_ref_put(spectrum), RES_OK);
- CHECK(ssol_spectrum_ref_put(spectrum2), RES_OK);
- CHECK(ssol_device_ref_put(dev), RES_OK);
+ CHK(ssol_device_create
+ (NULL, &allocator, SSOL_NTHREADS_DEFAULT, 0, &dev) == RES_OK);
+
+ CHK(ssol_spectrum_create(dev, &spectrum) == RES_OK);
+ CHK(ssol_spectrum_create(dev, &spectrum2) == RES_OK);
+
+ CHK(ssol_sun_create_directional(NULL, &sun) == RES_BAD_ARG);
+ CHK(ssol_sun_create_directional(dev, NULL) == RES_BAD_ARG);
+ CHK(ssol_sun_create_directional(dev, &sun) == RES_OK);
+
+ CHK(ssol_sun_ref_get(NULL) == RES_BAD_ARG);
+ CHK(ssol_sun_ref_get(sun) == RES_OK);
+
+ CHK(ssol_sun_ref_put(NULL) == RES_BAD_ARG);
+ CHK(ssol_sun_ref_put(sun) == RES_OK);
+
+ CHK(ssol_sun_set_spectrum(NULL, spectrum) == RES_BAD_ARG);
+ CHK(ssol_sun_set_spectrum(sun, NULL) == RES_BAD_ARG);
+ CHK(ssol_sun_set_spectrum(sun, spectrum) == RES_OK);
+ CHK(ssol_sun_set_spectrum(sun, spectrum) == RES_OK);
+
+ CHK(ssol_sun_set_direction(NULL, dir) == RES_BAD_ARG);
+ CHK(ssol_sun_set_direction(sun, NULL) == RES_BAD_ARG);
+ CHK(ssol_sun_set_direction(sun, dir0) == RES_BAD_ARG);
+ CHK(ssol_sun_set_direction(sun, dir) == RES_OK);
+ CHK(ssol_sun_set_direction(sun, dir) == RES_OK);
+
+ CHK(ssol_sun_get_direction(NULL, tmp) == RES_BAD_ARG);
+ CHK(ssol_sun_get_direction(sun, NULL) == RES_BAD_ARG);
+ CHK(ssol_sun_get_direction(sun, tmp) == RES_OK);
+ CHK(d3_eq(dir, tmp) == 1);
+
+ CHK(ssol_sun_set_dni(NULL, 1000) == RES_BAD_ARG);
+ CHK(ssol_sun_set_dni(sun, 0) == RES_BAD_ARG);
+ CHK(ssol_sun_set_dni(sun, 1000) == RES_OK);
+ CHK(ssol_sun_set_dni(sun, 1000) == RES_OK);
+
+ CHK(ssol_sun_get_dni(NULL, &dni) == RES_BAD_ARG);
+ CHK(ssol_sun_get_dni(sun, NULL) == RES_BAD_ARG);
+ CHK(ssol_sun_get_dni(sun, &dni) == RES_OK);
+ CHK(dni == 1000);
+
+ CHK(ssol_sun_pillbox_set_half_angle(NULL, 0.1) == RES_BAD_ARG);
+ CHK(ssol_sun_pillbox_set_half_angle(sun, -0.1) == RES_BAD_ARG);
+ CHK(ssol_sun_pillbox_set_half_angle(sun, 999) == RES_BAD_ARG);
+ CHK(ssol_sun_pillbox_set_half_angle(sun, 0.1) == RES_BAD_ARG);
+
+ CHK(ssol_sun_gaussian_set_std_dev(NULL, 0.1) == RES_BAD_ARG);
+ CHK(ssol_sun_gaussian_set_std_dev(sun, -0.1) == RES_BAD_ARG);
+ CHK(ssol_sun_gaussian_set_std_dev(sun, 0.1) == RES_BAD_ARG);
+
+ CHK(ssol_sun_set_buie_param(NULL, 0.1) == RES_BAD_ARG);
+ CHK(ssol_sun_set_buie_param(sun, -0.1) == RES_BAD_ARG);
+ CHK(ssol_sun_set_buie_param(sun, 999) == RES_BAD_ARG);
+ CHK(ssol_sun_set_buie_param(sun, 0.1) == RES_BAD_ARG);
+
+ CHK(ssol_sun_ref_put(sun) == RES_OK);
+
+ CHK(ssol_sun_create_pillbox(NULL, &sun) == RES_BAD_ARG);
+ CHK(ssol_sun_create_pillbox(dev, NULL) == RES_BAD_ARG);
+ CHK(ssol_sun_create_pillbox(dev, &sun) == RES_OK);
+
+ CHK(ssol_sun_ref_get(NULL) == RES_BAD_ARG);
+ CHK(ssol_sun_ref_get(sun) == RES_OK);
+
+ CHK(ssol_sun_ref_put(NULL) == RES_BAD_ARG);
+ CHK(ssol_sun_ref_put(sun) == RES_OK);
+
+ CHK(ssol_sun_set_spectrum(NULL, spectrum) == RES_BAD_ARG);
+ CHK(ssol_sun_set_spectrum(sun, NULL) == RES_BAD_ARG);
+ CHK(ssol_sun_set_spectrum(sun, spectrum) == RES_OK);
+ CHK(ssol_sun_set_spectrum(sun, spectrum2) == RES_OK);
+ CHK(ssol_sun_set_spectrum(sun, spectrum2) == RES_OK);
+
+ CHK(ssol_sun_set_direction(NULL, dir) == RES_BAD_ARG);
+ CHK(ssol_sun_set_direction(sun, NULL) == RES_BAD_ARG);
+ CHK(ssol_sun_set_direction(sun, dir0) == RES_BAD_ARG);
+ CHK(ssol_sun_set_direction(sun, dir) == RES_OK);
+ CHK(ssol_sun_set_direction(sun, dir) == RES_OK);
+
+ CHK(ssol_sun_get_direction(NULL, tmp) == RES_BAD_ARG);
+ CHK(ssol_sun_get_direction(sun, NULL) == RES_BAD_ARG);
+ CHK(ssol_sun_get_direction(sun, tmp) == RES_OK);
+ CHK(d3_eq(dir, tmp) == 1);
+
+ CHK(ssol_sun_set_dni(NULL, 1000) == RES_BAD_ARG);
+ CHK(ssol_sun_set_dni(sun, 0) == RES_BAD_ARG);
+ CHK(ssol_sun_set_dni(sun, 1000) == RES_OK);
+ CHK(ssol_sun_set_dni(sun, 1000) == RES_OK);
+
+ CHK(ssol_sun_get_dni(NULL, &dni) == RES_BAD_ARG);
+ CHK(ssol_sun_get_dni(sun, NULL) == RES_BAD_ARG);
+ CHK(ssol_sun_get_dni(sun, &dni) == RES_OK);
+ CHK(dni == 1000);
+
+ CHK(ssol_sun_pillbox_set_half_angle(NULL, 0.1) == RES_BAD_ARG);
+ CHK(ssol_sun_pillbox_set_half_angle(sun, -0.1) == RES_BAD_ARG);
+ CHK(ssol_sun_pillbox_set_half_angle(sun, 999) == RES_BAD_ARG);
+ CHK(ssol_sun_pillbox_set_half_angle(sun, 0.1) == RES_OK);
+ CHK(ssol_sun_pillbox_set_half_angle(sun, 0.1) == RES_OK);
+
+ CHK(ssol_sun_gaussian_set_std_dev(NULL, 0.1) == RES_BAD_ARG);
+ CHK(ssol_sun_gaussian_set_std_dev(sun, -0.1) == RES_BAD_ARG);
+ CHK(ssol_sun_gaussian_set_std_dev(sun, 0.1) == RES_BAD_ARG);
+
+ CHK(ssol_sun_set_buie_param(NULL, 0.1) == RES_BAD_ARG);
+ CHK(ssol_sun_set_buie_param(sun, -0.1) == RES_BAD_ARG);
+ CHK(ssol_sun_set_buie_param(sun, 999) == RES_BAD_ARG);
+ CHK(ssol_sun_set_buie_param(sun, 0.1) == RES_BAD_ARG);
+
+ CHK(ssol_sun_ref_put(sun) == RES_OK);
+
+ CHK(ssol_sun_create_gaussian(NULL, &sun) == RES_BAD_ARG);
+ CHK(ssol_sun_create_gaussian(dev, NULL) == RES_BAD_ARG);
+ CHK(ssol_sun_create_gaussian(dev, &sun) == RES_OK);
+
+ CHK(ssol_sun_ref_get(NULL) == RES_BAD_ARG);
+ CHK(ssol_sun_ref_get(sun) == RES_OK);
+
+ CHK(ssol_sun_ref_put(NULL) == RES_BAD_ARG);
+ CHK(ssol_sun_ref_put(sun) == RES_OK);
+
+ CHK(ssol_sun_set_spectrum(NULL, spectrum) == RES_BAD_ARG);
+ CHK(ssol_sun_set_spectrum(sun, NULL) == RES_BAD_ARG);
+ CHK(ssol_sun_set_spectrum(sun, spectrum) == RES_OK);
+ CHK(ssol_sun_set_spectrum(sun, spectrum2) == RES_OK);
+ CHK(ssol_sun_set_spectrum(sun, spectrum2) == RES_OK);
+
+ CHK(ssol_sun_set_direction(NULL, dir) == RES_BAD_ARG);
+ CHK(ssol_sun_set_direction(sun, NULL) == RES_BAD_ARG);
+ CHK(ssol_sun_set_direction(sun, dir0) == RES_BAD_ARG);
+ CHK(ssol_sun_set_direction(sun, dir) == RES_OK);
+ CHK(ssol_sun_set_direction(sun, dir) == RES_OK);
+
+ CHK(ssol_sun_get_direction(NULL, tmp) == RES_BAD_ARG);
+ CHK(ssol_sun_get_direction(sun, NULL) == RES_BAD_ARG);
+ CHK(ssol_sun_get_direction(sun, tmp) == RES_OK);
+ CHK(d3_eq(dir, tmp) == 1);
+
+ CHK(ssol_sun_set_dni(NULL, 1000) == RES_BAD_ARG);
+ CHK(ssol_sun_set_dni(sun, 0) == RES_BAD_ARG);
+ CHK(ssol_sun_set_dni(sun, 1000) == RES_OK);
+ CHK(ssol_sun_set_dni(sun, 1000) == RES_OK);
+
+ CHK(ssol_sun_get_dni(NULL, &dni) == RES_BAD_ARG);
+ CHK(ssol_sun_get_dni(sun, NULL) == RES_BAD_ARG);
+ CHK(ssol_sun_get_dni(sun, &dni) == RES_OK);
+ CHK(dni == 1000);
+
+ CHK(ssol_sun_pillbox_set_half_angle(NULL, 0.1) == RES_BAD_ARG);
+ CHK(ssol_sun_pillbox_set_half_angle(sun, -0.1) == RES_BAD_ARG);
+ CHK(ssol_sun_pillbox_set_half_angle(sun, 999) == RES_BAD_ARG);
+ CHK(ssol_sun_pillbox_set_half_angle(sun, 0.1) == RES_BAD_ARG);
+ CHK(ssol_sun_pillbox_set_half_angle(sun, 0.1) == RES_BAD_ARG);
+
+ CHK(ssol_sun_gaussian_set_std_dev(NULL, 0.1) == RES_BAD_ARG);
+ CHK(ssol_sun_gaussian_set_std_dev(sun, -0.1) == RES_BAD_ARG);
+ CHK(ssol_sun_gaussian_set_std_dev(sun, 0.1) == RES_OK);
+ CHK(ssol_sun_gaussian_set_std_dev(sun, 0.1) == RES_OK);
+
+ CHK(ssol_sun_set_buie_param(NULL, 0.1) == RES_BAD_ARG);
+ CHK(ssol_sun_set_buie_param(sun, -0.1) == RES_BAD_ARG);
+ CHK(ssol_sun_set_buie_param(sun, 999) == RES_BAD_ARG);
+ CHK(ssol_sun_set_buie_param(sun, 0.1) == RES_BAD_ARG);
+
+ CHK(ssol_sun_ref_put(sun) == RES_OK);
+
+ CHK(ssol_sun_create_buie(NULL, &sun) == RES_BAD_ARG);
+ CHK(ssol_sun_create_buie(dev, NULL) == RES_BAD_ARG);
+ CHK(ssol_sun_create_buie(dev, &sun) == RES_OK);
+
+ CHK(ssol_sun_ref_get(NULL) == RES_BAD_ARG);
+ CHK(ssol_sun_ref_get(sun) == RES_OK);
+
+ CHK(ssol_sun_ref_put(NULL) == RES_BAD_ARG);
+ CHK(ssol_sun_ref_put(sun) == RES_OK);
+
+ CHK(ssol_sun_set_spectrum(NULL, spectrum) == RES_BAD_ARG);
+ CHK(ssol_sun_set_spectrum(sun, NULL) == RES_BAD_ARG);
+ CHK(ssol_sun_set_spectrum(sun, spectrum) == RES_OK);
+ CHK(ssol_sun_set_spectrum(sun, spectrum) == RES_OK);
+
+ CHK(ssol_sun_set_direction(NULL, dir) == RES_BAD_ARG);
+ CHK(ssol_sun_set_direction(sun, NULL) == RES_BAD_ARG);
+ CHK(ssol_sun_set_direction(sun, dir0) == RES_BAD_ARG);
+ CHK(ssol_sun_set_direction(sun, dir) == RES_OK);
+ CHK(ssol_sun_set_direction(sun, dir) == RES_OK);
+
+ CHK(ssol_sun_get_direction(NULL, tmp) == RES_BAD_ARG);
+ CHK(ssol_sun_get_direction(sun, NULL) == RES_BAD_ARG);
+ CHK(ssol_sun_get_direction(sun, tmp) == RES_OK);
+ CHK(d3_eq(dir, tmp) == 1);
+
+ CHK(ssol_sun_set_dni(NULL, 1000) == RES_BAD_ARG);
+ CHK(ssol_sun_set_dni(sun, 0) == RES_BAD_ARG);
+ CHK(ssol_sun_set_dni(sun, 1000) == RES_OK);
+ CHK(ssol_sun_set_dni(sun, 1000) == RES_OK);
+
+ CHK(ssol_sun_get_dni(NULL, &dni) == RES_BAD_ARG);
+ CHK(ssol_sun_get_dni(sun, NULL) == RES_BAD_ARG);
+ CHK(ssol_sun_get_dni(sun, &dni) == RES_OK);
+ CHK(dni == 1000);
+
+ CHK(ssol_sun_pillbox_set_half_angle(NULL, 0.1) == RES_BAD_ARG);
+ CHK(ssol_sun_pillbox_set_half_angle(sun, -0.1) == RES_BAD_ARG);
+ CHK(ssol_sun_pillbox_set_half_angle(sun, 999) == RES_BAD_ARG);
+ CHK(ssol_sun_pillbox_set_half_angle(sun, 0.1) == RES_BAD_ARG);
+
+ CHK(ssol_sun_gaussian_set_std_dev(NULL, 0.1) == RES_BAD_ARG);
+ CHK(ssol_sun_gaussian_set_std_dev(sun, -0.1) == RES_BAD_ARG);
+ CHK(ssol_sun_gaussian_set_std_dev(sun, 0.1) == RES_BAD_ARG);
+
+ CHK(ssol_sun_set_buie_param(NULL, 0.1) == RES_BAD_ARG);
+ CHK(ssol_sun_set_buie_param(sun, -0.1) == RES_BAD_ARG);
+ CHK(ssol_sun_set_buie_param(sun, 999) == RES_BAD_ARG);
+ CHK(ssol_sun_set_buie_param(sun, 0.1) == RES_OK);
+ CHK(ssol_sun_set_buie_param(sun, 0.1) == RES_OK);
+
+ CHK(ssol_sun_ref_put(sun) == RES_OK);
+
+ CHK(ssol_spectrum_ref_put(spectrum) == RES_OK);
+ CHK(ssol_spectrum_ref_put(spectrum2) == RES_OK);
+ CHK(ssol_device_ref_put(dev) == RES_OK);
check_memory_allocator(&allocator);
mem_shutdown_proxy_allocator(&allocator);
- CHECK(mem_allocated_size(), 0);
+ CHK(mem_allocated_size() == 0);
return 0;
}
