Blender Git Loki

Made exr saving respect the 'RGB' or 'RGBA' setting in render output
panel. Saves a whopping 25% filesize!

The preview-jpg option for rendering exr files was saving 32 bits jpg...
a weird format only blender can read properly. Made it 24 bits.

Also: fixed very weird line-endings in pipeline.c after schlaile's last
commit here.

Further tweak of Vector Blur and alpha;

- it now correctly pre-multiplies with alpha the RGB values for the
antialised mask (alpha artefacts were visible)
- The transparent layer will add speed vectors on top of the solid layer,
cancelling out cases where the solid layer was not moving (like in its
own antialising.
This works fine, for as long you don't render in a single pass trans-
parent faces that move on top of not-moving solid faces.

Added "select same group" to select group menu.

msvc6 projects that will compile when MEM_Allocator.h is fixed

Compositing workflow upgrade;

You now can set a Preview panel in the Image window, to define a sub-rect
of an image to be processed. Works like the preview in 3D Window. Just
press SHIFT+P to get it activated. Very nice speedup!

This is how it works:

- The compositor still uses the scene image size (including % setting) for
Viewer or Composite output size
- If a preview exists, it calculates the cropped rect from its position
in the Image window, and stores that in the Scene render data
- On composite execute, it copies only this part from the 'generator nodes',
right now Images or Render Results. That makes the entire composite tree
only using small rects, so it will execute fast.
- Also the render window will only display the cropped rect, and on F12
only the cropped part is being executed
- On rendering in background mode, the cropping is ignored though.

Usability notes:

- translating or zooming view will automatically invoke a recalculation
- if you zoom in on details, the calculated rect will even become smaller
- only one Imagewindow can have this Preview Panel, to prevent conflicts of
what the cropped area should be. Compositing is on Scene level, not local
per image window. (Note; 3D Previews are local per window!)
- Closing the preview panel will invoke a full-size recalculation
- All passes/layers from rendering are nicely cropped, including Z and
vectors.

The work to make the compositor do cropping was simple, but getting the
Image window displaying correctly and get all events OK was a lot of work...
indeed, we need to refactor Image Window usage once. Sorry for making the
mess even bigger now. :) I've tried not to interfere with UV edit or Paint
though... only when you're in compositing mode the panel will work.

BUG fix:

3D Preview render didn't work when multiple layers were set in the current
scene.

add #include <sys/time.h> to get declaration of struct timeval on
loonix for that ${BADWORD} webserver thingie.

Changed Composit Composite.

(Voted on #blendercoders and did some websearching and it seems like
this is more correct.)

Kent

Seam Cutting in Faceselect Mode:

- Mark Border Seam: mark edges on the border of face selection as seam.
- Clear Seam: clears seams in selected faces.
Hotkey: Ctrl+E

- Alt+RMB Click: mark/clear edge as seam
- Alt+Shift+RMB Click: mark/clear seams along the shortest/straightest path
from last marked seam. The cost of the path also includes some measure of
'straightness' next to the typical distance to make things work more
predicatble and edgeloop friendly. Note that this cuts a path from edge to
edge, not vertex to vertex. That gives some nice control over the direction
of the seam.

Also includes:

- Removed old LSCM code.
- Fix updates glitches with DerivedMesh/Subsurf drawing in FaceSelect mode.
Now there's a drawMappedFacesTex instead of drawFacesTex.
- Minimize Stretch menu entry called Limit Stitch.
- Removed the lasttface global, was being set before it was used anyway, so
might as wel return from a function.
- Moved some backbuf sampling code to drawview.c from editmesh, so it can be
used by Faceselect and VPaint.
- Use BLI_heap in parametrizer.c.

Upgraded max limit for faces in render. Up to now, quads were zbuffered
as triangles, with a tag bit to denote which triangle was which part of
the quad. That was hardcoded bit 0x800000, which allows a maximum of
about 8 million quads...

I've made this a nice #define, set to be 16 times larger. So, now the
facejunkies can go up to 128 Million faces, were it not that this will eat
up a load of memory!
I only have 1 Gig in this machine. A test with 9M vertices and 7.5M quads
eats up 912 MB of memory already. If this becomes a real issue, I know
tricks how to make the vertices 20 bytes smaller, and faces 4 bytes, which
would in the above case save about 200 MB. Not much... but probably worth
the try? A much better method is of course 'bucketing' the renderdata per
tile. It's a spec of the render recode, but not a quicky to add.

