Welcome to mirror list, hosted at ThFree Co, Russian Federation.

git.blender.org/blender.git - Unnamed repository; edit this file 'description' to name the repository.
summaryrefslogtreecommitdiff
diff options
context:
space:
mode:
Diffstat (limited to 'intern/cycles/kernel/integrator/integrator_shade_surface.h')
-rw-r--r--intern/cycles/kernel/integrator/integrator_shade_surface.h543
1 files changed, 0 insertions, 543 deletions
diff --git a/intern/cycles/kernel/integrator/integrator_shade_surface.h b/intern/cycles/kernel/integrator/integrator_shade_surface.h
deleted file mode 100644
index 3724b05c6b0..00000000000
--- a/intern/cycles/kernel/integrator/integrator_shade_surface.h
+++ /dev/null
@@ -1,543 +0,0 @@
-/*
- * Copyright 2011-2021 Blender Foundation
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#pragma once
-
-#include "kernel/kernel_accumulate.h"
-#include "kernel/kernel_emission.h"
-#include "kernel/kernel_light.h"
-#include "kernel/kernel_passes.h"
-#include "kernel/kernel_path_state.h"
-#include "kernel/kernel_shader.h"
-
-#include "kernel/integrator/integrator_subsurface.h"
-#include "kernel/integrator/integrator_volume_stack.h"
-
-CCL_NAMESPACE_BEGIN
-
-ccl_device_forceinline void integrate_surface_shader_setup(KernelGlobals kg,
- ConstIntegratorState state,
- ccl_private ShaderData *sd)
-{
- Intersection isect ccl_optional_struct_init;
- integrator_state_read_isect(kg, state, &isect);
-
- Ray ray ccl_optional_struct_init;
- integrator_state_read_ray(kg, state, &ray);
-
- shader_setup_from_ray(kg, sd, &ray, &isect);
-}
-
-#ifdef __HOLDOUT__
-ccl_device_forceinline bool integrate_surface_holdout(KernelGlobals kg,
- ConstIntegratorState state,
- ccl_private ShaderData *sd,
- ccl_global float *ccl_restrict render_buffer)
-{
- /* Write holdout transparency to render buffer and stop if fully holdout. */
- const uint32_t path_flag = INTEGRATOR_STATE(state, path, flag);
-
- if (((sd->flag & SD_HOLDOUT) || (sd->object_flag & SD_OBJECT_HOLDOUT_MASK)) &&
- (path_flag & PATH_RAY_TRANSPARENT_BACKGROUND)) {
- const float3 holdout_weight = shader_holdout_apply(kg, sd);
- if (kernel_data.background.transparent) {
- const float3 throughput = INTEGRATOR_STATE(state, path, throughput);
- const float transparent = average(holdout_weight * throughput);
- kernel_accum_holdout(kg, state, path_flag, transparent, render_buffer);
- }
- if (isequal_float3(holdout_weight, one_float3())) {
- return false;
- }
- }
-
- return true;
-}
-#endif /* __HOLDOUT__ */
-
-#ifdef __EMISSION__
-ccl_device_forceinline void integrate_surface_emission(KernelGlobals kg,
- ConstIntegratorState state,
- ccl_private const ShaderData *sd,
- ccl_global float *ccl_restrict
- render_buffer)
-{
- const uint32_t path_flag = INTEGRATOR_STATE(state, path, flag);
-
- /* Evaluate emissive closure. */
- float3 L = shader_emissive_eval(sd);
-
-# ifdef __HAIR__
- if (!(path_flag & PATH_RAY_MIS_SKIP) && (sd->flag & SD_USE_MIS) &&
- (sd->type & PRIMITIVE_ALL_TRIANGLE))
-# else
- if (!(path_flag & PATH_RAY_MIS_SKIP) && (sd->flag & SD_USE_MIS))
-# endif
- {
- const float bsdf_pdf = INTEGRATOR_STATE(state, path, mis_ray_pdf);
- const float t = sd->ray_length + INTEGRATOR_STATE(state, path, mis_ray_t);
-
- /* Multiple importance sampling, get triangle light pdf,
- * and compute weight with respect to BSDF pdf. */
- float pdf = triangle_light_pdf(kg, sd, t);
- float mis_weight = power_heuristic(bsdf_pdf, pdf);
-
- L *= mis_weight;
- }
-
- const float3 throughput = INTEGRATOR_STATE(state, path, throughput);
- kernel_accum_emission(kg, state, throughput, L, render_buffer);
-}
-#endif /* __EMISSION__ */
-
-#ifdef __EMISSION__
-/* Path tracing: sample point on light and evaluate light shader, then
- * queue shadow ray to be traced. */
-ccl_device_forceinline void integrate_surface_direct_light(KernelGlobals kg,
- IntegratorState state,
- ccl_private ShaderData *sd,
- ccl_private const RNGState *rng_state)
-{
- /* Test if there is a light or BSDF that needs direct light. */
- if (!(kernel_data.integrator.use_direct_light && (sd->flag & SD_BSDF_HAS_EVAL))) {
- return;
- }
-
- /* Sample position on a light. */
- LightSample ls ccl_optional_struct_init;
- {
- const uint32_t path_flag = INTEGRATOR_STATE(state, path, flag);
- const uint bounce = INTEGRATOR_STATE(state, path, bounce);
- float light_u, light_v;
- path_state_rng_2D(kg, rng_state, PRNG_LIGHT_U, &light_u, &light_v);
-
- if (!light_distribution_sample_from_position(
- kg, light_u, light_v, sd->time, sd->P, bounce, path_flag, &ls)) {
- return;
- }
- }
-
- kernel_assert(ls.pdf != 0.0f);
-
- /* Evaluate light shader.
- *
- * TODO: can we reuse sd memory? In theory we can move this after
- * integrate_surface_bounce, evaluate the BSDF, and only then evaluate
- * the light shader. This could also move to its own kernel, for
- * non-constant light sources. */
- ShaderDataTinyStorage emission_sd_storage;
- ccl_private ShaderData *emission_sd = AS_SHADER_DATA(&emission_sd_storage);
- const float3 light_eval = light_sample_shader_eval(kg, state, emission_sd, &ls, sd->time);
- if (is_zero(light_eval)) {
- return;
- }
-
- /* Evaluate BSDF. */
- const bool is_transmission = shader_bsdf_is_transmission(sd, ls.D);
-
- BsdfEval bsdf_eval ccl_optional_struct_init;
- const float bsdf_pdf = shader_bsdf_eval(kg, sd, ls.D, is_transmission, &bsdf_eval, ls.shader);
- bsdf_eval_mul3(&bsdf_eval, light_eval / ls.pdf);
-
- if (ls.shader & SHADER_USE_MIS) {
- const float mis_weight = power_heuristic(ls.pdf, bsdf_pdf);
- bsdf_eval_mul(&bsdf_eval, mis_weight);
- }
-
- /* Path termination. */
- const float terminate = path_state_rng_light_termination(kg, rng_state);
- if (light_sample_terminate(kg, &ls, &bsdf_eval, terminate)) {
- return;
- }
-
- /* Create shadow ray. */
- Ray ray ccl_optional_struct_init;
- light_sample_to_surface_shadow_ray(kg, sd, &ls, &ray);
- const bool is_light = light_sample_is_light(&ls);
-
- /* Branch off shadow kernel. */
- INTEGRATOR_SHADOW_PATH_INIT(
- shadow_state, state, DEVICE_KERNEL_INTEGRATOR_INTERSECT_SHADOW, shadow);
-
- /* Copy volume stack and enter/exit volume. */
- integrator_state_copy_volume_stack_to_shadow(kg, shadow_state, state);
-
- if (is_transmission) {
-# ifdef __VOLUME__
- shadow_volume_stack_enter_exit(kg, shadow_state, sd);
-# endif
- }
-
- /* Write shadow ray and associated state to global memory. */
- integrator_state_write_shadow_ray(kg, shadow_state, &ray);
-
- /* Copy state from main path to shadow path. */
- const uint16_t bounce = INTEGRATOR_STATE(state, path, bounce);
- const uint16_t transparent_bounce = INTEGRATOR_STATE(state, path, transparent_bounce);
- uint32_t shadow_flag = INTEGRATOR_STATE(state, path, flag);
- shadow_flag |= (is_light) ? PATH_RAY_SHADOW_FOR_LIGHT : 0;
- shadow_flag |= (is_transmission) ? PATH_RAY_TRANSMISSION_PASS : PATH_RAY_REFLECT_PASS;
- const float3 throughput = INTEGRATOR_STATE(state, path, throughput) * bsdf_eval_sum(&bsdf_eval);
-
- if (kernel_data.kernel_features & KERNEL_FEATURE_LIGHT_PASSES) {
- const float3 diffuse_glossy_ratio = (bounce == 0) ?
- bsdf_eval_diffuse_glossy_ratio(&bsdf_eval) :
- INTEGRATOR_STATE(state, path, diffuse_glossy_ratio);
- INTEGRATOR_STATE_WRITE(shadow_state, shadow_path, diffuse_glossy_ratio) = diffuse_glossy_ratio;
- }
-
- INTEGRATOR_STATE_WRITE(shadow_state, shadow_path, render_pixel_index) = INTEGRATOR_STATE(
- state, path, render_pixel_index);
- INTEGRATOR_STATE_WRITE(shadow_state, shadow_path, rng_offset) = INTEGRATOR_STATE(
- state, path, rng_offset);
- INTEGRATOR_STATE_WRITE(shadow_state, shadow_path, rng_hash) = INTEGRATOR_STATE(
- state, path, rng_hash);
- INTEGRATOR_STATE_WRITE(shadow_state, shadow_path, sample) = INTEGRATOR_STATE(
- state, path, sample);
- INTEGRATOR_STATE_WRITE(shadow_state, shadow_path, flag) = shadow_flag;
- INTEGRATOR_STATE_WRITE(shadow_state, shadow_path, bounce) = bounce;
- INTEGRATOR_STATE_WRITE(shadow_state, shadow_path, transparent_bounce) = transparent_bounce;
- INTEGRATOR_STATE_WRITE(shadow_state, shadow_path, diffuse_bounce) = INTEGRATOR_STATE(
- state, path, diffuse_bounce);
- INTEGRATOR_STATE_WRITE(shadow_state, shadow_path, glossy_bounce) = INTEGRATOR_STATE(
- state, path, glossy_bounce);
- INTEGRATOR_STATE_WRITE(shadow_state, shadow_path, transmission_bounce) = INTEGRATOR_STATE(
- state, path, transmission_bounce);
- INTEGRATOR_STATE_WRITE(shadow_state, shadow_path, throughput) = throughput;
-
- if (kernel_data.kernel_features & KERNEL_FEATURE_SHADOW_PASS) {
- INTEGRATOR_STATE_WRITE(shadow_state, shadow_path, unshadowed_throughput) = throughput;
- }
-}
-#endif
-
-/* Path tracing: bounce off or through surface with new direction. */
-ccl_device_forceinline int integrate_surface_bsdf_bssrdf_bounce(
- KernelGlobals kg,
- IntegratorState state,
- ccl_private ShaderData *sd,
- ccl_private const RNGState *rng_state)
-{
- /* Sample BSDF or BSSRDF. */
- if (!(sd->flag & (SD_BSDF | SD_BSSRDF))) {
- return LABEL_NONE;
- }
-
- float bsdf_u, bsdf_v;
- path_state_rng_2D(kg, rng_state, PRNG_BSDF_U, &bsdf_u, &bsdf_v);
- ccl_private const ShaderClosure *sc = shader_bsdf_bssrdf_pick(sd, &bsdf_u);
-
-#ifdef __SUBSURFACE__
- /* BSSRDF closure, we schedule subsurface intersection kernel. */
- if (CLOSURE_IS_BSSRDF(sc->type)) {
- return subsurface_bounce(kg, state, sd, sc);
- }
-#endif
-
- /* BSDF closure, sample direction. */
- float bsdf_pdf;
- BsdfEval bsdf_eval ccl_optional_struct_init;
- float3 bsdf_omega_in ccl_optional_struct_init;
- differential3 bsdf_domega_in ccl_optional_struct_init;
- int label;
-
- label = shader_bsdf_sample_closure(
- kg, sd, sc, bsdf_u, bsdf_v, &bsdf_eval, &bsdf_omega_in, &bsdf_domega_in, &bsdf_pdf);
-
- if (bsdf_pdf == 0.0f || bsdf_eval_is_zero(&bsdf_eval)) {
- return LABEL_NONE;
- }
-
- /* Setup ray. Note that clipping works through transparent bounces. */
- INTEGRATOR_STATE_WRITE(state, ray, P) = ray_offset(sd->P,
- (label & LABEL_TRANSMIT) ? -sd->Ng : sd->Ng);
- INTEGRATOR_STATE_WRITE(state, ray, D) = normalize(bsdf_omega_in);
- INTEGRATOR_STATE_WRITE(state, ray, t) = (label & LABEL_TRANSPARENT) ?
- INTEGRATOR_STATE(state, ray, t) - sd->ray_length :
- FLT_MAX;
-
-#ifdef __RAY_DIFFERENTIALS__
- INTEGRATOR_STATE_WRITE(state, ray, dP) = differential_make_compact(sd->dP);
- INTEGRATOR_STATE_WRITE(state, ray, dD) = differential_make_compact(bsdf_domega_in);
-#endif
-
- /* Update throughput. */
- float3 throughput = INTEGRATOR_STATE(state, path, throughput);
- throughput *= bsdf_eval_sum(&bsdf_eval) / bsdf_pdf;
- INTEGRATOR_STATE_WRITE(state, path, throughput) = throughput;
-
- if (kernel_data.kernel_features & KERNEL_FEATURE_LIGHT_PASSES) {
- if (INTEGRATOR_STATE(state, path, bounce) == 0) {
- INTEGRATOR_STATE_WRITE(state, path, diffuse_glossy_ratio) = bsdf_eval_diffuse_glossy_ratio(
- &bsdf_eval);
- }
- }
-
- /* Update path state */
- if (label & LABEL_TRANSPARENT) {
- INTEGRATOR_STATE_WRITE(state, path, mis_ray_t) += sd->ray_length;
- }
- else {
- INTEGRATOR_STATE_WRITE(state, path, mis_ray_pdf) = bsdf_pdf;
- INTEGRATOR_STATE_WRITE(state, path, mis_ray_t) = 0.0f;
- INTEGRATOR_STATE_WRITE(state, path, min_ray_pdf) = fminf(
- bsdf_pdf, INTEGRATOR_STATE(state, path, min_ray_pdf));
- }
-
- path_state_next(kg, state, label);
- return label;
-}
-
-#ifdef __VOLUME__
-ccl_device_forceinline bool integrate_surface_volume_only_bounce(IntegratorState state,
- ccl_private ShaderData *sd)
-{
- if (!path_state_volume_next(state)) {
- return LABEL_NONE;
- }
-
- /* Setup ray position, direction stays unchanged. */
- INTEGRATOR_STATE_WRITE(state, ray, P) = ray_offset(sd->P, -sd->Ng);
-
- /* Clipping works through transparent. */
- INTEGRATOR_STATE_WRITE(state, ray, t) -= sd->ray_length;
-
-# ifdef __RAY_DIFFERENTIALS__
- INTEGRATOR_STATE_WRITE(state, ray, dP) = differential_make_compact(sd->dP);
-# endif
-
- INTEGRATOR_STATE_WRITE(state, path, mis_ray_t) += sd->ray_length;
-
- return LABEL_TRANSMIT | LABEL_TRANSPARENT;
-}
-#endif
-
-#if defined(__AO__)
-ccl_device_forceinline void integrate_surface_ao_pass(
- KernelGlobals kg,
- IntegratorState state,
- ccl_private const ShaderData *ccl_restrict sd,
- ccl_private const RNGState *ccl_restrict rng_state,
- ccl_global float *ccl_restrict render_buffer)
-{
- float bsdf_u, bsdf_v;
- path_state_rng_2D(kg, rng_state, PRNG_BSDF_U, &bsdf_u, &bsdf_v);
-
- const float3 ao_N = shader_bsdf_ao_normal(kg, sd);
- float3 ao_D;
- float ao_pdf;
- sample_cos_hemisphere(ao_N, bsdf_u, bsdf_v, &ao_D, &ao_pdf);
-
- if (!(dot(sd->Ng, ao_D) > 0.0f && ao_pdf != 0.0f)) {
- return;
- }
-
- Ray ray ccl_optional_struct_init;
- ray.P = ray_offset(sd->P, sd->Ng);
- ray.D = ao_D;
- ray.t = kernel_data.integrator.ao_bounces_distance;
- ray.time = sd->time;
- ray.dP = differential_zero_compact();
- ray.dD = differential_zero_compact();
-
- /* Branch off shadow kernel. */
- INTEGRATOR_SHADOW_PATH_INIT(shadow_state, state, DEVICE_KERNEL_INTEGRATOR_INTERSECT_SHADOW, ao);
-
- /* Copy volume stack and enter/exit volume. */
- integrator_state_copy_volume_stack_to_shadow(kg, shadow_state, state);
-
- /* Write shadow ray and associated state to global memory. */
- integrator_state_write_shadow_ray(kg, shadow_state, &ray);
-
- /* Copy state from main path to shadow path. */
- const uint16_t bounce = INTEGRATOR_STATE(state, path, bounce);
- const uint16_t transparent_bounce = INTEGRATOR_STATE(state, path, transparent_bounce);
- uint32_t shadow_flag = INTEGRATOR_STATE(state, path, flag) | PATH_RAY_SHADOW_FOR_AO;
- const float3 throughput = INTEGRATOR_STATE(state, path, throughput) * shader_bsdf_alpha(kg, sd);
-
- INTEGRATOR_STATE_WRITE(shadow_state, shadow_path, render_pixel_index) = INTEGRATOR_STATE(
- state, path, render_pixel_index);
- INTEGRATOR_STATE_WRITE(shadow_state, shadow_path, rng_offset) = INTEGRATOR_STATE(
- state, path, rng_offset);
- INTEGRATOR_STATE_WRITE(shadow_state, shadow_path, rng_hash) = INTEGRATOR_STATE(
- state, path, rng_hash);
- INTEGRATOR_STATE_WRITE(shadow_state, shadow_path, sample) = INTEGRATOR_STATE(
- state, path, sample);
- INTEGRATOR_STATE_WRITE(shadow_state, shadow_path, flag) = shadow_flag;
- INTEGRATOR_STATE_WRITE(shadow_state, shadow_path, bounce) = bounce;
- INTEGRATOR_STATE_WRITE(shadow_state, shadow_path, transparent_bounce) = transparent_bounce;
- INTEGRATOR_STATE_WRITE(shadow_state, shadow_path, throughput) = throughput;
-}
-#endif /* defined(__AO__) */
-
-template<uint node_feature_mask>
-ccl_device bool integrate_surface(KernelGlobals kg,
- IntegratorState state,
- ccl_global float *ccl_restrict render_buffer)
-
-{
- PROFILING_INIT_FOR_SHADER(kg, PROFILING_SHADE_SURFACE_SETUP);
-
- /* Setup shader data. */
- ShaderData sd;
- integrate_surface_shader_setup(kg, state, &sd);
- PROFILING_SHADER(sd.object, sd.shader);
-
- int continue_path_label = 0;
-
- /* Skip most work for volume bounding surface. */
-#ifdef __VOLUME__
- if (!(sd.flag & SD_HAS_ONLY_VOLUME)) {
-#endif
- const uint32_t path_flag = INTEGRATOR_STATE(state, path, flag);
-
-#ifdef __SUBSURFACE__
- /* Can skip shader evaluation for BSSRDF exit point without bump mapping. */
- if (!(path_flag & PATH_RAY_SUBSURFACE) || ((sd.flag & SD_HAS_BSSRDF_BUMP)))
-#endif
- {
- /* Evaluate shader. */
- PROFILING_EVENT(PROFILING_SHADE_SURFACE_EVAL);
- shader_eval_surface<node_feature_mask>(kg, state, &sd, render_buffer, path_flag);
-
- /* Initialize additional RNG for BSDFs. */
- if (sd.flag & SD_BSDF_NEEDS_LCG) {
- sd.lcg_state = lcg_state_init(INTEGRATOR_STATE(state, path, rng_hash),
- INTEGRATOR_STATE(state, path, rng_offset),
- INTEGRATOR_STATE(state, path, sample),
- 0xb4bc3953);
- }
- }
-
-#ifdef __SUBSURFACE__
- if (path_flag & PATH_RAY_SUBSURFACE) {
- /* When coming from inside subsurface scattering, setup a diffuse
- * closure to perform lighting at the exit point. */
- subsurface_shader_data_setup(kg, state, &sd, path_flag);
- INTEGRATOR_STATE_WRITE(state, path, flag) &= ~PATH_RAY_SUBSURFACE;
- }
-#endif
-
- shader_prepare_surface_closures(kg, state, &sd);
-
-#ifdef __HOLDOUT__
- /* Evaluate holdout. */
- if (!integrate_surface_holdout(kg, state, &sd, render_buffer)) {
- return false;
- }
-#endif
-
-#ifdef __EMISSION__
- /* Write emission. */
- if (sd.flag & SD_EMISSION) {
- integrate_surface_emission(kg, state, &sd, render_buffer);
- }
-#endif
-
-#ifdef __PASSES__
- /* Write render passes. */
- PROFILING_EVENT(PROFILING_SHADE_SURFACE_PASSES);
- kernel_write_data_passes(kg, state, &sd, render_buffer);
-#endif
-
- /* Load random number state. */
- RNGState rng_state;
- path_state_rng_load(state, &rng_state);
-
- /* Perform path termination. Most paths have already been terminated in
- * the intersect_closest kernel, this is just for emission and for dividing
- * throughput by the probability at the right moment.
- *
- * Also ensure we don't do it twice for SSS at both the entry and exit point. */
- if (!(path_flag & PATH_RAY_SUBSURFACE)) {
- const float probability = (path_flag & PATH_RAY_TERMINATE_ON_NEXT_SURFACE) ?
- 0.0f :
- path_state_continuation_probability(kg, state, path_flag);
- if (probability == 0.0f) {
- return false;
- }
- else if (probability != 1.0f) {
- INTEGRATOR_STATE_WRITE(state, path, throughput) /= probability;
- }
- }
-
-#ifdef __DENOISING_FEATURES__
- kernel_write_denoising_features_surface(kg, state, &sd, render_buffer);
-#endif
-
-#ifdef __SHADOW_CATCHER__
- kernel_write_shadow_catcher_bounce_data(kg, state, &sd, render_buffer);
-#endif
-
- /* Direct light. */
- PROFILING_EVENT(PROFILING_SHADE_SURFACE_DIRECT_LIGHT);
- integrate_surface_direct_light(kg, state, &sd, &rng_state);
-
-#if defined(__AO__)
- /* Ambient occlusion pass. */
- if ((kernel_data.film.pass_ao != PASS_UNUSED) &&
- (INTEGRATOR_STATE(state, path, flag) & PATH_RAY_CAMERA)) {
- PROFILING_EVENT(PROFILING_SHADE_SURFACE_AO);
- integrate_surface_ao_pass(kg, state, &sd, &rng_state, render_buffer);
- }
-#endif
-
- PROFILING_EVENT(PROFILING_SHADE_SURFACE_INDIRECT_LIGHT);
- continue_path_label = integrate_surface_bsdf_bssrdf_bounce(kg, state, &sd, &rng_state);
-#ifdef __VOLUME__
- }
- else {
- PROFILING_EVENT(PROFILING_SHADE_SURFACE_INDIRECT_LIGHT);
- continue_path_label = integrate_surface_volume_only_bounce(state, &sd);
- }
-
- if (continue_path_label & LABEL_TRANSMIT) {
- /* Enter/Exit volume. */
- volume_stack_enter_exit(kg, state, &sd);
- }
-#endif
-
- return continue_path_label != 0;
-}
-
-template<uint node_feature_mask = KERNEL_FEATURE_NODE_MASK_SURFACE & ~KERNEL_FEATURE_NODE_RAYTRACE,
- int current_kernel = DEVICE_KERNEL_INTEGRATOR_SHADE_SURFACE>
-ccl_device_forceinline void integrator_shade_surface(KernelGlobals kg,
- IntegratorState state,
- ccl_global float *ccl_restrict render_buffer)
-{
- if (integrate_surface<node_feature_mask>(kg, state, render_buffer)) {
- if (INTEGRATOR_STATE(state, path, flag) & PATH_RAY_SUBSURFACE) {
- INTEGRATOR_PATH_NEXT(current_kernel, DEVICE_KERNEL_INTEGRATOR_INTERSECT_SUBSURFACE);
- }
- else {
- kernel_assert(INTEGRATOR_STATE(state, ray, t) != 0.0f);
- INTEGRATOR_PATH_NEXT(current_kernel, DEVICE_KERNEL_INTEGRATOR_INTERSECT_CLOSEST);
- }
- }
- else {
- INTEGRATOR_PATH_TERMINATE(current_kernel);
- }
-}
-
-ccl_device_forceinline void integrator_shade_surface_raytrace(
- KernelGlobals kg, IntegratorState state, ccl_global float *ccl_restrict render_buffer)
-{
- integrator_shade_surface<KERNEL_FEATURE_NODE_MASK_SURFACE,
- DEVICE_KERNEL_INTEGRATOR_SHADE_SURFACE_RAYTRACE>(
- kg, state, render_buffer);
-}
-
-CCL_NAMESPACE_END