griefith/test
1
0
Fork 0
Code Issues Pull Requests Actions 1 Packages Projects Releases Wiki Activity
Files
7ee518cf705fcebee2d110bfbb6bf00a0f170efb
test/intern/cycles/kernel/kernels/cpu/kernel_cpu_impl.h

Ignoring revisions in .git-blame-ignore-revs. Click here to bypass and see the normal blame view.

233 lines
8.0 KiB
C
Raw Normal View History

Cycles: Deduplicte CPU kernel declaration and definition code Main goal is to make kernel signatures editing easier and less prone to the errors caused by missing function signature update or so. This will also make it easier to add new CPU architectures. Reviewers: juicyfruit, dingto, lukasstockner97, brecht Reviewed By: dingto, lukasstockner97, brecht Differential Revision: https://developer.blender.org/D1703
2015-12-30 17:54:02 +05:00
/*
* Copyright 2011-2013 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.
*/
/* Templated common implementation part of all CPU kernels.
*
* The idea is that particular .cpp files sets needed optimization flags and
* simply includes this file without worry of copying actual implementation over.
*/
Cleanup: tweak Cycles #includes in preparation for clang-format sorting
2020-03-06 14:15:21 +01:00
// clang-format off
Cycles: Make all #include statements relative to cycles source directory The idea is to make include statements more explicit and obvious where the file is coming from, additionally reducing chance of wrong header being picked up. For example, it was not obvious whether bvh.h was refferring to builder or traversal, whenter node.h is a generic graph node or a shader node and cases like that. Surely this might look obvious for the active developers, but after some time of not touching the code it becomes less obvious where file is coming from. This was briefly mentioned in T50824 and seems @brecht is fine with such explicitness, but need to agree with all active developers before committing this. Please note that this patch is lacking changes related on GPU/OpenCL support. This will be solved if/when we all agree this is a good idea to move forward. Reviewers: brecht, lukasstockner97, maiself, nirved, dingto, juicyfruit, swerner Reviewed By: lukasstockner97, maiself, nirved, dingto Subscribers: brecht Differential Revision: https://developer.blender.org/D2586
2017-03-28 20:39:14 +02:00
#include "kernel/kernel_compat_cpu.h"
Cycles: CPU implementation of split kernel
2017-02-14 06:20:48 -05:00
Cycles: Fix building with native only option Approach suggested by Lukas S.
2017-05-16 15:59:57 -04:00
#ifndef KERNEL_STUB
# ifndef __SPLIT_KERNEL__
# include "kernel/kernel_math.h"
# include "kernel/kernel_types.h"
# include "kernel/split/kernel_split_data.h"
# include "kernel/kernel_globals.h"
Cycles: Query XYZ to/from Scene Linear conversion from OCIO instead of assuming sRGB I've limited it to just the RGB<->XYZ stuff for now, correct image handling is the next step. Reviewers: brecht, sergey Differential Revision: https://developer.blender.org/D3478
2018-06-14 17:48:19 +02:00
# include "kernel/kernel_color.h"
Cycles: Fix building with native only option Approach suggested by Lukas S.
2017-05-16 15:59:57 -04:00
# include "kernel/kernels/cpu/kernel_cpu_image.h"
# include "kernel/kernel_film.h"
# include "kernel/kernel_path.h"
# include "kernel/kernel_path_branched.h"
# include "kernel/kernel_bake.h"
# else
# include "kernel/split/kernel_split_common.h"
# include "kernel/split/kernel_data_init.h"
# include "kernel/split/kernel_path_init.h"
# include "kernel/split/kernel_scene_intersect.h"
# include "kernel/split/kernel_lamp_emission.h"
# include "kernel/split/kernel_do_volume.h"
# include "kernel/split/kernel_queue_enqueue.h"
# include "kernel/split/kernel_indirect_background.h"
# include "kernel/split/kernel_shader_setup.h"
# include "kernel/split/kernel_shader_sort.h"
# include "kernel/split/kernel_shader_eval.h"
# include "kernel/split/kernel_holdout_emission_blurring_pathtermination_ao.h"
# include "kernel/split/kernel_subsurface_scatter.h"
# include "kernel/split/kernel_direct_lighting.h"
# include "kernel/split/kernel_shadow_blocked_ao.h"
# include "kernel/split/kernel_shadow_blocked_dl.h"
Cycles: Add kernel to enqueue inactive rays The queue will be used to make reuse of inactive threads to keep the GPU more busy.
2017-05-29 20:40:26 -04:00
# include "kernel/split/kernel_enqueue_inactive.h"
Cycles: Fix building with native only option Approach suggested by Lukas S.
2017-05-16 15:59:57 -04:00
# include "kernel/split/kernel_next_iteration_setup.h"
# include "kernel/split/kernel_indirect_subsurface.h"
# include "kernel/split/kernel_buffer_update.h"
Adaptive Sampling for Cycles. This feature takes some inspiration from "RenderMan: An Advanced Path Tracing Architecture for Movie Rendering" and "A Hierarchical Automatic Stopping Condition for Monte Carlo Global Illumination" The basic principle is as follows: While samples are being added to a pixel, the adaptive sampler writes half of the samples to a separate buffer. This gives it two separate estimates of the same pixel, and by comparing their difference it estimates convergence. Once convergence drops below a given threshold, the pixel is considered done. When a pixel has not converged yet and needs more samples than the minimum, its immediate neighbors are also set to take more samples. This is done in order to more reliably detect sharp features such as caustics. A 3x3 box filter that is run periodically over the tile buffer is used for that purpose. After a tile has finished rendering, the values of all passes are scaled as if they were rendered with the full number of samples. This way, any code operating on these buffers, for example the denoiser, does not need to be changed for per-pixel sample counts. Reviewed By: brecht, #cycles Differential Revision: https://developer.blender.org/D4686
2020-03-05 12:05:42 +01:00
# include "kernel/split/kernel_adaptive_stopping.h"
# include "kernel/split/kernel_adaptive_filter_x.h"
# include "kernel/split/kernel_adaptive_filter_y.h"
# include "kernel/split/kernel_adaptive_adjust_samples.h"
Cycles: Fix building with native only option Approach suggested by Lukas S.
2017-05-16 15:59:57 -04:00
# endif /* __SPLIT_KERNEL__ */
Cycles: CPU implementation of split kernel
2017-02-14 06:20:48 -05:00
#else
Cycles: Implement denoising option for reducing noise in the rendered image This commit contains the first part of the new Cycles denoising option, which filters the resulting image using information gathered during rendering to get rid of noise while preserving visual features as well as possible. To use the option, enable it in the render layer options. The default settings fit a wide range of scenes, but the user can tweak individual settings to control the tradeoff between a noise-free image, image details, and calculation time. Note that the denoiser may still change in the future and that some features are not implemented yet. The most important missing feature is animation denoising, which uses information from multiple frames at once to produce a flicker-free and smoother result. These features will be added in the future. Finally, thanks to all the people who supported this project: - Google (through the GSoC) and Theory Studios for sponsoring the development - The authors of the papers I used for implementing the denoiser (more details on them will be included in the technical docs) - The other Cycles devs for feedback on the code, especially Sergey for mentoring the GSoC project and Brecht for the code review! - And of course the users who helped with testing, reported bugs and things that could and/or should work better!
2017-05-07 14:40:58 +02:00
# define STUB_ASSERT(arch, name) \
assert(!(#name " kernel stub for architecture " #arch " was called!"))
Cycles: Fix building with native only option Approach suggested by Lukas S.
2017-05-16 15:59:57 -04:00
# ifdef __SPLIT_KERNEL__
# include "kernel/split/kernel_data_init.h"
# endif /* __SPLIT_KERNEL__ */
#endif /* KERNEL_STUB */
Cleanup: tweak Cycles #includes in preparation for clang-format sorting
2020-03-06 14:15:21 +01:00
// clang-format on
Cycles: Implement denoising option for reducing noise in the rendered image This commit contains the first part of the new Cycles denoising option, which filters the resulting image using information gathered during rendering to get rid of noise while preserving visual features as well as possible. To use the option, enable it in the render layer options. The default settings fit a wide range of scenes, but the user can tweak individual settings to control the tradeoff between a noise-free image, image details, and calculation time. Note that the denoiser may still change in the future and that some features are not implemented yet. The most important missing feature is animation denoising, which uses information from multiple frames at once to produce a flicker-free and smoother result. These features will be added in the future. Finally, thanks to all the people who supported this project: - Google (through the GSoC) and Theory Studios for sponsoring the development - The authors of the papers I used for implementing the denoiser (more details on them will be included in the technical docs) - The other Cycles devs for feedback on the code, especially Sergey for mentoring the GSoC project and Brecht for the code review! - And of course the users who helped with testing, reported bugs and things that could and/or should work better!
2017-05-07 14:40:58 +02:00
Cycles: Deduplicte CPU kernel declaration and definition code Main goal is to make kernel signatures editing easier and less prone to the errors caused by missing function signature update or so. This will also make it easier to add new CPU architectures. Reviewers: juicyfruit, dingto, lukasstockner97, brecht Reviewed By: dingto, lukasstockner97, brecht Differential Revision: https://developer.blender.org/D1703
2015-12-30 17:54:02 +05:00
CCL_NAMESPACE_BEGIN
Cycles: CPU implementation of split kernel
2017-02-14 06:20:48 -05:00
#ifndef __SPLIT_KERNEL__
Cycles: Deduplicte CPU kernel declaration and definition code Main goal is to make kernel signatures editing easier and less prone to the errors caused by missing function signature update or so. This will also make it easier to add new CPU architectures. Reviewers: juicyfruit, dingto, lukasstockner97, brecht Reviewed By: dingto, lukasstockner97, brecht Differential Revision: https://developer.blender.org/D1703
2015-12-30 17:54:02 +05:00
/* Path Tracing */
void KERNEL_FUNCTION_FULL_NAME(path_trace)(
KernelGlobals *kg, float *buffer, int sample, int x, int y, int offset, int stride)
{
Cycles: Implement denoising option for reducing noise in the rendered image This commit contains the first part of the new Cycles denoising option, which filters the resulting image using information gathered during rendering to get rid of noise while preserving visual features as well as possible. To use the option, enable it in the render layer options. The default settings fit a wide range of scenes, but the user can tweak individual settings to control the tradeoff between a noise-free image, image details, and calculation time. Note that the denoiser may still change in the future and that some features are not implemented yet. The most important missing feature is animation denoising, which uses information from multiple frames at once to produce a flicker-free and smoother result. These features will be added in the future. Finally, thanks to all the people who supported this project: - Google (through the GSoC) and Theory Studios for sponsoring the development - The authors of the papers I used for implementing the denoiser (more details on them will be included in the technical docs) - The other Cycles devs for feedback on the code, especially Sergey for mentoring the GSoC project and Brecht for the code review! - And of course the users who helped with testing, reported bugs and things that could and/or should work better!
2017-05-07 14:40:58 +02:00
# ifdef KERNEL_STUB
STUB_ASSERT(KERNEL_ARCH, path_trace);
# else
# ifdef __BRANCHED_PATH__
Cycles: Deduplicte CPU kernel declaration and definition code Main goal is to make kernel signatures editing easier and less prone to the errors caused by missing function signature update or so. This will also make it easier to add new CPU architectures. Reviewers: juicyfruit, dingto, lukasstockner97, brecht Reviewed By: dingto, lukasstockner97, brecht Differential Revision: https://developer.blender.org/D1703
2015-12-30 17:54:02 +05:00
if (kernel_data.integrator.branched) {
kernel_branched_path_trace(kg, buffer, sample, x, y, offset, stride);
}
else
Cycles: Implement denoising option for reducing noise in the rendered image This commit contains the first part of the new Cycles denoising option, which filters the resulting image using information gathered during rendering to get rid of noise while preserving visual features as well as possible. To use the option, enable it in the render layer options. The default settings fit a wide range of scenes, but the user can tweak individual settings to control the tradeoff between a noise-free image, image details, and calculation time. Note that the denoiser may still change in the future and that some features are not implemented yet. The most important missing feature is animation denoising, which uses information from multiple frames at once to produce a flicker-free and smoother result. These features will be added in the future. Finally, thanks to all the people who supported this project: - Google (through the GSoC) and Theory Studios for sponsoring the development - The authors of the papers I used for implementing the denoiser (more details on them will be included in the technical docs) - The other Cycles devs for feedback on the code, especially Sergey for mentoring the GSoC project and Brecht for the code review! - And of course the users who helped with testing, reported bugs and things that could and/or should work better!
2017-05-07 14:40:58 +02:00
# endif
Cycles: Deduplicte CPU kernel declaration and definition code Main goal is to make kernel signatures editing easier and less prone to the errors caused by missing function signature update or so. This will also make it easier to add new CPU architectures. Reviewers: juicyfruit, dingto, lukasstockner97, brecht Reviewed By: dingto, lukasstockner97, brecht Differential Revision: https://developer.blender.org/D1703
2015-12-30 17:54:02 +05:00
{
Code refactor: remove rng_state buffer and compute hash on the fly. A little faster on some benchmark scenes, a little slower on others, seems about performance neutral on average and saves a little memory.
2017-09-27 00:39:53 +02:00
kernel_path_trace(kg, buffer, sample, x, y, offset, stride);
Cycles: Deduplicte CPU kernel declaration and definition code Main goal is to make kernel signatures editing easier and less prone to the errors caused by missing function signature update or so. This will also make it easier to add new CPU architectures. Reviewers: juicyfruit, dingto, lukasstockner97, brecht Reviewed By: dingto, lukasstockner97, brecht Differential Revision: https://developer.blender.org/D1703
2015-12-30 17:54:02 +05:00
}
Cycles: Implement denoising option for reducing noise in the rendered image This commit contains the first part of the new Cycles denoising option, which filters the resulting image using information gathered during rendering to get rid of noise while preserving visual features as well as possible. To use the option, enable it in the render layer options. The default settings fit a wide range of scenes, but the user can tweak individual settings to control the tradeoff between a noise-free image, image details, and calculation time. Note that the denoiser may still change in the future and that some features are not implemented yet. The most important missing feature is animation denoising, which uses information from multiple frames at once to produce a flicker-free and smoother result. These features will be added in the future. Finally, thanks to all the people who supported this project: - Google (through the GSoC) and Theory Studios for sponsoring the development - The authors of the papers I used for implementing the denoiser (more details on them will be included in the technical docs) - The other Cycles devs for feedback on the code, especially Sergey for mentoring the GSoC project and Brecht for the code review! - And of course the users who helped with testing, reported bugs and things that could and/or should work better!
2017-05-07 14:40:58 +02:00
# endif /* KERNEL_STUB */
Cycles: Deduplicte CPU kernel declaration and definition code Main goal is to make kernel signatures editing easier and less prone to the errors caused by missing function signature update or so. This will also make it easier to add new CPU architectures. Reviewers: juicyfruit, dingto, lukasstockner97, brecht Reviewed By: dingto, lukasstockner97, brecht Differential Revision: https://developer.blender.org/D1703
2015-12-30 17:54:02 +05:00
}
/* Film */
void KERNEL_FUNCTION_FULL_NAME(convert_to_byte)(KernelGlobals *kg,
uchar4 *rgba,
float *buffer,
float sample_scale,
int x,
int y,
int offset,
int stride)
{
Cycles: Implement denoising option for reducing noise in the rendered image This commit contains the first part of the new Cycles denoising option, which filters the resulting image using information gathered during rendering to get rid of noise while preserving visual features as well as possible. To use the option, enable it in the render layer options. The default settings fit a wide range of scenes, but the user can tweak individual settings to control the tradeoff between a noise-free image, image details, and calculation time. Note that the denoiser may still change in the future and that some features are not implemented yet. The most important missing feature is animation denoising, which uses information from multiple frames at once to produce a flicker-free and smoother result. These features will be added in the future. Finally, thanks to all the people who supported this project: - Google (through the GSoC) and Theory Studios for sponsoring the development - The authors of the papers I used for implementing the denoiser (more details on them will be included in the technical docs) - The other Cycles devs for feedback on the code, especially Sergey for mentoring the GSoC project and Brecht for the code review! - And of course the users who helped with testing, reported bugs and things that could and/or should work better!
2017-05-07 14:40:58 +02:00
# ifdef KERNEL_STUB
STUB_ASSERT(KERNEL_ARCH, convert_to_byte);
# else
Cycles: Deduplicte CPU kernel declaration and definition code Main goal is to make kernel signatures editing easier and less prone to the errors caused by missing function signature update or so. This will also make it easier to add new CPU architectures. Reviewers: juicyfruit, dingto, lukasstockner97, brecht Reviewed By: dingto, lukasstockner97, brecht Differential Revision: https://developer.blender.org/D1703
2015-12-30 17:54:02 +05:00
kernel_film_convert_to_byte(kg, rgba, buffer, sample_scale, x, y, offset, stride);
Cycles: Implement denoising option for reducing noise in the rendered image This commit contains the first part of the new Cycles denoising option, which filters the resulting image using information gathered during rendering to get rid of noise while preserving visual features as well as possible. To use the option, enable it in the render layer options. The default settings fit a wide range of scenes, but the user can tweak individual settings to control the tradeoff between a noise-free image, image details, and calculation time. Note that the denoiser may still change in the future and that some features are not implemented yet. The most important missing feature is animation denoising, which uses information from multiple frames at once to produce a flicker-free and smoother result. These features will be added in the future. Finally, thanks to all the people who supported this project: - Google (through the GSoC) and Theory Studios for sponsoring the development - The authors of the papers I used for implementing the denoiser (more details on them will be included in the technical docs) - The other Cycles devs for feedback on the code, especially Sergey for mentoring the GSoC project and Brecht for the code review! - And of course the users who helped with testing, reported bugs and things that could and/or should work better!
2017-05-07 14:40:58 +02:00
# endif /* KERNEL_STUB */
Cycles: Deduplicte CPU kernel declaration and definition code Main goal is to make kernel signatures editing easier and less prone to the errors caused by missing function signature update or so. This will also make it easier to add new CPU architectures. Reviewers: juicyfruit, dingto, lukasstockner97, brecht Reviewed By: dingto, lukasstockner97, brecht Differential Revision: https://developer.blender.org/D1703
2015-12-30 17:54:02 +05:00
}
void KERNEL_FUNCTION_FULL_NAME(convert_to_half_float)(KernelGlobals *kg,
uchar4 *rgba,
float *buffer,
float sample_scale,
int x,
int y,
int offset,
int stride)
{
Cycles: Implement denoising option for reducing noise in the rendered image This commit contains the first part of the new Cycles denoising option, which filters the resulting image using information gathered during rendering to get rid of noise while preserving visual features as well as possible. To use the option, enable it in the render layer options. The default settings fit a wide range of scenes, but the user can tweak individual settings to control the tradeoff between a noise-free image, image details, and calculation time. Note that the denoiser may still change in the future and that some features are not implemented yet. The most important missing feature is animation denoising, which uses information from multiple frames at once to produce a flicker-free and smoother result. These features will be added in the future. Finally, thanks to all the people who supported this project: - Google (through the GSoC) and Theory Studios for sponsoring the development - The authors of the papers I used for implementing the denoiser (more details on them will be included in the technical docs) - The other Cycles devs for feedback on the code, especially Sergey for mentoring the GSoC project and Brecht for the code review! - And of course the users who helped with testing, reported bugs and things that could and/or should work better!
2017-05-07 14:40:58 +02:00
# ifdef KERNEL_STUB
STUB_ASSERT(KERNEL_ARCH, convert_to_half_float);
# else
Cycles: Deduplicte CPU kernel declaration and definition code Main goal is to make kernel signatures editing easier and less prone to the errors caused by missing function signature update or so. This will also make it easier to add new CPU architectures. Reviewers: juicyfruit, dingto, lukasstockner97, brecht Reviewed By: dingto, lukasstockner97, brecht Differential Revision: https://developer.blender.org/D1703
2015-12-30 17:54:02 +05:00
kernel_film_convert_to_half_float(kg, rgba, buffer, sample_scale, x, y, offset, stride);
Cycles: Implement denoising option for reducing noise in the rendered image This commit contains the first part of the new Cycles denoising option, which filters the resulting image using information gathered during rendering to get rid of noise while preserving visual features as well as possible. To use the option, enable it in the render layer options. The default settings fit a wide range of scenes, but the user can tweak individual settings to control the tradeoff between a noise-free image, image details, and calculation time. Note that the denoiser may still change in the future and that some features are not implemented yet. The most important missing feature is animation denoising, which uses information from multiple frames at once to produce a flicker-free and smoother result. These features will be added in the future. Finally, thanks to all the people who supported this project: - Google (through the GSoC) and Theory Studios for sponsoring the development - The authors of the papers I used for implementing the denoiser (more details on them will be included in the technical docs) - The other Cycles devs for feedback on the code, especially Sergey for mentoring the GSoC project and Brecht for the code review! - And of course the users who helped with testing, reported bugs and things that could and/or should work better!
2017-05-07 14:40:58 +02:00
# endif /* KERNEL_STUB */
Cycles: Deduplicte CPU kernel declaration and definition code Main goal is to make kernel signatures editing easier and less prone to the errors caused by missing function signature update or so. This will also make it easier to add new CPU architectures. Reviewers: juicyfruit, dingto, lukasstockner97, brecht Reviewed By: dingto, lukasstockner97, brecht Differential Revision: https://developer.blender.org/D1703
2015-12-30 17:54:02 +05:00
}
Cycles: code refactor to bake using regular render session and tiles There should be no user visible change from this, except that tile size now affects performance. The goal here is to simplify bake denoising in D3099, letting it reuse more denoising tiles and pass code. A lot of code is now shared with regular rendering, with the two main differences being that we read some render result passes from the bake API when starting to render a tile, and call the bake kernel instead of the path trace kernel. With this kind of design where Cycles asks for tiles from the bake API, it should eventually be easier to reduce memory usage, show tiles as they are baked, or bake multiple passes at once, though there's still quite some work needed for that. Reviewers: #cycles Subscribers: monio, wmatyjewicz, lukasstockner97, michaelknubben Differential Revision: https://developer.blender.org/D3108
2019-05-10 21:39:58 +02:00
/* Bake */
void KERNEL_FUNCTION_FULL_NAME(bake)(
KernelGlobals *kg, float *buffer, int sample, int x, int y, int offset, int stride)
{
# ifdef KERNEL_STUB
STUB_ASSERT(KERNEL_ARCH, bake);
# else
Fix Cycles build error when disabling some kernel features Differential Revision: https://developer.blender.org/D8372
2020-09-01 19:10:03 +02:00
# ifdef __BAKING__
Cycles: code refactor to bake using regular render session and tiles There should be no user visible change from this, except that tile size now affects performance. The goal here is to simplify bake denoising in D3099, letting it reuse more denoising tiles and pass code. A lot of code is now shared with regular rendering, with the two main differences being that we read some render result passes from the bake API when starting to render a tile, and call the bake kernel instead of the path trace kernel. With this kind of design where Cycles asks for tiles from the bake API, it should eventually be easier to reduce memory usage, show tiles as they are baked, or bake multiple passes at once, though there's still quite some work needed for that. Reviewers: #cycles Subscribers: monio, wmatyjewicz, lukasstockner97, michaelknubben Differential Revision: https://developer.blender.org/D3108
2019-05-10 21:39:58 +02:00
kernel_bake_evaluate(kg, buffer, sample, x, y, offset, stride);
Fix Cycles build error when disabling some kernel features Differential Revision: https://developer.blender.org/D8372
2020-09-01 19:10:03 +02:00
# endif
Cycles: code refactor to bake using regular render session and tiles There should be no user visible change from this, except that tile size now affects performance. The goal here is to simplify bake denoising in D3099, letting it reuse more denoising tiles and pass code. A lot of code is now shared with regular rendering, with the two main differences being that we read some render result passes from the bake API when starting to render a tile, and call the bake kernel instead of the path trace kernel. With this kind of design where Cycles asks for tiles from the bake API, it should eventually be easier to reduce memory usage, show tiles as they are baked, or bake multiple passes at once, though there's still quite some work needed for that. Reviewers: #cycles Subscribers: monio, wmatyjewicz, lukasstockner97, michaelknubben Differential Revision: https://developer.blender.org/D3108
2019-05-10 21:39:58 +02:00
# endif /* KERNEL_STUB */
}
Cycles: Deduplicte CPU kernel declaration and definition code Main goal is to make kernel signatures editing easier and less prone to the errors caused by missing function signature update or so. This will also make it easier to add new CPU architectures. Reviewers: juicyfruit, dingto, lukasstockner97, brecht Reviewed By: dingto, lukasstockner97, brecht Differential Revision: https://developer.blender.org/D1703
2015-12-30 17:54:02 +05:00
/* Shader Evaluate */
void KERNEL_FUNCTION_FULL_NAME(shader)(KernelGlobals *kg,
uint4 *input,
float4 *output,
int type,
Cycles-Bake: Custom Baking passes The combined pass is built with the contributions the user finds fit. It is useful for lightmap baking, as well as non-view dependent effects baking. The manual will be updated once we get closer to the 2.77 release. Meanwhile the new page can be found here: http://dalaifelinto.com/blender-manual/render/cycles/baking.html Reviewers: sergey, brecht Differential Revision: https://developer.blender.org/D1674
2016-01-15 13:00:56 -02:00
int filter,
Cycles: Deduplicte CPU kernel declaration and definition code Main goal is to make kernel signatures editing easier and less prone to the errors caused by missing function signature update or so. This will also make it easier to add new CPU architectures. Reviewers: juicyfruit, dingto, lukasstockner97, brecht Reviewed By: dingto, lukasstockner97, brecht Differential Revision: https://developer.blender.org/D1703
2015-12-30 17:54:02 +05:00
int i,
int offset,
int sample)
{
Cycles: Implement denoising option for reducing noise in the rendered image This commit contains the first part of the new Cycles denoising option, which filters the resulting image using information gathered during rendering to get rid of noise while preserving visual features as well as possible. To use the option, enable it in the render layer options. The default settings fit a wide range of scenes, but the user can tweak individual settings to control the tradeoff between a noise-free image, image details, and calculation time. Note that the denoiser may still change in the future and that some features are not implemented yet. The most important missing feature is animation denoising, which uses information from multiple frames at once to produce a flicker-free and smoother result. These features will be added in the future. Finally, thanks to all the people who supported this project: - Google (through the GSoC) and Theory Studios for sponsoring the development - The authors of the papers I used for implementing the denoiser (more details on them will be included in the technical docs) - The other Cycles devs for feedback on the code, especially Sergey for mentoring the GSoC project and Brecht for the code review! - And of course the users who helped with testing, reported bugs and things that could and/or should work better!
2017-05-07 14:40:58 +02:00
# ifdef KERNEL_STUB
STUB_ASSERT(KERNEL_ARCH, shader);
# else
Cycles: code refactor to bake using regular render session and tiles There should be no user visible change from this, except that tile size now affects performance. The goal here is to simplify bake denoising in D3099, letting it reuse more denoising tiles and pass code. A lot of code is now shared with regular rendering, with the two main differences being that we read some render result passes from the bake API when starting to render a tile, and call the bake kernel instead of the path trace kernel. With this kind of design where Cycles asks for tiles from the bake API, it should eventually be easier to reduce memory usage, show tiles as they are baked, or bake multiple passes at once, though there's still quite some work needed for that. Reviewers: #cycles Subscribers: monio, wmatyjewicz, lukasstockner97, michaelknubben Differential Revision: https://developer.blender.org/D3108
2019-05-10 21:39:58 +02:00
if (type == SHADER_EVAL_DISPLACE) {
Code refactor: split displace/background into separate kernels, remove luma.
2017-10-05 15:17:09 +02:00
kernel_displace_evaluate(kg, input, output, i);
}
Cycles: Deduplicte CPU kernel declaration and definition code Main goal is to make kernel signatures editing easier and less prone to the errors caused by missing function signature update or so. This will also make it easier to add new CPU architectures. Reviewers: juicyfruit, dingto, lukasstockner97, brecht Reviewed By: dingto, lukasstockner97, brecht Differential Revision: https://developer.blender.org/D1703
2015-12-30 17:54:02 +05:00
else {
Code refactor: split displace/background into separate kernels, remove luma.
2017-10-05 15:17:09 +02:00
kernel_background_evaluate(kg, input, output, i);
Cycles: Deduplicte CPU kernel declaration and definition code Main goal is to make kernel signatures editing easier and less prone to the errors caused by missing function signature update or so. This will also make it easier to add new CPU architectures. Reviewers: juicyfruit, dingto, lukasstockner97, brecht Reviewed By: dingto, lukasstockner97, brecht Differential Revision: https://developer.blender.org/D1703
2015-12-30 17:54:02 +05:00
}
Cycles: Implement denoising option for reducing noise in the rendered image This commit contains the first part of the new Cycles denoising option, which filters the resulting image using information gathered during rendering to get rid of noise while preserving visual features as well as possible. To use the option, enable it in the render layer options. The default settings fit a wide range of scenes, but the user can tweak individual settings to control the tradeoff between a noise-free image, image details, and calculation time. Note that the denoiser may still change in the future and that some features are not implemented yet. The most important missing feature is animation denoising, which uses information from multiple frames at once to produce a flicker-free and smoother result. These features will be added in the future. Finally, thanks to all the people who supported this project: - Google (through the GSoC) and Theory Studios for sponsoring the development - The authors of the papers I used for implementing the denoiser (more details on them will be included in the technical docs) - The other Cycles devs for feedback on the code, especially Sergey for mentoring the GSoC project and Brecht for the code review! - And of course the users who helped with testing, reported bugs and things that could and/or should work better!
2017-05-07 14:40:58 +02:00
# endif /* KERNEL_STUB */
Cycles: Deduplicte CPU kernel declaration and definition code Main goal is to make kernel signatures editing easier and less prone to the errors caused by missing function signature update or so. This will also make it easier to add new CPU architectures. Reviewers: juicyfruit, dingto, lukasstockner97, brecht Reviewed By: dingto, lukasstockner97, brecht Differential Revision: https://developer.blender.org/D1703
2015-12-30 17:54:02 +05:00
}
Cycles: CPU implementation of split kernel
2017-02-14 06:20:48 -05:00
#else /* __SPLIT_KERNEL__ */
/* Split Kernel Path Tracing */
Cycles: Implement denoising option for reducing noise in the rendered image This commit contains the first part of the new Cycles denoising option, which filters the resulting image using information gathered during rendering to get rid of noise while preserving visual features as well as possible. To use the option, enable it in the render layer options. The default settings fit a wide range of scenes, but the user can tweak individual settings to control the tradeoff between a noise-free image, image details, and calculation time. Note that the denoiser may still change in the future and that some features are not implemented yet. The most important missing feature is animation denoising, which uses information from multiple frames at once to produce a flicker-free and smoother result. These features will be added in the future. Finally, thanks to all the people who supported this project: - Google (through the GSoC) and Theory Studios for sponsoring the development - The authors of the papers I used for implementing the denoiser (more details on them will be included in the technical docs) - The other Cycles devs for feedback on the code, especially Sergey for mentoring the GSoC project and Brecht for the code review! - And of course the users who helped with testing, reported bugs and things that could and/or should work better!
2017-05-07 14:40:58 +02:00
# ifdef KERNEL_STUB
# define DEFINE_SPLIT_KERNEL_FUNCTION(name) \
void KERNEL_FUNCTION_FULL_NAME(name)(KernelGlobals * kg, KernelData * /*data*/) \
{ \
STUB_ASSERT(KERNEL_ARCH, name); \
}
ClangFormat: apply to source, most of intern Apply clang format as proposed in T53211. For details on usage and instructions for migrating branches without conflicts, see: https://wiki.blender.org/wiki/Tools/ClangFormat
2019-04-17 06:17:24 +02:00
Cycles: Fix building with native only option Approach suggested by Lukas S.
2017-05-16 15:59:57 -04:00
# define DEFINE_SPLIT_KERNEL_FUNCTION_LOCALS(name, type) \
void KERNEL_FUNCTION_FULL_NAME(name)(KernelGlobals * kg, KernelData * /*data*/) \
{ \
STUB_ASSERT(KERNEL_ARCH, name); \
}
Cycles: Implement denoising option for reducing noise in the rendered image This commit contains the first part of the new Cycles denoising option, which filters the resulting image using information gathered during rendering to get rid of noise while preserving visual features as well as possible. To use the option, enable it in the render layer options. The default settings fit a wide range of scenes, but the user can tweak individual settings to control the tradeoff between a noise-free image, image details, and calculation time. Note that the denoiser may still change in the future and that some features are not implemented yet. The most important missing feature is animation denoising, which uses information from multiple frames at once to produce a flicker-free and smoother result. These features will be added in the future. Finally, thanks to all the people who supported this project: - Google (through the GSoC) and Theory Studios for sponsoring the development - The authors of the papers I used for implementing the denoiser (more details on them will be included in the technical docs) - The other Cycles devs for feedback on the code, especially Sergey for mentoring the GSoC project and Brecht for the code review! - And of course the users who helped with testing, reported bugs and things that could and/or should work better!
2017-05-07 14:40:58 +02:00
# else
# define DEFINE_SPLIT_KERNEL_FUNCTION(name) \
Cycles: CPU implementation of split kernel
2017-02-14 06:20:48 -05:00
void KERNEL_FUNCTION_FULL_NAME(name)(KernelGlobals * kg, KernelData * /*data*/) \
{ \
kernel_##name(kg); \
}
ClangFormat: apply to source, most of intern Apply clang format as proposed in T53211. For details on usage and instructions for migrating branches without conflicts, see: https://wiki.blender.org/wiki/Tools/ClangFormat
2019-04-17 06:17:24 +02:00
Cycles: Fix building with native only option Approach suggested by Lukas S.
2017-05-16 15:59:57 -04:00
# define DEFINE_SPLIT_KERNEL_FUNCTION_LOCALS(name, type) \
Cycles: Define ccl_local variables in kernel functions Declaring ccl_local in a device function is not supported by certain compilers.
2017-03-08 13:34:29 +01:00
void KERNEL_FUNCTION_FULL_NAME(name)(KernelGlobals * kg, KernelData * /*data*/) \
{ \
ccl_local type locals; \
kernel_##name(kg, &locals); \
}
Cycles: Fix building with native only option Approach suggested by Lukas S.
2017-05-16 15:59:57 -04:00
# endif /* KERNEL_STUB */
Cycles: Define ccl_local variables in kernel functions Declaring ccl_local in a device function is not supported by certain compilers.
2017-03-08 13:34:29 +01:00
Cycles: Split path initialization into own kernel This makes it easier to initialize things correctly in the data_init kernel before they are needed by path tracing.
2017-03-01 01:05:55 -05:00
DEFINE_SPLIT_KERNEL_FUNCTION(path_init)
Cycles: CPU implementation of split kernel
2017-02-14 06:20:48 -05:00
DEFINE_SPLIT_KERNEL_FUNCTION(scene_intersect)
DEFINE_SPLIT_KERNEL_FUNCTION(lamp_emission)
Cycles: SSS and Volume rendering in split kernel Decoupled ray marching is not supported yet. Transparent shadows are always enabled for volume rendering. Changes in kernel/bvh and kernel/geom are from Sergey. This simiplifies code significantly, and prepares it for record-all transparent shadow function in split kernel.
2017-03-08 15:42:26 +01:00
DEFINE_SPLIT_KERNEL_FUNCTION(do_volume)
Cycles: Define ccl_local variables in kernel functions Declaring ccl_local in a device function is not supported by certain compilers.
2017-03-08 13:34:29 +01:00
DEFINE_SPLIT_KERNEL_FUNCTION_LOCALS(queue_enqueue, QueueEnqueueLocals)
Cycles: SSS and Volume rendering in split kernel Decoupled ray marching is not supported yet. Transparent shadows are always enabled for volume rendering. Changes in kernel/bvh and kernel/geom are from Sergey. This simiplifies code significantly, and prepares it for record-all transparent shadow function in split kernel.
2017-03-08 15:42:26 +01:00
DEFINE_SPLIT_KERNEL_FUNCTION(indirect_background)
Cycles: Split kernel - sort shaders Reduce thread divergence in kernel_shader_eval. Rays are sorted in blocks of 2048 according to shader->id. On R9 290 Classroom is ~30% faster, and Pabellon Barcelone is ~8% faster. No sorting for CUDA split kernel. Reviewers: sergey, maiself Reviewed By: maiself Differential Revision: https://developer.blender.org/D2598
2017-05-03 15:30:45 +02:00
DEFINE_SPLIT_KERNEL_FUNCTION_LOCALS(shader_setup, uint)
DEFINE_SPLIT_KERNEL_FUNCTION_LOCALS(shader_sort, ShaderSortLocals)
DEFINE_SPLIT_KERNEL_FUNCTION(shader_eval)
Cycles: Define ccl_local variables in kernel functions Declaring ccl_local in a device function is not supported by certain compilers.
2017-03-08 13:34:29 +01:00
DEFINE_SPLIT_KERNEL_FUNCTION_LOCALS(holdout_emission_blurring_pathtermination_ao,
BackgroundAOLocals)
Cycles: Branched path tracing for the split kernel This implements branched path tracing for the split kernel. General approach is to store the ray state at a branch point, trace the branched ray as normal, then restore the state as necessary before iterating to the next part of the path. A state machine is used to advance the indirect loop state, which avoids the need to add any new kernels. Each iteration the state machine recreates as much state as possible from the stored ray to keep overall storage down. Its kind of hard to keep all the different integration loops in sync, so this needs lots of testing to make sure everything is working correctly. We should probably start trying to deduplicate the integration loops more now. Nonbranched BMW is ~2% slower, while classroom is ~2% faster, other scenes could use more testing still. Reviewers: sergey, nirved Reviewed By: nirved Subscribers: Blendify, bliblubli Differential Revision: https://developer.blender.org/D2611
2017-03-20 22:31:54 -04:00
DEFINE_SPLIT_KERNEL_FUNCTION(subsurface_scatter)
Cycles: Define ccl_local variables in kernel functions Declaring ccl_local in a device function is not supported by certain compilers.
2017-03-08 13:34:29 +01:00
DEFINE_SPLIT_KERNEL_FUNCTION_LOCALS(direct_lighting, uint)
Cycles: split kernel_shadow_blocked to AO & DL parts Reduces memory allocation for split kernel. This allows for faster rendering due to bigger global size, specially when GPU memory is limited. Perfromance results: R9 290 total render time Before After Change BMW 4:37 4:34 -1.1 % Classroom 14:43 14:30 -1.5 % Fishy Cat 11:20 11:04 -2.4 % Koro 12:11 12:04 -1.0 % Pabellon Barcelona 22:01 20:44 -5.8 % Pabellon Barcelona(*) 15:32 15:09 -2.5 % (*) without glossy connected to volume
2017-03-08 17:39:40 +01:00
DEFINE_SPLIT_KERNEL_FUNCTION(shadow_blocked_ao)
DEFINE_SPLIT_KERNEL_FUNCTION(shadow_blocked_dl)
Cycles: Add kernel to enqueue inactive rays The queue will be used to make reuse of inactive threads to keep the GPU more busy.
2017-05-29 20:40:26 -04:00
DEFINE_SPLIT_KERNEL_FUNCTION_LOCALS(enqueue_inactive, uint)
Cycles: Define ccl_local variables in kernel functions Declaring ccl_local in a device function is not supported by certain compilers.
2017-03-08 13:34:29 +01:00
DEFINE_SPLIT_KERNEL_FUNCTION_LOCALS(next_iteration_setup, uint)
Cycles: SSS and Volume rendering in split kernel Decoupled ray marching is not supported yet. Transparent shadows are always enabled for volume rendering. Changes in kernel/bvh and kernel/geom are from Sergey. This simiplifies code significantly, and prepares it for record-all transparent shadow function in split kernel.
2017-03-08 15:42:26 +01:00
DEFINE_SPLIT_KERNEL_FUNCTION(indirect_subsurface)
Cycles: Define ccl_local variables in kernel functions Declaring ccl_local in a device function is not supported by certain compilers.
2017-03-08 13:34:29 +01:00
DEFINE_SPLIT_KERNEL_FUNCTION_LOCALS(buffer_update, uint)
Adaptive Sampling for Cycles. This feature takes some inspiration from "RenderMan: An Advanced Path Tracing Architecture for Movie Rendering" and "A Hierarchical Automatic Stopping Condition for Monte Carlo Global Illumination" The basic principle is as follows: While samples are being added to a pixel, the adaptive sampler writes half of the samples to a separate buffer. This gives it two separate estimates of the same pixel, and by comparing their difference it estimates convergence. Once convergence drops below a given threshold, the pixel is considered done. When a pixel has not converged yet and needs more samples than the minimum, its immediate neighbors are also set to take more samples. This is done in order to more reliably detect sharp features such as caustics. A 3x3 box filter that is run periodically over the tile buffer is used for that purpose. After a tile has finished rendering, the values of all passes are scaled as if they were rendered with the full number of samples. This way, any code operating on these buffers, for example the denoiser, does not need to be changed for per-pixel sample counts. Reviewed By: brecht, #cycles Differential Revision: https://developer.blender.org/D4686
2020-03-05 12:05:42 +01:00
DEFINE_SPLIT_KERNEL_FUNCTION(adaptive_stopping)
DEFINE_SPLIT_KERNEL_FUNCTION(adaptive_filter_x)
DEFINE_SPLIT_KERNEL_FUNCTION(adaptive_filter_y)
DEFINE_SPLIT_KERNEL_FUNCTION(adaptive_adjust_samples)
Cycles: CPU implementation of split kernel
2017-02-14 06:20:48 -05:00
#endif /* __SPLIT_KERNEL__ */
Cycles: Implement denoising option for reducing noise in the rendered image This commit contains the first part of the new Cycles denoising option, which filters the resulting image using information gathered during rendering to get rid of noise while preserving visual features as well as possible. To use the option, enable it in the render layer options. The default settings fit a wide range of scenes, but the user can tweak individual settings to control the tradeoff between a noise-free image, image details, and calculation time. Note that the denoiser may still change in the future and that some features are not implemented yet. The most important missing feature is animation denoising, which uses information from multiple frames at once to produce a flicker-free and smoother result. These features will be added in the future. Finally, thanks to all the people who supported this project: - Google (through the GSoC) and Theory Studios for sponsoring the development - The authors of the papers I used for implementing the denoiser (more details on them will be included in the technical docs) - The other Cycles devs for feedback on the code, especially Sergey for mentoring the GSoC project and Brecht for the code review! - And of course the users who helped with testing, reported bugs and things that could and/or should work better!
2017-05-07 14:40:58 +02:00
#undef KERNEL_STUB
#undef STUB_ASSERT
#undef KERNEL_ARCH
Cycles: Deduplicte CPU kernel declaration and definition code Main goal is to make kernel signatures editing easier and less prone to the errors caused by missing function signature update or so. This will also make it easier to add new CPU architectures. Reviewers: juicyfruit, dingto, lukasstockner97, brecht Reviewed By: dingto, lukasstockner97, brecht Differential Revision: https://developer.blender.org/D1703
2015-12-30 17:54:02 +05:00
CCL_NAMESPACE_END
Reference in New Issue Copy Permalink