Hans Goudey
cfa53e0fbe
As described in T91186, this commit moves mesh vertex normals into a contiguous array of float vectors in a custom data layer, how face normals are currently stored. The main interface is documented in `BKE_mesh.h`. Vertex and face normals are now calculated on-demand and cached, retrieved with an "ensure" function. Since the logical state of a mesh is now "has normals when necessary", they can be retrieved from a `const` mesh. The goal is to use on-demand calculation for all derived data, but leave room for eager calculation for performance purposes (modifier evaluation is threaded, but viewport data generation is not). **Benefits** This moves us closer to a SoA approach rather than the current AoS paradigm. Accessing a contiguous `float3` is much more efficient than retrieving data from a larger struct. The memory requirements for accessing only normals or vertex locations are smaller, and at the cost of more memory usage for just normals, they now don't have to be converted between float and short, which also simplifies code In the future, the remaining items can be removed from `MVert`, leaving only `float3`, which has similar benefits (see T93602). Removing the combination of derived and original data makes it conceptually simpler to only calculate normals when necessary. This is especially important now that we have more opportunities for temporary meshes in geometry nodes. **Performance** In addition to the theoretical future performance improvements by making `MVert == float3`, I've done some basic performance testing on this patch directly. The data is fairly rough, but it gives an idea about where things stand generally. - Mesh line primitive 4m Verts: 1.16x faster (36 -> 31 ms), showing that accessing just `MVert` is now more efficient. - Spring Splash Screen: 1.03-1.06 -> 1.06-1.11 FPS, a very slight change that at least shows there is no regression. - Sprite Fright Snail Smoosh: 3.30-3.40 -> 3.42-3.50 FPS, a small but observable speedup. - Set Position Node with Scaled Normal: 1.36x faster (53 -> 39 ms), shows that using normals in geometry nodes is faster. - Normal Calculation 1.6m Vert Cube: 1.19x faster (25 -> 21 ms), shows that calculating normals is slightly faster now. - File Size of 1.6m Vert Cube: 1.03x smaller (214.7 -> 208.4 MB), Normals are not saved in files, which can help with large meshes. As for memory usage, it may be slightly more in some cases, but I didn't observe any difference in the production files I tested. **Tests** Some modifiers and cycles test results need to be updated with this commit, for two reasons: - The subdivision surface modifier is not responsible for calculating normals anymore. In master, the modifier creates different normals than the result of the `Mesh` normal calculation, so this is a bug fix. - There are small differences in the results of some modifiers that use normals because they are not converted to and from `short` anymore. **Future improvements** - Remove `ModifierTypeInfo::dependsOnNormals`. Code in each modifier already retrieves normals if they are needed anyway. - Copy normals as part of a better CoW system for attributes. - Make more areas use lazy instead of eager normal calculation. - Remove `BKE_mesh_normals_tag_dirty` in more places since that is now the default state of a new mesh. - Possibly apply a similar change to derived face corner normals. Differential Revision: https://developer.blender.org/D12770
331 lines
13 KiB
C++
331 lines
13 KiB
C++
/*
|
|
* This program is free software; you can redistribute it and/or
|
|
* modify it under the terms of the GNU General Public License
|
|
* as published by the Free Software Foundation; either version 2
|
|
* of the License, or (at your option) any later version.
|
|
*
|
|
* This program is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License
|
|
* along with this program; if not, write to the Free Software Foundation,
|
|
* Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
|
|
*
|
|
* The Original Code is Copyright (C) 2006 by NaN Holding BV.
|
|
* All rights reserved.
|
|
*/
|
|
#pragma once
|
|
|
|
/** \file
|
|
* \ingroup bke
|
|
*/
|
|
|
|
#include "BLI_bitmap.h"
|
|
#include "BLI_kdopbvh.h"
|
|
#include "BLI_threads.h"
|
|
|
|
#ifdef __cplusplus
|
|
extern "C" {
|
|
#endif
|
|
|
|
/**
|
|
* This header encapsulates necessary code to build a BVH
|
|
*/
|
|
|
|
struct BMEditMesh;
|
|
struct MFace;
|
|
struct MVert;
|
|
struct Mesh;
|
|
struct PointCloud;
|
|
|
|
struct BVHCache;
|
|
|
|
/**
|
|
* Struct that stores basic information about a BVHTree built from a edit-mesh.
|
|
*/
|
|
typedef struct BVHTreeFromEditMesh {
|
|
struct BVHTree *tree;
|
|
|
|
/** Default callbacks to BVH nearest and ray-cast. */
|
|
BVHTree_NearestPointCallback nearest_callback;
|
|
BVHTree_RayCastCallback raycast_callback;
|
|
|
|
struct BMEditMesh *em;
|
|
|
|
/* Private data */
|
|
bool cached;
|
|
|
|
} BVHTreeFromEditMesh;
|
|
|
|
/**
|
|
* Struct that stores basic information about a #BVHTree built from a mesh.
|
|
*/
|
|
typedef struct BVHTreeFromMesh {
|
|
struct BVHTree *tree;
|
|
|
|
/** Default callbacks to BVH nearest and ray-cast. */
|
|
BVHTree_NearestPointCallback nearest_callback;
|
|
BVHTree_RayCastCallback raycast_callback;
|
|
|
|
/* Vertex array, so that callbacks have instant access to data. */
|
|
const struct MVert *vert;
|
|
const float (*vert_normals)[3];
|
|
const struct MEdge *edge; /* only used for #BVHTreeFromMeshEdges */
|
|
const struct MFace *face;
|
|
const struct MLoop *loop;
|
|
const struct MLoopTri *looptri;
|
|
bool vert_allocated;
|
|
bool edge_allocated;
|
|
bool face_allocated;
|
|
bool loop_allocated;
|
|
bool looptri_allocated;
|
|
|
|
/* Private data */
|
|
bool cached;
|
|
|
|
} BVHTreeFromMesh;
|
|
|
|
typedef enum BVHCacheType {
|
|
BVHTREE_FROM_VERTS,
|
|
BVHTREE_FROM_EDGES,
|
|
BVHTREE_FROM_FACES,
|
|
BVHTREE_FROM_LOOPTRI,
|
|
BVHTREE_FROM_LOOPTRI_NO_HIDDEN,
|
|
|
|
BVHTREE_FROM_LOOSEVERTS,
|
|
BVHTREE_FROM_LOOSEEDGES,
|
|
|
|
BVHTREE_FROM_EM_VERTS,
|
|
BVHTREE_FROM_EM_EDGES,
|
|
BVHTREE_FROM_EM_LOOPTRI,
|
|
|
|
/* Keep `BVHTREE_MAX_ITEM` as last item. */
|
|
BVHTREE_MAX_ITEM,
|
|
} BVHCacheType;
|
|
|
|
/**
|
|
* Builds a BVH tree where nodes are the relevant elements of the given mesh.
|
|
* Configures #BVHTreeFromMesh.
|
|
*
|
|
* The tree is build in mesh space coordinates, this means special care must be made on queries
|
|
* so that the coordinates and rays are first translated on the mesh local coordinates.
|
|
* Reason for this is that bvh_from_mesh_* can use a cache in some cases and so it
|
|
* becomes possible to reuse a #BVHTree.
|
|
*
|
|
* #free_bvhtree_from_mesh should be called when the tree is no longer needed.
|
|
*/
|
|
BVHTree *bvhtree_from_editmesh_verts(
|
|
BVHTreeFromEditMesh *data, struct BMEditMesh *em, float epsilon, int tree_type, int axis);
|
|
|
|
/**
|
|
* Builds a BVH-tree where nodes are the vertices of the given `em`.
|
|
*/
|
|
BVHTree *bvhtree_from_editmesh_verts_ex(BVHTreeFromEditMesh *data,
|
|
struct BMEditMesh *em,
|
|
const BLI_bitmap *mask,
|
|
int verts_num_active,
|
|
float epsilon,
|
|
int tree_type,
|
|
int axis,
|
|
BVHCacheType bvh_cache_type,
|
|
struct BVHCache **bvh_cache_p,
|
|
ThreadMutex *mesh_eval_mutex);
|
|
|
|
/**
|
|
* Builds a BVH-tree where nodes are the given vertices (NOTE: does not copy given `vert`!).
|
|
* \param vert_allocated: if true, vert freeing will be done when freeing data.
|
|
* \param verts_mask: if not null, true elements give which vert to add to BVH-tree.
|
|
* \param verts_num_active: if >= 0, number of active verts to add to BVH-tree
|
|
* (else will be computed from mask).
|
|
*/
|
|
BVHTree *bvhtree_from_mesh_verts_ex(struct BVHTreeFromMesh *data,
|
|
const struct MVert *vert,
|
|
int verts_num,
|
|
bool vert_allocated,
|
|
const BLI_bitmap *verts_mask,
|
|
int verts_num_active,
|
|
float epsilon,
|
|
int tree_type,
|
|
int axis,
|
|
BVHCacheType bvh_cache_type,
|
|
struct BVHCache **bvh_cache_p,
|
|
ThreadMutex *mesh_eval_mutex);
|
|
|
|
BVHTree *bvhtree_from_editmesh_edges(
|
|
BVHTreeFromEditMesh *data, struct BMEditMesh *em, float epsilon, int tree_type, int axis);
|
|
|
|
/**
|
|
* Builds a BVH-tree where nodes are the edges of the given `em`.
|
|
*/
|
|
BVHTree *bvhtree_from_editmesh_edges_ex(BVHTreeFromEditMesh *data,
|
|
struct BMEditMesh *em,
|
|
const BLI_bitmap *edges_mask,
|
|
int edges_num_active,
|
|
float epsilon,
|
|
int tree_type,
|
|
int axis,
|
|
BVHCacheType bvh_cache_type,
|
|
struct BVHCache **bvh_cache_p,
|
|
ThreadMutex *mesh_eval_mutex);
|
|
|
|
/**
|
|
* Builds a BVH-tree where nodes are the given edges.
|
|
* \param vert, vert_allocated: if true, elem freeing will be done when freeing data.
|
|
* \param edge, edge_allocated: if true, elem freeing will be done when freeing data.
|
|
* \param edges_mask: if not null, true elements give which vert to add to BVH-tree.
|
|
* \param edges_num_active: if >= 0, number of active edges to add to BVH-tree
|
|
* (else will be computed from mask).
|
|
*/
|
|
BVHTree *bvhtree_from_mesh_edges_ex(struct BVHTreeFromMesh *data,
|
|
const struct MVert *vert,
|
|
bool vert_allocated,
|
|
const struct MEdge *edge,
|
|
int edges_num,
|
|
bool edge_allocated,
|
|
const BLI_bitmap *edges_mask,
|
|
int edges_num_active,
|
|
float epsilon,
|
|
int tree_type,
|
|
int axis,
|
|
BVHCacheType bvh_cache_type,
|
|
struct BVHCache **bvh_cache_p,
|
|
ThreadMutex *mesh_eval_mutex);
|
|
|
|
/**
|
|
* Builds a BVH-tree where nodes are the given tessellated faces
|
|
* (NOTE: does not copy given mfaces!).
|
|
* \param vert_allocated: if true, vert freeing will be done when freeing data.
|
|
* \param face_allocated: if true, face freeing will be done when freeing data.
|
|
* \param faces_mask: if not null, true elements give which faces to add to BVH-tree.
|
|
* \param faces_num_active: if >= 0, number of active faces to add to BVH-tree
|
|
* (else will be computed from mask).
|
|
*/
|
|
BVHTree *bvhtree_from_mesh_faces_ex(struct BVHTreeFromMesh *data,
|
|
const struct MVert *vert,
|
|
bool vert_allocated,
|
|
const struct MFace *face,
|
|
int numFaces,
|
|
bool face_allocated,
|
|
const BLI_bitmap *faces_mask,
|
|
int faces_num_active,
|
|
float epsilon,
|
|
int tree_type,
|
|
int axis,
|
|
BVHCacheType bvh_cache_type,
|
|
struct BVHCache **bvh_cache_p,
|
|
ThreadMutex *mesh_eval_mutex);
|
|
|
|
BVHTree *bvhtree_from_editmesh_looptri(
|
|
BVHTreeFromEditMesh *data, struct BMEditMesh *em, float epsilon, int tree_type, int axis);
|
|
|
|
/**
|
|
* Builds a BVH-tree where nodes are the `looptri` faces of the given `bm`.
|
|
*/
|
|
BVHTree *bvhtree_from_editmesh_looptri_ex(BVHTreeFromEditMesh *data,
|
|
struct BMEditMesh *em,
|
|
const BLI_bitmap *mask,
|
|
int looptri_num_active,
|
|
float epsilon,
|
|
int tree_type,
|
|
int axis,
|
|
BVHCacheType bvh_cache_type,
|
|
struct BVHCache **bvh_cache_p,
|
|
ThreadMutex *mesh_eval_mutex);
|
|
|
|
/**
|
|
* Builds a BVH-tree where nodes are the looptri faces of the given mesh.
|
|
*
|
|
* \note for edit-mesh this is currently a duplicate of #bvhtree_from_mesh_faces_ex
|
|
*/
|
|
BVHTree *bvhtree_from_mesh_looptri_ex(struct BVHTreeFromMesh *data,
|
|
const struct MVert *vert,
|
|
bool vert_allocated,
|
|
const struct MLoop *mloop,
|
|
bool loop_allocated,
|
|
const struct MLoopTri *looptri,
|
|
int looptri_num,
|
|
bool looptri_allocated,
|
|
const BLI_bitmap *mask,
|
|
int looptri_num_active,
|
|
float epsilon,
|
|
int tree_type,
|
|
int axis,
|
|
BVHCacheType bvh_cache_type,
|
|
struct BVHCache **bvh_cache_p,
|
|
ThreadMutex *mesh_eval_mutex);
|
|
|
|
/**
|
|
* Builds or queries a BVH-cache for the cache BVH-tree of the request type.
|
|
*
|
|
* \note This function only fills a cache, and therefore the mesh argument can
|
|
* be considered logically const. Concurrent access is protected by a mutex.
|
|
*/
|
|
BVHTree *BKE_bvhtree_from_mesh_get(struct BVHTreeFromMesh *data,
|
|
const struct Mesh *mesh,
|
|
BVHCacheType bvh_cache_type,
|
|
int tree_type);
|
|
|
|
/**
|
|
* Builds or queries a BVH-cache for the cache BVH-tree of the request type.
|
|
*/
|
|
BVHTree *BKE_bvhtree_from_editmesh_get(BVHTreeFromEditMesh *data,
|
|
struct BMEditMesh *em,
|
|
int tree_type,
|
|
BVHCacheType bvh_cache_type,
|
|
struct BVHCache **bvh_cache_p,
|
|
ThreadMutex *mesh_eval_mutex);
|
|
|
|
/**
|
|
* Frees data allocated by a call to `bvhtree_from_editmesh_*`.
|
|
*/
|
|
void free_bvhtree_from_editmesh(struct BVHTreeFromEditMesh *data);
|
|
/**
|
|
* Frees data allocated by a call to `bvhtree_from_mesh_*`.
|
|
*/
|
|
void free_bvhtree_from_mesh(struct BVHTreeFromMesh *data);
|
|
|
|
/**
|
|
* Math functions used by callbacks
|
|
*/
|
|
float bvhtree_ray_tri_intersection(
|
|
const BVHTreeRay *ray, float m_dist, const float v0[3], const float v1[3], const float v2[3]);
|
|
float bvhtree_sphereray_tri_intersection(const BVHTreeRay *ray,
|
|
float radius,
|
|
float m_dist,
|
|
const float v0[3],
|
|
const float v1[3],
|
|
const float v2[3]);
|
|
|
|
typedef struct BVHTreeFromPointCloud {
|
|
struct BVHTree *tree;
|
|
|
|
BVHTree_NearestPointCallback nearest_callback;
|
|
|
|
const float (*coords)[3];
|
|
} BVHTreeFromPointCloud;
|
|
|
|
BVHTree *BKE_bvhtree_from_pointcloud_get(struct BVHTreeFromPointCloud *data,
|
|
const struct PointCloud *pointcloud,
|
|
int tree_type);
|
|
|
|
void free_bvhtree_from_pointcloud(struct BVHTreeFromPointCloud *data);
|
|
|
|
/**
|
|
* BVHCache
|
|
*/
|
|
|
|
/* Using local coordinates */
|
|
|
|
bool bvhcache_has_tree(const struct BVHCache *bvh_cache, const BVHTree *tree);
|
|
struct BVHCache *bvhcache_init(void);
|
|
/**
|
|
* Frees a BVH-cache.
|
|
*/
|
|
void bvhcache_free(struct BVHCache *bvh_cache);
|
|
|
|
#ifdef __cplusplus
|
|
}
|
|
#endif
|