Exemplo n.º 1
0
	SmokeParticle::SmokeParticle(Effect* _effect, ParticleMover* _mover,
		const Vec3 _pos, const Vec3 _velocity, const color_t hue_adjust,
		const color_t saturation_adjust, const coord_t _sqrt_scale,
		const coord_t _max_size, const coord_t size_scalar,
		const alpha_t alpha_scale) :
		Particle(_effect, _mover, _pos, _velocity,
			size_scalar * (0.5f + randcoord()))
	{
		sqrt_scale = _sqrt_scale;
		max_size = _max_size;
		const color_t color_scale= square(randcolor(0.6));
		color_t hue, saturation, value;
		hue = randcolor(1.0);
		//  saturation = 1.0 - (color_scale + 0.15) / (0.15 + color_scale + square(randcolor(0.15)));
		saturation = color_scale;
		value = square(randcolor(0.15)) + color_scale + 0.15;
		//  color[0] = square(randcolor(0.15)) + color_scale + 0.15;
		//  color[1] = square(randcolor(0.15)) + color_scale + 0.15;
		//  color[2] = square(randcolor(0.15)) + color_scale + 0.15;
		hue += hue_adjust;
		if (hue > 1.0)
			hue -= 1.0;
		saturation = std::min(1.0f, saturation * saturation_adjust);
		hsv_to_rgb(hue, saturation, value, color[0], color[1], color[2]);
		alpha = std::min(1.0f, (0.05f + randcoord(0.1f)) * alpha_scale);
		flare_max = 1.0;
		flare_exp = 1.0;
		flare_frequency = 1.0;
		state = 0;
	}
Exemplo n.º 2
0
	BagParticle::BagParticle(Effect* _effect, ParticleMover* _mover,
		const Vec3 _pos, const Vec3 _velocity, const coord_t _size) :
		Particle(_effect, _mover, _pos, _velocity, _size)
	{
		color[0] = randcolor(0.3) + 0.7;
		color[1] = randcolor(0.3) + 0.5;
		color[2] = randcolor(0.3) + 0.3;
		alpha = 0.75;
		flare_max = 1.0;
		flare_exp = 1.0;
		flare_frequency = 1.0;
		state = 0;
	}
Exemplo n.º 3
0
	CandleParticle::CandleParticle(Effect* _effect, ParticleMover* _mover,
		const Vec3 _pos, const Vec3 _velocity, const color_t hue_adjust,
		const color_t saturation_adjust, const float _scale, const Uint16 _LOD) :
		Particle(_effect, _mover, _pos, _velocity)
	{
		LOD = _LOD;
		color_t hue, saturation, value;
		hue = 0.03 + randcolor(0.08);
		saturation = 0.78;
		value = 0.9;
		hue += hue_adjust;
		if (hue > 1.0)
			hue -= 1.0;
		saturation *= saturation_adjust;
		if (saturation > 1.0)
			saturation = 1.0;
		hsv_to_rgb(hue, saturation, value, color[0], color[1], color[2]);
		size = 6.0 * (2.0 + randcoord()) / (LOD + 2);
		alpha = 0.4 * 5 / size / (LOD + 2);
		if (alpha > 1.0)
			alpha = 1.0;
		size *= _scale;
		flare_max = 1.0;
		flare_exp = 0.0;
		flare_frequency = 2.0;
		state = ((rand() % 3) == 0);
	}
Exemplo n.º 4
0
	SwordParticle::SwordParticle(Effect* _effect, ParticleMover* _mover,
		const Vec3 _pos, const Vec3 _velocity, const coord_t _size,
		const alpha_t _alpha, const color_t red, const color_t green,
		const color_t blue, TextureEnum _texture, const Uint16 _LOD) :
		Particle(_effect, _mover, _pos, _velocity,
			std::min(1.0f, _size * (0.2f + randcoord())))
	{
		color[0] = std::max(0.0f, std::min(1.0f, red + randcolor(0.25f) - 0.125f));
		color[1] = std::max(0.0f, std::min(1.0f, green + randcolor(0.25f) - 0.125f));
		color[2] = std::max(0.0f, std::min(1.0f, blue + randcolor(0.25f) - 0.125f));
		texture = _texture;
		alpha = _alpha;
		velocity /= size;
		flare_max = 1.6;
		flare_exp = 0.2;
		flare_frequency = 2.0;
		LOD = _LOD;
	}
