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

Age	Commit message (Collapse)	Author
2013-12-07	Cycles: network render code updated for latest changes and improved	Martijn Berger
	This actually works somewhat now, although viewport rendering is broken and any kind of network error or connection failure will kill Blender. * Experimental WITH_CYCLES_NETWORK cmake option * Networked Device is shown as an option next to CPU and GPU Compute * Various updates to work with the latest Cycles code * Locks and thread safety for RPC calls and tiles * Refactored pointer mapping code * Fix error in CPU brand string retrieval code This includes work by Doug Gale, Martijn Berger and Brecht Van Lommel. Reviewers: brecht Differential Revision: http://developer.blender.org/D36
2013-09-04	Fix a few issues reported by coverity scan.	Brecht Van Lommel

2013-08-31	Cycles: viewport render now takes scene color management settings into account,	Brecht Van Lommel
	except for curves, that's still missing from the OpenColorIO GLSL shader. The pixels are stored in a half float texture, converterd from full float with native GPU instructions and SIMD on the CPU, so it should be pretty quick. Using a GLSL shader is useful for GPU render because it avoids a copy through CPU memory.
2013-08-23	Cycles: more code refactoring to rename things internally as well. Also change	Brecht Van Lommel
	property name back so we keep compatibility.
2013-08-18	Cycles: relicense GNU GPL source code to Apache version 2.0.	Brecht Van Lommel
	More information in this post: http://code.blender.org/ Thanks to all contributes for giving their permission!
2013-08-13	Code cleanup:	Thomas Dinges
	* Some typo fixes.
2013-08-09	Cycles / Non-Progressive integrator:	Thomas Dinges
	* Non-Progressive integrator is now available on the GPU (CUDA, sm_20 and above). Implementation details: * kernel_path_trace() has been split up into two functions: kernel_path_trace_non_progressive() and kernel_path_trace_progressive(). * We compile two CUDA kernel entry functions (in kernel.cu) for the two integrators, they are still inside one .cubin file but due to the kernel separation there should be no performance problem. I tested with the BMW file on my Geforce 540M and the render times were the same for 100 samples (1.57 min in my case). This is part of my GSoC project, SVN merge of r59032 + manual merge of UI changes for this from my branch.
2013-07-20	Code cleanup / Cycles:	Thomas Dinges
	* Use USHRT_MAX rather than manual value, suggested by Campbell.
