from Jesse Kaukonen (gekko)
--- text from the patch.
Recently Campbell Barton added callback functionality for Python's usage, but this only includes pre- and post-render callbacks. There are no callbacks for the duration of the render. This patch adds the few lines required for executing a callback while Blender Render is working. The callback resides in the rendering pipeline stats function, so whenever statistics are printed, the callback is executed. This functionality is required if one wants to:
1) Observe what is happening while Blender is rendering via the command line
2) Add custom statistics that Blender prints while the renderer works
3) The user wants to continue executing his Python script without the code halting at bpy.ops.render.render()
Personally I'm currently using this for printing out more detailed progress reports at Renderfarm.fi (such as CPU time, time spent rendering, total progress in regards to the entire rendering process). Tested on Windows, Linux and OS X.
Example on how to use the callback:
def statscall(context): print("Thanks for calling!")
bpy.app.handlers.render_stats.append(statscall)
bpy.ops.render.render(animation=False, write_still=True)
from Tom Edwards (artfunkel), with minor edits.
This patch makes the following improvements to environment map scripting:
* Adds a "is_valid" RNA property to envmaps. True if the map is ready for use, False if it needs rendering.
* Adds a "clear" RNA function to envmaps. Deletes any envmap image data.
* Adds a "save" RNA function to envmaps. Writes the envmap to disc with a configurable layout. (Defaults to the current hard-coded layout.)
* Updates bpy.ops.texture.envmap_save with configurable layout support as above.
These changes, particularly configurable layouts, make exporting envmaps to other software much easier.
Change OURPLATFORM from "linux<major_version>" to simple "linux".
Since new policy for linux kernel versions that major version in
platform doesn't make much sense for building rules so the same
rules could be used for both of linux2 and linux3 now/
Tested on both of linux2 and linux3 systems.
This commit fixes very noticeable seams caused by margins
calculated incorrectly. This commit changes way margin is
calculated in and makes textures really seamless.
Also margin limited to 32 isn't good now -- artists are baking
really large textures nowadays so margin is now limited to 64px.
Thank you, Morten!
This fixes bug #26764 and several others like it, where modifier
properties (and others, but most visibly modifiers) would not do
anything when animated or driven, as modifier properties require the
RNA update calls to tag the modifiers to get recalculated.
While just adding a call to RNA_property_update() could have gotten
this working (as per the Campbell's patch attached in the report, and
also my own attempt #25881). However, on production rigs, the
performance cost of this is untenatable (on my own tests, without
these updates, I was getting ~5fps on such a rig, but only 0.9fps or
possibly even worse with the updates added).
Hence, this commit adds a property-update caching system to the RNA
level, which aims to reduce to the number of times that the update
functions end up needing to get called.
While this is much faster than without the caching, I also added an
optimisation for pose bones (which are numerous in production rigs) so
that their property updates are skipped, since they are useless to the
animsys (they only tag the depsgraph for updating). This gets things
moving at a more acceptable framerate.
Blender render optimizes alpha=0 materials away, unless it has
a number of properties... but there wasn't a check for material
being ray-mirror, it then should be rendered always.
* Noise is now considered an animated texture as it changes with every frame
* Converted a few places in particles code to use the particle system's own random table instead of BLI_frand.
It was a regression introduced in rev36301. Average normal calcilation
used to fail due to triangular faces which are too slight.
Do not use triangles with too small area for average normal calculation.
The information was written in the temp exr files, but was not read back.
After checking I saw that the pass was not merged back in the rendercore.
After adding this it worked. tested with all FSAA settings.
A mesh can consist out of multiple material. Take a character with clothing's. the skin can be a different material as the different clothing's. During compositing it is a common use-case to only do a part of the composit on only a specific material. Currently this can not be done.
In blender movies this feature is known to be implemented, but until now it never got integrated into trunk.
Proposal
With material index the Blender internal renderer will be capable of creating a buffer containing the material indexes of the first pixel-hit. This will be implemented in the same manner as the object index.
In the compositor the ID Mask node can be used to extract the information out of the Render pass.
Impact
User interface
On the properties-space the next changes will be done
Scene⇒Render layer⇒Passes⇒Material index will be added
Material⇒Options⇒Pass index will be added
DNA
Material struct will get an new field called “index”. this will be a short-type.
Material struct the field pad will be removed.
A new Render-layer pass will be added (bit 1«18)
RNA
Material RNA is updated (based on “pass index” from object)
Render layer RNA is updated (based on IndexOB)
Blender internal renderer
The Blender internal renderer will process the render pass as a copy of the Object index.
Blender compositor
The render layer input will get a new output socket called “IndexMA”
Usage
An example on how to use material index can be found at:
https://svn.blender.org/svnroot/bf-blender/trunk/lib/tests/compositing/composite_materialindex.blend
This is also example of a commit message longer than the commit itself :)
render strands use the window matrix and window size which were both zero while baking, this caused divides by 0 and eternal malloc loop.
So set unit window matrix and dummy view size.
This is more a workaround then a fix but avoids crashing.
this bug was introduced in 2.58 (r37342), when adding filtering support to imagewrap(), the problem is boxsample was getting float values which were not wrapped as int values are.
Python:
* adds bpy.app.handlers which contains lists, each for an event type:
render_pre, render_post, load_pre, load_post, save_pre, save_post
* each list item needs to be a callable object which takes 1 argument (the ID).
* callbacks are cleared on file load.
Example:
def MyFunc(scene): print("Callback:", data)
bpy.app.handlers.render_post.append(MyFunc)
C:
* This patch adds a generic C callback api which is currently only used by python.
* Unlike python callbacks these are not cleared on file load.
In addition the billboards can be scaled by the particle velocity with optional head and tail factors (similar to line drawing options). This allows for pseudo-motionblur effects.
Render + compositing error:
When adding renderlayer nodes in a composite, without having own
scene render, the renderlayer nodes were not tagged as changed,
causing compositing to give previous result.
