X-Git-Url: https://git.pterodactylus.net/?a=blobdiff_plain;f=synfig-core%2Ftrunk%2Fsrc%2Fmodules%2Fmod_particle%2Fplant.cpp;h=c97d3aec934882acec1332fadded9ffa7d319640;hb=715cd2ff1c66dde194d89615b447fcbe86f3ccc6;hp=1af642c49ac7df4eab9a987ffa27c177b487200f;hpb=534d634ec3ace72b406bde4f847ac1eb506fe484;p=synfig.git

diff --git a/synfig-core/trunk/src/modules/mod_particle/plant.cpp b/synfig-core/trunk/src/modules/mod_particle/plant.cpp
index 1af642c..c97d3ae 100644
--- a/synfig-core/trunk/src/modules/mod_particle/plant.cpp
+++ b/synfig-core/trunk/src/modules/mod_particle/plant.cpp
@@ -6,6 +6,7 @@
 **
 **	\legal
 **	Copyright (c) 2002-2005 Robert B. Quattlebaum Jr., Adrian Bentley
+**	Copyright (c) 2007 Chris Moore
 **
 **	This package is free software; you can redistribute it and/or
 **	modify it under the terms of the GNU General Public License as
@@ -78,7 +79,7 @@ Plant::Plant():
 	split_angle(Angle::deg(10)),
 	gravity(0,-0.1),
 	velocity(0.3),
-	perp_velocity(0.3),
+	perp_velocity(0.0),
 	step(0.01),
 	sprouts(10)
 {
@@ -106,6 +107,7 @@ Plant::Plant():
 	needs_sync_=true;
 	sync();
 	size_as_alpha=false;
+	reverse=true;
 }
 
 void
@@ -178,6 +180,7 @@ Plant::sync()const
 {
 	Mutex::Lock lock(mutex);
 	if (!needs_sync_) return;
+	time_t start_time; time(&start_time);
 	particle_list.clear();
 
 	bounding_rect=Rect::zero();
@@ -215,6 +218,7 @@ Plant::sync()const
 		Real f;
 
 		int i=0, branch_count = 0, steps = round_to_int(1.0/step);
+		if (steps < 1) steps = 1;
 		for(f=0.0;f<1.0;f+=step,i++)
 		{
 			Point point(curve(f));
@@ -225,7 +229,7 @@ Plant::sync()const
 
 			bounding_rect.expand(point);
 
-			Real stunt_growth(random_factor * random(Random::SMOOTH_COSINE,i,f+seg,0.0f,0.0f)/2.0+0.5);
+			Real stunt_growth(random_factor * (random(Random::SMOOTH_COSINE,i,f+seg,0.0f,0.0f)/2.0+0.5));
 			stunt_growth*=stunt_growth;
 
 			if((((i+1)*sprouts + steps/2) / steps) > branch_count) {
@@ -242,6 +246,10 @@ Plant::sync()const
 		}
 	}
 
+	time_t end_time; time(&end_time);
+	if (end_time-start_time > 4)
+		synfig::info("Plant::sync() constructed %d particles in %d seconds\n",
+					 particle_list.size(), int(end_time-start_time));
 	needs_sync_=false;
 }
 
@@ -267,13 +275,22 @@ Plant::set_param(const String & param, const ValueBase &value)
 	IMPORT_PLUS(gradient,needs_sync_=true);
 	IMPORT_PLUS(velocity,needs_sync_=true);
 	IMPORT_PLUS(perp_velocity,needs_sync_=true);
-	IMPORT_PLUS(step,needs_sync_=true);
+	IMPORT_PLUS(step,{
+			needs_sync_ = true;
+			if (step <= 0)
+				step=0.01; // user is probably clueless - give a good default
+			else if (step < 0.00001)
+				step=0.00001; // 100K should be enough for anyone
+			else if (step > 1)
+				step=1;
+		});
 	IMPORT_PLUS(splits,needs_sync_=true);
 	IMPORT_PLUS(sprouts,needs_sync_=true);
 	IMPORT_PLUS(random_factor,needs_sync_=true);
 	IMPORT_PLUS(drag,needs_sync_=true);
 	IMPORT(size);
 	IMPORT(size_as_alpha);
