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

Mesh: Move freestyle tags to generic attributes

Browse Source 
This commit moves the freestyle edge and face mark tags to become
generic attributes, similar to other changes over the past years. The
attributes are called "freestyle_edge" and "freestyle_face", and they're
now propagated like regular boolean attributes.

Compatibility wise, forward and backward blend file compatibility are
maintained (for forward compatibility this is implemented a bit
differently than in the past because of the ongoing `AttributeStorage`
transition). In the Python API, `use_freestyle_mark` has been removed;
the attribute API should be used instead (just like bevel weights).
The BMesh (`freestyle`) accessors are removed too.

The conversions benefit from the fact that bit-wise, the old structs are
the same as `bool`, so we can convert to the old and new formats without
reallocating arrays.

Pull Request: https://projects.blender.org/blender/blender/pulls/141996
This commit is contained in:
Hans Goudey
2025-07-16 18:26:26 +02:00
committed by Hans Goudey
parent feb4122f62
commit b20ecee555
24 changed files with 265 additions and 267 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
scripts/startup/bl_operators/freestyle.py
View File

@@ -147,7 +147,7 @@ class SCENE_OT_freestyle_add_edge_marks_to_keying_set(Operator):
bpy.ops.object.mode_set(mode='OBJECT', toggle=False)
for i, edge in enumerate(mesh.edges):
if not edge.hide and edge.select:
path = "edges[{:d}].use_freestyle_mark".format(i)
path = "attributes[\"freestyle_edge\"].data[{:d}].value".format(i)
ks.paths.add(mesh, path, index=0)
bpy.ops.object.mode_set(mode=ob_mode, toggle=False)
return {'FINISHED'}
@@ -178,7 +178,7 @@ class SCENE_OT_freestyle_add_face_marks_to_keying_set(Operator):
bpy.ops.object.mode_set(mode='OBJECT', toggle=False)
for i, polygon in enumerate(mesh.polygons):
if not polygon.hide and polygon.select:
path = "polygons[{:d}].use_freestyle_mark".format(i)
path = "attributes[\"freestyle_face\"].data[{:d}].value".format(i)
ks.paths.add(mesh, path, index=0)
bpy.ops.object.mode_set(mode=ob_mode, toggle=False)
return {'FINISHED'}

11
source/blender/blenkernel/BKE_mesh_legacy_convert.hh
View File

@@ -8,6 +8,10 @@
* \ingroup bke
*/
#include "BKE_attribute_storage.hh"
#include "BLI_vector.hh"
struct CustomData;
struct Main;
struct Mesh;
@@ -20,6 +24,13 @@ void mesh_custom_normals_to_generic(Mesh &mesh);
void mesh_sculpt_mask_to_generic(Mesh &mesh);
void mesh_freestyle_marks_to_generic(Mesh &mesh);
void mesh_freestyle_marks_to_legacy(AttributeStorage::BlendWriteData &attr_write_data,
CustomData &edge_data,
CustomData &face_data,
Vector<CustomDataLayer, 16> &edge_layers,
Vector<CustomDataLayer, 16> &face_layers);
} // namespace blender::bke
void BKE_mesh_legacy_convert_uvs_to_generic(Mesh *mesh);

4
source/blender/blenkernel/intern/attribute_legacy_convert.cc
View File