Exemplo n.º 5
0
// rshapes draws shapes with random colors, strokes, and sizes. 
void rshapes(int width, int height, int n) {
	int i, j, np = 10;
	VGfloat sx, sy, cx, cy, px, py, ex, ey, pox, poy;
	VGfloat polyx[np], polyy[np];
	rseed();
	Start(width, height);
	for (i = 0; i < n; i++) {
		Fill(randcolor(), randcolor(), randcolor(), drand48());
		Ellipse(randf(width), randf(height), randf(200), randf(100));
		Circle(randf(width), randf(height), randf(100));
		Rect(randf(width), randf(height), randf(200), randf(100));
		Arc(randf(width), randf(height), randf(200), randf(200), randf(360), randf(360));

		sx = randf(width);
		sy = randf(height);
		Stroke(randcolor(), randcolor(), randcolor(), 1);
		StrokeWidth(randf(5));
		Line(sx, sy, sx + randf(200), sy + randf(100));
		StrokeWidth(0);

		sx = randf(width);
		sy = randf(height);
		ex = sx + randf(200);
		ey = sy;
		cx = sx + ((ex - sx) / 2.0);
		cy = sy + randf(100);
		Qbezier(sx, sy, cx, cy, ex, ey);

		sx = randf(width);
		sy = randf(height);
		ex = sx + randf(200);
		ey = sy;
		cx = sx + ((ex - sx) / 2.0);
		cy = sy + randf(100);
		px = cx;
		py = sy - randf(100);
		Cbezier(sx, sy, cx, cy, px, py, ex, ey);

		pox = randf(width);
		poy = randf(height);
		for (j = 0; j < np; j++) {
			polyx[j] = pox + randf(200);
			polyy[j] = poy + randf(100);
		}
		Polygon(polyx, polyy, np);

		pox = randf(width);
		poy = randf(height);
		for (j = 0; j < np; j++) {
			polyx[j] = pox + randf(200);
			polyy[j] = poy + randf(100);
		}
		Polyline(polyx, polyy, np);
	}
	Fill(128, 0, 0, 1);
	Text(20, 20, "OpenVG on the Raspberry Pi", 32);
	End();
}
Exemplo n.º 6
0
	MissileParticle::MissileParticle(Effect* _effect, ParticleMover* _mover,
		const Vec3 _pos, const Vec3 _velocity, const coord_t _size,
		const alpha_t _alpha, const color_t red, const color_t green,
#ifdef	NEW_TEXTURES
		const color_t blue, TextureEnum _texture, const Uint16 _LOD,
#else	/* NEW_TEXTURES */
		const color_t blue, Texture* _texture, const Uint16 _LOD,
#endif	/* NEW_TEXTURES */
		const MissileEffect::MissileType _type) :
		Particle(_effect, _mover, _pos, _velocity)
	{
		color[0] = red + randcolor(0.25) - 0.125;
		if (color[0] > 1.0)
			color[0] = 1.0;
		else if (color[0] < 0.0)
			color[0] = 0.0;
		color[1] = green + randcolor(0.25) - 0.125;
		if (color[1] > 1.0)
			color[1] = 1.0;
		else if (color[1] < 0.0)
			color[1] = 0.0;
		color[2] = blue + randcolor(0.25) - 0.125;
		if (color[2] > 1.0)
			color[2] = 1.0;
		else if (color[2] < 0.0)
			color[2] = 0.0;
		texture = _texture;
		size = std::max(1.0f, (float)(_size * (0.25 + randcoord(1.25)))); // size >= 1.0
		alpha = std::max(0.25f, (float)_alpha); // at least 25% alpha
		velocity /= size;
		flare_max = 1.6;
		flare_exp = 0.2;
		flare_frequency = 2.0;
		LOD = _LOD;
		type = _type;
	}
Exemplo n.º 7
0
void render_frame(pixel* pixels, int64_t frame_index) {
  int64_t pixel_index = 0;
  int64_t x = 0, y = 0, z = 0;
  if (frame_index % frames_per_layer == 0) {
    int i;
    for (i = spheres - 1; i > 0; i--) {
      sphere_colors[i] = sphere_colors[i - 1];
    }
    sphere_colors[0] = randcolor();
  }
  for (y = 0; y < depth; y++) {
    for (x = 0; x < width; x++) {
      for (z = 0; z < height; z++, pixel_index++) {
	render_pixel(pixels + pixel_index,
		     frame_index, pixel_index,
		     x, y, z,
		     x / xd, y / yd, z / zd);
      }
    }
  }
}
	TeleporterParticle::TeleporterParticle(Effect* _effect,
		ParticleMover* _mover, const Vec3 _pos, const Vec3 _velocity,
		const color_t hue_adjust, const color_t saturation_adjust,
		const coord_t size_scalar) :
		Particle(_effect, _mover, _pos, _velocity,
			size_scalar * (0.5 + 1.5 * randcoord()))
	{
		color_t hue, saturation, value;
		hue = randcolor(1.0);
		saturation = randfloat(0.2);
		value = 0.9;
		hue += hue_adjust;
		if (hue > 1.0)
			hue -= 1.0;
		saturation = std::min(1.0f, saturation * saturation_adjust);
		hsv_to_rgb(hue, saturation, value, color[0], color[1], color[2]);
		alpha = std::min(1.0f, 5.0f / size);
		velocity /= size;
		flare_max = 1.6;
		flare_exp = 0.2;
		flare_frequency = 2.0;
	}