+	IMPORT(reverse);
 
 	return Layer_Composite::set_param(param,value);
 }
@@ -321,6 +338,7 @@ Plant::get_param(const String& param)const
 	EXPORT(size);
 
 	EXPORT(size_as_alpha);
+	EXPORT(reverse);
 
 	EXPORT_NAME();
 	EXPORT_VERSION();
@@ -377,6 +395,11 @@ Plant::get_param_vocab()const
 		.set_description(_("If enabled, the alpha channel from the gradient is multiplied by the stem size, and an alpha of 1.0 is used when rendering"))
 	);
 
+	ret.push_back(ParamDesc("reverse")
+		.set_local_name(_("Reverse"))
+		.set_description(_("If enabled, render the plant in the opposite direction"))
+	);
+
 	ret.push_back(ParamDesc("step")
 		.set_local_name(_("Step"))
 		.set_description(_("Measure of the distance between points when rendering"))
@@ -437,101 +460,210 @@ Plant::accelerated_render(Context context,Surface *surface,int quality, const Re
 	if(needs_sync_==true)
 		sync();
 
-	std::vector<Particle>::reverse_iterator iter;
-	const float size_factor(1);
-	float radius(size_factor*size*sqrt(1.0f/(abs(pw)*abs(ph)))), temp_radius;
-
-	if(radius>1.0f)
+	if (particle_list.begin() != particle_list.end())
 	{
-		radius*=1.0;			// what does this do?
+		std::vector<Particle>::iterator iter;
+		Particle *particle;
+
+		float radius(size*sqrt(1.0f/(abs(pw)*abs(ph))));
+
 		int x1,y1,x2,y2;
-		for(iter=particle_list.rbegin();iter!=particle_list.rend();++iter)
+
+		if (reverse)	iter = particle_list.end();
+		else			iter = particle_list.begin();
+
+		while (true)
 		{
-			temp_radius = radius;
-			float radius(temp_radius);
-			Color color(iter->color);
+			if (reverse)	particle = &(*(iter-1));
+			else			particle = &(*iter);
+
+			float scaled_radius(radius);
+			Color color(particle->color);
 			if(size_as_alpha)
 			{
-				radius*=color.get_a();
+				scaled_radius*=color.get_a();
 				color.set_a(1);
 			}
 
-			// calculate the box that this particle will be drawn as
-			x1=ceil_to_int((iter->point[0]-tl[0])/pw-(radius*0.5));
-			y1=ceil_to_int((iter->point[1]-tl[1])/ph-(radius*0.5));
-			x2=x1+round_to_int(radius);
-			y2=y1+round_to_int(radius);
-
-			// if the box is entirely off the canvas, go to the next particle
-			if(x1>=surface_width || y1>=surface_height || x2<0 || y2<0) continue;
-
-			// adjust the box so it's entirely on the canvas
-			if(x2>=surface_width) x2=surface_width;
-			if(y2>=surface_height) y2=surface_height;
-			if(x1<0) x1=0;
-			if(y1<0) y1=0;
-
-			int w(min(round_to_int(radius),x2-x1));
-			int h(min(round_to_int(radius),y2-y1));
-
-			if(w<=0 || h<=0)
-				continue;
+			// previously, radius was multiplied by sqrt(step)*12 only if
+			// the radius came out at less than 1 (pixel):
+			//   if (radius<=1.0f) radius*=sqrt(step)*12.0f;
+			// seems a little arbitrary - does it help?
 
-			Surface::alpha_pen surface_pen(dest_surface.get_pen(x1,y1),1.0f);
-			dest_surface.fill(color,surface_pen,w,h);
-		}
-	}
-	else
-	{
-		//radius/=0.01;
-		radius*=sqrt(step)*12.0f;
-		for(iter=particle_list.rbegin();iter!=particle_list.rend();++iter)
-		{
-			temp_radius = radius;
-			float radius(temp_radius);
-			Color color(iter->color);
-			if(size_as_alpha)
+			// calculate the box that this particle will be drawn as
+			float x1f=(particle->point[0]-tl[0])/pw-(scaled_radius*0.5);
+			float x2f=(particle->point[0]-tl[0])/pw+(scaled_radius*0.5);
+			float y1f=(particle->point[1]-tl[1])/ph-(scaled_radius*0.5);
+			float y2f=(particle->point[1]-tl[1])/ph+(scaled_radius*0.5);
+			x1=ceil_to_int(x1f);
+			x2=ceil_to_int(x2f)-1;
+			y1=ceil_to_int(y1f);
+			y2=ceil_to_int(y2f)-1;
+
+			// if the box isn't entirely off the canvas, draw it
+			if(x1<=surface_width && y1<=surface_height && x2>=0 && y2>=0)
 			{
-				radius*=color.get_a();
-				color.set_a(1);
+				float x1e=x1-x1f, x2e=x2f-x2, y1e=y1-y1f, y2e=y2f-y2;
+				// printf("x1e %.4f x2e %.4f y1e %.4f y2e %.4f\n", x1e, x2e, y1e, y2e);
+
+				// adjust the box so it's entirely on the canvas
+				if(x1<=0) { x1=0; x1e=0; }
+				if(y1<=0) { y1=0; y1e=0; }
+				if(x2>=surface_width)  { x2=surface_width;  x2e=0; }
+				if(y2>=surface_height) { y2=surface_height; y2e=0; }
+
+				int w(x2-x1), h(y2-y1);
+
+				Surface::alpha_pen surface_pen(dest_surface.get_pen(x1,y1),1.0f);
+				if(w>0 && h>0)
+					dest_surface.fill(color,surface_pen,w,h);
+
+				/* the rectangle doesn't cross any vertical pixel boundaries so we don't
+				 * need to draw any top or bottom edges
+				 */
+				if(x2<x1)
+				{
+					// case 1 - a single pixel
+					if(y2<y1)
+					{
+						surface_pen.move_to(x2,y2);
+						surface_pen.set_alpha((x2f-x1f)*(y2f-y1f));
+						surface_pen.put_value(color);
+					}
+					// case 2 - a single vertical column of pixels
+					else
+					{
+						surface_pen.move_to(x2,y1-1);
+						if (y1e!=0)	// maybe draw top pixel
+						{
+							surface_pen.set_alpha(y1e*(x2f-x1f));
+							surface_pen.put_value(color);
+						}
+						surface_pen.inc_y();
+						surface_pen.set_alpha(x2f-x1f);
+						for(int i=y1; i<y2; i++) // maybe draw pixels between
+						{
+							surface_pen.put_value(color);
+							surface_pen.inc_y();
+						}
+						if (y2e!=0)	// maybe draw bottom pixel
+						{
+							surface_pen.set_alpha(y2e*(x2f-x1f));
+							surface_pen.put_value(color);
+						}
+					}
+				}
+				else
+				{
+					// case 3 - a single horizontal row of pixels
+					if(y2<y1)
+					{
+						surface_pen.move_to(x1-1,y2);
+						if (x1e!=0)	// maybe draw left pixel
+						{
+							surface_pen.set_alpha(x1e*(y2f-y1f));
+							surface_pen.put_value(color);
+						}
+						surface_pen.inc_x();
+						surface_pen.set_alpha(y2f-y1f);
+						for(int i=x1; i<x2; i++) // maybe draw pixels between
+						{
+							surface_pen.put_value(color);
+							surface_pen.inc_x();
+						}
+						if (x2e!=0)	// maybe draw right pixel
+						{
+							surface_pen.set_alpha(x2e*(y2f-y1f));
+							surface_pen.put_value(color);
+						}
+					}
+					// case 4 - a proper block of pixels
+					else
+					{
+						if (x1e!=0)	// maybe draw left edge
+						{
+							surface_pen.move_to(x1-1,y1-1);
+							if (y1e!=0)	// maybe draw top left pixel
+							{
+								surface_pen.set_alpha(x1e*y1e);
+								surface_pen.put_value(color);
+							}
+							surface_pen.inc_y();
+							surface_pen.set_alpha(x1e);
+							for(int i=y1; i<y2; i++) // maybe draw pixels along the left edge
+							{
+								surface_pen.put_value(color);
+								surface_pen.inc_y();
+							}
+							if (y2e!=0)	// maybe draw bottom left pixel
+							{
+								surface_pen.set_alpha(x1e*y2e);
+								surface_pen.put_value(color);
+							}
+							surface_pen.inc_x();
+						}
+						else
+							surface_pen.move_to(x1,y2);
+
+						if (y2e!=0)	// maybe draw bottom edge
+						{
+							surface_pen.set_alpha(y2e);
+							for(int i=x1; i<x2; i++) // maybe draw pixels along the bottom edge
+							{
+								surface_pen.put_value(color);
+								surface_pen.inc_x();
+							}
+							if (x2e!=0)	// maybe draw bottom right pixel
+							{
+								surface_pen.set_alpha(x2e*y2e);
+								surface_pen.put_value(color);
+							}
+							surface_pen.dec_y();
+						}
+						else
+							surface_pen.move_to(x2,y2-1);
+
+						if (x2e!=0)	// maybe draw right edge
+						{
+							surface_pen.set_alpha(x2e);
+							for(int i=y1; i<y2; i++) // maybe draw pixels along the right edge
+							{
+								surface_pen.put_value(color);
+								surface_pen.dec_y();
+							}
+							if (y1e!=0)	// maybe draw top right pixel
+							{
+								surface_pen.set_alpha(x2e*y1e);
+								surface_pen.put_value(color);
+							}
+							surface_pen.dec_x();
+						}
+						else
+							surface_pen.move_to(x2-1,y1-1);
+
+						if (y1e!=0)	// maybe draw top edge
+						{
+							surface_pen.set_alpha(y1e);
+							for(int i=x1; i<x2; i++) // maybe draw pixels along the top edge
+							{
+								surface_pen.put_value(color);
+								surface_pen.dec_x();
+							}
+						}
+					}
+				}
 			}
 
-			bool top = false, bottom = false, left = false, right = false;
-
-			// calculate the point that this particle will be drawn as
-			int x=ceil_to_int((iter->point[0]-tl[0])/pw-1.499999f);
-			if (x < 0)
-				if (x == -1) left = true; else continue;
-			else  if (x > surface_width-2)
-				if (x == surface_width-1) right = true; else continue;
-
-			int y=ceil_to_int((iter->point[1]-tl[1])/ph-1.499999f);
-			if (y < 0)
-				if (y == -1) top = true; else continue;
-			else if (y > surface_height-2)
-				if (y == surface_height-1) bottom = true; else continue;
-
-			// calculate how much of the point is at (x) and how much at (x+1)
-			float x1=((iter->point[0]-tl[0])/pw-0.5f-x)*radius, x0=radius-x1;
-
-			// calculate how much of the point is at (y) and how much at (y+1)
-			float y1=((iter->point[1]-tl[1])/ph-0.5f-y)*radius, y0=radius-y1;
-
-			Surface::alpha_pen surface_pen(dest_surface.get_pen(x,y),1.0f);
-
-			//     |  x0 |  x1
-			//  ---+-----+-----
-			//  y0 | 1st | 2nd
-			//  ---+-----+-----
-			//  y1 | 4th | 3rd
-
-			if (!left  && !top)    { surface_pen.set_alpha(x0*y0); surface_pen.put_value(color); }
-			surface_pen.inc_x();
-			if (!right && !top)    { surface_pen.set_alpha(x1*y0); surface_pen.put_value(color); }
-			surface_pen.inc_y();
-			if (!right && !bottom) { surface_pen.set_alpha(x1*y1); surface_pen.put_value(color); }
-			surface_pen.dec_x();
-			if (!left  && !bottom) { surface_pen.set_alpha(x0*y1); surface_pen.put_value(color); }
+			if (reverse)
+			{
+				if (--iter == particle_list.begin())
+					break;
+			}
+			else
+			{
+				if (++iter == particle_list.end())
+					break;
+			}
 		}
 	}