commit 90111b058e4a7388fd5505b8a705cd1668431119
parent c15a9a41515a5d2433fbb2190bd0c83b153fbddb
Author: Vincent Forest <vincent.forest@meso-star.com>
Date: Tue, 11 Oct 2016 14:29:43 +0200
Change the ssol_instance_set_receiver API
Diffstat:
21 files changed, 154 insertions(+), 203 deletions(-)
diff --git a/src/ssol.h b/src/ssol.h
@@ -201,13 +201,17 @@ struct ssol_mirror_shader {
static const struct ssol_mirror_shader SSOL_MIRROR_SHADER_NULL =
SSOL_MIRROR_SHADER_NULL__;
-/* The type of data produced on receiver hits
- as ssol_solve() write them on its FILE* argument */
-struct receiver_data {
+/* The type of data produced on receiver hits as ssol_solve() write them on its
+ * FILE* argument */
+struct ssol_receiver_data {
uint64_t realization_id;
int64_t date;
uint32_t segment_id;
- uint32_t receiver_id;
+
+ /* Its absolute value is the identifier of an SSOL instance. A negative
+ * value means for back faces primitive */
+ int32_t receiver_id;
+
float wavelength;
float pos[3];
float in_dir[3];
@@ -377,12 +381,6 @@ SSOL_API res_T
ssol_shape_ref_put
(struct ssol_shape* shape);
-/* Retrieve the id of the shape */
-SSOL_API res_T
-ssol_shape_get_id
- (struct ssol_shape* shape,
- uint32_t* id);
-
/* Define a punched surface in local space, i.e. no translation & no orientation */
SSOL_API res_T
ssol_punched_surface_setup
@@ -484,8 +482,8 @@ ssol_instance_set_transform
SSOL_API res_T
ssol_instance_set_receiver
(struct ssol_instance* instance,
- const char* name_front, /* May be NULL <=> Front faces are no more receivers */
- const char* name_back); /* May be NULL <=> back faces are no more receivers */
+ const int front, /* Define wether or not front faces are receivers */
+ const int back); /* Define wheter or not back faces are receivers */
SSOL_API res_T
ssol_instance_set_target_mask
@@ -495,13 +493,14 @@ ssol_instance_set_target_mask
SSOL_API res_T
ssol_instance_dont_sample
-(struct ssol_instance* instance,
- const int dont_sample);
+ (struct ssol_instance* instance,
+ const int dont_sample);
+/* Retrieve the id of the shape */
SSOL_API res_T
-ssol_instance_is_attached
+ssol_instance_get_id
(struct ssol_instance* instance,
- char* is_attached);
+ uint32_t* id);
/*******************************************************************************
* Spectrum API - Collection of wavelengths with their associated data.
diff --git a/src/ssol_c.h b/src/ssol_c.h
@@ -17,12 +17,33 @@
#define SSOL_C_H
#include "ssol.h"
+#include "ssol_instance_c.h"
+
#include <star/s3d.h>
+#include <math.h>
+
#define SSOL_TO_S3D_POSITION S3D_POSITION
#define SSOL_TO_S3D_NORMAL S3D_ATTRIB_0
#define SSOL_TO_S3D_TEXCOORD S3D_ATTRIB_1
+/* hack until the needed API comes from a merge */
+#define FRONT_FLAG 0
+#define RECEIVER_ID_MASK 0x7FFFFFFF
+#define BACK_FLAG 0x80000000
+
+#ifndef NDEBUG
+ #define ASSERT_NAN(x, sz) { \
+ int i__; \
+ FOR_EACH(i__, 0, sz) \
+ ASSERT(!IS_NaN((x)[i__])); \
+ } (void)0
+#else
+ #define ASSERT_NAN(x, sz)
+#endif
+
+#define NON_BOOL 99
+
static FINLINE enum s3d_attrib_usage
ssol_to_s3d_attrib_usage(const enum ssol_attrib_usage usage)
{
@@ -42,41 +63,5 @@ hit_filter_function
void* realisation,
void* filter_data);
-#include <math.h>
-
-#ifndef NDEBUG
- #define ASSERT_NAN(x, sz) { \
- int i__; \
- FOR_EACH(i__, 0, sz) \
- ASSERT(!IS_NaN((x)[i__])); \
- } (void)0
-#else
- #define ASSERT_NAN(x, sz)
-#endif
-
-#define NON_BOOL 99
-
-/* hack until the needed API comes from a merge */
-#define FRONT_FLAG 0
-#define RECEIVER_ID_MASK 0x7FFFFFFF
-#define BACK_FLAG 0x80000000
-
-#include "ssol_instance_c.h"
-static FINLINE res_T
-get_receiver_id(struct ssol_instance* instance, const int front_face, uint32_t* id) {
- struct str* rec;
-
- if (!instance || !id)
- return RES_BAD_ARG;
- rec = front_face ? &instance->receiver_front : &instance->receiver_back;
- if (str_is_empty(rec))
- return RES_BAD_ARG;
-
- S3D(shape_get_id(instance->shape_rt, id));
- ASSERT((*id & RECEIVER_ID_MASK) == *id);
- *id |= (front_face ? FRONT_FLAG : BACK_FLAG);
- return RES_OK;
-}
-
#endif /* SSOL_C_H */
diff --git a/src/ssol_device_c.h b/src/ssol_device_c.h
@@ -16,11 +16,17 @@
#ifndef SSOL_DEVICE_C_H
#define SSOL_DEVICE_C_H
+#include <rsys/free_list.h>
#include <rsys/ref_count.h>
#include <star/s3d.h>
struct scpr_mesh;
+/* Declare the free list used to generate unique identifier */
+struct name { FITEM; };
+#define FITEM_TYPE name
+#include <rsys/free_list.h>
+
struct ssol_device {
struct logger* logger;
struct mem_allocator* allocator;
diff --git a/src/ssol_instance.c b/src/ssol_instance.c
@@ -43,8 +43,6 @@ instance_release(ref_T* ref)
SSOL(object_ref_put(instance->object));
if(instance->shape_rt) S3D(shape_ref_put(instance->shape_rt));
if(instance->shape_samp) S3D(shape_ref_put(instance->shape_samp));
- str_release(&instance->receiver_front);
- str_release(&instance->receiver_back);
MEM_RM(dev->allocator, instance);
SSOL(device_ref_put(dev));
}
@@ -61,7 +59,7 @@ ssol_object_instantiate
struct ssol_device* dev;
res_T res = RES_OK;
- if (!object || !out_instance) {
+ if(!object || !out_instance) {
res = RES_BAD_ARG;
goto error;
}
@@ -70,21 +68,19 @@ ssol_object_instantiate
ASSERT(dev && dev->allocator);
instance = (struct ssol_instance*)MEM_CALLOC
(dev->allocator, 1, sizeof(struct ssol_instance));
- if (!instance) {
+ if(!instance) {
res = RES_MEM_ERR;
goto error;
}
+ ref_init(&instance->ref);
+ SSOL(device_ref_get(dev));
+ SSOL(object_ref_get(object));
instance->dev = dev;
instance->object = object;
+ instance->target_front_mask = instance->target_back_mask = 0;
d33_set_identity(instance->transform);
d3_splat(instance->transform + 9, 0);
- instance->target_front_mask = instance->target_back_mask = 0;
- str_init(dev->allocator, &instance->receiver_front);
- str_init(dev->allocator, &instance->receiver_back);
- SSOL(object_ref_get(object));
- SSOL(device_ref_get(dev));
- ref_init(&instance->ref);
/* Create the Star-3D instance to ray-trace */
res = s3d_scene_instantiate(object->scn_rt, &instance->shape_rt);
@@ -98,7 +94,7 @@ exit:
if(out_instance) *out_instance = instance;
return res;
error:
- if (instance) {
+ if(instance) {
SSOL(instance_ref_put(instance));
instance = NULL;
}
@@ -118,7 +114,7 @@ res_T
ssol_instance_ref_put
(struct ssol_instance* instance)
{
- if (!instance)
+ if(!instance)
return RES_BAD_ARG;
ref_put(&instance->ref, instance_release);
return RES_OK;
@@ -158,39 +154,12 @@ error:
res_T
ssol_instance_set_receiver
- (struct ssol_instance* instance,
- const char* name_front,
- const char* name_back)
+ (struct ssol_instance* instance, const int front, const int back)
{
- struct str front;
- struct str back;
- res_T res = RES_OK;
-
if(!instance) return RES_BAD_ARG;
-
- str_init(instance->dev->allocator, &front);
- str_init(instance->dev->allocator, &back);
-
- if(name_front) {
- res = str_set(&front, name_front);
- if(res != RES_OK) goto error;
- }
- if(name_back) {
- res = str_set(&back, name_back);
- if(res != RES_OK) goto error;
- }
-
- res = str_copy_and_release(&instance->receiver_front, &front);
- ASSERT(res == RES_OK);
- res = str_copy_and_release(&instance->receiver_back, &back);
- ASSERT(res == RES_OK);
-
-exit:
- return res;
-error:
- str_release(&front);
- str_release(&back);
- goto exit;
+ instance->receiver_front = front;
+ instance->receiver_back = back;
+ return RES_OK;
}
res_T
@@ -199,7 +168,7 @@ ssol_instance_set_target_mask
const uint32_t front_mask,
const uint32_t back_mask)
{
- if (!instance)
+ if(!instance)
return RES_BAD_ARG;
instance->target_front_mask = front_mask;
@@ -212,19 +181,20 @@ ssol_instance_dont_sample
(struct ssol_instance* instance,
const int dont_sample)
{
- if (!instance)
- return RES_BAD_ARG;
-
+ if(!instance) return RES_BAD_ARG;
instance->dont_sample = dont_sample;
return RES_OK;
}
res_T
-ssol_instance_is_attached
- (struct ssol_instance* instance, char* is_attached)
+ssol_instance_get_id(struct ssol_instance* instance, uint32_t* id)
{
- FATAL("Not implemented yet.");
- if(!instance || !is_attached) return RES_BAD_ARG;
+ unsigned u;
+ STATIC_ASSERT
+ (sizeof(unsigned) <= sizeof(uint32_t), Unexpected_sizeof_unsigned);
+ if(!instance || !id) return RES_BAD_ARG;
+ S3D(shape_get_id(instance->shape_rt, &u));
+ *id = (uint32_t)u;
return RES_OK;
}
diff --git a/src/ssol_instance_c.h b/src/ssol_instance_c.h
@@ -16,20 +16,22 @@
#ifndef SSOL_INSTANCE_C_H
#define SSOL_INSTANCE_C_H
+#include <rsys/free_list.h>
#include <rsys/list.h>
#include <rsys/ref_count.h>
-#include <rsys/str.h>
struct ssol_instance {
struct ssol_object* object; /* Instantiated object */
struct s3d_shape* shape_rt; /* Instantiated Star-3D shape to ray-trace */
struct s3d_shape* shape_samp; /* Instantiated Star-3D shape to sample */
- struct str receiver_front; /* Empty if front faces are not receivers */
- struct str receiver_back; /* Empty if back faces are not receivers */
double transform[12]; /* Column major 4x3 affine transformation */
- uint32_t target_front_mask, target_back_mask;
+ uint32_t target_front_mask, target_back_mask; /* FIXME remove this? */
+ int receiver_front; /* Are front faces receivers */
+ int receiver_back; /* Are back faces receivers */
int dont_sample;
+ struct fid id; /* Unique identifier */
+
struct ssol_device* dev;
ref_T ref;
};
diff --git a/src/ssol_scene.c b/src/ssol_scene.c
@@ -291,8 +291,7 @@ scene_setup_s3d_sampling_scene
unsigned id;
htable_instance_iterator_next(&it);
- if(!str_is_empty(&inst->receiver_back)
- || !str_is_empty(&inst->receiver_front)) {
+ if(inst->receiver_back || inst->receiver_front) {
hr = 1;
}
@@ -341,10 +340,12 @@ hit_filter_function
struct ssol_instance* inst;
const struct shaded_shape* shaded_shape;
const struct ssol_shape* shape;
- const struct str* receiver_name;
struct realisation* rs = realisation;
struct segment* seg;
size_t id;
+ int is_receiver = 0;
+ uint32_t inst_id;
+ int32_t receiver_id;
(void) filter_data, (void) org, (void) dir;
ASSERT(rs);
@@ -418,25 +419,29 @@ hit_filter_function
return 1;
}
+ SSOL(instance_get_id(inst, &inst_id));
+ ASSERT(inst_id < INT32_MAX);
if(seg->hit_front) {
seg->hit_material = shaded_shape->mtl_front;
- receiver_name = &inst->receiver_front;
+ is_receiver = inst->receiver_front;
+ receiver_id = (int32_t)inst_id;
} else {
d3_muld(seg->hit_normal, seg->hit_normal, -1);
seg->hit_material = shaded_shape->mtl_back;
- receiver_name = &inst->receiver_back;
+ is_receiver = inst->receiver_back;
+ receiver_id = -(int32_t)inst_id;
}
- /* Check if the hit surface is a receiver that registers hit data
+ /* Check if the hit surface is a receiver that registers hit data
* impacts on receivers before sampled surfaces are not registered */
- if (!seg->sun_segment && !str_is_empty(receiver_name)) {
+ if (!seg->sun_segment && is_receiver) {
struct receiver_record candidate;
f3_set_d3(candidate.dir, seg->dir);
candidate.hit_distance = (float)seg->hit_distance;
f3_set_d3(candidate.hit_normal, seg->hit_normal);
f3_set_d3(candidate.hit_pos, seg->hit_pos);
candidate.instance = inst;
- get_receiver_id(inst, seg->hit_front, &candidate.receiver_id);
+ candidate.receiver_id = receiver_id;
f2_set(candidate.uv, seg->hit.uv);
darray_receiver_record_push_back(
&rs->data.receiver_record_candidates, &candidate);
diff --git a/src/ssol_scene_c.h b/src/ssol_scene_c.h
@@ -57,5 +57,12 @@ scene_setup_s3d_sampling_scene
char* has_sampled,
char* has_receiver);
+/* TODO comment */
+extern LOCAL_SYM res_T
+scene_create_s3d_views
+ (struct ssol_scene* scn,
+ struct s3d_scene_view** view_rt,
+ struct s3d_scene_view** view_samp);
+
#endif /* SSOL_SCENE_C_H */
diff --git a/src/ssol_shape.c b/src/ssol_shape.c
@@ -842,17 +842,6 @@ ssol_shape_ref_put(struct ssol_shape* shape)
}
res_T
-ssol_shape_get_id(struct ssol_shape* shape, uint32_t* id)
-{
- unsigned ui;
- STATIC_ASSERT(sizeof(unsigned) <= sizeof(uint32_t), Unexpected_sizeof_unsigned);
- if(!shape || !id) return RES_BAD_ARG;
- S3D(shape_get_id(shape->shape_rt, &ui));
- *id = (uint32_t)ui;
- return RES_OK;
-}
-
-res_T
ssol_punched_surface_setup
(struct ssol_shape* shape,
const struct ssol_punched_surface* psurf)
diff --git a/src/ssol_solver.c b/src/ssol_solver.c
@@ -565,10 +565,11 @@ static int
receive_sunlight(struct realisation* rs)
{
struct segment* seg;
- const struct str* receiver_name = NULL;
const struct ssol_sun* sun;
struct starting_point* start;
- uint32_t receiver_id;
+ int is_receiver = 0;
+ uint32_t inst_id;
+ int32_t receiver_id;
ASSERT(rs && rs->s_idx == 0);
seg = current_segment(rs);
@@ -645,28 +646,27 @@ receive_sunlight(struct realisation* rs)
seg->hit_normal, &start->sampl_primitive, start->uv);
/* if the sampled instance is a receiver, register the sampled point */
+ SSOL(instance_get_id(start->instance, &inst_id));
+ ASSERT(inst_id < INT32_MAX);
if(start->front_exposed) {
- receiver_name = &start->instance->receiver_front;
- receiver_id = FRONT_FLAG;
+ is_receiver = start->instance->receiver_front;
+ receiver_id = (int32_t)inst_id;
} else {
- receiver_name = &start->instance->receiver_back;
- receiver_id = BACK_FLAG;
+ is_receiver = start->instance->receiver_back;
+ receiver_id = -(int32_t)inst_id;
}
/* if the sampled instance holds a receiver, push a candidate */
- if(!str_is_empty(receiver_name)) {
- uint32_t id;
+ if(is_receiver) {
struct receiver_record candidate;
f3_set_d3(candidate.dir, seg->dir);
candidate.hit_distance = 0; /* no atmospheric attenuation for sun rays */
f3_set_d3(candidate.hit_normal, seg->hit_normal);
f3_set_d3(candidate.hit_pos, seg->hit_pos);
candidate.instance = start->instance;
- S3D(shape_get_id(start->instance->shape_rt, &id));
- ASSERT((id & RECEIVER_ID_MASK) == id);
- candidate.receiver_id = receiver_id | id;
+ candidate.receiver_id = receiver_id;
f2_set(candidate.uv, start->uv);
- darray_receiver_record_push_back(
- &rs->data.receiver_record_candidates, &candidate);
+ darray_receiver_record_push_back
+ (&rs->data.receiver_record_candidates, &candidate);
}
return 1;
@@ -703,7 +703,7 @@ filter_receiver_hit_candidates(struct realisation* rs)
candidates->hit_distance <= tmax && candidates < candidates_end;
candidates++)
{
- struct receiver_data out;
+ struct ssol_receiver_data out;
double weight;
if (candidates->hit_distance == prev_distance) {
size_t i = 0, is_duplicate = 0;
@@ -738,7 +738,7 @@ filter_receiver_hit_candidates(struct realisation* rs)
f3_set(out.normal, candidates->hit_normal);
out.weight = weight;
f2_set(out.uv, candidates->uv);
- fwrite(&out, sizeof(struct receiver_data), 1, rs->data.out_stream);
+ fwrite(&out, sizeof(struct ssol_receiver_data), 1, rs->data.out_stream);
rs->success = 1;
}
/* reset candidates */
@@ -843,4 +843,3 @@ error:
/* TODO: release data */
goto exit;
}
-
diff --git a/src/ssol_solver_c.h b/src/ssol_solver_c.h
@@ -76,7 +76,7 @@ struct starting_point {
struct receiver_record {
struct ssol_instance* instance;
- uint32_t receiver_id;
+ int32_t receiver_id;
float dir[4];
float hit_pos[3];
float uv[2];
diff --git a/src/test_ssol_instance.c b/src/test_ssol_instance.c
@@ -61,13 +61,8 @@ main(int argc, char** argv)
CHECK(ssol_instance_set_transform(instance, transform), RES_OK);
#define SET_RECEIVER ssol_instance_set_receiver
- CHECK(SET_RECEIVER(NULL, "receiver 1", NULL), RES_BAD_ARG);
- CHECK(SET_RECEIVER(instance, NULL, NULL), RES_OK);
- CHECK(SET_RECEIVER(instance, "receiver 1", NULL), RES_OK);
- CHECK(SET_RECEIVER(instance, "receiver 0", NULL), RES_OK);
- CHECK(SET_RECEIVER(instance, NULL, NULL), RES_OK);
- CHECK(SET_RECEIVER(instance, "receiver front", "receiver back"), RES_OK);
- CHECK(SET_RECEIVER(instance, NULL, "receiver back"), RES_OK);
+ CHECK(ssol_instance_set_receiver(NULL, 0, 0), RES_BAD_ARG);
+ CHECK(ssol_instance_set_receiver(instance, 0, 0), RES_OK);
#undef SET_RECEIVER
CHECK(ssol_instance_set_target_mask(NULL, 1, 1), RES_BAD_ARG);
diff --git a/src/test_ssol_shape.c b/src/test_ssol_shape.c
@@ -37,7 +37,6 @@ main(int argc, char** argv)
struct ssol_punched_surface punched_surface;
struct ssol_carving carving;
struct ssol_quadric quadric;
- uint32_t id;
double polygon[] = {
-1.0, -1.0, -1.0, 1.0, 1.0, 1.0, 1.0, -1.0, 0.f, -2.f
};
@@ -59,11 +58,6 @@ main(int argc, char** argv)
CHECK(ssol_shape_create_mesh(NULL, &shape), RES_BAD_ARG);
CHECK(ssol_shape_create_mesh(dev, &shape), RES_OK);
- CHECK(ssol_shape_get_id(NULL, NULL), RES_BAD_ARG);
- CHECK(ssol_shape_get_id(shape, NULL), RES_BAD_ARG);
- CHECK(ssol_shape_get_id(NULL, &id), RES_BAD_ARG);
- CHECK(ssol_shape_get_id(shape, &id), RES_OK);
-
CHECK(ssol_shape_ref_get(NULL), RES_BAD_ARG);
CHECK(ssol_shape_ref_get(shape), RES_OK);
diff --git a/src/test_ssol_solver1.c b/src/test_ssol_solver1.c
@@ -130,12 +130,12 @@ main(int argc, char** argv)
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, "miroir", NULL), RES_OK);
+ CHECK(ssol_instance_set_receiver(heliostat, 1, 0), RES_OK);
CHECK(ssol_instance_set_target_mask(heliostat, 0x1, 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, "secondaire", NULL), RES_OK);
+ CHECK(ssol_instance_set_receiver(secondary, 1, 0), RES_OK);
CHECK(ssol_instance_set_transform(secondary, transform1), RES_OK);
CHECK(ssol_instance_set_target_mask(secondary, 0x2, 0), RES_OK);
CHECK(ssol_scene_attach_instance(scene, secondary), RES_OK);
@@ -144,7 +144,7 @@ main(int argc, char** argv)
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, "cible", NULL), RES_OK);
+ CHECK(ssol_instance_set_receiver(target, 1, 0), RES_OK);
CHECK(ssol_instance_set_target_mask(target, 0x4, 0), RES_OK);
CHECK(ssol_scene_attach_instance(scene, target), RES_OK);
@@ -177,13 +177,13 @@ main(int argc, char** argv)
CHECK(ssol_solve(scene, rng, 10, stdout, estimator), RES_BAD_ARG); /* sun with undefined DNI */
CHECK(ssol_sun_set_dni(sun, 1000), RES_OK);
- CHECK(ssol_instance_set_receiver(heliostat, NULL, NULL), RES_OK);
- CHECK(ssol_instance_set_receiver(secondary, NULL, NULL), RES_OK);
- CHECK(ssol_instance_set_receiver(target, NULL, NULL), RES_OK);
+ 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, stdout, estimator), RES_BAD_ARG); /* no receiver in scene */
- CHECK(ssol_instance_set_receiver(heliostat, "miroir", NULL), RES_OK);
- CHECK(ssol_instance_set_receiver(secondary, "secondaire", NULL), RES_OK);
- CHECK(ssol_instance_set_receiver(target, "cible", NULL), RES_OK);
+ CHECK(ssol_instance_set_receiver(heliostat, 1, 0), RES_OK);
+ CHECK(ssol_instance_set_receiver(secondary, 1, 0), RES_OK);
+ CHECK(ssol_instance_set_receiver(target, 1, 0), RES_OK);
CHECK(ssol_spectrum_create(dev, &abs), RES_OK);
CHECK(ssol_spectrum_setup(abs, mismatch, ka, 2), RES_OK);
@@ -200,10 +200,10 @@ main(int argc, char** argv)
#define N__ 10000
CHECK(ssol_estimator_clear(estimator), RES_OK);
CHECK(ssol_solve(scene, rng, N__, tmp, estimator), RES_OK);
- CHECK(get_receiver_id(target, 1, &r_id), RES_OK);
+ CHECK(ssol_instance_get_id(target, &r_id), RES_OK);
CHECK(ssol_estimator_get_count(estimator, &count), RES_OK);
CHECK(count, N__);
- CHECK(pp_sum(tmp, r_id, count, &m, &std), RES_OK);
+ CHECK(pp_sum(tmp, (int32_t)r_id, count, &m, &std), RES_OK);
CHECK(fclose(tmp), 0);
CHECK(ssol_estimator_get_failed_count(estimator, &fcount), RES_OK);
CHECK(fcount, 0);
@@ -238,7 +238,7 @@ main(int argc, char** argv)
CHECK(ssol_solve(scene, rng, N__, tmp, estimator), RES_OK);
CHECK(ssol_estimator_get_count(estimator, &count), RES_OK);
CHECK(count, N__);
- CHECK(pp_sum(tmp, r_id, count, &m, &std), RES_OK);
+ CHECK(pp_sum(tmp, (int32_t)r_id, count, &m, &std), RES_OK);
CHECK(fclose(tmp), 0);
logger_print(&logger, LOG_OUTPUT, "\nP = %g +/- %g", m, std);
CHECK(eq_eps(m, 4 * DNI_cos, MMAX(4 * DNI_cos * 1e-2, std)), 1);
@@ -262,7 +262,7 @@ main(int argc, char** argv)
CHECK(ssol_solve(scene, rng, N__, tmp, estimator), RES_OK);
CHECK(ssol_estimator_get_count(estimator, &count), RES_OK);
CHECK(count, N__);
- CHECK(pp_sum(tmp, r_id, count, &m, &std), RES_OK);
+ CHECK(pp_sum(tmp, (int32_t)r_id, count, &m, &std), RES_OK);
CHECK(fclose(tmp), 0);
logger_print(&logger, LOG_OUTPUT, "\nP = %g +/- %g", m, std);
CHECK(eq_eps(m, 4 * DNI_cos, MMAX(4 * DNI_cos * 1e-2, std)), 1);
@@ -290,7 +290,7 @@ main(int argc, char** argv)
CHECK(ssol_solve(scene, rng, N__, tmp, estimator), RES_OK);
CHECK(ssol_estimator_get_count(estimator, &count), RES_OK);
CHECK(count, N__);
- CHECK(pp_sum(tmp, r_id, count, &m, &std), RES_OK);
+ CHECK(pp_sum(tmp, (int32_t)r_id, count, &m, &std), RES_OK);
CHECK(fclose(tmp), 0);
logger_print(&logger, LOG_OUTPUT, "\nP = %g +/- %g", m, std);
#define K (exp(-0.1 * 4 * sqrt(2)))
@@ -318,7 +318,7 @@ main(int argc, char** argv)
CHECK(ssol_solve(scene, rng, N__, tmp, estimator), RES_OK);
CHECK(ssol_estimator_get_count(estimator, &count), RES_OK);
CHECK(count, N__);
- CHECK(pp_sum(tmp, r_id, count, &m, &std), RES_OK);
+ CHECK(pp_sum(tmp, (int32_t)r_id, count, &m, &std), RES_OK);
CHECK(fclose(tmp), 0);
logger_print(&logger, LOG_OUTPUT, "\nP = %g +/- %g", m, std);
#define K2 (exp(-0.121 * 4 * sqrt(2)))
diff --git a/src/test_ssol_solver2.c b/src/test_ssol_solver2.c
@@ -155,8 +155,8 @@ main(int argc, char** argv)
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, "miroir", NULL), RES_OK);
- CHECK(ssol_instance_set_receiver(heliostat2, "miroir", NULL), RES_OK);
+ CHECK(ssol_instance_set_receiver(heliostat1, 1, 0), RES_OK);
+ CHECK(ssol_instance_set_receiver(heliostat2, 1, 0), RES_OK);
transform3[9] = -0.5; /* -0.5 offset along X axis */
CHECK(ssol_instance_set_transform(heliostat1, transform3), RES_OK);
transform3[9] = +0.5; /* +0.5 offset along X axis */
@@ -167,7 +167,7 @@ main(int argc, char** argv)
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, "secondaire", NULL), RES_OK);
+ CHECK(ssol_instance_set_receiver(secondary, 1, 0), RES_OK);
CHECK(ssol_instance_set_transform(secondary, transform1), RES_OK);
CHECK(ssol_instance_dont_sample(secondary, 1), RES_OK);
CHECK(ssol_scene_attach_instance(scene, secondary), RES_OK);
@@ -176,7 +176,7 @@ main(int argc, char** argv)
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, "cible", NULL), RES_OK);
+ CHECK(ssol_instance_set_receiver(target, 1, 0), RES_OK);
CHECK(ssol_instance_set_target_mask(target, 0x1, 0), RES_OK);
CHECK(ssol_instance_dont_sample(target, 1), RES_OK);
CHECK(ssol_scene_attach_instance(scene, target), RES_OK);
@@ -184,10 +184,10 @@ main(int argc, char** argv)
NCHECK(tmp = tmpfile(), 0);
#define N__ 10000
CHECK(ssol_solve(scene, rng, N__, tmp, estimator), RES_OK);
- CHECK(get_receiver_id(target, 1, &r_id), RES_OK);
+ CHECK(ssol_instance_get_id(target, &r_id), RES_OK);
CHECK(ssol_estimator_get_count(estimator, &count), RES_OK);
CHECK(count, N__);
- CHECK(pp_sum(tmp, r_id, count, &m, &std), RES_OK);
+ CHECK(pp_sum(tmp, (int32_t)r_id, count, &m, &std), RES_OK);
CHECK(fclose(tmp), 0);
logger_print(&logger, LOG_OUTPUT, "\nP = %g +/- %g\n", m, std);
#define DNI_cos (1000 * cos(PI / 4))
diff --git a/src/test_ssol_solver2b.c b/src/test_ssol_solver2b.c
@@ -160,8 +160,8 @@ main(int argc, char** argv)
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, "miroir", NULL), RES_OK);
- CHECK(ssol_instance_set_receiver(heliostat2, "miroir", NULL), RES_OK);
+ CHECK(ssol_instance_set_receiver(heliostat1, 1, 0), RES_OK);
+ CHECK(ssol_instance_set_receiver(heliostat2, 1, 0), RES_OK);
transform3[9] = -0.5; /* -0.5 offset along X axis */
CHECK(ssol_instance_set_transform(heliostat1, transform3), RES_OK);
transform3[9] = +0.5; /* +0.5 offset along X axis */
@@ -172,7 +172,7 @@ main(int argc, char** argv)
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, "secondaire", NULL), RES_OK);
+ CHECK(ssol_instance_set_receiver(secondary, 1, 0), RES_OK);
CHECK(ssol_instance_set_transform(secondary, transform1), RES_OK);
CHECK(ssol_instance_dont_sample(secondary, 1), RES_OK);
CHECK(ssol_scene_attach_instance(scene, secondary), RES_OK);
@@ -181,7 +181,7 @@ main(int argc, char** argv)
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, "cible", NULL), RES_OK);
+ CHECK(ssol_instance_set_receiver(target, 1, 0), RES_OK);
CHECK(ssol_instance_set_target_mask(target, 0x1, 0), RES_OK);
CHECK(ssol_instance_dont_sample(target, 1), RES_OK);
CHECK(ssol_scene_attach_instance(scene, target), RES_OK);
@@ -189,10 +189,10 @@ main(int argc, char** argv)
NCHECK(tmp = tmpfile(), 0);
#define N__ 50000
CHECK(ssol_solve(scene, rng, N__, tmp, estimator), RES_OK);
- CHECK(get_receiver_id(target, 1, &r_id), RES_OK);
+ CHECK(ssol_instance_get_id(target, &r_id), RES_OK);
CHECK(ssol_estimator_get_count(estimator, &count), RES_OK);
CHECK(count, N__);
- CHECK(pp_sum(tmp, r_id, count, &m, &std), RES_OK);
+ CHECK(pp_sum(tmp, (int32_t)r_id, count, &m, &std), RES_OK);
CHECK(fclose(tmp), 0);
logger_print(&logger, LOG_OUTPUT, "\nP = %g +/- %g\n", m, std);
#define DNI_cos (1000 * cos(PI / 4))
diff --git a/src/test_ssol_solver3.c b/src/test_ssol_solver3.c
@@ -128,14 +128,14 @@ main(int argc, char** argv)
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, "heliostat", NULL), RES_OK);
+ CHECK(ssol_instance_set_receiver(heliostat, 1, 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, "cible", NULL), RES_OK);
+ CHECK(ssol_instance_set_receiver(target, 1, 0), RES_OK);
CHECK(ssol_instance_set_target_mask(target, 0x1, 0), RES_OK);
CHECK(ssol_instance_dont_sample(target, 1), RES_OK);
CHECK(ssol_scene_attach_instance(scene, target), RES_OK);
@@ -143,10 +143,10 @@ main(int argc, char** argv)
NCHECK(tmp = tmpfile(), 0);
#define N__ 20000
CHECK(ssol_solve(scene, rng, N__, tmp, estimator), RES_OK);
- CHECK(get_receiver_id(target, 1, &r_id), RES_OK);
+ CHECK(ssol_instance_get_id(target, &r_id), RES_OK);
CHECK(ssol_estimator_get_count(estimator, &count), RES_OK);
CHECK(count, N__);
- CHECK(pp_sum(tmp, r_id, count, &m, &std), RES_OK);
+ CHECK(pp_sum(tmp, (int32_t)r_id, count, &m, &std), RES_OK);
CHECK(fclose(tmp), 0);
logger_print(&logger, LOG_OUTPUT, "\nP = %g +/- %g\n", m, std);
#define DNI_cos (1000 * cos(PI / 4))
diff --git a/src/test_ssol_solver3N.c b/src/test_ssol_solver3N.c
@@ -200,7 +200,7 @@ main(int argc, char** argv)
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, "cible", NULL), RES_OK);
+ CHECK(ssol_instance_set_receiver(target, 1, 0), RES_OK);
CHECK(ssol_instance_set_target_mask(target, 0x1, 0), RES_OK);
CHECK(ssol_instance_dont_sample(target, 1), RES_OK);
CHECK(ssol_scene_attach_instance(scene, target), RES_OK);
@@ -208,10 +208,10 @@ main(int argc, char** argv)
NCHECK(tmp = tmpfile(), 0);
#define N__ 10000
CHECK(ssol_solve(scene, rng, N__, tmp, estimator), RES_OK);
- CHECK(get_receiver_id(target, 1, &r_id), RES_OK);
+ CHECK(ssol_instance_get_id(target, &r_id), RES_OK);
CHECK(ssol_estimator_get_count(estimator, &count), RES_OK);
CHECK(count, N__);
- CHECK(pp_sum(tmp, r_id, count, &m, &std), RES_OK);
+ CHECK(pp_sum(tmp, (int32_t)r_id, count, &m, &std), RES_OK);
CHECK(fclose(tmp), 0);
logger_print(&logger, LOG_OUTPUT, "\nP = %g +/- %g\n", m, std);
#define DNI_cos (1000 * cos(PI / 8))
diff --git a/src/test_ssol_solver4.c b/src/test_ssol_solver4.c
@@ -136,13 +136,13 @@ main(int argc, char** argv)
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, "cible1", NULL), RES_OK);
+ CHECK(ssol_instance_set_receiver(target1, 1, 0), RES_OK);
CHECK(ssol_instance_set_target_mask(target1, 0x1, 0), RES_OK);
CHECK(ssol_instance_dont_sample(target1, 1), RES_OK);
CHECK(ssol_scene_attach_instance(scene, target1), RES_OK);
CHECK(ssol_object_instantiate(t_object, &target2), RES_OK);
CHECK(ssol_instance_set_transform(target2, transform), RES_OK);
- CHECK(ssol_instance_set_receiver(target2, "cible2", NULL), RES_OK);
+ CHECK(ssol_instance_set_receiver(target2, 1, 0), RES_OK);
CHECK(ssol_instance_set_target_mask(target2, 0x1, 0), RES_OK);
CHECK(ssol_instance_dont_sample(target2, 1), RES_OK);
CHECK(ssol_scene_attach_instance(scene, target2), RES_OK);
@@ -150,12 +150,12 @@ main(int argc, char** argv)
NCHECK(tmp = tmpfile(), 0);
#define N__ 10000
CHECK(ssol_solve(scene, rng, N__, tmp, estimator), RES_OK);
- CHECK(get_receiver_id(target1, 1, &r_id1), RES_OK);
- CHECK(get_receiver_id(target2, 1, &r_id2), RES_OK);
+ CHECK(ssol_instance_get_id(target1, &r_id1), RES_OK);
+ CHECK(ssol_instance_get_id(target2, &r_id2), RES_OK);
CHECK(ssol_estimator_get_count(estimator, &count), RES_OK);
CHECK(count, N__);
- CHECK(pp_sum(tmp, r_id1, count, &m1, &std1), RES_OK);
- CHECK(pp_sum(tmp, r_id2, count, &m2, &std2), RES_OK);
+ CHECK(pp_sum(tmp, (int32_t)r_id1, count, &m1, &std1), RES_OK);
+ CHECK(pp_sum(tmp, (int32_t)r_id2, count, &m2, &std2), RES_OK);
CHECK(fclose(tmp), 0);
logger_print(&logger, LOG_OUTPUT, "\nP = %g +/- %g\n", m1, std1);
#define DNI_cos (1000 * cos(0))
diff --git a/src/test_ssol_solver5.c b/src/test_ssol_solver5.c
@@ -135,7 +135,7 @@ main(int argc, char** argv)
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, "cible", NULL), RES_OK);
+ CHECK(ssol_instance_set_receiver(target, 1, 0), RES_OK);
CHECK(ssol_instance_set_target_mask(target, 0x1, 0), RES_OK);
CHECK(ssol_instance_dont_sample(target, 1), RES_OK);
CHECK(ssol_scene_attach_instance(scene, target), RES_OK);
@@ -143,10 +143,10 @@ main(int argc, char** argv)
NCHECK(tmp = tmpfile(), 0);
#define N__ 10000
CHECK(ssol_solve(scene, rng, N__, tmp, estimator), RES_OK);
- CHECK(get_receiver_id(target, 1, &r_id), RES_OK);
+ CHECK(ssol_instance_get_id(target, &r_id), RES_OK);
CHECK(ssol_estimator_get_count(estimator, &count), RES_OK);
CHECK(count, N__);
- CHECK(pp_sum(tmp, r_id, count, &m, &std), RES_OK);
+ CHECK(pp_sum(tmp, (int32_t)r_id, count, &m, &std), RES_OK);
CHECK(fclose(tmp), 0);
logger_print(&logger, LOG_OUTPUT, "\nP = %g +/- %g\n", m, std);
#define DNI_cos (1000 * cos(0))
diff --git a/src/test_ssol_utils.c b/src/test_ssol_utils.c
@@ -27,12 +27,12 @@
res_T
pp_sum
(FILE* f,
- const uint32_t receiver_id,
+ const int32_t receiver_id,
const size_t count,
double* mean,
double* std)
{
- struct receiver_data hit;
+ struct ssol_receiver_data hit;
double sum = 0;
double sum2 = 0;
double E, V, SE;
@@ -41,7 +41,7 @@ pp_sum
return RES_BAD_ARG;
rewind(f);
- while (1 == fread(&hit, sizeof(struct receiver_data), 1, f)) {
+ while (1 == fread(&hit, sizeof(struct ssol_receiver_data), 1, f)) {
if (ferror(f))
return RES_BAD_ARG;
diff --git a/src/test_ssol_utils.h b/src/test_ssol_utils.h
@@ -41,7 +41,7 @@ check_memory_allocator(struct mem_allocator* allocator)
extern LOCAL_SYM res_T
pp_sum
(FILE* f,
- const uint32_t receiver_id,
+ const int32_t receiver_id,
const size_t count,
double* mean,
double* std);
