[Bf-blender-cvs] SVN commit: /data/svn/bf-blender [27653] trunk/blender: Screw Modifier ( old patch was called Lathe)

Campbell Barton ideasman42 at gmail.com
Mon Mar 22 01:22:53 CET 2010


Revision: 27653
          http://projects.blender.org/plugins/scmsvn/viewcvs.php?view=rev&root=bf-blender&revision=27653
Author:   campbellbarton
Date:     2010-03-22 01:22:52 +0100 (Mon, 22 Mar 2010)

Log Message:
-----------
Screw Modifier (old patch was called Lathe)

didnt commit this patch because curves are generally better to create a shape to lathe however now that curves can have modifiers applied to them I think its good to have this.

Added options to offset the lathe so it can work like the screw tool as well.

- optional object for axis which also controls the center point.
- screw offset so rather then just lathing this can work more like the screw tool.
- screw optionally using the object distance along the axis.
- iterations so the screw can be applied multiple times.

tested to work well with curves.

Modified Paths:
--------------
    trunk/blender/release/scripts/ui/properties_data_modifier.py
    trunk/blender/source/blender/blenkernel/intern/modifier.c
    trunk/blender/source/blender/editors/include/UI_icons.h
    trunk/blender/source/blender/editors/space_outliner/outliner.c
    trunk/blender/source/blender/makesdna/DNA_modifier_types.h
    trunk/blender/source/blender/makesrna/RNA_access.h
    trunk/blender/source/blender/makesrna/intern/rna_modifier.c

Modified: trunk/blender/release/scripts/ui/properties_data_modifier.py
===================================================================
--- trunk/blender/release/scripts/ui/properties_data_modifier.py	2010-03-22 00:14:56 UTC (rev 27652)
+++ trunk/blender/release/scripts/ui/properties_data_modifier.py	2010-03-22 00:22:52 UTC (rev 27653)
@@ -497,6 +497,28 @@
     def PARTICLE_SYSTEM(self, layout, ob, md, wide_ui):
         layout.label(text="See Particle panel.")
 
+    def SCREW(self, layout, ob, md, wide_ui):
+        split = layout.split()
+        
+        col = split.column()
+        col.prop(md, "axis")
+        col.prop(md, "object", text="AxisOb")
+        col.prop(md, "angle")
+        col.prop(md, "steps")
+        col.prop(md, "render_steps")
+        
+        col = split.column()
+        row = col.row()
+        row.active = (md.object is None or md.use_object_screw_offset == False)
+        row.prop(md, "screw_offset")
+        row = col.row()
+        row.active = (md.object is not None)
+        row.prop(md, "use_object_screw_offset")
+        col.prop(md, "use_normal_calculate")
+        col.prop(md, "use_normal_flip")
+        col.prop(md, "iterations")
+        
+
     def SHRINKWRAP(self, layout, ob, md, wide_ui):
         split = layout.split()
         col = split.column()

Modified: trunk/blender/source/blender/blenkernel/intern/modifier.c
===================================================================
--- trunk/blender/source/blender/blenkernel/intern/modifier.c	2010-03-22 00:14:56 UTC (rev 27652)
+++ trunk/blender/source/blender/blenkernel/intern/modifier.c	2010-03-22 00:22:52 UTC (rev 27653)
@@ -5991,6 +5991,803 @@
 	return solidifyModifier_applyModifier(md, ob, derivedData, 0, 1);
 }
 
