void DirectLightingIntegrator::add_non_physical_light_sample_contribution( const LightSample& sample, Spectrum& radiance, SpectrumStack& aovs) { const Light* light = sample.m_light; // No contribution if we are computing indirect lighting but this light does not cast indirect light. if (m_indirect && !(light->get_flags() & Light::CastIndirectLight)) return; // Evaluate the light. InputEvaluator input_evaluator(m_shading_context.get_texture_cache()); Vector3d emission_position, emission_direction; Spectrum light_value; light->evaluate( input_evaluator, sample.m_light_transform.point_to_local(m_point), emission_position, emission_direction, light_value); // Transform the emission position and direction from assembly space to world space. emission_position = sample.m_light_transform.point_to_parent(emission_position); emission_direction = normalize(sample.m_light_transform.vector_to_parent(emission_direction)); // Compute the incoming direction in world space. const Vector3d incoming = -emission_direction; // Cull light samples behind the shading surface. double cos_in = dot(incoming, m_shading_basis.get_normal()); if (m_bsdf.get_type() == BSDF::Transmissive) cos_in = -cos_in; if (cos_in <= 0.0) return; // Compute the transmission factor between the light sample and the shading point. const double transmission = m_shading_context.get_tracer().trace_between( m_shading_point, emission_position, ShadingRay::ShadowRay); // Discard occluded samples. if (transmission == 0.0) return; // Evaluate the BSDF. Spectrum bsdf_value; const double bsdf_prob = m_bsdf.evaluate( m_bsdf_data, false, // not adjoint true, // multiply by |cos(incoming, normal)| m_geometric_normal, m_shading_basis, m_outgoing, incoming, m_light_sampling_modes, bsdf_value); if (bsdf_prob == 0.0) return; // Add the contribution of this sample to the illumination. const double attenuation = light->compute_distance_attenuation(m_point, emission_position); const double weight = (transmission * attenuation) / sample.m_probability; light_value *= static_cast<float>(weight); light_value *= bsdf_value; radiance += light_value; aovs.add(light->get_render_layer_index(), light_value); }
void DirectLightingIntegrator::take_single_bsdf_sample( SamplingContext& sampling_context, const MISHeuristic mis_heuristic, const Dual3d& outgoing, Spectrum& radiance, SpectrumStack& aovs) const { assert(m_light_sampler.get_emitting_triangle_count() > 0); // Sample the BSDF. BSDFSample sample(m_shading_point, outgoing); m_bsdf.sample( sampling_context, m_bsdf_data, false, // not adjoint true, // multiply by |cos(incoming, normal)| sample); // Filter scattering modes. if (!(m_bsdf_sampling_modes & sample.m_mode)) return; // Trace a ray in the direction of the reflection. double weight; const ShadingPoint& light_shading_point = m_shading_context.get_tracer().trace( m_shading_point, sample.m_incoming.get_value(), VisibilityFlags::ShadowRay, weight); // todo: wouldn't it be more efficient to look the environment up at this point? if (!light_shading_point.hit()) return; // Retrieve the material at the intersection point. const Material* material = light_shading_point.get_material(); if (material == 0) return; const Material::RenderData& material_data = material->get_render_data(); // Retrieve the EDF at the intersection point. const EDF* edf = material_data.m_edf; if (edf == 0) return; // No contribution if we are computing indirect lighting but this light does not cast indirect light. if (m_indirect && !(edf->get_flags() & EDF::CastIndirectLight)) return; // Cull the samples on the back side of the lights' shading surface. const double cos_on = dot(-sample.m_incoming.get_value(), light_shading_point.get_shading_normal()); if (cos_on <= 0.0) return; #ifdef APPLESEED_WITH_OSL if (material_data.m_shader_group) { m_shading_context.execute_osl_emission( *material_data.m_shader_group, light_shading_point); } #endif // Evaluate the EDF inputs. InputEvaluator edf_input_evaluator(m_shading_context.get_texture_cache()); edf->evaluate_inputs(edf_input_evaluator, light_shading_point); // Evaluate emitted radiance. Spectrum edf_value; double edf_prob; edf->evaluate( edf_input_evaluator.data(), light_shading_point.get_geometric_normal(), light_shading_point.get_shading_basis(), -sample.m_incoming.get_value(), edf_value, edf_prob); if (edf_prob == 0.0) return; // Compute the square distance between the light sample and the shading point. const double square_distance = square(light_shading_point.get_distance()); // Don't use this sample if we're closer than the light near start value. if (square_distance < square(edf->get_light_near_start())) return; if (mis_heuristic != MISNone && square_distance > 0.0) { // Transform bsdf_prob to surface area measure (Veach: 8.2.2.2 eq. 8.10). const double bsdf_prob_area = sample.m_probability * cos_on / square_distance; // Compute the probability density wrt. surface area mesure of the light sample. const double light_prob_area = m_light_sampler.evaluate_pdf(light_shading_point); // Apply the weighting function. weight *= mis( mis_heuristic, m_bsdf_sample_count * bsdf_prob_area, m_light_sample_count * light_prob_area); } // Add the contribution of this sample to the illumination. edf_value *= static_cast<float>(weight / sample.m_probability); edf_value *= sample.m_value; radiance += edf_value; aovs.add(edf->get_render_layer_index(), edf_value); }
void DirectLightingIntegrator::add_emitting_triangle_sample_contribution( const LightSample& sample, const MISHeuristic mis_heuristic, const Dual3d& outgoing, Spectrum& radiance, SpectrumStack& aovs) const { const Material* material = sample.m_triangle->m_material; const Material::RenderData& material_data = material->get_render_data(); const EDF* edf = material_data.m_edf; // No contribution if we are computing indirect lighting but this light does not cast indirect light. if (m_indirect && !(edf->get_flags() & EDF::CastIndirectLight)) return; // Compute the incoming direction in world space. Vector3d incoming = sample.m_point - m_point; // Cull light samples behind the shading surface if the BSDF is either reflective or transmissive, // but not both. if (m_bsdf.get_type() != BSDF::AllBSDFTypes) { double cos_in = dot(incoming, m_shading_basis.get_normal()); if (m_bsdf.get_type() == BSDF::Transmissive) cos_in = -cos_in; if (cos_in <= 0.0) return; } // No contribution if the shading point is behind the light. double cos_on = dot(-incoming, sample.m_shading_normal); if (cos_on <= 0.0) return; // Compute the transmission factor between the light sample and the shading point. const double transmission = m_shading_context.get_tracer().trace_between( m_shading_point, sample.m_point, VisibilityFlags::ShadowRay); // Discard occluded samples. if (transmission == 0.0) return; // Compute the square distance between the light sample and the shading point. const double square_distance = square_norm(incoming); const double rcp_sample_square_distance = 1.0 / square_distance; const double rcp_sample_distance = sqrt(rcp_sample_square_distance); // Don't use this sample if we're closer than the light near start value. if (square_distance < square(edf->get_light_near_start())) return; // Normalize the incoming direction. incoming *= rcp_sample_distance; cos_on *= rcp_sample_distance; // Evaluate the BSDF. Spectrum bsdf_value; const double bsdf_prob = m_bsdf.evaluate( m_bsdf_data, false, // not adjoint true, // multiply by |cos(incoming, normal)| m_geometric_normal, m_shading_basis, outgoing.get_value(), incoming, m_light_sampling_modes, bsdf_value); if (bsdf_prob == 0.0) return; // Build a shading point on the light source. ShadingPoint light_shading_point; sample.make_shading_point( light_shading_point, sample.m_shading_normal, m_shading_context.get_intersector()); #ifdef APPLESEED_WITH_OSL if (material_data.m_shader_group) { m_shading_context.execute_osl_emission( *material_data.m_shader_group, light_shading_point); } #endif // Evaluate the EDF inputs. InputEvaluator edf_input_evaluator(m_shading_context.get_texture_cache()); edf->evaluate_inputs(edf_input_evaluator, light_shading_point); // Evaluate the EDF. Spectrum edf_value; edf->evaluate( edf_input_evaluator.data(), sample.m_geometric_normal, Basis3d(sample.m_shading_normal), -incoming, edf_value); const double g = cos_on * rcp_sample_square_distance; double weight = transmission * g / sample.m_probability; // Apply MIS weighting. weight *= mis( mis_heuristic, m_light_sample_count * sample.m_probability, m_bsdf_sample_count * bsdf_prob * g); // Add the contribution of this sample to the illumination. edf_value *= static_cast<float>(weight); edf_value *= bsdf_value; radiance += edf_value; aovs.add(edf->get_render_layer_index(), edf_value); }
void DirectLightingIntegrator::add_light_sample_contribution( const LightSample& sample, Spectrum& radiance, SpectrumStack& aovs) { // Compute the incoming direction in world space. Vector3d incoming = sample.m_point - m_point; // Cull light samples behind the shading surface. double cos_in = dot(incoming, m_shading_basis.get_normal()); if (m_bsdf.get_type() == BSDF::Transmissive) cos_in = -cos_in; if (cos_in <= 0.0) return; // Compute the transmission factor between the light sample and the shading point. const double transmission = m_shading_context.get_tracer().trace_between( m_point, sample.m_point, m_time, m_parent_shading_point); // Discard occluded samples. if (transmission == 0.0) return; // Compute the square distance between the light sample and the shading point. const double rcp_sample_square_distance = 1.0 / square_norm(incoming); const double rcp_sample_distance = sqrt(rcp_sample_square_distance); // Normalize the incoming direction. incoming *= rcp_sample_distance; cos_in *= rcp_sample_distance; // Evaluate the BSDF. Spectrum bsdf_value; const double bsdf_prob = m_bsdf.evaluate( m_bsdf_data, false, // not adjoint true, // multiply by |cos(incoming, normal)| m_geometric_normal, m_shading_basis, m_outgoing, incoming, m_bsdf_modes, bsdf_value); if (bsdf_prob == 0.0) return; const Light* light = sample.m_light; // Evaluate the input values of the light. InputEvaluator light_input_evaluator(m_shading_context.get_texture_cache()); light->evaluate_inputs(light_input_evaluator, -incoming); // Evaluate the light. Spectrum light_value; light->evaluate( light_input_evaluator.data(), -incoming, light_value); // Add the contribution of this sample to the illumination. const double weight = transmission * rcp_sample_square_distance / sample.m_probability; light_value *= static_cast<float>(weight); light_value *= bsdf_value; radiance += light_value; aovs.add(light->get_render_layer_index(), radiance); }