Add a call to orthogonalize the matrix before processing for the
same reasons as D8915, and an early exit in case no limits are
enabled for a bit of extra efficiency.
Since the constraint goes through Euler decomposition, it would
in fact remove shear even before this change, but the resulting
rotation won't make much sense.
This change allows using the constraint without any enabled limits
purely for the purpose of efficiently removing shear.
Differential Revision: https://developer.blender.org/D9626
Since Limit Rotation is based on Euler decomposition, it should allow
specifying the order to use for the same reasons as Copy Rotation does,
namely, if the bone uses Quaternion rotation for its animation channels,
there is no way to choose the order for the constraint.
Ref D9626
Fixed the logic for seeking in ffmpeg video files.
The main fix is that we now apply a small offset in ffmpeg_get_seek_pos
to make sure we don't get the frame in front of the seek position when
seeking backward.
The rest of the changes is general cleanup and untangling code.
Reviewed By: Richard Antalik
Differential Revision: http://developer.blender.org/D11492
Due to the way we ship the CRT on windows TBB's
malloc proxy was unable to attach it self to
the memory management functions on windows 10.
This change moves ucrtbase.dll out of the blender.crt
folder and back into the main blender folder to side
step some undesirable behaviour on win10 making TBB
once more able to attach it self.
Having this work again, should give a speed
boost in memory allocation heavy workloads
such as mantaflow.
For details on how this only failed on Win10
see T88813
This patch exposes functionality for performing partial mesh updates
for normal calculation and face tessellation while transforming a mesh.
The partial update data only needs to be generated once,
afterwards the cached connectivity information can be reused
(with the exception of changing proportional editing radius).
Currently this is only used for transform, in the future it could be
used for other operators as well as the transform panel.
The best-case overall speedup while transforming geometry is about
1.45x since the time to update a small number of normals and faces is
negligible.
For an additional speedup partial face tessellation is multi-threaded,
this gives ~15x speedup on my system (timing tessellation alone).
Exact results depend on the number of CPU cores available.
Ref D11494
Reviewed By: mano-wii
Cycles, Eevee, OSL, Geo, Attribute
This operator provides consistency with the standard math node. Allows users to use a single node instead of two nodes for this common operation.
Reviewed By: HooglyBoogly, brecht
Differential Revision: https://developer.blender.org/D10808
rB847579b42250 updated the TBB build script
which had some unintended consequences for
windows as the directory layout slightly
changed.
This change adjusts the builder to the new
structure, there are no version/functional
changes.
When changing to another texture paint slot, the texture displayed in
the viewport should change accordingly (as well as the image displayed
in the Image Editor).
The procedure to find the texture to display in the viewport
(BKE_texpaint_slot_material_find_node) could fail
though because it assumed iterating nodes would always happen in the
same order (it was index based). This is not the case though, nodes can
get sorted differently based on selection (see ED_node_sort).
Now check the actual image being referenced in the paint slot for
comparison.
ref T88788 (probably enough to call this a fix, the other issue(s)
mentioned in the report are more likely a feature request)
Reviewed By: mano-wii
Maniphest Tasks: T88788
Differential Revision: https://developer.blender.org/D11496
The (tracking) camera presets have not been updated in the last 7 or
more years, so they are very outdated. I found it pointless to have a
few specific camera models in the list and instead add the most commonly
used sensor sizes/film sizes. This way the list is shorter, easier to
maintain/becomes later outdated, and is more user friendly for most people
who don't own any of the specific cameras. I added the Crop Factor to the
Beginning of the name, so it gets sortet in the correct order and presets
are easier to find based on the size.
Reviewed By: #render_cycles, #motion_tracking, brecht, sergey
Differential Revision: https://developer.blender.org/D10739
These were only showing in the Properties Editor, but there is no reason
to have the panels be different in the sidebar (they should not show in
the top bar though).
agreed upon by both @anoniov and @mendio
ref T88787
So far, linked IDs were not properly sorted at all, only the ones
explicitely linked from WM code would be, but any indirectly linked
data-blocks would end up in some random order in their lists.
While not ideal, this is not a huge issue in itself, but it had bad
side-effects, e.g. causing (recursive) resync of overrides to happen in
random order, leading to mismatches between name indices of newly-generated
override IDs and the one existings e.g.
And in general, it is much better to be consistent here.
Note that the file sub-version is bumped for this commit, since some
sorting (the directly linked IDs which we keep a reference to) should
never need to be re-done after relevant doversion process.
This commit adds a node that outputs the total length of all
evalauted curve splines in a geometry set as a float value.
Differential Revision: https://developer.blender.org/D11459
This commit implements support for deleting curve data in the geometry
delete node. Spline domain and point domain attributes are supported.
Differential Revision: https://developer.blender.org/D11464
This implements T87633
This overlay renders a flash animation on the target object when
transfering the mode to it using the mode transfer operator.
This provides visual feedback when switching between objects without
extra overlays that affect the general color and lighting in the scene.
Differences with the design task:
- This uses just a fade out animation instead of a fade in/out animation.
The code is ready for fade in/out, but as the rest of the overlays
(face sets, masks...) change instantly without animation, having a fade
in/out effect gives the impression that the object flashes twice (once
for the face sets, twice for the peak alpha of the flash animation).
- The rendering uses a flat color without fresnel for now, but this can
be improved in the future to make it look more like the shader in the
prototype.
- Not enabled by default (can be enabled in the overlays panel), maybe
the defaults can change for 3.0 to disable fade inactive and enable this
instead.
Reviewed By: jbakker, JulienKaspar
Differential Revision: https://developer.blender.org/D11055
This operator is needed in some cases to update image preview.
In workspaces with smaller timelines this is limiting, because users
need to first check that mouse cursor is in correct place, then press
CTRL+R shortcut.
The Wayland server will not update hidden surfaces. This will block the
main event loop and thus also block updates to visible windows in a multi-
window setup.
Keyboard click-drag events now use the "Drag Threshold".
This resolves a problem where keyboard click drag events
used a much smaller threshold when using a tablet.
In some cases e.g. only objects would actually need resync, so
collections on the override character would not be resynced, and if some
objects were sharing relationships with others those could be
lost/destroyed.
max unneccessarily
Since rB298d5eb66916 [which was needed to update buttons with custom
property range functions correctly], using tab would always clamp
(hardmin/hardmax) properties which were using FLT_MAX / INT_MAX as range
in their property definitions.
The clamping of rB298d5eb66916 was copied over from rB9b7f44ceb56c
[where it was used for the softmin/softmax], and while the re-evaluation
of hardmin/hardmax is needed for custom property range functions, the
clamping should actually not take place.
There are many properties using FLT_MAX / INT_MAX etc. and while it
probably would be good to update these with ranges that make more sense
-- not using FLT_MAX / INT_MAX would not have done the clamping here --
there should not be an arbitrary limit to these and they should stay as
they are.
Maniphest Tasks: T88762
Differential Revision: https://developer.blender.org/D11473
Ensure 'virtual' linked override IDs generated by the recursive resync
process are tagged as indirectly linked data.
This is needed to avoid the 'missing data' messages on those virtual
data-blocks after saving and reloading.
`BKE_main_collections_parent_relations_rebuild`,
`BKE_collection_parent_relations_rebuild` anf their internal
dependencies had two issues fixed by this commit:
* Main one was that a same collection could be processed several times,
sometimes even in an infinite loop (in some rare corner cases), by
`collection_parents_rebuild_recursive`.
* More exotic, code here would not ensure that the collections it was
processing were actually in Main (or a master one from a scene in
Main), which became an issue with some advanced ID management
processes involving partially out-of-main remapping, like liboverride
resync.
Use SEQ_time_strip_intersects_frame function to test if strip intersects with frame.
Note: There are cases where this function should not be used. For example splitting
strips require at least 1 frame "inside" strip. Another example is drawing, where
playhead technically doesn't intersect strip, but it is rendered, because current
frame has "duration" or "thickness" of 1 frame.
Reviewed By: sergey
Differential Revision: https://developer.blender.org/D11320
Remove unused flag `SEQ_DUPE_ANIM` and code used by this flag.
Remove flag `SEQ_DUPE_CONTEXT` and refactor code, to split operator
logic from duplication code.
Reduce indentation level in for loop.
Reviewed By: sergey
Differential Revision: https://developer.blender.org/D11318
Images with 4:2:2 and 4:4:4 chroma subsampling were blurred when
`SWS_FAST_BILINEAR` interpolation is set for `anim->img_convert_ctx`.
Use `SWS_BILINEAR` interpolation for all movies, as performance is
not impacted by this change.
Reviewed By: sergey
Differential Revision: https://developer.blender.org/D11457
Changes in rBce649c73446e, affected established proxy codec preset.
Presets were not working and all presets were similar to `veryfast`.
Tunes are now working too, so `fastdecode` tune can be used. I have
measured little improvement, but I tested this only on 2 machines and
I have been informed that `fastdecode` tune does influence decoding
performance for some users.
Change preset from `slow` to `veryfast` and add tune `fastdecode`
Reviewed By: sergey
Differential Revision: https://developer.blender.org/D11454
While encoder parameters for lossless encoding are set correctly,
output is not lossless due to pixel format being set to
`AV_PIX_FMT_YUV420P` which is inherently lossy due to chroma subsampling.
This was reported in T61569 and was merged to T57397, but there were
2 bugs - one for encoding and one for decoding.
Set pixel format to `AV_PIX_FMT_YUV444P` when rendering lossless H264
files. This format isn't available in `codec->pix_fmts[0]` and it looks,
that it has to be hard-coded.
Reviewed By: sergey
Differential Revision: D11458
This patch is from erik85, who says:
This patch makes populate_plane inside polymesh_from_trimesh_with_dissolve run in parallel.
On a test file with a boolean between two subdivided cubes (~6 million verts) this gives a 10% speed increase (49.5s to 45s) on my 6 core CPU.
Also there is an optimization of other_tri_if_manifold to skip the contains-call and get the pointer directly.
This reduces CPU time for find_patches from 5s to 2.2s on the same test file.
When there are many components (separate pieces of connected mesh),
a part of the algorithm to determine component containment was slow.
Using a float version of finding the nearest point on a triangle
as a prefilter sped this up enormously. A case of 25 icospheres
subdivided twice goes 11 seconds faster on my Macbook pro with this
change.
This just moves a couple of files in `space_node` to C++ and fixes
related errors.
The goal is to be able to use C++ data structures to simplify the code.
Differential Revision: https://developer.blender.org/D11451
The mesh to curve node generated an empty curve because no edges were
selected. This commit changes that node to not add a curve in that case.
This also changes the curve to mesh node to not add a material when
no mesh was created. Even though we don't expect null curves or meshes
in this case, the change is harmless.
EEVEE uses hashing to sync aov names and types with the gpu.
For the type a hashed value was overridden making `decalA`
and `decalB` choose the same hash. This patches fixes this
by removing the most significant bit.
EEVEE uses hashing to sync aov names and types with the gpu. For the type a hashed value was overridden making `decalA` and `decalB` choose the same hash. This patches fixes this by removing the most significant bit.
Sometimes is required to reset the thickness or the opacity of the strokes. Actually this was done using a modifier, but this operators solves this.
Reviewed By: mendio, filedescriptor
Maniphest Tasks: T87427
Differential Revision: https://developer.blender.org/D11453
Often you need to copy a spline to do an operation, but don't want
to manually copy over all of the settings. I've already forgotten to
do it once anyway. These functions copy a spline's "settings" into a
new spline, but not the data. I tried to avoid duplicating any copying
so this is easier to extend in the future.
Differential Revision: https://developer.blender.org/D11463
This is due to cam->obmat precision issue,
where it affects view vector precision.
Reviewed by Sebastian Parborg (zeddb)
Differential Revision: https://developer.blender.org/D11461
Often it would be beneficial to avoid the virtual array implementation
in `geometry_component_curve.cc` that flattens an attribute for every
spline and instead read an attribute separately for every input spline.
This commit implements functions to do that.
The downside is some code duplication-- we now have two places handling
this conversion. However, we can head in this general direction for the
attribute API anyway and support accessing attributes in smaller
contiguous chunks where necessary.
No functional changes in this commit.
Differential Revision: https://developer.blender.org/D11456
Initial steps for T88184.
Adds a `filelist/` directory to `editors/`, containing C++ classes for
(recursively) reading directories and files into a file-list. The logic is
based on the File-Browser file-list, so that the actually executed logic is
basically the same (avoiding regressions or old issues re-appearing). But it
is entirely re-designed to work for both the asset system and the file browser.
For more info about the design, see T88184.
Also contains "peeking" the file list to count the files to be read. This is to
improve progress reporting later. However, it has some issues and I'm not sure
actually it's something we'll even need in the end, I see other ways to improve
things here.
I want to clean this up a bit still, but it seems to work now.
Also includes (to be split off):
* Don't allow renaming assets from the file list for now (e.g. right-click >
Rename). This doesn't work yet and I'm not sure it should even. If an asset
is a local data-block it can be renamed in the sidebar.
* Fix broken logic to scroll a preview into view.
* Partially includes D9994. These changes were needed for this to work.
Differential Revision: https://developer.blender.org/D11119
On MSVC it failed with this error:
```
source\blender\blenkernel\BKE_context.h(361,20): error C2526:
'CTX_wm_asset_handle': C linkage function cannot return C++ class 'AssetHandle'
```
On Apple Clang I would get this:
```
warning: 'CTX_wm_asset_handle' has C-linkage specified, but returns incomplete
type 'struct AssetHandle' which could be incompatible with C
[-Wreturn-type-c-linkage]
struct AssetHandle CTX_wm_asset_handle(const bContext *C, bool *r_is_valid);
^
1 warning generated.
```
Just include the asset header defining the type for now, it should later on be
solved properly with a better design for `AssetHandle`.
Add improved arrow key walk navigation in grid layout UI List templates.
Pressing up or down walks the active item to the adjacent row in that
direction, while left and right walk through the items along the columns
wrapping at the rows.
Differential Revision: https://developer.blender.org/D11063
Fix a glitch when blending a pose by always starting blending at 0%.
Previously, the blend percentage was remembered between operator
invocations, causing the glitch.
The `ASSET_OT_open_containing_blend_file` operator starts a new Blender
process, and refreshes the assets after it quits. It now also refreshes
the assets UIlist (f.e. the pose library panel in the 3D Viewport).
Add a class `AssetBrowserSpecificCategoryPanel` that only shows if the
asset browser is showing a specific set of categories. This makes it
simple for the Pose Library panels to only show when the user has selected
the Animations category.
When using the arrow keys to "walk" the active item in the asset view, call the
activate operator which applies the pose asset. This is useful for animators to
easily go through poses on the search for an appropriate one.
The Ctrl+F is a general UI list feature. You can hover any UI list and
press Ctrl+F now to open and activate the search field. If needed the
view is scrolled to make it completely visible (with some additional
margin). Plus, the view is updated to keep the search field visible
while typing.
The latter part is also a text button feature. When you activate a text
button (that doesn't have a search menu attached, which causes further
issues), the UI code makes sure it's visible and keeps it visible while
typing.
This could go into master (after some functionality review), I'll check
on that in a bit.
Free the flipped Action before calling `poselib_tempload_exit()`, to avoid
any problems from indirectly referenced ID pointers.
Thanks @campbellbarton for the patch!
When a (Python defined) UI-list type is unregistered, we have to make sure no
list still references that type. We do the same for other such UI types.
This didn't happen to be an issue before, since the list type was not accessed
until the list was drawn again (which re-assigns the type).
After macro expansion, there would be C++ code in code with C linkage
(`extern "C"`). Clang warned about this.
Make sure the expanded C++ code always uses C++ linkage. Will commit this to
master soon.
C++ has strongly typed enums (which is great!), so a bitwise OR on two
enum values will result in a compiler error. Use our `ENUM_OPERATORS()`
utility to overload the bitwise operations to be valid for this strong
enum type.
The asset view so far showed up to 5 items by default. If there were
more assets to be shown than that, it the list would become scrollable.
This would cause a scrollable box inside a scrollable region, which is
not nice for interaction. We can just expand the list so all assets are
in the layout, and the user can scroll the region rather than scrolling
the list.
Also hide the "grip" button so the list can't be resized. If needed we
could allow making the list smaller still, even if that causes double
scrolling again. For now keeping it simple.
Had to add a "no grip" option for that, so I changed the signature a bit
to avoid too many boolean arguments.
And another also: Adds missing return after error check.
Rendering a preview for an Action requires temporarily modifying the pose
of some object (otherwise there is nothing to render); after this is done,
the object needs to be tagged correctly to flush the temporary changes.
When rendering the preview icon of an Action, apply it to the pose
object first. This ensures that the "Refresh" button of a pose actually
uses that pose.
This splits some functions into two flavours, one that acts on all bones
and one that acts on the selected bones only. Normal use of the pose
library only acts on selected bones, but for the preview the entire pose
from the library is applied, regardless of selection.
Move the pose backup & restore functionality into its own file, so that
the functions can be called from other places in Blender as well.
No functional changes.
After temp-loading an asset datablock, explicitly free it before calling
`BLO_library_temp_free()`. Without this step, normal linking would be
performed, causing temp datablocks to actually be linked into the current
blend file.
Make `ASSET_OT_open_containing_blend_file` in a asset view UIList as
well as the Asset Browser. This uses the context variables
`asset_file_handle` and `asset_library`, which are temporary in lieu of
a better asset API.
Needed so the pose library add-on can keep its operators work outside of
the Asset Browser context, namely with the asset view template.
An issue here is that we can't expose an asset handle from the Asset
Browser, because there is not permanently saved one whose pointer we can
pass around. This is planned to be addressed, but for now Python will
have to use the file wrapped by the asset-handle directly, via
`context.asset_file_handle`.
Makes it possible to add custom entries to the context menu of UI List items, by doing the following:
`bpy.types.UI_MT_list_item_context_menu.prepend(some_draw_function)`/`append(...)`.
The given draw function must check if the list is of the correct type. For that
to work I made it possible to get the hovered UI List using `context.ui_list`
and the list-ID via `ui_list.list_id`.
Rename the operator property `apply_flipped` to simply `flipped`, as the
verb ("apply") is already in the operator name. This will make it possible
to add a `flipped` property to the select/deselect operators too, keeping
things consistent.
No functional changes.
We'd store references to temporary objects, e.g. see
`AssetListStorage::ensure_list_storage()`. Stupid mistake, store a copy
of the `AssetLibraryReference` struct now (cheap to copy).
This will make it possible to click and drag on the poses in the
asset view template to do the blending. On mouse release, the blended
pose will be applied.
This isn't used yet, follow-up commits will enable it.
This also hides the cursor and enables continuous grabbing when dragging
with the "Release Confirm" enabled. To be evaluated; maybe it should
always do this while blending.
Also fixes mouse hover highlights not being updated when confirming or
cancelling the pose blending operator.
The asset view template now provides a way to set the operator
properties of its custom drag & activate operators. In Python they are
returned from `UILayout.template_asset_view()` as tuple.
Includes some cleanup to better manage the data of the custom operators.
The preview rendering notifiers would be continuously sent, causing
continuous redraws. In the File Browser that also happens (and I don't
think it's intentionaly) although it causes refreshes there that don't
do much and there won't be redraws unless necessary. Correcting this may
cause issues, so better to do it separately.
Issue is that the previews were fetched using the BLI_task API, and a
timer was started to send notifiers continuously. But there was nothing
to check if the tasks were done, so that the timer could be stopped.
The pose apply operator would be invoked when double-clicking a
directory in the File Browser, while in pose mode.
The operator's poll would succeed because since 29887bbb32, the
File/Asset Browser would just create a `AssetHandle` from the active
file received from context, without ensuring that the file actually
represents an asset.
When the interactive blending operator finishes, store the chosen blend
factor in the RNA properties. This ensures that pressing F9 shows the
actual factor, which can then be readjusted.
When Blender quits while the pose blending operator is active, set the
correct state (`POSE_BLEND_CANCEL`) before exiting, so that cleanup done
correctly.
Add an "Open Blend File" operator to the Asset Browser context menu,
which starts a new blender process to open the blend file containing the
active asset.
Similar to the pose sliding tools, use the relative mouse position in the
active area to determine the pose blend factor.
This is not a final implementation, but at least makes the pose library
usable with a tablet.
The Asset Browser uses the `FileList` from the File Browser, which isn't
properly using the `AssetList` yet. So of course getting the file-path
from the asset list will fail.
For now just add a little hack to fall-back to get the data from the
Asset Browser directly.
I did some casting hack to return an `AssetHandle` from a
`FileDirEntry`. But this doesn't actually work.
What I added now isn't something I'm happy with either, but it will have
to do for now. Basically we request an `AssetHandle`, which the Asset
Browser doesn't actually store, since it's just a wrapper around the
Asset Browser's `FileDirEntry`. So there is no consistent pointer the
editor could return to context queries, and the context needs a pointer
so that it can be passed around as `void *`.
Eventually once we have the planned asset storage design implemented,
the storage would include actual asset handles. So we can pass around
consistent pointers to them then.
The operators are not exclusive to the File Browser anymore now. The logic to
get the asset file information and use that to append the ID if necessary is
abstracted away by the asset system now, see 10383566b8.
Add operator `POSELIB_OT_apply_pose_asset` that does the same as executing
(instead of invoking) `POSELIB_OT_blend_pose_asset` with
`blend_factor=1.0f`. This will replace the Python equivalent in the
pose library add-on.
Rename the pose blending operator to `POSELIB_OT_blend_pose_asset`, so that
we can make an operator `POSELIB_OT_apply_pose_asset` without colliding
with the old `POSELIB_OT_apply_pose` operator (from the current pose
library system instead of the new one).
No functional changes.
The operators are not exclusive to the File Browser anymore now. The logic to
get the asset file information and use that to append the ID if necessary is
abstracted away by the asset system now, see 10383566b8.
This adds a new RNA method `Action.flip_with_pose(ob, frame)`
to flip the action channels that control a pose.
The rest-pose it's self is used to properly flip the bones transformation.
This is useful as a way to flip actions used in pose libraries,
so the same action need not be included for each side.
API calls to cache F-curve look-ups have also been added,
supporting a single hash lookup to access all channels controlling an RNA path.
----
**Motivation**
This patch adds functionality to flip an entire action on the X axis using a symmetrical rig.
This was written so the asset manager can apply poses flipped, see T86159,
tested with spring.blend.
**Alternative Solutions**
It's possible to calculate this on the pose directly (see D10766), however operating on the action data makes this more useful as an API function, since the data can be flipped before it's applied to the pose.
Instead of flipping on the pose, then writing back to the action.
**Limitations**
There is some information not easily available at the time of flipping, for example - it's possible the flipped data-path doesn't exist in all cases, although the ideal behavior isn't obvious when the RNA path only resolves on one side of the pose.
- Currently the API function flips all channels, we could add an argument so it only operates on some of the channels.
**Open Topics**
- When some actions transform channels don't exist, they could be created (for example - if only X & Y rotation are set, it may be necessary to create a Z F-Curve to properly flip the rotation).
- The key-framing API is currently part of the editors (it would be a bad-level call from the BKE), we could expose some keyframing functionality to BKE, or move this functionality to editors. For now there is a simple keyframe adjusting function.
- Currently only the armature rest-matrices is used, not the pose. This API could take an armature instead of an object, although we might want to use pose content in the future, it doesn't seem like a big issue either way.
- This could eventually be exposed as an operator.
- Currently this re-orders channels which could have other frames keyed. A more comprehensive approach could be to operate on all keyed frames for an action, so an action that includes multiple poses will have them all properly flipped.
-----
**Notes**
- The F-Curve lookup cache can be committed separately.
- This is an example script for testing with the pose object set active:
```
import bpy
from bpy import context
ob = context.object
action = bpy.data.actions['07_040_A.spring']
action.flip_with_pose(ob, context.scene.frame_current)
```
Differential Revision: https://developer.blender.org/D10781
An annoyance is that the operator names have to be passed to the template which
makes the already long argument list even longer.
Thought about a couple of ways to do this, unfortunately this is the only
decent way to do this that I see. There's also no way to pass operator options
currently.
Getting the handling to work correctly took some effort, and the code is not
exactly nice.
Note that even though we activate the item when calling the custom drag
operator (helps indicating the pose being blended for example), we only call
the drag operator then, not the activate one. They are never executed both.
Also note that this won't compile right now, I'll have to commit some changes
to master first.
Uses the new `BLO_library_temp_xxx` functions, but deals with all the asset
specific file path building. This is a reasonable utility for the asset system
to have, it will probably be needed by more asset types than IDs.
`CTX_wm_asset_library()` returns the active asset library from the workspace,
or the the Asset Browser one while inside that. The active asset handle is set
by the Asset Browser and the asset view UI template so that operators executed
via the template can access it.
Expand the `POSELIB_OT_blend_pose` poll function to check whether there
is an actively selected pose, and don't crash even if the operator gets
called regardless.
Switch addons submodule to `asset-browser-poselib` branch in the
`.gitmodules` file. This should affect any subsequent calls to `git
submodule update`.
Care should be taken when merging this branch back to master, because
this change should *not* be included.
This commit sets the `release/scripts/addons` to its
`asset-browser-poselib` branch, with the aim that animators checking out
this branch on the main Blender repo also get the corresponding branch
in the addons repo.
This is generally what people expect when generating a cone. Note that
this translation currently happens after the rotation, but since the rotation
will likely be removed in the future, that won't be a problem for long.
This patch adds the remaining 6 interpolations for mesh domains.
The new interpolations are:
- Corner / point / polygon to edge
- Edge to corner / point / polygon
After this it is possible to adapt an attribute to and from every
mesh domain. This is simple to test with the "Attribute Convert" node.
Though, as a note for the future, there are still some improvements
possible to the interpolations, like lazily calculating values for the
interpolations where it's possible, and slightly improving the
algorithms used for some interpolations, like using corner angles
for polygon to point.
Differential Revision: https://developer.blender.org/D10765
This is not only potentially extremely expensive, it is also fairly
futile, and code is not designed to handle it currently anyway (could
easily end up in inifinite loops and other crashes).
- Remove use of evaluated poses, instead calculate transformations
into an array which is applied afterwards.
- Only update ID's for poses that have been changed.
This is simply a convenience when using this type. More similar
constructors can be added in the future when they are useful.
Differential Revision: https://developer.blender.org/D10714
Allow python access to the `reset_view` functionality which before
was only available through the menu. This was suggested for
consistency after D10561.
Differential Revision: https://developer.blender.org/D10595
The size in the transform matrices was extra, since it is also
passed as an argument to the BMesh operators.
Differential Revision: https://developer.blender.org/D10763
Previously even if the input goemetry set had no point cloud or no mesh
instances, `geometry_set_realize_instances` would create empty data.
This isn't necessarily bad, but it can complicate things down the line if
there are a bunch of empty components getting passed around.
This was reported for geometry nodes, but was true for all nodetrees
(e.g. after deleting the active node). Geometry node trees just made
this more obvious since they start without an active node to begin with.
Fix provided by @lone_noel, thx!
Maniphest Tasks: T86677
Differential Revision: https://developer.blender.org/D10762
Caused by {rB2917f550caa9} which renamed the entry in the toolsystem,
but not the corresponding keymap.
Maniphest Tasks: T86548
Differential Revision: https://developer.blender.org/D10725
Since {rB46aa70cb486d}, using `NC_SPACE | ND_SPACE_VIEW3D` as notifier is
restricted to space data as a reference. This was still used though for
RNA updates in other places (namely `rna_camera`, `rna_scene`,
`rna_animviz`), and passing NULL would automatically set the notifier
reference to the owner id. Above commit would happily filter these out,
leading to missing refreshes.
Now use more specific notifiers (in case of animviz a new
`ND_DRAW_ANIMVIZ` was added).
This was reported for Camera background images btw.
Fixes T86670.
Maniphest Tasks: T86670
Differential Revision: https://developer.blender.org/D10758
E.g. opening a file with an asset viewer and an Asset Browser could cause one
of them to not load its files properly. That is because there was only one
`wmJob` per scene so when the first one was done it would end the other one(s).
I think this would be a problem in master for the regular File Browser too.
Instead of setting the scene as owner of the job, use the file-list, so that
each file/asset-list gets its own job.
`UIList` is designed to use collection properties. I previously did a
whole bunch of hacks to use it without. This isn't acceptable for
master, instead a proper collection property should be provided.
Idea is to let scripts register a custom collection property, that the
asset view template can fill with the latest asset list contents and
pass that to the UI list.
Longer term I'd prefer if the UI code would support other containers,
and not rely so much on RNA and custom/ID properties. I have ideas and
plans for this, but meanwhile, this will do to remove the hacks.
Would give a warning:
```
'ED_asset_library_reference_from_enum_value' has C-linkage specified, but
returns incomplete type 'struct AssetLibraryReference' which could be
incompatible with C [-Wreturn-type-c-linkage]
```
We didn't actually run into the static initialization fiasco, but only
because `blender::Map` didn't use the guarded allocator on default
destruction. Better to stay far way from static initialization fiasco,
and the construct on first use idiom is trivial and prevents it. So
better use that.
Previously I just used the active color index of the first palette to
get things to work.
I would've preferred if the asset view template could register own
properties and store them in the `UIList` it creates. That way you could
have multiple asset views with entirely independent data. But since this
isn't possible, we need a different way to store such data, I think the
workspace makes sense. It should still be possible to store different
data for different use-cases, e.g. to show a pose asset list in pose
mode and a material asset list in object mode. So idea is to let
scripts/add-ons register custom properties for their specific use case
(e.g. "Active Pose Asset" for the pose libraries).
Previously I just used the active color index of the first palette to
get things to work.
I would've preferred if the asset view template could register own
properties and store them in the `UIList` it creates. That way you could
have multiple asset views with entirely independent data. But since this
isn't possible, we need a different way to store such data, I think the
workspace makes sense. It should still be possible to store different
data for different use-cases, e.g. to show a pose asset list in pose
mode and a material asset list in object mode. So idea is to let
scripts/add-ons register custom properties for their specific use case
(e.g. "Active Pose Asset" for the pose libraries).
The Asset Browser still has its own active asset library. But for the UI
(e.g. the asset view UI template), there is one active asset library per
workspace now. This is needed because for technical reasons the property
has to be registered in C, ideally you could just register it as custom
property for any use-case and pass that to the asset view template.
Since this isn't possible, an active asset library per workspace seems
reasonable.
This also removes the `bool flush_to_original` argument, as this flushing
is not required for the pose library (poses are always applied to the
original, and not to evaluated copies).
My code for interpolating booleans basically performed the same function
as the rounding for ints and enums. Now the code is the same, too.
No functional changes
Naieve blending of the pose Action onto the current pose. This performs
linear blending (LERP) per FCurve. This is not suitable for rotations, so
it's probably better to do proper matrix interpolation for loc/rot/scale.
However, for other properties, the current LERP will be necessary anyway.
The operator doesn't blend yet, but it does allow temporarily applying the
pose, switching between the original and the given pose with Tab, applying
the pose with Enter/LeftClick, and cancelling with Esc/RightClick.
Makes sure the asset list is updated and redrawn correctly an local asset data
changes: Creating assets, removing assets, clearing assets, undo/redo, reading
files (with and without UI), parallel reading of asset data from files, ...
For redraws there now is a listener callback in the uiList type (C only) that
asks the asset lists if it needs a redraw after a given notifier. For the case
of asset data-block removal there is a ID remapping function in the asset list
now (just tags the list for a complete re-read). File reading, undo, redo and
the "Mark Asset"/"Clear Asset" operators explicitly tag asset lists showing
main data as dirty (via the global asset storage).
The ID type filter can be set as follows:
```
template_asset_view(..., filter_id_types={'filter_material', 'filter_object'})
```
I would have prefered if you could just create a
`bpy.types.AssetFilterSettings` object, fill that and pass it to the
template. But that doesn't seem possible right now without more complex
BPY additions.
Also, newer ID types (hair, point cloud, volume and simulation IDs) do
not support filtering, because their filtering flags exceed 32, meaning
we have to store them in 64 bit integers which RNA doesn't support for
enum properties...
No reason to skip adding the UI elements just because the preview is missing.
We can still show the text and allow dragging. Also makes it feel more
interactive while the previews load in a background thread.
The new button type (UI_BTYPE_PREVIEW_TILE) shows the items similar to
the Asset Browser, or the File Browser in thumbnail display mode. That
is, previews bigger than normal buttons, with the name drawn centered
below it.
Would be nice if the File/Asset Browser and preview templates could
adopt that new button type, so that there's no ad-hoc drawing for these
anymore. That's for a future cleanup though.
This was very glitchy before and just didn't work in most cases. The mouse
press event was simply caught by the preview icon button and didn't make its
way to the underlying list-row button.
The SSS shader in Eevee has the following drawbacks (elaborated in {T79933}):
1. Glowing
2. Ringing. On low SSS jittering it is rendered a bunch of sharp lines
3. Overall blurriness due to the nature of the effect
4. Shadows near occlusions as in T65849
5. Too much SSS near the edge and on highly-tilted surfaces
{F9438636}
{F9427302}
In the original shader code there was a depth correction factor, as far as I can understand for fixing light bleeding from one object to another. But it was scaled incorrectly. I modified its scale to depend on SSS scale*radius and made it independent from the scene scale. The scale parameter (`-4`) is chosen so that it makes tilted surfaces to have visually the same SSS radius as straight surfaces (surfaces with normal pointed directly to the camera).
This depth correction factor alone fixes all the problems except for ringing (pt. 2). Because of float-point precision errors and irradiance interpolation some samples near the border of an object might leak light, causing sparkly or dashed (because of aliasing) patterns around the highlights. Switching from `texture()` to `texelFetch()` fixes this problem and makes textures on renders visually sharper.
An alternative solution would be to detect object borders and somehow prevent samples from crossing it. This can be done by:
1. Adding an `object_id` texture. I think it requires much more code changing and makes the shader more complicated. Again, `object_id` is not interpolatable.
2. Watch gradient of depth and discard samples if the gradient is too big. This solution depends on scene scale and requires more texture lookups. Since SSS is usually a minor effect, it probably doesn't require that level of accuracy.
I haven't notice it in practice, but I assume it can make visible SSS radius slightly off (up to 0.5 px in screen space, which is negligible). It is completely mitigated with render sampling.
Reviewed By: Clément Foucault
Differential Revision: https://developer.blender.org/D9740
This is ported from Cycles and fixes issues with bump/normal mapping
giving weird reflections/lighting.
Fixes T81070 Specular light should be limited to normal pointing toward the camera
Fixes T78501 Normal mapping making specular artifact
Steps to reproduce:
- switch to Scripting workspace
- execute bpy.data.meshes['Cube'].copy()
- Outliner will not show the new mesh immediately
Now just send appropriate notifier.
Differential Revision: https://developer.blender.org/D10584
The `bNodeLinkDrag` struct was NULL when dragging a node instead of
a link. It is allocated with `calloc` anyway, so this field doesn't
need to be explitely cleared.
This commit includes a few simple improvements to the direct mesh
boolean code added recently.
- Passing the transforms and meshes to `direct_mesh_boolean` as spans
makes the function easier to call from C++.
- The definition of `TransMat`, was unecessary when we have the
`float4x4` type already used elsewhere in C++ code.
Differential Revision: https://developer.blender.org/D10592
The socket drag operator stored the index of the last picked socket
into RNA in case the mouse cursor leaves the link while dragging.
This id was not unique which is why sometimes a link from an other node
with the same id is picked.
This patch changes the way the last picked link is stored and stores a
pointer to the link directly into bNodeLinkDrag struct instead.
Differential Revision: https://developer.blender.org/D10590
The Python API for the curve mapping widget offers the `update`
function, but no way to reset the view to the clipping rectangle.
This commit adds a blenkernel function for this operation,
and exposes it to the CurvMapping RNA API. This allows addons
to display a more user-friendly view of the data in this widget.
Differential Revision: https://developer.blender.org/D10561
This commit adds a search for existing attributes when you click
on an attribute field. This is useful because otherwise you have
to remember which attributes should be available at each node in
the tree.
The fundamental complication is that this information is not
accessible statically. So the search data is only a cache from
the previous node tree evaluation. The information is added
with `BKE_nodetree_attribute_hint_add`, currently for every
input geometry socket for a single node.
This is only an initial implementation, and later versions will
expose the data type and domain of the attributes.
Differential Revision: https://developer.blender.org/D10519
I landed D10527 in rB1a8aee0a7cec accidentally, and the version there was
missing a name change discussed in review. This commit just renames the
boolean variable controlling the special behavior for attribute search.
Original message meant for this change:
For geometry nodes we will use search buttons to display a list of
attributes available the last time the node tree was executed (D10519).
Because this list is just a hint, we need to be able to enter any string,
not just strings from the search items.
This patch adds a boolean option to string buttons to enable this.
The change is quite simple, changes to behavior are only required in
two places. The type-specific button struct changes help a lot here.
Differential Revision: https://developer.blender.org/D10527
In Blender, we used to use the term 'draw' to refer to information
displayed to the user. For version 2.80, it was decided to change these
instances to 'display' instead. This was to avoid the ambiguity between
end-user drawing tools and display options.
From the Oxford English Dictionary:
- Draw: produce (a picture or diagram) by making lines and marks on
paper with a pencil, pen, etc.
- Display: show (data or an image) on a computer, television, or
other screen.
Therefore, we should use draw when referring to drawing tools for
making marks, but use display when referring to information
shown/displayed to the user. From a user POV, the computer displays
certain information, whereas the user draws a mark.
Apparently this change was not implemented consistently, so this patch
changes all remaining relevant instances of "draw".
Differential Revision: https://developer.blender.org/D10551
Currently when you open an RNA collection search button, like a
vertex group selector, the search filter isn't applied until you
start typing, in order to display every option at the start.
Otherwise they wouldn't be visible, since the search filter would
run for the current text.
Currently this check happens in one place, but it relies on the
`changed` value of `uiBut`. This is fine in the interface directory,
but anywhere else it would require exposing `uiBut.changed`, which
is probably too low-level to expose.
The solution is adding an `is_first` argument to the search callbacks,
which is nice for a few reasons:
- They work at a higher level of abstraction, meaning they don't
have to worry about how exactly to tell if this is the first
search.
- It makes it easier to do special behavior when the search menu
is first opened.
- Then, obviously, it makes that state accessible without including
`interface_intern.h`.
Needed for attribute search: T85658
Differential Revision: https://developer.blender.org/D10528
Since the same node tree can be used in modifiers on different objects,
there can be multiple threads writing to the maps in the node tree UI
storage at the same time. The additions for attribute name hints and
error messages made it so this would often cause a crash or at least
an ASAN report. This patch adds locks to prevent multiple threads
from using the maps concurrently.
In a brief test I actually didn't observe a crash without the global
`bNodeTree` UI storage mutex, but I think it's necessary for the change
to be correct, and I did notice some unfreed memory without it anyway.
Ideally it would be in a node tree runtime struct though.
Differential Revision: https://developer.blender.org/D10577
The shadowing was computed on the light distance squared,
leaking to much light since it was integrating the extinction behind
the ligth itself.
Also bump the maximum shadow max step to the actual UI values. Otherwise
we get shadowing under evaluated because `dd` is too small.
Expand is a new operator for Sculpt Mode which is intended to be the main
tool for masking, Face Set editing, interacting with the filters and pattern
creation.
The fundamentals of the tool are similar to the previous sculpt.mask_expand
operator. It shares the same default shortcuts and functionality, making
the previous operator obsolete.
The shortcuts to execute the operator are:
- Shift + A: Expand mask
- Shift + Alt + A: Expand mask by normals
- Shift + W: Expand Face Set
- Shift + Alt + W: Resize current Face Set
The main changes compared to the previous sculpt.mask_expand operator are:
- Modal keymap, all operator options can be changed in real time while the
operator is running.
- Supports creating Mask, Face Sets and Sculpt Vertex Colors.
- Much better code, new features can be easily integrated.
Limitations:
- All Mask operations are supported for Sculpt Vertex colors, but not exposed
by default as their support is still experimental.
- Dyntopo does not support any Face Set or Sculpt Vertex Colors. functionality
(they are not implemented in general for Dyntopo).
- Multires does not support any feature related to geodesic distances.
- Multires does not support vertex colors.
- Multires does not support recursions.
- In Multires, Face Sets snaping does not initialize all current enabled Face
Sets when toggling snapping.
- In Multires, Face Sets are created at base mesh level (works by this by
design, like any other tool).
- Unlike the previous mask_expand operator, this one does not blur the mask
by default after finishing Expand as that does not fit the new design.
The mask can still be blurred by using the mask filter manually.
Reviewed By: JacquesLucke
Differential Revision: https://developer.blender.org/D10455
The performance debug menu isn't used that often anymore as render doc
also show the timings. This patch will make sure that enabling the
performance debug view (21) does not crash blender.
The crash happened when the density in the Point Distribute node was
above zero but so small, that no point was generated. In this case, there
was a point cloud component, but the point cloud was empty, making some
attributes unavailable.
One could also make more attributes available in this case, but that can
be done separately if necessary.
Move low level logic to module code and versioning logic to versioning code.
Metas strip position was handled in diffrent way compared to other strips.
This was introduced in c8b0d25794 as bugfix for T28158.
I disagree with such design. Meta strips should be handled in same way as
any other strips.
I have tested this change and haven't found any problems.
No problems after checking T28158 as well.
There should be no functional changes on user level.
Reviewed By: campbellbarton
Differential Revision: https://developer.blender.org/D9972
Nicely hidden bug in pose read library code, it was using the library
from the wrong ID as reference to relink the custom shape object pointer
(pose is data from Object, not Armature).
This is same issue as fixed by d857892553, but I forgot to check meta
strips. Meta strip output is always in render size.
Reviewed By: sergey
Differential Revision: https://developer.blender.org/D10560
Applying negative offset to seek position before scanning doesnn't have
any effect. This change results in 1.5x faster seeking (random frame,
average value) in sample file with 30 frame GOP length.
If I am not mistaken, B frames can have pts that can be less than
pts of I frame that must be decoded. Even in this case though, B frame
packet will be stored after that I frame.
In addition, preseek value is de facto hardcoded so seeking would fail
if it could. This can be hard to spot though.
Reviewed By: sergey
Differential Revision: https://developer.blender.org/D10529
Isolate RNA and operator logic from functions that create strips.
- Operator specific code was removed from `SeqLoadInfo` structure and
`SEQ_add_*` functions.
- Strip loading code was removed from RNA and operator functions.
- `SEQ_add_*` API was unified to work on `SeqLoadData` struct.
Only exception is image strip, which require files to be loaded
separately to strip creation itself. This is not ideal, but I think
it's acceptable.
- Some functions and variables were refactored so the code reads
better.
There are minor functional changes (coincidental bugfixes):
- Operator errors are reported per-strip. Previously they were not
reported at all?
- `new_sound()` RNA API function now create sound with length of 1
if source file does not exist. Previously it created strip with
length of 0.
- Replace selection operator property wasn't working correctly.
Fixed in this patch.
Reviewed By: sergey
Differential Revision: https://developer.blender.org/D9760
This enables the quick access button [to show the relevant Texture in
the Properties Editor] for textures used in geometry nodes.
This goes in line to what we do for other textures:
- modifier textures have this button
- particle textures have this button
- brush textures will soon have it, too (see D9813)
When outside of the Properties Editor, the button will always show (if a
texture is actually assigned), but will be inactive if no suiting
Properties Editor to show the texture in can be found.
Note this also changes the behavior to not show the button if _no_
texture is assigned (as in: we are still showing the "New" button).
Previously it was always there (e.g. for modifier textures), even if it
would take us to an empty texture tab. (Sure, we could add a texture
there then, but imho it makes more sense to just start showing it once a
texture is already there)
For this to work with geometry nodes, the following chages were done:
- implement foreachTexLink for geonode modifiers
- new buttons_texture_user_node_property_add() that stores prop as well
as node
- also use NODE_ACTIVE_TEXTURE flag in geometry nodetrees
notes:
- this still uses the first suiting (as in: pinning does not interfere)
Properties Editor it finds, this should (maybe?) find the _closest_
Property Editor instead (see related feedback in D9813).
- this will already show the button for brush textures as well
(disabled), but there is another mandatory change in an upcomming commit
to make it work there as well (see D9813)
ref. T85278
Maniphest Tasks: T85278
Differential Revision: https://developer.blender.org/D10293
Lots of hacks and temporary code here. I wanted a first working version to find
possible pain points before getting into details.
Basic idea is to store each asset library in an `AssetList`, with a globally
accessible storage. Internally the list uses the File Browser's `FileList`
which already does a fair amount of heavy lifting (threaded file & external
asset reading, lazy loading of visible previews, ...). The File Browser could
access the global asset-list storage as well.
The asset view template uses the new asset list to load and display the assets.
Current state: {F9856940}
Open TODOs: https://developer.blender.org/maniphest/query/M6RWFxFSDor3/#R
Idea is to be able to display a list of assets in a layout, by giving it
some custom filtering settings (not done yet). This would be just a
uiList managed by Blender, displaying previews similar to the Asset
Browser.
I decided to use uiLists for this because it already deals with stuff
like writing its UI data to .blends (e.g. filtering and sort settings),
filtering and scrolling. But I think we'll have to do a number of
general improvements to them. Here I just added a new (C-only for now)
"flexible grid" list display type, which uses bigger previews and
behaves much better than the currend "grid" one.
There's a bit of hacking going on here and things will probably change.
For now I'm just interested in getting the basics done to see if the
direction is good.
2021-02-23 18:50:31 +01:00
372 changed files with 10508 additions and 2772 deletions
Some files were not shown because too many files have changed in this diff
Show More
Reference in New Issue
Block a user
Blocking a user prevents them from interacting with repositories, such as opening or commenting on pull requests or issues. Learn more about blocking a user.
