git.blender.org/blender.git - Unnamed repository; edit this file 'description' to name the repository.

Age	Commit message (Collapse)	Author
2017-03-17	Cycles: Fix mistake in previous split kernel commits	Sergey Sharybin
	Own stupid mistake. Reported by nirved in IRC, thanks!
2017-03-17	Cycles: Fix handling of barriers	Mai Lavelle

2017-03-16	Cycles: Define ccl_local variables in kernel functions	Sergey Sharybin
	Declaring ccl_local in a device function is not supported by certain compilers.
2017-03-16	Cycles: Avoid some ccl_local in various kernels	Sergey Sharybin

2017-03-13	Cycles: Cleanup, wipe obviously outdated parts of split kernel comments	Sergey Sharybin

2017-03-13	Cycles: Add missing header in the file	Sergey Sharybin

2017-03-13	Fix T50925: Add AO approximation to split kernel	Hristo Gueorguiev

2017-03-11	Fix T50888: Numeric overflow in split kernel state buffer size calculation	Mai Lavelle
	Overflow led to the state buffer being too small and the split kernel to get stuck doing nothing forever.
2017-03-09	Cycles: split kernel_shadow_blocked to AO & DL parts	Hristo Gueorguiev
	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-09	Cycles: SSS and Volume rendering in split kernel	Hristo Gueorguiev
	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	Cycles: Make it possible to access KernelGlobals from split data ↵	Sergey Sharybin
	initialization function
2017-03-08	Cycles: Fix indentation	Mai Lavelle

2017-03-08	Cycles: Fix strict warning about unused variable	Mai Lavelle

2017-03-08	Cycles: Calculate size of split state buffer kernel side	Mai Lavelle
	By calculating the size of the state buffer in the kernel rather than the host less code is needed and the size actually reflects the requested features. Will also be a little faster in some cases because of larger global work size.
2017-03-08	Cycles: Initialize rng_state for split kernel	Mai Lavelle
	Because the split kernel can render multiple samples in parallel it is necessary to have everything initialized before rendering of any samples begins. The code that normally handles initialization of `rng_state` (`kernel_path_trace_setup()`) only does so for the first sample, which was causing artifacts in the split kernel due to uninitialized `rng_state` for some samples. Note that because the split kernel can render samples in parallel this means that the split kernel is incompatible with the LCG.
2017-03-08	Cycles: Remove sum_all_radiance kernel	Mai Lavelle
	This was only needed for the previous implementation of parallel samples. As we don't have that any more it can be removed. Real reason for removal tho is this: `per_sample_output_buffers` was being calculated too small and artifacts resulted. The tile buffer is already the correct size and calculating the size for `per_sample_output_buffers` is a bit difficult with the current layout of the code. As `per_sample_output_buffers` was only needed for `sum_all_radiance`, removing that kernel and writing output to the tile buffer directly fixes the artifacts.
2017-03-08	Cycles: Split path initialization into own kernel	Mai Lavelle
	This makes it easier to initialize things correctly in the data_init kernel before they are needed by path tracing.
2017-03-08	Cycles: CUDA implementation of split kernel	Mai Lavelle

2017-03-08	Cycles: CPU implementation of split kernel	Mai Lavelle

2017-03-08	Cycles: Remove ccl_fetch and SOA	Mai Lavelle

2017-03-08	Cycles: OpenCL split kernel refactor	Mai Lavelle
	This does a few things at once: - Refactors host side split kernel logic into a new device agnostic class `DeviceSplitKernel`. - Removes tile splitting, a new work pool implementation takes its place and allows as many threads as will fit in memory regardless of tile size, which can give performance gains. - Refactors split state buffers into one buffer, as well as reduces the number of arguments passed to kernels. Means there's less code to deal with overall. - Moves kernel logic out of OpenCL kernel files so they can later be used by other device types. - Replaced OpenCL specific APIs with new generic versions - Tiles can now be seen updating during rendering
2017-01-23	Cycles: Split ShaderData object and shader flags	Sergey Sharybin
	We started to run out of bits there, so now we separate flags which came from __object_flags and which are either runtime or coming from __shader_flags. Rule now is: SD_OBJECT_* flags are to be tested against new object_flags field of ShaderData, all the rest flags are to be tested against flags field of ShaderData. There should be no user-visible changes, and time difference should be minimal. In fact, from tests here can only see hardly measurable difference and sometimes the new code is somewhat faster (all within a noise floor, so hard to tell for sure). Reviewers: brecht, dingto, juicyfruit, lukasstockner97, maiself Differential Revision: https://developer.blender.org/D2428
