[Bf-blender-cvs] [1e58ce97978] hair_object: Iterator functions and macros for hair primitives.
Lukas Tönne
noreply at git.blender.org
Sun Sep 16 11:22:54 CEST 2018
Commit: 1e58ce97978b56edd2a4c44f5ff8395efc538239
Author: Lukas Tönne
Date: Sun Sep 16 10:22:25 2018 +0100
Branches: hair_object
https://developer.blender.org/rB1e58ce97978b56edd2a4c44f5ff8395efc538239
Iterator functions and macros for hair primitives.
===================================================================
A source/blender/blenkernel/BKE_hair_iterators.h
M source/blender/blenkernel/CMakeLists.txt
M source/blender/blenkernel/intern/hair.c
M source/blender/draw/intern/draw_cache_impl_hair.c
M source/blender/editors/space_view3d/view3d_iterators.c
M source/blender/editors/transform/transform_conversions.c
===================================================================
diff --git a/source/blender/blenkernel/BKE_hair_iterators.h b/source/blender/blenkernel/BKE_hair_iterators.h
new file mode 100644
index 00000000000..3962d30a9af
--- /dev/null
+++ b/source/blender/blenkernel/BKE_hair_iterators.h
@@ -0,0 +1,265 @@
+/*
+ * ***** BEGIN GPL LICENSE BLOCK *****
+ *
+ * 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) Blender Foundation
+ * All rights reserved.
+ *
+ * The Original Code is: all of this file.
+ *
+ * Contributor(s): Lukas Toenne
+ *
+ * ***** END GPL LICENSE BLOCK *****
+ */
+
+#ifndef __BKE_HAIR_ITERATORS_H__
+#define __BKE_HAIR_ITERATORS_H__
+
+/** \file blender/blenkernel/BKE_hair_iterators.h
+ * \ingroup bke
+ */
+
+#include "BLI_utildefines.h"
+
+#include "DNA_hair_types.h"
+
+#include "BKE_hair.h"
+
+/* === Hair Element Iterators === */
+
+typedef struct HairIter__curves
+{
+ HairFiberCurve *curve;
+ HairFiberCurve *last;
+} HairIter__curves;
+
+typedef struct HairIter__verts
+{
+ HairFiberVertex *vertex;
+ HairFiberVertex *last;
+} HairIter__verts;
+
+typedef struct HairIter__follicles
+{
+ HairFollicle *follicle;
+ HairFollicle *last;
+} HairIter__follicles;
+
+typedef struct HairIter__follicle_curves
+{
+ HairFollicle *follicle;
+ HairFollicle *last;
+ HairFiberCurve *curves_array;
+ HairFiberCurve *curve;
+} HairIter__follicle_curves;
+
+typedef struct HairIter__curve_verts
+{
+ HairFiberVertex *vertex;
+ HairFiberVertex *last;
+} HairIter__curve_verts;
+
+typedef struct HairIterator
+{
+ union {
+ HairIter__curves curves;
+ HairIter__verts verts;
+ HairIter__follicles follicles;
+ HairIter__follicle_curves follicle_curves;
+ HairIter__curve_verts curve_verts;
+ } data;
+} HairIterator;
+
+/* === Inline functions for element iterators === */
+
+/* Curves */
+
+BLI_INLINE HairFiberCurve* BKE_hair_iter__curves_init(HairIterator *iter, const HairCurveData *curve_data)
+{
+ iter->data.curves.last = curve_data->curves + curve_data->totcurves;
+ iter->data.curves.curve = curve_data->curves;
+ return iter->data.curves.curve;
+}
+
+BLI_INLINE bool BKE_hair_iter__curves_valid(const HairIterator *iter)
+{
+ return iter->data.curves.curve != iter->data.curves.last;
+}
+
+BLI_INLINE HairFiberCurve* BKE_hair_iter__curves_next(HairIterator *iter)
+{
+ ++iter->data.curves.curve;
+ return iter->data.curves.curve;
+}
+
+/* Vertices */
+
+BLI_INLINE HairFiberVertex* BKE_hair_iter__verts_init(HairIterator *iter, const HairCurveData *curve_data)
+{
+ iter->data.verts.last = curve_data->verts + curve_data->totverts;
+ iter->data.verts.vertex = curve_data->verts;
+ return iter->data.verts.vertex;
+}
+
+BLI_INLINE bool BKE_hair_iter__verts_valid(const HairIterator *iter)
+{
+ return iter->data.verts.vertex != iter->data.verts.last;
+}
+
+BLI_INLINE HairFiberVertex* BKE_hair_iter__verts_next(HairIterator *iter)
+{
+ ++iter->data.verts.vertex;
+ return iter->data.verts.vertex;
+}
+
+/* Follicles */
+
+BLI_INLINE HairFollicle* BKE_hair_iter__follicles_init(HairIterator *iter, const HairPattern *pattern)
+{
+ iter->data.follicles.last = pattern->follicles + pattern->num_follicles;
+ iter->data.follicles.follicle = pattern->follicles;
+ return iter->data.follicles.follicle;
+}
+
+BLI_INLINE bool BKE_hair_iter__follicles_valid(const HairIterator *iter)
+{
+ return iter->data.follicles.follicle != iter->data.follicles.last;
+}
+
+BLI_INLINE HairFollicle* BKE_hair_iter__follicles_next(HairIterator *iter)
+{
+ ++iter->data.follicles.follicle;
+ return iter->data.follicles.follicle;
+}
+
+/* Follicle Curves */
+
+BLI_INLINE HairFollicle* BKE_hair_iter__follicle_curves_init(HairIterator *iter, const HairPattern *pattern, const HairCurveData *curve_data)
+{
+ HairIter__follicle_curves *intern = &iter->data.follicle_curves;
+
+ intern->last = pattern->follicles + pattern->num_follicles;
+ intern->curves_array = curve_data->curves;
+
+ intern->follicle = pattern->follicles;
+ while (intern->follicle != intern->last) {
+ if (intern->follicle->curve != HAIR_CURVE_INDEX_NONE) {
+ intern->curve = &intern->curves_array[intern->follicle->curve];
+ break;
+ }
+ ++intern->follicle;
+ }
+ return intern->follicle;
+}
+
+BLI_INLINE bool BKE_hair_iter__follicle_curves_valid(const HairIterator *iter)
+{
+ const HairIter__follicle_curves *intern = &iter->data.follicle_curves;
+
+ return intern->follicle != intern->last;
+}
+
+BLI_INLINE HairFollicle* BKE_hair_iter__follicle_curves_next(HairIterator *iter)
+{
+ HairIter__follicle_curves *intern = &iter->data.follicle_curves;
+
+ ++intern->follicle;
+ while (intern->follicle != intern->last) {
+ if (intern->follicle->curve != HAIR_CURVE_INDEX_NONE) {
+ intern->curve = &intern->curves_array[intern->follicle->curve];
+ break;
+ }
+ ++intern->follicle;
+ }
+ return intern->follicle;
+}
+
+/* Curve Vertices */
+
+BLI_INLINE HairFiberVertex* BKE_hair_iter__curve_verts_init(HairIterator *iter, const HairCurveData *curve_data, const HairFiberCurve *curve)
+{
+ HairIter__curve_verts *intern = &iter->data.curve_verts;
+
+ intern->last = &curve_data->verts[curve->vertstart + curve->numverts];
+ intern->vertex = &curve_data->verts[curve->vertstart];
+ return intern->vertex;
+}
+
+BLI_INLINE bool BKE_hair_iter__curve_verts_valid(const HairIterator *iter)
+{
+ const HairIter__curve_verts *intern = &iter->data.curve_verts;
+
+ return intern->vertex != intern->last;
+}
+
+BLI_INLINE HairFiberVertex* BKE_hair_iter__curve_verts_next(HairIterator *iter)
+{
+ HairIter__curve_verts *intern = &iter->data.curve_verts;
+
+ ++intern->vertex;
+ return intern->vertex;
+}
+
+/* Loop macros */
+
+#define BKE_HAIR_ITER_CURVES(ele, iter, curve_data) \
+ for ((ele) = BKE_hair_iter__curves_init((iter), (curve_data)); \
+ BKE_hair_iter__curves_valid(iter); \
+ (ele) = BKE_hair_iter__curves_next(iter))
+
+#define BKE_HAIR_ITER_CURVES_INDEX(ele, iter, curve_data, indexvar) \
+ for ((ele) = BKE_hair_iter__curves_init((iter), (curve_data)), (indexvar = 0); \
+ BKE_hair_iter__curves_valid(iter); \
+ (ele) = BKE_hair_iter__curves_next(iter), ++(indexvar))
+
+#define BKE_HAIR_ITER_VERTS(ele, iter, curve_data) \
+ for ((ele) = BKE_hair_iter__verts_init((iter), (curve_data)); \
+ BKE_hair_iter__verts_valid(iter); \
+ (ele) = BKE_hair_iter__verts_next(iter))
+
+#define BKE_HAIR_ITER_VERTS_INDEX(ele, iter, curve_data, indexvar) \
+ for ((ele) = BKE_hair_iter__verts_init((iter), (curve_data)), (indexvar = 0); \
+ BKE_hair_iter__verts_valid(iter); \
+ (ele) = BKE_hair_iter__verts_next(iter), ++(indexvar))
+
+#define BKE_HAIR_ITER_FOLLICLES(ele, iter, pattern) \
+ for ((ele) = BKE_hair_iter__follicles_init((iter), (pattern)); \
+ BKE_hair_iter__follicles_valid(iter); \
+ (ele) = BKE_hair_iter__follicles_next(iter))
+
+#define BKE_HAIR_ITER_FOLLICLES_INDEX(ele, iter, pattern, indexvar) \
+ for ((ele) = BKE_hair_iter__follicles_init((iter), (pattern)), (indexvar = 0); \
+ BKE_hair_iter__follicles_valid(iter); \
+ (ele) = BKE_hair_iter__follicles_next(iter), ++(indexvar))
+
+#define BKE_HAIR_ITER_FOLLICLE_CURVES(ele, curvevar, iter, pattern, curve_data) \
+ for ((ele) = BKE_hair_iter__follicle_curves_init((iter), (pattern), (curve_data)), \
+ (curvevar) = (iter)->data.follicle_curves.curve; \
+ BKE_hair_iter__follicle_curves_valid(iter); \
+ (ele) = BKE_hair_iter__follicle_curves_next((iter)), \
+ (curvevar) = (iter)->data.follicle_curves.curve)
+
+#define BKE_HAIR_ITER_CURVE_VERTS(ele, iter, curve_data, curve) \
+ for ((ele) = BKE_hair_iter__curve_verts_init((iter), (curve_data), (curve)); \
+ BKE_hair_iter__curve_verts_valid(iter); \
+ (ele) = BKE_hair_iter__curve_verts_next(iter))
+
+#define BKE_HAIR_ITER_CURVE_VERTS_INDEX(ele, iter, curve_data, curve, indexvar) \
+ for ((ele) = BKE_hair_iter__curve_verts_init((iter), (curve_data), (curve)), (indexvar = 0); \
+ BKE_hair_iter__curve_verts_valid(iter); \
+ (ele) = BKE_hair_iter__curve_verts_next(iter), ++(indexvar))
+
+#endif
diff --git a/source/blender/blenkernel/CMakeLists.txt b/source/blender/blenkernel/CMakeLists.txt
index 2640abab15b..a4ae045586e 100644
--- a/source/blender/blenkernel/CMakeLists.txt
+++ b/source/blender/blenkernel/CMakeLists.txt
@@ -268,6 +268,7 @@ set(SRC
BKE_gpencil.h
BKE_gpencil_modifier.h
BKE_hair.h
+ BKE_hair_iterators.h
BKE_icons.h
BKE_idcode.h
BKE_idprop.h
diff --git a/source/blender/blenkernel/intern/hair.c b/source/blender/blenkernel/intern/hair.c
index 8d635c47b29..2cc646bd6df 100644
--- a/source/blender/blenkernel/intern/hair.c
+++ b/source/blender/blenkernel/intern/hair.c
@@ -51,6 +51,7 @@
#include "DEG_depsgraph_query.h"
#include "BKE_global.h"
#include "BKE_hair.h"
+#include "BKE_hair_iterators.h"
#include "BKE_library.h"
#include "BKE_main.h"
#include "BKE_mesh.h"
@@ -491,11 +492,10 @@ bool BKE_hair_bind_follicles(HairSystem *hsys, const Mesh *scalp)
/* Need at least one curve for binding */
if (num_strands == 0)
{
- HairFollicle *follicle = pattern->follicles;
- for (int i = 0; i < pattern->num_follicles; ++i, ++follicle)
- {
- for (int k = 0; k < 4; ++k)
- {
+ HairIterator iter;
+ HairFollicle *follicle;
+ BKE_HAIR_ITER_FOLLICLES(follicle, &iter, pattern) {
+ for (int k = 0; k < 4; ++k) {
follicle->curve = HAIR_CURVE_INDEX_NONE;
}
}
@@ -512,12 +512,11 @@ bool BKE_hair_bind_follicles(HairSystem *hsys, const Mesh *scalp)
BLI_kdtree_balance(tree);
{
- HairFollicle *follicle = pattern->follicles;
- for (int i = 0; i < pattern->num_follicles; ++i, ++follicle)
- {
+ Hai
@@ Diff output truncated at 10240 characters. @@
More information about the Bf-blender-cvs
mailing list