Blender Git Commits

Combined storage of render and realtime data in caches.

Caches now create 2 new roots below the main 'top' object of Alembic:
root and root_render for realtime and render data respectively.
This makes it easy to switch the whole archive to either of the modes
during baking and for constructing dupli caches.

Alternatively individual objects could store hires versions of their
data. This would also be more efficient if the cache contains many
simple objects which don't have 2 different variants. However, such
design decisions are difficult to make at this point and the
implementation can be modifier later.

Fix for use of wrong CustomData for tessfaces.

MCol customdata caching.

CD_NORMAL support for mesh customdata caching.

Replacing boundbox temporarily during drawing is dangerous, since it
can be freed at any point.

Luckily we only need the boundbox locally for testing dupli visibility.

Distinguish realtime/render setting in the Object writer.

Now the derived_render mesh version is created locally when writing
render results.

Disable the bake operator if cache reading is enabled.

Re-baking cache results is not technically prohibited, but not useful
and allowing only read or write selectively gives a nicer workflow.

Added customdata writers/readers for missing mesh edge, poly and loop
data.

Test for NULL archive pointer when writing as well.

This should not usually happen because the operator asks for permission
to delete the file prior to writing, but should be checked nevertheless.

Main argument is no longer needed for cache reading, the cachelib is
now given explicitly.

MTFACE customdata is not suitable or necessary for caching, so disable
it.

Safeguard against crashes from invalid Alembic file paths by returning
NULL archive pointers.

This allows writer/reader code to test against obvious archive errors
easily and is unmistakable.

Skip drawing of particle systems (including hair) when using cache
duplis.

Particle systems can not be overridden from caches easily, there are too
many strings attached to the data and code to make this reliable.
Instead, a new simplified data structure for reading hair from caches
will be added, which replaces drawing and rendering of particle data.
The original particle data is not updated through duplis, so is usually
out of sync and should not be displayed.

UI cleanup and a bit nicer workflow by treating read/write mode like
an enum toggle.

Removed unused variable.

Cycles support for dupli caches.

If a cache is read-enabled cycles will now use the cached mesh data
instead of dupli results.

Calculate bounding boxes for cached DMs to avoid visual popping when
using the original Object's bb.

Use a new flag in duplicator objects to enable cache reading and avoid
unnecessary dependencies.

This flag will replace the current "read" mode on cache libraries.

Beside enabling cache reading, it also disables the current "fake"
dependencies between duplicators and their group objects. This is
exploiting the layer visibility mechanism in depsgraph to ensure that
animated group objects get evaluated when used by a visible duplicator,
even when they are not themselves visible. These dependencies cause
group object updates even if the duplicator is using cached results.
To avoid this unnecessary overhead and make caching worthwhile we
rebuild depsgraph without these relations when using the cache instead.

Added a cache library pointer to objects as a replacement for CL->GR
pointers.

Relationship between CacheLibrary, duplicator Objects and Groups is
difficult. There are a number of somewhat conflicting goals:
- CacheLibraries write out data for objects and dupli groups. Multiple
objects can be stored in the same cache: CL *->* GR
- Objects can override a dupli group with different caches: OB *->1 CL
- As before, each object can be the duplicator for one group: OB *->1 GR

To combine these requirements, the first relationship will be made
indirect. Only the Object -> Group/CacheLib relations are explicit
pointers in the DNA. For finding all objects contained in a cache
library the usual recursive DNA tagging system must then be used.

Mesh overrides for duplis from cached Alembic data.

If a duplicator has cached data it will now replace the derivedFinal
mesh of objects with the cached version for drawing.

This is a compromise atm: It would be better to actually draw derived
meshes directly, so that we don't have to modify objects. Then we could
also have multiple different instances of the same orignal object
(in whatever way these might be defined). DNA Objects would then be
totally separate from duplis, but at this point the drawing and render
code makes this unfeasible.