Exemplo n.º 9
0
	ImpactEffect::ImpactEffect(EyeCandy* _base, bool* _dead, Vec3* _pos,
		const Vec3 _angle, const ImpactType _type, const Uint16 _LOD,
		const float _strength)
	{
		if (EC_DEBUG)
			std::cout << "ImpactEffect (" << this << ") created." << std::endl;
		base = _base;
		dead = _dead;
		pos = _pos;
		center = *pos;
		angle = _angle;
		type = _type;
		LOD = base->last_forced_LOD;
		desired_LOD = _LOD;
		spawner = NULL;
		bounds = NULL;
		mover = NULL;
		strength = _strength;
		const coord_t size_scalar = strength * 1.3;
		const coord_t vel_scalar= std::sqrt(strength) * 0.44;

		switch (type)
		{
			case MAGIC_PROTECTION:
			{
				angle.normalize(2.0 * vel_scalar);
				mover = new ParticleMover(this);
				for (int i = 0; i < 50 * LOD; i++)
				{
					Vec3 velocity = -angle;
					Vec3 offset;
					offset.randomize(0.3);
					velocity += offset;
					Particle * p = new ImpactParticle(this, mover, center, velocity, 0.3 * size_scalar, 1.0, 0.7, 0.2, 0.4, EC_SHIMMER, LOD, type);
					if (!base->push_back_particle(p))
						break;
				}
				break;
			}
			case SHIELD:
			{
				angle.normalize(2.0 * vel_scalar);
				mover = new ParticleMover(this);
				for (int i = 0; i < 50 * LOD; i++)
				{
					Vec3 velocity = -angle;
					Vec3 offset;
					offset.randomize(0.3);
					velocity += offset;
					Particle * p = new ImpactParticle(this, mover, center, velocity, 0.3 * size_scalar, 1.0, 0.9, 0.9, 0.9, EC_SHIMMER, LOD, type);
					if (!base->push_back_particle(p))
						break;
				}
				break;
			}
			case MAGIC_IMMUNITY:
			{
				angle.normalize(2.5 * vel_scalar);
				mover = new ParticleMover(this);
				for (int i = 0; i < 50 * LOD; i++)
				{
					Vec3 velocity = -angle;
					Vec3 offset;
					offset.randomize(0.4);
					velocity += offset;
					Particle * p = new ImpactParticle(this, mover, center, velocity, 0.35 * size_scalar, 1.0, randcolor(1.0), randcolor(1.0), randcolor(1.0), EC_VOID, LOD, type);
					if (!base->push_back_particle(p))
						break;
				}
				break;
			}
			case POISON:
			{
				angle.normalize(1.0 * vel_scalar);
				mover = new ParticleMover(this);
				for (int i = 0; i < 50 * LOD; i++)
				{
					Vec3 velocity = -angle;
					Vec3 offset;
					offset.randomize(0.7);
					velocity += offset;
					Particle* p;
					if (randfloat() < 0.4)
					{
						p = new ImpactParticle(this, mover, center, velocity, 0.6 * size_scalar, 0.5, 0.2 + randcolor(0.2), 0.5 + randcolor(0.3), 0.2, EC_FLARE, LOD, type);
						p->state = 1;
					}
					else
					{
						p = new ImpactParticle(this, mover, center, velocity, 0.3 * size_scalar, 1.0, randcolor(0.1), 0.2 + randcolor(0.1), 0.2, EC_WATER, LOD, type);
						p->state = 0;
					}
					if (!base->push_back_particle(p))
						break;
				}
				break;
			}
			case BLOOD:
			{
				angle.normalize(0.8 * vel_scalar);
				mover = new SimpleGravityMover(this);
				for (int i = 0; i < 20 * LOD; i++)
				{
					Vec3 velocity = -angle;
					Vec3 offset;
					offset.randomize(0.7);
					//        std::cout << velocity << ", " << angle << ", " << vel_scalar << std::endl;
					velocity += offset;
					velocity.normalize(0.8 * vel_scalar);
					//        std::cout << velocity << std::endl;
					Particle * p = new ImpactParticle(this, mover, center, velocity, square(square(randcoord(0.85))) * size_scalar, 0.5, 0.3 + randcolor(0.7), 0.15 + randcolor(0.1), 0.15 + randcolor(0.1), EC_WATER, LOD, type);
					p->state = 1;
					if (!base->push_back_particle(p))
						break;
				}
				break;
			}
		}
	}
Exemplo n.º 10
0
	bool MissileEffect::idle(const Uint64 usec)
	{

		if (particles.size() == 0)
			return false;

		const interval_t dist = (old_pos - *pos).magnitude();
		const Vec3 direction = (old_pos - *pos).normalize(0.75);

		if (dist < 1E-4)
			return true; // do not add more particles, dist < 0.0001

		for (float step = 0.0; step < dist; step += (0.1 / ((1.0
			+ (float)hitOrMiss) / 1.5)))
		{
			const percent_t percent = step / dist;
			Vec3 randshift;
			randshift.randomize(0.025 * (1.0 + (float)hitOrMiss / 2.0)); // random particle position change
			const Vec3 coords = (old_pos * percent) + (*pos * (1.0 - percent))
				+ randshift;
			Vec3 velocity;
			velocity.randomize(0.0625 * (1.0 + (float)hitOrMiss / 2.0)); // random particle movement
			velocity -= direction; // follow the missile
			Particle* p;
			if (type == MAGIC && randfloat() < 0.25)
			{
				p = new MissileParticle(this, mover, coords, velocity, size / 2 + randfloat (size / 2), 1.0, randcolor(), randcolor(), randcolor(), texture, LOD, type);
				base->push_back_particle(p);
			}
			p
				= new MissileParticle(this, mover, coords, velocity, size / 2 + randfloat (size / 2), alpha / 2 + randfloat(alpha / 2), color[0], color[1], color[2], texture, LOD, type);
			base->push_back_particle(p);
		}

		old_pos = *pos;

		return true;
	}
