griefith/test2
1
0
Fork 0
Code Issues Pull Requests Actions 1 Packages Projects Releases Wiki Activity

Cleanup: Use standard variable name for mesh face corner normals

Browse Source
This commit is contained in:
Hans Goudey
2024-01-15 11:39:50 -05:00
parent 62dbef895b
commit 78587261da
18 changed files with 74 additions and 74 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
source/blender/blenkernel/BKE_editmesh_tangent.hh
View File

@@ -24,7 +24,7 @@ void BKE_editmesh_loop_tangent_calc(BMEditMesh *em,
const char (*tangent_names)[MAX_CUSTOMDATA_LAYER_NAME],
int tangent_names_len,
const float (*face_normals)[3],
const float (*loop_normals)[3],
const float (*corner_normals)[3],
const float (*vert_orco)[3],
CustomData *dm_loopdata_out,
uint dm_loopdata_out_len,

4
source/blender/blenkernel/BKE_mesh_tangent.hh
View File

@@ -25,7 +25,7 @@ void BKE_mesh_calc_loop_tangent_single_ex(const float (*vert_positions)[3],
int numVerts,
const int *corner_verts,
float (*r_looptangent)[4],
const float (*loop_normals)[3],
const float (*corner_normals)[3],
const float (*loopuv)[2],
int numLoops,
blender::OffsetIndices<int> faces,
@@ -59,7 +59,7 @@ void BKE_mesh_calc_loop_tangent_ex(const float (*vert_positions)[3],
int tangent_names_len,
const float (*vert_normals)[3],
const float (*face_normals)[3],
const float (*loop_normals)[3],
const float (*corner_normals)[3],
const float (*vert_orco)[3],
/* result */
CustomData *loopdata_out,

4
source/blender/blenkernel/BKE_mesh_types.hh
View File

@@ -170,9 +170,9 @@ struct MeshRuntime {
/** Lazily computed vertex normals (#Mesh::vert_normals()). */
SharedCache<Vector<float3>> vert_normals_cache;
/** Lazily computed face normals (#Mesh::vert_normals()). */
/** Lazily computed face normals (#Mesh::face_normals()). */
SharedCache<Vector<float3>> face_normals_cache;
/** Lazily computed face corner normals (#Mesh::vert_normals()). */
/** Lazily computed face corner normals (#Mesh::corner_normals()). */
SharedCache<Vector<float3>> corner_normals_cache;
/**

12
source/blender/blenkernel/intern/mesh_mirror.cc
View File

@@ -396,7 +396,7 @@ Mesh *BKE_mesh_mirror_apply_mirror_on_axis_for_modifier(MirrorModifierData *mmd,
if (ob->type == OB_MESH && CustomData_has_layer(&result->corner_data, CD_CUSTOMLOOPNORMAL) &&
result->faces_num > 0)
{
blender::Array<blender::float3> loop_normals(result_corner_verts.size());
blender::Array<blender::float3> corner_normals(result_corner_verts.size());
blender::short2 *clnors = static_cast<blender::short2 *>(CustomData_get_layer_for_write(
&result->corner_data, CD_CUSTOMLOOPNORMAL, result->corners_num));
blender::bke::mesh::CornerNormalSpaceArray lnors_spacearr;
@@ -407,7 +407,7 @@ Mesh *BKE_mesh_mirror_apply_mirror_on_axis_for_modifier(MirrorModifierData *mmd,
invert_m4_m4(mtx_nor, mtx);
transpose_m4(mtx_nor);
/* calculate custom normals into loop_normals, then mirror first half into second half */
/* calculate custom normals into corner_normals, then mirror first half into second half */
const bke::AttributeAccessor attributes = result->attributes();
const VArraySpan sharp_edges = *attributes.lookup<bool>("sharp_edge", AttrDomain::Edge);
const VArraySpan sharp_faces = *attributes.lookup<bool>("sharp_face", AttrDomain::Face);
@@ -423,7 +423,7 @@ Mesh *BKE_mesh_mirror_apply_mirror_on_axis_for_modifier(MirrorModifierData *mmd,
sharp_faces,
clnors,
&lnors_spacearr,
loop_normals);
corner_normals);
/* mirroring has to account for loops being reversed in faces in second half */
for (const int i : src_faces.index_range()) {
@@ -436,12 +436,12 @@ Mesh *BKE_mesh_mirror_apply_mirror_on_axis_for_modifier(MirrorModifierData *mmd,
mirrorj += result_faces[mirror_i].size() - (j - src_face.start());
}
copy_v3_v3(loop_normals[mirrorj], loop_normals[j]);
mul_m4_v3(mtx_nor, loop_normals[mirrorj]);
copy_v3_v3(corner_normals[mirrorj], corner_normals[j]);
mul_m4_v3(mtx_nor, corner_normals[mirrorj]);
const int space_index = lnors_spacearr.corner_space_indices[mirrorj];
clnors[mirrorj] = blender::bke::mesh::corner_space_custom_normal_to_data(
lnors_spacearr.spaces[space_index], loop_normals[mirrorj]);
lnors_spacearr.spaces[space_index], corner_normals[mirrorj]);
}
}
}

