- adding new points de-selects previous so Ctrl+Click+Drag works usefully.
- cyclic curves now extrude properly
- adding new points inbetween existing now use the surrounding points handle length.
Added four new functions as shortcuts to creating GHashes that use the
standard ptr/str/int/pair hash and compare functions.
GHash *BLI_ghash_ptr_new(const char *info);
GHash *BLI_ghash_str_new(const char *info);
GHash *BLI_ghash_int_new(const char *info);
GHash *BLI_ghash_pair_new(const char *info);
Replaced almost all occurrences of BLI_ghash_new() with one of the
above functions.
- Triangulate Cloth Mesh for collisions
- Speed up collisions
- Remove EL Topo code
- Prepare code to incooperate El Topo self collisions (TODO next commits)
TODO:
----------
- Triangulation: Is custom data/uv preserved correctly?
- Use MPoly not tessface?
- reuses auto handle calculation
- keeps handle length relate to surrounding handles
todo
- only works well when cyclic is off
- isnt aspect aware (looks like other tools are not aspect aware too)
Added support of tracks to have their own grease pencil datablock.
This is controllable by Clip/Track toggle in Grease Pencil panel
in Clip Editor.
This toggle shows whether grease pencil stroke should go to movie clip's
datablock or to active track. As soon as this toggle is switched to Track,
all further strokes would be added to active track and only strokes which
belongs to active track would be displayed on the screen.
This strokes would be relative to track's position, which means if one
made some strokes to track and started moving it, stokes would be moved
together with track.
Different tracks might share the same grease pencil datablock.
Also hide draw modes which are not supported by space clip.
Initial idea why tracks should have grease pencil datablocks was to
support easy mask creation for tracking. This seemed fastest and
easiest way to achieve mask editing for tracks.
To get mask for specified track there's function BKE_tracking_track_mask_get
which requires MovieTracking structure, track for which mask is creating and
also width and height of current overall frame. it'll return ImBuf with
mask (probably it's more like overkill, because internally it works with
single-channel value buffer and probably that's one should be passing to
libmv).
Probably hacking grease pencil in such way is not ideal solution, but that
part of code might be cleaned up further and it seems to be straightforward
to use grease pencil for such a purpose.
Note: this is commit to tomato branch, not to trunk.
This starts converting markers in the movie clip editor / 2D
tracker from using pat_min and pat_max notation to using the
a more general, 4-corner representation. There is still
considerable porting work to do; in particular:
- The preview widget does not respect the new
representation
- The corners cannot yet be edited individually.
- The clamping does not do the right thing for general
corners; e.g. detecting a convex quad.
- The tracking code in Blender does not actually invoke the
corner tracking version of libmv's tracking API.
Next steps:
- Convert libmv's legacy ESM tracker and brute tracker to
work under the new TrackRegion() API.
- Make Blender use the new TrackRegion() API; this will
allow real planar tracking tests.
- Everything else (UI, etc).
This patch is mostly the work of Sergey Sharybin.
Conflicts resolved:
source/blender/blenkernel/intern/material.c
source/blender/blenkernel/intern/subsurf_ccg.c
source/blender/blenloader/intern/readfile.c
source/blender/editors/animation/anim_channels_defines.c
source/blender/makesrna/intern/rna_scene.c
Additional changes:
* Fix for recent changes of BKE_* function renaming.
* Fix for an "attempt to free NULL pointer" in BlenderStrokeRenderer::RenderStrokeRepBasic().
... instead add scene.sequencer_editor_create / clear, these match id.animation_data_* functions.
- refactor for names, for scene level functions call them BKE_sequencer_*
* Add new CCG function ccgSubSurf_setAllocMask(). Similar to to
ccgSubSurf_setCalcVertexNormals(), it sets whether the CCG elements
have a mask layer and what that layer's offset is. Unlike normals
however, it doesn't change any behavior during CCG calculation; it's
there only to give CCGKey information on the mask.
* Add a new flag to _getSubSurf(), CCG_ALLOC_MASK. If set, space for
an extra layer is allocated, but the number of CCG layers is not set
to include it. This is done because GridPaintMasks are absolute,
rather than being relative to the subdivided output (as MDisp
displacements are), so we skip subdividing paint masks here.
* Add a new flag to subsurf_make_derived_from_derived(),
SUBSURF_ALLOC_PAINT_MASK. This controls whether CCG_ALLOC_MASK is
set for _getSubSurf(). Related, masks are never loaded in during
ss_sync_from_derivedmesh(). After subdivision is finished, if the
alloc mask flag is set, the number of CCG layers is increase to 4
with ccgSubSurf_setNumLayers().
* Add a new flag to multires_make_from_derived(),
MULTIRES_ALLOC_PAINT_MASK. Not all multires functions need paint
mask data (e.g. multiresModifier_base_apply.) This flag is always
set in MOD_multires.c so that subdividing a mesh with a mask updates
properly even when not in sculpt mode.
* Update multiresModifier_disp_run() to apply, calculate, and add mask
elements. It's almost the same as the existing operations with xyz
coordinates, but treats masks as absolute rather than displacements
relative to subdivided values.
* Update multires_customdata_delete to free CD_GRID_PAINT_MASK in
addition to CD_MDISPS.
* Update multires_del_higher() to call the new function
multires_grid_paint_mask_downsample(), which allocates a
lower-resolution paint mask grid and copies values over from the
high-resolution grid.
CD_PAINT_MASK is a layer of per-vertex floats for non-multires
meshes. Multires meshes use CD_GRID_PAINT_MASK, which is a layer of
per-loop GridPaintMask structures. GridPaintMask is similar to MDisp,
but contains an array of scalar floats.
Note: the GridPaintMask could be folded into MDisp, but this way
should be easier to add mask layers in the future (if we do fold
GridPaintMask into MDisp, the mask array should probably be an array
of arrays with a 'totmask' field so that mask layers can be easily
supported.)
Includes blenload read/write support for CD_PAINT_MASK and
CD_GRID_PAINT_MASK.
* Changes to DerivedMesh interface: DMGridData has been removed,
getGridData() now returns an array of CCGElem pointers. Also added
getGridKey() to initialize a CCGKey (implemented only by
CCGDerivedMesh.)
* PBVH: added BLI_pbvh_get_grid_key().
* A lot of code is affected, but mainly is just replacing
DMGridData.co, DMGridData.no, and sizeof(DMGridData) with the
CCG_*_elem functions, removing the reliance on grid elements of
exactly six floats.
CCGKey caches information about the CCGSubSurf element layout. This
data, along with the CCG_* inline functions, allows access to
CCGSubSurf elements with an arbitrary number of layers (as opposed to
the hardcoded DMGridData structure which assumes xyz coordinates
followed by three normal components.)
The CCGElem structure is declared but not defined anywhere, just used
as a convenient type.
The layout of vert data in CCGSubSurf is almost the same; previously
it was three floats (for xyz coordinate) optionally followed by three
floats for the normal. The only change is that the first three floats
can now be any number of floats.
* _getSubSurf takes a numLayers parameter to set the number of layers,
stored in CCGMeshIFC.numLayers.
* All calls to _getSubSurf currently have numLayers set to 3, except
for UV subsurf, where it is reduced to 2 (with a corresponding
change when reading the results out to use float (*)[2] rather than
float (*)[3].)
* The various VertData* macros in CCGSubSurf.c are now functions that
take a CCGSubSurf pointer, which provides access to CCGMeshIFC,
which has numLayers.
* Add ccgSubSurf_setNumLayers() to the API. Only changes the number of
layers that get subdivided, doesn't change the amount of memory
allocated. So if space for N layers is allocated, it's safe to set
the number of layers to less than N, but not more.
* The rest of the changes are just adding the 'ss' parameter.
Changed name to multires_make_derived_from_derived() and parameter
order to be more similar to subsurf_make_derived_from_derived().
Added MultiresFlags enum with flag values to replace the local_mmd and
useRenderParams parameters.