Exemplo n.º 11
0
	bool BreathEffect::idle(const Uint64 usec)
	{
		if (particles.size() == 0)
			return false;

		if (recall)
			return true;

		const Uint64 cur_time = get_time();
		const Uint64 age = cur_time - born;
		if (age > 1100000)
			return true;

		count += usec;

		while (count > 0)
		{
			count -= count_scalar * (14 - LOD);

			Vec3 coords;
			Vec3 velocity;
			if (type == WIND)
			{
				coords = spawner->get_new_coords() * 2 + *pos;
				velocity.randomize(1.0 * scale);
				velocity += (*target - *pos) * 10.0;
			}
			else
			{
				coords = spawner->get_new_coords() + *pos;
				velocity.randomize(0.5 * scale);
				velocity += (*target - *pos) * 2.0;
			}

			switch (type)
			{
				case FIRE:
				{
					Particle * p = new BreathParticle(this, mover, coords, velocity, 0.5 * size_scalar, 0.6, 0.8 + randcolor(0.2), 0.4 + randcolor(0.4), randcolor(0.4), EC_FLARE, LOD, type);
					if (!base->push_back_particle(p))
						return true;
					break;
				}
				case ICE:
				{
					Particle * p = new BreathParticle(this, mover, coords, velocity, 0.5 * size_scalar, 0.6, randcolor(0.4), 0.4 + randcolor(0.4), 0.8 + randcolor(0.2), EC_CRYSTAL, LOD, type);
					if (!base->push_back_particle(p))
						return true;
					break;
				}
				case POISON:
				{
					Particle * p = new BreathParticle(this, mover, coords, velocity, 0.5 * size_scalar, 0.1, 0.9 + randcolor(0.1), 0.8 + randcolor(0.2), 0.6 + randcolor(0.2), EC_FLARE, LOD, type);
					if (!base->push_back_particle(p))
						return true;
					break;
				}
				case MAGIC:
				{
					Particle * p = new BreathParticle(this, mover, coords, velocity, 0.5 * size_scalar, 0.6, randcolor(1.0), randcolor(1.0), randcolor(1.0), EC_TWINFLARE, LOD, type);
					if (!base->push_back_particle(p))
						return true;
					break;
				}
				case LIGHTNING:
				{
					Particle * p = new BreathParticle(this, mover, coords, velocity, 0.25 * size_scalar, 0.6, 0.9 + randcolor(0.1), 0.85 + randcolor(0.15), 0.8 + randcolor(0.2), EC_FLARE, LOD, type);
					if (!base->push_back_particle(p))
						return true;
					break;
				}
				case WIND:
				{
					Particle * p = new BreathParticle(this, mover, coords, velocity, 0.5 * size_scalar, 0.1, 0.8 + randcolor(0.2), 0.8 + randcolor(0.2), 0.8 + randcolor(0.2), EC_FLARE, LOD, type);
					if (!base->push_back_particle(p))
						return true;
					break;
				}
			}
		}

		return true;
	}
Exemplo n.º 12
0
	BreathEffect::BreathEffect(EyeCandy* _base, bool* _dead, Vec3* _pos,
		Vec3* _target, std::vector<ec::Obstruction*>* _obstructions,
		const BreathType _type, const Uint16 _LOD, const percent_t _scale)
	{
		if (EC_DEBUG)
			std::cout << "BreathEffect (" << this << ") created." << std::endl;
		base = _base;
		dead = _dead;
		pos = _pos;
		target = _target;
		obstructions = _obstructions;
		type = _type;
		LOD = base->last_forced_LOD;
		desired_LOD = _LOD;
		scale = _scale;
		bounds = NULL;
		spawner = NULL;
		mover = NULL;
		count = 0;
		count_scalar = 3000 / LOD;
		size_scalar = scale * std::sqrt(LOD) / sqrt(10.0);

		spawner = new FilledSphereSpawner(scale / 3.0);
		mover = new SmokeMover(this, 10.0);
		while ((int)particles.size() < LOD * 64)
		{
			const Vec3 coords = spawner->get_new_coords() + *pos;
			Vec3 velocity;
			velocity.randomize(0.5);
			velocity += (*target - *pos) * 2.0;
			switch (type)
			{
				case FIRE:
				{
					Particle * p = new BreathParticle(this, mover, coords, velocity, 0.5 * size_scalar, 0.6, 0.8 + randcolor(0.2), 0.4 + randcolor(0.4), randcolor(0.4), EC_FLARE, LOD, type);
					if (!base->push_back_particle(p))
						return;
					break;
				}
				case ICE:
				{
					Particle * p = new BreathParticle(this, mover, coords, velocity, 0.5 * size_scalar, 0.6, randcolor(0.4), 0.4 + randcolor(0.4), 0.8 + randcolor(0.2), EC_CRYSTAL, LOD, type);
					if (!base->push_back_particle(p))
						return;
					break;
				}
				case POISON:
				{
					Particle * p = new BreathParticle(this, mover, coords, velocity, 0.5 * size_scalar, 0.1, randcolor(0.3), 0.8 + randcolor(0.2), randcolor(0.3), EC_WATER, LOD, type);
					if (!base->push_back_particle(p))
						return;
					break;
				}
				case MAGIC:
				{
					Particle * p = new BreathParticle(this, mover, coords, velocity, 0.5 * size_scalar, 0.6, randcolor(1.0), randcolor(1.0), randcolor(1.0), EC_TWINFLARE, LOD, type);
					if (!base->push_back_particle(p))
						return;
					break;
				}
				case LIGHTNING:
				{
					Particle * p = new BreathParticle(this, mover, coords, velocity, 0.25 * size_scalar, 0.6, 0.9 + randcolor(0.1), 0.85 + randcolor(0.15), 0.8 + randcolor(0.2), EC_FLARE, LOD, type);
					if (!base->push_back_particle(p))
						return;
					break;
				}
				case WIND:
				{
					Particle * p = new BreathParticle(this, mover, coords, velocity, 0.5 * size_scalar, 0.6, 0.8 + randcolor(0.2), 0.8 + randcolor(0.2), 0.8 + randcolor(0.2), EC_FLARE, LOD, type);
					if (!base->push_back_particle(p))
						return;
					break;
				}
			}
		}
	}
