Blender Git Commits

Cycles: Experiment with using Lambert cylindrical equal-area projection

This commit implements new panorama and environment texture projection
which is called after a dude named Lambert:

https://en.wikipedia.org/wiki/Lambert_cylindrical_equal-area_projection

Advantage of this projection is that it doesn't waste sampling time next
to the poles (which is a huge issue for the equirectangular projection).

Disadvantage of this model is that there'll be some distortion on the
poles when mapping it back to the sphere.

This is partially worked around by using scaling magic so there'll be
a bit more samples added on the top/bottom of the image (which makes it
technically a Roosendaal-Sharybin mapping since that's what we've been
discussing in the studio).

Maybe we should be more aggressive here with clamping of the sine, but
let's start doing some real-world tests first.

Cycles: Experiment with native cubemap support in Cycles

This commit implements a native cubemap rendering in Cycles,
which is currently a research project with the following goals:

- Make it easier to render cubemaps for engines which supports
or expects them to be used.

- Intermediate projection to optimize rendering of equirectangular
camera.

Cube map layout is not currently standart but it's most efficient
from the resolution and storage point of views and it's currently:

+-------+-------+--------+
| Back | Right | Bottom |
+-------+-------+--------+
| Front | Left | Top |
+-------+-------+--------+

It's easy to re-map views in the future.

There are still issues to be solved, but it'll be nice to get
VR and panorama artists involved into feedback already. So the
limitations are:

- There's no auto-remapping to equirectangular map happening yet,
so the only way to see result is to put result to an environment
map with cubemap projection and either re-render or investigate
it in viewport.

- Projection formulas are not optimized by any mean. This is to
keep them totally obvious to make it easier to make further
tweaks.

Add UserPref option to change HMD device

A new file wm_device.c is added with this, think this is good to have.

NOTE: Couldn't really test if changing device actually works as I don't have one. Without a device available everything seems to work though.

better and safer to delete solver python variables (and thus trigger object deletion) at the end

Option to request interocular distance from HMD driver

Adds a new camera option to request the interocular distance (IPD) from the HMD device/driver. It's still an open design question if it's even worth to support a custom distance though.

Also hides convergence options for HMD mode, not sure if those are needed.

added current frame number to manta step. useful for standalone mantaflow script usage and for correct caching (uvweight)

run uv setup strings only when using high res

Partial port of the Python importer to C++.

For performance reasons, and cleaner code.

TODOs:
- cameras are not imported.
- better handling of the object names.
- object hierarchies/parenting.

fix attempt for some dynamic fracture rotation glitches

Cleanup: function names.

Remove unused function.

Start implementing the importer in C.

Only shell code for the operator is done at the moment. The Alembic API
would probably need to be refactored and cleaned up further before
pursuing this.

Merge the 'Alembic' modifier in the 'Mesh Cache' modifier.

Apply patch in a new branch.

fix: crash when removing FM, ob->derivedFinal can become NULL in this case

keep objects completely intact with compounds and stability factor = 1

Show option for interocular distance for HMD mode

Just as for stereo 3D, available in properties editor, camera context.

Merge branch 'master' into HMD_viewport

switched back to old uv setup using low res solver

stability factor should now influence overall stability of object more directly.
This should allow to control breaking behavior of the compounds better.
As before the masses still have the biggest influence to the breaking behavior, followed by thresholds and
connection count per shard.