Blender Git Loki

BLI: support disabling task isolation in task pool

Under some circumstances using task isolation can cause deadlocks.
Previously, our task pool implementation would run all tasks in an
isolated region. Now using task isolation is optional and can be
turned on/off for individual task pools.

Task pools that spawn new tasks recursively should never enable
task isolation. There is a new check that finds these cases at runtime.
Right now this check is disabled, so that this commit is a pure refactor.
It will be enabled in an upcoming commit.

This fixes T88598.

Differential Revision: https://developer.blender.org/D11415

BMesh: simplify normal calculation, resolve partial update error

Simplify vertex normal calculation by moving the main normal
accumulation function to operate on vertices instead of faces.

Using faces had the down side that it needed to zero, accumulate and
normalize the vertex normals in 3 separate passes, accumulating also
needed a spin-lock for thread since the face would write it's normal
to all of it's vertices which could be shared with other faces.

Now a single loop over vertices is performed without locking.
This gives 5-6% speedup calculating all normals.

This also simplifies partial updates, fixing a problem where
all connected faces were being read from when calculating normals.
While this could have been resolved separately,
it's simpler to operate on vertices directly.

Cleanup: Silent compile warning in `interface_widgets.c`.

Cleanup: Soilent compile warning in `curve_bevel.c`.

LineArt: Threaded Object Loading.

Move BMesh conversion and all loading code into worker.

Reviewed By: Sebastian Parborg (zeddb)

Differential Revision: https://developer.blender.org/D11288

Cleanup: Improve comments

Merge branch 'master' into xr-controller-support

Fix build warnings

Curve Deform: Simplify parameter calculation, add comments

Cleanup: Comments and unused var.

Merge branch 'master' into temp-geometry-nodes-curve-deform-node

Fix test failure caused by earlier cleanup commit

rB8cbff7093d65 neglected to move the "pre-tesselation" modifier to the
next before calculating the second part of the curve modifier stack.

Remove noop code from WM_MOUSEWHEEL processing.

ChildWindowFromPoint retrieves the child of the provided window at a
point. In this case it always returns 0 because HWND_DESKTOP is flag
defined as 0, which is never a valid window handle and is not intended
for use in place of a window handle.

Forwarding of mousewheel events was added in adb08def613d, and later
modified to the current unworking state in e9645806f563. Sending mouse
wheel events to the window under the cursor is a system preference and
therefore should not be overridden by Blender, therefore the noop code
has been removed.

Subdivision: basic GPU subdivision for OpenGL

This implements GPU subdivision via OpenSubDiv for OpenGL based render
engines. At the moment only uniform subdivision is supported. Adaptive
subdivision still lacks a way to render triangles from the subdivision
patches.

The GPUBatch is extended with a new VBO and a new IBO to gather
subdivided points and indices. This allows to render the subdivided
surface and the original control cage in edit mode without disrupting
too much the code.

To generate triangles from the subdivided index buffer, a compute
shader is used. Although, at the moment normals are not computed there
so a CPU fallback is used, where data is read from the GPU, processed
on the CPU to generate triangles and normals, and then sent back to
the GPU. To compute normals, a secondary compute shader might be used.
This is not ideal for performance, but allows to validate that
subdivision is indeed performed properly on the GPU.

Attributes (including UVs and vertex colors) are not supported yet.

For performance, some proper caching mechanism will need to be used.
There currently is some logic to cache the subdivision structures that
can be reused between updates. However, it is deactivated as it does
not properly detect when changes occur, and causes crashes in edit
mode.

Performance can be further improved by reducing data transfer to the
GPU, since OpenSubDiv asks us to allocate buffers big enough for the
refined and coarse mesh we also allocate such buffer on the host, and
transfer the entier buffer worth of data to the device, although only
the coarse part need to be truly allocated on the host and sent to the
device. This will require some change to the vertex buffer structure.

Subdivision: store settings in the Mesh datablock

This stores the subdivision settings in the Mesh datablock in order to simplify
detection of whether subdivision is needed, especially for rendering to avoid
subdividing a Mesh twice, one on the Blender side, and once on the render engine
side.

Ref T68891

Subdivision: initial support for face holes

Subdivision: add support for vertex creasing

This adds vertex creasing support for modeling, rendering, and Alembic IO. This is only implemented for OpenSubDiv.

For modeling, vertex creasing follows the edge creasing implementation with an operator accessed through the Vertex menu in Edit Mode, and some parameter in the properties panel.

Also added options to the Subsurf and Multires modifiers to disable vertex creasing, the existing option is only affecting edge creasing. Not sure if this is desirable, but I think it makes sense to separate them, as it can help people understand and study the effects of each of them.

For Cycles this adds a couple of sockets on the Mesh node to hold data about which vertices are creased (one socket for the indices, one for the weigths). We could have a single socket with a value for every vertex, but this helps reducing memory usage a bit. Crease weights for vertices are then merged with the ones for edge creasing when setting up data for OpenSubDiv.

For rendering vertex creasing in the viewport in Edit Mode, I tried to have a similar rendering as for edge creasing, that is with a colored outline, but I could not get it to work properly, so I resorted to mixing the vertex selected color with the edge crease color so the creasing is shown to emanate from the vertices, along the edges. If both vertices of an edge are creased, this would render the edge as creased. This needs improvement.

To support rendering vertex and edge creases differently, `EditLoopData` was modified to hold `ushorts` instead of `uchars` in order to store more bit flags as all available bits in `EditLoopData.e_flag` were used. (For those unaware, this structure maps to an `ivec4` in the GLSL shader, so adding another member to hold vertex creasing is not really possible.)

For Alembic, vertex creases are read and written in a similar fashion as edge creases (vertex creases are called "corners" in Alembic), so this is only written if a subdivision modifier is present on the Blender Mesh.

Merge branch 'master' into temp_bmesh_multires

Improve multires performance.

Added a new api function to stich multires grids
on specific faces in a mesh,
subdiv_ccg_average_faces_boundaries_and_corners,
and changed multires normal calc to use it.

VTune profiling showed that this was a major
performance hit once you get above 10,000 or so
base mesh faces and/or have a high number of
subdivision levels.

Here's a video comparing the difference. Note the
bpy.app_debug switch is not in the final commit.

{F10145323}

And the .blend file:

{F10145346}

Reviewed By: Sergey Sharybin (sergey)

Differential Revision:
https://developer.blender.org/D11334

Revert "Improve multires performance."
. . .because I accidentally committed
submodule references.

This reverts commit 482465e18aa7c9f74fcb90ec1002f157a580e240.