+/* Screw */
+
+/* Screw */
+/* Screw modifier: revolves the edges about an axis
+*/
+
+/* used for gathering edge connectivity */
+typedef struct ScrewVertConnect {
+	float dist;  /* distance from the center axis */
+	float co[3]; /* loaction relative to the transformed axis */
+	float no[3]; /* calc normal of the vertex */
+	int v[2]; /* 2  verts on either side of this one */
+	MEdge *e[2]; /* edges on either side, a bit of a waste since each edge ref's 2 edges */
+	char flag;
+} ScrewVertConnect;
+
+typedef struct ScrewVertIter {
+	ScrewVertConnect * v_array;
+	ScrewVertConnect * v_poin;
+	int v;
+	int v_other;
+	MEdge *e;
+} ScrewVertIter;
+
+#define ScrewVertIter_INIT(iter, array, v_init, dir)\
+	iter.v_array = array;\
+	iter.v = v_init;\
+	if (v_init>=0) {\
+		iter.v_poin = &array[v_init];\
+		iter.v_other = iter.v_poin->v[dir];\
+		if (dir)\
+			iter.e = iter.v_poin->e[0];\
+		else\
+			iter.e = iter.v_poin->e[1];\
+	} else {\
+		iter.v_poin= NULL;\
+		iter.e= NULL;\
+	}
+
+
+#define ScrewVertIter_NEXT(iter)\
+	if (iter.v_poin->v[0] == iter.v_other) {\
+		iter.v_other= iter.v;\
+		iter.v= iter.v_poin->v[1];\
+	} else if (iter.v_poin->v[1] == iter.v_other) {\
+		iter.v_other= iter.v;\
+		iter.v= iter.v_poin->v[0];\
+	}\
+	if (iter.v >=0)	{\
+		iter.v_poin= &iter.v_array[iter.v];\
+		if ( iter.v_poin->e[0] != iter.e )	iter.e= iter.v_poin->e[0];\
+		else								iter.e= iter.v_poin->e[1];\
+	} else {\
+		iter.e= NULL;\
+		iter.v_poin= NULL;\
+	}
+	
+static void screwModifier_initData(ModifierData *md)
+{
+	ScrewModifierData *ltmd= (ScrewModifierData*) md;
+	ltmd->ob_axis= NULL;
+	ltmd->angle= M_PI * 2.0;
+	ltmd->axis= 2;
+	ltmd->flag= 0;
+	ltmd->steps= 16;
+	ltmd->render_steps= 16;
+	ltmd->iter= 1;
+}
+
+static void screwModifier_copyData(ModifierData *md, ModifierData *target)
+{
+	ScrewModifierData *sltmd= (ScrewModifierData*) md;
+	ScrewModifierData *tltmd= (ScrewModifierData*) target;
+	
+	tltmd->ob_axis= sltmd->ob_axis;
+	tltmd->angle= sltmd->angle;
+	tltmd->axis= sltmd->axis;
+	tltmd->flag= sltmd->flag;
+	tltmd->steps= sltmd->steps;
+	tltmd->render_steps= sltmd->render_steps;
+	tltmd->iter= sltmd->iter;
+}
+
+static DerivedMesh *screwModifier_applyModifier(ModifierData *md, Object *ob,
+                                         DerivedMesh *derivedData,
+                                         int useRenderParams, int isFinalCalc)
+{
+	DerivedMesh *dm= derivedData;
+	DerivedMesh *result;
+	ScrewModifierData *ltmd= (ScrewModifierData*) md;
+	
+	int *origindex;
+	int mface_index=0;
+	int i, j;
+	int i1,i2;
+	int steps= ltmd->steps;
+	int maxVerts=0, maxEdges=0, maxFaces=0;
+	int totvert= dm->getNumVerts(dm);
+	int totedge= dm->getNumEdges(dm);
+
+	char axis_char, close;
+	float angle= ltmd->angle;
+	float screw_ofs= ltmd->screw_ofs;
+	float axis_vec[3]= {0.0f, 0.0f, 0.0f};
+	float tmp_vec1[3], tmp_vec2[3]; 
+	float mat3[3][3];
+	float mtx_tx[4][4]; /* transform the coords by an object relative to this objects transformation */
+	float mtx_tx_inv[4][4]; /* inverted */
+	float mtx_tmp_a[4][4];
+	
+	int vc_tot_linked= 0;
+	short other_axis_1, other_axis_2;
+	float *tmpf1, *tmpf2;
+	
+	MFace *mface_new, *mf_new;
+	MEdge *medge_orig, *med_orig, *med_new, *med_new_firstloop, *medge_new;
+	MVert *mvert_new, *mvert_orig, *mv_orig, *mv_new, *mv_new_base;
+
+	ScrewVertConnect *vc, *vc_tmp, *vert_connect= NULL;
+
+
+	float mat[4][4] =	{{0.0f, 0.0f, 0.0f, 0.0f},
+						 {0.0f, 0.0f, 0.0f, 0.0f},
+						 {0.0f, 0.0f, 0.0f, 0.0f},
+						 {0.0f, 0.0f, 0.0f, 1.0f}};
+
+	/* dont do anything? */
+	if (!totvert)
+		return CDDM_from_template(dm, 0, 0, 0);
+
+	if (useRenderParams)
+		steps= ltmd->render_steps;
+	else
+		steps= ltmd->steps;
+
+	if (ltmd->axis==0) {
+		other_axis_1=1;
+		other_axis_2=2;
+	} else if (ltmd->axis==1) {
+		other_axis_1=0;
+		other_axis_2=2;
+	} else {
+		other_axis_1=0;
+		other_axis_2=1;
+	}
+
+	axis_vec[ltmd->axis]= 1.0;
+	if (ltmd->ob_axis) {
+		float mtx3_tx[3][3];
+		/* calc the matrix relative to the axis object */
+		invert_m4_m4(mtx_tmp_a, ob->obmat);
+		copy_m4_m4(mtx_tx_inv, ltmd->ob_axis->obmat);
+		mul_m4_m4m4(mtx_tx, mtx_tx_inv, mtx_tmp_a);
+
+		copy_m3_m4(mtx3_tx, mtx_tx);
+
+		/* calc the axis vec */
+		mul_m3_v3(mtx3_tx, axis_vec);
+		normalize_v3(axis_vec);
+
+		/* screw */
+		if(ltmd->flag & MOD_SCREW_OBJECT_OFFSET) {
+			/* find the offset along this axis relative to this objects matrix */
+			float totlen = len_v3(mtx_tx[3]);
+
+			if(totlen != 0.0f) {
+				float zero[3]={0,0,0};
+				float cp[3];				
+				screw_ofs= closest_to_line_v3(cp, mtx_tx[3], zero, axis_vec);
+			}
+			else {
+				screw_ofs= 0.0f;
+			}
+		}
+
+		/* angle */
+
+#if 0	// cant incluide this, not pradictable enough, though quite fun,.
+		if(ltmd->flag & MOD_SCREW_OBJECT_ANGLE) {
+
+
+			float vec[3] = {0,1,0};
+			float cross1[3];
+			float cross2[3];
+			cross_v3_v3v3(cross1, vec, axis_vec);
+
+			mul_v3_m3v3(cross2, mtx3_tx, cross1);
+			{
+				float c1[3];
+				float c2[3];
+				float axis_tmp[3];
+
+				cross_v3_v3v3(c1, cross2, axis_vec);
+				cross_v3_v3v3(c2, axis_vec, c1);
+
+
+				angle= angle_v3v3(cross1, c2);
+
+				cross_v3_v3v3(axis_tmp, cross1, c2);
+				normalize_v3(axis_tmp);
+
+				if(len_v3v3(axis_tmp, axis_vec) > 1.0)
+					angle= -angle;
+
+			}
+		}
+#endif
+
+	} else {
+		/* exis char is used by i_rotate*/
+		axis_char= 'X' + ltmd->axis;
+
+		/* useful to be able to use the axis vec in some cases still */
+		zero_v3(axis_vec);
+		axis_vec[ltmd->axis]= 1.0;
+	}
+
+	/* apply the multiplier */
+	angle *= ltmd->iter;
+	screw_ofs *= ltmd->iter;
+
+	/* multiplying the steps is a bit tricky, this works best */
+	steps += 1;
+	steps = (steps * ltmd->iter) - (ltmd->iter - 1);
+	if(steps < 2) steps= 2;
+
+	/* will the screw be closed? */
+	if (fabs(screw_ofs) <= (FLT_EPSILON*100) && fabs(fabs(angle) -  M_PI * 2.0) <= (FLT_EPSILON*100)) {
+		close= 1;
+	
+		maxVerts =	totvert  * steps; /* -1 because we're joining back up */
+		maxEdges =	(totvert * steps) + /* these are the edges between new verts */
+					(totedge * steps); /* -1 because vert edges join */
+		maxFaces =	totedge * steps;
+
+		screw_ofs= 0.0f;
+	} else {
+		close= 0;
+		
+		maxVerts =	totvert  * steps; /* -1 because we're joining back up */
+		maxEdges =	(totvert * (steps-1)) + /* these are the edges between new verts */
+					(totedge * steps); /* -1 because vert edges join */
+		maxFaces =	totedge * (steps-1);
+	}
+	
+	result= CDDM_from_template(dm, maxVerts, maxEdges, maxFaces);
+	
+	/* copy verts from mesh */
+	mvert_orig =	dm->getVertArray(dm);
+	medge_orig =	dm->getEdgeArray(dm);
+	
+	mvert_new =		result->getVertArray(result);
+	mface_new =		result->getFaceArray(result);
+	medge_new =		result->getEdgeArray(result);
+	
+	origindex= result->getFaceDataArray(result, CD_ORIGINDEX);
+	
+	/* Set the locations of the first set of verts */
+	
+	mv_new= mvert_new;
+	mv_orig= mvert_orig;
+	
+	/* Copy the first set of edges */
+	med_orig= medge_orig;
+	med_new= medge_new;
+	for (i=0; i < totedge; i++, med_orig++, med_new++) {
+		med_new->v1= med_orig->v1;
+		med_new->v2= med_orig->v2;
+		med_new->crease= med_orig->crease;
+		med_new->flag= med_orig->flag &  ~ME_LOOSEEDGE;
+	}
+	
+	if(ltmd->flag & MOD_SCREW_NORMAL_CALC) {
+		/*
+		 * Normal Calculation (for face flipping)
+		 * Sort edge verts for correct face flipping
+		 * NOT REALLY NEEDED but face flipping is nice.
+		 *
+		 * */
+
+
+		/* Notice!
+		 *
+		 * Since we are only ordering the edges here it can avoid mallocing the
+		 * extra space by abusing the vert array berfore its filled with new verts.
+		 * The new array for vert_connect must be at least sizeof(ScrewVertConnect) * totvert
+		 * and the size of our resulting meshes array is sizeof(MVert) * totvert * 3
+		 * so its safe to use the second 2 thrids of MVert the array for vert_connect,
+		 * just make sure ScrewVertConnect struct is no more then twice as big as MVert,
+		 * at the moment there is no chance of that being a problem,
+		 * unless MVert becomes half its current size.
+		 *
+		 * once the edges are ordered, vert_connect is not needed and it can be used for verts
+		 *
+		 * This makes the modifier faster with one less alloc.
+		 */
+
+		vert_connect= MEM_mallocN(sizeof(ScrewVertConnect) * totvert, "ScrewVertConnect");
+		//vert_connect= (ScrewVertConnect *) &medge_new[totvert]; /* skip the first slice of verts */
+		vc= vert_connect;
+
+		/* Copy Vert Locations */
+		/* - We can do this in a later loop - only do here if no normal calc */
+		if (!totedge) {
+			for (i=0; i < totvert; i++, mv_orig++, mv_new++) {
+				copy_v3_v3(mv_new->co, mv_orig->co);
+				normalize_v3_v3(vc->no, mv_new->co); /* no edges- this is realy a dummy normal */
+			}
+		} else {
+			/*printf("\n\n\n\n\nStarting Modifier\n");*/
+			/* set edge users */
+			med_new= medge_new;

@@ Diff output truncated at 10240 characters. @@




More information about the Bf-blender-cvs mailing list