@@ -41,6 +41,8 @@ std::optional<AttrType> custom_data_type_to_attr_type(const eCustomDataType data
case CD_SCULPT_FACE_SETS:
case CD_MTFACE:
case CD_TESSLOOPNORMAL:
case CD_FREESTYLE_EDGE:
case CD_FREESTYLE_FACE:
/* These types are only used for versioning old files. */
return std::nullopt;
case CD_SHAPEKEY:
@@ -61,8 +63,6 @@ std::optional<AttrType> custom_data_type_to_attr_type(const eCustomDataType data
case CD_ORIGSPACE_MLOOP:
case CD_GRID_PAINT_MASK:
case CD_MVERT_SKIN:
case CD_FREESTYLE_EDGE:
case CD_FREESTYLE_FACE:
case CD_MLOOPTANGENT:
/* These types are not generic. They will either be moved to some generic data type or
* #AttributeStorage will be extended to be able to support a similar format. */

42
source/blender/blenkernel/intern/customdata.cc
View File

@@ -1940,28 +1940,10 @@ static const LayerTypeInfo LAYERTYPEINFO[CD_NUMTYPES] = {
layerInterp_mvert_skin,
nullptr,
layerDefault_mvert_skin},
/* 37: CD_FREESTYLE_EDGE */
{sizeof(FreestyleEdge),
alignof(FreestyleEdge),
"FreestyleEdge",
1,
nullptr,
nullptr,
nullptr,
nullptr,
nullptr,
nullptr},
/* 38: CD_FREESTYLE_FACE */
{sizeof(FreestyleFace),
alignof(FreestyleFace),
"FreestyleFace",
1,
nullptr,
nullptr,
nullptr,
nullptr,
nullptr,
nullptr},
/* 37: CD_FREESTYLE_EDGE */ /* DEPRECATED */
{sizeof(FreestyleEdge), alignof(FreestyleEdge), "FreestyleEdge", 1},
/* 38: CD_FREESTYLE_FACE */ /* DEPRECATED */
{sizeof(FreestyleFace), alignof(FreestyleFace), "FreestyleFace", 1},
/* 39: CD_MLOOPTANGENT */
{sizeof(float[4]),
alignof(float[4]),
@@ -2208,10 +2190,10 @@ const CustomData_MeshMasks CD_MASK_BAREMESH_ORIGINDEX = {
const CustomData_MeshMasks CD_MASK_MESH = {
/*vmask*/ (CD_MASK_PROP_FLOAT3 | CD_MASK_MDEFORMVERT | CD_MASK_MVERT_SKIN | CD_MASK_PROP_ALL),
/*emask*/
(CD_MASK_FREESTYLE_EDGE | CD_MASK_PROP_ALL),
CD_MASK_PROP_ALL,
/*fmask*/ 0,
/*pmask*/
(CD_MASK_FREESTYLE_FACE | CD_MASK_PROP_ALL),
CD_MASK_PROP_ALL,
/*lmask*/
(CD_MASK_MDISPS | CD_MASK_GRID_PAINT_MASK | CD_MASK_PROP_ALL),
};
@@ -2219,20 +2201,20 @@ const CustomData_MeshMasks CD_MASK_DERIVEDMESH = {
/*vmask*/ (CD_MASK_ORIGINDEX | CD_MASK_MDEFORMVERT | CD_MASK_SHAPEKEY | CD_MASK_MVERT_SKIN |
CD_MASK_ORCO | CD_MASK_CLOTH_ORCO | CD_MASK_PROP_ALL),
/*emask*/
(CD_MASK_ORIGINDEX | CD_MASK_FREESTYLE_EDGE | CD_MASK_PROP_ALL),
(CD_MASK_ORIGINDEX | CD_MASK_PROP_ALL),
/*fmask*/ (CD_MASK_ORIGINDEX | CD_MASK_ORIGSPACE | CD_MASK_TANGENT),
/*pmask*/
(CD_MASK_ORIGINDEX | CD_MASK_FREESTYLE_FACE | CD_MASK_PROP_ALL),
(CD_MASK_ORIGINDEX | CD_MASK_PROP_ALL),
/*lmask*/
(CD_MASK_ORIGSPACE_MLOOP | CD_MASK_PROP_ALL), /* XXX: MISSING #CD_MASK_MLOOPTANGENT ? */
};
const CustomData_MeshMasks CD_MASK_BMESH = {
/*vmask*/ (CD_MASK_MDEFORMVERT | CD_MASK_MVERT_SKIN | CD_MASK_SHAPEKEY |
CD_MASK_SHAPE_KEYINDEX | CD_MASK_PROP_ALL),
/*emask*/ (CD_MASK_FREESTYLE_EDGE | CD_MASK_PROP_ALL),
/*emask*/ CD_MASK_PROP_ALL,
/*fmask*/ 0,
/*pmask*/
(CD_MASK_FREESTYLE_FACE | CD_MASK_PROP_ALL),
CD_MASK_PROP_ALL,
/*lmask*/
(CD_MASK_MDISPS | CD_MASK_GRID_PAINT_MASK | CD_MASK_PROP_ALL),
};
@@ -2241,12 +2223,12 @@ const CustomData_MeshMasks CD_MASK_EVERYTHING = {
CD_MASK_MVERT_SKIN | CD_MASK_ORCO | CD_MASK_CLOTH_ORCO | CD_MASK_SHAPEKEY |
CD_MASK_SHAPE_KEYINDEX | CD_MASK_PROP_ALL),
/*emask*/
(CD_MASK_BM_ELEM_PYPTR | CD_MASK_ORIGINDEX | CD_MASK_FREESTYLE_EDGE | CD_MASK_PROP_ALL),
(CD_MASK_BM_ELEM_PYPTR | CD_MASK_ORIGINDEX | CD_MASK_PROP_ALL),
/*fmask*/
(CD_MASK_MFACE | CD_MASK_ORIGINDEX | CD_MASK_NORMAL | CD_MASK_MTFACE | CD_MASK_MCOL |
CD_MASK_ORIGSPACE | CD_MASK_TANGENT | CD_MASK_TESSLOOPNORMAL | CD_MASK_PROP_ALL),
/*pmask*/
(CD_MASK_BM_ELEM_PYPTR | CD_MASK_ORIGINDEX | CD_MASK_FREESTYLE_FACE | CD_MASK_PROP_ALL),
(CD_MASK_BM_ELEM_PYPTR | CD_MASK_ORIGINDEX | CD_MASK_PROP_ALL),
/*lmask*/
(CD_MASK_BM_ELEM_PYPTR | CD_MASK_MDISPS | CD_MASK_NORMAL | CD_MASK_MLOOPTANGENT |
CD_MASK_ORIGSPACE_MLOOP | CD_MASK_GRID_PAINT_MASK | CD_MASK_PROP_ALL),

51
source/blender/blenkernel/intern/data_transfer.cc
View File

@@ -201,14 +201,14 @@ int BKE_object_data_transfer_dttype_to_cdtype(const int dtdata_type)
case DT_TYPE_BWEIGHT_EDGE:
return CD_FAKE_BWEIGHT;
case DT_TYPE_FREESTYLE_EDGE:
return CD_FREESTYLE_EDGE;
return CD_FAKE_FREESTYLE_EDGE;
case DT_TYPE_UV:
return CD_FAKE_UV;
case DT_TYPE_SHARP_FACE:
return CD_FAKE_SHARP;
case DT_TYPE_FREESTYLE_FACE:
return CD_FREESTYLE_FACE;
return CD_FAKE_FREESTYLE_FACE;
case DT_TYPE_LNOR:
return CD_FAKE_LNOR;
case DT_TYPE_MLOOPCOL_VERT:
@@ -503,15 +503,6 @@ static void data_transfer_layersmapping_add_item_cd(ListBase *r_map,
cd_datatransfer_interp interp,
void *interp_data)
{
uint64_t data_flag = 0;
if (cddata_type == CD_FREESTYLE_EDGE) {
data_flag = FREESTYLE_EDGE_MARK;
}
else if (cddata_type == CD_FREESTYLE_FACE) {
data_flag = FREESTYLE_FACE_MARK;
}
data_transfer_layersmapping_add_item(r_map,
cddata_type,
mix_mode,
@@ -524,7 +515,7 @@ static void data_transfer_layersmapping_add_item_cd(ListBase *r_map,
0,
0,
0,
data_flag,
0,
interp,
interp_data);
}
@@ -1035,6 +1026,24 @@ static bool data_transfer_layersmapping_generate(ListBase *r_map,
interp_data);
return true;
}
if (r_map && cddata_type == CD_FAKE_FREESTYLE_EDGE) {
if (!CustomData_get_layer_named(&me_dst->edge_data, CD_PROP_BOOL, "freestyle_edge")) {
CustomData_add_layer_named(
&me_dst->edge_data, CD_PROP_BOOL, CD_SET_DEFAULT, me_dst->edges_num, "freestyle_edge");
}
data_transfer_layersmapping_add_item_cd(
r_map,
CD_PROP_BOOL,
mix_mode,
mix_factor,
mix_weights,
CustomData_get_layer_named(&me_src->edge_data, CD_PROP_BOOL, "freestyle_edge"),
CustomData_get_layer_named_for_write(
&me_dst->edge_data, CD_PROP_BOOL, "freestyle_edge", me_dst->edges_num),
interp,
interp_data);
return true;
}
return false;
}
@@ -1137,6 +1146,24 @@ static bool data_transfer_layersmapping_generate(ListBase *r_map,
interp_data);
return true;
}
if (r_map && cddata_type == CD_FAKE_FREESTYLE_FACE) {
if (!CustomData_has_layer_named(&me_dst->face_data, CD_PROP_BOOL, "freestyle_face")) {
CustomData_add_layer_named(
&me_dst->face_data, CD_PROP_BOOL, CD_SET_DEFAULT, me_dst->faces_num, "freestyle_face");
}
data_transfer_layersmapping_add_item_cd(
r_map,
CD_PROP_BOOL,
mix_mode,
mix_factor,
mix_weights,
CustomData_get_layer_named(&me_src->face_data, CD_PROP_BOOL, "freestyle_face"),
CustomData_get_layer_named_for_write(
&me_dst->face_data, CD_PROP_BOOL, "freestyle_face", me_dst->faces_num),
interp,
interp_data);
return true;
}
return false;
}

2
source/blender/blenkernel/intern/data_transfer_intern.hh
View File

@@ -42,6 +42,8 @@ enum {
CD_FAKE_BWEIGHT = CD_FAKE | 300,
CD_FAKE_CREASE = CD_FAKE | 400,
CD_FAKE_FREESTYLE_EDGE = CD_FAKE | 500,
CD_FAKE_FREESTYLE_FACE = CD_FAKE | 600,
};
float data_transfer_interp_float_do(int mix_mode, float val_dst, float val_src, float mix_factor);

4
source/blender/blenkernel/intern/mesh.cc
View File

@@ -357,6 +357,10 @@ static void mesh_blend_write(BlendWriter *writer, ID *id, const void *id_address
mesh->face_data, AttrDomain::Face, mesh->faces_num, face_layers, attribute_data);
CustomData_blend_write_prepare(
mesh->corner_data, AttrDomain::Corner, mesh->corners_num, loop_layers, attribute_data);
if (!is_undo) {
mesh_freestyle_marks_to_legacy(
attribute_data, mesh->edge_data, mesh->face_data, edge_layers, face_layers);
}
if (attribute_data.attributes.is_empty()) {
mesh->attribute_storage.dna_attributes = nullptr;
mesh->attribute_storage.dna_attributes_num = 0;

112
source/blender/blenkernel/intern/mesh_legacy_convert.cc
View File

@@ -2489,6 +2489,118 @@ void mesh_sculpt_mask_to_generic(Mesh &mesh)
}
}
void mesh_freestyle_marks_to_generic(Mesh &mesh)
{
{
void *data = nullptr;
const ImplicitSharingInfo *sharing_info = nullptr;
for (const int i : IndexRange(mesh.edge_data.totlayer)) {
CustomDataLayer &layer = mesh.edge_data.layers[i];
if (layer.type == CD_FREESTYLE_EDGE) {
data = layer.data;
sharing_info = layer.sharing_info;
layer.data = nullptr;
layer.sharing_info = nullptr;
CustomData_free_layer(&mesh.edge_data, CD_FREESTYLE_EDGE, i);
break;
}
}
if (data != nullptr) {
static_assert(sizeof(FreestyleEdge) == sizeof(bool));
static_assert(char(FREESTYLE_EDGE_MARK) == char(true));
CustomData_add_layer_named_with_data(
&mesh.edge_data, CD_PROP_BOOL, data, mesh.edges_num, "freestyle_edge", sharing_info);
}
if (sharing_info != nullptr) {
sharing_info->remove_user_and_delete_if_last();
}
}
{
void *data = nullptr;
const ImplicitSharingInfo *sharing_info = nullptr;
for (const int i : IndexRange(mesh.face_data.totlayer)) {
CustomDataLayer &layer = mesh.face_data.layers[i];
if (layer.type == CD_FREESTYLE_FACE) {
data = layer.data;
sharing_info = layer.sharing_info;
layer.data = nullptr;
layer.sharing_info = nullptr;
CustomData_free_layer(&mesh.face_data, CD_FREESTYLE_FACE, i);
break;
}
}
if (data != nullptr) {
static_assert(sizeof(FreestyleFace) == sizeof(bool));
static_assert(char(FREESTYLE_FACE_MARK) == char(true));
CustomData_add_layer_named_with_data(
&mesh.face_data, CD_PROP_BOOL, data, mesh.faces_num, "freestyle_face", sharing_info);
}
if (sharing_info != nullptr) {
sharing_info->remove_user_and_delete_if_last();
}
}
}
void mesh_freestyle_marks_to_legacy(AttributeStorage::BlendWriteData &attr_write_data,
CustomData &edge_data,
CustomData &face_data,
Vector<CustomDataLayer, 16> &edge_layers,
Vector<CustomDataLayer, 16> &face_layers)
{
Array<bool, 64> attrs_to_remove(attr_write_data.attributes.size(), false);
for (const int i : attr_write_data.attributes.index_range()) {
const ::Attribute &dna_attr = attr_write_data.attributes[i];
if (dna_attr.data_type != int8_t(AttrType::Bool)) {
continue;
}
if (dna_attr.storage_type != int8_t(AttrStorageType::Array)) {
continue;
}
if (dna_attr.domain == int8_t(AttrDomain::Edge)) {
if (STREQ(dna_attr.name, "freestyle_edge")) {
const auto &array_dna = *static_cast<const ::AttributeArray *>(dna_attr.data);
static_assert(sizeof(FreestyleEdge) == sizeof(bool));
static_assert(char(FREESTYLE_EDGE_MARK) == char(true));
CustomDataLayer layer{};
layer.type = CD_FREESTYLE_EDGE;
layer.data = array_dna.data;
layer.sharing_info = array_dna.sharing_info;
edge_layers.append(layer);
std::stable_sort(
edge_layers.begin(),
edge_layers.end(),
[](const CustomDataLayer &a, const CustomDataLayer &b) { return a.type < b.type; });
edge_data.totlayer = edge_layers.size();
edge_data.maxlayer = edge_data.totlayer;
attrs_to_remove[i] = true;
}
}
else if (dna_attr.domain == int8_t(AttrDomain::Face)) {
if (STREQ(dna_attr.name, "freestyle_face")) {
const auto &array_dna = *static_cast<const ::AttributeArray *>(dna_attr.data);
static_assert(sizeof(FreestyleFace) == sizeof(bool));
static_assert(char(FREESTYLE_FACE_MARK) == char(true));
CustomDataLayer layer{};
layer.type = CD_FREESTYLE_FACE;
layer.data = array_dna.data;
layer.sharing_info = array_dna.sharing_info;
face_layers.append(layer);
std::stable_sort(
face_layers.begin(),
face_layers.end(),
[](const CustomDataLayer &a, const CustomDataLayer &b) { return a.type < b.type; });
face_data.totlayer = face_layers.size();
face_data.maxlayer = face_data.totlayer;
attrs_to_remove[i] = true;
}
}
}
attr_write_data.attributes.remove_if([&](const ::Attribute &attr) {
const int i = &attr - attr_write_data.attributes.begin();
return attrs_to_remove[i];
});
}
void mesh_custom_normals_to_generic(Mesh &mesh)
{
if (mesh.attributes().contains("custom_normal")) {

7
source/blender/blenkernel/intern/object_update.cc
View File

@@ -142,13 +142,6 @@ void BKE_object_handle_data_update(Depsgraph *depsgraph, Scene *scene, Object *o
cddata_masks.fmask |= CD_MASK_PROP_ALL;
cddata_masks.pmask |= CD_MASK_PROP_ALL;
cddata_masks.lmask |= CD_MASK_PROP_ALL;
/* Make sure Freestyle edge/face marks appear in evaluated mesh (see #40315).
* Due to Line Art implementation, edge marks should also be shown in viewport. */
#ifdef WITH_FREESTYLE
cddata_masks.emask |= CD_MASK_FREESTYLE_EDGE;
cddata_masks.pmask |= CD_MASK_FREESTYLE_FACE;
#endif
if (DEG_get_mode(depsgraph) == DAG_EVAL_RENDER) {
/* Always compute orcos for render. */
cddata_masks.vmask |= CD_MASK_ORCO;

6
source/blender/blenloader/intern/versioning_500.cc
View File

@@ -1505,4 +1505,10 @@ void blo_do_versions_500(FileData * /*fd*/, Library * /*lib*/, Main *bmain)
*
* \note Keep this message at the bottom of the function.
*/
/* Keep this versioning always enabled at the bottom of the function; it can only be moved behind
* a subversion bump when the file format is changed. */
LISTBASE_FOREACH (Mesh *, mesh, &bmain->meshes) {
bke::mesh_freestyle_marks_to_generic(*mesh);
}
}

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

@@ -590,8 +590,10 @@ MeshRenderData mesh_render_data_create(Object &object,
mr.bweight_ofs = CustomData_get_offset_named(
&mr.bm->edata, CD_PROP_FLOAT, "bevel_weight_edge");
#ifdef WITH_FREESTYLE
mr.freestyle_edge_ofs = CustomData_get_offset(&mr.bm->edata, CD_FREESTYLE_EDGE);
mr.freestyle_face_ofs = CustomData_get_offset(&mr.bm->pdata, CD_FREESTYLE_FACE);
mr.freestyle_edge_ofs = CustomData_get_offset_named(
&mr.bm->edata, CD_PROP_BOOL, "freestyle_edge");
mr.freestyle_face_ofs = CustomData_get_offset_named(
&mr.bm->pdata, CD_PROP_BOOL, "freestyle_face");
#endif
/* Use bmesh directly when the object is unchanged by any modifiers. For non-final UVs, always

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

@@ -43,9 +43,7 @@ void mesh_render_data_face_flag(const MeshRenderData &mr,
#ifdef WITH_FREESTYLE
if (mr.freestyle_face_ofs != -1) {
const FreestyleFace *ffa = (const FreestyleFace *)BM_ELEM_CD_GET_VOID_P(efa,
mr.freestyle_face_ofs);
if (ffa->flag & FREESTYLE_FACE_MARK) {
if (BM_ELEM_CD_GET_BOOL(efa, mr.freestyle_face_ofs)) {
eattr.v_flag |= VFLAG_FACE_FREESTYLE;
}
}

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

@@ -72,9 +72,7 @@ static void mesh_render_data_edge_flag(const MeshRenderData &mr,
}
#ifdef WITH_FREESTYLE
if (mr.freestyle_edge_ofs != -1) {
const FreestyleEdge *fed = (const FreestyleEdge *)BM_ELEM_CD_GET_VOID_P(eed,
mr.freestyle_edge_ofs);
if (fed->flag & FREESTYLE_EDGE_MARK) {
if (BM_ELEM_CD_GET_BOOL(eed, mr.freestyle_edge_ofs)) {
eattr.e_flag |= VFLAG_EDGE_FREESTYLE;
}
}

20
source/blender/editors/mesh/editmesh_path.cc
View File

@@ -307,10 +307,7 @@ static bool edgetag_test_cb(BMEdge *e, void *user_data_v)
return BM_ELEM_CD_GET_FLOAT(e, user_data->cd_offset);
#ifdef WITH_FREESTYLE
case EDGE_MODE_TAG_FREESTYLE: {
BMesh *bm = user_data->bm;
FreestyleEdge *fed = static_cast<FreestyleEdge *>(
CustomData_bmesh_get(&bm->edata, e->head.data, CD_FREESTYLE_EDGE));
return (!fed) ? false : (fed->flag & FREESTYLE_EDGE_MARK) ? true : false;
return BM_ELEM_CD_GET_BOOL(e, user_data->cd_offset);
}
#endif
}
@@ -338,15 +335,7 @@ static void edgetag_set_cb(BMEdge *e, bool val, void *user_data_v)
break;
#ifdef WITH_FREESTYLE
case EDGE_MODE_TAG_FREESTYLE: {
FreestyleEdge *fed;
fed = static_cast<FreestyleEdge *>(
CustomData_bmesh_get(&bm->edata, e->head.data, CD_FREESTYLE_EDGE));
if (!val) {
fed->flag &= ~FREESTYLE_EDGE_MARK;
}
else {
fed->flag |= FREESTYLE_EDGE_MARK;
}
BM_ELEM_CD_SET_BOOL(e, user_data->cd_offset, val);
break;
}
#endif
@@ -370,8 +359,8 @@ static void edgetag_ensure_cd_flag(Mesh *mesh, const char edge_mode)
break;
#ifdef WITH_FREESTYLE
case EDGE_MODE_TAG_FREESTYLE:
if (!CustomData_has_layer(&bm->edata, CD_FREESTYLE_EDGE)) {
BM_data_layer_add(bm, &bm->edata, CD_FREESTYLE_EDGE);
if (!CustomData_has_layer_named(&bm->edata, CD_PROP_BOOL, "freestyle_edge")) {
BM_data_layer_add_named(bm, &bm->edata, CD_PROP_BOOL, "freestyle_edge");
}
break;
#endif
@@ -396,6 +385,7 @@ static void mouse_mesh_shortest_path_edge(
case EDGE_MODE_TAG_SHARP:
#ifdef WITH_FREESTYLE
case EDGE_MODE_TAG_FREESTYLE:
cd_offset = CustomData_get_offset_named(&bm->edata, CD_PROP_BOOL, "freestyle_edge");
#endif
break;
case EDGE_MODE_TAG_CREASE:

55
source/blender/editors/mesh/editmesh_select_similar.cc
View File

@@ -210,6 +210,7 @@ static wmOperatorStatus similar_face_select_exec(bContext *C, wmOperator *op)
float ob_m3[3][3];
copy_m3_m4(ob_m3, ob->object_to_world().ptr());
int custom_data_offset = -1;
switch (type) {
case SIMFACE_MATERIAL: {
if (ob->totcol == 0) {
@@ -219,7 +220,9 @@ static wmOperatorStatus similar_face_select_exec(bContext *C, wmOperator *op)
break;
}
case SIMFACE_FREESTYLE: {
if (!CustomData_has_layer(&bm->pdata, CD_FREESTYLE_FACE)) {
custom_data_offset = CustomData_get_offset_named(
&bm->pdata, CD_PROP_BOOL, "freestyle_face");
if (custom_data_offset == -1) {
face_data_value |= SIMFACE_DATA_FALSE;
continue;
}
@@ -274,10 +277,7 @@ static wmOperatorStatus similar_face_select_exec(bContext *C, wmOperator *op)
break;
}
case SIMFACE_FREESTYLE: {
FreestyleFace *fface;
fface = static_cast<FreestyleFace *>(
CustomData_bmesh_get(&bm->pdata, face->head.data, CD_FREESTYLE_FACE));
if ((fface == nullptr) || ((fface->flag & FREESTYLE_FACE_MARK) == 0)) {
if (custom_data_offset == -1 || !BM_ELEM_CD_GET_BOOL(face, custom_data_offset)) {
face_data_value |= SIMFACE_DATA_FALSE;
}
else {
@@ -317,7 +317,7 @@ static wmOperatorStatus similar_face_select_exec(bContext *C, wmOperator *op)
float ob_m3[3][3];
copy_m3_m4(ob_m3, ob->object_to_world().ptr());
bool has_custom_data_layer = false;
int custom_data_offset = -1;
switch (type) {
case SIMFACE_MATERIAL: {
if (ob->totcol == 0) {
@@ -327,8 +327,9 @@ static wmOperatorStatus similar_face_select_exec(bContext *C, wmOperator *op)
break;
}
case SIMFACE_FREESTYLE: {
has_custom_data_layer = CustomData_has_layer(&bm->pdata, CD_FREESTYLE_FACE);
if ((face_data_value == SIMFACE_DATA_TRUE) && !has_custom_data_layer) {
custom_data_offset = CustomData_get_offset_named(
&bm->pdata, CD_PROP_BOOL, "freestyle_face");
if ((face_data_value == SIMFACE_DATA_TRUE) && (custom_data_offset == -1)) {
continue;
}
break;
@@ -429,19 +430,15 @@ static wmOperatorStatus similar_face_select_exec(bContext *C, wmOperator *op)
}
break;
case SIMFACE_FREESTYLE: {
FreestyleFace *fface;
if (!has_custom_data_layer) {
if (custom_data_offset == -1) {
BLI_assert(face_data_value == SIMFACE_DATA_FALSE);
select = true;
break;
}
fface = static_cast<FreestyleFace *>(
CustomData_bmesh_get(&bm->pdata, face->head.data, CD_FREESTYLE_FACE));
if (((fface != nullptr) && (fface->flag & FREESTYLE_FACE_MARK)) ==
((face_data_value & SIMFACE_DATA_TRUE) != 0))
{
const bool value = BM_ELEM_CD_GET_BOOL(face, custom_data_offset);
if (value == ((face_data_value & SIMFACE_DATA_TRUE) != 0)) {
select = true;
}
break;
@@ -611,7 +608,7 @@ static wmOperatorStatus similar_edge_select_exec(bContext *C, wmOperator *op)
switch (type) {
case SIMEDGE_FREESTYLE: {
if (!CustomData_has_layer(&bm->edata, CD_FREESTYLE_EDGE)) {
if (!CustomData_has_layer_named(&bm->edata, CD_PROP_BOOL, "freestyle_edge")) {
edge_data_value |= SIMEDGE_DATA_FALSE;
continue;
}
@@ -637,6 +634,11 @@ static wmOperatorStatus similar_edge_select_exec(bContext *C, wmOperator *op)
int custom_data_offset;
switch (type) {
case SIMEDGE_FREESTYLE: {
custom_data_offset = CustomData_get_offset_named(
&bm->edata, CD_PROP_BOOL, "freestyle_edge");
break;
}
case SIMEDGE_CREASE:
custom_data_offset = CustomData_get_offset_named(&bm->edata, CD_PROP_FLOAT, "crease_edge");
break;
@@ -692,10 +694,7 @@ static wmOperatorStatus similar_edge_select_exec(bContext *C, wmOperator *op)
}
break;
case SIMEDGE_FREESTYLE: {
FreestyleEdge *fedge;
fedge = static_cast<FreestyleEdge *>(
CustomData_bmesh_get(&bm->edata, edge->head.data, CD_FREESTYLE_EDGE));
if ((fedge == nullptr) || ((fedge->flag & FREESTYLE_EDGE_MARK) == 0)) {
if (custom_data_offset == -1 || !BM_ELEM_CD_GET_BOOL(edge, custom_data_offset)) {
edge_data_value |= SIMEDGE_DATA_FALSE;
}
else {
@@ -736,7 +735,8 @@ static wmOperatorStatus similar_edge_select_exec(bContext *C, wmOperator *op)
bool has_custom_data_layer = false;
switch (type) {
case SIMEDGE_FREESTYLE: {
has_custom_data_layer = CustomData_has_layer(&bm->edata, CD_FREESTYLE_EDGE);
has_custom_data_layer = CustomData_has_layer_named(
&bm->edata, CD_PROP_BOOL, "freestyle_edge");
if ((edge_data_value == SIMEDGE_DATA_TRUE) && !has_custom_data_layer) {
continue;
}
@@ -776,6 +776,10 @@ static wmOperatorStatus similar_edge_select_exec(bContext *C, wmOperator *op)
int custom_data_offset;
switch (type) {
case SIMEDGE_FREESTYLE:
custom_data_offset = CustomData_get_offset_named(
&bm->edata, CD_PROP_BOOL, "freestyle_edge");
break;
case SIMEDGE_CREASE:
custom_data_offset = CustomData_get_offset_named(&bm->edata, CD_PROP_FLOAT, "crease_edge");
break;
@@ -852,19 +856,14 @@ static wmOperatorStatus similar_edge_select_exec(bContext *C, wmOperator *op)
}
break;
case SIMEDGE_FREESTYLE: {
FreestyleEdge *fedge;
if (!has_custom_data_layer) {
BLI_assert(edge_data_value == SIMEDGE_DATA_FALSE);
select = true;
break;
}
fedge = static_cast<FreestyleEdge *>(
CustomData_bmesh_get(&bm->edata, edge->head.data, CD_FREESTYLE_EDGE));
if (((fedge != nullptr) && (fedge->flag & FREESTYLE_EDGE_MARK)) ==
((edge_data_value & SIMEDGE_DATA_TRUE) != 0))
{
const bool value = BM_ELEM_CD_GET_BOOL(edge, custom_data_offset);
if (value == ((edge_data_value & SIMEDGE_DATA_TRUE) != 0)) {
select = true;
}
break;

30
source/blender/editors/mesh/editmesh_tools.cc
View File

@@ -7990,7 +7990,6 @@ static wmOperatorStatus edbm_mark_freestyle_edge_exec(bContext *C, wmOperator *o
{
BMEdge *eed;
BMIter iter;
FreestyleEdge *fed;
const bool clear = RNA_boolean_get(op->ptr, "clear");
const Scene *scene = CTX_data_scene(C);
ViewLayer *view_layer = CTX_data_view_layer(C);
@@ -8010,25 +8009,23 @@ static wmOperatorStatus edbm_mark_freestyle_edge_exec(bContext *C, wmOperator *o
continue;
}
if (!CustomData_has_layer(&em->bm->edata, CD_FREESTYLE_EDGE)) {
BM_data_layer_add(em->bm, &em->bm->edata, CD_FREESTYLE_EDGE);
BM_data_layer_ensure_named(bm, &em->bm->edata, CD_PROP_BOOL, "freestyle_edge");
const int offset = CustomData_get_offset_named(&em->bm->edata, CD_PROP_BOOL, "freestyle_edge");
if (offset == -1) {
continue;
}
if (clear) {
BM_ITER_MESH (eed, &iter, em->bm, BM_EDGES_OF_MESH) {
if (BM_elem_flag_test(eed, BM_ELEM_SELECT) && !BM_elem_flag_test(eed, BM_ELEM_HIDDEN)) {
fed = static_cast<FreestyleEdge *>(
CustomData_bmesh_get(&em->bm->edata, eed->head.data, CD_FREESTYLE_EDGE));
fed->flag &= ~FREESTYLE_EDGE_MARK;
BM_ELEM_CD_SET_BOOL(eed, offset, false);
}
}
}
else {
BM_ITER_MESH (eed, &iter, em->bm, BM_EDGES_OF_MESH) {
if (BM_elem_flag_test(eed, BM_ELEM_SELECT) && !BM_elem_flag_test(eed, BM_ELEM_HIDDEN)) {
fed = static_cast<FreestyleEdge *>(
CustomData_bmesh_get(&em->bm->edata, eed->head.data, CD_FREESTYLE_EDGE));
fed->flag |= FREESTYLE_EDGE_MARK;
BM_ELEM_CD_SET_BOOL(eed, offset, true);
}
}
}
@@ -8070,7 +8067,6 @@ static wmOperatorStatus edbm_mark_freestyle_face_exec(bContext *C, wmOperator *o
{
BMFace *efa;
BMIter iter;
FreestyleFace *ffa;
const bool clear = RNA_boolean_get(op->ptr, "clear");
const Scene *scene = CTX_data_scene(C);
ViewLayer *view_layer = CTX_data_view_layer(C);
@@ -8088,25 +8084,23 @@ static wmOperatorStatus edbm_mark_freestyle_face_exec(bContext *C, wmOperator *o
continue;
}
if (!CustomData_has_layer(&em->bm->pdata, CD_FREESTYLE_FACE)) {
BM_data_layer_add(em->bm, &em->bm->pdata, CD_FREESTYLE_FACE);
BM_data_layer_ensure_named(em->bm, &em->bm->edata, CD_PROP_BOOL, "freestyle_edge");
const int offset = CustomData_get_offset_named(&em->bm->edata, CD_PROP_BOOL, "freestyle_edge");
if (offset == -1) {
continue;
}
if (clear) {
BM_ITER_MESH (efa, &iter, em->bm, BM_FACES_OF_MESH) {
if (BM_elem_flag_test(efa, BM_ELEM_SELECT) && !BM_elem_flag_test(efa, BM_ELEM_HIDDEN)) {
ffa = static_cast<FreestyleFace *>(
CustomData_bmesh_get(&em->bm->pdata, efa->head.data, CD_FREESTYLE_FACE));
ffa->flag &= ~FREESTYLE_FACE_MARK;
BM_ELEM_CD_SET_BOOL(efa, offset, false);
}
}
}
else {
BM_ITER_MESH (efa, &iter, em->bm, BM_FACES_OF_MESH) {
if (BM_elem_flag_test(efa, BM_ELEM_SELECT) && !BM_elem_flag_test(efa, BM_ELEM_HIDDEN)) {
ffa = static_cast<FreestyleFace *>(
CustomData_bmesh_get(&em->bm->pdata, efa->head.data, CD_FREESTYLE_FACE));
ffa->flag |= FREESTYLE_FACE_MARK;
BM_ELEM_CD_SET_BOOL(efa, offset, true);
}
}
}

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

@@ -394,7 +394,10 @@ int BlenderFileLoader::testDegenerateTriangle(float v1[3], float v2[3], float v3
return 0;
}
static bool testEdgeMark(Mesh *mesh, const FreestyleEdge *fed, const blender::int3 &tri, int i)
static bool testEdgeMark(Mesh *mesh,
const blender::VArray<bool> &fed,
const blender::int3 &tri,
int i)
{
const Span<blender::int2> edges = mesh->edges();
const Span<int> corner_verts = mesh->corner_verts();
@@ -409,7 +412,7 @@ static bool testEdgeMark(Mesh *mesh, const FreestyleEdge *fed, const blender::in
return false;
}
return (fed[corner_edges[corner]].flag & FREESTYLE_EDGE_MARK) != 0;
return fed[corner_edges[corner]];
}
void BlenderFileLoader::insertShapeNode(Object *ob, Mesh *mesh, int id)
@@ -428,12 +431,13 @@ void BlenderFileLoader::insertShapeNode(Object *ob, Mesh *mesh, int id)
vert_positions, mesh_polys, corner_verts, {corner_tris, tottri});
const blender::Span<int> tri_faces = mesh->corner_tri_faces();
const blender::Span<blender::float3> corner_normals = mesh->corner_normals();
const bke::AttributeAccessor attributes = mesh->attributes();
// Get other mesh data
const FreestyleEdge *fed = (const FreestyleEdge *)CustomData_get_layer(&mesh->edge_data,
CD_FREESTYLE_EDGE);
const FreestyleFace *ffa = (const FreestyleFace *)CustomData_get_layer(&mesh->face_data,
CD_FREESTYLE_FACE);
const VArray<bool> fed = *attributes.lookup_or_default<bool>(
"freestyle_edge", bke::AttrDomain::Edge, false);
const VArray<bool> ffa = *attributes.lookup_or_default<bool>(
"freestyle_face", bke::AttrDomain::Face, false);
// Compute view matrix
Object *ob_camera_eval = DEG_get_evaluated(_depsgraph, RE_GetCamera(_re));
@@ -519,7 +523,6 @@ void BlenderFileLoader::insertShapeNode(Object *ob, Mesh *mesh, int id)
FrsMaterial tmpMat;
const bke::AttributeAccessor attributes = mesh->attributes();
const VArray<int> material_indices = *attributes.lookup_or_default<int>(
"material_index", bke::AttrDomain::Face, 0);
const VArray<bool> sharp_faces = *attributes.lookup_or_default<bool>(
@@ -570,7 +573,7 @@ void BlenderFileLoader::insertShapeNode(Object *ob, Mesh *mesh, int id)
continue;
}
bool fm = (ffa) ? (ffa[poly_i].flag & FREESTYLE_FACE_MARK) != 0 : false;
bool fm = ffa[poly_i];
bool em1 = false, em2 = false, em3 = false;
if (fed) {

1
source/blender/geometry/intern/mesh_split_edges.cc
View File

@@ -65,7 +65,6 @@ static void propagate_vert_attributes(Mesh &mesh, const Span<int> new_to_old_ver
static void propagate_edge_attributes(Mesh &mesh, const Span<int> new_to_old_edge_map)
{
CustomData_free_layers(&mesh.edge_data, CD_FREESTYLE_EDGE);
CustomData_realloc(&mesh.edge_data, mesh.edges_num, mesh.edges_num + new_to_old_edge_map.size());
mesh.edges_num += new_to_old_edge_map.size();

4
source/blender/makesdna/DNA_customdata_types.h
View File

@@ -147,8 +147,10 @@ typedef enum eCustomDataType {
#endif
CD_GRID_PAINT_MASK = 35,
CD_MVERT_SKIN = 36,
#ifdef DNA_DEPRECATED_ALLOW
CD_FREESTYLE_EDGE = 37,
CD_FREESTYLE_FACE = 38,
#endif
CD_MLOOPTANGENT = 39,
CD_TESSLOOPNORMAL = 40,
#ifdef DNA_DEPRECATED_ALLOW
@@ -202,8 +204,6 @@ using eCustomDataMask = uint64_t;
#define CD_MASK_GRID_PAINT_MASK (1LL << CD_GRID_PAINT_MASK)
#define CD_MASK_MVERT_SKIN (1LL << CD_MVERT_SKIN)
#define CD_MASK_FREESTYLE_EDGE (1LL << CD_FREESTYLE_EDGE)
#define CD_MASK_FREESTYLE_FACE (1LL << CD_FREESTYLE_FACE)
#define CD_MASK_MLOOPTANGENT (1LL << CD_MLOOPTANGENT)
#define CD_MASK_TESSLOOPNORMAL (1LL << CD_TESSLOOPNORMAL)
#define CD_MASK_PROP_COLOR (1ULL << CD_PROP_COLOR)

4
source/blender/makesdna/DNA_meshdata_types.h
View File

@@ -252,6 +252,8 @@ typedef struct OrigSpaceLoop {
/** \} */
#ifdef DNA_DEPRECATED_ALLOW
/* -------------------------------------------------------------------- */
/** \name Custom Data (FreeStyle for Edge, Face)
* \{ */
@@ -280,8 +282,6 @@ enum {
/** \name Deprecated Structs
* \{ */
#ifdef DNA_DEPRECATED_ALLOW
/**
* Mesh Edges.
*

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

@@ -829,64 +829,6 @@ static void rna_CustomDataLayer_clone_set(PointerRNA *ptr, CustomData *data, int
CustomData_set_layer_clone_index(data, eCustomDataType(type), n);
}
static bool rna_MEdge_freestyle_edge_mark_get(PointerRNA *ptr)
{
const Mesh *mesh = rna_mesh(ptr);
const int index = rna_MeshEdge_index_get(ptr);
const FreestyleEdge *fed = static_cast<const FreestyleEdge *>(
CustomData_get_layer(&mesh->edge_data, CD_FREESTYLE_EDGE));
return fed && (fed[index].flag & FREESTYLE_EDGE_MARK) != 0;
}
static void rna_MEdge_freestyle_edge_mark_set(PointerRNA *ptr, bool value)
{
Mesh *mesh = rna_mesh(ptr);
const int index = rna_MeshEdge_index_get(ptr);
FreestyleEdge *fed = static_cast<FreestyleEdge *>(
CustomData_get_layer_for_write(&mesh->edge_data, CD_FREESTYLE_EDGE, mesh->edges_num));
if (!fed) {
fed = static_cast<FreestyleEdge *>(CustomData_add_layer(
&mesh->edge_data, CD_FREESTYLE_EDGE, CD_SET_DEFAULT, mesh->edges_num));
}
if (value) {
fed[index].flag |= FREESTYLE_EDGE_MARK;
}
else {
fed[index].flag &= ~FREESTYLE_EDGE_MARK;
}
}
static bool rna_MPoly_freestyle_face_mark_get(PointerRNA *ptr)
{
const Mesh *mesh = rna_mesh(ptr);
const int index = rna_MeshPolygon_index_get(ptr);
const FreestyleFace *ffa = static_cast<const FreestyleFace *>(
CustomData_get_layer(&mesh->face_data, CD_FREESTYLE_FACE));
return ffa && (ffa[index].flag & FREESTYLE_FACE_MARK) != 0;
}
static void rna_MPoly_freestyle_face_mark_set(PointerRNA *ptr, bool value)
{
Mesh *mesh = rna_mesh(ptr);
const int index = rna_MeshPolygon_index_get(ptr);
FreestyleFace *ffa = static_cast<FreestyleFace *>(
CustomData_get_layer_for_write(&mesh->face_data, CD_FREESTYLE_FACE, mesh->faces_num));
if (!ffa) {
ffa = static_cast<FreestyleFace *>(CustomData_add_layer(
&mesh->face_data, CD_FREESTYLE_FACE, CD_SET_DEFAULT, mesh->faces_num));
}
if (value) {
ffa[index].flag |= FREESTYLE_FACE_MARK;
}
else {
ffa[index].flag &= ~FREESTYLE_FACE_MARK;
}
}
/* uv_layers */
DEFINE_CUSTOMDATA_LAYER_COLLECTION(uv_layer, ldata, CD_PROP_FLOAT2)
@@ -2085,12 +2027,6 @@ static void rna_def_medge(BlenderRNA *brna)
RNA_def_property_boolean_funcs(prop, "rna_MeshEdge_is_loose_get", nullptr);
RNA_def_property_ui_text(prop, "Loose", "Edge is not connected to any faces");
prop = RNA_def_property(srna, "use_freestyle_mark", PROP_BOOLEAN, PROP_NONE);
RNA_def_property_boolean_funcs(
prop, "rna_MEdge_freestyle_edge_mark_get", "rna_MEdge_freestyle_edge_mark_set");
RNA_def_property_ui_text(prop, "Freestyle Edge Mark", "Edge mark for Freestyle line rendering");
RNA_def_property_update(prop, 0, "rna_Mesh_update_data_legacy_deg_tag_all");
prop = RNA_def_property(srna, "index", PROP_INT, PROP_UNSIGNED);
RNA_def_property_clear_flag(prop, PROP_EDITABLE);
RNA_def_property_int_funcs(prop, "rna_MeshEdge_index_get", nullptr, nullptr);
@@ -2298,12 +2234,6 @@ static void rna_def_mpolygon(BlenderRNA *brna)
RNA_def_property_ui_text(prop, "Smooth", "");
RNA_def_property_update(prop, 0, "rna_Mesh_update_data_legacy_deg_tag_all");
prop = RNA_def_property(srna, "use_freestyle_mark", PROP_BOOLEAN, PROP_NONE);
RNA_def_property_boolean_funcs(
prop, "rna_MPoly_freestyle_face_mark_get", "rna_MPoly_freestyle_face_mark_set");
RNA_def_property_ui_text(prop, "Freestyle Face Mark", "Face mark for Freestyle line rendering");
RNA_def_property_update(prop, 0, "rna_Mesh_update_data_legacy_deg_tag_all");
prop = RNA_def_property(srna, "normal", PROP_FLOAT, PROP_DIRECTION);
RNA_def_property_array(prop, 3);
RNA_def_property_range(prop, -1.0f, 1.0f);

40
source/blender/modifiers/intern/lineart/lineart_cpu.cc
View File

@@ -1495,9 +1495,9 @@ struct EdgeFeatData {
float crease_threshold;
bool use_auto_smooth;
bool use_freestyle_face;
const FreestyleFace *freestyle_face;
blender::VArray<bool> freestyle_face;
bool use_freestyle_edge;
const FreestyleEdge *freestyle_edge;
blender::VArray<bool> freestyle_edge;
LineartEdgeNeighbor *edge_nabr;
};
@@ -1541,14 +1541,13 @@ static void lineart_identify_corner_tri_feature_edges(void *__restrict userdata,
if (enable_face_mark) {
bool ff1 = false;
bool ff2 = false;
if (const FreestyleFace *freestyle_face = e_feat_data->freestyle_face) {
if (freestyle_face[tri_faces[i / 3]].flag & FREESTYLE_FACE_MARK) {
if (const blender::VArray<bool> &freestyle_face = e_feat_data->freestyle_face) {
if (freestyle_face[tri_faces[i / 3]]) {
ff1 = true;
}
}
if (edge_nabr[i].e > -1 && e_feat_data->freestyle_face) {
ff2 = (e_feat_data->freestyle_face[tri_faces[edge_nabr[i].e / 3]].flag &
FREESTYLE_FACE_MARK) != 0;
ff2 = e_feat_data->freestyle_face[tri_faces[edge_nabr[i].e / 3]];
}
else {
/* Handle mesh boundary cases: We want mesh boundaries to respect
@@ -1709,7 +1708,7 @@ static void lineart_identify_corner_tri_feature_edges(void *__restrict userdata,
}
if (ld->conf.use_edge_marks && e_feat_data->use_freestyle_edge) {
if (e_feat_data->freestyle_edge[real_edges[i % 3]].flag & FREESTYLE_EDGE_MARK) {
if (e_feat_data->freestyle_edge[real_edges[i % 3]]) {
edge_flag_result |= MOD_LINEART_EDGE_FLAG_EDGE_MARK;
}
}
@@ -1978,19 +1977,6 @@ static void lineart_geometry_object_load(LineartObjectInfo *ob_info,
const AttributeAccessor attributes = mesh->attributes();
const VArraySpan material_indices = *attributes.lookup<int>("material_index", AttrDomain::Face);
/* Check if we should look for custom data tags like Freestyle edges or faces. */
bool can_find_freestyle_edge = false;
int layer_index = CustomData_get_active_layer_index(&mesh->edge_data, CD_FREESTYLE_EDGE);
if (layer_index != -1) {
can_find_freestyle_edge = true;
}
bool can_find_freestyle_face = false;
layer_index = CustomData_get_active_layer_index(&mesh->face_data, CD_FREESTYLE_FACE);
if (layer_index != -1) {
can_find_freestyle_face = true;
}
/* If we allow duplicated edges, one edge should get added multiple times if is has been
* classified as more than one edge type. This is so we can create multiple different line type
* chains containing the same edge. */
@@ -2127,16 +2113,10 @@ static void lineart_geometry_object_load(LineartObjectInfo *ob_info,
edge_feat_data.v_array = la_v_arr;
edge_feat_data.crease_threshold = crease_angle;
edge_feat_data.use_auto_smooth = use_auto_smooth;
edge_feat_data.use_freestyle_face = can_find_freestyle_face;
edge_feat_data.use_freestyle_edge = can_find_freestyle_edge;
if (edge_feat_data.use_freestyle_face) {
edge_feat_data.freestyle_face = static_cast<const FreestyleFace *>(
CustomData_get_layer(&mesh->face_data, CD_FREESTYLE_FACE));
}
if (edge_feat_data.use_freestyle_edge) {
edge_feat_data.freestyle_edge = static_cast<const FreestyleEdge *>(
CustomData_get_layer(&mesh->edge_data, CD_FREESTYLE_EDGE));
}
edge_feat_data.freestyle_face = *attributes.lookup<bool>("freestyle_face", AttrDomain::Face);
edge_feat_data.freestyle_edge = *attributes.lookup<bool>("freestyle_edge", AttrDomain::Edge);
edge_feat_data.use_freestyle_face = bool(edge_feat_data.freestyle_face);
edge_feat_data.use_freestyle_edge = bool(edge_feat_data.freestyle_edge);
BLI_task_parallel_range(0,
total_edges,

17
source/blender/nodes/geometry/nodes/node_geo_extrude_mesh.cc
View File

@@ -114,16 +114,6 @@ static void remove_unsupported_vert_data(Mesh &mesh)
CustomData_free_layers(&mesh.vert_data, CD_MVERT_SKIN);
}
static void remove_unsupported_edge_data(Mesh &mesh)
{
CustomData_free_layers(&mesh.edge_data, CD_FREESTYLE_EDGE);
}
static void remove_unsupported_face_data(Mesh &mesh)
{
CustomData_free_layers(&mesh.face_data, CD_FREESTYLE_FACE);
}
static void remove_unsupported_corner_data(Mesh &mesh)
{
CustomData_free_layers(&mesh.corner_data, CD_MDISPS);
@@ -417,7 +407,6 @@ static void extrude_mesh_vertices(Mesh &mesh,
}
remove_unsupported_vert_data(mesh);
remove_unsupported_edge_data(mesh);
expand_mesh(mesh, selection.size(), selection.size(), 0, 0);
const IndexRange new_vert_range{orig_vert_size, selection.size()};
@@ -629,8 +618,6 @@ static void extrude_mesh_edges(Mesh &mesh,
}
remove_unsupported_vert_data(mesh);
remove_unsupported_edge_data(mesh);
remove_unsupported_face_data(mesh);
remove_unsupported_corner_data(mesh);
expand_mesh(mesh,
new_vert_range.size(),
@@ -971,8 +958,6 @@ static void extrude_mesh_face_regions(Mesh &mesh,
remove_non_propagated_attributes(attributes, attribute_filter);
remove_unsupported_vert_data(mesh);
remove_unsupported_edge_data(mesh);
remove_unsupported_face_data(mesh);
remove_unsupported_corner_data(mesh);
expand_mesh(mesh,
new_vert_range.size(),
@@ -1266,8 +1251,6 @@ static void extrude_individual_mesh_faces(Mesh &mesh,
remove_non_propagated_attributes(attributes, attribute_filter);
remove_unsupported_vert_data(mesh);
remove_unsupported_edge_data(mesh);
remove_unsupported_face_data(mesh);
remove_unsupported_corner_data(mesh);
expand_mesh(mesh,
new_vert_range.size(),

15
source/blender/python/bmesh/bmesh_py_types_customdata.cc
View File

@@ -311,13 +311,6 @@ static PyGetSetDef bpy_bmlayeraccess_edge_getseters[] = {
(setter) nullptr,
bpy_bmlayeraccess_collection__string_doc,
(void *)CD_PROP_STRING},
#ifdef WITH_FREESTYLE
{"freestyle",
(getter)bpy_bmlayeraccess_collection_get,
(setter) nullptr,
bpy_bmlayeraccess_collection__freestyle_edge_doc,
(void *)CD_FREESTYLE_EDGE},
#endif
{nullptr, nullptr, nullptr, nullptr, nullptr} /* Sentinel */
};
@@ -358,14 +351,6 @@ static PyGetSetDef bpy_bmlayeraccess_face_getseters[] = {
bpy_bmlayeraccess_collection__string_doc,
(void *)CD_PROP_STRING},
#ifdef WITH_FREESTYLE
{"freestyle",
(getter)bpy_bmlayeraccess_collection_get,
(setter) nullptr,
bpy_bmlayeraccess_collection__freestyle_face_doc,
(void *)CD_FREESTYLE_FACE},
#endif
{nullptr, nullptr, nullptr, nullptr, nullptr} /* Sentinel */
};