Exemplo n.º 13
0
	BreathSmokeParticle::BreathSmokeParticle(Effect* _effect,
		ParticleMover* _mover, const Vec3 _pos, const Vec3 _velocity,
		const coord_t _size, const alpha_t _alpha, TextureEnum _texture,
		const Uint16 _LOD, const BreathEffect::BreathType _type) :
		Particle(_effect, _mover, _pos, _velocity)
	{
		texture = _texture;
		type = _type;
		switch (type)
		{
			case BreathEffect::FIRE:
			{
				const color_t color_scale= randcolor(0.1);
				color[0] = randcolor(0.1) + color_scale;
				color[1] = randcolor(0.1) + color_scale;
				color[2] = randcolor(0.1) + color_scale;
				break;
			}
			case BreathEffect::ICE:
			{
				const color_t color_scale= randcolor(0.2);
				color[0] = 0.3 + randcolor(0.1) + color_scale;
				color[1] = 0.3 + randcolor(0.1) + color_scale;
				color[2] = 1.0;
				break;
			}
			case BreathEffect::POISON:
			{
				const color_t color_scale= randcolor(0.1);
				color[0] = randcolor(0.0) + color_scale;
				color[1] = randcolor(0.0) + color_scale;
				color[2] = randcolor(0.0) + color_scale;
				texture = EC_SIMPLE;
				break;
			}
			case BreathEffect::MAGIC:
			{
				color[0] = randcolor(0.35);
				color[1] = randcolor(0.35);
				color[2] = randcolor(0.35);
				break;
			}
			case BreathEffect::LIGHTNING: // Impossible; lightning doesn't use smoke.
			{
				break;
			}
			case BreathEffect::WIND:
			{
				const color_t color_scale= randcolor(0.4);
				color[0] = randcolor(0.1) + color_scale;
				color[1] = randcolor(0.1) + color_scale;
				color[2] = randcolor(0.1) + color_scale;
				break;
			}
		}
		size = _size * (0.5 + randcoord()) * 10 / _LOD;
		alpha = _alpha;
		flare_max = 1.0;
		flare_exp = 1.0;
		flare_frequency = 1.0;
		state = 0;
	}