12
source/blender/blenkernel/intern/mesh_tangent.cc
View File

@@ -61,7 +61,7 @@ struct BKEMeshToTangent {
mikk::float3 GetNormal(const uint face_num, const uint vert_num)
{
return mikk::float3(loop_normals[uint(faces[face_num].start()) + vert_num]);
return mikk::float3(corner_normals[uint(faces[face_num].start()) + vert_num]);
}
void SetTangentSpace(const uint face_num, const uint vert_num, mikk::float3 T, bool orientation)
@@ -74,7 +74,7 @@ struct BKEMeshToTangent {
const int *corner_verts; /* faces vertices */
const float (*positions)[3]; /* vertices */
const float (*luvs)[2]; /* texture coordinates */
const float (*loop_normals)[3]; /* loops' normals */
const float (*corner_normals)[3]; /* loops' normals */
float (*tangents)[4]; /* output tangents */
int num_faces; /* number of polygons */
};
@@ -83,7 +83,7 @@ void BKE_mesh_calc_loop_tangent_single_ex(const float (*vert_positions)[3],
const int /*numVerts*/,
const int *corner_verts,
float (*r_looptangent)[4],
const float (*loop_normals)[3],
const float (*corner_normals)[3],
const float (*loop_uvs)[2],
const int /*numLoops*/,
const blender::OffsetIndices<int> faces,
@@ -95,7 +95,7 @@ void BKE_mesh_calc_loop_tangent_single_ex(const float (*vert_positions)[3],
mesh_to_tangent.corner_verts = corner_verts;
mesh_to_tangent.positions = vert_positions;
mesh_to_tangent.luvs = loop_uvs;
mesh_to_tangent.loop_normals = loop_normals;
mesh_to_tangent.corner_normals = corner_normals;
mesh_to_tangent.tangents = r_looptangent;
mesh_to_tangent.num_faces = int(faces.size());
@@ -401,7 +401,7 @@ void BKE_mesh_calc_loop_tangent_ex(const float (*vert_positions)[3],
int tangent_names_len,
const float (*vert_normals)[3],
const float (*face_normals)[3],
const float (*loop_normals)[3],
const float (*corner_normals)[3],
const float (*vert_orco)[3],
/* result */
CustomData *loopdata_out,
@@ -503,7 +503,7 @@ void BKE_mesh_calc_loop_tangent_ex(const float (*vert_positions)[3],
mesh2tangent->sharp_faces = sharp_faces;
/* NOTE: we assume we do have tessellated loop normals at this point
* (in case it is object-enabled), have to check this is valid. */
mesh2tangent->precomputedLoopNormals = loop_normals;
mesh2tangent->precomputedLoopNormals = corner_normals;
mesh2tangent->precomputedFaceNormals = face_normals;
mesh2tangent->orco = nullptr;

4
source/blender/draw/intern/draw_cache_extract_mesh_render_data.cc
View File

@@ -490,7 +490,7 @@ void mesh_render_data_update_normals(MeshRenderData &mr, const eMRDataType data_
mr.normals_domain == bke::MeshNormalDomain::Corner) ||
(data_flag & MR_DATA_TAN_LOOP_NOR))
{
mr.loop_normals = mr.mesh->corner_normals();
mr.corner_normals = mr.mesh->corner_normals();
}
}
else {
@@ -525,7 +525,7 @@ void mesh_render_data_update_normals(MeshRenderData &mr, const eMRDataType data_
nullptr,
clnors_offset,
false);
mr.loop_normals = mr.bm_loop_normals;
mr.corner_normals = mr.bm_loop_normals;
}
}
}

2
source/blender/draw/intern/mesh_extractors/extract_mesh.hh
View File

@@ -102,7 +102,7 @@ struct MeshRenderData {
bke::MeshNormalDomain normals_domain;
Span<float3> vert_normals;
Span<float3> face_normals;
Span<float3> loop_normals;
Span<float3> corner_normals;
VArraySpan<bool> hide_vert;
VArraySpan<bool> hide_edge;

16
source/blender/draw/intern/mesh_extractors/extract_mesh_vbo_lnor.cc
View File

@@ -42,8 +42,8 @@ static void extract_lnor_iter_face_bm(const MeshRenderData &mr,
l_iter = l_first = BM_FACE_FIRST_LOOP(f);
do {
const int l_index = BM_elem_index_get(l_iter);
if (!mr.loop_normals.is_empty()) {
(*(GPUPackedNormal **)data)[l_index] = GPU_normal_convert_i10_v3(mr.loop_normals[l_index]);
if (!mr.corner_normals.is_empty()) {
(*(GPUPackedNormal **)data)[l_index] = GPU_normal_convert_i10_v3(mr.corner_normals[l_index]);
}
else {
if (BM_elem_flag_test(f, BM_ELEM_SMOOTH)) {
@@ -65,8 +65,8 @@ static void extract_lnor_iter_face_mesh(const MeshRenderData &mr, const int face
for (const int corner : mr.faces[face_index]) {
const int vert = mr.corner_verts[corner];
GPUPackedNormal *lnor_data = &(*(GPUPackedNormal **)data)[corner];
if (!mr.loop_normals.is_empty()) {
*lnor_data = GPU_normal_convert_i10_v3(mr.loop_normals[corner]);
if (!mr.corner_normals.is_empty()) {
*lnor_data = GPU_normal_convert_i10_v3(mr.corner_normals[corner]);
}
else if (mr.normals_domain == bke::MeshNormalDomain::Face ||
(!mr.sharp_faces.is_empty() && mr.sharp_faces[face_index]))
@@ -165,8 +165,8 @@ static void extract_lnor_hq_iter_face_bm(const MeshRenderData &mr,
l_iter = l_first = BM_FACE_FIRST_LOOP(f);
do {
const int l_index = BM_elem_index_get(l_iter);
if (!mr.loop_normals.is_empty()) {
normal_float_to_short_v3(&(*(gpuHQNor **)data)[l_index].x, mr.loop_normals[l_index]);
if (!mr.corner_normals.is_empty()) {
normal_float_to_short_v3(&(*(gpuHQNor **)data)[l_index].x, mr.corner_normals[l_index]);
}
else {
if (BM_elem_flag_test(f, BM_ELEM_SMOOTH)) {
@@ -188,8 +188,8 @@ static void extract_lnor_hq_iter_face_mesh(const MeshRenderData &mr,
for (const int corner : mr.faces[face_index]) {
const int vert = mr.corner_verts[corner];
gpuHQNor *lnor_data = &(*(gpuHQNor **)data)[corner];
if (!mr.loop_normals.is_empty()) {
normal_float_to_short_v3(&lnor_data->x, mr.loop_normals[corner]);
if (!mr.corner_normals.is_empty()) {
normal_float_to_short_v3(&lnor_data->x, mr.corner_normals[corner]);
}
else if (mr.normals_domain == bke::MeshNormalDomain::Face ||
(!mr.sharp_faces.is_empty() && mr.sharp_faces[face_index]))

4
source/blender/draw/intern/mesh_extractors/extract_mesh_vbo_tan.cc
View File

@@ -111,7 +111,7 @@ static void extract_tan_init_common(const MeshRenderData &mr,
r_tangent_names,
tan_len,
reinterpret_cast<const float(*)[3]>(mr.face_normals.data()),
reinterpret_cast<const float(*)[3]>(mr.loop_normals.data()),
reinterpret_cast<const float(*)[3]>(mr.corner_normals.data()),
orco,
r_loop_data,
mr.loop_len,
@@ -131,7 +131,7 @@ static void extract_tan_init_common(const MeshRenderData &mr,
tan_len,
reinterpret_cast<const float(*)[3]>(mr.vert_normals.data()),
reinterpret_cast<const float(*)[3]>(mr.face_normals.data()),
reinterpret_cast<const float(*)[3]>(mr.loop_normals.data()),
reinterpret_cast<const float(*)[3]>(mr.corner_normals.data()),
orco,
r_loop_data,
mr.corner_verts.size(),

8
source/blender/freestyle/intern/blender_interface/BlenderFileLoader.cpp
View File

@@ -428,7 +428,7 @@ void BlenderFileLoader::insertShapeNode(Object *ob, Mesh *mesh, int id)
blender::bke::mesh::corner_tris_calc(
vert_positions, mesh_polys, corner_verts, {corner_tris, tottri});
const blender::Span<int> tri_faces = mesh->corner_tri_faces();
const blender::Span<blender::float3> lnors = mesh->corner_normals();
const blender::Span<blender::float3> corner_normals = mesh->corner_normals();
// Get other mesh data
const FreestyleEdge *fed = (const FreestyleEdge *)CustomData_get_layer(&mesh->edge_data,
@@ -546,9 +546,9 @@ void BlenderFileLoader::insertShapeNode(Object *ob, Mesh *mesh, int id)
v3[2] += _z_offset;
if (_smooth && (!sharp_faces[poly_i])) {
copy_v3_v3(n1, lnors[tri[0]]);
copy_v3_v3(n2, lnors[tri[1]]);
copy_v3_v3(n3, lnors[tri[2]]);
copy_v3_v3(n1, corner_normals[tri[0]]);
copy_v3_v3(n2, corner_normals[tri[1]]);
copy_v3_v3(n3, corner_normals[tri[2]]);
mul_mat3_m4_v3(nmat, n1);
mul_mat3_m4_v3(nmat, n2);

8
source/blender/io/wavefront_obj/importer/obj_import_mesh.cc
View File

@@ -372,7 +372,7 @@ void MeshFromGeometry::create_normals(Mesh *mesh)
return;
}
float(*loop_normals)[3] = static_cast<float(*)[3]>(
float(*corner_normals)[3] = static_cast<float(*)[3]>(
MEM_malloc_arrayN(mesh_geometry_.total_loops_, sizeof(float[3]), __func__));
int tot_loop_idx = 0;
for (const PolyElem &curr_face : mesh_geometry_.face_elements_) {
@@ -383,12 +383,12 @@ void MeshFromGeometry::create_normals(Mesh *mesh)
if (n_index >= 0 && n_index < global_vertices_.vert_normals.size()) {
normal = global_vertices_.vert_normals[n_index];
}
copy_v3_v3(loop_normals[tot_loop_idx], normal);
copy_v3_v3(corner_normals[tot_loop_idx], normal);
tot_loop_idx++;
}
}
BKE_mesh_set_custom_normals(mesh, loop_normals);
MEM_freeN(loop_normals);
BKE_mesh_set_custom_normals(mesh, corner_normals);
MEM_freeN(corner_normals);
}
void MeshFromGeometry::create_colors(Mesh *mesh)

8
source/blender/io/wavefront_obj/tests/obj_importer_tests.cc
View File

@@ -137,10 +137,10 @@ class obj_importer_test : public BlendfileLoadingBaseTest {
const Span<float3> positions = mesh->vert_positions();
EXPECT_V3_NEAR(positions.first(), exp.vert_first, 0.0001f);
EXPECT_V3_NEAR(positions.last(), exp.vert_last, 0.0001f);
const float3 *lnors = mesh->normals_domain() == bke::MeshNormalDomain::Corner ?
mesh->corner_normals().data() :
nullptr;
float3 normal_first = lnors != nullptr ? lnors[0] : float3(0, 0, 0);
const float3 *corner_normals = mesh->normals_domain() == bke::MeshNormalDomain::Corner ?
mesh->corner_normals().data() :
nullptr;
float3 normal_first = corner_normals != nullptr ? corner_normals[0] : float3(0, 0, 0);
EXPECT_V3_NEAR(normal_first, exp.normal_first, 0.0001f);
const float2 *mloopuv = static_cast<const float2 *>(
CustomData_get_layer(&mesh->corner_data, CD_PROP_FLOAT2));

8
source/blender/makesrna/intern/rna_mesh.cc
View File

@@ -705,11 +705,11 @@ static void rna_MeshLoopTriangle_normal_get(PointerRNA *ptr, float *values)
static void rna_MeshLoopTriangle_split_normals_get(PointerRNA *ptr, float *values)
{
Mesh *mesh = rna_mesh(ptr);
const blender::Span<blender::float3> loop_normals = mesh->corner_normals();
const blender::Span<blender::float3> corner_normals = mesh->corner_normals();
const blender::int3 tri = *(const blender::int3 *)ptr->data;
copy_v3_v3(values + 0, loop_normals[tri[0]]);
copy_v3_v3(values + 3, loop_normals[tri[1]]);
copy_v3_v3(values + 6, loop_normals[tri[2]]);
copy_v3_v3(values + 0, corner_normals[tri[0]]);
copy_v3_v3(values + 3, corner_normals[tri[1]]);
copy_v3_v3(values + 6, corner_normals[tri[2]]);
}
static float rna_MeshLoopTriangle_area_get(PointerRNA *ptr)

4
source/blender/makesrna/intern/rna_mesh_api.cc
View File

@@ -109,7 +109,7 @@ static void rna_Mesh_normals_split_custom_set(Mesh *mesh,
const float *normals,
int normals_num)
{
float(*loop_normals)[3] = (float(*)[3])normals;
float(*corner_normals)[3] = (float(*)[3])normals;
const int numloops = mesh->corners_num;
if (normals_num != numloops * 3) {
BKE_reportf(reports,
@@ -120,7 +120,7 @@ static void rna_Mesh_normals_split_custom_set(Mesh *mesh,
return;
}
BKE_mesh_set_custom_normals(mesh, loop_normals);
BKE_mesh_set_custom_normals(mesh, corner_normals);
DEG_id_tag_update(&mesh->id, 0);
}

4
source/blender/modifiers/intern/MOD_multires.cc
View File

@@ -260,9 +260,9 @@ static Mesh *modify_mesh(ModifierData *md, const ModifierEvalContext *ctx, Mesh
result = multires_as_mesh(mmd, ctx, mesh, subdiv);
if (use_clnors) {
float(*lnors)[3] = static_cast<float(*)[3]>(
float(*corner_normals)[3] = static_cast<float(*)[3]>(
CustomData_get_layer_for_write(&result->corner_data, CD_NORMAL, result->corners_num));
BKE_mesh_set_custom_normals(result, lnors);
BKE_mesh_set_custom_normals(result, corner_normals);
CustomData_free_layers(&result->corner_data, CD_NORMAL, result->corners_num);
}
// BKE_subdiv_stats_print(&subdiv->stats);

22
source/blender/modifiers/intern/MOD_normal_edit.cc
View File

@@ -219,7 +219,7 @@ static void normalEditModifier_do_radial(NormalEditModifierData *enmd,
Object *ob,
Mesh *mesh,
blender::MutableSpan<blender::short2> clnors,
blender::MutableSpan<blender::float3> loop_normals,
blender::MutableSpan<blender::float3> corner_normals,
const short mix_mode,
const float mix_factor,
const float mix_limit,
@@ -307,7 +307,7 @@ static void normalEditModifier_do_radial(NormalEditModifierData *enmd,
}
}
if (!loop_normals.is_empty()) {
if (!corner_normals.is_empty()) {
mix_normals(mix_factor,
dvert,
defgrp_index,
@@ -316,7 +316,7 @@ static void normalEditModifier_do_radial(NormalEditModifierData *enmd,
mix_mode,
vert_positions.size(),
corner_verts,
loop_normals.data(),
corner_normals.data(),
nos.data());
}
@@ -346,7 +346,7 @@ static void normalEditModifier_do_directional(NormalEditModifierData *enmd,
Object *ob,
Mesh *mesh,
blender::MutableSpan<blender::short2> clnors,
blender::MutableSpan<blender::float3> loop_normals,
blender::MutableSpan<blender::float3> corner_normals,
const short mix_mode,
const float mix_factor,
const float mix_limit,
@@ -413,7 +413,7 @@ static void normalEditModifier_do_directional(NormalEditModifierData *enmd,
MEM_freeN(cos);
}
if (!loop_normals.is_empty()) {
if (!corner_normals.is_empty()) {
mix_normals(mix_factor,
dvert,
defgrp_index,
@@ -422,7 +422,7 @@ static void normalEditModifier_do_directional(NormalEditModifierData *enmd,
mix_mode,
positions.size(),
corner_verts,
loop_normals.data(),
corner_normals.data(),
nos.data());
}
@@ -500,7 +500,7 @@ static Mesh *normalEditModifier_do(NormalEditModifierData *enmd,
int defgrp_index;
const MDeformVert *dvert;
blender::Array<blender::float3> loop_normals;
blender::Array<blender::float3> corner_normals;
CustomData *ldata = &result->corner_data;
@@ -513,7 +513,7 @@ static Mesh *normalEditModifier_do(NormalEditModifierData *enmd,
if (use_current_clnors) {
clnors = static_cast<blender::short2 *>(
CustomData_get_layer_for_write(ldata, CD_CUSTOMLOOPNORMAL, corner_verts.size()));
loop_normals.reinitialize(corner_verts.size());
corner_normals.reinitialize(corner_verts.size());
const VArraySpan sharp_faces = *attributes.lookup<bool>("sharp_face", bke::AttrDomain::Face);
blender::bke::mesh::normals_calc_corners(positions,
edges,
@@ -527,7 +527,7 @@ static Mesh *normalEditModifier_do(NormalEditModifierData *enmd,
sharp_faces,
clnors,
nullptr,
loop_normals);
corner_normals);
}
if (clnors == nullptr) {
@@ -543,7 +543,7 @@ static Mesh *normalEditModifier_do(NormalEditModifierData *enmd,
ob,
result,
{clnors, result->corners_num},
loop_normals,
corner_normals,
enmd->mix_mode,
enmd->mix_factor,
enmd->mix_limit,
@@ -563,7 +563,7 @@ static Mesh *normalEditModifier_do(NormalEditModifierData *enmd,
ob,
result,
{clnors, result->corners_num},
loop_normals,
corner_normals,
enmd->mix_mode,
enmd->mix_factor,
enmd->mix_limit,

4
source/blender/modifiers/intern/MOD_triangulate.cc
View File

@@ -72,9 +72,9 @@ static Mesh *triangulate_mesh(Mesh *mesh,
BM_mesh_free(bm);
if (keep_clnors) {
float(*lnors)[3] = static_cast<float(*)[3]>(
float(*corner_normals)[3] = static_cast<float(*)[3]>(
CustomData_get_layer_for_write(&result->corner_data, CD_NORMAL, result->corners_num));
BKE_mesh_set_custom_normals(result, lnors);
BKE_mesh_set_custom_normals(result, corner_normals);
CustomData_free_layers(&result->corner_data, CD_NORMAL, result->corners_num);
}

22
source/blender/modifiers/intern/MOD_weighted_normal.cc
View File

@@ -214,13 +214,13 @@ static void apply_weights_vertex_normal(WeightedNormalModifierData *wnmd,
face_strength != nullptr;
const bool has_vgroup = dvert != nullptr;
blender::Array<blender::float3> loop_normals;
blender::Array<blender::float3> corner_normals;
Array<WeightedNormalDataAggregateItem> items_data;
if (keep_sharp) {
/* This will give us loop normal spaces,
* we do not actually care about computed loop_normals for now... */
loop_normals.reinitialize(corner_verts.size());
* we do not actually care about computed corner_normals for now... */
corner_normals.reinitialize(corner_verts.size());
bke::mesh::normals_calc_corners(positions,
edges,
faces,
@@ -233,7 +233,7 @@ static void apply_weights_vertex_normal(WeightedNormalModifierData *wnmd,
wn_data->sharp_faces,
has_clnors ? clnors.data() : nullptr,
&lnors_spacearr,
loop_normals);
corner_normals);
WeightedNormalDataAggregateItem start_item{};
start_item.curr_strength = FACE_STRENGTH_WEAK;
@@ -295,14 +295,14 @@ static void apply_weights_vertex_normal(WeightedNormalModifierData *wnmd,
if (keep_sharp) {
/* Set loop normals for normal computed for each lnor space (smooth fan).
* Note that loop_normals is already populated with clnors
* Note that corner_normals is already populated with clnors
* (before this modifier is applied, at start of this function),
* so no need to recompute them here. */
for (int corner = 0; corner < corner_verts.size(); corner++) {
const int space_index = lnors_spacearr.corner_space_indices[corner];
WeightedNormalDataAggregateItem *item_data = &items_data[space_index];
if (!is_zero_v3(item_data->normal)) {
copy_v3_v3(loop_normals[corner], item_data->normal);
copy_v3_v3(corner_normals[corner], item_data->normal);
}
}
@@ -315,7 +315,7 @@ static void apply_weights_vertex_normal(WeightedNormalModifierData *wnmd,
face_normals,
wn_data->sharp_faces,
wn_data->sharp_edges,
loop_normals,
corner_normals,
clnors);
}
else {
@@ -348,7 +348,7 @@ static void apply_weights_vertex_normal(WeightedNormalModifierData *wnmd,
clnors);
}
else {
loop_normals.reinitialize(corner_verts.size());
corner_normals.reinitialize(corner_verts.size());
blender::bke::mesh::normals_calc_corners(positions,
edges,
faces,
@@ -361,12 +361,12 @@ static void apply_weights_vertex_normal(WeightedNormalModifierData *wnmd,
wn_data->sharp_faces,
has_clnors ? clnors.data() : nullptr,
nullptr,
loop_normals);
corner_normals);
for (int corner = 0; corner < corner_verts.size(); corner++) {
const int item_index = corner_verts[corner];
if (!is_zero_v3(items_data[item_index].normal)) {
copy_v3_v3(loop_normals[corner], items_data[item_index].normal);
copy_v3_v3(corner_normals[corner], items_data[item_index].normal);
}
}
blender::bke::mesh::normals_corner_custom_set(positions,
@@ -378,7 +378,7 @@ static void apply_weights_vertex_normal(WeightedNormalModifierData *wnmd,
face_normals,
wn_data->sharp_faces,
wn_data->sharp_edges,
loop_normals,
corner_normals,
clnors);
}
}