2023-08-15 16:20:26 +02:00
|
|
|
/* SPDX-FileCopyrightText: Blender Authors
|
2023-05-31 16:19:06 +02:00
|
|
|
*
|
|
|
|
* SPDX-License-Identifier: GPL-2.0-or-later */
|
2012-02-17 19:59:41 +01:00
|
|
|
#pragma once
|
2008-04-25 20:22:20 +02:00
|
|
|
|
2019-02-17 22:08:12 +01:00
|
|
|
/** \file
|
|
|
|
* \ingroup bke
|
2011-02-18 14:05:18 +01:00
|
|
|
*/
|
|
|
|
|
2008-07-19 00:24:20 +02:00
|
|
|
/* Shrinkwrap stuff */
|
2023-11-16 11:41:55 +01:00
|
|
|
#include "BKE_bvhutils.hh"
|
2008-08-07 17:18:47 +02:00
|
|
|
|
2023-12-04 21:22:00 +01:00
|
|
|
#include "BLI_array.hh"
|
|
|
|
#include "BLI_bit_vector.hh"
|
2023-11-28 22:40:43 +01:00
|
|
|
#include "BLI_math_vector_types.hh"
|
|
|
|
#include "BLI_offset_indices.hh"
|
|
|
|
#include "BLI_span.hh"
|
|
|
|
|
2008-08-12 22:43:10 +02:00
|
|
|
/*
|
|
|
|
* Shrinkwrap is composed by a set of functions and options that define the type of shrink.
|
|
|
|
*
|
|
|
|
* 3 modes are available:
|
2021-12-07 07:19:15 +01:00
|
|
|
* - Nearest vertex.
|
|
|
|
* - Nearest surface.
|
|
|
|
* - Normal projection.
|
2008-08-12 22:43:10 +02:00
|
|
|
*
|
2021-12-07 07:19:15 +01:00
|
|
|
* #ShrinkwrapCalcData encapsulates all needed data for shrink-wrap functions.
|
2012-03-18 08:38:51 +01:00
|
|
|
* (So that you don't have to pass an enormous amount of arguments to functions)
|
2008-08-12 22:43:10 +02:00
|
|
|
*/
|
|
|
|
|
2019-01-28 11:08:24 +01:00
|
|
|
struct BVHTree;
|
2009-04-20 17:06:46 +02:00
|
|
|
struct MDeformVert;
|
2019-01-28 11:08:24 +01:00
|
|
|
struct Mesh;
|
2022-09-07 07:14:31 +02:00
|
|
|
struct ModifierEvalContext;
|
2019-01-28 11:08:24 +01:00
|
|
|
struct Object;
|
2021-12-13 17:09:22 +01:00
|
|
|
struct ShrinkwrapGpencilModifierData;
|
2022-01-24 11:16:06 +01:00
|
|
|
struct ShrinkwrapModifierData;
|
2014-08-01 16:28:31 +02:00
|
|
|
struct SpaceTransform;
|
2008-04-25 20:22:20 +02:00
|
|
|
|
Shrinkwrap: new mode that projects along the target normal.
The Nearest Surface Point shrink method, while fast, is neither
smooth nor continuous: as the source point moves, the projected
point can both stop and jump. This causes distortions in the
deformation of the shrinkwrap modifier, and the motion of an
animated object with a shrinkwrap constraint.
This patch implements a new mode, which, instead of using the simple
nearest point search, iteratively solves an equation for each triangle
to find a point which has its interpolated normal point to or from the
original vertex. Non-manifold boundary edges are treated as infinitely
thin cylinders that cast normals in all perpendicular directions.
Since this is useful for the constraint, and having multiple
objects with constraints targeting the same guide mesh is a quite
reasonable use case, rather than calculating the mesh boundary edge
data over and over again, it is precomputed and cached in the mesh.
Reviewers: mont29
Differential Revision: https://developer.blender.org/D3836
2018-11-06 19:04:53 +01:00
|
|
|
/* Information about boundary edges in the mesh. */
|
2023-11-28 22:13:09 +01:00
|
|
|
struct ShrinkwrapBoundaryVertData {
|
Shrinkwrap: new mode that projects along the target normal.
The Nearest Surface Point shrink method, while fast, is neither
smooth nor continuous: as the source point moves, the projected
point can both stop and jump. This causes distortions in the
deformation of the shrinkwrap modifier, and the motion of an
animated object with a shrinkwrap constraint.
This patch implements a new mode, which, instead of using the simple
nearest point search, iteratively solves an equation for each triangle
to find a point which has its interpolated normal point to or from the
original vertex. Non-manifold boundary edges are treated as infinitely
thin cylinders that cast normals in all perpendicular directions.
Since this is useful for the constraint, and having multiple
objects with constraints targeting the same guide mesh is a quite
reasonable use case, rather than calculating the mesh boundary edge
data over and over again, it is precomputed and cached in the mesh.
Reviewers: mont29
Differential Revision: https://developer.blender.org/D3836
2018-11-06 19:04:53 +01:00
|
|
|
/* Average direction of edges that meet here. */
|
|
|
|
float direction[3];
|
|
|
|
|
|
|
|
/* Closest vector to direction that is orthogonal to vertex normal. */
|
|
|
|
float normal_plane[3];
|
2023-11-28 22:13:09 +01:00
|
|
|
};
|
Shrinkwrap: new mode that projects along the target normal.
The Nearest Surface Point shrink method, while fast, is neither
smooth nor continuous: as the source point moves, the projected
point can both stop and jump. This causes distortions in the
deformation of the shrinkwrap modifier, and the motion of an
animated object with a shrinkwrap constraint.
This patch implements a new mode, which, instead of using the simple
nearest point search, iteratively solves an equation for each triangle
to find a point which has its interpolated normal point to or from the
original vertex. Non-manifold boundary edges are treated as infinitely
thin cylinders that cast normals in all perpendicular directions.
Since this is useful for the constraint, and having multiple
objects with constraints targeting the same guide mesh is a quite
reasonable use case, rather than calculating the mesh boundary edge
data over and over again, it is precomputed and cached in the mesh.
Reviewers: mont29
Differential Revision: https://developer.blender.org/D3836
2018-11-06 19:04:53 +01:00
|
|
|
|
2023-11-28 22:13:09 +01:00
|
|
|
struct ShrinkwrapBoundaryData {
|
Shrinkwrap: new mode that projects along the target normal.
The Nearest Surface Point shrink method, while fast, is neither
smooth nor continuous: as the source point moves, the projected
point can both stop and jump. This causes distortions in the
deformation of the shrinkwrap modifier, and the motion of an
animated object with a shrinkwrap constraint.
This patch implements a new mode, which, instead of using the simple
nearest point search, iteratively solves an equation for each triangle
to find a point which has its interpolated normal point to or from the
original vertex. Non-manifold boundary edges are treated as infinitely
thin cylinders that cast normals in all perpendicular directions.
Since this is useful for the constraint, and having multiple
objects with constraints targeting the same guide mesh is a quite
reasonable use case, rather than calculating the mesh boundary edge
data over and over again, it is precomputed and cached in the mesh.
Reviewers: mont29
Differential Revision: https://developer.blender.org/D3836
2018-11-06 19:04:53 +01:00
|
|
|
/* True if the edge belongs to exactly one face. */
|
2023-12-04 21:22:00 +01:00
|
|
|
blender::BitVector<> edge_is_boundary;
|
2023-12-19 14:57:49 +01:00
|
|
|
/* True if the triangle has any boundary edges. */
|
|
|
|
blender::BitVector<> tri_has_boundary;
|
2019-04-17 06:17:24 +02:00
|
|
|
|
Shrinkwrap: new mode that projects along the target normal.
The Nearest Surface Point shrink method, while fast, is neither
smooth nor continuous: as the source point moves, the projected
point can both stop and jump. This causes distortions in the
deformation of the shrinkwrap modifier, and the motion of an
animated object with a shrinkwrap constraint.
This patch implements a new mode, which, instead of using the simple
nearest point search, iteratively solves an equation for each triangle
to find a point which has its interpolated normal point to or from the
original vertex. Non-manifold boundary edges are treated as infinitely
thin cylinders that cast normals in all perpendicular directions.
Since this is useful for the constraint, and having multiple
objects with constraints targeting the same guide mesh is a quite
reasonable use case, rather than calculating the mesh boundary edge
data over and over again, it is precomputed and cached in the mesh.
Reviewers: mont29
Differential Revision: https://developer.blender.org/D3836
2018-11-06 19:04:53 +01:00
|
|
|
/* Mapping from vertex index to boundary vertex index, or -1.
|
|
|
|
* Used for compact storage of data about boundary vertices. */
|
2023-12-04 21:22:00 +01:00
|
|
|
blender::Array<int> vert_boundary_id;
|
2019-04-17 06:17:24 +02:00
|
|
|
|
Shrinkwrap: new mode that projects along the target normal.
The Nearest Surface Point shrink method, while fast, is neither
smooth nor continuous: as the source point moves, the projected
point can both stop and jump. This causes distortions in the
deformation of the shrinkwrap modifier, and the motion of an
animated object with a shrinkwrap constraint.
This patch implements a new mode, which, instead of using the simple
nearest point search, iteratively solves an equation for each triangle
to find a point which has its interpolated normal point to or from the
original vertex. Non-manifold boundary edges are treated as infinitely
thin cylinders that cast normals in all perpendicular directions.
Since this is useful for the constraint, and having multiple
objects with constraints targeting the same guide mesh is a quite
reasonable use case, rather than calculating the mesh boundary edge
data over and over again, it is precomputed and cached in the mesh.
Reviewers: mont29
Differential Revision: https://developer.blender.org/D3836
2018-11-06 19:04:53 +01:00
|
|
|
/* Direction data about boundary vertices. */
|
2023-12-04 21:22:00 +01:00
|
|
|
blender::Array<ShrinkwrapBoundaryVertData> boundary_verts;
|
2023-11-28 22:13:09 +01:00
|
|
|
};
|
Shrinkwrap: new mode that projects along the target normal.
The Nearest Surface Point shrink method, while fast, is neither
smooth nor continuous: as the source point moves, the projected
point can both stop and jump. This causes distortions in the
deformation of the shrinkwrap modifier, and the motion of an
animated object with a shrinkwrap constraint.
This patch implements a new mode, which, instead of using the simple
nearest point search, iteratively solves an equation for each triangle
to find a point which has its interpolated normal point to or from the
original vertex. Non-manifold boundary edges are treated as infinitely
thin cylinders that cast normals in all perpendicular directions.
Since this is useful for the constraint, and having multiple
objects with constraints targeting the same guide mesh is a quite
reasonable use case, rather than calculating the mesh boundary edge
data over and over again, it is precomputed and cached in the mesh.
Reviewers: mont29
Differential Revision: https://developer.blender.org/D3836
2018-11-06 19:04:53 +01:00
|
|
|
|
2021-12-07 07:19:15 +01:00
|
|
|
/**
|
|
|
|
* Free boundary data for target project.
|
|
|
|
*/
|
2023-11-28 22:13:09 +01:00
|
|
|
void BKE_shrinkwrap_compute_boundary_data(Mesh *mesh);
|
Shrinkwrap: new mode that projects along the target normal.
The Nearest Surface Point shrink method, while fast, is neither
smooth nor continuous: as the source point moves, the projected
point can both stop and jump. This causes distortions in the
deformation of the shrinkwrap modifier, and the motion of an
animated object with a shrinkwrap constraint.
This patch implements a new mode, which, instead of using the simple
nearest point search, iteratively solves an equation for each triangle
to find a point which has its interpolated normal point to or from the
original vertex. Non-manifold boundary edges are treated as infinitely
thin cylinders that cast normals in all perpendicular directions.
Since this is useful for the constraint, and having multiple
objects with constraints targeting the same guide mesh is a quite
reasonable use case, rather than calculating the mesh boundary edge
data over and over again, it is precomputed and cached in the mesh.
Reviewers: mont29
Differential Revision: https://developer.blender.org/D3836
2018-11-06 19:04:53 +01:00
|
|
|
|
|
|
|
/* Information about a mesh and BVH tree. */
|
2023-11-28 22:13:09 +01:00
|
|
|
struct ShrinkwrapTreeData {
|
2018-10-03 18:09:43 +02:00
|
|
|
Mesh *mesh;
|
2008-05-07 14:45:02 +02:00
|
|
|
|
2018-10-03 18:09:43 +02:00
|
|
|
BVHTree *bvh;
|
|
|
|
BVHTreeFromMesh treeData;
|
2008-04-30 19:55:26 +02:00
|
|
|
|
2023-11-28 22:40:43 +01:00
|
|
|
blender::OffsetIndices<int> faces;
|
|
|
|
blender::Span<int> corner_edges;
|
|
|
|
|
|
|
|
blender::Span<blender::float3> face_normals;
|
|
|
|
blender::Span<blender::float3> vert_normals;
|
|
|
|
blender::Span<blender::float3> corner_normals;
|
Mesh: Move face shade smooth flag to a generic attribute
Currently the shade smooth status for mesh faces is stored as part of
`MPoly::flag`. As described in #95967, this moves that information
to a separate boolean attribute. It also flips its status, so the
attribute is now called `sharp_face`, which mirrors the existing
`sharp_edge` attribute. The attribute doesn't need to be allocated
when all faces are smooth. Forward compatibility is kept until
4.0 like the other mesh refactors.
This will reduce memory bandwidth requirements for some operations,
since the array of booleans uses 12 times less memory than `MPoly`.
It also allows faces to be stored more efficiently in the future, since
the flag is now unused. It's also possible to use generic functions to
process the values. For example, finding whether there is a sharp face
is just `sharp_faces.contains(true)`.
The `shade_smooth` attribute is no longer accessible with geometry nodes.
Since there were dedicated accessor nodes for that data, that shouldn't
be a problem. That's difficult to version automatically since the named
attribute nodes could be used in arbitrary combinations.
**Implementation notes:**
- The attribute and array variables in the code use the `sharp_faces`
term, to be consistent with the user-facing "sharp faces" wording,
and to avoid requiring many renames when #101689 is implemented.
- Cycles now accesses smooth face status with the generic attribute,
to avoid overhead.
- Changing the zero-value from "smooth" to "flat" takes some care to
make sure defaults are the same.
- Versioning for the edge mode extrude node is particularly complex.
New nodes are added by versioning to propagate the attribute in its
old inverted state.
- A lot of access is still done through the `CustomData` API rather
than the attribute API because of a few functions. That can be
cleaned up easily in the future.
- In the future we would benefit from a way to store attributes as a
single value for when all faces are sharp.
Pull Request: https://projects.blender.org/blender/blender/pulls/104422
2023-03-08 15:36:18 +01:00
|
|
|
const bool *sharp_faces;
|
Shrinkwrap: new mode that projects along the target normal.
The Nearest Surface Point shrink method, while fast, is neither
smooth nor continuous: as the source point moves, the projected
point can both stop and jump. This causes distortions in the
deformation of the shrinkwrap modifier, and the motion of an
animated object with a shrinkwrap constraint.
This patch implements a new mode, which, instead of using the simple
nearest point search, iteratively solves an equation for each triangle
to find a point which has its interpolated normal point to or from the
original vertex. Non-manifold boundary edges are treated as infinitely
thin cylinders that cast normals in all perpendicular directions.
Since this is useful for the constraint, and having multiple
objects with constraints targeting the same guide mesh is a quite
reasonable use case, rather than calculating the mesh boundary edge
data over and over again, it is precomputed and cached in the mesh.
Reviewers: mont29
Differential Revision: https://developer.blender.org/D3836
2018-11-06 19:04:53 +01:00
|
|
|
ShrinkwrapBoundaryData *boundary;
|
2023-11-28 22:13:09 +01:00
|
|
|
};
|
2008-07-22 13:50:50 +02:00
|
|
|
|
2021-12-07 07:19:15 +01:00
|
|
|
/**
|
|
|
|
* Checks if the modifier needs target normals with these settings.
|
|
|
|
*/
|
2018-10-03 18:09:43 +02:00
|
|
|
bool BKE_shrinkwrap_needs_normals(int shrinkType, int shrinkMode);
|
2008-04-30 19:55:26 +02:00
|
|
|
|
2021-12-07 07:19:15 +01:00
|
|
|
/**
|
|
|
|
* Initializes the mesh data structure from the given mesh and settings.
|
|
|
|
*/
|
2023-11-28 22:13:09 +01:00
|
|
|
bool BKE_shrinkwrap_init_tree(
|
|
|
|
ShrinkwrapTreeData *data, Mesh *mesh, int shrinkType, int shrinkMode, bool force_normals);
|
2008-11-04 00:17:36 +01:00
|
|
|
|
2021-12-07 07:19:15 +01:00
|
|
|
/**
|
|
|
|
* Frees the tree data if necessary.
|
|
|
|
*/
|
2023-11-28 22:13:09 +01:00
|
|
|
void BKE_shrinkwrap_free_tree(ShrinkwrapTreeData *data);
|
2008-04-30 19:55:26 +02:00
|
|
|
|
2021-12-07 07:19:15 +01:00
|
|
|
/**
|
|
|
|
* Main shrink-wrap function (implementation of the shrink-wrap modifier).
|
|
|
|
*/
|
2023-11-28 22:13:09 +01:00
|
|
|
void shrinkwrapModifier_deform(ShrinkwrapModifierData *smd,
|
|
|
|
const ModifierEvalContext *ctx,
|
|
|
|
Scene *scene,
|
|
|
|
Object *ob,
|
|
|
|
Mesh *mesh,
|
|
|
|
const MDeformVert *dvert,
|
2022-01-07 01:38:08 +01:00
|
|
|
int defgrp_index,
|
2018-11-26 20:43:35 +01:00
|
|
|
float (*vertexCos)[3],
|
|
|
|
int numVerts);
|
2021-12-13 17:09:22 +01:00
|
|
|
/* Implementation of the Shrinkwrap Grease Pencil modifier. */
|
2023-11-28 22:13:09 +01:00
|
|
|
void shrinkwrapGpencilModifier_deform(ShrinkwrapGpencilModifierData *mmd,
|
|
|
|
Object *ob,
|
|
|
|
MDeformVert *dvert,
|
2022-01-07 01:38:08 +01:00
|
|
|
int defgrp_index,
|
2021-12-13 17:09:22 +01:00
|
|
|
float (*vertexCos)[3],
|
|
|
|
int numVerts);
|
2008-08-12 22:43:10 +02:00
|
|
|
|
2021-12-07 07:19:15 +01:00
|
|
|
/**
|
2023-02-07 21:56:45 +01:00
|
|
|
* Used in `editmesh_mask_extract.cc` to shrink-wrap the extracted mesh to the sculpt.
|
2021-12-07 07:19:15 +01:00
|
|
|
*/
|
2023-12-04 21:29:40 +01:00
|
|
|
void BKE_shrinkwrap_mesh_nearest_surface_deform(Depsgraph *depsgraph,
|
|
|
|
Scene *scene,
|
|
|
|
Object *ob_source,
|
|
|
|
Object *ob_target);
|
2019-09-10 15:18:51 +02:00
|
|
|
|
2021-12-07 07:19:15 +01:00
|
|
|
/**
|
|
|
|
* Used in `object_remesh.cc` to preserve the details and volume in the voxel remesher.
|
|
|
|
*/
|
2023-11-28 22:13:09 +01:00
|
|
|
void BKE_shrinkwrap_remesh_target_project(Mesh *src_me, Mesh *target_me, Object *ob_target);
|
2019-09-26 16:28:56 +02:00
|
|
|
|
2021-12-07 07:19:15 +01:00
|
|
|
/**
|
|
|
|
* This function ray-cast a single vertex and updates the hit if the "hit" is considered valid.
|
2008-08-12 22:43:10 +02:00
|
|
|
*
|
2021-12-07 07:19:15 +01:00
|
|
|
* \param options: Opts control whether an hit is valid or not.
|
|
|
|
* Supported options are:
|
|
|
|
* - #MOD_SHRINKWRAP_CULL_TARGET_FRONTFACE (front faces hits are ignored)
|
|
|
|
* - #MOD_SHRINKWRAP_CULL_TARGET_BACKFACE (back faces hits are ignored)
|
2008-08-12 22:43:10 +02:00
|
|
|
*
|
2021-12-07 07:19:15 +01:00
|
|
|
* \param transf: Take into consideration the space_transform, that is:
|
|
|
|
* if `transf` was configured with `SPACE_TRANSFORM_SETUP( &transf, ob1, ob2)`
|
|
|
|
* then the input (vert, dir, #BVHTreeRayHit) must be defined in ob1 coordinates space
|
|
|
|
* and the #BVHTree must be built in ob2 coordinate space.
|
2012-12-23 02:18:35 +01:00
|
|
|
* Thus it provides an easy way to cast the same ray across several trees
|
2021-12-07 07:19:15 +01:00
|
|
|
* (where each tree was built on its own coords space).
|
|
|
|
*
|
|
|
|
* \return true if "hit" was updated.
|
2008-08-12 22:43:10 +02:00
|
|
|
*/
|
2014-03-20 12:56:28 +01:00
|
|
|
bool BKE_shrinkwrap_project_normal(char options,
|
2018-05-04 12:39:07 +02:00
|
|
|
const float vert[3],
|
|
|
|
const float dir[3],
|
2022-01-07 01:38:08 +01:00
|
|
|
float ray_radius,
|
2023-11-28 22:13:09 +01:00
|
|
|
const SpaceTransform *transf,
|
|
|
|
ShrinkwrapTreeData *tree,
|
2018-10-03 18:09:43 +02:00
|
|
|
BVHTreeRayHit *hit);
|
|
|
|
|
2021-12-07 07:19:15 +01:00
|
|
|
/**
|
|
|
|
* Maps the point to the nearest surface, either by simple nearest, or by target normal projection.
|
|
|
|
*/
|
2023-11-28 22:13:09 +01:00
|
|
|
void BKE_shrinkwrap_find_nearest_surface(ShrinkwrapTreeData *tree,
|
|
|
|
BVHTreeNearest *nearest,
|
Shrinkwrap: new mode that projects along the target normal.
The Nearest Surface Point shrink method, while fast, is neither
smooth nor continuous: as the source point moves, the projected
point can both stop and jump. This causes distortions in the
deformation of the shrinkwrap modifier, and the motion of an
animated object with a shrinkwrap constraint.
This patch implements a new mode, which, instead of using the simple
nearest point search, iteratively solves an equation for each triangle
to find a point which has its interpolated normal point to or from the
original vertex. Non-manifold boundary edges are treated as infinitely
thin cylinders that cast normals in all perpendicular directions.
Since this is useful for the constraint, and having multiple
objects with constraints targeting the same guide mesh is a quite
reasonable use case, rather than calculating the mesh boundary edge
data over and over again, it is precomputed and cached in the mesh.
Reviewers: mont29
Differential Revision: https://developer.blender.org/D3836
2018-11-06 19:04:53 +01:00
|
|
|
float co[3],
|
|
|
|
int type);
|
|
|
|
|
2021-12-07 07:19:15 +01:00
|
|
|
/**
|
|
|
|
* Compute a smooth normal of the target (if applicable) at the hit location.
|
|
|
|
*
|
|
|
|
* \param tree: information about the mesh.
|
|
|
|
* \param transform: transform from the hit coordinate space to the object space; may be null.
|
|
|
|
* \param r_no: output in hit coordinate space; may be shared with inputs.
|
|
|
|
*/
|
2023-11-28 22:13:09 +01:00
|
|
|
void BKE_shrinkwrap_compute_smooth_normal(const ShrinkwrapTreeData *tree,
|
|
|
|
const SpaceTransform *transform,
|
2023-12-19 14:57:49 +01:00
|
|
|
int tri_idx,
|
2018-10-03 18:09:43 +02:00
|
|
|
const float hit_co[3],
|
|
|
|
const float hit_no[3],
|
|
|
|
float r_no[3]);
|
2008-08-12 22:43:10 +02:00
|
|
|
|
2021-12-07 07:19:15 +01:00
|
|
|
/**
|
|
|
|
* Apply the shrink to surface modes to the given original coordinates and nearest point.
|
|
|
|
*
|
|
|
|
* \param tree: mesh data for smooth normals.
|
|
|
|
* \param transform: transform from the hit coordinate space to the object space; may be null.
|
|
|
|
* \param r_point_co: may be the same memory location as `point_co`, `hit_co`, or `hit_no`.
|
|
|
|
*/
|
2023-11-28 22:13:09 +01:00
|
|
|
void BKE_shrinkwrap_snap_point_to_surface(const ShrinkwrapTreeData *tree,
|
|
|
|
const SpaceTransform *transform,
|
2018-10-03 18:09:43 +02:00
|
|
|
int mode,
|
|
|
|
int hit_idx,
|
|
|
|
const float hit_co[3],
|
|
|
|
const float hit_no[3],
|
|
|
|
float goal_dist,
|
2018-07-07 17:39:45 +02:00
|
|
|
const float point_co[3],
|
|
|
|
float r_point_co[3]);
|
|
|
|
|
2008-08-12 22:43:10 +02:00
|
|
|
/*
|
2020-03-11 11:39:56 +01:00
|
|
|
* NULL initializes to local data
|
2008-08-12 22:43:10 +02:00
|
|
|
*/
|
2012-05-12 22:39:39 +02:00
|
|
|
#define NULL_ShrinkwrapCalcData \
|
|
|
|
{ \
|
|
|
|
NULL, \
|
|
|
|
}
|
|
|
|
#define NULL_BVHTreeFromMesh \
|
|
|
|
{ \
|
|
|
|
NULL, \
|
|
|
|
}
|
|
|
|
#define NULL_BVHTreeRayHit \
|
|
|
|
{ \
|
|
|
|
NULL, \
|
|
|
|
}
|
|
|
|
#define NULL_BVHTreeNearest \
|
2019-04-17 06:17:24 +02:00
|
|
|
{ \
|
2012-05-12 22:39:39 +02:00
|
|
|
0, \
|
2019-04-17 06:17:24 +02:00
|
|
|
}
|