2017-01-23	Cycles: Make object flag names more obvious that hey are object and not shader	Sergey Sharybin

2017-01-12	Cycles: Use dedicated debug passes for traversed nodes and intersection tests	Sergey Sharybin
	This way it's more clear whether some issue is caused by lots of geometry in the node or by lots of "transparent" BVH nodes.
2016-10-30	Cycles: Add optional probabilistic termination of light samples based on ↵	Lukas Stockner
	their expected contribution In scenes with many lights, some of them might have a very small contribution to some pixels, but the shadow rays are traced anyways. To avoid that, this patch adds probabilistic termination to light samples - if the contribution before checking for shadowing is below a user-defined threshold, the sample will be discarded with probability (1 - (contribution / threshold)) and otherwise kept, but weighted more to remain unbiased. This is the same approach that's also used in path termination based on length. Note that the rendering remains unbiased with this option, it just adds a bit of noise - but if the setting is used moderately, the speedup gained easily outweighs the additional noise. Reviewers: #cycles Subscribers: sergey, brecht Differential Revision: https://developer.blender.org/D2217
2016-10-23	Cycles: OpenCL 3d textures support.	Hristo Gueorguiev
	Note that volume rendering is not supported yet, this is a step towards that. Reviewed By: brecht Differential Revision: https://developer.blender.org/D2299
2016-10-07	Cycles: Fix OpenCL split kernel compilation after recent CUDA 8 performance fix	Lukas Stockner

2016-09-19	Cycles: Cleanup code style in split kernel	Sergey Sharybin

2016-09-14	Cycles: Stop lamp sampling if the lamp isn't visible	Lukas Stockner
	Both spot and area light have large areas where they're not visible. Therefore, this patch stops the light sampling code when one of these cases (outside of the spotlight cone or behind the area light) occurs, before the lamp shader is evaluated. In the case of the area light, the solid angle sampling can also be skipped. In a test scene with Sample All Lights and 18 Area lamps and 9 Spot lamps that all point away from the area that the camera sees, render time drops from 12sec to 5sec. Reviewers: brecht, sergey, dingto, juicyfruit Differential Revision: https://developer.blender.org/D2216
2016-07-11	Cycles: Move BVK kernel files to own directory	Sergey Sharybin
	BVH traversal is not really that much a geometry and we've got quite some traversals now. Makes sense to keep them separate in the name of source structure clarity.
2016-06-23	Cycles: Add multi-scattering, energy-conserving GGX as an option to the ↵	Lukas Stockner
	Glossy, Anisotropic and Glass BSDFs This commit adds a new distribution to the Glossy, Anisotropic and Glass BSDFs that implements the multiple-scattering microfacet model described in the paper "Multiple-Scattering Microfacet BSDFs with the Smith Model". Essentially, the improvement is that unlike classical GGX, which only models single scattering and assumes the contribution of multiple bounces to be zero, this new model performs a random walk on the microsurface until the ray leaves it again, which ensures perfect energy conservation. In practise, this means that the "darkening problem" - GGX materials becoming darker with increasing roughness - is solved in a physically correct and efficient way. The downside of this model is that it has no (known) analytic expression for evalation. However, it can be evaluated stochastically, and although the correct PDF isn't known either, the properties of MIS and the balance heuristic guarantee an unbiased result at the cost of slightly higher noise. Reviewers: dingto, #cycles, brecht Reviewed By: dingto, #cycles, brecht Subscribers: bliblubli, ace_dragon, gregzaal, brecht, harvester, dingto, marcog, swerner, jtheninja, Blendify, nutel Differential Revision: https://developer.blender.org/D2002
2016-05-23	Cycles CUDA: reduce stack memory by reusing ShaderData.	Brecht Van Lommel
	57% less for path and 48% less for branched path.
2016-02-03	Cycles: Cleanup, indentation and braces	Sergey Sharybin

2016-01-30	Cycles: Cleanup of OpenCL split kernel routines	Sergey Sharybin
	The idea is to switch from allocating separate buffers for shader data's structure of arrays to allocating one huge memory block and do some index trickery to make it accessed as SOA. This saves quite reasonable amount of lines of code in device_opencl and also makes it possible to get rid of special declaration of ShaderData structure. As a side effect it also makes it easier to experiment with SOA vs. AOS for split kernel. Works fine here on NVidia GTX580, Intel CPU amd AMD Fiji cards. Reviewers: #cycles, brecht, juicyfruit, dingto Differential Revision: https://developer.blender.org/D1593