Also: bug fix in curve code. There was a short counter still, crashing on
large curves with resol set to 1024 :)

A Heap / Priority Queue ADT, will be used for Dijkstra shortest path.

Three fixes;

- Composit cache now gets fully freed on a render. Each output socket of a
node stores the entire image... and while render that's a waste of memory

- Sky 'paper' render was using wrong texture coordinates

- Found missing test_break() in ztransp rendering.

More things for easying the job of replacing proxy/working armatures in the scenes of Elephants Dream with the final ones: 1) adds removing Fakeusers from Actions to PyAPI, now with a hackish call in the Blender module. Possibility of better ways should be discussed on bf-python. 2) adds BPY Object.copyNLA(otherob) - that was simple 'cause the copy_nla function was nicely in kernel nla.c. 3) Object.convertActionToStrip(), here it gets tricky: the function to convert the active action of an object to a NLA strip was buried inside the respective function in the GUI editnla.c which had also code for reading mouse coordinates and whatnot. So I took the actual copying out of it and moved it to the kernel nla.c as a new function, bActionStrip *convert_action_to_strip (Object *ob). that code used other functions, of which find_stridechannel() was also in editnla.c but free of UI code so i moved it to kernel too. kept things with UI code in editnla.c. tried to be careful with keeping mallocs and the pointer business intact, and tested that this works and after usage Blender gives no memory warnings or anything, so seems ok - but certainly is best reviewed by ppl more active with c coding than me. hopefully this little refactor makes it possible to add this function to the menus too, which was not straightforward earlier when Matt took a look at it.

New:

- ZTransp render now also delivers Z values and Speed vectors in passes
Note that speed vectors accumulate within a pixel to store the minimum,
so rendering ztransp on top of a non-moving plane won't give speed...
Best results you get is by rendering it in a separate layer.

The Z value stored is the closest visible transparent face in the pixel.

Fixes:

- Render to 'spare page' has been enabled again. Because of the strict
separation of Render and UI, but especially because a 'render result' now
can consist of unlimited images, I've not made this a Render feature.
Instead, the render-window itself stores the 'spare' image... I also
had to change the convention for it a bit.

Now, instead of having two "render buffers" (which was a render feature),
the RenderWindow will store each previous frame on a re-render. This
storing will only start after you've pressed 'Jkey' once, but then always
will happen for as long the rendered image is same size as previously.
For clarity, I've also renamed the window title, to 'previous frame'.

- RenderWindow shows alpha again on Akey

- Display of the Zvalues in ImageWindow has been tweaked. White now denotes
closest, and the color range goes from camera clip-sta to clip-end.

- Bugfix: on splitting/merging/duplicating windows, the 3D Previewrender was
not always freed correctly, potentially causing crashes or memory leaks.

This script converts open and closed edge loops into polylines

Supported:
Polylines where each vert has no more then 2 edges attached to it.

Changed MEM_freeN(nu->knotsu);
to..
if (nu->knotsu) MEM_freeN(nu->knotsu);
Python created curves have nu->knotsu set to zero and was throwing.
Memoryblock free: attempt to free NULL pointer

- Autosmooth now calculates smoothing based on original object-space
vertex locations, not global coordinates. This ensures consistant
autosmoothing for each frame. Also fixes missing vectorblur for parts.

Nice task for a dev: put autosmooth code in end of modifier stack... then
it also shows in 3D window

- BUG FIX! I noticed the last tile rendered quite slow, and even did not
update scanlines. Found out that the main tiles processor didn't go
to sleep when the last tile was rendered, because it detected a free
possible thread. This caused the main thread to go into a very tight
loop, eating up a lot of cpu and blocking the other thread.

==SCons==
+ install blenderplayer to BF_INSTALLDIR after successful build

==SCons==
* 'scons blenderplayer' links the blenderplayer now correctly also on win32-vc.
If the OS X-folks can verify the linking of the blenderplayer too, we'd have
much of the needed work done.

==SCons==
* The only lib that needs change in more than one place (two), and I forgot
that, of course.