2013-07-19	Fix for [#36216] Viewport render with CMJ sampler and unlimited passes freezes	Thomas Dinges
	* If Preview Samples are set to 0 (unlimited) it now assumes 65536 instead of INT_MAX. This doesn't affect regular sampling, you can still enter fixed values of 100k or whatever.
2013-06-25	Render stats text: show elapsed time for blender internal, hide useless ↵	Brecht Van Lommel
	"Single Layer" at the start, more clearly indicate what the render time of the last frame was, some other tweaks for consistency.
2013-06-07	Cycles: experimental correlated multi-jittered sampling pattern that can be used	Brecht Van Lommel
	instead of sobol. So far one doesn't seem to be consistently better or worse than the other for the same number of samples but more testing is needed. The random number generator itself is slower than sobol for most number of samples, except 16, 64, 256, .. because they can be computed faster. This can probably be optimized, but we can do that when/if this actually turns out to be useful. Paper this implementation is based on: http://graphics.pixar.com/library/MultiJitteredSampling/ Also includes some refactoring of RNG code, fixing a Sobol correlation issue with the first BSDF and < 16 samples, skipping some unneeded RNG calls and using a simpler unit square to unit disk function.
2013-05-15	Cycles:	Thomas Dinges
	* Code cleanup, remove unused "resolution" variable from the DeviceTask class, was never used.
2013-04-16	Cycles Hair: Strand Minimum Pixel Size	Stuart Broadfoot
	Code is added to restrict the pixel size of strands in cycles. It works best with ribbon primitives and a preset for these is included. It uses distance dependent expansion of the strands and then stochastic strand removal to give a fading. To prevent a slowdown for triangle mesh objects in the BVH an extra visibility flag has been added. It is also only applied for camera rays. The strand width settings are also changed, so that the particle size is not included in the width calculation. Instead there is a separate particle system parameter for width scaling.
2013-04-05	Fix another part of #34877: cycles progress status text not showing correct with	Brecht Van Lommel
	per render layer samples in addition to the progress bar. Also fixed job progress bar not working at all on high DPI / retina, was so small the actual progress was not visible.
2013-02-13	Correction for fix #34205: Zooming in rendered mode during update out of ↵	Sergey Sharybin
	sync with intended zoom Didn't initially notice one possibility when GPU render would fail here,
2013-02-12	Fix #34205: Cycles: Zooming in rendered mode during update out of sync with ↵	Sergey Sharybin
	intended zoom Made sure no pause_cond.wait() happens at the same time as session as resetting.
2013-02-07	Fix small memory leak in cycles tile render, a few bytes for each tile.	Brecht Van Lommel
	Reported by "aquo" on IRC.
2013-02-06	style cleanup: some warnigs & spelling.	Campbell Barton

2013-01-07	Cycles / Tile Rendering:	Thomas Dinges
	* Added new option to chose the tile order. In addition to the "Center" method, 4 new methods are available now, like Top -> Bottom and Right -> Left. Thanks to Sergey for code review and some tweaks!
2013-01-01	Highlight currently rendering tiles	Sergey Sharybin
	This commit implements highlight of tiles which are being currently rendered for both Blender Internal and Cycles (and should be possible to use it for other external engines as well). Couple of implementation details: - Added one extra boolean flag to render engine which should be set to truth if render engine wants to highlight tiles. If so, property use_highlight_tiles should be set to True. - Render Part's ready boolena was changed by status enum, which could be NONE, IN_PROGRESS and READY. All render part with IN_PROGRESS status will be highlighted in image editor. - For external engines render part's status is filling in automatically. Initially all render parts has got NONE status, then one external engine acquire render result, corresponding part will change status to IN_PROGRESS. As soon as render result is finished, corresponding render part will change status to FINISHED This should make it easy to highlight tiles for other engines as well.
2012-11-28	Fix #33337: cycles crash with progressive refine and multiple render layers.	Brecht Van Lommel

2012-11-13	avoid divide by zero in cycles progress calculation	Campbell Barton

2012-11-09	Cycles: persistent images option	Sergey Sharybin
	This option enables keeping loaded images in the memory in-between of rendering. Implemented by keeping render engine alive for until Render structure is being freed. Cycles will free all data when render finishes, optionally keeping image manager untouched. All shaders, meshes, objects will be re-allocated next time rendering happens. Cycles cession and scene will be re-created from scratch if render/ scene parameters were changed. This will also allow to keep compiled OSL shaders in memory without need to re-compile them again. P.S. Performance panel could be cleaned up a bit, not so much happy with it's vertical alignment currently but not sure how to make it look better. P.P.S. Currently the only way to free images from the device is to disable Persistent Images option and start rendering.
2012-11-08	code cleanup: quiet double promotion warnings	Campbell Barton

2012-11-08	Fix #33107: cycles fixed threads 1 was still having two cores do work,	Brecht Van Lommel
	because main thread works as well.
2012-11-05	Cycles: memory usage report	Sergey Sharybin
	This commit adds memory usage information while rendering. It reports memory used by device, meaning: - For CPU it'll report real memory consumption - For GPU rendering it'll report GPU memory consumption, but it'll also mean the same memory is used from host side. This information displays information about memory requested by Cycles, not memory really allocated on a device. Real memory usage might be higher because of memory fragmentation or optimistic memory allocator. There's really nothing we can do against this. Also in contrast with blender internal's render cycles memory usage does not include memory used by scene, only memory needed by cycles itself will be displayed. So don't freak out if memory usage reported by cycles would be much lower than blender internal's. This commit also adds RenderEngine.update_memory_stats callback which is used to tell memory consumption from external engine to blender. This information is used to generate information line after rendering is finished.
2012-11-05	Cycles: multi-gpu rendering doesn't know for sure which sample is being sampled,	Sergey Sharybin
	so only report tile number is being processed
2012-10-24	Fix #32951: Progressive refine crashing Blender when used with multiple cuda ↵	Sergey Sharybin
	devices This time issue was caused by Save Buffers enabled and the reason blender crashed was tiles generated by cycles didn't match tiles generated by openexr. Currently solved it in a way that background rendering will allocate tiles in the same way render parts are generated in blender. Viewport rendering will still be using sliced image, but it's more tricky to change and it's no so big deal for now.
2012-10-23	Cycles: update buffers only once in a while when progressive refine is used	Sergey Sharybin
	It'll mimic the same behavior as regular tile rendering update and it should give pretty noticeable boost on simpler scenes.
2012-10-23	Fix #32951: Progressive refine crashing Blender when used with multiple cuda	Sergey Sharybin
	Issue was caused by offline rendering could have been allocated the same tile to different devices and in this case buffers would become invalid. Made it more clear in the code, so now it's flag for tile manager to indicate whether tiles should always be allocated for the same device or not. Also cleaned a way how tile index for progressive refine is calculating, which is now avoids tricky computation based on tile coordinate and it's dimensions.
2012-10-13	Cycles: progressive refine option	Sergey Sharybin
	Just makes progressive refine :) This means the whole image would be refined gradually using as much threads as it's set in performance settings. Having enough tiles is required to have this option working as it's expected. Technically it's implemented by repeatedly computing next sample for all the tiles before switching to next sample. This works around 7-12% slower than regular tile-based rendering, so use this option only if you really need it. This commit also fixes progressive update of image when Save Buffers option is enabled. And one more thing this commit fixes is handling display buffer with Save Buffers option enabled. If this option is enabled image buffer wouldn't have neither byte nor float buffer until image is fully rendered which could backfire in missing image while rendering in cases color management cache became full. This issue solved by allocating byte buffer for image buffer from tile update callback. Patch was reviewed by Brecht. He also made some minor edits to original version to patch. Thanks, man!
