diff options
31 files changed, 388 insertions, 367 deletions
diff --git a/intern/cycles/kernel/closure/bsdf_transparent.h b/intern/cycles/kernel/closure/bsdf_transparent.h index 22ca7f3847e..79ee9dc4537 100644 --- a/intern/cycles/kernel/closure/bsdf_transparent.h +++ b/intern/cycles/kernel/closure/bsdf_transparent.h @@ -35,21 +35,38 @@ CCL_NAMESPACE_BEGIN -ccl_device void bsdf_transparent_setup(ShaderData *sd, const float3 weight) +ccl_device void bsdf_transparent_setup(ShaderData *sd, const float3 weight, int path_flag) { if(sd->flag & SD_TRANSPARENT) { sd->closure_transparent_extinction += weight; + + for(int i = 0; i < sd->num_closure; i++) { + ShaderClosure *sc = &sd->closure[i]; + + if(sc->type == CLOSURE_BSDF_TRANSPARENT_ID) { + sc->weight += weight; + sc->sample_weight += fabsf(average(weight)); + break; + } + } } else { sd->flag |= SD_BSDF|SD_TRANSPARENT; sd->closure_transparent_extinction = weight; - } - ShaderClosure *bsdf = bsdf_alloc(sd, sizeof(ShaderClosure), weight); + if(path_flag & PATH_RAY_TERMINATE) { + /* In this case the number of closures is set to zero to disable + * all others, but we still want to get transparency so increase + * the number just for this. */ + sd->num_closure_left = 1; + } + + ShaderClosure *bsdf = bsdf_alloc(sd, sizeof(ShaderClosure), weight); - if(bsdf) { - bsdf->N = sd->N; - bsdf->type = CLOSURE_BSDF_TRANSPARENT_ID; + if(bsdf) { + bsdf->N = sd->N; + bsdf->type = CLOSURE_BSDF_TRANSPARENT_ID; + } } } diff --git a/intern/cycles/kernel/kernel_bake.h b/intern/cycles/kernel/kernel_bake.h index 8788e89c40e..b3c2450d10e 100644 --- a/intern/cycles/kernel/kernel_bake.h +++ b/intern/cycles/kernel/kernel_bake.h @@ -51,7 +51,7 @@ ccl_device_inline void compute_light_pass(KernelGlobals *kg, path_state_init(kg, &emission_sd, &state, rng_hash, sample, NULL); /* evaluate surface shader */ - shader_eval_surface(kg, sd, &state, state.flag, kernel_data.integrator.max_closures); + shader_eval_surface(kg, sd, &state, state.flag); /* TODO, disable more closures we don't need besides transparent */ shader_bsdf_disable_transparency(kg, sd); @@ -228,12 +228,12 @@ ccl_device float3 kernel_bake_evaluate_direct_indirect(KernelGlobals *kg, } else { /* surface color of the pass only */ - shader_eval_surface(kg, sd, state, 0, kernel_data.integrator.max_closures); + shader_eval_surface(kg, sd, state, 0); return kernel_bake_shader_bsdf(kg, sd, type); } } else { - shader_eval_surface(kg, sd, state, 0, kernel_data.integrator.max_closures); + shader_eval_surface(kg, sd, state, 0); color = kernel_bake_shader_bsdf(kg, sd, type); } @@ -333,7 +333,7 @@ ccl_device void kernel_bake_evaluate(KernelGlobals *kg, ccl_global uint4 *input, { float3 N = sd.N; if((sd.flag & SD_HAS_BUMP)) { - shader_eval_surface(kg, &sd, &state, 0, kernel_data.integrator.max_closures); + shader_eval_surface(kg, &sd, &state, 0); N = shader_bsdf_average_normal(kg, &sd); } @@ -348,7 +348,7 @@ ccl_device void kernel_bake_evaluate(KernelGlobals *kg, ccl_global uint4 *input, } case SHADER_EVAL_EMISSION: { - shader_eval_surface(kg, &sd, &state, 0, 0); + shader_eval_surface(kg, &sd, &state, PATH_RAY_EMISSION); out = shader_emissive_eval(kg, &sd); break; } diff --git a/intern/cycles/kernel/kernel_emission.h b/intern/cycles/kernel/kernel_emission.h index 94b0a37ce62..5875249b404 100644 --- a/intern/cycles/kernel/kernel_emission.h +++ b/intern/cycles/kernel/kernel_emission.h @@ -67,13 +67,13 @@ ccl_device_noinline float3 direct_emissive_eval(KernelGlobals *kg, ls->Ng = emission_sd->Ng; - /* no path flag, we're evaluating this for all closures. that's weak but - * we'd have to do multiple evaluations otherwise */ + /* No proper path flag, we're evaluating this for all closures. that's + * weak but we'd have to do multiple evaluations otherwise. */ path_state_modify_bounce(state, true); - shader_eval_surface(kg, emission_sd, state, 0, 0); + shader_eval_surface(kg, emission_sd, state, PATH_RAY_EMISSION); path_state_modify_bounce(state, false); - /* evaluate emissive closure */ + /* Evaluate emissive closure. */ eval = shader_emissive_eval(kg, emission_sd); } diff --git a/intern/cycles/kernel/kernel_path.h b/intern/cycles/kernel/kernel_path.h index dbbb80ca37f..aef350b0658 100644 --- a/intern/cycles/kernel/kernel_path.h +++ b/intern/cycles/kernel/kernel_path.h @@ -400,6 +400,13 @@ ccl_device void kernel_path_indirect(KernelGlobals *kg, PathState *state, PathRadiance *L) { +#ifdef __SUBSURFACE__ + SubsurfaceIndirectRays ss_indirect; + kernel_path_subsurface_init_indirect(&ss_indirect); + + for(;;) { +#endif /* __SUBSURFACE__ */ + /* path iteration */ for(;;) { /* Find intersection with objects in scene. */ @@ -439,11 +446,8 @@ ccl_device void kernel_path_indirect(KernelGlobals *kg, } /* Setup and evaluate shader. */ - shader_setup_from_ray(kg, - sd, - &isect, - ray); - shader_eval_surface(kg, sd, state, state->flag, kernel_data.integrator.max_closures); + shader_setup_from_ray(kg, sd, &isect, ray); + shader_eval_surface(kg, sd, state, state->flag); shader_prepare_closures(sd, state); /* Apply shadow catcher, holdout, emission. */ @@ -485,29 +489,21 @@ ccl_device void kernel_path_indirect(KernelGlobals *kg, } #endif /* __AO__ */ + #ifdef __SUBSURFACE__ /* bssrdf scatter to a different location on the same object, replacing * the closures with a diffuse BSDF */ if(sd->flag & SD_BSSRDF) { - float bssrdf_u, bssrdf_v; - path_state_rng_2D(kg, - state, - PRNG_BSDF_U, - &bssrdf_u, &bssrdf_v); - - const ShaderClosure *sc = shader_bssrdf_pick(sd, &throughput, &bssrdf_u); - - /* do bssrdf scatter step if we picked a bssrdf closure */ - if(sc) { - uint lcg_state = lcg_state_init(state, 0x68bc21eb); - - subsurface_scatter_step(kg, - sd, - state, - sc, - &lcg_state, - bssrdf_u, bssrdf_v, - false); + if(kernel_path_subsurface_scatter(kg, + sd, + emission_sd, + L, + state, + ray, + &throughput, + &ss_indirect)) + { + break; } } #endif /* __SUBSURFACE__ */ @@ -530,6 +526,24 @@ ccl_device void kernel_path_indirect(KernelGlobals *kg, if(!kernel_path_surface_bounce(kg, sd, &throughput, state, &L->state, ray)) break; } + +#ifdef __SUBSURFACE__ + /* Trace indirect subsurface rays by restarting the loop. this uses less + * stack memory than invoking kernel_path_indirect. + */ + if(ss_indirect.num_rays) { + kernel_path_subsurface_setup_indirect(kg, + &ss_indirect, + state, + ray, + L, + &throughput); + } + else { + break; + } + } +#endif /* __SUBSURFACE__ */ } #endif /* defined(__BRANCHED_PATH__) || defined(__BAKING__) */ @@ -593,7 +607,7 @@ ccl_device_forceinline void kernel_path_integrate( /* Setup and evaluate shader. */ shader_setup_from_ray(kg, &sd, &isect, ray); - shader_eval_surface(kg, &sd, state, state->flag, kernel_data.integrator.max_closures); + shader_eval_surface(kg, &sd, state, state->flag); shader_prepare_closures(&sd, state); /* Apply shadow catcher, holdout, emission. */ diff --git a/intern/cycles/kernel/kernel_path_branched.h b/intern/cycles/kernel/kernel_path_branched.h index 6fb55bda08d..441a06eeba3 100644 --- a/intern/cycles/kernel/kernel_path_branched.h +++ b/intern/cycles/kernel/kernel_path_branched.h @@ -480,7 +480,7 @@ ccl_device void kernel_branched_path_integrate(KernelGlobals *kg, /* Setup and evaluate shader. */ shader_setup_from_ray(kg, &sd, &isect, &ray); - shader_eval_surface(kg, &sd, &state, state.flag, kernel_data.integrator.max_closures); + shader_eval_surface(kg, &sd, &state, state.flag); shader_merge_closures(&sd); /* Apply shadow catcher, holdout, emission. */ diff --git a/intern/cycles/kernel/kernel_path_state.h b/intern/cycles/kernel/kernel_path_state.h index a16c20cbee6..15d81fcddf4 100644 --- a/intern/cycles/kernel/kernel_path_state.h +++ b/intern/cycles/kernel/kernel_path_state.h @@ -75,6 +75,9 @@ ccl_device_inline void path_state_next(KernelGlobals *kg, ccl_addr_space PathSta if(label & LABEL_TRANSPARENT) { state->flag |= PATH_RAY_TRANSPARENT; state->transparent_bounce++; + if(state->transparent_bounce >= kernel_data.integrator.transparent_max_bounce) { + state->flag |= PATH_RAY_TERMINATE_IMMEDIATE; + } if(!kernel_data.integrator.transparent_shadows) state->flag |= PATH_RAY_MIS_SKIP; @@ -86,6 +89,10 @@ ccl_device_inline void path_state_next(KernelGlobals *kg, ccl_addr_space PathSta } state->bounce++; + if(state->bounce >= kernel_data.integrator.max_bounce) { + state->flag |= PATH_RAY_TERMINATE_AFTER_TRANSPARENT; + } + state->flag &= ~(PATH_RAY_ALL_VISIBILITY|PATH_RAY_MIS_SKIP); #ifdef __VOLUME__ @@ -95,6 +102,9 @@ ccl_device_inline void path_state_next(KernelGlobals *kg, ccl_addr_space PathSta state->flag &= ~PATH_RAY_TRANSPARENT_BACKGROUND; state->volume_bounce++; + if(state->volume_bounce >= kernel_data.integrator.max_volume_bounce) { + state->flag |= PATH_RAY_TERMINATE_AFTER_TRANSPARENT; + } } else #endif @@ -104,10 +114,18 @@ ccl_device_inline void path_state_next(KernelGlobals *kg, ccl_addr_space PathSta state->flag |= PATH_RAY_REFLECT; state->flag &= ~PATH_RAY_TRANSPARENT_BACKGROUND; - if(label & LABEL_DIFFUSE) + if(label & LABEL_DIFFUSE) { state->diffuse_bounce++; - else + if(state->diffuse_bounce >= kernel_data.integrator.max_diffuse_bounce) { + state->flag |= PATH_RAY_TERMINATE_AFTER_TRANSPARENT; + } + } + else { state->glossy_bounce++; + if(state->glossy_bounce >= kernel_data.integrator.max_glossy_bounce) { + state->flag |= PATH_RAY_TERMINATE_AFTER_TRANSPARENT; + } + } } else { kernel_assert(label & LABEL_TRANSMIT); @@ -119,6 +137,9 @@ ccl_device_inline void path_state_next(KernelGlobals *kg, ccl_addr_space PathSta } state->transmission_bounce++; + if(state->transmission_bounce >= kernel_data.integrator.max_transmission_bounce) { + state->flag |= PATH_RAY_TERMINATE_AFTER_TRANSPARENT; + } } /* diffuse/glossy/singular */ @@ -162,13 +183,13 @@ ccl_device_inline float path_state_continuation_probability(KernelGlobals *kg, ccl_addr_space PathState *state, const float3 throughput) { - if(state->flag & PATH_RAY_TRANSPARENT) { - /* Transparent rays are treated separately with own max bounces. */ - if(state->transparent_bounce >= kernel_data.integrator.transparent_max_bounce) { - return 0.0f; - } + if(state->flag & PATH_RAY_TERMINATE_IMMEDIATE) { + /* Ray is to be terminated immediately. */ + return 0.0f; + } + else if(state->flag & PATH_RAY_TRANSPARENT) { /* Do at least one bounce without RR. */ - else if(state->transparent_bounce <= 1) { + if(state->transparent_bounce <= 1) { return 1.0f; } #ifdef __SHADOW_TRICKS__ @@ -179,19 +200,8 @@ ccl_device_inline float path_state_continuation_probability(KernelGlobals *kg, #endif } else { - /* Test max bounces for various ray types. */ - if((state->bounce >= kernel_data.integrator.max_bounce) || - (state->diffuse_bounce >= kernel_data.integrator.max_diffuse_bounce) || - (state->glossy_bounce >= kernel_data.integrator.max_glossy_bounce) || -#ifdef __VOLUME__ - (state->volume_bounce >= kernel_data.integrator.max_volume_bounce) || -#endif - (state->transmission_bounce >= kernel_data.integrator.max_transmission_bounce)) - { - return 0.0f; - } /* Do at least one bounce without RR. */ - else if(state->bounce <= 1) { + if(state->bounce <= 1) { return 1.0f; } #ifdef __SHADOW_TRICKS__ diff --git a/intern/cycles/kernel/kernel_path_volume.h b/intern/cycles/kernel/kernel_path_volume.h index b6a856baf24..6275d0d6562 100644 --- a/intern/cycles/kernel/kernel_path_volume.h +++ b/intern/cycles/kernel/kernel_path_volume.h @@ -99,6 +99,23 @@ bool kernel_path_volume_bounce( /* update path state */ path_state_next(kg, state, label); + /* Russian roulette termination of volume ray scattering. */ + float probability = path_state_continuation_probability(kg, state, *throughput); + + if(probability == 0.0f) { + return false; + } + else if(probability != 1.0f) { + /* Use dimension from the previous bounce, has not been used yet. */ + float terminate = path_state_rng_1D(kg, state, PRNG_TERMINATE - PRNG_BOUNCE_NUM); + + if(terminate >= probability) { + return false; + } + + *throughput /= probability; + } + /* setup ray */ ray->P = sd->P; ray->D = phase_omega_in; diff --git a/intern/cycles/kernel/kernel_shader.h b/intern/cycles/kernel/kernel_shader.h index 5f2f00c5ceb..8cfd33b808e 100644 --- a/intern/cycles/kernel/kernel_shader.h +++ b/intern/cycles/kernel/kernel_shader.h @@ -966,10 +966,21 @@ ccl_device float3 shader_holdout_eval(KernelGlobals *kg, ShaderData *sd) /* Surface Evaluation */ ccl_device void shader_eval_surface(KernelGlobals *kg, ShaderData *sd, - ccl_addr_space PathState *state, int path_flag, int max_closure) + ccl_addr_space PathState *state, int path_flag) { + /* If path is being terminated, we are tracing a shadow ray or evaluating + * emission, then we don't need to store closures. The emission and shadow + * shader data also do not have a closure array to save GPU memory. */ + int max_closures; + if(path_flag & (PATH_RAY_TERMINATE|PATH_RAY_SHADOW|PATH_RAY_EMISSION)) { + max_closures = 0; + } + else { + max_closures = kernel_data.integrator.max_closures; + } + sd->num_closure = 0; - sd->num_closure_left = max_closure; + sd->num_closure_left = max_closures; #ifdef __OSL__ if(kg->osl) @@ -1140,13 +1151,23 @@ ccl_device_inline void shader_eval_volume(KernelGlobals *kg, ShaderData *sd, ccl_addr_space PathState *state, ccl_addr_space VolumeStack *stack, - int path_flag, - int max_closure) + int path_flag) { + /* If path is being terminated, we are tracing a shadow ray or evaluating + * emission, then we don't need to store closures. The emission and shadow + * shader data also do not have a closure array to save GPU memory. */ + int max_closures; + if(path_flag & (PATH_RAY_TERMINATE|PATH_RAY_SHADOW|PATH_RAY_EMISSION)) { + max_closures = 0; + } + else { + max_closures = kernel_data.integrator.max_closures; + } + /* reset closures once at the start, we will be accumulating the closures * for all volumes in the stack into a single array of closures */ sd->num_closure = 0; - sd->num_closure_left = max_closure; + sd->num_closure_left = max_closures; sd->flag = 0; sd->object_flag = 0; diff --git a/intern/cycles/kernel/kernel_shadow.h b/intern/cycles/kernel/kernel_shadow.h index ab364d3037a..8a0da6c3b13 100644 --- a/intern/cycles/kernel/kernel_shadow.h +++ b/intern/cycles/kernel/kernel_shadow.h @@ -86,8 +86,7 @@ ccl_device_forceinline bool shadow_handle_transparent_isect( shader_eval_surface(kg, shadow_sd, state, - PATH_RAY_SHADOW, - 0); + PATH_RAY_SHADOW); path_state_modify_bounce(state, false); *throughput *= shader_bsdf_transparency(kg, shadow_sd); } diff --git a/intern/cycles/kernel/kernel_subsurface.h b/intern/cycles/kernel/kernel_subsurface.h index 80dda31c61e..e8553d84547 100644 --- a/intern/cycles/kernel/kernel_subsurface.h +++ b/intern/cycles/kernel/kernel_subsurface.h @@ -69,44 +69,42 @@ ccl_device_inline float3 subsurface_scatter_eval(ShaderData *sd, } /* replace closures with a single diffuse bsdf closure after scatter step */ -ccl_device void subsurface_scatter_setup_diffuse_bsdf(KernelGlobals *kg, ShaderData *sd, const ShaderClosure *sc, float3 weight, bool hit, float3 N) +ccl_device void subsurface_scatter_setup_diffuse_bsdf(KernelGlobals *kg, ShaderData *sd, const ShaderClosure *sc, float3 weight, float3 N) { sd->flag &= ~SD_CLOSURE_FLAGS; sd->num_closure = 0; sd->num_closure_left = kernel_data.integrator.max_closures; - if(hit) { - Bssrdf *bssrdf = (Bssrdf *)sc; + Bssrdf *bssrdf = (Bssrdf *)sc; #ifdef __PRINCIPLED__ - if(bssrdf->type == CLOSURE_BSSRDF_PRINCIPLED_ID || - bssrdf->type == CLOSURE_BSSRDF_PRINCIPLED_RANDOM_WALK_ID) - { - PrincipledDiffuseBsdf *bsdf = (PrincipledDiffuseBsdf*)bsdf_alloc(sd, sizeof(PrincipledDiffuseBsdf), weight); - - if(bsdf) { - bsdf->N = N; - bsdf->roughness = bssrdf->roughness; - sd->flag |= bsdf_principled_diffuse_setup(bsdf); - - /* replace CLOSURE_BSDF_PRINCIPLED_DIFFUSE_ID with this special ID so render passes - * can recognize it as not being a regular Disney principled diffuse closure */ - bsdf->type = CLOSURE_BSDF_BSSRDF_PRINCIPLED_ID; - } + if(bssrdf->type == CLOSURE_BSSRDF_PRINCIPLED_ID || + bssrdf->type == CLOSURE_BSSRDF_PRINCIPLED_RANDOM_WALK_ID) + { + PrincipledDiffuseBsdf *bsdf = (PrincipledDiffuseBsdf*)bsdf_alloc(sd, sizeof(PrincipledDiffuseBsdf), weight); + + if(bsdf) { + bsdf->N = N; + bsdf->roughness = bssrdf->roughness; + sd->flag |= bsdf_principled_diffuse_setup(bsdf); + + /* replace CLOSURE_BSDF_PRINCIPLED_DIFFUSE_ID with this special ID so render passes + * can recognize it as not being a regular Disney principled diffuse closure */ + bsdf->type = CLOSURE_BSDF_BSSRDF_PRINCIPLED_ID; } - else if(CLOSURE_IS_BSDF_BSSRDF(bssrdf->type) || - CLOSURE_IS_BSSRDF(bssrdf->type)) + } + else if(CLOSURE_IS_BSDF_BSSRDF(bssrdf->type) || + CLOSURE_IS_BSSRDF(bssrdf->type)) #endif /* __PRINCIPLED__ */ - { - DiffuseBsdf *bsdf = (DiffuseBsdf*)bsdf_alloc(sd, sizeof(DiffuseBsdf), weight); + { + DiffuseBsdf *bsdf = (DiffuseBsdf*)bsdf_alloc(sd, sizeof(DiffuseBsdf), weight); - if(bsdf) { - bsdf->N = N; - sd->flag |= bsdf_diffuse_setup(bsdf); + if(bsdf) { + bsdf->N = N; + sd->flag |= bsdf_diffuse_setup(bsdf); - /* replace CLOSURE_BSDF_DIFFUSE_ID with this special ID so render passes - * can recognize it as not being a regular diffuse closure */ - bsdf->type = CLOSURE_BSDF_BSSRDF_ID; - } + /* replace CLOSURE_BSDF_DIFFUSE_ID with this special ID so render passes + * can recognize it as not being a regular diffuse closure */ + bsdf->type = CLOSURE_BSDF_BSSRDF_ID; } } } @@ -148,7 +146,7 @@ ccl_device void subsurface_color_bump_blur(KernelGlobals *kg, if(bump || texture_blur > 0.0f) { /* average color and normal at incoming point */ - shader_eval_surface(kg, sd, state, state->flag, kernel_data.integrator.max_closures); + shader_eval_surface(kg, sd, state, state->flag); float3 in_color = shader_bssrdf_sum(sd, (bump)? N: NULL, NULL); /* we simply divide out the average color and multiply with the average @@ -334,104 +332,7 @@ ccl_device_noinline void subsurface_scatter_multi_setup( subsurface_color_bump_blur(kg, sd, state, &weight, &N); /* Setup diffuse BSDF. */ - subsurface_scatter_setup_diffuse_bsdf(kg, sd, sc, weight, true, N); -} - -/* subsurface scattering step, from a point on the surface to another nearby point on the same object */ -ccl_device void subsurface_scatter_step(KernelGlobals *kg, ShaderData *sd, ccl_addr_space PathState *state, - const ShaderClosure *sc, uint *lcg_state, float disk_u, float disk_v, bool all) -{ - float3 eval = make_float3(0.0f, 0.0f, 0.0f); - - /* pick random axis in local frame and point on disk */ - float3 disk_N, disk_T, disk_B; - float pick_pdf_N, pick_pdf_T, pick_pdf_B; - - disk_N = sd->Ng; - make_orthonormals(disk_N, &disk_T, &disk_B); - - if(disk_v < 0.5f) { - pick_pdf_N = 0.5f; - pick_pdf_T = 0.25f; - pick_pdf_B = 0.25f; - disk_v *= 2.0f; - } - else if(disk_v < 0.75f) { - float3 tmp = disk_N; - disk_N = disk_T; - disk_T = tmp; - pick_pdf_N = 0.25f; - pick_pdf_T = 0.5f; - pick_pdf_B = 0.25f; - disk_v = (disk_v - 0.5f)*4.0f; - } - else { - float3 tmp = disk_N; - disk_N = disk_B; - disk_B = tmp; - pick_pdf_N = 0.25f; - pick_pdf_T = 0.25f; - pick_pdf_B = 0.5f; - disk_v = (disk_v - 0.75f)*4.0f; - } - - /* sample point on disk */ - float phi = M_2PI_F * disk_v; - float disk_height, disk_r; - - bssrdf_sample(sc, disk_u, &disk_r, &disk_height); - - float3 disk_P = (disk_r*cosf(phi)) * disk_T + (disk_r*sinf(phi)) * disk_B; - - /* create ray */ - Ray ray; - ray.P = sd->P + disk_N*disk_height + disk_P; - ray.D = -disk_N; - ray.t = 2.0f*disk_height; - ray.dP = sd->dP; - ray.dD = differential3_zero(); - ray.time = sd->time; - - /* intersect with the same object. if multiple intersections are - * found it will randomly pick one of them */ - LocalIntersection ss_isect; - scene_intersect_local(kg, ray, &ss_isect, sd->object, lcg_state, 1); - - /* evaluate bssrdf */ - if(ss_isect.num_hits > 0) { - float3 origP = sd->P; - - /* Workaround for AMD GPU OpenCL compiler. Most probably cache bypass issue. */ -#if defined(__SPLIT_KERNEL__) && defined(__KERNEL_OPENCL_AMD__) && defined(__KERNEL_GPU__) - kernel_split_params.dummy_sd_flag = sd->flag; -#endif - /* setup new shading point */ - shader_setup_from_subsurface(kg, sd, &ss_isect.hits[0], &ray); - - /* Probability densities for local frame axes. */ - float pdf_N = pick_pdf_N * fabsf(dot(disk_N, sd->Ng)); - float pdf_T = pick_pdf_T * fabsf(dot(disk_T, sd->Ng)); - float pdf_B = pick_pdf_B * fabsf(dot(disk_B, sd->Ng)); - - /* Multiple importance sample between 3 axes, power heuristic - * found to be slightly better than balance heuristic. pdf_N - * in the MIS weight and denominator cancelled out. */ - float w = pdf_N / (sqr(pdf_N) + sqr(pdf_T) + sqr(pdf_B)); - w *= ss_isect.num_hits; - - /* Real distance to sampled point. */ - float r = len(sd->P - origP); - - /* Evaluate profiles. */ - eval = subsurface_scatter_eval(sd, sc, disk_r, r, all) * w; - } - - /* optionally blur colors and bump mapping */ - float3 N = sd->N; - subsurface_color_bump_blur(kg, sd, state, &eval, &N); - - /* setup diffuse bsdf */ - subsurface_scatter_setup_diffuse_bsdf(kg, sd, sc, eval, (ss_isect.num_hits > 0), N); + subsurface_scatter_setup_diffuse_bsdf(kg, sd, sc, weight, N); } /* Random walk subsurface scattering. diff --git a/intern/cycles/kernel/kernel_types.h b/intern/cycles/kernel/kernel_types.h index aeb63b4a65e..44e7fd46adc 100644 --- a/intern/cycles/kernel/kernel_types.h +++ b/intern/cycles/kernel/kernel_types.h @@ -347,12 +347,31 @@ enum PathRayFlag { PATH_RAY_ALL_VISIBILITY = ((1 << 14)-1), - PATH_RAY_MIS_SKIP = (1 << 15), - PATH_RAY_DIFFUSE_ANCESTOR = (1 << 16), - PATH_RAY_SINGLE_PASS_DONE = (1 << 17), - PATH_RAY_SHADOW_CATCHER = (1 << 18), - PATH_RAY_STORE_SHADOW_INFO = (1 << 19), - PATH_RAY_TRANSPARENT_BACKGROUND = (1 << 20), + /* Don't apply multiple importance sampling weights to emission from + * lamp or surface hits, because they were not direct light sampled. */ + PATH_RAY_MIS_SKIP = (1 << 14), + /* Diffuse bounce earlier in the path, skip SSS to improve performance + * and avoid branching twice with disk sampling SSS. */ + PATH_RAY_DIFFUSE_ANCESTOR = (1 << 15), + /* Single pass has been written. */ + PATH_RAY_SINGLE_PASS_DONE = (1 << 16), + /* Ray is behind a shadow catcher .*/ + PATH_RAY_SHADOW_CATCHER = (1 << 17), + /* Store shadow data for shadow catcher or denoising. */ + PATH_RAY_STORE_SHADOW_INFO = (1 << 18), + /* Zero background alpha, for camera or transparent glass rays. */ + PATH_RAY_TRANSPARENT_BACKGROUND = (1 << 19), + /* Terminate ray immediately at next bounce. */ + PATH_RAY_TERMINATE_IMMEDIATE = (1 << 20), + /* Ray is to be terminated, but continue with transparent bounces and + * emission as long as we encounter them. This is required to make the + * MIS between direct and indirect light rays match, as shadow rays go + * through transparent surfaces to reach emisison too. */ + PATH_RAY_TERMINATE_AFTER_TRANSPARENT = (1 << 21), + /* Ray is to be terminated. */ + PATH_RAY_TERMINATE = (PATH_RAY_TERMINATE_IMMEDIATE|PATH_RAY_TERMINATE_AFTER_TRANSPARENT), + /* Path and shader is being evaluated for direct lighting emission. */ + PATH_RAY_EMISSION = (1 << 22) }; /* Closure Label */ diff --git a/intern/cycles/kernel/kernel_volume.h b/intern/cycles/kernel/kernel_volume.h index 7b67a37adc5..3274e05f98e 100644 --- a/intern/cycles/kernel/kernel_volume.h +++ b/intern/cycles/kernel/kernel_volume.h @@ -45,7 +45,7 @@ ccl_device_inline bool volume_shader_extinction_sample(KernelGlobals *kg, float3 *extinction) { sd->P = P; - shader_eval_volume(kg, sd, state, state->volume_stack, PATH_RAY_SHADOW, 0); + shader_eval_volume(kg, sd, state, state->volume_stack, PATH_RAY_SHADOW); if(sd->flag & SD_EXTINCTION) { *extinction = sd->closure_transparent_extinction; @@ -64,7 +64,7 @@ ccl_device_inline bool volume_shader_sample(KernelGlobals *kg, VolumeShaderCoefficients *coeff) { sd->P = P; - shader_eval_volume(kg, sd, state, state->volume_stack, state->flag, kernel_data.integrator.max_closures); + shader_eval_volume(kg, sd, state, state->volume_stack, state->flag); if(!(sd->flag & (SD_EXTINCTION|SD_SCATTER|SD_EMISSION))) return false; @@ -76,18 +76,11 @@ ccl_device_inline bool volume_shader_sample(KernelGlobals *kg, make_float3(0.0f, 0.0f, 0.0f); if(sd->flag & SD_SCATTER) { - if(state->bounce < kernel_data.integrator.max_bounce && - state->volume_bounce < kernel_data.integrator.max_volume_bounce) { - for(int i = 0; i < sd->num_closure; i++) { - const ShaderClosure *sc = &sd->closure[i]; + for(int i = 0; i < sd->num_closure; i++) { + const ShaderClosure *sc = &sd->closure[i]; - if(CLOSURE_IS_VOLUME(sc->type)) - coeff->sigma_s += sc->weight; - } - } - else { - /* When at the max number of bounces, clear scattering. */ - sd->flag &= ~SD_SCATTER; + if(CLOSURE_IS_VOLUME(sc->type)) + coeff->sigma_s += sc->weight; } } diff --git a/intern/cycles/kernel/osl/osl_closures.cpp b/intern/cycles/kernel/osl/osl_closures.cpp index d0c357580fd..ee16ddaf0fd 100644 --- a/intern/cycles/kernel/osl/osl_closures.cpp +++ b/intern/cycles/kernel/osl/osl_closures.cpp @@ -705,7 +705,7 @@ public: void setup(ShaderData *sd, int path_flag, float3 weight) { - bsdf_transparent_setup(sd, weight); + bsdf_transparent_setup(sd, weight, path_flag); } }; diff --git a/intern/cycles/kernel/shaders/node_bevel.osl b/intern/cycles/kernel/shaders/node_bevel.osl index a5b185b6b4c..9c4ca15be17 100644 --- a/intern/cycles/kernel/shaders/node_bevel.osl +++ b/intern/cycles/kernel/shaders/node_bevel.osl @@ -23,9 +23,9 @@ shader node_bevel( output normal NormalOut = N) { /* Abuse texture call with special @bevel token. */ - NormalOut = (normal)(color)texture("@bevel", samples, Radius); + vector bevel_N = (normal)(color)texture("@bevel", samples, Radius); /* Preserve input normal. */ - NormalOut = normalize(N + (NormalOut - NormalIn)); + NormalOut = normalize(NormalIn + (bevel_N - N)); } diff --git a/intern/cycles/kernel/split/kernel_indirect_subsurface.h b/intern/cycles/kernel/split/kernel_indirect_subsurface.h index e9fe5552e8c..b65f3d1a940 100644 --- a/intern/cycles/kernel/split/kernel_indirect_subsurface.h +++ b/intern/cycles/kernel/split/kernel_indirect_subsurface.h @@ -49,28 +49,22 @@ ccl_device void kernel_indirect_subsurface(KernelGlobals *kg) ccl_global Ray *ray = &kernel_split_state.ray[ray_index]; ccl_global float3 *throughput = &kernel_split_state.throughput[ray_index]; -#ifdef __BRANCHED_PATH__ - if(!kernel_data.integrator.branched) { -#endif - if(IS_STATE(ray_state, ray_index, RAY_UPDATE_BUFFER)) { - ccl_addr_space SubsurfaceIndirectRays *ss_indirect = &kernel_split_state.ss_rays[ray_index]; + if(IS_STATE(ray_state, ray_index, RAY_UPDATE_BUFFER)) { + ccl_addr_space SubsurfaceIndirectRays *ss_indirect = &kernel_split_state.ss_rays[ray_index]; - /* Trace indirect subsurface rays by restarting the loop. this uses less - * stack memory than invoking kernel_path_indirect. - */ - if(ss_indirect->num_rays) { - kernel_path_subsurface_setup_indirect(kg, - ss_indirect, - state, - ray, - L, - throughput); - ASSIGN_RAY_STATE(ray_state, ray_index, RAY_REGENERATED); - } + /* Trace indirect subsurface rays by restarting the loop. this uses less + * stack memory than invoking kernel_path_indirect. + */ + if(ss_indirect->num_rays) { + kernel_path_subsurface_setup_indirect(kg, + ss_indirect, + state, + ray, + L, + throughput); + ASSIGN_RAY_STATE(ray_state, ray_index, RAY_REGENERATED); } -#ifdef __BRANCHED_PATH__ } -#endif #endif /* __SUBSURFACE__ */ diff --git a/intern/cycles/kernel/split/kernel_shader_eval.h b/intern/cycles/kernel/split/kernel_shader_eval.h index 2409d1ba28b..2bc2d300699 100644 --- a/intern/cycles/kernel/split/kernel_shader_eval.h +++ b/intern/cycles/kernel/split/kernel_shader_eval.h @@ -50,7 +50,7 @@ ccl_device void kernel_shader_eval(KernelGlobals *kg) if(IS_STATE(ray_state, ray_index, RAY_ACTIVE)) { ccl_global PathState *state = &kernel_split_state.path_state[ray_index]; - shader_eval_surface(kg, kernel_split_sd(sd, ray_index), state, state->flag, kernel_data.integrator.max_closures); + shader_eval_surface(kg, kernel_split_sd(sd, ray_index), state, state->flag); #ifdef __BRANCHED_PATH__ if(kernel_data.integrator.branched) { shader_merge_closures(kernel_split_sd(sd, ray_index)); diff --git a/intern/cycles/kernel/split/kernel_split_common.h b/intern/cycles/kernel/split/kernel_split_common.h index 21886ee62ee..b52e7bddc82 100644 --- a/intern/cycles/kernel/split/kernel_split_common.h +++ b/intern/cycles/kernel/split/kernel_split_common.h @@ -59,7 +59,12 @@ ccl_device_inline void kernel_split_path_end(KernelGlobals *kg, int ray_index) ccl_global char *ray_state = kernel_split_state.ray_state; #ifdef __BRANCHED_PATH__ - if(IS_FLAG(ray_state, ray_index, RAY_BRANCHED_INDIRECT_SHARED)) { + ccl_addr_space SubsurfaceIndirectRays *ss_indirect = &kernel_split_state.ss_rays[ray_index]; + + if(ss_indirect->num_rays) { + ASSIGN_RAY_STATE(ray_state, ray_index, RAY_UPDATE_BUFFER); + } + else if(IS_FLAG(ray_state, ray_index, RAY_BRANCHED_INDIRECT_SHARED)) { int orig_ray = kernel_split_state.branched_state[ray_index].original_ray; PathRadiance *L = &kernel_split_state.path_radiance[ray_index]; diff --git a/intern/cycles/kernel/split/kernel_subsurface_scatter.h b/intern/cycles/kernel/split/kernel_subsurface_scatter.h index e50d63ea3bc..af0303d8608 100644 --- a/intern/cycles/kernel/split/kernel_subsurface_scatter.h +++ b/intern/cycles/kernel/split/kernel_subsurface_scatter.h @@ -228,7 +228,9 @@ ccl_device void kernel_subsurface_scatter(KernelGlobals *kg) if(sd->flag & SD_BSSRDF) { #ifdef __BRANCHED_PATH__ - if(!kernel_data.integrator.branched) { + if(!kernel_data.integrator.branched || + IS_FLAG(ray_state, ray_index, RAY_BRANCHED_INDIRECT)) + { #endif if(kernel_path_subsurface_scatter(kg, sd, @@ -243,27 +245,6 @@ ccl_device void kernel_subsurface_scatter(KernelGlobals *kg) } #ifdef __BRANCHED_PATH__ } - else if(IS_FLAG(ray_state, ray_index, RAY_BRANCHED_INDIRECT)) { - float bssrdf_u, bssrdf_v; - path_state_rng_2D(kg, - state, - PRNG_BSDF_U, - &bssrdf_u, &bssrdf_v); - - const ShaderClosure *sc = shader_bssrdf_pick(sd, throughput, &bssrdf_u); - - /* do bssrdf scatter step if we picked a bssrdf closure */ - if(sc) { - uint lcg_state = lcg_state_init_addrspace(state, 0x68bc21eb); - subsurface_scatter_step(kg, - sd, - state, - sc, - &lcg_state, - bssrdf_u, bssrdf_v, - false); - } - } else { kernel_split_branched_path_subsurface_indirect_light_init(kg, ray_index); diff --git a/intern/cycles/kernel/svm/svm_bevel.h b/intern/cycles/kernel/svm/svm_bevel.h index dcfe4ad71b8..6d5a10db98f 100644 --- a/intern/cycles/kernel/svm/svm_bevel.h +++ b/intern/cycles/kernel/svm/svm_bevel.h @@ -216,7 +216,7 @@ ccl_device void svm_node_bevel( if(stack_valid(normal_offset)) { /* Preserve input normal. */ float3 ref_N = stack_load_float3(stack, normal_offset); - bevel_N = normalize(sd->N + (bevel_N - ref_N)); + bevel_N = normalize(ref_N + (bevel_N - sd->N));; } stack_store_float3(stack, out_offset, bevel_N); diff --git a/intern/cycles/kernel/svm/svm_closure.h b/intern/cycles/kernel/svm/svm_closure.h index 5398f36c267..24452c81fe0 100644 --- a/intern/cycles/kernel/svm/svm_closure.h +++ b/intern/cycles/kernel/svm/svm_closure.h @@ -449,7 +449,7 @@ ccl_device void svm_node_closure_bsdf(KernelGlobals *kg, ShaderData *sd, float * } case CLOSURE_BSDF_TRANSPARENT_ID: { float3 weight = sd->svm_closure_weight * mix_weight; - bsdf_transparent_setup(sd, weight); + bsdf_transparent_setup(sd, weight, path_flag); break; } case CLOSURE_BSDF_REFLECTION_ID: @@ -728,7 +728,7 @@ ccl_device void svm_node_closure_bsdf(KernelGlobals *kg, ShaderData *sd, float * * the throughput can blow up after multiple bounces. we * better figure out a way to skip backfaces from rays * spawned by transmission from the front */ - bsdf_transparent_setup(sd, make_float3(1.0f, 1.0f, 1.0f)); + bsdf_transparent_setup(sd, make_float3(1.0f, 1.0f, 1.0f), path_flag); } else { HairBsdf *bsdf = (HairBsdf*)bsdf_alloc(sd, sizeof(HairBsdf), weight); diff --git a/intern/cycles/render/nodes.cpp b/intern/cycles/render/nodes.cpp index 48613a9324c..56c9e669a5c 100644 --- a/intern/cycles/render/nodes.cpp +++ b/intern/cycles/render/nodes.cpp @@ -3463,7 +3463,7 @@ NODE_DEFINE(ParticleInfoNode) { NodeType* type = NodeType::add("particle_info", create, NodeType::SHADER); - SOCKET_OUT_FLOAT(random, "Index"); + SOCKET_OUT_FLOAT(index, "Index"); SOCKET_OUT_FLOAT(random, "Random"); SOCKET_OUT_FLOAT(age, "Age"); SOCKET_OUT_FLOAT(lifetime, "Lifetime"); @@ -3576,7 +3576,7 @@ NODE_DEFINE(HairInfoNode) SOCKET_OUT_FLOAT(is_strand, "Is Strand"); SOCKET_OUT_FLOAT(intercept, "Intercept"); SOCKET_OUT_FLOAT(thickness, "Thickness"); - SOCKET_OUT_NORMAL(tangent Normal, "Tangent Normal"); + SOCKET_OUT_NORMAL(tangent_normal, "Tangent Normal"); #if 0 /*output for minimum hair width transparency - deactivated */ SOCKET_OUT_FLOAT(fade, "Fade"); #endif diff --git a/intern/cycles/render/osl.cpp b/intern/cycles/render/osl.cpp index 5c5ac6e2be9..4d066c89b76 100644 --- a/intern/cycles/render/osl.cpp +++ b/intern/cycles/render/osl.cpp @@ -233,18 +233,25 @@ void OSLShaderManager::shading_system_init() "glossy", /* PATH_RAY_GLOSSY */ "singular", /* PATH_RAY_SINGULAR */ "transparent", /* PATH_RAY_TRANSPARENT */ + "shadow", /* PATH_RAY_SHADOW_OPAQUE_NON_CATCHER */ "shadow", /* PATH_RAY_SHADOW_OPAQUE_CATCHER */ "shadow", /* PATH_RAY_SHADOW_TRANSPARENT_NON_CATCHER */ "shadow", /* PATH_RAY_SHADOW_TRANSPARENT_CATCHER */ "__unused__", + "volume_scatter", /* PATH_RAY_VOLUME_SCATTER */ + "__unused__", + "__unused__", "diffuse_ancestor", /* PATH_RAY_DIFFUSE_ANCESTOR */ "__unused__", "__unused__", - "__unused__", /* PATH_RAY_SINGLE_PASS_DONE */ - "volume_scatter", /* PATH_RAY_VOLUME_SCATTER */ + "__unused__", + "__unused__", + "__unused__", + "__unused__", + "__unused__", }; const int nraytypes = sizeof(raytypes)/sizeof(raytypes[0]); diff --git a/source/blender/blenkernel/intern/fcurve.c b/source/blender/blenkernel/intern/fcurve.c index 9c85a26b58a..d7e8c62375b 100644 --- a/source/blender/blenkernel/intern/fcurve.c +++ b/source/blender/blenkernel/intern/fcurve.c @@ -804,7 +804,7 @@ void bezt_add_to_cfra_elem(ListBase *lb, BezTriple *bezt) for (ce = lb->first; ce; ce = ce->next) { /* double key? */ - if (ce->cfra == bezt->vec[1][0]) { + if (IS_EQT(ce->cfra, bezt->vec[1][0], BEZT_BINARYSEARCH_THRESH)) { if (bezt->f2 & SELECT) ce->sel = bezt->f2; return; } diff --git a/source/blender/depsgraph/intern/builder/deg_builder_relations_rig.cc b/source/blender/depsgraph/intern/builder/deg_builder_relations_rig.cc index f3c3772e512..b501e4b1ac4 100644 --- a/source/blender/depsgraph/intern/builder/deg_builder_relations_rig.cc +++ b/source/blender/depsgraph/intern/builder/deg_builder_relations_rig.cc @@ -181,9 +181,6 @@ void DepsgraphRelationBuilder::build_ik_pose(Object *object, bPoseChannel *parchan = pchan; /* exclude tip from chain? */ if (!(data->flag & CONSTRAINT_IK_TIP)) { - OperationKey tip_transforms_key(&object->id, DEG_NODE_TYPE_BONE, - parchan->name, DEG_OPCODE_BONE_LOCAL); - add_relation(solver_key, tip_transforms_key, "IK Solver Result"); parchan = pchan->parent; } diff --git a/source/blender/depsgraph/intern/depsgraph.cc b/source/blender/depsgraph/intern/depsgraph.cc index 3b5ea2bfc3f..0ae5f44c3ed 100644 --- a/source/blender/depsgraph/intern/depsgraph.cc +++ b/source/blender/depsgraph/intern/depsgraph.cc @@ -161,16 +161,20 @@ static bool pointer_to_component_node_criteria( Object *object = (Object *)ptr->id.data; bConstraint *con = (bConstraint *)ptr->data; /* Check whether is object or bone constraint. */ + /* NOTE: Currently none of the area can address transform of an object + * at a given constraint, but for rigging one might use constraint + * influence to be used to drive some corrective shape keys or so. + */ if (BLI_findindex(&object->constraints, con) != -1) { - /* Constraint is defining object transform. */ *type = DEG_NODE_TYPE_TRANSFORM; + *operation_code = DEG_OPCODE_TRANSFORM_LOCAL; return true; } else if (object->pose != NULL) { LISTBASE_FOREACH(bPoseChannel *, pchan, &object->pose->chanbase) { if (BLI_findindex(&pchan->constraints, con) != -1) { - /* bone transforms */ *type = DEG_NODE_TYPE_BONE; + *operation_code = DEG_OPCODE_BONE_LOCAL; *subdata = pchan->name; return true; } diff --git a/source/blender/editors/animation/anim_filter.c b/source/blender/editors/animation/anim_filter.c index bc901d7e13f..eb101fd89a7 100644 --- a/source/blender/editors/animation/anim_filter.c +++ b/source/blender/editors/animation/anim_filter.c @@ -880,6 +880,7 @@ static bAnimListElem *make_new_animlistelem(void *data, short datatype, ID *owne break; } case ANIMTYPE_FCURVE: + case ANIMTYPE_NLACURVE: /* practically the same as ANIMTYPE_FCURVE. Differences are applied post-creation */ { FCurve *fcu = (FCurve *)data; @@ -1089,13 +1090,14 @@ static bool name_matches_dopesheet_filter(bDopeSheet *ads, char *name) /* (Display-)Name-based F-Curve filtering * NOTE: when this function returns true, the F-Curve is to be skipped */ -static bool skip_fcurve_with_name(bDopeSheet *ads, FCurve *fcu, ID *owner_id) +static bool skip_fcurve_with_name(bDopeSheet *ads, FCurve *fcu, eAnim_ChannelType channel_type, void *owner, ID *owner_id) { bAnimListElem ale_dummy = {NULL}; const bAnimChannelType *acf; - /* create a dummy wrapper for the F-Curve */ - ale_dummy.type = ANIMTYPE_FCURVE; + /* create a dummy wrapper for the F-Curve, so we can get typeinfo for it */ + ale_dummy.type = channel_type; + ale_dummy.owner = owner; ale_dummy.id = owner_id; ale_dummy.data = fcu; @@ -1158,8 +1160,9 @@ static bool fcurve_has_errors(FCurve *fcu) } /* find the next F-Curve that is usable for inclusion */ -static FCurve *animfilter_fcurve_next(bDopeSheet *ads, FCurve *first, bActionGroup *grp, int filter_mode, ID *owner_id) +static FCurve *animfilter_fcurve_next(bDopeSheet *ads, FCurve *first, eAnim_ChannelType channel_type, int filter_mode, void *owner, ID *owner_id) { + bActionGroup *grp = (channel_type == ANIMTYPE_FCURVE) ? owner : NULL; FCurve *fcu = NULL; /* loop over F-Curves - assume that the caller of this has already checked that these should be included @@ -1193,7 +1196,7 @@ static FCurve *animfilter_fcurve_next(bDopeSheet *ads, FCurve *first, bActionGro if (!(filter_mode & ANIMFILTER_ACTIVE) || (fcu->flag & FCURVE_ACTIVE)) { /* name based filtering... */ if ( ((ads) && (ads->filterflag & ADS_FILTER_BY_FCU_NAME)) && (owner_id) ) { - if (skip_fcurve_with_name(ads, fcu, owner_id)) + if (skip_fcurve_with_name(ads, fcu, channel_type, owner, owner_id)) continue; } @@ -1216,7 +1219,10 @@ static FCurve *animfilter_fcurve_next(bDopeSheet *ads, FCurve *first, bActionGro return NULL; } -static size_t animfilter_fcurves(ListBase *anim_data, bDopeSheet *ads, FCurve *first, bActionGroup *grp, int filter_mode, ID *owner_id) +static size_t animfilter_fcurves(ListBase *anim_data, bDopeSheet *ads, + FCurve *first, eAnim_ChannelType fcurve_type, + int filter_mode, + void *owner, ID *owner_id) { FCurve *fcu; size_t items = 0; @@ -1230,8 +1236,18 @@ static size_t animfilter_fcurves(ListBase *anim_data, bDopeSheet *ads, FCurve *f * 4) the fcu pointer is set to the F-Curve after the one we just added, so that we can keep going through * the rest of the F-Curve list without an eternal loop. Back to step 2 :) */ - for (fcu = first; ( (fcu = animfilter_fcurve_next(ads, fcu, grp, filter_mode, owner_id)) ); fcu = fcu->next) { - ANIMCHANNEL_NEW_CHANNEL(fcu, ANIMTYPE_FCURVE, owner_id); + for (fcu = first; ( (fcu = animfilter_fcurve_next(ads, fcu, fcurve_type, filter_mode, owner, owner_id)) ); fcu = fcu->next) { + if (UNLIKELY(fcurve_type == ANIMTYPE_NLACURVE)) { + /* NLA Control Curve - Basically the same as normal F-Curves, except we need to set some stuff differently */ + ANIMCHANNEL_NEW_CHANNEL_FULL(fcu, ANIMTYPE_NLACURVE, owner_id, { + ale->owner = owner; /* strip */ + ale->adt = NULL; /* to prevent time mapping from causing problems */ + }); + } + else { + /* Normal FCurve */ + ANIMCHANNEL_NEW_CHANNEL(fcu, ANIMTYPE_FCURVE, owner_id); + } } /* return the number of items added to the list */ @@ -1282,10 +1298,10 @@ static size_t animfilter_act_group(bAnimContext *ac, ListBase *anim_data, bDopeS /* group must be editable for its children to be editable (if we care about this) */ if (!(filter_mode & ANIMFILTER_FOREDIT) || EDITABLE_AGRP(agrp)) { /* get first F-Curve which can be used here */ - FCurve *first_fcu = animfilter_fcurve_next(ads, agrp->channels.first, agrp, filter_mode, owner_id); + FCurve *first_fcu = animfilter_fcurve_next(ads, agrp->channels.first, ANIMTYPE_FCURVE, filter_mode, agrp, owner_id); /* filter list, starting from this F-Curve */ - tmp_items += animfilter_fcurves(&tmp_data, ads, first_fcu, agrp, filter_mode, owner_id); + tmp_items += animfilter_fcurves(&tmp_data, ads, first_fcu, ANIMTYPE_FCURVE, filter_mode, agrp, owner_id); } } } @@ -1341,7 +1357,7 @@ static size_t animfilter_action(bAnimContext *ac, ListBase *anim_data, bDopeShee /* un-grouped F-Curves (only if we're not only considering those channels in the active group) */ if (!(filter_mode & ANIMFILTER_ACTGROUPED)) { FCurve *firstfcu = (lastchan) ? (lastchan->next) : (act->curves.first); - items += animfilter_fcurves(anim_data, ads, firstfcu, NULL, filter_mode, owner_id); + items += animfilter_fcurves(anim_data, ads, firstfcu, ANIMTYPE_FCURVE, filter_mode, NULL, owner_id); } /* return the number of items added to the list */ @@ -1463,36 +1479,8 @@ static size_t animfilter_nla_controls(ListBase *anim_data, bDopeSheet *ads, Anim /* for now, we only go one level deep - so controls on grouped FCurves are not handled */ for (nlt = adt->nla_tracks.first; nlt; nlt = nlt->next) { for (strip = nlt->strips.first; strip; strip = strip->next) { - ListBase strip_curves = {NULL, NULL}; - size_t strip_items = 0; - - /* create the raw items */ - strip_items += animfilter_fcurves(&strip_curves, ads, strip->fcurves.first, NULL, filter_mode, owner_id); - - /* change their types and add extra data - * - There is no point making a separate copy of animfilter_fcurves for this now/yet, - * unless we later get per-element control curves for other stuff too - */ - if (strip_items) { - bAnimListElem *ale, *ale_n = NULL; - - for (ale = strip_curves.first; ale; ale = ale_n) { - ale_n = ale->next; - - /* change the type to being a FCurve for editing NLA strip controls */ - BLI_assert(ale->type == ANIMTYPE_FCURVE); - - ale->type = ANIMTYPE_NLACURVE; - ale->owner = strip; - - ale->adt = NULL; /* XXX: This way, there are no problems with time mapping errors */ - } - } - - /* add strip curves to the set of channels inside the group being collected */ - BLI_movelisttolist(&tmp_data, &strip_curves); - BLI_assert(BLI_listbase_is_empty(&strip_curves)); - tmp_items += strip_items; + /* pass strip as the "owner", so that the name lookups (used while filtering) will resolve */ + tmp_items += animfilter_fcurves(&tmp_data, ads, strip->fcurves.first, ANIMTYPE_NLACURVE, filter_mode, strip, owner_id); } } } @@ -1543,7 +1531,7 @@ static size_t animfilter_block_data(bAnimContext *ac, ListBase *anim_data, bDope items += animfilter_nla(ac, anim_data, ads, adt, filter_mode, id); }, { /* Drivers */ - items += animfilter_fcurves(anim_data, ads, adt->drivers.first, NULL, filter_mode, id); + items += animfilter_fcurves(anim_data, ads, adt->drivers.first, ANIMTYPE_FCURVE, filter_mode, NULL, id); }, { /* NLA Control Keyframes */ items += animfilter_nla_controls(anim_data, ads, adt, filter_mode, id); diff --git a/source/blender/editors/space_action/action_select.c b/source/blender/editors/space_action/action_select.c index 3c3a71d00fd..3346c628336 100644 --- a/source/blender/editors/space_action/action_select.c +++ b/source/blender/editors/space_action/action_select.c @@ -262,7 +262,7 @@ static void borderselect_action(bAnimContext *ac, const rcti rect, short mode, s { /* loop over data selecting */ switch (ale->type) { -#if 0 /* XXXX: Keyframes are not currently shown here */ +#if 0 /* XXX: Keyframes are not currently shown here */ case ANIMTYPE_GPDATABLOCK: { bGPdata *gpd = ale->data; @@ -466,6 +466,7 @@ static void region_select_action_keys(bAnimContext *ac, const rctf *rectf_view, { /* loop over data selecting */ switch (ale->type) { +#if 0 /* XXX: Keyframes are not currently shown here */ case ANIMTYPE_GPDATABLOCK: { bGPdata *gpd = ale->data; @@ -475,6 +476,7 @@ static void region_select_action_keys(bAnimContext *ac, const rctf *rectf_view, } break; } +#endif case ANIMTYPE_GPLAYER: { ED_gplayer_frames_select_region(&ked, ale->data, mode, selectmode); @@ -718,8 +720,6 @@ static void columnselect_action_keys(bAnimContext *ac, short mode) KeyframeEditFunc select_cb, ok_cb; KeyframeEditData ked = {{NULL}}; - /* initialize keyframe editing data */ - /* build list of columns */ switch (mode) { case ACTKEYS_COLUMNSEL_KEYS: /* list of selected keys */ diff --git a/source/blender/editors/space_graph/space_graph.c b/source/blender/editors/space_graph/space_graph.c index 4b89c8db9e6..b03c6a2eb0b 100644 --- a/source/blender/editors/space_graph/space_graph.c +++ b/source/blender/editors/space_graph/space_graph.c @@ -700,13 +700,12 @@ static void graph_id_remap(ScrArea *UNUSED(sa), SpaceLink *slink, ID *old_id, ID { SpaceIpo *sgraph = (SpaceIpo *)slink; - if (!ELEM(GS(old_id->name), ID_GR)) { - return; - } - if (sgraph->ads && (ID *)sgraph->ads->filter_grp == old_id) { sgraph->ads->filter_grp = (Group *)new_id; } + if ((ID *)sgraph->ads->source == old_id) { + sgraph->ads->source = new_id; + } } /* only called once, from space/spacetypes.c */ diff --git a/source/blender/editors/space_nla/space_nla.c b/source/blender/editors/space_nla/space_nla.c index f6068087f02..03265c8dcba 100644 --- a/source/blender/editors/space_nla/space_nla.c +++ b/source/blender/editors/space_nla/space_nla.c @@ -518,13 +518,12 @@ static void nla_id_remap(ScrArea *UNUSED(sa), SpaceLink *slink, ID *old_id, ID * { SpaceNla *snla = (SpaceNla *)slink; - if (!ELEM(GS(old_id->name), ID_GR)) { - return; - } - if ((ID *)snla->ads->filter_grp == old_id) { snla->ads->filter_grp = (Group *)new_id; } + if ((ID *)snla->ads->source == old_id) { + snla->ads->source = new_id; + } } /* only called once, from space/spacetypes.c */ diff --git a/source/blender/editors/transform/transform_conversions.c b/source/blender/editors/transform/transform_conversions.c index 96970fa8a0f..9c3ed801381 100644 --- a/source/blender/editors/transform/transform_conversions.c +++ b/source/blender/editors/transform/transform_conversions.c @@ -3497,67 +3497,123 @@ static void posttrans_mask_clean(Mask *mask) } } +/* Time + Average value */ +typedef struct tRetainedKeyframe { + struct tRetainedKeyframe *next, *prev; + float frame; /* frame to cluster around */ + float val; /* average value */ + + size_t tot_count; /* number of keyframes that have been averaged */ + size_t del_count; /* number of keyframes of this sort that have been deleted so far */ +} tRetainedKeyframe; + /* Called during special_aftertrans_update to make sure selected keyframes replace * any other keyframes which may reside on that frame (that is not selected). */ static void posttrans_fcurve_clean(FCurve *fcu, const bool use_handle) { - float *selcache; /* cache for frame numbers of selected frames (fcu->totvert*sizeof(float)) */ - int len, index, i; /* number of frames in cache, item index */ - - /* allocate memory for the cache */ - // TODO: investigate using BezTriple columns instead? - if (fcu->totvert == 0 || fcu->bezt == NULL) + /* NOTE: We assume that all keys are sorted */ + ListBase retained_keys = {NULL, NULL}; + const bool can_average_points = ((fcu->flag & (FCURVE_INT_VALUES | FCURVE_DISCRETE_VALUES)) == 0); + + /* sanity checks */ + if ((fcu->totvert == 0) || (fcu->bezt == NULL)) return; - selcache = MEM_callocN(sizeof(float) * fcu->totvert, "FCurveSelFrameNums"); - len = 0; - index = 0; - - /* We do 2 loops, 1 for marking keyframes for deletion, one for deleting - * as there is no guarantee what order the keyframes are exactly, even though - * they have been sorted by time. + + /* 1) Identify selected keyframes, and average the values on those + * in case there are collisions due to multiple keys getting scaled + * to all end up on the same frame */ - - /* Loop 1: find selected keyframes */ - for (i = 0; i < fcu->totvert; i++) { + for (int i = 0; i < fcu->totvert; i++) { BezTriple *bezt = &fcu->bezt[i]; if (BEZT_ISSEL_ANY(bezt)) { - selcache[index] = bezt->vec[1][0]; - index++; - len++; + bool found = false; + + /* If there's another selected frame here, merge it */ + for (tRetainedKeyframe *rk = retained_keys.last; rk; rk = rk->prev) { + if (IS_EQT(rk->frame, bezt->vec[1][0], BEZT_BINARYSEARCH_THRESH)) { + rk->val += bezt->vec[1][1]; + rk->tot_count++; + + found = true; + break; + } + else if (rk->frame < bezt->vec[1][0]) { + /* Terminate early if have passed the supposed insertion point? */ + break; + } + } + + /* If nothing found yet, create a new one */ + if (found == false) { + tRetainedKeyframe *rk = MEM_callocN(sizeof(tRetainedKeyframe), "tRetainedKeyframe"); + + rk->frame = bezt->vec[1][0]; + rk->val = bezt->vec[1][1]; + rk->tot_count = 1; + + BLI_addtail(&retained_keys, rk); + } } } - - /* Loop 2: delete unselected keyframes on the same frames - * (if any keyframes were found, or the whole curve wasn't affected) + + if (BLI_listbase_is_empty(&retained_keys)) { + /* This may happen if none of the points were selected... */ + if (G.debug & G_DEBUG) { + printf("%s: nothing to do for FCurve %p (rna_path = '%s')\n", __func__, fcu, fcu->rna_path); + } + return; + } + else { + /* Compute the average values for each retained keyframe */ + for (tRetainedKeyframe *rk = retained_keys.first; rk; rk = rk->next) { + rk->val = rk->val / (float)rk->tot_count; + } + } + + /* 2) Delete all keyframes duplicating the "retained keys" found above + * - Most of these will be unselected keyframes + * - Some will be selected keyframes though. For those, we only keep the last one + * (or else everything is gone), and replace its value with the averaged value. */ - if ((len) && (len != fcu->totvert)) { - for (i = fcu->totvert - 1; i >= 0; i--) { - BezTriple *bezt = &fcu->bezt[i]; - - if (BEZT_ISSEL_ANY(bezt) == 0) { - /* check beztriple should be removed according to cache */ - for (index = 0; index < len; index++) { - if (IS_EQF(bezt->vec[1][0], selcache[index])) { - delete_fcurve_key(fcu, i, 0); - break; + for (int i = fcu->totvert - 1; i >= 0; i--) { + BezTriple *bezt = &fcu->bezt[i]; + + /* Is this a candidate for deletion? */ + /* TODO: Replace loop with an O(1) lookup instead */ + for (tRetainedKeyframe *rk = retained_keys.last; rk; rk = rk->prev) { + if (IS_EQT(bezt->vec[1][0], rk->frame, BEZT_BINARYSEARCH_THRESH)) { + /* Delete this keyframe, unless it's the last selected one on this frame, + * in which case, we'll update its value instead + */ + if (BEZT_ISSEL_ANY(bezt) && (rk->del_count == rk->tot_count - 1)) { + /* Update keyframe */ + if (can_average_points) { + /* TODO: update handles too? */ + bezt->vec[1][1] = rk->val; } - else if (bezt->vec[1][0] < selcache[index]) - break; } + else { + /* Delete keyframe */ + delete_fcurve_key(fcu, i, 0); + } + + /* Stop searching for matching RK's */ + rk->del_count++; + break; } } - - testhandles_fcurve(fcu, use_handle); } - - /* free cache */ - MEM_freeN(selcache); + + /* 3) Recalculate handles */ + testhandles_fcurve(fcu, use_handle); + + /* cleanup */ + BLI_freelistN(&retained_keys); } - /* Called by special_aftertrans_update to make sure selected keyframes replace * any other keyframes which may reside on that frame (that is not selected). * remake_action_ipos should have already been called diff --git a/source/blender/nodes/shader/nodes/node_shader_bsdf_principled.c b/source/blender/nodes/shader/nodes/node_shader_bsdf_principled.c index 1c291cb5b83..1989290558b 100644 --- a/source/blender/nodes/shader/nodes/node_shader_bsdf_principled.c +++ b/source/blender/nodes/shader/nodes/node_shader_bsdf_principled.c @@ -145,7 +145,7 @@ void register_node_type_sh_bsdf_principled(void) sh_node_type_base(&ntype, SH_NODE_BSDF_PRINCIPLED, "Principled BSDF", NODE_CLASS_SHADER, 0); node_type_compatibility(&ntype, NODE_NEW_SHADING); node_type_socket_templates(&ntype, sh_node_bsdf_principled_in, sh_node_bsdf_principled_out); - node_type_size_preset(&ntype, NODE_SIZE_MIDDLE); + node_type_size_preset(&ntype, NODE_SIZE_LARGE); node_type_init(&ntype, node_shader_init_principled); node_type_storage(&ntype, "", NULL, NULL); node_type_gpu(&ntype, node_shader_gpu_bsdf_principled); |