The velocity is also reset to 0, which makes sense after forcing a dynamic object position.
Known issues:
- in interactive mode, changing an object position by rna causes a simulation step
- setting any part of the object position or orientation causes the full matrix to be applied to physics => missing true rigid body API
Note: bug was caused by use of legacy ob->flag & SELECT. New OB_PHYS_MOVING
flag to mark that an active object is being transformed.
Make active object position update independent of cache write in preparation
of interactive physics.
The changes are:
- The shader now is passed as a parameter of the batch `draw` method (batch.draw(shader)). Since the batch always has to set a shader before drawing;
- The batch methods to specify a value to a uniform have been removed. Uniforms are parameters of the program (here called shader). If you change a uniform, it changes in all batchs that use the same program;
- New methods were added to set uniforms by the shader;
- The `batch.program_set_builtin` was removed. It is a duplicate of `program_set` but without a shader object. We need the shader object to configure the uniform;
Differential Revision: https://developer.blender.org/D3752
Avoid accessing object mode via the view layer active object
when drawing since it's done everywhere we store the active object mode
in the draw-context.
The problem is that string width computing is performed in integers
(pixels), which can generate a rather annoying error (a few pixels)...
Simply work around that for now, by trimming an extra middle char when
needed.
`to_strlen` just benefits from using pre-computed kerning table for
ascii chars (gives about 30% speed improvements).
`to_rstrlen` was re-written and heavily simplified, basically using same
logic as `to_strlen`, and `BLI_str_find_prev_char_utf8()` to loop
backward in the string, instead of looping forwards the whole string,
storing each gliph's width in temp array, and looping backward on that
temp array to find final string matching expected width. Gives about 70%
speed improvements!
And both functions can now share their core logic.
With new jemalloc versions memory allocated by threads that then become
inactive is not longer automatically freed. Instead we have to enable a
background thread to do it.
Some testing is needed to find out of this is sufficient, because the
background thread only runs periodically.
This parameter allows to define the percentage of offset of a stroke when uses surface mode.
Before, this was a fixed value, but for some artists' purposes, it's good to have the option to change it.
Users can select the main unit they want to use now.
Previously the displayed unit always depended on the magnitude of the value.
The old behavior can be restored by switching to the "Adaptive" mode for length, mass and time units.
Meters, kilograms and seconds are the default units for new and old scenes.
The selected unit is also the default unit for user input.
E.g. if cm is selected, whenever the user inputs a unitless number into a field of type length, it will be interpreted as cm.
Reviewer: brecht
Differential: https://developer.blender.org/D3740
Currently some modes share tool keymaps, we might want to disable
this since it's confusing editing one thing in multiple places.
However this should be resolved in the tool definitions.
This includes all the modes that don't need multi-object support:
* SIMEDBONE_CHILDREN
* SIMEDBONE_CHILDREN_IMMEDIATE
* SIMEDBONE_SIBLINGS
* SIMEDBONE_GROUP
* SIMEDBONE_SHAPE
Unlike the mesh select similar operator, in this case we take
only the active bone in consideration, not all the selected ones.
I decided not to change that, and keep this 2.79 behaviour.
We could though if we want to.
It is crucial that scripts do not write, and even more importantly, do
not store any references to those. Otherwise, that’s a rather straight
path to crash.
This is quite an obscure option only useful in rare cases,
when enabled by accident it's confusing since single objects
can't be transformed.
Also, w/ 2.8x you don't see the option change in the header.
This allows gizmo groups to store properties in the tool.
This makes sense for gizmo options which only control gizmo display and
don't control operator execution.
Unlike similar kinds of properties,
this isn't accessible via the gizmo-group-type instance.
For now the it's only stored in the workspace tool as can be done for
operator properties, so each instance doesn't have different settings
which would be confusing from a user perspective and complicate access
from the top-bar.
Later we could add gizmo-group properties if needed.
Currently it's not showing the subdivided mesh (if there is a subdiv mod)
and there is some sync issue if there is multiple uv image space opened.
But thoses will be tackled later on. The purpose of this commit is to fix
the overflow issue of IMM and speed issue.
NOTE: This commit only concern edit UVs and not the "shadow" mesh displayed
when texture painting. This will be address in a future commit.
We now cache the uv mesh in the mesh batch cache and only reupload data on
changes.
Update could be more granular (and a bit faster) but it's not our main
concern ATM.
This should fix problem caused by the IMM api used to draw large meshes.
This makes performance skyrocket compared to previous implementation.
There is still a big CPU bottleneck when not in sync selection mode but it
is not related to the drawing function directly.
Allow raycasting in two directions and culling front or back faces.
Also implement a new Invert Cull option in both constraint and
modifier that can be used to aim for faces aligned with the project
axis direction when raycasting both ways.
Reviewers: mont29
Differential Revision: https://developer.blender.org/D3737
Was using 'selected_editable_bases', which used to save a lookup.
This is no longer the case and complicates access from Python
which cant yet easily access Bases.
Now it's possible to disable the lasso effect of the fill color while drawing with a fill color.
This sometimes is required to see the lines and it's the first step to implement a new lasso brush.
Now it's possible to define what material is used in the generated strokes and if the strokes are put in front of the original (default) or keep the original in front.
Before, the generated strokes have been always on top of the original because they were drawn later.
Following the vertice delete menu logic here, where delete needs no verb
and the special case (dissolve here) gets the full verb + noun)
Note: This operator wasn't even listed in the T54646 task. I suspect other
operators may share the same fate.
I'm storing the name of the vertex groups in a gset. This way
we can select vertex groups with the same name across different
objects.
Also this is the last select similar mode that needs porting o/
The crash was caused by BVH traversal stack being overflowed.
That overflow was caused by lots of false-positive intersections
for rays originating on a non-finite location.
Not sure why those rays will be existing in the first place,
this is to be investigated separately.
This commit moves pre-SSE4.1 check to a higher level function
and enables it for all miroarchitectures.
It's too easy to miss at the bottom of the screen, and if the status bar is
collapsed critical messages may not be seen at all. There might be a better
looking solution, but for now this solves the main usability problem.
Seems there is something wrong with ternary operator
and type deduction.
Copying matrix to a variable with cleaner name seems
to be better solution than to force cast to an array.
The option WITH_C11 is gone, and C++ is defaulting to C++11 now,
so guess it's fine to assume we need C11 now.
This is technically what we use anyway, with all the re-definitions
of structs (like when we typedef anonymous struct in a header file
first, and them define it to a proper structure in implementation
file).
That new bpy_extras' node_shader_utils module is remotely based on
existing addons' cycles_shader_compat module. It has some key
differences though:
- It is based on Principled shader, instead of the noodle combination
of half a dozen simpler shaders.
- It does not do any value conversion (like e.g. clamping, which was
only suited for FBX). Any conversion/adaptation is to be done
by each IO add-on.
- It extensively uses accessors to offer:
- Easy read/write of values, hiding all the hairy noodly nodes
(principled shader helps a lot here).
- lazy creation of most nodes on accessing (when generating a
material), which avoids getting unused nodes in final shader.
- We only use Principled BSDF so far though, which means some features
supported by previous system are not yet implemented in new one.
Note that, even though we support 'exporting' side of things, this will
only work for a very specific (and basic) kind of shader. This will have
to be clearly explained in end-user documentation.
Also, that code has had some basic testing, but most certainly needs a
lot more refinement.
As proof-of-concept, OBJ IO script will be updated to use that new
system after that commit.
I had to make the viewport navigation icons a bit smaller in the SVG since
the edges were being clipped off, we only support 16x16 icons currently.
They are a bit blurry because of this.
Move the weight paint drawing to the fragment shader. The shader
uses a texture that uses the U.coba_weight custom color band, or
an internal color band.
In addition to actual weights, the shader has to display two
alert colors: missing vertex group, and zero weight. The zero
weight alert has to be blended with regular weight colors,
so that a single alert vertex surrounded by weighted ones is
still visible.
Reviewers: campbellbarton, fclem
Differential Revision: https://developer.blender.org/D3675
New entry in the Add Object menu.
Opens a file selector and creates a new empty object from the selected image.
Previously more steps were needed to archieve the same.
Differential: https://developer.blender.org/D3708
Reviewer: brecht
This was caused by the object center being selected by the wireframe pass.
The wireframe pass is now only drawn if we search for the nearest surface.
This makes all wire objects (like non-meshes objects) higher priority than
mesh surfaces.
Previously copy and paste was handled within the same function using a mode switch, which is quite ugly in most cases.
This patch separates the function into two and splits up those in even smaller functions to increase maintainability.
Finally one new feature was added: You can copy from disabled fields now. (requested by hjalti)
Reviewers: brecht
Differential Revision: https://developer.blender.org/D3738
* Panels now use single column layout.
* Footage Info was moved into Footage Settings.
* Display settings are now in a popover in the header.
* Graph view shows tracking controls in the header center.
Differential Revision: https://developer.blender.org/D3643
- Use ctrl for de-select since we may want to use shift for extend.
- Use cursor tool by default,
it's agreed lasso select isn't accessible from a shortcut by default.
This commit make the Xray option for the wireframe different from the other
shading mode. This makes it possible to rapidly switch between wireframe +
Xray and Solid mode without Xray.
Xray alpha is also decoupled.
Both variables are duplicated and exposed separately through RNA.
* Proportional pie menu at shift+O.
* Snap pie menu at shift+S.
* Pivot pie menu at comma. Previous comma, ctrl+comma, period
and ctrl+period shortcuts for specific pivot types were removed.
Ref T56881.
This commit includes several performance, stability, and reliability
improvements to cloth collisions.
Most notably:
* The implementation of a new self-collisions system.
* Multithreading of collision detection.
* Implementation of single sided collisions and normal overrides.
* Replacement of the `plNearestPoints` function from Bullet with a
dedicated solution.
Further, this also includes several bug fixes, and algorithmic
improvements.
Reviewed By: brecht
Differential Revision: http://developer.blender.org/D3712
In addition to the original map to surface and Keep Above Surface,
add modes that only affect vertices that are inside or outside
the object. This is inspired by the Limit Distance constraint,
and can be useful for crude collision detection in rigs.
The inside/outside test works based on face normals and may not be
completely reliable near 90 degree or sharper angles in the target.
Reviewers: campbellbarton, mont29
Differential Revision: https://developer.blender.org/D3717
Select minimum of render subdivision levels and 3 for
the initial value of quality. This way we don't force
too much quality for meshes which were not supposed to
be too much quality :)
Need to resize `have_functions` arrays when adding more functions.
Not sure there is more reliable way which will prevent accidents
like this.
Was caused by c47be43674.
Unlike 2.79 I am not using the comparison type to get coplanar planes that are above/below the plane.
That seems arbritary at best, and a bit of a challenge to get it right.
Also, I'm doing some shenanigans to use a single tree to store the face direction and the distance.
Here in my tests it is working fine though.
Now handles are drawn using index buffer instead of duplicating memory
requirement.
Also make use of shader tricks to draw handles antialiased, and respond to
UI scalling.
Make vertex point match edit mesh vertex size.
Note: Not doing worldspace comparison for now. We would need to create new
BM_face_calc_area and BM_face_calc_perimeter equivalent functions for that.
Not sure if it is worth the trouble.
Note: Unlike 2.79 we are not comparing face->mat_nr, but the material itself.
On top og that, if the material slot is empty we are just ignoring this face.
This was because weight paint was using the original obj to show weights.
But the mesh can be deformed by the armature and this is not visible on
the original object.
This makes the Edit Mesh display settings common to all objects. They can
also be set differently per viewport.
Modifying extra data (seams, sharp edges etc...) will no longer set them
automaticaly visible.
Bumping version because we need to force set all extra draw options for
older files.
For onion skin, the cache is set as dirty always because can be too many combinations of overlays and windows and makes impossible to control all changes of dirty flag.
This reduces performance, but it's safer and the onion is disabled while play animation, so the fps value is not affected.
This adds existing behavior from calc_weightpaint_vert_array
that was missing from the new rendering code:
- No selected Vertex Group displays as a solid pink color.
- Zero weight displays as alert color depending on Options.
- Multipaint mode correctly displays collective weight.
In order to properly implement this variety, a data structure
holding all relevant parameters is introduced.
Reviewers: fclem, campbellbarton
Subscribers: jbakker
Differential Revision: https://developer.blender.org/D3722
As the comment states, this is not really great solution, but
is good enough for now. Proper solution needs some more work,
and maybe reconsideration of what is stored where.
I think there are two possible ways to fix that.
1. Make the name a required parameter.
2. Provide a default value.
I choosed option 1 in this fix to be consistent with other .new functions.
Also I think `RNA_def_string` instead of `RNA_def_string_file_path` should be used here. Looks like a copy-paste error.
Reviewers: brecht
Differential Revision: https://developer.blender.org/D3728
Use the 2x spin tool has 2x handles to control normal direction,
dragging either handle backwards now reverses normals.
Previously it was common for the spin result to have normals
flipped the wrong way.
Use the multiply blending mode for the weight paint overlay.
To support the opacity slider, we need a new shader. Otherwise this combination of multiplication and mixing does not seem to be supported by glBlendFunc.
Reviewers: brecht
Differential Revision: https://developer.blender.org/D3727
Before it was only doing this for directly linked objects. This was
initially needed to solve fps issues in some of the shots. Now this
fps drop i can no longer reproduce. Was likely needed prior to
modifiers dependencies "inheriting" visibility from the "parent".
This commit makes it so objects which are linked indirectly to the
scene via collections are properly considered visible (or, rather,
evaluatable) by dependency graph.
Solves missing eyelashes and braids issues with 01_035_A.
The fields currently support a Point source and a two-dimensional
Plane source, but there is no way to create a field that pulls
toward or from a line in space other than using the Texture field
type. This adds a new simple shape option to do that.
The line is aligned along the Z axis so that it works meaningfully
with the Tube and Cone falloff modes.
Reviewers: brecht, mont29, LucaRood
Differential Revision: https://developer.blender.org/D3721
The default compositor node update function sets the need_exec flag on the node
which the Auto Render feature checks, but the custom update function that was
added as part of rB4cf7fc3b3a4d didn't do so.
Therefore, the two custom update functions that were added now also call the
default update function.
I'm not sure why we may want to sample both a sharp and an unsharp edges at the
same time, maybe to see if the selected edges all have the same values?
Either way, implemented as in 2.79. I also believe we may have a faster way to
select all the edges, but let's file this under optimizations to be done later.
I'm not sure why the original implementation was only checking for equal
comparison but I'm doing the same here. It is a one line change if we
want to support LT/GT anyways.
Also "technically" we should compare the angles in the worldspace, since
different scales will result in different angles. Added as a TODO but
honestly I think this is overkill.
I'm using kdtree here but there is nothing preventing us from using a simple
float linked list with a sorting and finding "nearest" equivalents.
At least we are benefitting from bisecting as oppose to the original solution.
Also we need epsilon for the float comparisons.
This lets us do the most common shading switching with one shortcut. We keep
alt+Z and shift+Z for quickly toggling to lookdev and rendered mode and back,
it's debatable which settings deserve a dedicated shortcut like this.
The downside is that switching X-ray is a little slower, and that there is
some risk of accidentally going to lookdev or rendered mode which can be slow
to cancel.
We now treat Xray as being the mode where Limit selection to visible is off.
If Xray is OFF, Limit selection to visible is considered ON.
To allow 'see through wires' with solid shading (not Xray shading) we still
draw solid shading if Xray is ON with Xray Alpha set to 1.0.
This is using the existing engine (workbench forward) with 0.0 xray_alpha
and forcing wireframes on all objects.
There is no workflow/shortcut changes in this commit.
Normally the time can be read from DEG_get_ctime(depsgraph), but this is a
bit more forgiving for e.g. addons that don't care too much about the details
of the COW depsgraph.
Added propagation of displacement to a higher levels.
Has the same limitation as reshape from object, which makes
grids somewhat choppy due to linear interpolation nature.
This is to be addressed next.
This brings basic implementation of displacement propagation
to a higher levels. Currently does linear interpolation between
grid points at which reshape happened. It makes results a bit
choppy, proper solution would be to use some interpolation
weights from the limit patch.
The image I get is a bit too dark, which is the same I get in the viewport
itself when there is no Display Device. So I believe for cases like this
we need to have color management on top of the buffer.
Also, on EEVEE it looks like it needs to clear some extra buffers. You can see
that, by rotating the camera view around.
That said, this is the first step to bring back fun addons
that use external offscreen buffers.
Note: When using gpu offscreen with POST_VIEW (as oppose to POST_PIXEL)
I get a crash with DST having 0xFF..
This implementation is a bit hacky but match cycles pretty close.
If pixel size is not enabled, it will use the geom shader to
compute distances between vertices. This will have a cost.
Implementation is a bit hacky in gpu_codegen to make the geom shader works
in an optional manner.
Makes it so smooth brush works properly, without causing grids
to become disconnected from each other.
This need to optimize the code for brush, to only average edges
and vertices which are adjacent to modified faces.
This information is stored for each non-loose edge.
For each of such edge we store:
- List of CCG faces it is adjacent to.
This way we can easily check whether it is adjacent to
any face which is tagged for update or so.
- List of boundary elements from adjacent grids.
This allows to traverse along the edge and average all
adjacent grids.
The main goal of this patch is to cleanup the interface of every modifier. More specifically the interface of modifiers should be DerivedMesh-free.
Internally some modifiers still use DerivedMesh. However I think it is better when the wrappers are in the modifiers so that higher level functions can use the simplified interface.
This patch removes the applyModifier_DM and applyModifierEM_DM functions. In a previous patch (rB3614d9d) the other functions that used DerivedMesh have been removed.
Reviewers: brecht
Since shape keys are stored as raw floating point data, this
unfortunately requires changes to all code that works with it.
An additional complication is that bezier and nurbs control
points have different entry size, and can be mixed in the same
object (and hence shape key buffer).
Shape key entries are changed from:
bezier: float v1[3], v2[3], v3[3], tilt, pad, pad;
nurbs: float vec[3], tilt;
To:
bezier: float v1[3], v2[3], v3[3], tilt, radius, pad;
nurbs: float vec[3], tilt, radius, pad;
The official shape key element size is changed to 3 floats,
with 4 elements for bezier nodes, and 2 for nurbs. This also
means that the element count is not equal to the vertex count
anymore.
While searching for all curve Shape Key code, I also found that
BKE_curve_transform_ex and BKE_curve_translate were broken. This
can be seen by trying to change the Origin of a Curve with keys.
Reviewers: campbellbarton, sergey
Differential Revision: https://developer.blender.org/D3676
Seems like GLEW_ARB_texture_float is not defined in core profile on OSX
even if float textures are part of the 3.3 core spec.
So removing uneeded backup cases.
Most other software expects to read indexed vertex colors, so write indices
along with the colors as we already do for UVs.
Differential Revision: https://developer.blender.org/D3704
Previously it was possible to have geometry component to
tag batch for DIRTY_ALL and shading to tag with SHADING_UPDATE.
Now there is a relation between uber eval and shading, which
solves this issue.
The idea of those flags is to avoid evaluation of operations
which are not needed to bring visible objects to an up to date
state.
Previously, dependency graph attempted to do combine those
into an ID level flag. In practice it proved to be rather
tricky, since there could be dependency cycles on ID level
which will not exist on component level.
This allows to force duplicated object to be fully evaluated for
display/draw.
Previously only transform component of duplicated object was
forced to become evaluated.
Need to ensure objects from collection which was built but
is became visible in the new "context" are poked for re-built.
This should be rather cheap, since this only will update
their visibility flag.
Can not rely on visibility flush here, since there is no
relations between collection and its objects.
Previous code would crash on whole lot of accessors in case current item
was not a real dupli instance.
And code was missing access to crucial dupli (world) matrix! Pretty
useless without that.
Also reordered a bit members in here, let's try to keep a bit of logic...
- Add Arc-Inner-Factor, to increase the inner arc radius from 0
(show as a disk).
- When showing an angle value, show the angle-end line thicker
(since thats whats being adjusted).
- Remove offset used by arc drawing which caused aliasing artifacts.
Terms get/set don't make much sense when casting values.
Name macros so the conversion is obvious,
use common prefix for easier completion.
- GET_INT_FROM_POINTER -> POINTER_AS_INT
- SET_INT_IN_POINTER -> POINTER_FROM_INT
- GET_UINT_FROM_POINTER -> POINTER_AS_UINT
- SET_UINT_IN_POINTER -> POINTER_FROM_UINT
Note: I had to add an epsilon on top of the threshould for SIMVERT_NORMAL.
Otherwise I was getting differences such as 0.000000something when comparing
supposed-to-be-identical normals.
The way I see it, the Threshold option is a user feature, where users can
control more or less what they want selected. While the epsilon is a
non-negotiable requirement for our float comparison here.
This includes support for:
* SIMVERT_NORMAL
* SIMVERT_FACE
* SIMVERT_EDGE
Not included and currently not supported/disabled:
* SIMVERT_VGROUP
* SIMEDGE_*
* SIMFACE_*
While we are working on this, we prevent users from using the non-ported modes.
Note: the bmo_similar.c file is still around, to be removed in the near future.
Everyone: Please fell free to jump in and help tackling the missing modes.
For details on the implementation discussion:
https://developer.blender.org/D3674
Also minor changes:
- Remove unused headers.
- rename SimpleExprParseState -> ExprParseState
- rename max_ops -> ops_count_alloc
Was misleading since maximums are often limits which can't be exceeded.
Simple isn't a good prefix for library names since
lots of unrelated modules could be called 'simple'.
Include 'py' in module name since this is a subset of Python,
one of the main motivations for this is to be Python like/compatible.
- Pass in the snap distance
(to avoid comparisons in the multi-object version).
- Loop directly over BMLoop's (without using the iterator).
- Use squared distance instead of manhattan.
The thing is that the quality is something a bit subjective regarding this
option value.
A more precise trace will have more noise so quality is also diminished in
a way. I believe that using "Precision" is more correct than "Quality" in
this case.
Also tested the straighten option and it is working-ish.
That said, I think straighten should take all the meshes vertices to determine
the line you want to use as reference. However we would need a different way to
determine the first and last uvs to use as reference for the line.
The first time setup screen only has the interaction preset currently, some
more work is needed to be able to set e.g. the language or compute device
here as in the mockups.
The splash screen stayed the same for now, to make room for the templates
most of the links are now in the Help menu. If there are no recent files yet
the links still show.
The splash screen buttons implementation was fully moved to Python, in the
WM_MT_splash menu.
These can now be acessed from the File > New, Ctrl+N, or the splash screen.
Since these are application templates, users can save a separate startup.blend
for each. User preferences are shared between these templates though.
This also fixes some issues in the default startup.blend (triangulated cube..).
Differential Revision: https://developer.blender.org/D3690
The goal here is to make app templates usable for default templates
that we can ship with Blender. These only have a custom startup.blend
currently and so are quite limited compared to app templates that fully
customize Blender.
But still it seems like the same kind of concept where we should be
sharing the code and UI. It is useful to be able to save a startup.blend
per template, and I can imagine some scripting being useful in the future
as well.
Changes made:
* File > New and Ctrl+N now list the templates, replacing a separate
Application Templates menu that was not as easy to discover.
* File menu now shows name of active template above Save Startup File
and Load Factory Settings to indicate these are saved/loaded per
template.
* The "Default" template was renamed to "General".
* Workspaces can now be added from any of the template startup.blend
files when clicking the (+) button in the topbar.
* User preferences are now fully shared between app templates, unless
the template includes a custom userpref.blend. I think this will be
useful in general, not all app templates need their own keymaps for
example.
* Previously Save User Preferences would save the current app template
and then Blender would start using that template by default. I've
disabled this, to me it seems it was unintentional, or at least not
clear at all that saving user preferences also makes the current
Differential Revision: https://developer.blender.org/D3690
This makes it so coordinates and normals for CCG are calculated
with mutires displacement taken into account. This solves issues
with multires displacement being lost when entering sculpt mode.
The missing part is averaging of normals along grid boundaries.
But even then sculpting shows decent results.
The plan to solve that would be to introduce function to stitch
grids, which can also be used by Smooth brush which requires
this.
This happens on NVidia GPUs, using more textures than the maximum allowed
by the gl will NOT trigger a linking issue (maybe because of bindless
texture implementation?).
So in this case we manually count the number of samplers per shader stage
and compare it against the GL limit. We discard the shader if the sampler
count is too high. This shows the user something is wrong with the shader.
Recently @sergey found that hard-coding evaluation of certain very
common driver expressions without calling the Python interpreter
produces a 30-40% performance improvement. Since hard-coding is
obviously not suitable for production, I implemented a proper
parser and interpreter for simple arithmetic expressions in C.
The evaluator supports +, -, *, /, (), ==, !=, <, <=, >, >=,
and, or, not, ternary if; driver variables, frame, pi, True, False,
and a subset of standard math functions that seem most useful.
Booleans are represented as numbers, since within the supported
operation set it seems to be impossible to distinguish True/False
from 1.0/0.0. Boolean operations properly implement lazy evaluation
with jumps, and comparisons support chaining like 'a < b < c...'.
Expressions are parsed into a very simple stack machine program
that can then be safely evaluated in multiple threads.
Reviewers: sergey, campbellbarton
Differential Revision: https://developer.blender.org/D3698
This partially solves ASAN report about unfreed memory. There is still
something in the report, need to have a closer look with debug version
of OpenEXE library.
- Now the spin tool has a persistent gizmo.
- Uses scene orientation, with additional view orientation.
- Uses the cursor center, ignoring the pivot since the
selection center is rarely useful.
- Disable most of the redo gizmo's for now since they overlap,
only allow adjusting the angle.
Note: mixing new action with adjusting previous is confusing,
we'll want to have design guidelines regarding this.
While building the AVX kernel, util_avxf.h/avxb.h were using some AVX2 intrinsics,
these were never called, so it wasn't a run-time issue, but the intrinsics headers
on centos excluded the AVX2 prototypes when building the AVX kernel causing build errors.
This commit cleans up the improper usage of the AVX2 intrinsics and provides AVX
fallback implementations for future use.
Differential Revision: https://developer.blender.org/D3696
ffi stubbornly wants to put libs in lib64 even when you tell it not to on some linux distributions.
patch based on sed fix the gentoo guys did [1]
[1] https://bugs.gentoo.org/462814
This isn't really possible to do the shuffle which was attempted to do.
While it's possible to achieve expected behavior, the function needs to
be rewritten. Since it's not used anyway, it's simpler to remove it for
now.
Fix T56789: There was issue with certain driver with glGenerateMipmap and
GPU_DEPTH_COMPONENT24.
In this case we just create a complete texture with mipmaps manually
without downsampling / initializing the data.
This reorganizes the cloth UI, and changes some of the behaviour to be
more reasonable.
Changes included here:
* Reorganized cloth panels
* Improved some tooltips
* Removed `vel_damping` option
* Removed cloth pinning checkbox
* Removed stiffness scaling checkbox
* Separated shrinking from sewing
* Separated self collisions from object collisions
Reviewed By: brecht
Differential Revision: http://developer.blender.org/D3691
Avoids invisible objects from being considered visible when they
are used as driver variables.
If those cases are actually coming from a visible object, then
deg_graph_build_flush_visibility() will ensure visibility is
properly flushed there.
Allows to go to sculpt mode, do brush strokes, get out of sculpt mode
and have deformation preserved.
The issues currently is that the current implementation of CCG
storage is created from the limit surface, without displacement
taken into account. It is trivial to get displaced coordinates,
but it is more tricky to get displaced normals. This is something
to be solved next.
Another limitation is that this only works for sculpting at a maximal
multires level. There is code to be done to support propagation
of displacement onto a higher levels.
The function is supposed to be called for original object.
Draw manager abuses this a bit, will solve later by moving
PBVH (re)creation to dependency graph.
At the time being, stop adding object evaluation to draw
manager, this is really where it does not belong to.
Flat shaded grids are now rendered as a long triangle strip with
degenerate triangles.
Smooth shaded grids are not changed.
Also add back fast navigate. The only difference with 2.79 is that fast
navigate + flat shading will show slitly "incorrect" smooth face. But that's too
much effort to fix for what it is.
Since we are not linking against OpenCV ourselves, that generated
linking errors later on (while building OSL e.g.).
Those 'open' libs link against way too many other libs... :/
Thanks to @intrah for initial report (T56785), and @LazyDodo for
suggested solution.
That bug probably did not affect 2.7x, only 2.8 with COW copying IDs in
threads... But root of the issue is that underlying boost i18n lib does
not support well multi-threaded access. So simply forbid any translation
from non-main thread. This *may* be an annoying limit at some point, but
doubt it will be any issue currently.
That pointer can be NULL, RNA default string handling does not support
that. (that whole uv_layer prop is quite nasty actually, since it does
not own that string, always borrows it from some other data :((( ).
Rebuilding depsgraph is not enough, with COW we also need to ensure COW
copies get updated accordingly.
Had to tweak the generic update system here, since it was always passed
a NULL pointer for the callback arg, this should not change existing
behavior (besides crash fixing ;) )...
Failed as in did not allocate due to possibly weight cutoff.
Tryign to allocated Extra storage for closure in such situation
will consfuse Cycles and cause crashes later one due to obscure
values in ShaderData.
Consequences of new requirement to use named keywords parameters for our
RNA API... Hopefully fixed all other cases in that file as well, but
guess we'll find more of those in comming weeks. :|
Obvious bug in recent CName cleanup commit, while BGE library
was indeed mentioned on that line it was to put Bullet libraries
after all the other libraries.
One day we should really switch to a CMake dependency graph to
take care of library dependencies.
It's more convenient to keep version patching in the same place,
this also splits out some function calls from version patching
and supports updating UserDef structs besides the 'U'l global.
Attempts to substitude CCGDM with an OpenSubdiv based structure
which has less abstraction levels. The missing part in this
substitude is a face pointers which old CCGDM/multires code was
using to stitch faces (averaging boundaries).
Another curial bit missing: "reshaping" of multires CD_MDISPS
to the state of new PBVH grids.
The new code is only available when OpenSubdiv modifier is
enabled (WITH_OPENSUBDIV_MODIFIER=ON) and with debug value of
128. This is so this WIP code is not interfering with current
production machines in the studio.
Reviewers: brecht
Reviewed By: brecht
Differential Revision: https://developer.blender.org/D3685
Didn't realize the index buffer is stored once in a BVH
and same pointer is reused. Surprisingly, simple files
were fixed with the previous fix.
Now disabled the optimization all together, and it was
simpler to just completely remove all residue of the
code. It is likely to be a different implementation
anyway, so no need to try to keep code in a semi-broken
state.
Nodes can have different number of grids, so can not so simply
re-use index buffer across nodes. For now allow re-using buffer
if number of grids matches.
The issue is, number of grids is probably almost never matches,
so in order to have this optimization working need more tricks.
Maybe we can "instance" index buffers?
* WITH_SYSTEM_OPENJPEG is removed and is now always on, this was already
the case for macOS and Windows.
* This should not break existing Linx builds. If there is no new enough
OpenJPEG installed, CMake will no find libopenjp2 and WITH_IMAGE_OPENJPEG
will be disabled.
* install_deps.sh was updated with new package names, since distributions
put this version in a new package.
Differential Revision: https://developer.blender.org/D3663
Mainly this is following Linux to build own xml2/lzma/ssl/sqlite and linking
them all statically. This ensures the Python ssl module uses a recent openssl
version rather than a very old one shipped with macOS.
Was using UI_BLOCK_LOOP to control draw style,
this meant we couldn't use popup theme colors for cases
where it the interface has the same purpose as a popup but happens
not to use this flag.
As mentioned in d81aeb60fe the alignment for multiple text boxes should all
respect the same overall padding.
Vertical alignment is fully implemented now.
During drawing, the depsgrah was tagged to update and this produced a full copy of the datablock. This tag was done in order to get the right data in drawing engine, but this added a great overhead while drawing and the response of the pen was not good.
Now, the depsgraph is not tagged and the drawing engine uses the original copy data of the buffer datablock. This is not a problem because only can draw in one window at time.
Now we can create new base color, roughness, metallic, specular, normal,
bump and displacement images, and linked them to the appropriate socket.
Also fixes image nodes inside groups not being visible.
Differential Revision: https://developer.blender.org/D3679
To follow Blender standards, the name of the new primitive stroke must be different of blank object.
Also changed the default orientation of Suzanne 2D to use the same as other objects (not aligned by default)
In some cases we need to use this array afterwards,
so this gives control over which objects are used for picking.
Also use an index argument as return argument
so callers that need to know the index in the array
don't need to calculate it afterwards.
- Poly build now uses a new gizmo for pre-selection
which has the same behavior as loop-cut.
This replaces hack where mouse-move set the active element
which was no longer working properly because of missing
depsgraph updates.
- Multi-object support for poly-build.
- Support for deformed cage.
- Fix error where changing active object wasn't properly
refreshing the preselect gizmo (for loopcut too).
Currently holding Alt to select non-boundary element's isn't working.
There was an issue caused by Antialiasing being done after DoF. Move TAA
after DOF and Motion Blur.
Also certain pixel with lower CoC would be spread all over the background
because the neighbooring pixel have higher CoC. So we need to apply some
bilateral filtering when downsampling. Currently we limit the influence of
neighbor pixels with a CoC inside the range [MaxCoC-2, MaxCoC].
If something is a list of data, it is to be called list, and data
is to be called data. No need to call list a data and data a weird
two letter abbreviation.
Clarity is our friend!
This is something what we need to know quite often from various places.
Added it as a cached value in Subdiv itself, so it can be queried easily
from any area.
Shouldn't be a problem from memory usage point of view, it's 4MB per
1M faces coarse mesh. This is very low percentage of mesh itself, and
even lower percentage of highres subdivided mesh.
When using the 'normal' orientation, the normal would be ignored
if the plane couldn't be calculated.
Now use only the normal if the plane is zero length,
this was already done, just not in all cases.
With the removal of blender internal, the texture preview had to be
rewritten. Now we evaluate and write the texture directly to the
preview buffer instead of going through the renderer.
Differential Revision: https://developer.blender.org/D3670
D3375 by @Al
I did a few changes before the commit:
* Initialize flot arrays with {0} instead of memset(foo, 0, sizeof(foo)).
* Use add_v4_v4 instead of for loop.
* Rename uv_map_rotation_matrix_w_offset > uv_map_rotation_matrix_ex.
bjects: orthographic support for UV project
Nothing really interesting, just starting laying down API which
seems to be a decent substitute to CCGDM, without requiring too
much work be done in sculpting area.
Tested with Debian Testing, might need some adjustements for other
distributions...
Also removed last patches we used here, we shall not need any anymore!
In a real world it is very weird to disable AA on a mask,
it will give ugly looking result. For some fast preview
passes (like in the node preview) the system can decide
to disable AA without asking user to do anything.
One thing we can consider doing is to remove Feather
option as well. If real compo becomes measurably slower
in cases when mask has no real feather, we can disable
feather internally, without user input. Disabling
feather in the interface is like making things faster
but giving a wrong result, which doesn't sound that
helpful either.
Reviewers: brecht
Reviewed By: brecht
Subscribers: hype, sebastian_k
Differential Revision: https://developer.blender.org/D3677
The pie menus were a legacy of old grease pencil and now need a full redesign or maybe a new add-on.
While we decide the way to go, the pie menus are disabled.
Displaying the labels tip immediately feels too intrusive,
make this work more like regular tooltips, displaying more quickly.
Tooltips can now uses multiple passes, each pass with it's own delay
for the next pass to show.
- Only show label-tips when tools are icon-only.
- Don't show shortcuts in label-tips.
- Position both tool label & full tips around the button bounds.
Maybe it's still early to set the new drawing api for python.
But joining these two modules is an initial step.
```
>>> gpu.
matrix
select
types
```
```
>>> gpu.types.GPU
Batch(
OffScreen(
VertBuf(
VertFormat(
```
The creation of a new offscreen object is now done by the `GPUOffscreen.__new__` method.
Reviewers: campbellbarton, dfelinto
Reviewed By: campbellbarton, dfelinto
Tags: #bf_blender_2.8
Differential Revision: https://developer.blender.org/D3667
Use kdtree for doubles (old standing TODO for this operator).
Small changes from reviewer (Dalai Felinto):
* Code style ({ is in a new line only if it is a two-line if).
* Skip objetcs loops when we know for sure nothing is selected (or all is)
https://developer.blender.org/D3441
I don't even know why this operator was ever made to work in object mode.
That said, since it does, we should have different options for it
(or rather, always do all faces for it).
Do note that we force showing the face dot if we are in face select mode
but faces and edges overlays are disable to not loose the selected faces
entirely.
The issue there was that number of layers did not include normals,
while element size counts bytes used by normals. This sounds very
fragile and dangerous to work further. Also, one value can easily
be delivered from another, so it is redundancy going on here.
Possible difference now is that multires subdivision will copy
normals to a higher levels. Shouldn't be big of a problem, since
leaving old normals and updating coordinates is not correct either.
The original code was already making a distinction between lines in the last
text box and all lines. However I removed that bit since when I tested the
values were the same (I tested with a single text box).
Bringing this distinction back.
Not addressed here: All boxes should respect the alignment. Which at the moment
they don't seem to fully do.
They way Blender handles vertical alignment is very buggy:
- Top-Base: It works perfectly.
- Bottom: It is actually bottom-baseline,
and it fails when line size is != 1.0 when working with text boxes.
- Top: Poorly implemented, it should use font's ascent
(recommended distance from baseline),
so it has room for accents,
but it's not one line distance far from the origin (as it is now).
- Center: Poorly implemented.
This is tricky since there is no silver bullet.
To clear this situation I created a new option (Bottom-Baseline),
and addressed the issues above.
I'm getting the ascent and descent from freetype2,
and use this for padding above/below the text.
Also for vertically centering the text.
Changes from reviewer (Dalai Felinto):
* pep8.
* Skip meshes that come from libraries.
* `Copy Mirrored UV coords > Copy Mirrored UV Coords`.
* Remove mesh(es) from warnings, report mesh or meshes based on number.
https://developer.blender.org/D3529
Changes from Reviewer (Dalai Felinto):
* MEM_SAFE_FREE > MEM_freeN.
* Skip loop if sync selection and no face selected.
https://developer.blender.org/D3415
Changes from reviewer (Dalai Felinto):
* MEM_SAFE_FREE > MEM_freeN.
* Skip loop if sync selection and no edge selected.
https://developer.blender.org/D3417
Annotations are not designed to edit, copy or paste, so the operators must be disabled.
By design annotations can only be added or deleted, but not edited.
Still pending clean the pie menus, but this will be done during UI cleanup.
Testing GLEW_ARB_texture_gather is not sufficient in this case. We need to
test if GL_ARB_texture_gather is defined in the shader, which is always true
on some NVIDIA drivers who does not support it...
So trying to make everything work.
We would need to at least support one more PBVH building
here, trying to squeeze everything into one function will
make it really hard to read and follow.
Simplify library remapping code to handle special collection/object links
in postprocess. Previously base contained the actual object link which
needed special handling in preprocess, now objects are linked through
collection and the base cache can be updated in postprocess.
This was introduced in the original implementation of weightpaint
in 2.8 (20f95de6ba). But this is very shortsighted, we can't assume only one
object will be edited at once, nor should we tag things during drawing.
There is a chance this introduces "bugs". If it does, we then tackle them in the
proper way (usually tagging DEG after operators changing the weight paint data).
I (Dalai) did a few changes before committing:
* Code style (mostly tabs instead of space).
* Skip loop when no vert selected.
* Keeping comment on why always return FINISHED.
Maniphest Tasks: T54643
https://developer.blender.org/D3338
Changes from reviewer (Dalai Felinto):
* Code style (replace tabs with spaces).
* Return OPERATOR_CANCELLED if no a single object get through.
Maniphest Tasks: T54643
https://developer.blender.org/D3392
"Blend from Shape" lists keys from active object and applies to all selected
objects that have keys with a matching name.
Changes from reviewer (Dalai Felinto):
* Code Style.
* Move Object **objects after sanity check to prevent leak when
returning OPERATOR_CANCELLED.
* Skip objects that have no selected vertex.
* Fixed existent comments code-style: Since we are changing the indentation of
these lines, may as well correct this as well.
Differential Revision: https://developer.blender.org/D3656
Since D3284 was inactive for a long time, I figured I could finish this.
This revision also gives warning when there are no selected faces or when
selected faces are invalid.
Changes from reviewer (Dalai Felinto) :
* Code style
* Fix checking for ngons (BM_ITER_MESH is a for loop, you need to break from it
before continuing the object iteration loop).
Differential Revision: https://developer.blender.org/D3659
This implements angular bending springs for cloth simulation. This also
adds shearing springs for n-gons.
This angular spring implementation does not include Jacobian matrices,
as the springs can exist between polygons of different vertex counts,
rendering their relationships asymmetrical, and thus impossible to solve
with the current implementation. This means that the bending component
is solved explicitly. However, this is usually not a big problem, as
bending springs contribute less to instability than structural springs.
The the old linear bending model can still be used, and is the default for
existing files, to keep compatibility. However, the new angular bending
model is the default for any new simulation.
This commit makes small breaking changes, in that shearing springs are
now created on n-gons (also in linear bending mode), while n-gons were
previously ignored.
Reviewed By: brecht
Differential Revision: http://developer.blender.org/D3662
This separates cloth stiffness and damping forces into tension,
compression, and shearing components, allowing more control over the
cloth behaviour.
This also adds a bending model selector (although the new bending model
itself is not implemented in this commit). This is because some of the
features implemented here only make sense within the new bending model,
while the old model is kept for compatibility.
This commit makes non-breaking changes, and thus maintains full
compatibility with existing simulations.
Reviewed By: brecht
Differential Revision: http://developer.blender.org/D3655
Objects in edit mode now behave as if they were joined.
Changes from reviewer (Dalai Felinto): code style (tabs, spaces, ...), missing MEM_freeN(objects);
https://developer.blender.org/D3648
MASS unit was already implemented for the C api. Only making sure it is
accessible in the python api. Also added 'CAMERA' to the documentation as a valid option.
I'm using a different shading group for the active text box and the others.
This way I can assign different colors to them.
The alternative would be to create a new `shgroup_dynlines_dashed_flat_color`,
but I find this overkill for such a simple use case.
The statement that PBVH needs to keep track of CCGDM is wrong, PBVH itself
does not care about CCGDM at all, and it's weird for it to carry on this
beast so others can access.
Even more, nobody will actually caring about CCGDM itself, all the usages
were checking whether there is CCGDM or not. This is as good as simply
checking PBVH type.
Tested with an original report T53551 and everything is still stable.
WITH_ASSERT_ABORT was not disabled for release builds. In most cases asserts
are disabled in release builds, but not always.
This also changes the buildbot to use blender_release.cmake instead of
blender_full.cmake, the only effective difference should be WITH_ASSERT_ABORT.
The preset and decorator icons were updated to be monochrome and draw in the
same color as text. Other icons are unchanged, having them as separate icon IDs
prepares for an artist to make them.
When drawing in surface mode if the stroke z-depth was not valid, the stroke was created, but it was not visible because location was something illogical.
Now, if the z-depth cannot be calculated, the stroke is calculated as it was done in other modes.
In the workspace properties a mode can now be configured that is
automatically enabled when switching to the workspace.
This is a test to validate how well it works. The weak point is
that if you don't have an appropriate object already select it will
not switch modes.
See T56475.
The assembler template was backing up and restoring ebx, which is
fair enough. However, this did not prevent compiler for putting
result variables to ebx. This was causing data corruption.
In order to prevent this easiest solution is to list ebx in clobbers
for the assembly.
This commit adds a new armature modifier for grease pencil. The deformations are done reusing the mesh deform routines.
There is also a new operator in weight paint mode to help the artist to generate weights base on armatures. This operator is required because 2D animation workflow is not equal to meshes when parent an object to armatures.
In the drawing engine has been added the option to handle the Fade object parameter used in armatures to see the strokes while move the bones.
When rename bones, all related data of grease pencil is renamed too. This not only affect new armature code, but also layers parented and hook modifiers.
Thanks @aligorith for his review and help.
Now it's possible to add the weight of the current selected vertex group to any new stroke created.
This is very handy when add drawings after the weight paint was done and it will be required with Armatures.
This small offset helps to keep the stroke over the surface and avoid the stoke is "inside" the face of the surface.
We could add this as a parameter in the UI, but after doing a lot of test, the valid values are very limited and don't worth the change, so a hardcoded value works fine.
There is chance that on a system with both versions installed this
*might* cause some issues. Such system will be pain to support out
of the box anyway.
This change allows to use precompiled libraries without extra
modifications in the config.
- Foe some reason CMake's platform and processor are not intialized there.
- Need to set variables in cache, otherwise they are not visible in the
actual CMake files.
The script clearly states:
This makes the presumption that you are include al.h like
#include "al.h"
and not
#include <AL/al.h>
The reason for this is that the latter is not entirely portable.
Windows/Creative Labs does not by default put their headers in AL/ and
OS X uses the convention <OpenAL/al.h>.
This commit makes default precompiled OpenAL to be properly detected
and also removes hack on MacOS which was finding the OpenAL package but
then was overwriting include directory.
Note, that new audaspace in 2.8 is using expected #include <al.h>.
This is an initial implementation of BVH8 optimization structure
and packated triangle intersection. The aim is to get faster ray
to scene intersection checks.
Scene BVH4 BVH8
barbershop_interior 10:24.94 10:10.74
bmw27 02:41.25 02:38.83
classroom 08:16.49 07:56.15
fishy_cat 04:24.56 04:17.29
koro 06:03.06 06:01.45
pavillon_barcelona 09:21.26 09:02.98
victor 23:39.65 22:53.71
As memory goes, peak usage raises by about 4.7% in a complex
scenes.
Note that BVH8 is disabled when using OSL, this is because OSL
kernel does not get per-microarchitecture optimizations and
hence always considers BVH3 is used.
Original BVH8 patch from Anton Gavrikov.
Batched triangles intersection from Victoria Zhislina.
Extra work and tests and fixes from Maxym Dmytrychenko.
- Added icon for To Sphere
- Added icon for Shear
- Added icons for adding mesh objects
- Added icon for Curve Draw
- Add Curve Extrude to Cursor icon
- Tweak Curve Draw icon
- Simplified Hair Cut icon. Was hard to read
- Tweaks to Hair Puff and Smooth icons
- Added icon for Extrude Along Normals
- Updated Extrude Individual icon to become clearer and more consistent
with "Extrude Along Normals". Now it's easy to see the difference.
- Rip Edge and Rip Region icon tweaks
Note, many icons are regenerated in this commit which
weren't intended to be changed, in some cases this looks to be caused
by material color. Generating again doesn't modify so it
shouldn't be changing every time in future.
There is system-wide libz development package installed by default,
needed for some other dependencies. This patch ensures Python will
use our own self-compiled Zlib.
Misleading name since it's between 0..1.
Use as a keyword argument to prepare for keyword only args.
Also document that leaving unset has special behavior.
If the brush had assigned a color not present in the object material slots, the fill crashed.
Now, the material is added to the object slot before using it.
This involved getting SSL compiled from sources first, ensuring
it is a static library placement independent code. Configuration
is based on what Debian is using. CFlags required to have own
configuration file, which i didn't find a better place that next
to the corresponding CMake file.
It is OpenSSL btw.
It is set to Python via --with-openssl= configuration argument.
This works fine in a clean chroot, but having libssl-dev installed
might make Python to prefer system wide library, This was worked
around by using libssl_pic.a name for the library and modifying
setup.py. Would be cool to ensure system wide libraries are not
a problem, but official release builder is safe against this,
since it will catch possible non-static dependencies.
There is also a new map file which shadows bunch of Python
symbols. Without this Python's shared libraries might bring
conflicting symbols to Blender namespace at runtime.
Hopefully this doesn't break other platforms.
The operator allows to copy a complete layer with all frames or only active frame to a new object.
Can be found in edit specials menu (W key) or in Layers specials menu (last button near layer list).
That is kind of mandatory with complex rigged-character groups, with
hundreds of helper objects, and a few useful ones being hidden on
specific layers (like e.g. the main rig...).
It is especially critical point with static override, which won't allow
to move objects between collections and such (that would be a nightmare
to implement and handle).
Note that this is rather basic implementation, we could go further and
move all objects in all layers they are 'active', but that would
probably be overkill.
Reviewers: brecht
Subscribers: brecht
Differential Revision: https://developer.blender.org/D3649
- Add orientation option (defaults to local, as 2.7x does)
can optionally use global, cursor, view... etc.
- Fix typo which caused select flush to fail.
- Fix for instanced objects (was only checking one instance).
- Only tag for changes if a change is made.
- Skip meshes with all vertices selected.
Before, the weight data array was created always, but now only is added when a weight value is assigned.
This change was suggested by algorithm, and both agreed it was good idea.
You cannot immediately add parent's library to newly generated hidden
child collection, since it would allow to get several of those hidden
collections with same name/library. That is strictly forbidden!
So rather loop again on collections after all hidden ones have been
generated, and assign children's library from parent one then.
there is an issue with objects destructing in a non deterministic way during process shutdown, temporary work around this until osl has a fix in place.
Only the upper triangle of the block matrix is stored, thus when
executing operations on the lower triangle, each block must be
transposed. This transposition was not ocurring in the matrix-vector
multiplication function, which is fixed by this commit.
Reviewed By: brecht
Differential Revision: http://developer.blender.org/D3619
With small tiles, the repeated allocations on GPUs can actually slow down the denoising quite a lot.
Allocating the buffer just once reduces rendertime for the default cube with 16x16 tiles and denoising on a mobile 1050 from 22.7sec to 14.0sec.
After some artist feedback the material selection was not clear.
Now, the material can be selected in the top bar or in the properties panel.
1) If the material is selected in properties panel, all Brushes except pinned will be assigned to this material.
2) If the material is selected in the brush, the properties panel is updated to set the active material.
Added a new Pin icon to keep locked the material to one brush
As the polygon drawing is handled using a buffer that is converted to stroke inmediately, the drawing engine was not drawing the buffer stroke because it was empty, and the stoke was not visible becaus eit was in fast drawing mode.
Now there is a special flag to indicate the polygon mode is enabled and force the drawing engine to draw strokes and disable fast drawing.
* Remove support for diffuse color in the pbvh buffers.
* Upload raw data to GPU.
* Only draw nodes that have mask data when drawing the overlay.
This should fix T56466
Now that this operator is working properly (in world space axis), it can
be ported for multi object support.
The issue of only running on redo is still present though, to be investigated
later.
Not, I tried using `dist_signed_squared_to_plane_v3` but profiling showed that
it is 50% slower than using regular `mul_v3_m4v3` for the verts.
I managed to get this number closer when manually inlining all the functions
called by `dist_signed_squared_to_plane_v3`. But still `mul_v3_m4v3` was better
and it makes the code simpler to understand.
Also I'm changing the default mode to positive, no idea why it was negative as
default in the first place.
Last but not least, the operator only works well on redo. This was a problem
before, not introduced by this patch.
The lock to axis is only used by grease pencil object and can produce weird results in annotations.
This lock to axis function was kept by error when the annotation code was splitted from general grease pencil code.
Was happenign for following cases:
- Deep hierarchy of non-restircted collections, which has grand-grand
parent restricted.
- Collections which are constructed from invisible object.
Available in RGB Curve node in the compositor and as modifier in the
sequencer. I reshuffled the values of the enum. But a the first commit
is just 1 day old I think that the order is more important than the file
compatibility.
While the crash is in 2.8, it's possible undo operates on data
which isn't only owned by the current scene (any object for eg).
Thanks to @mont29 for suggesting the fix.
* Move Add to Quick Favorites before Assign Shortcut, as it is more often
that we add items to favorites, than changing shortcuts.
* Move Header menu last. In some cases the Online Manual for that item
would appear after the header menu.
* No icon for "Remove from Quick Favorites", matches Remove Shortcut
Now wireframe does update in sculpt mode using the sculpt mesh VBOs.
The only thing that does not work is simplified wireframe (the wireframe
slider) when the mesh is shaded flat. In this case all edges are shown.
The title says it all actually, the idea is to speedup the following case:
- Visible duplicator of a restricted collection (reported as T56512),
One of the questionable change is that none of the view layer bases is
ignored now. This ensures corresponding objects will have copy-on-write
component evaluated, making it possible to access those pointers. The
evaluation of those objects is skipped.
Reviewers: brecht
Differential Revision: https://developer.blender.org/D3641
For this we need to add a bias depending on the viewing angle.
But increasing the hardness of the test make float precision issues in
the mesh transformation more prominent (actual geometry is far below the
surface). So to solve this issue we use a more subdivided grid mesh
8x8 quads instead of 1 triangle.
Film-like curves for the RGB Curve node (Compositor) and Curve Modifier
(Sequencer)
Film-like curves originated from Adobe.
"It’s an RGB curve where the tone curve is applied on the largest and smallest value, and then the middle value is adapted to keep a constant hue as defined by RGB-HSL/HSV. In terms of look and saturation increase it’s very similar to a pure RGB curve, more so than a HSL-L curve or HSV-V curve, but some color shift problems are avoided."
Other tools like Natron, Krita and RawTherapee have implemented this curve tone.
Reviewers: brecht, campbellbarton
Reviewed By: brecht
Tags: #compositing, #video_sequencer
Differential Revision: https://developer.blender.org/D3638
You cannot store ID (or any other data) pointers accross undo’s/redo’s, those
are reading .blend file and hence invalidating all pointers!
Not that happy with this fix, code is rather convoluted and not elegant
at all, but cannot think of a better solution, so will do for now.
Also found and fixed another 'str ghash used for int keys' case...
Basically just concatenates ID's name (including its IDtype code) and
that library's name, if any. This must give unique string in a given
Main database, suitable for GHash keys e.g.
- Add support for key_modifiers, so grease pencil gets "D".
- Assign number keys for unmapped items
This means all tools get keyboard access,
use number/numpad to avoid confusion with other keymap items
which directly activate the tool.
Use debug_value = -1 to disable the use of the filtered depsgraph.
It's still useful to have this for benchmarking + until we're
confident the filtering works safely.
* Don't print on every frame evaluated. This was only needed
earlier to track the progress (and why things were taking so
long - answer, it was the Scene COW issue). Saves 50-100 ms
* Remove the extra calculation of the scene after evaluating
motion paths. This shouldn't be needed now with COW.
Saves about 20-30 ms
This was just randomly leaving all the Particle datablocks in the
filtered graph (and causing and extra/excess pass over the ID's
to get run). Unless we actually need those specially kept for
some reason later, it's better to leave those out for now.
This commit makes the motion path calculations use the
new Depsgraph Filtering API to obtain a more streamlined
copy of the full scene dependency graph, allowing for
faster calculations (as less data needs to be evaluated
for each frame being baked).
For example, in 01_020_A.anim.blend from the Spring production
files, the time needed to calculate paths on several bones
on Autumn went from 39.84 seconds (!) down to 9.90 seconds!
Currently, this works by just replacing the depsgraph instance
passed to the motion path calculation function. This filtered
instance contains just the ID's needed to evaluate the graph
to evaluate a specified target (i.e. the Object owning the pose).
Notes:
* By default, the filtering is not performed unless debug mode 555
is activated. Having a debug switch here allows comparing
performance and disabling it should thing it start crashing.
* It is necessary to pass in the original Scene instance (not the
COW one owned by the filtered depsgraph), otherwise changing the
current frame had no effect, due to the COW flushing from original
Scene to the new Scene overwriting the CFRA changes we make.
* The code here still needs cleaning up to debugging instrumentation, etc.
and also to optimise further (e.g. caching the filtered depsgraph
for faster updates when animating on existing paths, or fine-tuning
the exact set of nodes needed). I'm just committing this first,
since this was the quickly hacked-together test code I've been using
to check that this is all working.
* Further improvements could also be made to the time needed to
build the full graph instance (about 3.3 sec), by allowing partial
builds (e.g. by making a filtering proxy/wrapper around existing builders)
* COW data hasn't been expanded yet when we try to filter the graph
(you need to have tagged + evaluated it for this data to exist),
so all the offending nodes would just get left in
* Added more debug prints to verify whether the id_nodes vector is
getting cleared correctly
* Simplified operation-relation deletion. Now we collect the relations
to delete into a vector, then iterate through that, thus solving issues
with iterator invalidation (+ aborts arising from that)
* DEG_foreach_ancestor_ID() was assuming that all dependencies were
OperationDepsNodes, when in fact, some could be TimeSource nodes
When this works correctly, we should be able to feed in an existing
depsgraph instance, and get out a "filtered" copy of it that contains
only the subset of nodes needed to evaluate what we're interested in.
The current implementation only filters on ID blocks/nodes,
and starts by building a full new depsgraph instance first.
I'd originally intended to do it per operation instead, copying
over individual nodes as appropriate to have the smallest and least
memory intensive graph possible. However, I ended up running into
into problems with function binding + COW arguments, hence the
current slow solution.
Building the CUDA kernels takes quite a bit of memory, and when building all of
them the combined usage can be too much on some systems (especially VMs).
Therefore, this patch adds an option to force the build system to build them
sequentially by making each build step depend on the previous kernel.
Reviewers: brecht, sergey
Differential Revision: https://developer.blender.org/D3623
* Add Shortcut -> Assign Shortcut
* Add to Favorites Menu -> Add to Quick Favorites
To match the menu name and be more general for when the Quick Favorites
are accessible in places other than just menus (like panels).
Add blank icon to Remove Shortcut so it aligns with Change Shortcut
which is usually the item on top of it in the menu.
Limited to mesh type of source, not sure it ever worked for non-meshes.
While it's possible to support reshape from any object, the actual brain
of operation would need to be recoded to go away from requirement of
vertex indices matching in source and destination.
This fully works as "expected", however it seems strange when
there is no selected vertex in the non-active object.
In 2.7x if you join two monkeys, select a vertex in one of them and
try to use this operator in the other it will select the lonely newly
selected vertex.
If you split both monkeys and do this in 2.8 while multi-editing them
you won't get nothing when trying to ctrl+RMB any vertex in the monkey
object that has nothing selected yet.
I propose to have this addressed in an upcoming patch where we always
select a vertex if no vertex was previously selected.
This make the workbench draw everything in the background routine just like
eevee. This is because the workbench uses floating point buffers too and
rendering background to this buffer makes it incorrect without proper
color management.
This could be improved because in xray the background is not blended but
dithered as it's drawn after the main pass.
This supports meshes and hairs too. Matches cycles output.
This adds barycentric coords to the GPUBuiltin enum which will also be used
for the wireframe node.
This makes it more generic process to perform actions which
depend on ptex face + (u, v) and on subdivided vertex index.
Currently it is still just a subdivision calculation process,
but same foreach callbacks can easily be used to propagate
displacement from known vertex locations back to displacement
grids.
Add a general parameter to force the recalc of the triangulation data because some modifiers could change the geometry and the filling triangles would not be right.
Now, the parameter is visible in UI panel because this option reduces FPS, but maybe in the future we can keep always ON and remove the parameter.
This changes the text hinting setting to be an enum with options
Auto / None / Slight / Full. The default is Auto which currently disables
hinting.
The hinting was tested with a new FreeType version, but this is not what
is used on the buildbots an official release environment, and the fonts
look quite bad because of that. Once FreeType has been upgraded we can
change the default.
Even then the results are not ideal, perhaps due to missing subpixel
positioning and linear color blending support in BLF.
In some extreme modifications the fill triangulation cannot be right, so need a refresh.
This is done only for sculpt brushes that can change the geometry.
Supporting the ctrl+click operator for multiple objects.
When no vertex is selected we only add a new vertex for the active object.
I'm using all the selected vertices to calculate the center of transformation
regardless of the object they come from. This way we have the same effect if the
meshes are joined together or kept as individual objects.
Thanks Campbell Barton for reviewing the patch.
OpenGL rendering only implemented the deferred renderer. This commit
will add the forward renderer. The forward renderer is used when XRay
mode is enabled
The loop cut tool now works as expected for the tool-system,
where hovering previews the loop and clicking activates.
This uses a new gizmo type to pre-select the edge.
This commit adds a new method, DEG_foreach_ancestor_ID()
to accompany the existing DEG_foreach_descendent_ID().
It can be used to help print/collect all the ID's that
a given ID block depends on (i.e. all the datablocks that
need to be evaluated before the datablock of interest can
be evaluated)
The core logic of this implementation comes from the drawobject.c from 2.7x.
I'm using `ts.colorGridAxisZ` for its color because of the legacy code:
```
UI_GetThemeColor3ubv(TH_GRID, col1);
UI_make_axis_color(col1, col2, 'Z');
glColor3ubv(col2);
```
There is nothing stopping us from adding this to the theme though, as it should
have been the case to start with.
This is quite confusing in the current UI, with both startup.blend and
workspaces.blend containing a list of workspaces. In practice you'd usually
want to save workspaces to both files.
The downside of having a single file may be that you then can't disable
certain workspaces by default, but we could add a setting for that.
These are taken from HDRI Haven (https://hdrihaven.com). Many thanks to
Greg Zaal for creating and releasing them under a CC0 license!
The HDRIs are intended to be used in the Lookdev display mode. With
1K resolution and compression they are not intended for final renders,
but it keeps the file size small and the difference is not noticeable
for lighting.
Command used for compression:
oiiotool %s --ch R,G,B -d float --compression dwab:300 -o output/%s
This reuses the tool defines for the 3D view. However, for some reason,
the events don't seem to be getting fired off here, like the tool system
is getting ignored here completely.
FIXME: Resolve the event handling issues
When OpenGL renderer is selected the option for background colors are
displayed, but ignored. For now we hide this option as it makes no sense
to have a viewport color option without viewport or render a 'final'
with a theme color.
blosc embedded a copy of zlib/pthreads causing duplicate symbol linker errors. pthreads was windows specific, but zlib may apply to other platforms as well.
This avoids getting all overridden objects from said collection
instantiated in master collection, totally untidy!
Note that there is still an issue when 'active' object (i.e. the
armature usually) is in hidden sub-collection, since you have to make
that whole hidden collection visible again to see it.
We'll need to support moving objects into overridden collections am
afraid, arg. :(
Without this, there was no simple way to have
launchers for different app-templates.
Also allows force-disabling the app-template stored in the preferences.
Very dummy mistake (someone forgot to increment one of the variables in
one of the loops in that spaghetti nightmare that is nurbs shapekey
code), took half an age to spot it... :/
* 3D Markers to Mesh
* Link Empty to Track
* Set as Background
Note, the "Setup Tracking Scene" was not addressed. Pending for this script is:
* Update world for EEVEE settings
* Adjust the layer code to use collections
* Remove broken world API
The only difference from 2.7x is that we were using glLineWidth(2.0) before,
which is not supported reliably in the latest OpenGL.
Big thanks to Clément Foucault for helping with this, on the design as well as
debugging the implementation.
For the records, I'm creating and destroying batches for the path geometry at
every draw. The pipeline is as follows:
1. Create GPUBatch with all the points
2. Create new shgroup with simple shader
3. Add call with the gpubatch
4. Save it in a linked list in stl->g_data
5. Free it after all drawing is done
The function must be static. The error was the definition in header file must be removed. This error was not detected by Microsoft compiler but Linux compiler fails.
-Moved from dynamic link to static on windows
-gained lcms/tinyxml/yamlcpp deps, since we need a little more control over the build flags than the build-in options will provide.
This operator clean any stroke below a defined number of points. This is used because sometimes when use eraser some points keep missing.
Also some changes in the UI menu.
The initial design assumed that there was only one object for each unique name, but that was not the case when instances were created.
Now, instances are supported and speed has been greatly improved when repetitions are used.
As a result of this change, the option to create objects has been removed in the Instances modifier. This option was strange and was also against Blender's design rules, since a modifier should never create objects. The old functionality of the modifier can be achieved with instances.
Also, several memory leakage problems that were not previously detected have been eliminated, and especially in the grid and in the drawing process
Onion Skin is not supported in multi-user datablocks. Support this, makes incompatible with instances. We need find a solution in the long term, but now it's better keep disabled and make instances work. Anyway, the new instances makes unnecessary to use muli-user datablocks.
Adds a displacement support for OpenSubdiov based subsurf object implemented
as a callback which gives vector displacement in object space. Currently is
implemented to calculate displacement based on myltires displacement grids,
but we can support things in the future if needed.
Submitting to review to see if there is something obviously wrong in the
direction (old multires code was sharing same displacement code to both
calculate final displaced mesh and reshape an existing one, which is rather
confusing and probably can be done more cleanly?).
Reviewers: brecht
Reviewed By: brecht
Differential Revision: https://developer.blender.org/D3604
This includes selections both in the clip editor as the viewport.
The selection is implemented as a synchronization function called from the eval
selection update node in depsgraph.
* Draw bundle names.
* Draw bundle shapes (but spheres).
* Draw custom colors for bundles.
* Support selecting bundles.
* Object bundles also fully tested.
Missing from this commit:
* Camera path.
* Spheres are not drawn as solid.
* Blue dashed line from camera to tracker objects.
Regenerating all to remove zero area triangles.
Previously icons included files not committed to lib/.
This is the output of 'make icons_geom' for svn rev: 62081.
Previously back-facing normal was checked which isn't ideal
because a triangle that starts out zero-area may become
visible once it's coordinates are quantized.
Add tool options to control how select operates (add/sub/set/and/xor).
Note: edit mode armature select still needs to support all options,
this is complicated by how it handles partial end-point selection.
This is a manual synchronization. If we need to re-use the same util in both
areas it would be welcomed as well. For now this at least get things back to a
working state.
Conversion code could leave object with inconsistent material data
compared to its new obdata.
Ideally, various conversion code would handle that properly, conserving
materials when possible, but for now at least ensure we get valid
result!
Related to T56363, this is not fixing the root of the bug, but ID
copying should always be a good occasion to ensure sanity of our data
(and error checking is always better than a crash!).
Currently no functional changes, just exposes all settings which we need
for OpenSubdiv, similar to what Subsurf modifier is doing already.
Reviewers: brecht
Reviewed By: brecht
Differential Revision: https://developer.blender.org/D3602
* http -> https
* Release Logs -> Release Notes
* Match number of items on both sides by adding a separator
* Remove Python API Reference link since it's already under Help
when Developer Extras is enabled.
Note to myself, next time, better check the fix before pushing it.
GL_ARB_texture_gather is defined if there is support for the extension
not only when the extension is enabled. Do this check ourself with
GPU_ARB_texture_gather define.
Original fix 822de6e9e1
A lot of code in codegen was used by previous GLSL system.
Now most of it is not used due to all the things being written from scratch
in 2.8 and we can clean most of it.
As a side not this make the system a bit less flexible (no support for
cubemaps, preview image, etc...) but can be extended again.
* Remove GPU_link_changed which is unused.
* Remove all GPU link function that are not used anymore.
* GPU_uniform_buffer is now GPU_uniform.
* GPU_texture_ramp is now GPU_color_band.
* GPU_uniform is now GPU_constant.
The extension GL_ARB_texture_gather is reported to be supported and does
not trigger an error when enabled but the textureGater functions are not
defined.
Workaround is to disable the use of this extension on such systems.
Currently constraints can only read the location along the
spline. This obviously limits opportunities for complex bone
interactions in rigs.
This patch exposes access to rotation and scale as well in
Copy Transforms. However, due to the way how things work,
this data cannot be smoothly interpolated, and abruptly
changes when switching to the next segment.
Reviewers: aligorith
Differential Revision: https://developer.blender.org/D3545
Scale is a multiplicative quantity, so adding it doesn't make sense.
However, for backward compatibility reasons, and in case somebody
actually desires the old additive behavior, the old way remains as
an option.
Without this change the only way to properly combine scale is via
parenting or the complicated Transformation constraint.
The new mode is turned on by a flag for file compatibility, but the
RNA option is reversed so that the new behavior feels more default.
Reviewers: aligorith
Differential Revision: https://developer.blender.org/D3558
Some constraints have an option to take the final bezier shape of
the target B-Bone into account. This shape usually depends on two
other bones in addition to the target itself, so the graph should
include the relevant dependencies.
Reviewers: sergey
Differential Revision: https://developer.blender.org/D3591
To get consistent, user-expected results here, we need to 'fake'
starting immediately after a 'skip' block (such that we start with a
full block of selected elements).
Same issue affected vertices and edges selection of course, did not
check the other usages of WM_operator_properties_checker_interval_test()
though.
seems like the openexr 2.3.0 release tarball has broken cmake support, latest from git works
we'll have to revisit this once they get a new release out.
For users it defines how accurate vertex positions are in terms
of limit surface (as in, how close the vertices locations to the
condition when they are calculated for an infinitely subdivided
mesh).
This affects things like:
- Irregular vertices (joint of 3 or more edges)
- Crease
Keep quality value low for performance.
NOTE: Going higher does not necessarily mean real improvement
in quality, ideal case might be reached well before maximum
quality of 10. Quality of 3 is a good starting point.
Internally quality is translated directly to adaptive subdivision
level.
Reviewers: brecht
Reviewed By: brecht
Differential Revision: https://developer.blender.org/D3599
Beautiful example of typo going unoticed and firing back up in totally
unexpected place years later. Guess nobody actually duplicated a Clip
data-block before! :P
Most likely own fault, during refactor of ID copying code.
There are following reasons to do so:
- The plan is to replace it with some sort of object or viewport option,
so we can apply OpenSubdiv subdivisions on top of modifier stack and
keep modifier stack purely CPU side.
This will solve issues when adding some relation in scene will force
modifier to be evaluated on CPU.
- With new upcoming OpenSubdiv based CPU modifier implementation we can
cache topology similar to what GPU side was doing, which will already
be reasonably faster.
- OpenSubdiv GPU does not work since the OpenGL version bump, and is
to be rewritten with all the adaptive refine options kept in mind.
Since OpenSubdiv GPU was already broken and was only causing object
to become invisible, there is no reason to keep having that option in
the modifier.
Reviewers: brecht
Reviewed By: brecht
Differential Revision: https://developer.blender.org/D3598
This replaces old single toggle option to subdivide UVs with
an enum which can have more options. The usecase for this is
to be compatible with other software. But we also might choose
different subdivision type as default in the future.
DNA and underlying code supports all possible options, but
only the ones which are compatible with old subdivision code
are currently exposes.
Reviewers: brecht
Reviewed By: brecht
Differential Revision: https://developer.blender.org/D3575
C-API is way smaller than the rest of the code which uses it.
So better to conditionally compile stub implementation than
to keep adding ifdef everywhere.
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.
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
@@ -197,10 +206,10 @@ option(WITH_INTERNATIONAL "Enable I18N (International fonts and text)" ON)
option(WITH_PYTHON"Enable Embedded Python API (only disable for development)"ON)
option(WITH_PYTHON_SECURITY"Disables execution of scripts within blend files by default"ON)
mark_as_advanced(WITH_PYTHON)# dont want people disabling this unless they really know what they are doing.
mark_as_advanced(WITH_PYTHON)# don't want people disabling this unless they really know what they are doing.
mark_as_advanced(WITH_PYTHON_SECURITY)# some distributions see this as a security issue, rather than have them patch it, make a build option.
option(WITH_PYTHON_SAFETY"Enable internal API error checking to track invalid data to prevent crash on access (at the expense of some effeciency, only enable for development)."OFF)
option(WITH_PYTHON_SAFETY"Enable internal API error checking to track invalid data to prevent crash on access (at the expense of some efficiency, only enable for development)."OFF)
mark_as_advanced(WITH_PYTHON_SAFETY)
option(WITH_PYTHON_MODULE"Enable building as a python module which runs without a user interface, like running regular blender in background mode (experimental, only enable for development), installs to PYTHON_SITE_PACKAGES (or CMAKE_INSTALL_PREFIX if WITH_INSTALL_PORTABLE is enabled)."OFF)
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.
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.