Exemplo n.º 14
0
int main(int argc, char** argv) {
  width = 12, depth = 8, height = 60;
  xd = (width - 1) / 2.4;
  yd = (depth - 1) / 1.6;
  zd = (height - 1) / 2.0;
  xl = (width - 1) / xd;
  yl = (depth - 1) / yd;
  zl = (height - 1) / zd;
  total_leds = width * depth * height;
  channel = 0;

  fps = 60;
  period_x = xl / (2 * M_PI);
  speed_x = 1.0 / fps;
  period_y = yl / (2 * M_PI);
  speed_y = 0.9 / fps;
  period_z = zl / (2 * M_PI);
  speed_z = 0.8 / fps;

  sphere_r = .3;
  spheres = sqrt(pow(xl/2, 2) + pow(yl/2, 2) + pow(zl/2, 2)) / sphere_r;
  spheres += 2;
  frames_per_layer = fps / 2;
  pixel l_sphere_colors[spheres];
  sphere_colors = l_sphere_colors;
  int i;
  for (i = 0; i < spheres; i++) {
    sphere_colors[i] = randcolor();
  }

  pixel pixels[total_leds + 1];
  opc_sink s;

  if (argc < 2) {
    fprintf(stderr, "Usage: %s <server>[:<port>]\n", argv[0]);
    return 1;
  }

  s = opc_new_sink(argv[1]);

  int64_t frame_index = 0;
  int64_t start = now();
  struct fps_queue fpsq;
  int64_t frames[total_leds];
  fpsq.samples = fps;
  fpsq.pos = 0;
  fpsq.frames = frames;
  while (1) {
    sleep_until(start + 1000000 * frame_index / fps);
    render_frame(pixels, frame_index);
    if (!opc_put_pixels(s, channel, total_leds, pixels)) {
      break;
    }
    record_frame(&fpsq);
    if (fpsq.pos == 0) {
      double cur_fps = (fpsq.samples - 1) / (get_elapsed(&fpsq) / 1000000.0);
      printf("fps: %.2f  (%.2f Mbps)\n",
	     cur_fps, total_leds * 24 * cur_fps / 1000000.0);
    }
    frame_index++;
  }
  printf("fps: %f\n", frame_index / 5.0);
}
Exemplo n.º 15
0
MineEffect::MineEffect(EyeCandy* _base, bool* _dead, Vec3* _pos,
                       const MineType _type, const Uint16 _LOD)
{
    if (EC_DEBUG)
        std::cout << "MineEffect (" << this << ") created (" << type
                  << ")." << std::endl;
    base = _base;
    dead = _dead;
    pos = _pos;
    effect_center = *pos;
    type = _type;
    LOD = base->last_forced_LOD;
    desired_LOD = _LOD;
    spawner = NULL;
    bounds = NULL;
    mover = NULL;
    spawner2 = NULL;
    mover2 = NULL;

    switch (type)
    {
    case DETONATE_MAGIC_IMMUNITY_REMOVAL:
    {
        spawner = new FilledSphereSpawner(0.1);
        mover = new ParticleMover(this);
        while ((int)particles.size() < LOD * 150)
        {
            const Vec3 coords = spawner->get_new_coords()
                                + effect_center;
            Vec3 velocity;
            velocity.randomize(0.5);
            velocity.y = 0.2;
            Particle
            * p =
#ifdef	NEW_TEXTURES
                new MineParticle(this, mover, coords, velocity, 0.2, 1.0, 3.0, 3.0, 3.0, EC_SIMPLE, LOD, type);
#else	/* NEW_TEXTURES */
                new MineParticle(this, mover, coords, velocity, 0.2, 1.0, 3.0, 3.0, 3.0, &(base->TexSimple), LOD, type);
#endif	/* NEW_TEXTURES */
            if (!base->push_back_particle(p))
                break;
        }
        break;
    }
    case DETONATE_UNINVIZIBILIZER:
    {
        effect_center.y += 1.8;
        spawner = new HollowDiscSpawner(0.3);
        mover = new ParticleMover(this);
        while ((int)particles.size() < LOD * 200)
        {
            Vec3 coords = spawner->get_new_coords();
            Vec3 velocity;
            velocity.randomize();
            velocity.normalize(0.2);
            coords += effect_center;
            coords.y = randfloat(1.8);
            Particle
            * p =
#ifdef	NEW_TEXTURES
                new MineParticle(this, mover, coords, velocity, 1.2, 1.0, 3.0, 3.0, 3.0, EC_SIMPLE, LOD, type);
#else	/* NEW_TEXTURES */
                new MineParticle(this, mover, coords, velocity, 1.2, 1.0, 3.0, 3.0, 3.0, &(base->TexSimple), LOD, type);
#endif	/* NEW_TEXTURES */
            if (!base->push_back_particle(p))
                break;
        }
        break;
    }
    case DETONATE_MANA_DRAINER:
    {
        effect_center.y += 1.6;
        spawner = new HollowDiscSpawner(0.3);
        mover = new SimpleGravityMover(this);
        while ((int)particles.size() < LOD * 50)
        {
            const Vec3 coords = spawner->get_new_coords()
                                + effect_center;
            Vec3 velocity;
            velocity.randomize();
            velocity.normalize(0.2);
            Particle
            * p =
#ifdef	NEW_TEXTURES
                new MineParticle(this, mover, coords, velocity, 0.3, 1.0, 0.8, 0.35, 0.7, EC_SIMPLE, LOD, type);
#else	/* NEW_TEXTURES */
                new MineParticle(this, mover, coords, velocity, 0.3, 1.0, 0.8, 0.35, 0.7, &(base->TexSimple), LOD, type);
#endif	/* NEW_TEXTURES */
            if (!base->push_back_particle(p))
                break;
        }
        break;
    }
    case DETONATE_MANA_BURNER:
    {
        effect_center.y += 1.0;
        spawner = new FilledSphereSpawner(0.5);
        mover = new GravityMover(this, &effect_center, 8e9);
        while ((int)particles.size() < LOD * 100)
        {
            const Vec3 coords = spawner->get_new_coords()
                                + effect_center;
            Vec3 velocity;
            velocity.randomize();
            velocity.normalize(0.9);
            Particle
            * p =
#ifdef	NEW_TEXTURES
                new MineParticle(this, mover, coords, velocity, 0.5, 0.5, 0.8, 0.35, 0.7, EC_TWINFLARE, LOD, type);
#else	/* NEW_TEXTURES */
                new MineParticle(this, mover, coords, velocity, 0.5, 0.5, 0.8, 0.35, 0.7, &(base->TexTwinflare), LOD, type);
#endif	/* NEW_TEXTURES */
            if (!base->push_back_particle(p))
                break;
        }
        break;
    }
    case DETONATE_CALTROP:
    case DETONATE_CALTROP_POISON:
    {
        effect_center.y += 0.05;
        mover = new SimpleGravityMover(this);
        spawner = new HollowSphereSpawner(0.1);

        for (int i = 0; i < LOD * 10; i++)
        {
            const Vec3 coords = spawner->get_new_coords()
                                + effect_center;
            const Vec3 velocity(0.0, 5.0, 0.0);
#ifdef	NEW_TEXTURES
            Particle* p = new MineParticle(this, mover, coords, velocity, 0.75, 0.6, 0.4, (type == DETONATE_CALTROP ? 0.3 : 0.5), 0.3, EC_TWINFLARE, LOD, type);
#else	/* NEW_TEXTURES */
            Particle* p = new MineParticle(this, mover, coords, velocity, 0.75, 0.6, 0.4, (type == DETONATE_CALTROP ? 0.3 : 0.5), 0.3, &(base->TexTwinflare), LOD, type);
#endif	/* NEW_TEXTURES */
            p->state = 1;
            if (!base->push_back_particle(p))
                break;
        }

        break;
    }
    case DETONATE_TRAP:
    {
        effect_center.y += 1.25;
        mover = new OrbitalMover(this, effect_center);
        spawner = new HollowSphereSpawner(1.25);
        Particle* p;

        for (int i = 0; i < LOD * 100; i++)
        {
            Vec3 c = effect_center;
            c.y = -0.3 + (i * 0.05);
            Vec3 vel;
            vel.randomize();
            vel.normalize(2.0);
            vel *= randfloat() * 4.0;
#ifdef	NEW_TEXTURES
            p = new MineParticle(this, mover, c, vel, 0.2, 1.0, 1.0, 1.0, 1.0, EC_VOID, LOD, type);
#else	/* NEW_TEXTURES */
            p = new MineParticle(this, mover, c, vel, 0.2, 1.0, 1.0, 1.0, 1.0, &(base->TexVoid), LOD, type);
#endif	/* NEW_TEXTURES */
            if (!base->push_back_particle(p))
                break;

            dynamic_cast<OrbitalMover*>(mover)->setParticleData(p, OrbitalParticleData(i, 10,
                    0.45, 10) );
        }

        break;
    }
    case DETONATE_TYPE1_SMALL:
    case DETONATE_TYPE1_MEDIUM:
    case DETONATE_TYPE1_LARGE:
    {
        spawner = new FilledSphereSpawner(0.1);
        mover = new ParticleMover(this);
        const float scale = (type == DETONATE_TYPE1_SMALL ? 0.75 : type
                             == DETONATE_TYPE1_MEDIUM ? 1.25 : 2.0);
        Vec3 wind;
        wind.randomize();
        wind.normalize(0.25);
        wind.y = 0;
        for (int i = 0; i < LOD * 100 * scale; i++)
        {
            Vec3 coords = spawner->get_new_coords();
            Vec3 velocity = coords * 10.0 * sqrt(scale);
            velocity.y = fabs(velocity.y) * 3.0f;
            coords += effect_center;
            coords.y -= 0.1;
#ifdef	NEW_TEXTURES
            Particle * p = new MineParticleFire(this, mover, coords, velocity, 0.5, 1.0, 1.0, randcolor(0.75), 0.0, EC_FLARE, LOD);
#else	/* NEW_TEXTURES */
            Particle * p = new MineParticleFire(this, mover, coords, velocity, 0.5, 1.0, 1.0, randcolor(0.75), 0.0, &(base->TexFlare), LOD);
#endif	/* NEW_TEXTURES */
            if (!base->push_back_particle(p))
                break;
        }
        spawner = new FilledSphereSpawner(0.5 * std::sqrt(scale));
        for (int i = 0; i < LOD * 32 * scale; i++)
        {
            Vec3 coords = spawner->get_new_coords();
            Vec3 velocity;
            coords += effect_center;
            float grey = randcolor(0.5);
            velocity.randomize();
            velocity.normalize(0.25 * scale);
            velocity.y = fabs(velocity.y) * 6.0f;
            velocity += wind;
#ifdef	NEW_TEXTURES
            Particle *p = new MineParticleSmoke(this, mover, coords, velocity, 3.0 + randcoord(3.0 * scale), 0.0, grey, grey, grey, EC_SIMPLE, LOD);
#else	/* NEW_TEXTURES */
            Particle *p = new MineParticleSmoke(this, mover, coords, velocity, 3.0 + randcoord(3.0 * scale), 0.0, grey, grey, grey, &(base->TexSimple), LOD);
#endif	/* NEW_TEXTURES */
            if (!base->push_back_particle(p))
                break;
        }
        break;
    }
    }
}
Exemplo n.º 16
0
	HarvestingEffect::HarvestingEffect(EyeCandy* _base, bool* _dead,
		Vec3* _pos, const HarvestingType _type, const Uint16 _LOD)
	{
		if (EC_DEBUG)
			std::cout << "HarvestingEffect (" << this << ") created (" << type
				<< ")." << std::endl;
		base = _base;
		dead = _dead;
		pos = _pos;
		effect_center = *pos;
		type = _type;
		LOD = base->last_forced_LOD;
		desired_LOD = _LOD;
		spawner = NULL;
		bounds = NULL;
		mover = NULL;
		spawner2 = NULL;
		mover2 = NULL;
		direction = Vec3(0.0, 0.0, 0.0);

		switch (type)
		{
			case TOOL_BREAK:
			{
				// handled in other constructor
				break;
			}
			case RADON_POUCH:
			{
				effect_center.y += 0.5;
				spawner = new FilledSphereSpawner(0.9);
				mover = new GravityMover(this, &effect_center, 8e9);
				while ((int)particles.size() < LOD * 50)
				{
					const Vec3 coords = spawner->get_new_coords()
						+ effect_center;
					Vec3 velocity;
					velocity.randomize();
					velocity.normalize(0.8);
					Particle * p = new HarvestingParticle(this, mover, coords, velocity, 5.25, 0.5, 0.6, 0.7, 0.2, EC_FLARE, LOD, type);
					p->state = 0;
					if (!base->push_back_particle(p))
						break;
				}
				while ((int)particles.size() < LOD * 100)
				{
					const Vec3 coords = spawner->get_new_coords()
						+ effect_center;
					Vec3 velocity;
					velocity.randomize();
					velocity.normalize(1.5);
					Particle * p = new HarvestingParticle(this, mover, coords, velocity, 4.5, 0.5 + randalpha(0.4), 0.7, 0.6, 0.5, EC_WATER, LOD, type);
					p->state = 1;
					if (!base->push_back_particle(p))
						break;
				}
				break;
			}
			case CAVERN_WALL:
			{
				effect_center.y += 15.0;
				spawner = new FilledSphereSpawner(1.0);
				mover = new ParticleMover(this);
				while ((int)particles.size() < LOD * 50)
				{
					Vec3 coords = spawner->get_new_coords();
					coords.y *= 8.0;
					Vec3 velocity;
					velocity.randomize();
					velocity.normalize(0.2);
					velocity.y *= 3.0;
					velocity.y -= 9.0;
					coords += effect_center;
					const color_t scalar= randcolor(0.4);
					Particle * p = new HarvestingParticle(this, mover, coords, velocity, 8.0 + randcoord(12.0), 1.0, scalar + randcolor(0.1), scalar + randcolor(0.1), scalar + randcolor(0.1), EC_SIMPLE, LOD, type);
					if (!base->push_back_particle(p))
						break;
				}
				while ((int)particles.size() < LOD * 100)
				{
					Vec3 coords = spawner->get_new_coords();
					coords.y *= 8.0;
					Vec3 velocity;
					velocity.randomize();
					velocity.normalize(0.2);
					velocity.y *= 3.0;
					velocity.y -= 9.0;
					coords += effect_center;
					Particle * p = new HarvestingParticle(this, mover, coords, velocity, 3.0 + randcoord(6.0), 0.4 + randalpha(0.4), 0.2 + randcolor(0.2), 0.2 + randcolor(0.2), 0.2 + randcolor(0.2), EC_WATER, LOD, type);
					if (!base->push_back_particle(p))
						break;
				}
				break;
			}
			case MOTHER_NATURE:
			{
				effect_center.y += 0.2;
				spawner = new HollowDiscSpawner(0.1);
				mover = new SpiralMover(this, &effect_center, 18.0, 11.0);
				while ((int)particles.size() < LOD * 100)
				{
					const Vec3 coords = spawner->get_new_coords()
						+ effect_center;
					Vec3 velocity;
					velocity.randomize(0.3);
					velocity.y *= 3;
					velocity.y += 1.4;
					Particle * p = new HarvestingParticle(this, mover, coords, velocity, 3.0, 0.2, 1.0, 0.5 + randcolor(0.5), 0.5, EC_TWINFLARE, LOD, type);
					if (!base->push_back_particle(p))
						break;
				}
				break;
			}
			case QUEEN_OF_NATURE:
			{
				effect_center.y += 0.2;
				spawner = new FilledDiscSpawner(0.5);
				mover = new ParticleMover(this);
				while ((int)particles.size() < LOD * 100)
				{
					Vec3 coords = spawner->get_new_coords() + effect_center;
					coords.y += (coord_t)(randfloat(2.0) * randfloat(2.0) * randfloat(2.0));
					const Vec3 velocity(0.0, 0.0, 0.0);
					Particle * p = new HarvestingParticle(this, mover, coords, velocity, 2.0 + randcoord(1.0), 1.0, randcolor(1.0), randcolor(1.0), randcolor(1.0), EC_SHIMMER, LOD, type);
					if (!base->push_back_particle(p))
						break;
				}
				break;
			}
			case BEES:
			{
				spawner = new FilledSphereSpawner(0.75);
				mover = new GravityMover(this, &effect_center, 8e9);
				direction.randomize();
				direction.y = 0;
				while ((int)particles.size() < LOD * 4)
				{
					const Vec3 coords = spawner->get_new_coords()
						+ effect_center - direction;
					Vec3 velocity;
					velocity.randomize();
					velocity.normalize(0.75);
					velocity.x += randfloat(direction.x);
					velocity.z += randfloat(direction.z);
					Particle * p = new HarvestingParticle(this, mover, coords, velocity, 0.5 + randfloat(0.25), 1.0, 0.9, 0.7, 0.3, EC_TWINFLARE, LOD, type);
					if (!base->push_back_particle(p))
						break;
				}
				break;
			}
			case BAG_OF_GOLD:
			{
				mover = new GravityMover(this, &effect_center, 2e10);
				spawner = new HollowSphereSpawner(0.3);

				for (int i = 0; i < LOD * 60; i++)
				{
					Vec3 coords = spawner->get_new_coords();
					const Vec3 velocity = coords / 10.0;
					coords += effect_center;
					Particle* p = new HarvestingParticle(this, mover, coords, velocity, 1.05, 0.75, randcolor(0.3) + 0.7, randcolor(0.3) + 0.5, randcolor(0.3) + 0.3, EC_FLARE, LOD, type);
					p->state = 1;
					if (!base->push_back_particle(p))
						break;
				}

				Particle* p = new HarvestingParticle(this, mover, effect_center, Vec3(0.0, 0.0, 0.0), 8.0, 1.0, 0.8, 0.7, 0.3, EC_SHIMMER, LOD, type);
				base->push_back_particle(p);
				break;
			}
			case RARE_STONE:
			{
				mover = new ParticleMover(this);
				spawner = new HollowSphereSpawner(0.3);

				for (int i = 0; i < LOD * 60; i++)
				{
					Vec3 coords = spawner->get_new_coords();
					const Vec3 velocity = coords / 10.0;
					coords += effect_center;
					Particle* p = new HarvestingParticle(this, mover, coords, velocity, 0.75, 0.05, randcolor(0.3) + 0.7, randcolor(0.3) + 0.5, randcolor(0.3) + 0.3, EC_FLARE, LOD, type);
					p->state = 1;
					if (!base->push_back_particle(p))
						break;
				}

				Particle* p = new HarvestingParticle(this, mover, effect_center, Vec3(0.0, 0.0, 0.0), 7.5, 1.0, 1.0, 1.0, 1.0, EC_VOID, LOD, type);
				if (!base->push_back_particle(p))
					break;
				p = new HarvestingParticle(this, mover, effect_center, Vec3(0.0, 0.01, 0.0), 7.5, 1.0, 1.0, 1.0, 1.0, EC_VOID, LOD, type);
				base->push_back_particle(p);
				break;
			}
		}
	}