24 return M_2PI_F * (1 - cos_theta_o) +
26 2 *
theta_o * sin_theta_o + cos_theta_o);
46 const float cos_a_b =
dot(a->
axis,
b->axis);
57 const float theta_o = (theta_d + a->
theta_o +
b->theta_o) * 0.5f;
65 if (cos_a_b < -0.9995f) {
71 const float theta_r = theta_o - a->
theta_o;
73 new_axis = a->
axis *
cosf(theta_r) + ortho *
sinf(theta_r);
88 bool need_transformation)
95 Mesh *mesh =
static_cast<Mesh *
>(
object->get_geometry());
97 Shader *shader =
static_cast<Shader *
>(mesh->get_used_shaders()[mesh->get_shader()[
prim_id]]);
100 for (
int i = 0; i < 3; i++) {
101 vertices[i] = mesh_positions[triangle.
v[i]];
104 if (need_transformation) {
106 const Transform &tfm =
object->get_tfm();
107 for (
int i = 0; i < 3; i++) {
113 const float area =
triangle_area(vertices[0], vertices[1], vertices[2]);
120 centroid = (vertices[0] + vertices[1] + vertices[2]) * (1.0f / 3.0f);
124 if (is_front_only || is_back_only) {
127 cross(vertices[1] - vertices[0], vertices[2] - vertices[0]));
145 for (
int i = 0; i < 3; i++) {
153 Light *lamp =
static_cast<Light *
>(
object->get_geometry());
154 float3 strength = lamp->get_strength();
156 if (!lamp->get_normalize()) {
157 strength *= lamp->
area(object->get_tfm());
173 const float3 half_extentu = 0.5f * light->get_sizeu() * axisu;
174 const float3 half_extentv = 0.5f * light->get_sizev() * axisv;
249 std::sort(emitters + start,
257bool LightTree::triangle_usable_as_light(
Mesh *mesh,
const int prim_id)
259 const int shader_index = mesh->get_shader()[prim_id];
260 if (shader_index < mesh->get_used_shaders().
size()) {
261 Shader *shader =
static_cast<Shader *
>(mesh->get_used_shaders()[shader_index]);
269void LightTree::add_mesh(
Scene *scene,
Mesh *mesh,
const int object_id)
272 for (
size_t i = 0; i < mesh_num_triangles; i++) {
273 if (triangle_usable_as_light(mesh, i)) {
274 emitters_.emplace_back(scene, i, object_id);
282 const uint max_lights_in_leaf)
283 : progress_(progress), max_lights_in_leaf_(max_lights_in_leaf)
285 KernelIntegrator *kintegrator = &dscene->
data.integrator;
287 local_lights_.reserve(kintegrator->num_lights - kintegrator->num_distant_lights);
288 distant_lights_.reserve(kintegrator->num_distant_lights);
293 int device_light_index = 0;
295 if (progress_.get_cancel()) {
299 if (object->get_geometry()->is_light()) {
301 Light *light = static_cast<Light *>(object->get_geometry());
302 if (light->is_enabled) {
303 if (light->is_distant_light()) {
304 distant_lights_.emplace_back(scene, ~device_light_index, object->index);
307 local_lights_.emplace_back(scene, ~device_light_index, object->index);
310 device_light_index++;
315 light_link_receiver_used |= (
uint64_t(1) <<
object->get_receiver_light_set());
317 if (!object->usable_as_light()) {
321 mesh_lights_.emplace_back(
object, object->index);
324 Mesh *mesh =
static_cast<Mesh *
>(
object->get_geometry());
325 auto map_it = offset_map_.find(mesh);
326 if (map_it == offset_map_.end()) {
327 offset_map_[mesh] = num_triangles;
336 if (local_lights_.empty() && distant_lights_.empty() && mesh_lights_.empty()) {
340 const int num_mesh_lights = mesh_lights_.size();
341 int num_local_lights = local_lights_.size() + num_mesh_lights;
342 const int num_distant_lights = distant_lights_.size();
345 std::unordered_map<Mesh *, std::tuple<LightTreeNode *, int, int>> unique_mesh;
347 emitters_.reserve(
num_triangles + num_local_lights + num_distant_lights);
350 Mesh *mesh =
static_cast<Mesh *
>(
object->get_geometry());
353 auto map_it = unique_mesh.find(mesh);
354 if (map_it == unique_mesh.end()) {
355 const int start = emitters_.size();
356 add_mesh(scene, mesh, emitter.object_id);
357 const int end = emitters_.size();
359 unique_mesh[mesh] = std::make_tuple(emitter.root.get(), start, end);
360 emitter.root->object_id = emitter.object_id;
363 emitter.root->make_instance(std::get<0>(map_it->second), emitter.object_id);
365 object_offsets[emitter.object_id] = offset_map_[mesh];
369 parallel_for_each(unique_mesh, [
this](
auto &map_it) {
371 int const start = std::get<1>(map_it.second);
372 int const end = std::get<2>(map_it.second);
373 recursive_build(
self,
node, start, end, emitters_.data(), 0, 0);
376 task_pool.wait_work();
381 Mesh *mesh =
static_cast<Mesh *
>(
object->get_geometry());
383 LightTreeNode *reference = std::get<0>(unique_mesh.find(mesh)->second);
396 for (
size_t i = 0; i < mesh_num_triangles; i++) {
397 if (triangle_usable_as_light(mesh, i)) {
409 const int num_emissive_triangles = emitters_.size();
410 num_local_lights += num_emissive_triangles;
416 std::move(local_lights_.begin(), local_lights_.end(), std::back_inserter(emitters_));
417 std::move(mesh_lights_.begin(), mesh_lights_.end(), std::back_inserter(emitters_));
419 left, root_.get(), num_emissive_triangles, num_local_lights, emitters_.data(), 0, 1);
420 task_pool.wait_work();
422 if (progress_.get_cancel()) {
429 for (
int i = 0; i < num_distant_lights; i++) {
430 root_->get_inner().children[
right]->add(distant_lights_[i]);
433 sort_leaf(0, num_distant_lights, distant_lights_.data());
434 root_->get_inner().children[
right]->make_distant(num_local_lights, num_distant_lights);
436 root_->measure = root_->get_inner().children[
left]->measure +
437 root_->get_inner().children[
right]->measure;
438 root_->light_link = root_->get_inner().children[
left]->light_link +
439 root_->get_inner().children[
right]->light_link;
444 root_->light_link.shareable =
false;
446 std::move(distant_lights_.begin(), distant_lights_.end(), std::back_inserter(emitters_));
451void LightTree::recursive_build(
const Child child,
456 const uint bit_trail,
477 if (should_split(emitters, start, middle, end,
node->measure,
node->light_link, split_dim)) {
479 if (split_dim != -1) {
481 std::nth_element(emitters + start,
484 [split_dim](
const LightTreeEmitter &l,
const LightTreeEmitter &r) {
485 return l.centroid[split_dim] < r.
centroid[split_dim];
490 if (middle - start > MIN_EMITTERS_PER_THREAD) {
491 task_pool.push([
this,
node, start, middle, emitters, bit_trail, depth] {
492 recursive_build(
left,
node, start, middle, emitters, bit_trail, depth + 1);
496 recursive_build(
left,
node, start, middle, emitters, bit_trail, depth + 1);
500 if (end - middle > MIN_EMITTERS_PER_THREAD) {
501 task_pool.push([
this,
node, middle, end, emitters, bit_trail, depth] {
502 recursive_build(
right,
node, middle, end, emitters, bit_trail | (1u << depth), depth + 1);
506 recursive_build(
right,
node, middle, end, emitters, bit_trail | (1u << depth), depth + 1);
511 node->make_leaf(start, end - start);
527 measure = emitters[start].
measure;
533 middle = (start + end) / 2;
536 for (
int i = start; i < end; i++) {
537 centroid_bbox.
grow((emitters + i)->centroid);
541 const float max_extent =
max4(extent.
x, extent.
y, extent.
z, 0.0f);
544 float total_cost = 0.0f;
546 for (
int dim = 0; dim < 3; dim++) {
547 std::array<LightTreeBucket, LightTreeBucket::num_buckets> buckets;
550 if (centroid_bbox.
size()[dim] == 0.0f) {
559 for (
int i = start; i < end; i++) {
560 buckets[0].add(emitters[i]);
565 inv_extent = 1 / (centroid_bbox.
size()[dim]);
566 for (
int i = start; i < end; i++) {
567 const LightTreeEmitter *emitter = emitters + i;
572 (emitter->
centroid[dim] - centroid_bbox.
min[dim]) * inv_extent;
575 buckets[bucket_idx].add(*emitter);
581 left_buckets.front() = buckets.front();
583 left_buckets[i] = left_buckets[i - 1] + buckets[i];
588 measure = left_buckets.back().measure + buckets.back().measure;
589 light_link = left_buckets.back().light_link + buckets.back().light_link;
597 if (centroid_bbox.
size()[dim] == 0.0f) {
602 if (total_cost == 0.0f) {
609 right_buckets.back() = buckets.back();
611 right_buckets[i] = right_buckets[i + 1] + buckets[i + 1];
615 const float regularization = max_extent * inv_extent;
617 const float left_cost = left_buckets[
split].measure.calculate();
618 const float right_cost = right_buckets[
split].measure.calculate();
619 const float cost = regularization * (left_cost + right_cost);
621 if (cost < total_cost && cost < min_cost) {
624 middle = start + left_buckets[
split].count;
628 return min_cost < total_cost || num_emitters > max_lights_in_leaf_;
unsigned long long int uint64_t
__forceinline float3 size() const
__forceinline void grow(const float3 &pt)
device_vector< uint > object_lookup_offset
const packed_float3 * get_position() const
LightTree(Scene *scene, DeviceScene *dscene, Progress &progress, const uint max_lights_in_leaf)
unique_ptr< LightTreeNode > create_node(const LightTreeMeasure &measure, const uint &bit_trial)
LightTreeNode * build(Scene *scene, DeviceScene *dscene)
size_t num_emitters() const
bool is_spot_light() const
bool is_sun_light() const
virtual float area(const Transform &tfm) const =0
Shader * get_shader() const
bool is_background_light() const
bool is_point_light() const
bool is_area_light() const
size_t num_triangles() const
Triangle get_triangle(const size_t i) const
unique_ptr_vector< Object > objects
EmissionSampling emission_sampling
T * alloc(const size_t width, const size_t height=0)
#define CCL_NAMESPACE_END
#define assert(assertion)
float dot(VecOp< float, D >, VecOp< float, D >) RET
VecBase< float, 3 > cross(VecOp< float, 3 >, VecOp< float, 3 >) RET
constexpr T clamp(T, U, U) RET
VecBase< float, 3 > float3
VecT safe_normalize(VecT vector)
@ EMISSION_SAMPLING_FRONT
static void sort_leaf(const int start, const int end, LightTreeEmitter *emitters)
__forceinline LightTreeMeasure operator+(const LightTreeMeasure &a, const LightTreeMeasure &b)
OrientationBounds merge(const OrientationBounds &cone_a, const OrientationBounds &cone_b)
ccl_device float safe_acosf(const float a)
ccl_device_inline T max4(const T &a, const T &b, const T &c, const T &d)
ccl_device_inline dual1 len(const ccl_private dual< T > &a)
ccl_device_inline dual3 fabs(const ccl_private dual3 &a)
ccl_device float fast_tanf(float x)
ccl_device float fast_atanf(const float x)
ccl_device_inline float triangle_area(const ccl_private float3 &v1, const ccl_private float3 &v2, const ccl_private float3 &v3)
ccl_device_inline void make_orthonormals(const float3 N, ccl_private float3 *a, ccl_private float3 *b)
int size(const AssetLibraryReference *library_reference)
void split(const std::string &s, const char delim, std::vector< std::string > &tokens)
ATTR_WARN_UNUSED_RESULT const BMLoop * l
LightTreeBucket()=default
LightTreeLightLink light_link
static const int num_buckets
__forceinline bool is_triangle() const
unique_ptr< LightTreeNode > root
uint64_t light_set_membership
LightTreeEmitter(Object *object, const int object_id)
__forceinline bool is_light() const
void add(const uint64_t prim_set_membership)
LightTreeLightLink()=default
bool transform(const Transform &tfm)
__forceinline void reset()
__forceinline float calculate()
__forceinline void add(const LightTreeMeasure &measure)
unique_ptr< LightTreeNode > children[2]
__forceinline Inner & get_inner()
__forceinline bool is_empty() const
__forceinline OrientationBounds()=default
float calculate_measure() const