Blender Git Loki

==SCons==
+ 'scons blenderplayer' builds blender AND blenderplayer now (tested on Linux
only, but was only linking issue, so should work on other platforms too).

NOTE: I noticed some compileflags for GE specific libs that were left out -
I re-enabled them in the SConscripts, but I'm going to do a test build my-
self now, so if there are problems with them on win32, I probably already
know about them :)

==SCons==
* use proper seperator instead of *nix-only /

==SCons==
- remove blenderdummy.cpp from list, so that elbeem actually works

Wanted feature for curves: a render-time resolution. This option is
located under the 'def resolu' button. If not zero, it assigns this
resolution to a curve on render.
Also copies with ctrl+c menu.

Add the WITH_OPENEXR to sconscript. I needed this for toni's latest SceneRender stuff to work. Strange that it worked ok on his computer without this.

additions to make the orange rendering preparation script work, sorry undocumented again (we are testing this now and gotta commit to get this to other compus at studio, Stivs make a note to bug me about the doc or someone add it.. :o)

Further tweaking group appending...

Previous commits attempted to link objects in a group to the scene, when
appending the group. Unfortunately... a single append then also linked
objects from previously linked groups. This is still a bit messy, mostly
caused by the way how appending now is coded.

At least things work as expected now!

Orange-reported vectorblur bug: when using autosmooth, the amount of
vertices differed on previous/next frame, causing speedvector calculus
to be skipped.
Now that worked OK, where it not that non-existing speed vectors were not
initialized zero while rendering...

Also another issue showed up with autosmooth. When using exact smooth
angles (like 30 degrees) on a model that has been spinned with exactly
30 degree steps, the autosmooth gave different results on each frame...
and only when compiled in O2 (probably thats doing bad float rounding).

Solved this by just adding 0.1 to the user defined smooth angle.

Group Nodes made functional: each group now can be re-used (instanced)
with SHIFT+G. This works as well for local groups as library-linked
groups.

Also fixed that group nodes were copying internal data to the outside,
which made it impossible to use the socket-buttons to set individual
values for each group-instance.

Library-linked groups are prevented from editing. But, try to open a
group and it will give a request for 'make local'. The make local rule
is identical to other library data in blender, meaning:
- if all users of the library data are local -> the library data is
flagged 'local', and if needed a unique name is made
- if there's mixed users (local and from other library data) it makes
a full copy, and assigns this copy to all local users.

* If an empty is a forcefield, scale the 3D forcefield shape with the empty drawsize

Added "Blur factor" button in Vector Blur node, which scales the speed
vectors. It's actually shutter speed, but in this case works identical to
the old motionblur 'blur fac' button.

Note; the "Max Speed" button only clips speed, use this to prevent
extreme speed values. Max speed applied before the scaling happens.

This script sets the UV mapping and image of selected faces from adjacent unselected faces.

Use this script in face select mode.

Note- If you make new faces between faces that are alredy UV mapped there is currently no way to say- map from others... this script does exactly that. and can save a lot of time manually moving and welding UV coords one by one.
Its realy usefull for mapping after a scanfill too.

works with free verts and a bit faster

Cleaning up some bad stuff from the merge in the release/ directory.
Somebody with good knowledge of the current state of icons should
probably check blenderbuttons for correctness. Also, splash.blend
was corrupt, so I restored the old version, but it says 2.40...

From __bpydoc__

This script relaxes selected UV verts in relation to there surrounding geometry.

Use this script in face select mode.
Left Click to finish or wait until no more relaxing can be done.

Needed to add zbuf_accumulate_vecblur() to the stubs.c for correct
linking of the blenderplayer.

iImage based Vector Blur

After a couple of experiments with variable blur filters, I tried
a more interesting, and who knows... original approach. :)

First watch results here:
http://www.blender.org/bf/rt0001_0030.avi
http://www.blender.org/bf/hand0001_0060.avi

These are the steps in producing such results:

- In preprocess, the speed vectors to previous and next frame are
calculated. Speed vectors are screen-aligned and in pixel size.
- while rendering, these vectors get calculated per sample, and
accumulated in the vector buffer checking for "minimum speed".
(on start the vector buffer is initialized on max speed).

- After render:
- The entire image, all pixels, then is converted to quad polygons.
- Also the z value of the pixels is assigned to the polygons
- The vertices for the quads use averaged speed vectors (of the 4
corner faces), using a 'minimum but non-zero' speed rule.

This minimal speed trick works very well to prevent 'tearing' apart
when multiple faces move in different directions in a pixel, or to
be able to separate moving pixels clearly from non-moving ones

- So, now we have a sort of 'mask' of quad polygons. The previous steps
guaranteed that this mask doesn't have antialias color info, and has
speed vectors that ensure individual parts to move nicely without
tearing effects. The Z allows multiple layers of moving masks.

- Then, in temporal buffer, faces get tagged if they move or not
- These tags then go to an anti-alias routine, which assigns alpha
values to edge faces, based on the method we used in past to antialias
bitmaps (still in our code, check the antialias.c in imbuf!)

- finally, the tag buffer is used to tag which z values of the original
image have to be included (to allow blur go behind stuff).

- OK, now we're ready for accumulating! In a loop, all faces then get
drawn (with zbuffer) with increasing influence of their speed vectors.
The resulting image then is accumulated on top of the original with a
decreasing weighting value.

It sounds all quite complex... but the speed is still encouraging. Above
images have 64 mblur steps, which takes about 1-3 seconds per frame.

Usage notes:

- Make sure the render-layer has passes 'Vector' and 'Z' on.
- add in Compositor the VectorBlur node, and connect the image, Z and
speed to the inputs.
- The node allows to set amount of steps (10 steps = 10 forward, 10 back).
and to set a maximum speed in pixels... to prevent extreme moving things
to blur too wide.

ABF:

- Improved splitting of quads, which helps to avoid some degenerate triangles.
- Also improvements to choosing pins to preserve symmetry better in a few
typical cases.

Sky textures were using wrong pixel-size vectors, so images got sampled
totally blurred.

Thanks plumiferos team for the poke!

Fixed problem spottet by Ken Hughes, that prevented FFMPEG-output with
NTSC target from working (floating point exception).
Fixes bug #3879 from the bug tracker.