2012-09-17	Revert r50528: "Performance fix for Cycles: Don't wait in the main UI thread ↵	Lukas Toenne
	when resetting devices." This commit leads to random freezes in Cycles rendering: https://projects.blender.org/tracker/index.php?func=detail&aid=32545&group_id=9&atid=498 The goal of this commit was to remove UI lag for OSL, but since that is not officially supported yet, better revert it until a proper fix can be implemented in 2.65.
2012-09-17	Cycles: change preview "resolution divider" that gave the number of lower	Brecht Van Lommel
	resolutions to render, to a "start resolution" which gives the resolution to start at. This avoids unnecessary rendering of small resolutions in small viewports, and avoids long waiting on big viewports.
2012-09-11	Performance fix for Cycles: Don't wait in the main UI thread when resetting ↵	Lukas Toenne
	devices. When the scene is updated Cycles resets the renderer device, cancelling all existing tasks. The main thread would wait for all running tasks to finish before continuing. This is ok when tasks can actually cancel in a timely fashion. For OSL however, this does not work, since the OSL shader group optimization takes quite a bit of time and can not be easily be cancelled once running (on my crappy machine in full debug mode: ~0.12 seconds for simple node trees). This would lead to very laggy UI behavior and make it difficult to accurately control elements such as sliders. This patch removes the wait condition from the device->task_cancel method. Instead it just sets the do_cancel flag and returns. To avoid backlog in the task pool of the device it will return early from the BlenderSession::sync function while the reset is going on (tested in Session::resetting). Once all existing tasks have finished the do_cancel flag is finally cleared again (checked in TaskPool::num_decrease). Care has to be taken to avoid race conditions on the do_cancel flag, since it can now be modified outside the TaskPool::cancel function itself. For this purpose the scope of the TaskPool::num_mutex locks has been extended, in most cases the mutex is now locked by the TaskPool itself before calling TaskScheduler methods, instead of only locking inside the num_increase/num_decrease functions themselves. The only occurrence of a lock outside of the TaskPool methods is in TaskScheduler::thread_run. This patch is most useful in combination with the OSL renderer mode, so it can probably wait until after the 2.64 release. SVM tasks tend to be cancelled quickly, so the effect is less noticeable.
2012-09-10	Fix #32529: after tomato merge, cycles multi GPU render not using all GPUs with	Brecht Van Lommel
	F12 rendering.
2012-09-04	Cycles: merge of changes from tomato branch.	Brecht Van Lommel
	Regular rendering now works tiled, and supports save buffers to save memory during render and cache render results. Brick texture node by Thomas. http://wiki.blender.org/index.php/Doc:2.6/Manual/Render/Cycles/Nodes/Textures#Brick_Texture Image texture Blended Box Mapping. http://wiki.blender.org/index.php/Doc:2.6/Manual/Render/Cycles/Nodes/Textures#Image_Texture http://mango.blender.org/production/blended_box/ Various bug fixes by Sergey and Campbell. * Fix for reading freed memory in some node setups. * Fix incorrect memory read when synchronizing mesh motion. * Fix crash appearing when direct light usage is different on different layers. * Fix for vector pass gives wrong result in some circumstances. * Fix for wrong resolution used for rendering Render Layer node. * Option to cancel rendering when doing initial synchronization. * No more texture limit when using CPU render. * Many fixes for new tiled rendering.
2012-06-09	style cleanup: block comments	Campbell Barton

2012-06-07	Cycles: border render now works in the viewport, when looking through the	Brecht Van Lommel
	camera, same as in render. It draws objects in solid draw mode outside of the border.
