code. This gives a speedup up to a couple of seconds based only on the image
resolution and tile size. For complex renders a second or two is not so noticeable
but for quick ones it's nice to save some time. On the default cube this gives me
about half a second speedup.
Patch by Johan Walles, based on the render branch implementation by me.
This is a special case, tangent space normal maps should be cleared to
0.5, 0.5, 1.0. This is good practice but there's no reason why not to
automate this (for artists whose bump map fu may be a bit shallow).
Thanks to Morten Mikkelsen for reporting.
Adding non-RGBA float buffers as texture crashes MipMap code.
Images with less than 4 channels not supported (yet). Not sure
if we ever should even... normals, Z, vectors, UV, Index, all
don't like downsampling.
Bang! How we didn't notice this for so long -- seems scenes came from render
layer node were rendering as if color management disabled (byte image wouldn't
be linearized).
Basically they're aimed to solve issues when scene with sky
was used for compositing. If compo used alpha output result
of current trunk would be completely different form hwo it
was before.
Two heuristics here:
- If there's no world or world color is black, it completely
equals to straight alpha mode, no further magic is needed
to preserve compatibility
- If scene is used as Render Layer node and something is
connected to Alpha output of this node, ensure alpha mode
for this scene is set to Premultiplied.
Basically it shall give better compatibility and make
4K mango project just happy! :)
Issue was caused by alpha pipeline cleanup: apparently depending on
use_alpha flag different channels for spec/alpha would be used.
Made it so talpha is computed from Image->ignore_alpha instead of
always considering to be TRUTH.
This is not so much trivial to understand what's going on here, but
it's not new issue. Anyway, if someone have got ideas how to improve
feedback here -- ideas are welcome! For now only regression is fixed.
The problem was caused by the fact that BKE_scene_copy() was simply doing "memcpy"
to duplicate render layers including lineset settings without taking care of pointers
in the linesets. For this reason, freeing the original scene and copied one resulted
in freeing allocated memory buffers twice.
Now BKE_scene_copy() properly duplicates linesets as part of render layers.
Also some code clean-up was made in the modified files.
Problem report by IRIE Shinsuke (with a patch to fix the crash). Many thanks!
Issue was caused by recursive call of RE_BlenderFrame. Solved by
reshuffling image pool init/free in do_render_all_options.
Should be harmless, but doublecheck on this is welcome.
- Cycles materials now render in Blender Internal too, skipping the nodes.
Not very useful, but at least things then show up on renders and in
previews.
- Node editor: if wrong shader nodes are in a tree, they draw with thene
color RED ALERT headers now. (Switching render engine will show it).
Issue was caused by the fact that guarded allocator is not thread-safe and
generated images/movies could allocate memory when loading pixels to Cycles.
Currently solved by switching memory allocator to using mutex lock (the same
as sued for jobs) when viewport rendering is used.
Nicer solution would be to make guarded allocator thread-safe by using atomic
operations and lock-free lists, but that's more serious change.
It was caused by own mistake by not noticing externtex is used not
only by render engine. Now this function uses pool passed as argument
rather than using R.pool.
Previously normalization will happen per image buffer individually, which
was wrong in cases different faces of the sane mesh uses different images.
Also solved possible threading issues when calculating min.max displacement.
This will calculate maximal distance automatically and normalize displacement
to it. Before this change normalization will not happen at all in cases max
distance is not set manually.
This affects on "regular" baker only, there are still some fixes to come for
multiresolution baker, but that could be solved separately.
It was caused by image threading safe commit and it was noticeable
only on really multi-core CPU (like dual-socket Xeon stations), was
not visible on core i7 machine.
The reason of slowdown was spinlock around image buffer referencing,
which lead to lots of cores waiting for single core and using image
buffer after it was referenced was not so much longer than doing
reference itself.
The most clear solution here seemed to be introducing Image Pool
which will contain list of loaded and referenced image buffers, so
all threads could skip lock if the pool is used for reading only.
Lock only needed in cases when buffer for requested image user is
missing in the pool. This lock will happen only once per image so
overall amount of locks is much less that it was before.
To operate with pool:
- BKE_image_pool_new() creates new pool
- BKE_image_pool_free() destroys pool and dereferences all image
buffers which were loaded to it
- BKE_image_pool_acquire_ibuf() returns image buffer for given
image and user. Pool could be NULL and in this case fallback to
BKE_image_acquire_ibuf will happen.
This helps to avoid lots to if(poll) checks in image sampling
code.
- BKE_image_pool_release_ibuf releases image buffer. In fact, it
will only do something if pool is NULL, in all other case it'll
equal to DoNothing operation.
allow_render_dupli_instance used to pass zero-based index to give_current_material
which is wrong.
Before rev53332 it wasn't so much visible because give_current_material used
to clamp index internally. But that was wrong behavior here anyway, and why
nobody noticed this for so long? :)
