This is needed for allowing variable length hair strands, where the hair index can not
simply be calculated from the vertex index based on a fixed-length strand.
Currently drop operators work mostly by specifying the name of the datablock.
However there can be datablocks with the same name in different libraries, so
this gives wrong results in some cases.
Currently only outliner drop operators have been updated to use this mechanism.
Color ramp with constant interpolation must bypass texture filtering and
use nearest neighboor sampling in order to appear correctly sharp.
This patch use a GLSL hack to use nearest sampling on thoses particular
color band.
This lower the use of texture samplers slots and let users use more real
textures in their shaders.
This patch also make the ramp texture 16 bit floating point. Meaning you
can now use value greater than one in your color ramps.
With the limit of 128 colorband per shader (a color band being either a
color ramp, a wavelength node or a curve node (and maybe wavelength node in
the future)).
Only drawback with the current implementation is that it does not remove
colorband from pruned GPUNodes but it shouldn't really matter in practice.
This should fix T56010
This is a rough (but fast) approximation that still match cycles reference
in common case.
In practice, it's just adding more of the diffuse light computed for the
diffuse contribution.
As grease pencil use multiedit frames instead of multiobject edit, this fix solves the issue.
In the future maybe will need modifications if we add multiobject support, but we need a solution now.
This is more like a static optimisation when some parameters are set to 1.0
or 0.0. In theses case we use a more optimized version of the node.
This also revisit the transmission parameter behaviour to make it closer to
cycles.
This was likely caused by some sort of race condition where the drawing
thread would request the state of the shader before the shader has been
compiled.
Thanks to Charlie Jolly (mistajolly@gmail.com) for his patch D3586 that added create materials to opacity modifier.
I had to do some more changes to get all running.
Patch porting to OpenJPEG 2.3 is by Campbell.
Once all platforms are upgraded we can remove the code for 1.5, and upgrade
or remove the openjpeg version from extern/. This intermediate step makes it
possible for platform maintainers to upgrade to 2.3 without breaking other
platforms.
This memory leak was undetected during a long time, but with new memory checking is visible.
The problem was the stroke buffer batch was realocating new batches without free the memory.
new background image/clip of Camera ID was totally wrong, down the old,
broken 'way it used to be' instead of using new, more generic system.
Those ID pointers were not even added to library_query.c file, shame! xD
The material created was not right when apply the modifiers.
These errors were related to the material modification from old palette system before the merge and for any reason this code was not changed in the right way.
Also changed the "Create Colors" to "Create Materials" to keep UI names aligned.
This is a limitation of the current operator design.
I have added a test to be sure the operator is not initializated while play animations to avoid segment fault.
In the future, we can enable this option again, but it will need a operator redesign.
This make the root flag writable using the Python API, using the
generic skin vertex flag setter function.
Reviewed By: Campbell Barton
Differential Revision: http://developer.blender.org/D3583
The object can be NULL. This was a line used in debug that it was not removed.
Also removed an old function not used.
Thanks to Charlie Jolly for catching this error.
Note that there are most certainly many other operators that’d need that
same flag... Don’t have time to hunt them down currently, will just fix
as issues are found, for now.
For now, that flag is only used in redo code, since after undo step
depsgraph is totally empty... We *may* want to add at least an assert in
op calling code too, though?
Some of them are unecessary and should be removed from the shader instead.
But for now we need a quick fix for the crashes happening on some platforms.
See T55475.
Calling code is responsible to check on NULL pointers here, or ensure
is does have a fully built and evaluated depsgraph, but this should
never crash in DEG queries themselves.
Enabled infinite sharp patches for topology refiner and evaluator,
which allows to have sharp edge at first subdivision level.
Also tweaked crease export from Blender to OpenSubdiv to have more
artistic control over the whole 0..1 range.
In some cases (e.g. using old userpref settings/keymaps)
it was possible to trigger a crash when the wrong GP/Annotation
operators were triggered in the wrong contexts (e.g. using
the old GPENCIL_OT_paint in annotation-only contexts like
all the 2D editors).
This commit resolves several issues that were caused by sloppy
code-churn + features that had been hacked on.
Since most animators find Motion Paths more useful than Armature Ghosting:
* Move Motion Paths before Ghosting settings (less scrolling)
* Collapse Ghosting panel by default
* Open Motion Paths panel by default instead
Pretty minor, from 0.6 to 0.8, but the improvement is noticeable
especially when using a stylus, without overlapping too much with
the buttons and dropdowns in headers.
Rendering OpenGL/Preview is accessible from each editor.
Render settings are accessible from the Film menu when in OpenGL/Preview engine.
It wasn't always predictable especially with Workspaces without or with many viewports.
Also reordering of items, renaming and removal of superfluous icons.
texelFetch return vec4(0.0) if the target pixel is outside the texture
rect. So we mimic the default repeate mode that we have for linear
interpolation.
Fix T56156 Mapping-Node doesn't work
The idea is simple: do not provide full topology to OpenSubdiv, leave
edges creation to OpenSubdiv itself. This solves issues with non-manifold
meshes which were known to fail, including the ones from T52059.
On a positive side we can simplify our side of converter, keeping code
shorter.
it is still possible that we'll need to ensure all loops has same
winding, but that is less things to worry about.
Applies to vertices and edges. Biggest annoyance here is that OpenSubdiv's
topology converter expects that there is no loose geometry, otherwise it
is getting confused.
For now solution is to create some sort of mapping from real Mesh vertex
and edge index to a non-loose-index. Now the annoying part is that this
is an extra step to calculate before we can compare topology, meaning FPS
will not be as great as if we knew for sure that topology didn't change.
Loose edges subdivision is different from what it used to be with old
subdivision code, but probably nice feature now is that endpoints of loose
edges are stay at the coarse vertex locations. This allows to have things
like plane with hair strands, without need to duplicate edge vertices at
endpoints.
All this required some re-work of topology refiner creation, which is now
only passing edges and vertices which are adjacent to face. This is how
topology refiner is supposed to be used, and this is how its validator
also works. Vertices which are adjacent to loose edges are marked as
infinite sharp. This seems to be good-enough approximation for now. In the
future we might tweaks things a bit and push such vertices in average
direction of loose edges, to match old subdivision code closer.
Having 'flag, flag2, flag3' is getting out of hand especially
when we support increasing the size of types.
Make flag2 into an int.
Note, this looses the 'show world' option,
but it's not such an important setting.
This also include a small optimisation (remove of a double loop and half of
the memory allocation for hit points)
This should fix T55946 Crash using knife tool on mesh with large number of
vertices.
Tried with a 500K vert suzanne and it seems fine.
instead of being ThreadLocal and leading to incorrect usage.
We still enforce no framebuffer when changing context. We can lift this
restriction later.
After clearing motion paths from objects, those objects needed to be
tagged for copy on write so that the copied data (i.e. viewport)
recieve the changes (i.e. removed paths)
Reported by Hjalti
Avoid double label for same properties in single-column.
Onion Skinning: Group custom colors together, and frame before/after together.
Small changes to tooltips.
Top bar is only for settings that apply to the next action
not a way to change existing data.
If each stroke could have a different color this would work as expected,
however it was adjusting the current layer color.
Rename "Seq. Strip" to Strip Name, "Sequence Strip" to Use Strip Metadata.
Plus re-arrange of properties and separators for sections.
Thanks @fsiddi for the feedback.
This commit merge the full development done in greasepencil-object branch and include mainly the following features.
- New grease pencil object.
- New drawing engine.
- New grease pencil modes Draw/Sculpt/Edit and Weight Paint.
- New brushes for grease pencil.
- New modifiers for grease pencil.
- New shaders FX.
- New material system (replace old palettes and colors).
- Split of annotations (old grease pencil) and new grease pencil object.
- UI adapted to blender 2.8.
You can get more info here:
https://code.blender.org/2017/12/drawing-2d-animation-in-blender-2-8/https://code.blender.org/2018/07/grease-pencil-status-update/
This is the result of nearly two years of development and I want thanks firstly the other members of the grease pencil team: Daniel M. Lara, Matias Mendiola and Joshua Leung for their support, ideas and to keep working in the project all the time, without them this project had been impossible.
Also, I want thanks other Blender developers for their help, advices and to be there always to help me, and specially to Clément Foucault, Dalai Felinto, Pablo Vázquez and Campbell Barton.
Usage of matcap image uniform had different ifdef than definition
of that uniform. Assuming the usage was correct, and the definition
needed an update.
Prevents shader from compilation failure and from aborts in debug
builds.
The idea is to create vertices along the coarse edges once, without
splitting coarse edges on separate ptex faces. This requires some
indexing magic, vertices within a patch are no longer sequential.
Not sure how to make it nicer without such a black magic looking
calculations (which are basically boiling down to mimicking order
of verts/edges creation).
In the current offsets calculation loose verts and edges are not
properly taken into account, but those are causing topology refiner
to fail anyway, so it needs a bit deeper change.
Reviewers: brecht
Differential Revision: https://developer.blender.org/D3570
This ignores the scene color managment view settings for solid mode and
lookdev when not using scene lights and world. The scene settings are
intended for tweaking renders and should not affect studio lighting and
matcaps.
There may be cases where a simple sRGB transform is better than Filmic
and we could add configuration for this. Not sure if it really matters
and it may be better if we just assume matcaps and studiolights are all
created for one view transform.
Differential Revision: https://developer.blender.org/D3569
By popular demand, the CLean Keyframes operator will now
leave handles and other interpolation settings untouched.
Previously, it would recreate the keyframes from scratch,
keeping only the frame + value, under the assumption that
the handle information was "bad" (i.e. the source of bumps
and roughness, due to bad hand tweaking). However, since
most animators use this on hand-keyed animation instead of
motion-capture data, this assumption didn't hold, and was
actually overly destructive - wiping out lots of hand-adjusted
curve data.
This is in preparation of upgrading our library dependencies, some of which
need C++11. We already use C++11 in blender2.8 and for Windows and macOS, so
this just affects Linux.
On many distributions this will not require any changes, on some
install_deps.sh will need to be run again to rebuild libraries.
Differential Revision: https://developer.blender.org/D3568
They were added as placeholder to show something until they lazy-load.
But since the load is fast and it's hard to fit the text, and their name
is displayed already in the tooltip, we can do without for now.
In the future when we have insta-tooltips we should make them use this.
These were made by the community and curated by Pablo and William.
Thanks to everyone who contributed!
https://devtalk.blender.org/t/call-for-content-matcaps/737
Command used for compression:
oiiotool %s --ch R,G,B -d half --compression dwab -o output/%s
Code was trying to hide properties by name that may not exist.
Check if it was actually found and add 'files' to the filter,
since it is what WM_OT_studio_lights_install uses.
Just basic algebra - because all vectors have the same z coordinate, a lot of terms end up cancelling out.
Not exactly a massive improvement, but it's measurable with Branched PT and a high sample count on the lamp.
Reviewers: brecht, sergey
Reviewed By: brecht
Subscribers: swerner
Differential Revision: https://developer.blender.org/D3540
Only enforce origindex to NONE for a generated geometry. For the rest
of geometry rely on CustomData_copy() to set it to the proper value.
This will ensure origindex is set correct for cases when there is an
array modifier prior to subsurf.
Gathers information about object geometry and textures. Very basic at
this moment, but need to start somewhere.
Things which needs to be included still:
- "Runtime" information, like BVH. While it is not directly controllable
by artists, it's still important to know.
- Device array sizes. Again, not under artists control, but is added to
the overall size.
- Memory peak at different synchronization stages.
At this point it simply prints info to the stdout after F12 is done,
need better control over that too.
Reviewers: brecht
Differential Revision: https://developer.blender.org/D3566
We use a hidden window for each offscreen context we need.
On X11 (linux) it does not show any other windows in the OS task bar
but it might be the case on other operating systems (untested).
Replaced the draw world option with a shading.background_type enum.
Where the user can select Theme, World or a Custom color.
World and theme colors do not always work in workbench. We needed to
have an option what the user could control locally (per viewport).
Especially when using linked data.
I removed the world background drawing from the draw_manager. It was never used as EEVEE and Workbench both override the logic.
Not 100% sure about the naming of Theme, World, Viewport.
In other parts of blender's codebase World is sometimes called Scene.
Will stick to the names that describes its location best.
{F3990139}
Reviewers: fclem, campbellbarton
Reviewed By: fclem
Subscribers: venomgfx
Tags: #bf_blender_2.8
Differential Revision: https://developer.blender.org/D3551
There is no reason or justification to have helper functions as
class methods: they do not depend on anything in the class itself.
There are probably more cases like that.
Show "Operators Cheatsheet" and Python API link only when developers extra is enabled.
Fix URL for User Communities, Developer Community and Release Notes (which 404s
now just like the wiki anyway since the page for 2.80 is being made).
While changing the shading normal is a great way to add additional detail to a model, there are some problems with it.
One of them is that at grazing angles and/or strong changes to the normal, the reflected ray can end up pointing into the actual geometry, which results in a black spot.
This patch helps avoid this by automatically reducing the strength of the bump/normal map if the reflected direction would end up too shallow or inside the geometry.
Differential Revision: https://developer.blender.org/D2574
Also always draw the counter of elements-per-type with a dark background
regardless of the active status. It being white when active affects
readability since the icon background itself is already highlighted.
Thanks devtalk forum for feedback.
RNA API Object.ray_cast would not normalize direction vector before
doing first quick bbox intersection test, while using its returned
distance value. This could lead to wrong exclusion of object.
Thanks to @codemanx for finding that issue.
In the outliner, right click > view layer > set indirect only. This is
like clearing camera ray visibility on objects in the collection, and is
temporary until we have more general dynamic overrides.
In the outliner, right click > view layer > set holdout. This is
temporary until we have more general dynamic overrides, but helps
Spring production for now.
Color and Properties panels as sub-panels of Node. Collapse Node properties
by default, since they are already in the node itself and in material properties.
Initial work on single column layout, flow and organization of
the texture properties. More work needs to be done in the C templates
for image textures.
See D3557
But I'm not sure if the flags `BA_WAS_SEL`,` BASE_SELECTED` and `BA_SNAP_FIX_DEPS_FIASCO`(lol XD) should be added to the bases of the not evaluated `view_layer`. This needs to be discussed.
For some reason 32c5972653 broke display of
solid meshes in workbench.
After some investigation, it seems that the vertex coordinate output is
degenerated even if the input is correct and the matrix too.
Removing dead code seems to fix the problem. So maybe the GLSL preprocessor
is not doing what it should?
This reverts commit 81a93df6d2, it is not safe
to handle initialization for startup.blend differently. Instead fix the root
issue of the preview icon data structures not being initialized in time.
This puts the motion path in the same location as the transform gizmo,
which is less confusing especially if you have a custom bone shape where
the tail is not visible.
The old springs with damping 1.0 operate in a special way that
is more similar to plastic deformation than a spring. Some users
rely on that, so let the user choose which implementation to use.
This also restores full backward compatibility with 2.79.
Reviewers: sergof
Differential Revision: https://developer.blender.org/D3544
Previously it was ptex faces which were subdividing to the same
resolution. This was looking like more details for non-quad faces,
but was also causing discontinuity in the edge where quad touches
non-quad polygon.
Now ptex faces which are coming from non-quad faces are subdivided
at a half of resolution, matching old behavior and solving
discontinuity problem.
Note: Moved doversion of VSE strips uniquename to 2.8 versionning area,
and raised accordingly current file subversion, since that bug also
affected previous 2.8 .blend files...
Conflicts:
source/blender/blenkernel/BKE_blender_version.h
We actually still had cases of Meta strip duplication resulting in
non-unique strip names. Quiet surprising this went unoticed for so long. :(
Fixed that bug, and think it was last one (at least, no other case of
SEQ_DUPE_UNIQUE_NAME usage should be broken, I think...), and raised
subversion and updated doversion to run uniquename check on strips on
all previous fileversions.
Note: will have to do that again when merging in 2.8...
- Use the object referenced in `BMEditMesh` as the `ghash` key to save the bvhtrees in cache;
- Create a boundbox around edit_mesh to test the snap before creating bvhtree;
- Save the `edit_mesh`s bvhtree in the mesh bvh_cache;
This is a part of the D3504.
The issue was caused by Render Single Layer option enabled, which is
very handy for artists work, so they can hit F12 and see view layer
they are currently working in a final rendered state. This saves a lot
of time since all the "non-interesting" objects are ignored for such
iterations.
However, for the render farm we need to render view layers which are
explicitly set for render, and ignore active view layer.
Reasonable solution seems to be to ignore the Render Single Layer
option when rendering from the command line. It is really something
more like UI behavior option.
Hopefully this will fix issue with camera rig where camera properties
(like, near/far clip) are driven by custom properties from bones, and
those bones are actually belong to proxied armature.
Add new tag to bSound (runtime flags), and make read code to set a 'no
reload waveform' new tag, since it uses a mapping to get existing
waveform in undo case...
Previously it was calling `BKE_pose_rebuild()`, such thing shall never
be called from drawing code! Hopefully this now works as expected and
that horrible hack is not needed anymore.
`BKE_pose_rebuild()` should (ideally) always trigger a rebuild of the
depsgraph, since it can add or remove posechannels.
This function now takes a Main parameter to ensure that related
depsgraphes are tagged as dirty (kept it optional, for some corner cases).
We should also probably double-check calls to that function, think in
theory it should only be called from depsgraph itself? But for now...
Damped Track by specification attempts to arrive at the desired
direction via the shortest rotation. However with opposite vectors
there are infinitely many valid 180 degree rotations. Currently
it gives up and does nothing.
I think that it would be more reasonable to resolve the ambiguity
arbitrarily, so that Damped Track won't have a weird dead zone.
To make it more predictable I use a local axis.
In addition, the singularity area vicinity has some floating
point precision problems that result in significant jitter.
This applies workarounds for two causes of instability.
Differential Revision: https://developer.blender.org/D3530
GPUFrameBuffers were being free when no context was attached or in the
wrong gl context. This make sure this does not happen again.
You can now safely free any gl resource from any thread (well as long as
it's not used anymore!).
This increases stack memory usage some, and ideally we'd support a dynamic
size. But this is quite difficult on the GPU and hopefully 32 is enough even
for very complex cases.
When editing a Material the depsgraph can throw away the evaluated ID
before the preview job localized the said ID.
To fix this we localize the ID from the main thread.
Also fix WM_OT_previews_ensure crashing because of no depsgraph.
Was only visible when doing command line, since it was happening due to
cache-free policy which was aimed to bring memory usage down.
The issue is that if object with particle system is used as a nested
duplicator multiple times, it will only generate children first time,
and after that its caches are freed. After that duplication system
can not generate any instances, since the path cache is lost.
Now we delay caches free to after all objects are synchronized, which
ensures all instances are generated.
This will increase a memory peak a bit during object synchronization
time, but overall it shouldn't be that bad, since memory footprint
after synchronization will stay the same as before this change.
The ultimate thing to do here would be to drop the whole dependency
graph away, but this will require:
- API on engine side, to inform it to drop the dependency graph.
- Changes in Cycles report system to NOT use evaluated scene to get
scene name (evaluated scene will be gone with dependency graph).
The idea is to use this as a replacement of old CCG, now it is
based on OpenSubdiv. The goal is to reduce any possible overhead
which was happening with OpenSubdiv used by CCG.
Currently implemented/supported:
- Creation from mesh, including topology on OpenSubdiv side,
its refinement.
- Evaluation of limit point, first order derivatives, normal,
and face-varying data for individual coarse position.
- Evaluation of whole patches.
Currently not optimized, uses evaluation of individual coarse
positions.
- Creation of Mesh from subdiv, with all geometry being real:
all mvert, medge, mloop, and mpoly.
This includes custom data interpolation, but all faces currently
are getting separated (they are converted to ptex patches, which
we need to weld back together).
Still need to support lighter weights grids and such, but this
is already a required part to have subsurf working in the middle
of modifier stack.
Annoying part is ifdef all over the place, to keep it compilable
when OpenSubdiv is disabled. More cleaner approach would be to
have stub API for OpenSubdiv, so everything gets ifdef-ed in a
much fewer places.
This is a physically-based, easy-to-use shader for rendering hair and fur,
with controls for melanin, roughness and randomization.
Based on the paper "A Practical and Controllable Hair and Fur Model for
Production Path Tracing".
Implemented by Leonardo E. Segovia and Lukas Stockner, part of Google
Summer of Code 2018.
This patch adds a new matte node that implements the Cryptomatte specification.
It also incluces a custom eye dropper that works outside of a color picker.
Cryptomatte export for the Cycles render engine will be in a separate patch.
Reviewers: brecht
Reviewed By: brecht
Subscribers: brecht
Tags: #compositing
Differential Revision: https://developer.blender.org/D3531
This does not include all the struct and type renaming. Only files were
renamed.
gwn_batch.c/h was fusioned with GPU_batch.c/h
gwn_immediate.c/h was fusioned with GPU_immediate.c/h
gwn_imm_util.c/h was fusioned with GPU_immediate_util.c/h
This is intended for quick renders for previsualization, animation previews
or sequencer previews. It provides the same settings as found in the 3D view
Shading popover in solid display mode, but in the scene render properties.
The "Workbench" engine was removed, and this name no longer appears in the
user interface, it's purely an internal name. We might come up with a better
name for this OpenGL engine still, but it's good to be consistent with the
OpenGL Render operator name since this has a similar purpose.
metadata loading code was assuming all videos in Blender were from
FFMPEG... added empty place-holders for other types too, we probably
could load some metadata from pictures or AVI files too!
The Properties->World tab had no Viewport Display panel. The world color
itself was hidden when the 'use_node_tree' was enabled.
Also renamed the World.horizon_color to World.color as it has nothing to
do with the color of the horizon (old BI feature)
This does not fix the smokesim. It only port the drawing method.
The Object mode engine is in charge of rendering the velocity debugging.
Things left to do:
- Flame rendering.
- Color Ramp coloring of volume data.
- View facing slicing (for now it's only doing sampling starting from the
volume bounds which gives a squarish look)
- Add option to enable dithering (currently on by default.
Only fixes compilation error, the functionality will be limited.
Currently we don't care that much, since all the work is done in
the branch anyway.
Later on when we'll know which fixes we need to apply on top of
latest OpenSubdiv library we will call a library upgrade.
Main goal is to make API simpler to follow (at least ion terms what
is defined/declared where, as opposite of handful big headers which
includes all the declarations), and also avoid a big set of long and
obscure functions.
Now C-API files are split into smaller ones, following OpenSubdiv
behavior more closely, and also function pointers in structures
used a lot more, which shortens functions names,
UV integration part in GL Mesh is mainly stripped away, it needs
to be done differently. On a related topic, UV coordinates API in
converter needs to be removed as well, we do not need coordinates,
only island connectivity information there.
Additional changes:
- Varying interpolation in evaluator API are temporarily disabled,
need to extend API somewhere (probably, evaluator's API) to inform
layout information of vertex data (whether it contains varying
data, width, stride and such).
- Evaluator now can interpolate face-varying data.
Only works for adaptive refiner, since some issues in OpenSubdiv
itself.
Planned changes:
- Remove uv coordinates from TopologyConverter.
- Support evaluation of patches (as opposite to individual coordinates
as it happens currently).
- Support more flexible layout of varying and face-varying data.
It is stupid to assume varying is 3 floats and face-varying 2 floats.
- Support of second order derivatives.
- Everything else what i'm missing in this list.
Features to get the 2nd, 3rd, 4th closest point instead of the closest, and
various distance metrics. No viewport/Eevee support yet.
Patch by Michel Anders, Charlie Jolly and Brecht Van Lommel.
Differential Revision: https://developer.blender.org/D3503
Useful to store a snapshot of the current keymap state
so changes to the default keymap are ignored.
Also useful for testing keymap export works properly.
This better aligns the matcap/hdri browser, rotation/background sliders and
preferences/flip matcap button.
The remaining sub-panels are not perfeclty aligned yet, once the sub-panels
separation is more prominent (and they can be collapsed) we can align those.
Thanks devtalk forum for feedback!
This works for Cycles, Eevee, texture nodes and compositing. It helps to
reduce the number of math nodes required in various node setups.
Differential Revision: https://developer.blender.org/D3537
crashed when using filtering and no item was found ('Blender File' mode)
Reviewed By: brecht
Differential Revision: https://developer.blender.org/D3535
- Rename "Viewport Info" to "Text Info".
Name was too vague, nearly everything is information,
this currently only controls overlay text.
- Swap text-info & 3D-cursor, making 3D-cursor less prominent.
- Logical use of fields since they define type information.
- Avoids using ordered-dict metaclass.
Properties using regular assignments will print a warning and load,
however the order is undefined.
This brings the Object Visibility dropdown closer to overlays which
also controls visibility of elements int he viewport, so it makes more
sense there. Also placing the Overlays settings closer to the viewport.
Sub-panels for shading, measurement, normals, freestyle and developer.
Less-used sub-panels will be collapsed by default once their implementation
is complete (fixing spacing between sub-panels, adding the triangle to collapse, etc).
Also added missing check for overlays on/off on existing sub-panels.
* Unify X-Ray/Shadow toggle and factor, using the whole width gives you finer control
* Shadow settings next to intensity slider
* Cavity settings next to Ridge/Valley sliders
* Collapse Cavity settings when not used
* Make MatCap preview and browser dialog smaller. MatCaps are added by the user
so she is already familiar with how they look. No need to preview them that big
while browsing. To see the MatCaps in detail we have the User Preferences/Asset Manager.
Having popovers inside popovers triggers some minor glitches that will be addressed later.
(e.g. they open on mouse over and the popover arrow is not aligned)
Revert changes from 785159e6e4
but keep 'ifdef'.
@mont29 maintains this area and prefers to keep existing logic.
Note that there was misunderstanding that '*' was intended only
to be a backup key for '=' for keyboards which require holding a
modifier.
Group Object Type Visibility with the viewport settings in the header.
The eye icon is a placeholder. A new icon is needed to better communicate
the user at a glance if all (or none) object types are enabled, or why certain types
are not visible/selectable in the viewport.
Part of design: T55863
When tweaking the shading/overlays settings through the popovers,
these get on the way of the content in the viewport. Making it hard to
see the result of our changes.
Unfortunately this breaks consistency with other headers where the snapping
tools are aligned to the right, but the benefits outweigh the costs.
Organize content in categories/sub-panels.
The result is a more organized but slightly taller popover.
Once sub-panels are implemented code-wise, the alignment issues
(like panel label) and extra space between the content and panels
headers will be reduced. Together with the ability to have certain
less-used popovers collapsed by default, this will make the
popover more compact.
Part of design: T55863
- Made OpenSubdiv_GLMesh private
Previously, it was still accessible via C-API from C++ code.
- Don't implicitly refine evaluator when updating coarse positions,
now there is an explicit call to do this.
Allows to first apply all changes to the coarse mesh and then
refine once.
- Added coarse positions update from a continuous buffer with given
starts offset and stride.
Allows to update coarse positions directly from MVert array.
- Refiner is no longer freed when CPU evaluator is created.
Allows to re-use refiner for multiple purposes.
There are now 3 categories in the overlay popover:
- Navigation
- Active (camera, lamp... etc)
- Tool (manipulator)
The user preference for mini axis now controls if the mini axis
displays minimal or a full-interactive widget.
Part of design: T55863
This reverts commit 8121010310.
After user feedback this has the downside of having no predictable
way of transforming in global space.
Since toggling between global/user is reversed when global is
the user axis.
This is no longer needed with the new offscreen draw method, so use whatever
is default and hopefully fastest. Fixes console warnings in some setups that
don't have swap copy.
Remove support for loading interlaced image sequences because
its less common now to record interlaced video,
the option to de-interlace video on load remains.
This separate probe rendering from viewport rendering, making possible to
run the baking in another thread (non blocking and faster).
The baked lighting is saved in the blend file. Nothing needs to be
recomputed on load.
There is a few missing bits / bugs:
- Cache cannot be saved to disk as a separate file, it is saved in the DNA
for now making file larger and memory usage higher.
- Auto update only cubemaps does update the grids (bug).
- Probes cannot be updated individually (considered as dynamic).
- Light Cache cannot be (re)generated during render.
- Change gl_context_mutex to a ticket mutex ensuring interactivity even
when rendering.
- Add DRW_custom_pipeline for using DRW outside of the viewport and render
pipeline.
- DRW_opengl_render_context_*** and DRW_gawain_render_context_*** to use
with DRW_custom_pipeline.
- Add possibility to bypass deferred compilation on demand (not User
demand).
- Add union to access DRWMatrixState members more easily.
- Texture creation now requires explicit data type.
- GPU_texture_add_mipmap enable explicit mipmap upload.
- GPU_texture_get_mipmap_size can be used to get the size of a mipmap level
of an existing GPUTexture
- GPU_texture_read let you read back data from a gpu texture.
Numeric input allowed mix of editing and hotkeys which were interpreted
as modifiers instead of using as numeric input.
This meant entering '1.0*3' needed to be typed as '1.0**3'
('*' to activate, and again to multiply).
Pressing '/' gave the reciprocal of the current number
which could be useful.
Test removing this feature, so only full numeric input is supported.
The approach of setting 'refresh' flags on the modifier, and performing
the associated actions when the modifier is being evaluated, is a bad
one. Instead, we use the separation of the original and the evaluated
copy to 'refresh' certain things (because they simply aren't set at all
on the original). Other actions are now done directly with BKE_ocean_xxx
functions on the original data, intead of during evaluation.
Previously CMake was raising a fatal error, which wasn't too helpful.
There is still some fatal messages about Audaspace and Game Engine,
but the latter one is on it's EOL and is removed in Blender 2.8.
The X resource database is to be explicitly destroyed. This fixes 46 bytes
leak per every window DPI query (which happens a lot on window move/resize
and even on areas resize).
Unfortunately, this does not fully fix the leak since the known leak:
https://bugs.freedesktop.org/show_bug.cgi?id=94604
Previously global was always used before the current orientation,
the order is now reversed, which assumes the user wants to first
use the value they set, with the global secondary.
A toggle for this is no longer required now that both header and background
colors are RGBA (disabling Show Header is the same setting the alpha to 0).
Thanks Brecht for reviewing!
There were a number of cases where immActivate() and immDeactivate() could
get out of sync, causing crashes due to using a freed mutex lock. Refactor
the code now to hopefully avoid this always.
Based on feedback from the 'User Feedback' devtalk forum
* More opaque panels for the viewport
* Darker state colors
* Current frame color consistency for MCE
Old behavior: tagging ID with DEG_TAG_COPY_ON_WRITE will do copy-on-write
(as requested), but will also flush changes to all operations with depends
on it. This means, for example, tagging object for copy-on-write will force
its modifier stack to be evaluated.
This was needed in the earlier days of copy-on-write when things were not
well defined and when lots of areas were not doing proper tagging.
New behavior: tagging ID with DEG_TAG_COPY_ON_WRITE will only ensure copy
of the dadatblock is up to date, without flushing updates to any dependencies.
This means following things:
- We can update parts of ID without invoking heavy computation of other
parts of same ID. For example, tagging object for COPY_ON_WRITE update
on mode change will not force modifiers stack to update.
- If some dependent datablock is dependent on pointers which are invalidated
by copy-on-write (like, evaluated mesh referencing custom data layers from
original mesh), this will either require explicit tag or explicit relation
in the dependency graph.
Currently can not find a faulty case since tagging of mesh happens with
either 0 (which means, everything) or with GEOMETRY, which also forces
all dependent modifier stacks to be re-evaluated.
This fixes missing PBVH when going into sculpt mode (sculpt mode toggle
was tagging object for COPY_ON_WRITE update, which was forcing modifier
stack to be updated, which was freeing PBVH.
Some other operations might also become faster with this change.
Instead of running code to create a keymap, store them as data.
This allows for keymaps to share content as well as running
transformations at load time.
Now we light with just a user defined HDRI by default, which is useful
for material setup and texture painting and lighting without having to
set up any scene lights.
Previously it would use the scene world without lights by default, which
in some files is just black.
Shortcut strings would be offset to the left to make space for the triangles,
breaking the alignment with other shortcut strings. Now this alignment is kept
by making menus slightly wider if there's a sub-menu triangle visible, making
room for the triangle.
Trying to have a single option for this is too likely to be
insufficient in some cases.
Instead, support object type visibility & selectability per view-port.
Remove depth testing flags from motion path pass drawing,
so that they always appear to draw in "x-ray" style on top
of everything, making it easier for animators to see what
they're doing.
This fixes an issue introduced in d192d72312.
When starting up, the UI hasn't been fully initialised yet, and calling
wm_event_do_depsgraph() can trigger icon updates when the startup file
contains an image, causing a segfault due to a not-yet-initialised ghash
for the icons.
The flag was only used in readfile.c, and resulted in a delayed call to
BKE_ocean_add(); this call is now immediately made instead as it's not
very expensive.
The previous commit only solves the problem when using the default
theme using factory settings. For previously saved themes, there could
still be problems, as the alpha values were still 0.
This commit improves the logic here so that while keyframe points on
unselected F-Curves will still get faded out (to not stick out too much
from the curves they live on), but the effect will not be as pronounced
(i.e. the points will stay visible all the time).
Restore theem setting default for Graph Editor's vertex,
with default alpha set to 1.0. The alpha value here needs
to be non-zero, as the alpha values currently get used
when drawing verts.
This makes it possible to have a single shading nodetree that contains
separate Cycles and Eevee shaders. By default the target is set to All
so shaders are shared.
* Z now goes to solid mode when in lookdev or rendered mode.
* Alt-Z was broken after removal of texture mode, now toggles lookdev mode.
* Simplify code by turning it into a single operator.
This patch will allow users to customize what object types will be drawn by the object mode overlay.
It supports: Empties, Lamps, Cameras, Speakers, Armatures and Lightprobes.
It currently does not support Physics objects due to the overlap it has with other objects types.
Also be aware that in pose mode the armature is drawn, but not by the object mode overlay
Reviewers: campbellbarton
Tags: #bf_blender_2.8
Differential Revision: https://developer.blender.org/D3524
Will help entering sculpt mode on file load by making it possible
to fully initialize sculpt session. The goal is to make sure PBVH
exists since the very beginning of file open (missing PBVH is a
reason why object is not visible before first stroke).
This is not enough yet to fully solve the issue, since entering
sculpt mode tags object for Copy-on-Write update, which frees
PBVH.
Added a option to the overlay popover that controls the visibility of
non-renderable objects like lamps, cameras, speakers, armatures, curves
empties and force fields.
After discussion we went for a single option with more detailed check in
the object_mode draw engine.
Differential Revision: https://developer.blender.org/D3524
Textures in 16 bit integer format are sometimes used for displacement, bump and normal maps and can be exported by tools like Substance Painter. Without this patch, Cycles would promote those textures to single precision floating point, causing them to take up twice as much memory as needed.
Reviewers: #cycles, brecht, sergey
Reviewed By: #cycles, brecht, sergey
Subscribers: sergey, dingto, #cycles
Tags: #cycles
Differential Revision: https://developer.blender.org/D3523
When switching the workspace in a window that does not yet have a layout
for the newly active workspace, we now duplicate the layout from the
previously active workspace. Previously it duplicated the layout from
the first window in the newly active workspace.
It was a bit odd that the scene was stored per window but not the view
layer. The reasoning was that you would use different view layers for
different tasks. This is still possible, but it's more predictable to
switch them both explicitly, and with child window support manually
syncing the view layers between multiple windows is no longer needed
as often.
* Main windows show a topbar and statusbar, and select a workspace and
scene. They are created with Window > New Main Window.
* Child windows do not show a topbar or statusbar. These follow the
workspace and scene of their parent main window. Created with Window >
New Window or View > Duplicate Area into New Window.
* The purpose of this change is to support multi monitor setups where you
just want to put more editors on the other monitors. Without multiple
topbars and statusbars, working within a single workspace and scene.
Creating multiple main windows is intended to be a concious choice to
do different tasks in different workspaces and scenes.
* Note these changes do not currently affect how the operating system
treats the windows.
* When changing the workspace, the layout in all child windows changes.
This makes sense if we consider child windows to be just a way to
extend the main window across more monitors. In some case it may be
useful to keep the same layout though, we can add an option for this
depending on user feedback.
Node link menus (like shader settings in Material properties) used a slightly
brighter variant of the menu widget. Making it hard to style and match the rest.
Make it use widget_menuiconbut, which is just the menu widget with an icon and no arrows.
Thanks Brecht for the help!
Shading is supposed to be dealing with draw manager batch cached
thingamajigs, but was causing full object update.
This was causing both flickering in sculpt mode (PBVH was removed,
why it was SOMETIMES restored before draw is a mystery), and was
also causing things to be really slow.
Workaround for now until all editors tabs share the dedicated Tab theme
settings under User Interface (which the top bar is currently using).
Thanks SimonStorl-Schulke from devtalk forum for feedback.
This deduplicates the calls for tile (un)mapping and allows to have a target buffer that is different from the source buffer (needed for baking and animation denoising).
Based on discussion with @eyecandy & @venomgfx,
we agreed that Tab drag/click, is too easy to accidentally press
while moving the cursor.
It's also not typical to activate the operator on release which
introduces a small lag switching edit-mode.
This is a shame since in some ways its a nice way to re-use the key,
overall it just feels a little too unpredictable for such an important
action.
This commit makes the following changes.
- Tab: toggles edit-mode.
- Ctrl-Tab: opens pie menu.
- Ctrl-AccentGrave: toggles manipulator.
Note, while AccentGrave isn't always available
this shortcut is not essential.
This is the same approach as 98a0bcd425
applied to soft body simulation. In short, CoW copies share the point cache,
and treat it as read-only except when the depsgraph is active.
This prevents having to wrap each call to sbFree() in an if(ob->soft)
condition and assign ob->soft = NULL after calling.
Furthermore, passing `Object *` allows us to change freeing behaviour
depending on whether the object is an evaluated copy or an original (not
done in this commit yet).
This unifies two almost-identical functions at the expense of having to
add one single 'flag' value at one call.
This makes copy_softbody() aware of the source/dest objects, allowing it
to make a distinction between doing depsgraph evaluation copies and real
object copies. This will be used in an upcoming commit to ensure that
the pointcache is shared between CoW copies, similar to the current
approach for rigidbody simulation.
This is because depth test is set before drawing anything now. There is no
case where we want to draw without depth test that is not selection and
this case is not handle by v3d->zbuf anymore.
UI assume depth test is off by default. The DRWManager assume it's on.
This should fix T55623.
In some cases we want associate use an operator for a tool
for introspection, so we can for eg, automatically
use the same binding for in the popup toolbar.
Space-G/R/S for transform now work as accelerator keys again.
Also Space-E for extrude.
Selected color is now .9 alpha so keyed/animated/driven statuses
show through when widget is active. Assign color for overriden state.
Also fix progress bar not visible.
Make room for Alt-A to be used for de-select.
Discussed with artists in studio & @venomgfx,
- Use Ctrl-Space for animation.
- Use Ctrl-Tab to toggle manipulator.
- Remove mirror transform binding.
it is possible that two threads will request same undo node, only one
of them will initialize the node. The issue is that initialization is
happening outside of a lock, which was making one thread to use non-
initialized node.
If this change is ever a bottleneck, make a lock inside of node.
When playing animations the anti-aliasing was not reset, resulting in
ghosts from previous frames to be drawn. Also when playing animations
and switching to X-Ray mode for the first time would most likely
result in a write to uninitialized memory.
The shortcut labels now use the "Item" theme color. Its contrast for hovered
items is a bit low, but not too bad.
Note that this also changes the color of the little toolbar triangle to be grey
(the same color we use for the keymap label). IMHO that looks better though.
This doesn't update any themes other than the default one.
Part of T54711.
Operators ignored edges along the screen-layout bounds. They should've ignored
those along window bounds instead.
Although the global areas can not be joined/split, the adjacent areas can. So
the menu should still be shown.
Had to change the return value of area joining operator, so that an error report
can show up when trying to join over a global area edge. Think this is fine to
do, but you never know with such stuff.
Preferably we'd gray out the "Join Area" item in the menu when clicking on the
edge of a global area. Unfotunately the operator uses coordinates passed as
operator properties to find the right edge/areas, which we cannot access from
the poll callback.
Authored by Pavel Rudko (PavelRudko) on Thu, Jun 21, 10:41 AM.
Original description:
I've encounterd into a problem with blender 2.8.
See the example screenshot (scene, shader setup). For some materials it's not enough to calculate hash based on fragment code and defines. In some cases attribute names may change. And if we change uv set name, for example, vertex shader is not recompiled, and another attribute name inside it is used.
This allows key bindings: link/append and user-preferences
to be accessed via keys - without having to assign keys to each action.
- F1: Context sensitive help.
- F2: File Context Menu.
- F3: Search.
- F4: Window Context Menu.
Other keys F5..10, remain free,
ideally they can be kept for user actions.
This reverts commit 9129319647.
This meant users needed to select everything to see relationship lines,
this isn't always easy since objects can have limit-selection set.
This could be made into an enum option if it's important.
Just like the top-bar, the status-bar can now be hidden/collapsed by dragging
its edge. We display a small line with the editor outline color then, so there
is something that can be dragged up to un-collapse the area again.
This collapsed state is not written to files yet.
For example collapsing the lower part of the topbar with 2x interface scale
would hide the top-bar header region. There were also more asserts when changing
window size and moving area edges afterwards (same assert as in T55298).
Fixes are similar to e626998a26.
With all the recent fixes I've done, area geometry handling should be stable
again. Let's hope I'm right :)
This used to be rather cryptic and it was easy to forget the `+ 1` which in fact
is needed to get the correct width/height, see e626998a26. This should
also fix some minor off-by-one errors.
This reverts commit 357b72e0a7 which caused
the issue, we need a better fix for that cosmetic issue from T50862. For
now displaying keyframes and drivers is the more important one.
Added a compile directive in order to test SH4 in stead of SH2Win.
For now I disabled SH4, it is a bit more clear, but has a small
performance impact. Will check later for a better approach
There is now a manual refresh button on the panel to update the list
of objects in case it changes, and it also gets refreshed when changing
the collection or toggling the use count option.
This is a bit more manual but the previous code of refreshing the
list while evaluating the depsgraph was unreliable.
This also fixes it to take properly take into account visibility, and
to work with linked collections for which index writing was missing.
Access to main database is actually rarely needed, but some custom
'apply' functions do need it (like Collections' overriding of objects or
children collections).
First frame of the TAA is just a regular copy of the previous buffer. so
we write directly to the final buffer and skip the taa shader. We do
init the history buffer via blit so it will be initialized for the other
iterations.
When AA was enabled a new buffer was created. As the composite pass is
already done, we can reuse earlier buffers.
For the deferred rendering we reuse the color_buffer_tx and for the
forward rendering we reuse the transparect_accum_tx.
Most of the times the materials differ due to the object_id. This was an
overhead and resulted in instabilities on Intel graphical cards. This
commit will revert the Material Data UBO and replace it with normal
uniform.
Caused by ca8f787349. This issue is in master actually. Fixing it there
would cause conflicts so won't do that unless needed ;)
Steps to recreate were:
* Split properties editor into two (default startup.blend)
* Move both properties editors to the bottom, so only their headers are visible
* Move the upper edge of the upper properties editor up and down
Although it doesn't happen everytime, you may see the edge between the timeline
and the 3D view move, while the region drawing doesn't update.
What happened is area edge snapping allowed to snap the edge outside of window
bounds (we snap to a 4px grid by default), which screen_vertices_scale
interpreted as window scaling and thus run area size updates.
Referring to ca8f787349. Thought in this case the simple `+ 1` would be
correct, but we need to make the same pixel adjustment as we do in other places.
Simply moving the properties editor of the default startup.blend all the way to
the bottom could trigger this. Calculating limits for area edge moving would use
screen bounds instead of entire window bounds (screen + global bars).
Added assert that should help debugging further issues like this.
This puts the wireframe on top of the weight in weight paint mode,
sculpt mode ...
Wireframe should be colored differently if the object is in paint mode
but it's not there yet.
Unbuffered stdout makes stdout and stderr better synchronised, and helps
when stepping through code in a debugger (prints are immediately
visible). We don't output much to stdout anyway, so this isn't likely to
cause any performance issues.
- TAA is also enabled for Forward rendering
- Uses less GPU memory (removed one history buffer)
- TAA is done after the color management
- consolidated the aa code between forward and deferred rendering
(workbench_effects_aa.c)
I.e. we can now use REPLACE operation directly on items of an RNA
collection, when those items are ID pointers.
Again, mandatory to support new Collection's objects/children override.
To prevent the pointcache from being copied-on-write too (and requiring
copying back), the cache is now shared between the original and
evaluated scenes. Reading from the cache is always allowed; running the
sim and writing to the cache is only allowed when the depsgraph is
active.
Some pointers have moved from RigidBodyWorld (RBO) to
RigidBodyWorldShared (RBOS). writefile.c copies some pointers back from
RBOS to RBO so that the file can still be opened on older Blenders
without crashing on a segfault.
The RigidBodyWorldShared struct is written to the blend file, because it
refers to the PointCache ID block.
The RigidObjectShared struct is runtime-only, and thus not saved to the
blend file.
An RNA getter-function is used to hide the new 'shared' pointer. As a
result the Python API hasn't changed.
Reviewed by: campbellbarton
Differential Revision: https://developer.blender.org/D3508
Key shortcuts and explanation about how to use the tool should go to the
status bar, but other info can in the header so it's near where the user
is working. This distinction has not been made yet for all operators.
When RNA path was for a collection item, we'd falsly get NULL final
property (and wrong final RNA pointer too).
Own stupid mistake in some previous commit, iirc.
The preview files had all the other collections excluded from the view layer.
Although this fix the problem, it probably means we ignored some existing
2.8 files in recent changes. Which is likely fine anyways given that 2.8 is
experimental.
Assert from BLI_assert by default in debug builds
(instead of just printing a warning).
Some developers ignored this, causing errors for others.
Better debug builds cause hard error so code isn't ignored.
Disabling is still useful when bisecting or testing outdated code.
When meshes has no uv layer, but has a texture assigned there was a uv
layer allocated which was corrupt. When no uv layer is available now
there won't be a vbo created. This might impact performance as the draw
cache does not cache this result.
Current implementation works with at most of 3 layers, but was not
checked during hair drawing leading to reading from uninitialized
memory.
This commit limits it to the number of layers that is used during
compilation of blender.
Based on animator feedback, accidentally not clicking on the manipulator
handle had unpredictable behavior.
This functionality will be moved into the manipulator and made optional
(add an invisible fallback manipulator).
textures were not always drawn as the material did not always include
the image in the hash. Not sure if this will solve all cases, but it
definitely works better with this change.
This translates the gl calls to the new GPU_ wrappers from D3501.
Given it's tedious and repetitive work, this patch does as much as it can with search + replace, the remainder of the gl calls will need to be manually dealt with on a case by case basis.
This fixes 13 of the 28 failing editors when building without opengl.
For the list of substitutions see D3502
Reviewers: brecht
Differential Revision: https://developer.blender.org/D3502
Added it as extension to harden. Tried out different methods to fix normals,
Though as with width and segments changes shape, orientation of new polys
a non-smooth method of fix was not possible. Current method aggregates
vertex normals into a smooth fan without affecting edge shading.
Still need to fix the crease at new vertex edges
This way we guarantee that animation component on the datablock will
totally wait for action to be fully evaluated before attempting to
evaluate f-curves.
Fixes T55642: Inconsistent result on animated DoF file
The theme is now stored in generated C code,
which can be extracted from existing user preferences.
This theme can then be used for version patching themes
instead of duplicating values
Note that theme versioning has been removed,
since minor changes from now on won't apply well on top of 2.7x theme.
Theme colors from interface_widgets.c have been removed too.
Per iteration a different AO samples are used, so the final result is
less distorted. Will improve the quality of the image a lot when the
cavity option is turned on.
Currently only attached to the Anti Aliasing of the solid mode of the
viewport. But eventually we could add other options here. Quality
setting can be found in the System tab of the userpref.
The slider goes from No Antialiasing (0.0 - 0.1) to FXAA (0.1 - 0.25) to
TAA8 (0.25 - 0.6) to TAA16 (0.6 - 0.8) to TAA32 (0.8 - 1.0)
This has wrappers for the most common gl* functions in the codebase, and is in preparation for D3502
Reviewers: brecht, fclem
Differential Revision: https://developer.blender.org/D3501
Seems to be that mix(a, b, 1.0) will not give you b. on nvidia this is
not a problem as a was initialized with 0.0, but on AMD it can be any
floating point number, resulting that mix(inf, b, 1.0) was still more to
inf than to b.
find_elem(olddata=NULL) doesn't work reliably for existence checks; it will
return NULL both when the field is found at offset 0 and when it is not
found at all.
- FXAA is now also done in the workbench_forward engine.
- User can enable TAA8 in the userpref by setting their max
viewport AA to TAA8. FXAA will still be used when navigating
Now the name/collection filters run when there's some text,
and don't run when the box is empty, thus reducing an extra
step that was needed before these options could be used.
This commit is an experiment in using popovers as a place to house some
of the filtering options for animation editors, in line with what's taking
place in the Outliner with the filtering popover there too.
Right now, the most frequently used/changed options are still available
on the headers (i.e. the "Only Selected"/"Hidden"/search fields), while
everything else (i.e. the per-datablock filters, which were already hidden
behind a collapsed-toggle button before) now live in the popover.
We have to discard the batch in smooth case, because we are modifying
the index buffer (flat shading don't need it, only changes vertex buffer
on redraw, which is safe).
Many thanks to @fclem for his help on debuging/understanding what was
wrong here!
The latest clang compiler (at least the one in Xcode 9.4.1) warns about the register keyword and macro expansions using defined().
Since these warnings come from third party code, we can't address them directly in Blender. Silencing them via #pramgas will
at least keep the warnings during a build down to the ones that are relevant to Blender code.
At the moment it's using a hardcoded gray color that conflicts with
themes using gray for the header text. Instead use a slightly brighter
background color to make it stand, yet still use a theme setting.
Force Fields and Falloff are now simpler and more compact
by removing unnecesary labels (there was a text label just for one option)
Particle Force Fields Falloff is now a sub-panel of each effector type,
rather than just as a section with label.
Move Navigation Manipulator toggle next to Mini Axis as they are related
(and in the future merged into one pulldown) and rename Manipulator
to "Transform Manipulator" to make it clear they're different kinds
of manipulators. Also move to the first column next to other viewport settings.
- Use per context menu lists to support menu editing.
- Support for different kinds of menu items since this may be needed
in the future. Only use operator types for now.
BLF' blf_font_width_to_strlen() could easily generate strings with up to
nearly two pixels length over requested limit!
Note that the fiddling between floats and ints values make things really
confusing here... :/
There is still a few limit cases where, even though computed str length
is now always below reauested limit, we still get first letter
disappearing, no idea why currently.
This method is a bit more optimized than the very first one
because it does not rely on the adjacent faces properties.
That said it's still a bit slower than the per vertex method.
createOffscreenContext left the new context bound to the calling thread
causing a race condition with the background thread doing the actual
rendering. see T55555 for a more detailed description of the problem.
this patch changes the behavior of createOffscreenContext to restore the
context to the calling context.
Reviewers: fclem
Differential Revision: https://developer.blender.org/D3499
block and layout could be NULL and checking this everywhere
wasn't practical.
Instead of lazy initializing, add UI_popup_menu_end_or_cancel
which cancels empty popup menus.
To find all effectors in the scene, we need to loop over all objects.
Doing this during depsgraph evaluation caused crashes because not all
objects are guaranteed to be evaluated yet.
To fix this, we now cache the relations as part of the dependency graph
build. As a bonus this also makes evaluation faster for big scenes,
since looping over all objects for each particle system is slow.
Fixes T55156.
In stead of a single refresh function that re-init the whole system. The
API now supports adding and removing. Which will be much faster and less
flickering of missing icons when adding/removing lights
Silences the following strict flags from external libraries:
- -Wclass-memaccess
- -Wswitch
- -Wtype-limits
- -Wint-in-bool-context
Needed to tweak macro a bit, since the old logic was wrong:
we can not use CXX flags for C compiler, need way more strict
separation between what goes where.
We draw small numbers over the icon of multiple objects of the same type.
Also, we make all inlined elements to be non-clickabled.
For modifiers we still do it the old way. In this case it is more important
to see the order then the ammount.
Reviewers: brecht, campbellbarton
Subscribers: billreynish, venomgfx
Design task and mockup: T54707
Differential Revision: https://developer.blender.org/D3497
Again, we cannot actually get rid of G_MAIN global access here, so in
most case just 'marked' them as valid, and added assert checks to ensure
we do only work with IDs in G_MAIN in those cases.
Avoids usage of uninitialized memory when inversion fails.
That uninitialized memory can cause object to become visible when
it is supposed not to or other artifacts like that.
Longer term solution would be to check every instance of invert_m#
function and to explicit fallback when needed (possibly, using
extra utility functions).
There was a Full Shading bool that was shared across the WP, VP and TP
modes. This commit makes some changes:
- Replace the bool with a factor. This gives the user more control on
the visibility.
- Also draw it on top of the Material and Rendered mode so the user can
control what he needs. In certain cases you don't want to see the final
rendered material, but the actual texture.
- Removed the skipping of objects when in paint modes. As now the paint
modes are blended.
In an effort to centralize all opengl calls in the codebase, this patch replaces
the raw opengl calls in bf_blenfont with GPUTexture so it's no longer depended
on opengl headers.
reviewer: Brecht
Differential Revision: https://developer.blender.org/D3483
This error is only in Windows and Mac when select in properties the material tab.
This commit revert dc856be839 Preview: Add own opengl context to render preview images.
Transform evaluation does depend on that matrix, but relation was never
in dependency graph. It was not even in the old dependency graph, which
makes me wonder how this thing worked reliably to begin with.
Should fix flickering issue in the render farm.
Transform evaluation doesn't not depend on objects which are being duplicated,
so should not be any regressions here.
The whole relation should probably be gone as it's kind of rooting back to
legacy times, but that would need more clear research and investigation and
regression testing.
Removing that stuff should be valid with new depsgraph/modifiers stack
evaluation system... BUT it might not be, so rather have those in
separate own well-isolated commit.
This was actually rather hairy, this code is huge and complicated, easy
to make mistakes...
Good thing is, it will allow for significant simplification and more
(name) cleanup in following commits ;)
I was originally going to just expose the filtering options fo the timeline
too (via popover), to provide full access to the filtering options here too.
However, investigating further, that would've caused problems when trying to
use the Next/Prev Keyframe operators in other editors (see comment in code).
For now, the simpler solution is to just sync the scene-level flag (used for
this option) back to the dopesheet settings (used for generating the summary
channel used for displaying keyframes), to buy some time to investigate more
carefully.
When in forward rendering and Object outline was disabled every render
call created one console warning (uniform objectId not found)
this commit removes this warning
This reverts commit fec97ec949, it's useful to be able to edit object
properties for hidden objects. The issue with mode locking that this
was meant to solve will be handled in another way.
the use of the texture drawtype is limited. so who should we have it
this prominent on the screen. By adding it as a shading.color_type
option we should save some screenspace.
The calculation of the irradiance buffer was slow. Now it is only
calculated when it is being used (background_alpha > 0.0)
this solves the freeze when switching to LookDev mode.
Also changed the default calculation to use the Spherical Harmonics
calculation. This is able to generate the irradiance buffer fast, but is
less accurate. As the irradiance buffer is only used for visual
guidance speed is more important than accuracy.
Added compile directive to switch between the implementations.
(see STUDIOLIGHT_IRRADIANCE_METHOD)
Disabled caching the irradiance buffer when
STUDIOLIGHT_IRRADIANCE_METHOD_SPHERICAL_HARMONICS is used as it is not
needed.
This is a step towards being able to just choose the "Drivers Editor"
from the editor selector, and have everything displayed, ready to use.
Currently there are a few problems to resolve still:
1) This update callback doesn't run when changing the mode via the
editors selector in the UI. (Note: This problem also affects the
Timeline vs Dopesheet, causing a lot of initialisation work to be
skipped)
2) There's some missing redraw/refresh here to cause the properties
region to actually show. You need to resize the window for that to
happen now.
This shouldn't really be part of the windowmanager code. Pulling it out
now, so that we can reuse in RNA when switching display modes,
(and perhaps other places later)
This commit fixes a number of problematic corner cases when switching between
editors after 2b5050a4cd
The root cause of these issues was that mode_prev was not being set in
many cases, resulting in mode changes to the Timeline and back (via other
editors) causing Dopesheet Editors to reset back to "Action Editor" mode.
1) Creating new Dopesheet Editors (e.g. change the default 3D view to
a Dopesheet editor) would default to displaying the "Action Editor",
since mode/mode_prev == 0 represents the "Action Editor" (for backwards
compatability reasons), while mode == 3 is for the "Dopesheet"
2) If you set the Dopesheet Editor to another mode (e.g. "Grease Pencil" mode),
change to another editor (e.g. Shaders), then come back, the mode would
get reset to "Action Editor".
Expose search like in 2.7, we could make it pop on Ctrl+F to save space if needed.
Align Filter and the less used View menu to the right.
Based on mockups and feedback session with William
- Orientation of the cubemap were not conform cycles and eevee
- one side of the cubemap was flipped, so one side was overlit and the
other side was to dark.
In the outliner there are now icons for it, Ctrl+Click isolates a
single collections.
In the 3D view, Ctrl+H key opens a menu that is more or less the
equivalent of the old layer buttons in the header. Regular Click isolates
the collection, Shift+Click toggle the collection visibility. Pressing
number keys and letters works in this menu, which can help for quickly
selecting a specific collection.
Shortcuts for quick switching by just pressing 1/2/3/.. keys are available
again. The order can be confusing with nested collections, but that seems
unavoidable. The first numbers control the top level collections, and then
sub collections if numbers are left.
Remaining design issues:
* The 3D view menu needs to be improved: support for sub collections,
staying open on shift+click, access from the 3D view header somewhere,
shortcut key display.
* Currently collection hiding just controls per-object hiding, we plan
to separate this state still so alt+H doesn't affect collection hiding.
Note this is now separate from H key hiding, and meant for more persistent
ways to define which objects are relevant to the viewport or render.
This avoids some cases where you'd have to create collection specifically
to hide objects for viewport/render.
H hides selected objects, Shift+H hides unselected objects, and Alt+H
reveals hidden objects.
This hiding state is distinct from restrict viewport and render, and
meant for temporarily hiding objects without affecting more persistent
collection hiding.
Object hiding is per view-layer, same as selection. It affects the
viewport and any preview renders in there, but not final renders.
In the outliner, different icons are now used for temporary hiding, and
restrict viewport and render. Hidden objects are greyed out.
Remaining design issues:
* For lamps we probably still want to keep their effect on the scene,
currently they are fully disabled by hiding. Arguably mesh lights or
even objects being reflected or casting shadows are not that different
but perhaps the special lamp exception from local view should remain.
* We need a feature still to disabled this hiding for specific viewports,
for render or animation preview where you want to see the entire scene
while working in another view.
* We need a new icon for restrict viewport, for now it uses a grid similar
to the 2.4 icon.
* Hiding objects does not preserve selection state as it did in 2.7,
it's probably convenient to support this again?
Validate some cases using G_MAIN instead (I don't think we want to work
on any other Main than G.main one when registering/unregistering nodes
etc.).
And when freeing, all ID not in Main shall now be tagged accordingly, so
we *should* not need to do that stupi search over all ntrees in G.main
to check wether we have to free it ourself or not!
Happened when deleting many studiolights at the same time when the
previews were still beging calculated in the background.
Added a free function callback that is filled when the preview is being
generated. This free function will then kill the preview job
This patch also removes icons that are not valid anymore so the user
cannot accidentally render an icon where the studiolight is invalid.
In the end we should use a add/remove function in the studiolight as
currently icons are recalculated too much.
`mesh_get_eval_final` and friends could call `mesh_build_data`, which in
paint/sculpt mode would call `BKE_sculpt_update_mesh_elements` which
would call `mesh_get_eval_final`... ugly!
Would compare evaluated ob pointer to original one...
Found while investigating some errors in incomming cleanup, but this was
probably generating lost of other issues in some cases...
This is a temp fix for a better system.
Currently the studiolights can be referenced by a WM_job and being freed
via the API. This can happen when removing a studiolight via the
interface.
As the studiolight has no relation with the job, it is hard to detect if
it is still being used. I tried with a Mutex and a Thread Queue but they
were failing.
So the current temp fix is to keep the studiolights in memory until you
close blender. This Must be fixed ASAP! I added this fix so normal cases
can workish.
I moved some code from ED_rigidbody_object_remove() to
BKE_rigidbody_remove_object(), so that calling the latter doesn't leave
the object in rbw->group (causing a crash later on when rebuilding the
depsgraph).
The idea is to only use pointers to particles in original object when
creating an edit structure. The derived mesh we get from evaluated
object.
The rest of the commit is just keeping pointers in sync.
This makes it possible to perform re-evaluation of the scene without
having to re-run the simulation.
The CoW → Orig copy is only performed when the depsgraph is active, so
as to not influence the current scene while rendering in the background.
Alternatively, we could have the CoW copy share the cache with the
original to prevent too much copying of cache data. This will be faster,
but I'm not sure whether we can reliably check the DEG_is_active()
status at CoW copy creation time.
- the result of the SH2-coeffiecients are stored in a bin file (3*9
floats). As the file is a local file we do not care about the
architecture.
- solved issue that also for internal lights the irradiance file were
stored. We don't want that as it could be in a not accessible location
SculptSession.mode_type wasn't initialized until painting,
making it unreliable for checks in other parts of the code.
Also remove unnecessary initialization,
matching sculpt mode more closely.
rBe0c088f8fb5a introduced offline rendering support on windows, sadly it was trying to use the desktop window for getting a context, which given SetPixelFormat can only be called once for any given HDC was an unfortunate choice.
This patch uses a temporary hidden window for getting the opengl context.
Reviewers: mano-wii
Differential Revision: https://developer.blender.org/D3481
Not sure why remap call for static override reference ID pointer was put
there, probably a mistake during some merge back in the days...
But this ended up with self_id of libquery data struct still being set
to previous ID pointer, which could randomly generate crap like falsly
reporting indirect data and such, leading to lost reference datablock at
writefile time...
Since we free collection caches when we remap one of their objects, we
also need to tell depsgraph to flush this into the COWs of that
collection, otherwise things like draw code can access freed memory...
There were two issues here, introduced by rB66aa4af836:
* Forgot to change length of some filter_glob var deep in filebrowser code.
* Truncating filter_glob in general can be dangerous, generating
unexpected patterns.
Last point was the root of the issue here, truncating to 63 chars string
left last group as 'match everything' `*` pattern.
To fix that to some extent, added a new BLI_path_extension_glob_validate
helper to BLI_path_util, which ensures we do not have last
wildcards-only group in our pattern, when there are more than one group.
By default users want AA in the viewport. For slower systems you want to
be able to turn it off. As in the future we would also like to support
TAA in the viewport we introduced it as a Max Viewport AA settings.
Also removed the drawoption to enable/disable AA per viewport
When rendering the AA is always turned on.
This mimics the behaviour of the old wireframe mode. When in Xray mode,
don't use the limit selection to visible option.
Also hide the option if Xray is enabled.
Limit to a restricted set of built-ins, as well as the math module.
Also restrict of op-codes, disallowing imports and attribute access.
This allows most math expressions to run
without any performance cost once the initial check is done.
See: D1862 for details.
This rewinds a change from own commit e3d88b021c
The only took edge overlay into account (crease, seam.. etc)
Currently active-face also uses this width.
While the difference is subtle,
this makes the active-face stand out more clearly.
In preparation for possible alternative back-ends, the dependency on glew.h needs to be confined to as few libraries as possible. This patch removes all gl types from the public gawain headers.
It'll need some more refactoring later on, but for now this will suffice.
Reviewer: brecht, fclem
Differential Revision: https://developer.blender.org/D3482
Remove all the clip cases and just pass the vertices screen position to the
fragment shader.
This does put a bit more pressure on the fragment shader but it seems to be
faster than before. And it simplify the code a lot.
It seems to fix some long standing issue on some intel GPU.
this is to highlight areas in the code that still directly do opengl calls or use
opengl types.
This is in preparation for supporting alternative rendering back-ends.
Reviewers: brecht, fclem
Differential Revision: https://developer.blender.org/D3304
This means the shader can now be used for procedural texturing. New
settings on the node are Samples, Inside, Local Only and Distance.
Original patch by Lukas with further changes by Brecht.
Differential Revision: https://developer.blender.org/D3479
- Vertex size now matches the theme setting.
- Edge width is closer to a single pixel line.
- Face dot was scaled up to be drawn as a circle,
but is currently a square.
Old implementation rendered alpha to 0.0 for background, but only during
deferred rendering. We should attach this to an DNA setting and also let
the forward shading respect this. But for now this is a better default
Currently focused on making parts which are a bottleneck for Spring,
to make things fast as possible. There are surely lots of places
where threading is not currently done, but we can keep doing this,
maybe even with help from the community :)
Without children we only need to update batch cache. This way
we don't re-evaluate the whole modifier stack just to perform
child particles redistribution.
Need to use the 'use_partial_connect' option in island connect,
so changed signatures of various functions to pass that into and
then down from BM_mesh_intersect (making true for intersect, false
for boolean).
Then fix bm_face_split_edgenet_partial_connect to work when
input edges are not necessarily wire, but at least not in the
face they are being connected in. That caused generalization
of core BM_vert_separate_hflag_wire (which is only used in
this one place in all Blender).
FXAA implementation in the deferred renderpass of the workbench.
Can be enabled per 3dview. Eventually this will also be a user setting
as it is more a system/performance setting than a scene setting.
object.base_flag was not synced back from evaluated ID to original one.
Similar thing as copying back to original transform matrix, avoids
having to get data from evaluated one in lots of cases.
Previously, render slots were hardcoded to a fixed amount.
With this change, render slots now are stored in a list. Therefore, users can add and/or remove as many slots as they want.
Credit to brecht for the UI part.
Reviewers: brecht, sergey
Differential Revision: https://developer.blender.org/D3474
I've limited it to just the RGB<->XYZ stuff for now, correct image handling is the next step.
Reviewers: brecht, sergey
Differential Revision: https://developer.blender.org/D3478
The automatic mode checks all Enviroment Texture nodes and picks the largest image's resolution.
If there are no Enviroment Textures, it just uses the old default.
Also, the sampling map now isn't limited to square shapes. The automatic detection uses the exact image size,
the manual UI option now halves the value to get the height.
A default aspect ratio of 2:1 makes sense since this is what most HDRIs use.
Reviewers: brecht, sergey
Differential Revision: https://developer.blender.org/D3477
This removes OperatorRepeatContextHandle, from 5f6c45498c
since we now only have redo in the area an operator is executed in.
These values could be invalid and crashed in some cases.
Sometimes the evaluated pose channel pointers can change during depsgraph
evaluation, so we can't store them ahead of time. The object pointer
should be ok since evaluated ID memory is reused.
This reverts commit 7529690df3.
I tried to put manually add threading protection to GHOST around
Xlib calls but that did not fix the crashes. So reverting that
for now despite the performance implication on some system.
Currently done for mesh batch cache update, and for base flags sync.
Those components do not need anything from original object, and hence
can skip CoW tag and have faster update after them used.
Currently with a debug build there is a race condition where the mutex is released before the DST structure is reset to 0xFF, meaning when multiple threads are using the DRWManager it can get cleared when the main thread is using it, causing crashes.
Reviewers: fclem, brecht
Reviewed By: fclem
Tags: #bf_blender_2.8
Differential Revision: https://developer.blender.org/D3476
this is actually adding option to add buggy behavior, but.. NPR often
expects buggy behaviors, and its one of the main targets for normal editing.
So think it's reasonable to add that option (disabled by default of
course).
Note that am not really happy with UI, but:
* Not sure where to put it, it's kind of own self-contained area option.
* Don't to make it too much visible, using this should be the exception!
This solves the problem of blocks jumping around when changing modes and
center them to the area (in case of only 2 spacers).
Which is (in my own opinion) more aestetically pleasing.
Minor changes based on user feedback.
- View aligned rotation manipulator overlapped too often
with axis aligned widgets. Increase size (matching 2.79)
- Offset arrow-heads when combining rotate & translate,
don't draw the stem since it overlaps with scale.
For grouped undo we should not skip the undo push, rather replace the
previous undo push. This way undo goes back to the state after the last
operation in the group.
Before that depsgraph tagging was done from inside notifier listener in
viewport. This had the following issues:
- If there are no viewports, selection tag was not done. Causing possible
issues when object becomes visible.
- Required special trickery to detect which data to tag for update.
- Was causing crash when transforming/selecting markers in clip editor.
This is because selecting marker needed to poke viewport to redraw, since
selected bundles will be displayed differently in viewport.
Moves the preset into a menu for the panel header, so it can be changed
without opening the panel and takes up less space. Two remaining issues:
* For long lists the add new preset button can be scrolled off screen.
* We should support showing the name of the chosen preset in the panel
header, but the current preset system does not support detecting which
preset is used.
Differential Revision: https://developer.blender.org/D3366
Note that due to RNA get/setters issue, that one may actually add some
G.main usages to the total... But at least it's not hidden anymore in a
very low-level, dark corner of BKE pointcache code!
Technically we probably need to do for the current subversion (17).
But the entirely 2.80 series is known to be experimental.
The most important part is to notify people that if they open the 2.80
file in master it will loose data.
- User preferences header at the bottom.
- Action header at the top.
Now all editors accessible from the menu have their header at the top,
default layout for the timeline remains at the bottom.
These are set in the interface and aren't useful to show to users.
Other minor changes
- Rename 'Ruler/Protractor' -> 'Ruler'
- Rename Subdivide 'Quad/Tri Mode' -> 'Create N-Gons' (and invert).
This is supposed to be handled by calling code! Henceforce, no need to
call BKE_sequencer_clear_scene_in_allseqs() here, and... no need for
that ugly G.main case. ;)
All areas are toy use "local" number generator, in order to keep
behavior predictable and threadable. This is what BLI_rng_() API
is for.
There are still lots of usages of BLI_frand(), which are to be
ported to BLI_rng_get_float(). but that is somewhat involved.
For the time being, remove unsafe API, so new areas have zero
chance using it.
Completely ignore animation for legacy zero update tag.
If one needs animation to be evaluated, tag with proper update tag, stop relying
on direct assignment of adt->>recalc with zero update tag for DEG.
This commit might cause missing updates when needed, those needs to be looked
into once they happen.
We shouldn't be using BI textures anyway. But in any case, adding noise
texture to compositor is doing proper seed updates already, so probably
was already ported to a proper RNG usage.
The ClayEngine was introduced to test the blender2.8 architecture during
development. As currently we have the wanted features implemented with
matcaps we are going to remove the clay engine as it was never intended
to be an official releasable engine
Note: The test cases are never run. But when enabled will be skipped as
they were implemented over the Clay Engine
Render depsgraph is evaluated from scratch, so it should not be needed
to do such a call.
This also prevents modifier stack from being evaluated on top of already
evaluated mesh
This is the first step to moving redo out of the top-bar, see: T55039
- Support for floating panels in the ScrArea has been added.
- A new region type RGN_TYPE_HUD is used for floating settings input.
- Only one HUD should be visible at a time.
- Currently HUD regions are only visible
for 3D view and image space types.
- There are currently some remaining glitches with hide/show
that need further investigation.
This is also a way to render an large preview icon without the selection
control. This is used by the studiolights in the userprefs that only
displays the preview of the light.
We actually get fully rid of BKE_object_free_derived_mesh_caches usages,
now always using BKE_object_free_derived_caches (bad name, btw, should
be 'evaluated_caches ;) )...
With copy-on-write we can no longer assumes the point density data is
available after Cycles synchronization with Blender data is done. So
force it to be loaded earlier, even if it's not great for interactivity.
- Added flexible separators to
Clip, Graph, Dopesheet, Image, Node, Timeline, 3D View.
- Added graying out for Proportional Editing
menus to avoid popping when right-aligned.
- Slightly re-arranged some controls,
so they can be on correct side of the separators.
Patch by @billreynish
This was causing driver editing popovers to just keep disappearing
whenever you accidentally moved the mouse away, making the popovers
there nearly useless.
After testing with the other popovers we have in other places, I don't
really see why we needed this flag enabled in the first place. You can
still switch between popovers in the topbar by mousing over the others,
and if you want to dismiss without clicking to escape, you can go over a
standard menu instead OR just move back towards the button that spawned it.
Let's just test this out for a while and see how it goes. Maybe we don't
need a more invasive solution here...
There is one legit place in the code where memcpy was used as an
optimization trick. Was needed for older version of GCC, but now
it should be re-evaluated and checked if it still helps to have
that trick.
In other places it's somewhat lazy programming to zero out all
object members. That is absolutely unsafe, at the moment when
less trivial class is used as a member in that object things
will break.
Other cases were using memcpy into an object which comes from
an external library. We don't control that object, and we can
not guarantee it will always be safe for such memory tricks
and debugging bugs caused by such low level access is far fun.
Ideally we need to use more proper C++, but needs to be done with
big care, including benchmarks of each change, For now do
annoying but simple cast to void*.
In C++ it is not really safe to memcpy objects, and newer GCC will warn
about this. However, we don't use our vector for unsafe-to-memcpy objects,
so just explicitly silence that warning.
This support layout.separator_spacer() to be used by headers as a way to
dynamically separate the ui buttons.
Right now no UI file is changed, though we can use this right away in the
timeline, and shortly after in the viewport header (moving settings from
the topbar to it).
Original design by William Reynish.
Review: Campbell Barton
D3468
This way they can be init in their owner thread. Contexts should not be
shared accross threads. Once you make a context active on a thread it is
owned by the thread.
This commit only have the GLX backend updated but should not break orther
platform.
Note: Metaballs only support the first material slot. Splicing it per
material would create empty Batches. In order to overcome this we set
the batch for other materials to NULL. We added extra checks in EEVEE
and Workbench to not draw when the geom is NULL.
thanx bblanimation (Christopher Gearhart) for spotting the issue and
providing the fix!
Reviewed By: brecht
Differential Revision: https://developer.blender.org/D3449
- Frame & object name now top left.
- Axis now top right (when view navigation disabled).
This is needed so we can use the lower area for redo popup, see T55386.
atoi usage in BLI_stringdec could overflow, use strtoll instead and
check
valid range with INT_MIN and INT_MAX
Reviewed By: campbellbarton
Differential Revision: https://developer.blender.org/D3452
This won't ever be used for this operator, as the "edit" operator should
only ever be used for dealign with a single driver - the one under the
cursor.
While we probably won't be getting a general purpose "Onion Skinning"
overlay anytime soon for meshes, etc. (at least not before the
depsgraph stabilises, and we also get geometry caching working),
for the Grease Pencil integration at least, it makes sense to move
GP objects to using a more general/future-proof solution, instead
of continuing to use a special/dedicated button in the header.
Currently the UI part of this is commented out. Also, the GP branch
doesn't need to move to this pre-merge. But, since 2.8 changes move
fast, it's better to reserve the space now to have it next to motionpaths,
than introduce it later.
The copy/paste driver variables buttons currently only work when used in the
Graph Editor as they rely on being able to have the "active F-Curve" context
info that's only present in the Graph Editor (in Drivers Editor mode).
Instead of having them constantly greyed out in the popover, it's easier
to just hide them for now. Besides, this is probably more of an "advanced"
feature that we don't need to expose in the simple UI.
use better poll and get ob with 'ED_object_active_context' (instead of
'CTX_data_active_object')
Reviewed By: campbellbarton
Differential Revision: https://developer.blender.org/D3467
This fixes the problem where the "Show in Drivers Editor" button would
not actually select and highlight the driver under the mouse.
(TODO: The channels still aren't getting selected properly in the
channels list, but at least the properties show correctly)
Previously, newly created drivers were set to "Scripted Expression"
mode and had their 'expression' field set to the pre-driver value of the
property, so that adding a driver didn't cause the property to immediately
lose its old value (and potentially causing havok in the scene).
However, this had the unintended consequence of making the driver setup
workflow more cumbersome, as you first had to replace that value with
the name of the driver variable before your driver would work.
This commit works around this issue by trying to combine the best of both
worlds (quite literally): Now, the driver expression for drivers created
using Ctrl-D will be "var + <old value>".
Thus, in the simplest case, the driver will do something as soon as you fill
out the driver variable settings (e.g. just filling out the Target Object field
will do it), meaning you get your drivers working faster. Of course, it may now
be necessary to edit out the old-value, and/or it might be a bit more confusing
what/why it's there for newbies. However, the improved ease of setup, and/or
a more tangible example of how an expression may be constructed outweigh the
downsides IMO.
This commit implements a new behaviour for the "Add Driver" functionality
(invoked from the RMB menu on a property, or by pressing Ctrl-D).
Instead of spawning a context menu asking you to pick the way
you want to create a driver, it will now just create a driver on the
property under the mouse and then show the "Edit Drivers" popover so
that you can immediately start editing the properties of this driver.
This way, the whole process is more visual and feels less blocking /
constrained, with less upfront decisions needed immediately.
Notes:
* The new behaviour is equivalent to choosing the "Manually Create (Single)"
and then doing a "Edit Driver" on the property
* Renamed the old "ANIM_OT_driver_button_add" operator to
"ANIM_OT_driver_button_add_menu". It will probably go away
in the near future, but it's better to keep it around for a
while longer still until the new workflow settles down.
The range is 0.25 to 0.75 opacity when the Xray opacity is between 0.0 to 1.0.
This is to avoid loosing completely the sense of occlusion when having no
other solid drawing than the wireframe and loosing the transparency when
xray alpha is at 1.0.
Also replace Bayer (checkerboard) method by interlieved gradient noise to
minimize the chance to loose an occluded line completely.
Other noise function could be tested in the future.
This Fix the problem when multiple objects are selected and one of them
occlude the others. You cannot see clearly what is selected.
With this option, selection is more clear when Xray mode is enabled.
By using equation 7 from the paper, we make the surfaces nearest to the
viewpoint appear more "opaque". This gives better sense of ordering than
the previous weighting function that was really not doing anything.
There was a method explained in the Weighted Blended Order-Independent
Transparency paper to support hardware that does not support per render
target blending function.
So now only 2 geometry passes are required instead of 3 (one being the
outline/depth fill pass).
This also fix how the blending is done. There was some premult confusion
in the implementation.
As in Pose Mode, the idea here it to try to reduce viewport complexity
without requiring users to turn off the overlay completely all the time.
For example, a background prop (e.g. a tree with a tyre hanging off it,
or a branch with hand-placed leaves) won't be cluttering the viewport with
its relationship lines all the time, when you're trying to do something else.
When you really do need to see these lines, you can still select the object
in question, and you'll see the lines for which objects are its children
or what its parent is. And to see all lines, you can still always select all
objects.
This patch reduce the branching in the lamp loop, improving compilation time
noticeably (2372ms to 1785ms for the default shader).
This should not change the appearance of the shader.
Performance impact is negligeable.
This mimics the 'spreadsheet' behavior. Columns and/or rows can have
equal sizes, or adapt to their content - but always in a grid way (i.e.
all items in a same column will always have same available width, and
all items in a same row will always have same available height).
Also, you can fill (order) the grid in a row- or column-major way.
Not used anywhere for now.
Differential: https://developer.blender.org/D2395
This fixes the problem that matcaps have when using a very larg FOV in
perspective view.
This was because it was stupidly using the normal direction which can not
aligned with the view vector under perspective.
So to workaround this problem we don't use the normal as is, but compute
how much it's facing the camera.
This changes how matcaps looks in perspective because they now always use
the full range of the matcap (which is expected).
material_index in hair system has been removed. The material/shader
for hair should be defined externally it doesn't make sense to rely
on the scalp object material slots for this.
Pretty straightforward changes, merely mimicking dm-related code,
which was already essentially using either Mesh or BMesh data to
build the PBVH...
Note that we "lose" the subsurf (a.k.a. grid) PBVH case here, but that
one was already dead code in current blender2.8, since final dm is
always a cddm built from evaluated mesh.
Proper fix is pending new code for subsurf/multires area.
Would try to use data from global area for the newly created fullscreen area.
This should not happen, so instead of a global area use first area from layout.
When a CacheFile datablock is copied to an in-main datablock, it means that
the new copy should be independent of the old copy. In this case certain
properties are reset/duplicated. When it is copied to a no-main datablock,
we assume this is a copy-on-write copy that's used for evaluating things,
in which case the handle and object paths are referenced instead of
reset/ duplicated. This prevents us from re-opening the Alembic file every
time a new CoW copy is made.
The same approach is taken when freeing data (only when an in-main datablock
is freed do we actually free the data).
This makes evaluated objects to point to a non-evaluated collection,
which is already really bad. What is even more worse, objects in those
collections are not evaluated either.
Proper solution would be to implement visibility flag for nodes, which
will be set to 0 for transform/geometry components, but which will be
1 for copy-on-write components.
This way we will guarantee consistency of dependency graph.
For now this change is good enough and unlocks production.
Fixes T55375: Crash when changing visibility of instanced collection
Fixes T55357: Particle geometry crash
- all known image types are supported
- BpyAPI for studiolights added
- added open user pref operator in shading menu
- possible to add multiple files in a single run
For now refreshing studio lights will free all studiolights and reinit
the whole mechanism. This can be improved by only freeing deleted, reset
updated and add new custom studiolights.
details to show currently only shows the path we perhaps want to add
other information also
After testing in the studio and extending the event system for
drag events, we've agreed on adjustments to the new keymap,
see: T55162
- Tab: Edit-mode toggle.
- Tab + Cursor Drag: mode switching pie menu.
- Accent/Grave: for 3D view pie menu.
- F3: Search
- 1..3, Shift-1..3: Edit mesh vertex/edge/face toggle.
Other minor changes were made, however they aren't part of the design.
- Ctrl-Shift-S: Image editor Save-As (was F3)
- Ctrl-Alt-R: Repeat history (was F3)
All keyboard events were sending double key events (including modifiers)
when xinput was enabled with gnome (causing much confusion!).
I cant test if XIM works,
but this isn't useful to send double events, so disabling for now.
Since we are only creating this and never updating, there is no need for
the original approach with the individual data to be updated.
Note we only populate the GPU data when binding the UBO, so we can in the
future easily create the UBOs in a separate thread than the main drawing one.
Also at the moment animated materials are not working. To fix that we need
to free/tag for free the GPUMaterials in BKE_material_eval.
This make the limited wireframe not a performance problem anymore.
However, this does change the number of edges displayed as the threshold
is now computed per vertex instead of per edges.
For this reason we extended (internaly) the range of the slider so that the
users can hide more edge.
Before that copied collection in copy-on-write were running out
of sync with original ones. This was causing crash with the
following scenario:
- Delete some objects from scene
- Add particle system to an object
- Change particle mode to Hair
Thanks Dalai for debug session! Pair programming ftw!
We now remove the shader for every update.
So at the moment the whole point of UBO (Uniform Buffer Objects) is that they
are more efficient than individual uniforms.
Next steps is a harmless refactor to stopping UBO from referring to original
data in the UBO, and simply copying it.
It would also be interesting to make the final shader more granular as far as
the library and required functions are concerned. Even if this doesn't impact
performance, it should give us smaller easy to debug shaders
(a simple shader now has > 5k lines!).
If performance for animated values is measureable slower after this commit we
can port the shader creation CPU side to the depsgraph - localizing the tree,
hashing, lookup, ...
Additionally we can stick to update the UBO when the material changes but not
its topology. This is very trick because of localized trees. So we will only
re-visit this if profiling hints at any benefit from it.
Notes:
* Really need to address RNA setters case, end up adding way too much
G.main here these days... :/
* Added Main pointer into bAnimContext, helps a lot in anim code ;)
When calling the bpy.ops.poselib.apply_pose() operator from Python, Blender
would deadlock when the rig has drivers.
Similar BPy_{BEGIN,END}_ALLOW_THREADS calls were already in place in the
rna_Scene_update_tagged() function.
This is part of the work needed to refactor the material parameters update.
Now the gpupass cache is polled before adding the gpumaterial to the
deferred compilation queue.
We store gpupasses in a single linked list grouped based on their hashes.
This is not the most efficient way but it can be improved upon later.
Not sure why exactly it is called a cleanup, the code was much more clear
and robust against possible missing return statements which are MANDATORY.
Missing return statement will:
- Cause two different BVH traversals to be run.
Not is happening currently, but if more BVH layouts are added, it will
become a problem.
- It is already causing assert() statements to fail, since functions are
no longer returning when they are supposed to.
If there is any measurable reason to keep this change, let me know.
Otherwise just stick to reliable/tested/robust code.
This reverts commit ba65f7093b.
The issue is that children drawing is done by object mode,
which operates with data from evaluated context. But that
data needs edit mode's cache to be properly updated first.
Makes ADD brush to work.
At some point children particles draw got broken, children are not
visible for until first stroke is done. Still looking into it.
Experiment: let the user be in control of the alpha channel as some rigs
are hard too see during bone selection. Especially rigs that were
designed for 2.79 wireframe mode.
That bug was also likely affecting other cases - basically it was making
auto-keying always key from evaluated ('visual') values, never base,
data values... Added a flag, in some cases we do want evaluated values
here, obviously.
This was no longer working, now this works the same way as
scene.update(), only it applied to the current view layer.
Caused crash running alembic export from Python.
A cavity shader based on SSAO. Works on all workbench deferred passes.
Per 3d viewport the cavity shader options can be set as different
shading needed different options. Some global options are in the
Viewport Display of the scene like num samples and distance.
Experimental: Naming of Ridges and Valleys
The mutex was shared between CoW copies of the CacheFile datablock, and
as a result also freed multiple times. It is now only freed when the
original datablock is freed; the CoW copies share the same mutex.
This is a beginning of series of commits which will clearly separate
building IDs which are used as object data from object building.
The goal is to be able to always build whatever ID. Required to make
driver targets to work reliably with copy-on-write concept.
DATA datablock must evaluation must never depend on object it is
used for. If there is something what depends on an object, it must
be done on object level.
At least the actual callback was empty.
When the source mesh doesn't have the primary layers (CD_VERT for vdata,
etc.) the returned mesh also didn't have those layers, even when non-zero
elements were requested (for example requesting 4 vertices would still
result in mvert = NULL).
The ObjectID pass was generating per material per dupli a specific
number for the outline what results in a GPU context switch. In spring scene
01-050 a scene with many trees (duplis) generated 28000 GPU materials.
Now only new materials are created when objectid pass is enabled. Also
added a hard limit to the number of objects for the objectid pass (255)
Basically the outline between objects will not be drawn, but it will be
very hard to detect them also.
Also fixed for XRay mode.
Test this since the popup feels disruptive/flashing when its too large
when set smaller it looks closer to a menu w/ key-accelerators which is
the intention in this case.
It's also more likely the active tool can be placed under the cursor.
The recent change also used the buildtools instead of the regular compiler, you now have to explicitly state what you want to use :
2017 - the standard msvc compiler
2017pre - the msvc compiler from the preview installation
2017b - the msvc compiler from the buildtools installation
The function definitions still reside in DerivedMesh.c. Once we're done
porting all the DerivedMesh use to Mesh, we'll move the still-relevant
functions to mesh_runtime.c. This move is now cumbersome due to shared
statically-declared utility functions in DerivedMesh.c
This helps making things clearer and cleaner. Func returning filepath of
G.main is separate, so that we can easily track its usages, and
hopefully deprecate it at some point. Though that usage of G.main is
likely the less evil one, you nearly always want current blendfile path
in those cases anyway.
When run from make.bat the environment is setup correctly and the VCToolsRedistDir environment variable exists, on later invocations of cmake this may no longer be the case and a warning was emitted about the missing runtime. we can't rely on InstallRequiredSystemLibraries.cmake here since it uses the compiler version to figure out the correct location and it doesn't know how to deal with clang.
Manipulators which aren't explicitly activated via tools are now hidden.
Tool manipulators are kept because it doesn't make sense to interact
with a tool with hidden manipulators.
Material slots are a real pain to get working, due to all the black
magic they do to hide object vs. obdata storage of the material...
Currently hitting an order problem - we need to always set 'link' (to
object or obdata) property of the slot first, before we set its
material... *super-sigh*
- users can use their own matcaps
.config/blender/2.80/datafiles/studiolights/matcap/ folder
- upto 100 matcaps can be loaded
- color of the matcap is influenced by the color of the material/single
color etc. To show the plain matcap use single color at 1.0
- chosing a matcap is at lighting level (flat/studio/matcap)
- matcap only possible in solid mode
- also works for X-Ray mode
As the old matcaps are still in used by the clay engine I didn't remove
it yet.
We are already running out of available flags in main, generic int, and
everytime I work on static override I find new special cases that will
need new specific propflag, so...
Switching the mode was being done per object,
where it should first check all pose bones from all objects.
This also removes code that changes the transform mode
from within the counting function.
This was only needed on transform initialization.
D3458 by @billreynish w/ edits.
- Context menu for dope-sheet, graph, image & node editors.
- Add type to contenxt menu header.
- Access with W-Key.
- Change UV-editor weld key binding to Shift-W.
Make it more reliable and predictable way of getting pointer to
an original mesh which came from copy-on-write engine.
Related change: made it (hopefully) more clear name for flags.
Non-manifold geom was producing inverted result when the camera was inside
the shadow volume.
When rendering non manifold geometry with the depth fail method, we need to
emit the cap as if it was the same geometry with a virtual thickness.
Another way to view it is to imagine having a set of non-manifold geometry
all facing the light.
So for every tri we emit a front cap oriented toward the light and the
back cap pointing away from it (whatever the actual orientation of the tri).
Extrusion pass stay the same as the depth pass method (double the increment
if it's a manifold edge).
In the Python API, any panel becomes a subpanel by setting bl_parent_id
to the name of the parent panel. These subpanels can contain advanced or
less commonly used settings.
Now hairs are shaded properly in workbench and support texturing.
I also added a 10% random normal direction per hair to have a bit more
variation in the shading. This is hardcoded for now.
-expanded build_deps.cmd with 2017 support, it can't locate msvc2017 so needs to be run from developer prompt.
-Newer cmake was unhappy with openal's cmakelists.txt
-collada has warning as error on and errored out on new msvc2017 warnings.
This is a dirty fix. A bit more cleaner approach would be to check if a
context is bound and delay the deletion only in this case.
Also we may want to do this orphan deletion at some other places than
wm_window_swap_buffers.
Do note that it does not match cycles implementation.
Also we could precompute the hash per strand before rendering but that would
suggest it's not per engine specific.
If we make the random value internal to blender then it won't be a matter
because other renderers will have access to the same value.
This is really convenient for development. Either for profiling the
generated shaders or to check if the generated code is correct.
It writes the shaders to the temporary blender session folder.
(ported over from blender2.8)
By default when moving a edge of the screen it always snaps to an invisible grid with unit of 4 pixels.
This was also affecting the snap to the midpoint and adjacent.
The solution was to make the snap to areagrid optional and use values of `origmin` and `origsize` that match the transformations in screen_edit.c.
The fix bit is the split.
But since we are using col.separator() left and right we need this as well.
I still don't think the separators are the way to go, yet may as well be
consistent with the current design in place, thus the extra separator here too.
This commit restores support for Motion Path drawing in 2.8 (as it wasn't ported over
to the new draw engines earlier, and the existing space_view3d/drawanimviz.c code was
removed during the Blender Internal removal).
Notes:
* Motion Paths are now implemented as an overlay (enabled by default).
Therefore, you can turn all of them on/off from the "Overlays" popover
* By and large, we have kept the same draw style as was used in 2.7
Further changes can happen later following further design work.
* One change from 2.7 is that thicker lines are used by default (2px vs 1px)
Todo's:
* There are some bad-level calls introduced here (i.e. the actgroup_to_keylist() stuff).
These were introduced to optimise drawing performance (by avoiding full keyframes -> keylist
conversion step on each drawcall). Instead, this has been moved to the calculation step
(in blenkernel). Soon, there will be some cleanups/improvements with those functions,
so until then, we'll keep the bad level calls.
Credits:
* Clément Foucault (fclem) - Draw Engine magic + Shader Conversion/Optimisation
* Joshua Leung (Aligorith) - COW fixes, UI integration, etc.
Revision History:
See "tmp-b28-motionpath_drawing" branch (rBa12ab5b2ef49ccacae091ccb54d72de0d63f990d)
Since the viewport header now supports transparency, text on pulldowns
can be hard to read if their color matches the viewport content.
Background is drawn using the 'inner' theme color, that was unused until now.
In some heavy rigs matrix inverse can be 10% of computation time. This
reduces it to 2% by using Eigen's optimized 4x4 matrix inverse and SSE
matrix multiplication.
- Uses the roughness setting of the basic eevee material
- renamed gloss_mir to roughness
- set default of roughness to 0.25
- renamed ray_mirror to metallic
- cleaned up material rna (BI mirror struct)
- use BLINN phong model
- normalize incoming/outgoing specular light
- when using camera oriented studiolight, the SolidLight will be used
for specular highlights
- EXPERIMENT: when in world oriented studiolight only the shadow direction will be used.
- change the settings of the internal light to make scenes more
readable
Note there is some talk about changing the position of this (which would be strange in the image editor by the way,
since there we use the bottom for the result of the current pixel when dragging the mouse).
However first I wanted to fix this regardless.
This currently shows panels that were in the 2.79 3D view toolbar
which are now popovers.
In some cases it's useful for these to stay open.
This commit adds a space type to do this.
Note this is currently empty in object mode.
This will currently only work for the RelWithDebInfo configuration since asan
does not support the debug crt. for source line information in the reports,
you need a copy of llvm-symbolizer in the blender folder or set the
ASAN_SYMBOLIZER_PATH environment variable to point to it. Currently (as of
6.0.0) llvm-symbolizer does not ship with the binary clang/llvm distribution.
Reviewers: campbellbarton
Differential Revision: https://developer.blender.org/D3446
This overlay is showing mesh topology. It is usable with transparency
even if the mesh order can mess up with the expected result (some object
more prominent than others).
Edge thickness and alpha values are hardcoded for now but can easily be
added to theme or object settings.
Only OB_MESH is supported for now.
Creates a simple index buffer with negative indices if the edges is not a
real edge.
Also create the buffer texture representation of this buffer along with the
pos_in_order buffer texture.
This includes:
- Skip OB_RECALC_TIME tag from object duplicate operator
not sure why it is needed: even if original object was
animated, duplicating it will copy evaluated values.
- Don't tag whole ID for update when updating it after
relations rebuilt. Use the same trickery to detect
whether animation is to be re-evaluated or not as is
done for update flag=0.
- Don't tag datablocks which are expanded for update
of copy-on-write.
- Avoid flush along relation from copy-on-write
operation in action. This will not invalidate any
pointers in the copied datablock since we don't
reference anything in the action.
Will cause some bad behavior when object is shared across multiple
visible view layers with different overrides. Accept it for now,
and possibly force single view layer later.
When active dependency graph is evaluated, it will apply animation,
drivers and scalar evaluation data (such as object matrix) to an
original datablock. This way operators and tools can easily read
data from original datablock.
This will simplify porting them to copy-on-write, and solve issues
when some operator will allocate new datablock based on original one,
and will want to read data from it.
This way we allow animation system to make decisions based on which
context dependency graph is coming from, and whether it belongs to
an active edit window or not.
After discussion with Sergey and Dalai, we have decided to remove
this option completely. We're getting to the point where it is almost
impossible to really use 2.8 without COW, and keeping the old option
running ends up diverting dev resources away towards tracking down
and fixing problems with a parallel system that will be going away.
Made the highlights darker (using the defaults of blender 2.7
- sharpness = 50
- spec color = 0.025 (I bumped it to 0.1)
- added a log2 to the frontal camera light to reveal more details of the
mesh
We no longer user scissor for 3D viewport drawing, and some selection
code assumed it still. This also cleans up unnecessary scissor test
switching, we only have it temporarily enabled now.
* depsgraph.ids: all evaluated datablocks in the depsgraph
* depsgraph.objects: all evaluated objects in the depsgraph
* depsgraph.object_instances: all object instances to display or render
* depsgraph.updates: list of updates to datablocks
After more testing, I realised that bendy bone properties should also be grouped,
but probably all other per-bone settings too. Now, just group all of them, since
it's easier for everyone this way.
For many years, animators have been complaining about how keyframing a (transform)
property directly would leave them ungrouped, while keyframing them using a Keying Set
would put them into a group based on the name of the keyingset.
This commit attempts to improve (unify + make consistent) the default behaviour:
* All object transforms now get added to an "Object Transforms" group,
regardless of whether they were added individually via buttons or keyingset
* All bone transforms now get added to a group corresponding to the name of the bone
instead of only the ones added via keyingset
Saves quite a bit of CPU ticks per mesh update, giving measurable
speedup for file from T55228.
Memory usage goes up a it, most likely due to evaluated mesh having
more custom data layers than corresponding DM does.
This introduces a new depsgraph API for getting updated datablocks,
rather than getting it from bpy.data.
* depsgraph.ids_updated gives a list of all datablocks in the depsgraph
which have been updated.
* depsgraph.id_type_updated('TYPE') is true if any datablock of the given
type has been added, removed or modified.
More API updates are coming to properly handle multiple depsgraphs and
finer update granularity, but this should make Cycles work again.
Use the same key for pose & weight paint mode (instead of texture paint)
This makes more sense since pose/weight paint modes
are often used in combination.
This mean you can store data used for drawing inside the object engine
data.
Also fixes T55243 Crash in ASAN debug builds due to use-after-free memory in draw code - instances issue?
This now can shade actual poly strips that mimics cylinders.
This makes hair coverage exact compared to the line method and result in
smoother fading hair.
This does make the sampling a bit more exact but needs more samples to
converge properly.
This new system use transform feedback to compute subdivided hair points
position. For now no smoothing is done between input points.
This new system decouple the strands data (uv, mcol) with the points
position, requiring less update work if only simulation is running.
In the future, we can have compute shader do the work of the feedback
transform pass since it's really what it's meant to. Also we could generate
the child particles during this pass, releasing some CPU time.
draw_hair.c has been created to handle all of the Shading group creations
as well as subdivision shaders.
We store one final batch per settings combination because multiple viewport
or render could use the same particle system with a different subdivision
count or hair shape type.
Hair Particles shape properties are ported from cycles. Thoses properties
have the same defaults and have a do_version of their own. Cycles will use
theses properties instead of its custom ones.
Some realtime engine specific settings are also added to scene->r because
it's much easier to control as global values.
Bumping Version number so cycles can do its own do_version on top of the
default settings.
This mimics the behaviour of DRW_shgroup_empty_tri_batch_create and will
replace it eventually.
The advantage is that it's compatible with transform feedback.
Modifiers stack only get COW/evaluated IDs, so no need to go auery again
DEG for those. Further more, now unified handling of EditBMesh case (was
done on case-by-case basis in a few modifiers, not all for some reason).
We are still missing the ability to get final and cage deformed meshes
when in Edit mode though, this is to be defined/implemented in depsgraph.
This is a first step to have correspondence of legacy derivedDeform
within a new formulation. Only base ground for now to support file
reading, copy-on-write remapping and such.
Support switching non-active objects in/out of a mode from the outliner.
- This allows users to change which objects are in a mode w/o
having to exit the mode and change seleciton.
- Changing the mode of the active object applies to all other objects.
- By convention setting a mode selects, removing de-selects,
this is done for convenience so switching to a mode from object mode
maintains the set of objects in the current mode.
See: T55246
The fur modifier is just a testbed for the underlying hair system.
The API is intended to allow specifying guide curves with python scripts
without having to worry about inconsistent state. All curves are first
defined in a python-friendly way, then applied to the hair system in one step.
This avoids overlap which happens on sharp turns when simply extending
the curve linearly from the center. It also simplifies the curve cache
data structure.
Face groups are used for now to define the origin of a groom bundle. This
is probably going to be replaced at some point with a dedicated surface
graph/mesh, but is much easier to implement and gives sufficient functionality.
When a face map is selected as the basis of a hair bundle it will update
the curve shape automatically. In the future this should perhaps be an
optional step (user operator) because it destructively changes existing
shapes.
This is updated through the depsgraph. Currently just checks for existing scalp
object and vertex groups, eventually will perform actual tracking of the mesh
surface to ensure the groom follows changes of the scalp mesh.
Adding new context modes requires adding a string in CTX_data_mode_string,
but there is no error when omitting this other than panels using
incorrect contexts. The static assert should help detect simple
missing strings at least to avoid confusing errors.
A Material pointer would be a nicer way to assign a hair material,
but unfortunately that does not work well with the context-based material
lookup of the node editor. There is no selection of an "active" modifier,
so the node editor will never display the material (unless it is placed
into a material stack as well).
The final count is inversely proportional to the min_distance, so using that
as a user variable is difficult to control. Instead we just use the overall
count as the single variable now.
The actual final count will be less than this maximum count, because the
theoretical limit is never reached in practice. The min. distance could also
be stored as a result of the hair generation as feedback for the user.
Using a single uint as combined cell index only leaves ~10 bits per
coordinate axis, which quickly leads to overflow for higher densities.
Now use 3 ints so that the sampling grid can have sufficiently small
cells.
This will be a simple testbed for generating hair geometry.
The plan here is to use different modifiers for different editing methods
for hair. Each of these will use a HairSystem instance, but vary
in the editable data used to generate guide curves. The hair system
underneath is agnostic to the editing method used.
Scalp mesh now is passed explicitly to the hair API functions again.
The idea is that hair systems can be created in any object and use
another object as the scalp. Sharing the same hair pattern should be
implemented at a later time, pending a good design for assigning
follicles to specific hair systems.
The purpose of this branch is to create a new hair system with a dedicated
grooming tool, unlike the current direct editing of hair guide curves.
The modified bmesh-based strand edit mode is quite complex and distracts
from the main purpose of the branch, so its better to remove it for now
and implement a new tool.
The idea is to separate guide curves from the various methods of
generating them. Guides could be created explicitly (as hair
strands), or automatically from vertices or external mesh data.
A guide then forms the basis for interpolating the render data
(fibers).
The cell size is chosen as r/sqrt(3) (i.e. max. 1 sample per cell),
which means that the influence of each cell extends beyond the 1st
neighbor. a 5x5x5 box (except the center and corners) needs to be
examined to find collisions.
This is still buggy (uneven sample coverage) and needs changes to the
sampling system for better threading support.
The implementation is based on
Bowers, John, et al. "Parallel Poisson disk sampling with spectrum analysis on surfaces." ACM Transactions on Graphics (TOG). Vol. 29. No. 6. ACM, 2010.
This should test general functionality and consistency of different methods
for generating samples. In particular it shoud ensure that threaded variants
produce the same samples as unthreaded variants when using the same generator
and seeds.
This is to ensure that threaded generator usage creates the exact same results
as the non-threaded base version. Further improvements and testing will be
needed.
Samples can be generated either one-by-one using the existing "make_sample"
function (which uses a default context), or use the more efficient batch
generation functions. These optionally support threading via the task scheduler
now.
This creates a dependency of the hair groups on the validity of the pattern,
so care has to be taken to always update the groups when the pattern changes.
This stores basic hair follicle data, rather than full fiber caches
(which should only be generated for render data).
Note that deformation by strands will just be one possible way to generate
hair fibers, so strands should be kept separate from the hair follicle data somewhat.
Currently only clumping and curls are implemented. There is no proper input
for the parameters yet, these are just hardcoded atm. Eventually the hair system
should either define uniform values from hair system settings or enable per-fiber
values using a material or other node-based input.
Subdivision works on the parent strands for efficiency. The fibers lengths
are based on the final subdivided length of parents, so no changes to the
shader are required.
This would be nicer with a tesselation shader, but this feature is not
available in Blender 2.8.
It turns out that 1D textures have the same size limit on their 1 axis as 2D textures.
This limits the potential number of hair dramatically, even though the actual size of
the texture is very small. Using a 2D texture and wrapping the index avoids this problem.
This allows the shader to use proper lighting from the standard Eevee shaders.
The code for interpolating hair strands is in a glsl library file to facilitate
use in other engines later.
Hair drawing requires fairly large vertex buffers. Vertices also need to be interpolated
and displaced according to the control (parent) hairs and hair-style features like curling
and clumping.
Instead of doing this in advance on the CPU and uploading a large vertex buffer every frame,
this work can be done on the GPU for realtime display, because interpolation and displacement
are highly parallelizable. The vertex buffers then only need to be uploaded once (as long
as strand lengths remain the same). The vertex format can also be very lightweight, requiring
only a curve parameter and index (half the size needed for full positions).
For interpolating a buffer texture is used in the shader, which contains all information
about the control curves (parents) from which to interpolate final vertex positions.
This adds the possibility to edit a regular mesh like strand data.
It's more of a test for independence from particles than a real use case,
but could come in handy anyway.
Based on the ray casting technique described here: http://www.joesfer.com/?p=84
Volume samples currently are not bound to mesh deformation in any way, they are
simple object-space locations. Potentially a harmonic weight approach as in
mesh cages could be used.
Currently strand edit mode tool use the object data 'x mirror' flag.
This flag is only available on mesh objects, but the strand editing
can be used for dupli override caches etc. as well. Eventually strand
editing should get it's own independent flag to avoid this problem.
separate file.
This may seem a bit like overkill, but it helps ensure that no particle
depedencies messes up the strand editing code. The same will be done for
other use cases of the strand editing code in the future.
Note that currently this has virtually no effect, because the mirror
option relies on exact positions of vertices, which does not happen with
random hair placement (the add brush has no mirror option yet).
Eventually topological mirroring should help with this case, but is not
implemented for either old or new strand edit yet.
These are a modified version of their BMEditMesh counterparts.
use_topology is not yet implemented for strands. Native strand topology
is not very useful for this. Instead, the topology of the scalp mesh
should be used for finding mirrored strand roots, then the arc- or
parametric length of a vertex from the root to find mirrored verts.
Conflicts:
source/blender/blenkernel/BKE_editstrands.h
When copying mesh data to bmesh the MVERT and similar customdata types
have to be omitted. Otherwise the bmesh instance ends up with NULL
pointers in customdata layers, but entries in the typemap != -1. The
effect was that when storing new steps after one or more undo, the
resulting original data would be copied, and subsequent undo steps
are ignored.
data masks explicitly.
A dummy mesh is used for strand edit undo storage like in mesh edit
to prevent unnecessary code duplication. However, when copying from/to
BMesh only the mesh data layers are copied by default, omitting the new
data layers for strands (currently only MSurfaceSample hair root data).
This uses the generalized undo stack system which is also used for
object data edit. An extension is necessary to tell the undo functions
which object is specifically used for generating undo data and
identifying the stack, since strand editing does not edit the obdata
itself.
consistent segment lengths when transforming vertices.
Warning: The implementation is not correct yet, but all the steps should
be there.
The main idea is to treat strands as a sequence of joints that are
displaced out of their original locations by a transform or other tool.
The solver then tries to find a global per-strand solution that keeps
the segment lengths unmodified, with a minimum change in angles from
the original starting shape. Such a solution is much more usable and
efficient than the current O(n^2) attempt of "spreading the error"
across the strand.
The inverse kinematics method is very flexible. It can also include
stretching, which would be very welcome for features like the length
tool. Different parts of the strand could be weighted separately using
scaling factors for the angle/stretch parameters.
Conflicts:
source/blender/physics/intern/implicit.h
mode.
This method is simple, but not really very usable. It works by
successively relaxing segments that are too long or too short, moving
both vertices along the edge between them. This is repeated N^2 times
(N: number of vertices on the strand).
A true IK solver could give a lot better results, as well as providing
many opportunities to apply weighting for targets (e.g. preferring to
move non-selected over selected vertices). Many different methods for
simple IK solvers exist, so there should be one that works well for
large number of simple strands. See e.g.
http://www.math.ucsd.edu/~sbuss/ResearchWeb/ikmethods/iksurvey.pdf
vertex positions.
This works a lot better with strokes perpendicular to the general hair
strand direction. With the previous comb tool such strokes would only
make a small dent in the hair curve and then vertices would slip out
of the tool circle. The edge combing affects the local direction of
strands, which acts as a kind of grabbing functionality by moving
further vertices in front of the tool circle. The result is that
drawing a curvy hair shape with the comb becomes much easier.
In addition, the new tool also uses edge filtering and weighting rather
than vertices. This means that small brushes also work well, instead
of having no effect when hitting the edge segments between vertices.
Further improvement could be achieved later by using a global strand
solver, which adjusts vertex positions based on an error metric along
the whole of the strand.
direction vector for the hair stroke tool.
This is necessary for directional tools such as combing, where the
stroke direction can lead to unwanted results if it changes too
abruptly.
The rationale behind this is that the BKE code could be used for
modeling hair and fur as well as a number of other features such as
grass. The primary addition to BMesh is the limitation to strand-like
topology (simple vertex chains, optionally rooted on a mesh surface).
The editor code OTOH is quite hair specific, since the result should
be suitable for hair simulation, and the workflow should mimick actual
hair grooming intuitively. Eventually the hair edit mode could become
a generalized strand edit mode with slightly different tool sets for
various purposes, but for now it is quite specifically built for hair.
Conflicts:
source/blender/blenkernel/CMakeLists.txt
source/blender/blenkernel/intern/particle.c
drawing code for edit mode.
The lighting uses the same method as the particle hair, interpreting
strand direction as the normal. This is nowhere near realistic hair
shading, but doing this with line shading alone in the fixed-function
pipeline is probably not possible. A GLSL shader could be used instead
for a more realistic alternative as part of the viewport project. At
least this simple shading mode gives some orientation feedback while
editing hair.
Currently uses the same approach as old particle edit mode (rescale
hair segments from the root on). A more sophisticated approach using
least-square error minimization of the displacement could yield better
results.
Stroke tools will be categorized by the hair elements they operate on:
vertices, segments or strands (roots). In addition to that a filter
function defines the influence of the brush. This should be defined by
the other brush settings and be largely independent of the main tool
mode.
This requires converting the old messy particle num/num_dmcache/fuv/foffset
data into the new mesh samples, which can potentially introduce floating
point errors and inaccuracies due to lack of face index mapping in the
new system. However, in any well-constructed particle system the hair
roots should be nearest to their num face, so mapping would be accurate
enough. If necessary face index data could be added to samples as a
legacy code hack, but probably it's best to eventually replace the
hair system as a whole anyway.
Currently particles only have a single weight value, controlling
pinning in the simulation (for root and virtual root verts) and goal
force scaling. This will be replaced by a full vertex group weight
system eventually.
This is more for testing purposes, since currently there is only a
single mass property for the psys as a whole. This should change in the
future though, to allow variable mass per strand or vertex.
Conflicts:
source/blender/bmesh/intern/bmesh_interp.c
Hair/Strand editing will only use a subset of the bmesh topology and
expect a specific topology that needs to be verified and enforced.
However, this extra requirement is much less work than reimplementing a
whole edit data system with the same feature set as bmesh and avoids
much redundant code.
Conflicts:
source/blender/blenkernel/intern/customdata.c
source/blender/makesdna/DNA_customdata_types.h
This means using mempools to store curve and vertex data, which allows
arbitrary addition and removal of data more easily. Also this includes
an iterator system similar to bmesh iterators (although the simpler
topology makes it a lot less complex).
Conflicts:
source/blender/blenkernel/intern/customdata.c
source/blender/makesdna/DNA_customdata_types.h
particle hairs remain visible.
Note that currently the hair root location (num/num_dmcache, fuv, foffset)
is not stored from edit data, so all hairs end up in a default location.
This makes it work more like editmesh, and avoid the awkward and
basically bad-level approach in particles, where the edit data is an
anonymous pointer in particle systems together with a callback for
freeing.
Conflicts:
source/blender/blenkernel/CMakeLists.txt
sampling system to keep the code simple.
Now there is a MSurfaceSampleStorage struct that encodes the storage
details, which the algorithms don't have to care about.
This code is not yet used by any feature in master, but has proved very useful in the Gooseberry branch and several WIP patches. Inclusion into master was requested to avoid diverging code in branches and get part of the Gooseberry code merged early on.
The core idea is to have a common way of identifying points on mesh surfaces. Efficient evaluation of such points after deformation and mappable modifiers (e.g. subdivision) tracks positions, normals and other surface attributes. This is used extensively in the particle/hair systems and could be useful for certain tools, duplicators, etc.. Currently the particle systems in particular are very fragile and succeptible to mesh changes because of the unreliable way mesh surface mapping is stored. While the new system at this point uses essentially the same method, it at least provides a centralized DNA type that can be improved easily without too much effort and compatiblity issues.
In addition to evaluating surface samples the system also provides a central place to implement surface sampling algorithms, such as random sampling, ray casting, paint-like tools, etc.
Differential Revision: https://developer.blender.org/D922
sampling system to keep the code simple.
Now there is a MSurfaceSampleStorage struct that encodes the storage
details, which the algorithms don't have to care about.
COMMAND${CMAKE_COMMAND}-Ecopy"${PYTHON_OUTPUTDIR}/python${PYTHON_SHORT_VERSION_NO_DOTS}${PYTHON_POSTFIX}.lib"${BUILD_DIR}/python/src/external_python/run/libs/python${PYTHON_SHORT_VERSION_NO_DOTS}${PYTHON_POSTFIX}.lib#other things like numpy still want it though.
setBUILD_CMAKE_ARGS=%BUILD_CMAKE_ARGS% -G "Visual Studio %BUILD_VS_VER%%BUILD_VS_YEAR%%WINDOWS_ARCH%"%TESTS_CMAKE_ARGS%%CLANG_CMAKE_ARGS%%ASAN_CMAKE_ARGS%
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.