2012-04-28	Cycles: merging features from tomato branch.	Brecht Van Lommel
	=== BVH build time optimizations === * BVH building was multithreaded. Not all building is multithreaded, packing and the initial bounding/splitting is still single threaded, but recursive splitting is, which was the main bottleneck. * Object splitting now uses binning rather than sorting of all elements, using code from the Embree raytracer from Intel. http://software.intel.com/en-us/articles/embree-photo-realistic-ray-tracing-kernels/ * Other small changes to avoid allocations, pack memory more tightly, avoid some unnecessary operations, ... These optimizations do not work yet when Spatial Splits are enabled, for that more work is needed. There's also other optimizations still needed, in particular for the case of many low poly objects, the packing step and node memory allocation. BVH raytracing time should remain about the same, but BVH build time should be significantly reduced, test here show speedup of about 5x to 10x on a dual core and 5x to 25x on an 8-core machine, depending on the scene. === Threads === Centralized task scheduler for multithreading, which is basically the CPU device threading code wrapped into something reusable. Basic idea is that there is a single TaskScheduler that keeps a pool of threads, one for each core. Other places in the code can then create a TaskPool that they can drop Tasks in to be executed by the scheduler, and wait for them to complete or cancel them early. === Normal ==== Added a Normal output to the texture coordinate node. This currently gives the object space normal, which is the same under object animation. In the future this might become a "generated" normal so it's also stable for deforming objects, but for now it's already useful for non-deforming objects. === Render Layers === Per render layer Samples control, leaving it to 0 will use the common scene setting. Environment pass will now render environment even if film is set to transparent. Exclude Layers" added. Scene layers (all object that influence the render, directly or indirectly) are shared between all render layers. However sometimes it's useful to leave out some object influence for a particular render layer. That's what this option allows you to do. === Filter Glossy === When using a value higher than 0.0, this will blur glossy reflections after blurry bounces, to reduce noise at the cost of accuracy. 1.0 is a good starting value to tweak. Some light paths have a low probability of being found while contributing much light to the pixel. As a result these light paths will be found in some pixels and not in others, causing fireflies. An example of such a difficult path might be a small light that is causing a small specular highlight on a sharp glossy material, which we are seeing through a rough glossy material. With path tracing it is difficult to find the specular highlight, but if we increase the roughness on the material the highlight gets bigger and softer, and so easier to find. Often this blurring will be hardly noticeable, because we are seeing it through a blurry material anyway, but there are also cases where this will lead to a loss of detail in lighting.
2012-04-04	Fix #30710: cycles wrong render time after pause/unpause in viewport.	Brecht Van Lommel

2012-02-23	Fix #30246: rendering multiple render layers with CUDA still not working,	Brecht Van Lommel
	should really be fixed now.
2012-01-09	Cycles: show elapsed time for F12/background render.	Brecht Van Lommel

2012-01-04	Cycles: device code refactoring, no functional changes.	Brecht Van Lommel

2011-12-21	Cycles: some small code refactoring related to buffer parameters.	Brecht Van Lommel

2011-12-20	Cycles: border rendering support, includes some refactoring in how pixels are	Brecht Van Lommel
	accessed on devices.
2011-12-13	Cycles: require Experimental to be set to enable CUDA on cards with shader model	Brecht Van Lommel
	lower than 1.3, since we're not officially supporting these. We're already not providing CUDA binaries for these, so better make it clear when compiling from source too.
2011-11-23	Cycles: improve error reporting for opencl and cuda, showing error messages in	Brecht Van Lommel
	viewport instead of only console.
2011-10-30	Cycles: progress printing in background mode, print finished at the end and	Brecht Van Lommel
	avoid duplicate prints.
2011-09-16	Cycles: tweaks to properties and nodes	Brecht Van Lommel
	* Passes renamed to samples * Camera lens radius renamed to aperature size/blades/rotation * Glass and fresnel nodes input is now index of refraction * Glossy and velvet fresnel socket removed * Mix/add closure node renamed to mix/add shader node * Blend weight node added for shader mixing weights There is some version patching code for reading existing files, but it's not perfect, so shaders may work a bit different.
2011-09-12	Cycles:	Brecht Van Lommel
	* Fix missing update when editing objects with emission materials. * Fix preview pass rendering set to 1 not showing full resolution. * Fix CUDA runtime compiling failing due to missing cache directory. * Use settings from first render layer for visibility and material override. And a bunch of incomplete and still disabled code mostly related to closure sampling.