There was a fixed limit to the number of points available in a buffer stroke.
Now, the array is expanded as needed using a predefined number of points for each expansion, instead to add one by one. This is done to reduce the number of times the memory allocation is required.
As part of the fix, some variables have been renamed to reflect better their use.
When using the clone brush, the first time the brush worked, but the next time no. The reasons were two:
1) The strokes were copied to the active layer, but if there were more than one layer, the stroke must be copied to the original layer.
2) The materials were not assigned properly and the materials were set as the first slot in the list always.
Now, the original layer name is used to try to find the same layer in destination. If the layer is missing, the active layer is used.
For materials, the bug in the hash lookup is fixed and the material is assigned to the right slot.
The issue was that the redo panel area would call with region type HUD (not WINDOW).
Now we make sure that the redo panel always polls the operator in the original area type context.
Reviewed By: Brecht
Differential Revision: http://developer.blender.org/D5361
While speedup is hard to detect (highly fluctuent), it seems to be
around 5% on average on my 8 threads machine...
It also remove usage of a 'global' thread lock, which is always good.
Note that I also tried to use proper foreach threaded iterator construct
(see D5372), but that proved to be relatively slower (presumably due to
the very high dissymmetry between tasks, usually during a paint stroke
only a few chunks will require most of the computing effort, overhead of
threaded foreach management is then noticeable).
This concludes (for now) the work on
T51133 Bad performance with texture painting depending on multi-thread settings.
This allows to type in numinput 720 and indeed get a rotation of 720°, not 0°...
This patch basically applies 'big rotations' in steps < 180°, such that
compatible rotation works as expected. This implies resetting current
rotation to initial one first, otherwise we'd end up applying much more
turns than expected when that code is called more than once.
It also makes things somewhat slower for big rotations (millions of degrees),
Hence we clamp to 1000 turns max.
And since that's a case that cannot happen with regular tool/widget-driven rotation,
it's only enabled when numinput is used for now.
Review task: https://developer.blender.org/D5289
Curve drawing was attempting to draw reprojection error curve when it was
not visible.
Worst thing is that the imm was not informed about vertices, so the code
was causing an assert in debug mode. Probably, it is also what have caused
random crashes after recent changes.
We didn't include and of the newer interpolation types in the
normalization function.
Besides taking into account these newer types, we now also only evaluate
the curves when needed. If the values between the control points won't
exceed the control point values, we only use the start/end values for
our normalization
Reviewed By: Brecht
Differential Revision: http://developer.blender.org/D5365
Mesh can not be requested from original object, and it can not be
copied into evaluated modifier because there is no such a thing yet.
It can not be done this way now, because getting evaluated object
will force it to re-calculate, which kind of defeats idea of this
code to preserve un-baked particles.
This commit moves the API of selecting faces, vertices and edges to a DRW manager engine.
Reviewers: campbellbarton, fclem
Subscribers: jbakker, brecht
Differential Revision: https://developer.blender.org/D5090
This is useful when popovers are launched from operators
instead of as button popover types.
Where the connection between the button and the popover is useful to keep.
We cannot reliably use translations API from non-main threads.
Now storing translated strings in a static cache, with basic mechanism
to update it on language change.
Reviewers: brecht, campbellbarton
Differential Revision: https://developer.blender.org/D5350
Weight Painting was using mask if "Selection Mask" in Sculpt Mode is turned on.
This can be quite confusing because the option to turn it off is not available in Weight Painting and the selection is also not visible.
Now the mask is not checked in weight paint mode.
Some modifier operators cannot be reliably executed from Edit mode
currently, so disable them from the generic mod ops pool function.
Have been very conservative here from now, keeping existing behavior
most of the time, and only forbidding Edit mode when code was already
doing it in its own way, or when it was obviously not possible.
Main issue in that report was that meshes generated from
`mesh_create_eval_final_view()` and the like need some
special freeing handling (as, among other things, they borrow and do not
own their potential editmesh data...).
Factorized that into a helper func also used by
`BKE_object_free_derived_caches()`.
Such reload can no longer happen directly and is to be done via dependency
graph.
Eventually, the movie cache will become shared across all copies of the
clip, but even then we still need to have dependency graph mechanism because
we need to update FFmpeg animation handle (which can not be shared across
the copies).
This change makes it so current frame is queried from a scene rather
than from a dependency graph. This makes it possible to avoid the
fact that dependency graph might not be fully evaluated yet.
There are still some cases where it frame is queried from the graph,
but those seems to be in a code path where we need to ensure valid
dependency graph anyway.
Reviewers: brecht
Reviewed By: brecht
Differential Revision: https://developer.blender.org/D5349
The amount of triangles drawn by the button depends on its `sizex`.
See:
```
immBegin(GPU_PRIM_TRI_STRIP, (sizex + 1) * 2);
```
Therefore the `sizex` cannot be 0.
Solution a bit similar to rB56b0cd1d.
Ref T67671
Reviewers: fclem, brecht
Maniphest Tasks: T67671
Differential Revision: https://developer.blender.org/D5347
Current frame is stored in a scene, and scene might have multiple view
layers. The inactive view layers were not informed about scene's frame
being changed, so when user switched back to view after changing scene
frame it was in an inconsistent state between current scene frame and
animation.
Now we tag scene for time changes, so dependency graph can catch up
and do proper update.
Currently tagging is from quite generic place. Probably better approach
would be to tag from where frame is actually being assigned. Downside
of this is that it's easy to miss some places.
Reviewers: brecht, mont29
Reviewed By: brecht
Maniphest Tasks: T66378
Differential Revision: https://developer.blender.org/D5332
Need to copy changes from original armature to evaluated one prior to
BKE_pose_where_is(), otherwise the pose matrix in pose channels will
not be correct.
Can not use dependency graph update here, since we must not re-evaluate
possible dependencies of the changed armature.
Reviewers: brecht
Reviewed By: brecht
Maniphest Tasks: T67507
Differential Revision: https://developer.blender.org/D5331
