Hans Goudey
16fbadde36
Implements #102359. Split the `MLoop` struct into two separate integer arrays called `corner_verts` and `corner_edges`, referring to the vertex each corner is attached to and the next edge around the face at each corner. These arrays can be sliced to give access to the edges or vertices in a face. Then they are often referred to as "poly_verts" or "poly_edges". The main benefits are halving the necessary memory bandwidth when only one array is used and simplifications from using regular integer indices instead of a special-purpose struct. The commit also starts a renaming from "loop" to "corner" in mesh code. Like the other mesh struct of array refactors, forward compatibility is kept by writing files with the older format. This will be done until 4.0 to ease the transition process. Looking at a small portion of the patch should give a good impression for the rest of the changes. I tried to make the changes as small as possible so it's easy to tell the correctness from the diff. Though I found Blender developers have been very inventive over the last decade when finding different ways to loop over the corners in a face. For performance, nearly every piece of code that deals with `Mesh` is slightly impacted. Any algorithm that is memory bottle-necked should see an improvement. For example, here is a comparison of interpolating a vertex float attribute to face corners (Ryzen 3700x): **Before** (Average: 3.7 ms, Min: 3.4 ms) ``` threading::parallel_for(loops.index_range(), 4096, [&](IndexRange range) { for (const int64_t i : range) { dst[i] = src[loops[i].v]; } }); ``` **After** (Average: 2.9 ms, Min: 2.6 ms) ``` array_utils::gather(src, corner_verts, dst); ``` That's an improvement of 28% to the average timings, and it's also a simplification, since an index-based routine can be used instead. For more examples using the new arrays, see the design task. Pull Request: blender/blender#104424
147 lines
5.2 KiB
C++
147 lines
5.2 KiB
C++
/* SPDX-License-Identifier: GPL-2.0-or-later */
|
|
|
|
#pragma once
|
|
|
|
/** \file
|
|
* \ingroup bke
|
|
*/
|
|
|
|
#include "BLI_function_ref.hh"
|
|
#include "BLI_generic_virtual_array.hh"
|
|
#include "BLI_math_vector_types.hh"
|
|
|
|
#include "DNA_meshdata_types.h"
|
|
|
|
#include "BKE_attribute.h"
|
|
|
|
struct Mesh;
|
|
struct BVHTreeFromMesh;
|
|
|
|
namespace blender {
|
|
class RandomNumberGenerator;
|
|
}
|
|
|
|
namespace blender::bke::mesh_surface_sample {
|
|
|
|
void sample_point_attribute(const Mesh &mesh,
|
|
Span<int> looptri_indices,
|
|
Span<float3> bary_coords,
|
|
const GVArray &src,
|
|
IndexMask mask,
|
|
GMutableSpan dst);
|
|
|
|
void sample_corner_attribute(const Mesh &mesh,
|
|
Span<int> looptri_indices,
|
|
Span<float3> bary_coords,
|
|
const GVArray &src,
|
|
IndexMask mask,
|
|
GMutableSpan dst);
|
|
|
|
void sample_face_attribute(const Mesh &mesh,
|
|
Span<int> looptri_indices,
|
|
const GVArray &src,
|
|
IndexMask mask,
|
|
GMutableSpan dst);
|
|
|
|
enum class eAttributeMapMode {
|
|
INTERPOLATED,
|
|
NEAREST,
|
|
};
|
|
|
|
/**
|
|
* A utility class that performs attribute interpolation from a source mesh.
|
|
*
|
|
* The interpolator is only valid as long as the mesh is valid.
|
|
* Barycentric weights are needed when interpolating point or corner domain attributes,
|
|
* these are computed lazily when needed and re-used.
|
|
*/
|
|
class MeshAttributeInterpolator {
|
|
const Mesh *mesh_;
|
|
const IndexMask mask_;
|
|
const Span<float3> positions_;
|
|
const Span<int> looptri_indices_;
|
|
|
|
Array<float3> bary_coords_;
|
|
Array<float3> nearest_weights_;
|
|
|
|
public:
|
|
MeshAttributeInterpolator(const Mesh *mesh,
|
|
IndexMask mask,
|
|
Span<float3> positions,
|
|
Span<int> looptri_indices);
|
|
|
|
void sample_data(const GVArray &src,
|
|
eAttrDomain domain,
|
|
eAttributeMapMode mode,
|
|
GMutableSpan dst);
|
|
|
|
protected:
|
|
Span<float3> ensure_barycentric_coords();
|
|
Span<float3> ensure_nearest_weights();
|
|
};
|
|
|
|
/**
|
|
* Find randomly distributed points on the surface of a mesh within a 3D sphere. This does not
|
|
* sample an exact number of points because it comes with extra overhead to avoid bias that is only
|
|
* required in some cases. If an exact number of points is required, that has to be implemented at
|
|
* a higher level.
|
|
*
|
|
* \param approximate_density: Roughly the number of points per unit of area.
|
|
* \return The number of added points.
|
|
*/
|
|
int sample_surface_points_spherical(RandomNumberGenerator &rng,
|
|
const Mesh &mesh,
|
|
Span<int> looptri_indices_to_sample,
|
|
const float3 &sample_pos,
|
|
float sample_radius,
|
|
float approximate_density,
|
|
Vector<float3> &r_bary_coords,
|
|
Vector<int> &r_looptri_indices,
|
|
Vector<float3> &r_positions);
|
|
|
|
/**
|
|
* Find randomly distributed points on the surface of a mesh within a circle that is projected on
|
|
* the mesh. This does not result in an exact number of points because that would come with extra
|
|
* overhead and is not always possible. If an exact number of points is required, that has to be
|
|
* implemented at a higher level.
|
|
*
|
|
* \param region_position_to_ray: Function that converts a 2D position into a 3D ray that is used
|
|
* to find positions on the mesh.
|
|
* \param mesh_bvhtree: BVH tree of the triangles in the mesh. Passed in so that it does not have
|
|
* to be retrieved again.
|
|
* \param tries_num: Number of 2d positions that are sampled. The maximum
|
|
* number of new samples.
|
|
* \return The number of added points.
|
|
*/
|
|
int sample_surface_points_projected(
|
|
RandomNumberGenerator &rng,
|
|
const Mesh &mesh,
|
|
BVHTreeFromMesh &mesh_bvhtree,
|
|
const float2 &sample_pos_re,
|
|
float sample_radius_re,
|
|
FunctionRef<void(const float2 &pos_re, float3 &r_start, float3 &r_end)> region_position_to_ray,
|
|
bool front_face_only,
|
|
int tries_num,
|
|
int max_points,
|
|
Vector<float3> &r_bary_coords,
|
|
Vector<int> &r_looptri_indices,
|
|
Vector<float3> &r_positions);
|
|
|
|
float3 compute_bary_coord_in_triangle(Span<float3> vert_positions,
|
|
Span<int> corner_verts,
|
|
const MLoopTri &looptri,
|
|
const float3 &position);
|
|
|
|
template<typename T>
|
|
inline T sample_corner_attrribute_with_bary_coords(const float3 &bary_weights,
|
|
const MLoopTri &looptri,
|
|
const Span<T> corner_attribute)
|
|
{
|
|
return attribute_math::mix3(bary_weights,
|
|
corner_attribute[looptri.tri[0]],
|
|
corner_attribute[looptri.tri[1]],
|
|
corner_attribute[looptri.tri[2]]);
|
|
}
|
|
|
|
} // namespace blender::bke::mesh_surface_sample
|