2016-01-29	Cycles: Remove code which was commented out for ages now	Sergey Sharybin
	It was mainly unfinished code for volume in a split kernel which should be done differently anyway to avoid such a code copy-paste. The code didn't really work, so likely nobody will cry.
2016-01-29	Cycles: Remove some unused variables from split kernel function	Sergey Sharybin

2016-01-28	Cycles: Remove few function arguments needed only for the split kernel	Sergey Sharybin
	Use KernelGlobals to access all the global arrays for the intermediate storage instead of passing all this storage things explicitly. Tested here with Intel OpenCL, NVIDIA GTX580 and AMD Fiji, didn't see any artifacts, so guess it's all good. Reviewers: juicyfruit, dingto, lukasstockner97 Differential Revision: https://developer.blender.org/D1736
2016-01-07	Cycles: Refactor how we pass bounce info to light path node.	Thomas Dinges
	This commit changes the way how we pass bounce information to the Light Path node. Instead of manualy copying the bounces into ShaderData, we now directly pass PathState. This reduces the arguments that we need to pass around and also makes it easier to extend the feature. This commit also exposes the Transmission Bounce Depth to the Light Path node. It works similar to the Transparent Depth Output: Replace a Transmission lightpath after X bounces with another shader, e.g a Diffuse one. This can be used to avoid black surfaces, due to low amount of max bounces. Reviewed by Sergey and Brecht, thanks for some hlp with this. I tested compilation and usage on CPU (SVM and OSL), CUDA, OpenCL Split and Mega kernel. Hopefully this covers all devices. :)
2015-11-01	Cycles: Partially revert previous commit	Sergey Sharybin
	Apparently removing kernel arguments broke NVidia OpenCL. Needs more investigation, for the time being revering changes which caused problem.
2015-11-01	Cycles: Remove unused argument from the split kernel functions	Sergey Sharybin
	Should be no functional changes, just simplifies operation with kernels.
2015-10-29	Cycles: Fix typo in split kernel	Sergey Sharybin
	Shadow blocked kernel was using wrong array for storing intersection.
2015-10-29	Cycles: OpenCL split kernel cleanup, move casts from .h files to .cl files	Sergey Sharybin
	Ideally we shouldn't use char* at all, but for now we have to, so at least let's assume common .h files are free from pointer magic.
2015-08-23	Cleanup: spelling/style	Campbell Barton

2015-07-03	Cycles: Code cleanup in split kernel, whitespaces	Sergey Sharybin

2015-06-12	Cycles: Add debug pass which shows number of instance pushes during camera ↵	Sergey Sharybin
	ray intersection TODO: We might want to refactor debug passes into PASS_DEBUG and some debug_type (similar to Blender's side passes) to avoid issue of running out of bits.
2015-06-11	Cycles: Add debug pass showing average number of ray bounces per pixel	Sergey Sharybin
	Quite straightforward implementation, but still needs some work for the split kernel. Includes both regular and split kernel implementation for that. The pass is not exposed to the interface yet because it's currently not really easy to have same pass listed in the menu multiple times.
2015-05-27	Cycles: Code cleanup, split kernel	Sergey Sharybin

2015-05-26	Fix T44833: Can't use ccl_local space in non-kernel functions	Sergey Sharybin
	This commit re-shuffles code in split kernel once again and makes it so common parts which is in the headers is only responsible to making all the work needed for specified ray index. Getting ray index, checking for it's validity and enqueuing tasks are now happening in the device specified part of the kernel. This actually makes sense because enqueuing is indeed device-specified and i.e. with CUDA we'll want to enqueue kernels from kernel and avoid CPU roundtrip. TODO: - Kernel comments are still placed in the common header files, but since queue related stuff is not passed to those functions those comments might need to be split as well. Just currently read them considering that they're also covering the way how all devices are invoking the common code path. - Arguments might need to be wrapped into KernelGlobals, so we don't ened to pass all them around as function arguments.
2015-05-26	Cleanup: warning, spelling	Campbell Barton

2015-05-25	Cycles: Fix compilation error of split kernel	Sergey Sharybin
	The code was failing to compile on runtime because of some path differences, and it seems we don't need to specify full path to the file which originally seemed to be needed to make include directives expansion working correct.