Exemple #1
0
/**
 * @brief Has a pilot attempt to board another pilot.
 * 
 *    @param p Pilot doing the boarding.
 *    @return 1 if target was boarded.
 */
int pilot_board( Pilot *p )
{
   Pilot *target;

   /* Make sure target is sane. */
   target = pilot_get(p->target);
   if (target == NULL) {
      DEBUG("NO TARGET");
      return 0;
   }

   /* Check if can board. */
   if (!pilot_isDisabled(target))
      return 0;
   else if (vect_dist(&p->solid->pos, &target->solid->pos) >
         target->ship->gfx_space->sw * PILOT_SIZE_APROX )
      return 0;
   else if ((pow2(VX(p->solid->vel)-VX(target->solid->vel)) +
            pow2(VY(p->solid->vel)-VY(target->solid->vel))) >
            (double)pow2(MAX_HYPERSPACE_VEL))
      return 0;
   else if (pilot_isFlag(target,PILOT_BOARDED))
      return 0;

   /* Set the boarding flag. */
   pilot_setFlag(target, PILOT_BOARDED);
   pilot_setFlag(p, PILOT_BOARDING);

   /* Set time it takes to board. */
   p->ptimer = 3.;

   return 1;
}
//---------------------------------------------------------
bool NDG3D::StartUp3D()
//---------------------------------------------------------
{
  // Purpose : Setup script, building operators, grid, metric,
  //           and connectivity tables for 3D meshes of tetrahedra.

  // Definition of constants
  Np = (N+1)*(N+2)*(N+3)/6; Nfp = (N+1)*(N+2)/2; Nfaces=4; NODETOL = 1e-7;

  // Compute nodal set
  DVec x1,y1,z1;
  Nodes3D(N, x1,y1,z1);
  xyztorst(x1,y1,z1, r,s,t);

  // Build reference element matrices
  V = Vandermonde3D(N,r,s,t); invV = inv(V);
  MassMatrix = trans(invV)*invV;
  ::Dmatrices3D(N, r, s, t, V, Dr, Ds, Dt);


  // build coordinates of all the nodes
  IVec va = EToV(All,1), vb = EToV(All,2), vc = EToV(All,3), vd = EToV(All,4);
  x = 0.5*(-(1.0+r+s+t)*VX(va) + (1.0+r)*VX(vb) + (1.0+s)*VX(vc) + (1.0+t)*VX(vd));
  y = 0.5*(-(1.0+r+s+t)*VY(va) + (1.0+r)*VY(vb) + (1.0+s)*VY(vc) + (1.0+t)*VY(vd));
  z = 0.5*(-(1.0+r+s+t)*VZ(va) + (1.0+r)*VZ(vb) + (1.0+s)*VZ(vc) + (1.0+t)*VZ(vd));

  // find all the nodes that lie on each edge
  IVec fmask1,fmask2,fmask3,fmask4;
  fmask1 = find( abs(1.0+t),     '<', NODETOL); 
  fmask2 = find( abs(1.0+s),     '<', NODETOL);
  fmask3 = find( abs(1.0+r+s+t), '<', NODETOL);
  fmask4 = find( abs(1.0+r),     '<', NODETOL);
  Fmask.resize(Nfp,4);                          // set shape (M,N) before concat()
  Fmask = concat(fmask1,fmask2,fmask3,fmask4);  // load vector into shaped matrix

  Fx=x(Fmask,All); Fy=y(Fmask,All); Fz=z(Fmask,All);

  // Create surface integral terms
  Lift3D();

  // calculate geometric factors and normals
  Normals3D();
  
  Fscale = sJ.dd(J(Fmask,All));

  // Build connectivity matrix
  tiConnect3D(EToV, EToE, EToF); 

  // Build connectivity maps
  BuildMaps3D();

  // Compute weak operators (could be done in preprocessing to save time)
  DMat Vr,Vs,Vt;  GradVandermonde3D(N, r, s, t, Vr, Vs, Vt);

  VVT = V*trans(V);
  Drw = (V*trans(Vr))/VVT; Dsw = (V*trans(Vs))/VVT; Dtw = (V*trans(Vt))/VVT;

  return true;
}
Exemple #3
0
/**
 * @brief Computes an estimation of ammo flying time
 *
 *    @param w the weapon that shoot
 *    @param parent Parent of the weapon
 *    @param target Target of the weapon
 */
double pilot_weapFlyTime( Outfit *o, Pilot *parent, Vector2d *pos, Vector2d *vel)
{
   Vector2d approach_vector, relative_location, orthoradial_vector;
   double speed, radial_speed, orthoradial_speed, dist, t;

   dist = vect_dist( &parent->solid->pos, pos );

   /* Beam weapons */
   if (outfit_isBeam(o))
      {
      if (dist > o->u.bem.range)
         return INFINITY;
      return 0.;
      }

   /* A bay doesn't have range issues */
   if (outfit_isFighterBay(o))
      return 0.;

   /* Rockets use absolute velocity while bolt use relative vel */
   if (outfit_isLauncher(o))
         vect_cset( &approach_vector, - vel->x, - vel->y );
   else
         vect_cset( &approach_vector, VX(parent->solid->vel) - vel->x,
               VY(parent->solid->vel) - vel->y );

   speed = outfit_speed(o);

   /* Get the vector : shooter -> target */
   vect_cset( &relative_location, pos->x - VX(parent->solid->pos),
         pos->y - VY(parent->solid->pos) );

   /* Get the orthogonal vector */
   vect_cset(&orthoradial_vector, VY(parent->solid->pos) - pos->y,
         pos->x -  VX(parent->solid->pos) );

   radial_speed = vect_dot( &approach_vector, &relative_location );
   radial_speed = radial_speed / VMOD(relative_location);

   orthoradial_speed = vect_dot(&approach_vector, &orthoradial_vector);
   orthoradial_speed = orthoradial_speed / VMOD(relative_location);

   if( ((speed*speed - VMOD(approach_vector)*VMOD(approach_vector)) != 0) && (speed*speed - orthoradial_speed*orthoradial_speed) > 0)
      t = dist * (sqrt( speed*speed - orthoradial_speed*orthoradial_speed ) - radial_speed) /
            (speed*speed - VMOD(approach_vector)*VMOD(approach_vector));
   else
      return INFINITY;

   /* if t < 0, try the other solution */
   if (t < 0)
      t = - dist * (sqrt( speed*speed - orthoradial_speed*orthoradial_speed ) + radial_speed) /
            (speed*speed - VMOD(approach_vector)*VMOD(approach_vector));

   /* if t still < 0, no solution */
   if (t < 0)
      return INFINITY;

   return t;
}
	void operator() (double *X, double *Y) {
		Map<VectorXd> VX(X, this->W->rows());
		Map<VectorXd> VY(Y, this->W->rows());
		VectorXd XmWX = VX - (*this->W) * VX;
		
		VY = XmWX - this->W->transpose() * XmWX;
	}
Exemple #5
0
void AddThing(short x, short y, short type)
{
	if (type != 1) return; //!!!!
	type = ENT_PLAYERSTART;

	short z = the_world->Loc(x, y).floor_h*4 + 1;

	lev_ents.push_back(new entity_c(VX(x,2), VY(y,2), z, type));
}
Exemple #6
0
/**
 * @brief Weapon hit the pilot.
 *
 *    @param w Weapon involved in the collision.
 *    @param p Pilot that got hit.
 *    @param layer Layer to which the weapon belongs.
 *    @param pos Position of the hit.
 *    @param dt Current delta tick.
 */
static void weapon_hitBeam( Weapon* w, Pilot* p, WeaponLayer layer,
      Vector2d pos[2], const double dt )
{
   (void) layer;
   Pilot *parent;
   int spfx;
   double damage;
   DamageType dtype;
   WeaponLayer spfx_layer;

   /* Get general details. */
   parent = pilot_get(w->parent);
   damage = outfit_damage(w->outfit) * dt;
   dtype  = outfit_damageType(w->outfit);

   /* Have pilot take damage and get real damage done. */
   damage = pilot_hit( p, w->solid, w->parent, dtype, damage );

   /* Add sprite, layer depends on whether player shot or not. */
   if (w->lockon == -1.) {
      /* Get the layer. */
      spfx_layer = (p==player) ? SPFX_LAYER_FRONT : SPFX_LAYER_BACK;

      /* Choose spfx. */
      if (p->shield > 0.)
         spfx = outfit_spfxShield(w->outfit);
      else
         spfx = outfit_spfxArmour(w->outfit);

      /* Add graphic. */
      spfx_add( spfx, pos[0].x, pos[0].y,
            VX(p->solid->vel), VY(p->solid->vel), spfx_layer );
      spfx_add( spfx, pos[1].x, pos[1].y,
            VX(p->solid->vel), VY(p->solid->vel), spfx_layer );
         w->lockon = -2;
   }

   /* Inform AI that it's been hit. */
   weapon_hitAI( p, parent, damage );
}
Exemple #7
0
/**
 * @brief Renders the entire spfx layer.
 *
 *    @param layer Layer to render.
 */
void spfx_render( const int layer )
{
   SPFX *spfx_stack;
   int i, spfx_nstack;
   SPFX_Base *effect;
   int sx, sy;
   double time;

   
   /* get the appropriate layer */
   switch (layer) {
      case SPFX_LAYER_FRONT:
         spfx_stack = spfx_stack_front;
         spfx_nstack = spfx_nstack_front;
         break;

      case SPFX_LAYER_BACK:
         spfx_stack = spfx_stack_back;
         spfx_nstack = spfx_nstack_back;
         break;

      default:
         WARN("Rendering invalid SPFX layer.");
         return;
   }

   /* Now render the layer */
   for (i=spfx_nstack-1; i>=0; i--) {
      effect = &spfx_effects[ spfx_stack[i].effect ];

      /* Simplifies */
      sx = (int)effect->gfx->sx;
      sy = (int)effect->gfx->sy;

      if (!paused) { /* don't calculate frame if paused */
         time = fmod(spfx_stack[i].timer,effect->anim) / effect->anim;
         spfx_stack[i].lastframe = sx * sy * MIN(time, 1.);
      }
      
      /* Renders */
      gl_blitSprite( effect->gfx, 
            VX(spfx_stack[i].pos), VY(spfx_stack[i].pos),
            spfx_stack[i].lastframe % sx,
            spfx_stack[i].lastframe / sx,
            NULL );
   }
}
Exemple #8
0
	FOR_LOC(x, y, loc)
    {
        if (loc.Void())
            continue;

		if (RandomPerc(90))
			continue;

		short z = the_world->Loc(x, y).ceil_h*4 - 2;

		lev_ents.push_back(new entity_c(VX(x,2), VY(y,2), z, ENT_LIGHT));

		entity_c *E = lev_ents[lev_ents.size()-1];

		E->attrs[0] = RandomRange(4,16);
		E->attrs[1] = RandomRange(25,255);
    }}
Exemple #9
0
ObjExplosion::ObjExplosion(const Point3d& pos, const Point3d& vel):
	Drawable3D(std::string("explosion"), pos, vel),
	sparkles()
{
		for(int i =0;i != 100;i ++){
			double vx = VX() +rand()%1000/(double)1-50;
			double vy = VY()+ rand()%1000/(double)1-50;
			double vz = VZ()+ rand()%1000/(double)1-50;
			std::cout << pos.z << std::endl;

			sparkles.push_back(
				Sparkle(pos, Point3d(vx,vy,vz))
			);
			
		}
	
}
Exemple #10
0
Fichier : spfx.c Projet : zid/naev
/**
 * @brief Updates an individual spfx.
 *
 *    @param layer Layer the spfx is on.
 *    @param nlayer Pointer to the assosciated nlayer.
 *    @param dt Current delta tick.
 */
static void spfx_update_layer( SPFX *layer, int *nlayer, const double dt )
{
   int i;

   for (i=0; i<*nlayer; i++) {
      layer[i].timer -= dt; /* less time to live */

      /* time to die! */
      if (layer[i].timer < 0.) {
         spfx_destroy( layer, nlayer, i );
         i--;
         continue;
      }

      /* actually update it */
      vect_cadd( &layer[i].pos, dt*VX(layer[i].vel), dt*VY(layer[i].vel) );
   }
}
Exemple #11
0
/**
 * @brief Weapon hit the pilot.
 *
 *    @param w Weapon involved in the collision.
 *    @param p Pilot that got hit.
 *    @param layer Layer to which the weapon belongs.
 *    @param pos Position of the hit.
 */
static void weapon_hit( Weapon* w, Pilot* p, WeaponLayer layer, Vector2d* pos )
{
   Pilot *parent;
   int spfx;
   double damage;
   DamageType dtype;
   WeaponLayer spfx_layer;
   int s;

   /* Get general details. */
   parent = pilot_get(w->parent);
   damage = w->strength * outfit_damage(w->outfit);
   dtype  = outfit_damageType(w->outfit);

   /* Play sound if they have it. */
   s = outfit_soundHit(w->outfit);
   if (s != -1)
      w->voice = sound_playPos( s,
            w->solid->pos.x,
            w->solid->pos.y,
            w->solid->vel.x,
            w->solid->vel.y);

   /* Have pilot take damage and get real damage done. */
   damage = pilot_hit( p, w->solid, w->parent, dtype, damage );

   /* Get the layer. */
   spfx_layer = (p==player) ? SPFX_LAYER_FRONT : SPFX_LAYER_BACK;
   /* Choose spfx. */
   if (p->shield > 0.)
      spfx = outfit_spfxShield(w->outfit);
   else
      spfx = outfit_spfxArmour(w->outfit);
   /* Add sprite, layer depends on whether player shot or not. */
   spfx_add( spfx, pos->x, pos->y,
         VX(p->solid->vel), VY(p->solid->vel), spfx_layer );

   /* Inform AI that it's been hit. */
   weapon_hitAI( p, parent, damage );

   /* no need for the weapon particle anymore */
   weapon_destroy(w,layer);
}
Exemple #12
0
void Obj3DDrawable::update(Uint32 ticks){
//todo

// 	setPosition(getPosition((double)ticks/10*getVelocity() ));

	setPosition(
		Point3d(X()+VX()/1000*ticks, Y()+VY()/1000*ticks, Z()+VZ()/1000*ticks )
	);

///	std::cout << Z() << std::endl;
//	std::cout << VZ()<< std::endl;
//

	ticks = ticks;//delete this line

	projectedLines.clear();
	for(std::vector<Line3d>::iterator i = lines.begin();i != lines.end();i ++){
		projectedLines. push_back(Viewpoint::getInstance().lookAtLine3D(*i));
	}

}
//---------------------------------------------------------
void NDG2D::MakeCylinder2D
(
  const IMat& faces, 
  double ra,
  double xo,
  double yo
)
//---------------------------------------------------------
{
  // Function: MakeCylinder2D(faces, ra, xo, yo)
  // Purpose:  Use Gordon-Hall blending with an isoparametric  
  //           map to modify a list of faces so they conform 
  //           to a cylinder of radius r centered at (xo,yo)

  int NCurveFaces = faces.num_rows();
  IVec vflag(VX.size()); IMat VFlag(EToV.num_rows(),EToV.num_cols());
  int n=0,k=0,f=0,v1=0,v2=0;
  double theta1=0.0,theta2=0.0,x1=0.0,x2=0.0,y1=0.0,y2=0.0;
  double newx1=0.0,newx2=0.0,newy1=0.0,newy2=0.0;
  DVec vr, fr, theta, fdx,fdy, vdx, vdy, blend,numer,denom;
  IVec va,vb,vc, ks, Fm_f, ids;  DMat Vface, Vvol;

  for (n=1; n<=NCurveFaces; ++n)
  {
    // move vertices of faces to be curved onto circle
    k = faces(n,1); f = faces(n,2);
    v1 = EToV(k, f); v2 = EToV(k, umMOD(f,Nfaces)+1);
    theta1 = atan2(VY(v1),VX(v1)); theta2 = atan2(VY(v2),VX(v2));
    newx1 = xo + ra*cos(theta1); newy1 = yo + ra*sin(theta1);
    newx2 = xo + ra*cos(theta2); newy2 = yo + ra*sin(theta2);
    
    // update mesh vertex locations
    VX(v1) = newx1; VX(v2) = newx2; VY(v1) = newy1; VY(v2) = newy2; 

    // store modified vertex numbers
    vflag(v1) = 1;  vflag(v2) = 1;
  }

  // map modified vertex flag to each element
//vflag = vflag(EToV);
  VFlag.resize(EToV);
  VFlag.set_map(EToV, vflag); // (map, values)

  // locate elements with at least one modified vertex
//ks = find(sum(vflag,2)>0);
  ks = find(VFlag.row_sums(), '>', 0);

  // build coordinates of all the corrected nodes
  IMat VA=EToV(ks,1), VB=EToV(ks,2), VC=EToV(ks,3);

  // FIXME: loading 2D mapped data into 1D vectors
  int Nr=VA.num_rows(); 
  va.copy(Nr,VA.data());
  vb.copy(Nr,VB.data());
  vc.copy(Nr,VC.data());

  // Note: outer products of (Vector,MappedRegion1D)
  x(All,ks) = 0.5*(-(r+s)*VX(va)+(1.0+r)*VX(vb)+(1.0+s)*VX(vc));
  y(All,ks) = 0.5*(-(r+s)*VY(va)+(1.0+r)*VY(vb)+(1.0+s)*VY(vc));

  // deform specified faces
  for (n=1; n<=NCurveFaces; ++n)
  {
    k = faces(n,1); f = faces(n,2);

    // find vertex locations for this face and tangential coordinate
    if      (f==1) { v1=EToV(k,1); v2=EToV(k,2); vr=r; }
    else if (f==2) { v1=EToV(k,2); v2=EToV(k,3); vr=s; }
    else if (f==3) { v1=EToV(k,1); v2=EToV(k,3); vr=s; }

    fr = vr(Fmask(All,f));
    x1 = VX(v1); y1 = VY(v1); x2 = VX(v2); y2 = VY(v2);

    // move vertices at end points of this face to the cylinder
    theta1 = atan2(y1-yo, x1-xo); theta2 = atan2(y2-yo, x2-xo);

    // check to make sure they are in the same quadrant
    if ((theta2 > 0.0) && (theta1 < 0.0)) { theta1 += 2*pi; }
    if ((theta1 > 0.0) && (theta2 < 0.0)) { theta2 += 2*pi; }

    // distribute N+1 nodes by arc-length along edge
    theta = 0.5*theta1*(1.0-fr) + 0.5*theta2*(1.0+fr);

    // evaluate deformation of coordinates
    fdx = xo + ra*apply(cos,theta) - x(Fmask(All,f),k); 
    fdy = yo + ra*apply(sin,theta) - y(Fmask(All,f),k);

    // build 1D Vandermonde matrix for face nodes and volume nodes
    Vface = Vandermonde1D(N, fr); Vvol = Vandermonde1D(N, vr);

    // compute unblended volume deformations 
    vdx = Vvol * (Vface|fdx); vdy = Vvol * (Vface|fdy);

    // blend deformation and increment node coordinates
    ids = find(abs(1.0-vr), '>', 1e-7); // warp and blend

    denom = 1.0-vr(ids);
    if      (1==f) { numer = -(r(ids)+s(ids));  }
    else if (2==f) { numer =  (r(ids)+1.0   );  }
    else if (3==f) { numer = -(r(ids)+s(ids));  }
    blend = numer.dd(denom);

    x(ids,k) += (blend.dm(vdx(ids)));
    y(ids,k) += (blend.dm(vdy(ids)));
  }

  // repair other coordinate dependent information
  Fx = x(Fmask, All); Fy = y(Fmask, All);
  ::GeometricFactors2D(x,y,Dr,Ds,  rx,sx,ry,sy,J);
  Normals2D(); Fscale = sJ.dd(J(Fmask,All));
}
//---------------------------------------------------------
DMat& NDG2D::ConformingHrefine2D(IMat& edgerefineflag, const DMat& Qin)
//---------------------------------------------------------
{
#if (0)
  OutputNodes(false); // volume nodes
//OutputNodes(true);  // face nodes
#endif


  // function newQ = ConformingHrefine2D(edgerefineflag, Q)
  // Purpose: apply edge splits as requested by edgerefineflag

  IVec v1("v1"), v2("v2"), v3("v3"), tvi;
  DVec x1("x1"), x2("x2"), x3("x3"), y1("y1"), y2("y2"), y3("y3");
  DVec a1("a1"), a2("a2"), a3("a3");

  // count vertices
  assert (VX.size() == Nv);

  // find vertex triplets for elements to be refined
  v1 = EToV(All,1);  v2 = EToV(All,2);  v3 = EToV(All,3);
  x1 = VX(v1);       x2 = VX(v2);       x3 = VX(v3);
  y1 = VY(v1);       y2 = VY(v2);       y3 = VY(v3);

  // find angles at each element vertex (in radians)
  VertexAngles(x1,x2,x3,y1,y2,y3, a1,a2,a3);

  // absolute value of angle size
  a1.set_abs(); a2.set_abs(); a3.set_abs();

  int k=0,k1=0,f1=0,k2=0,f2=0, e1=0,e2=0,e3=0, b1=0,b2=0,b3=0, ref=0;
  IVec m1,m2,m3; DVec mx1, my1, mx2, my2, mx3, my3;

  // create new vertices at edge centers of marked elements 
  // (use unique numbering derived from unique edge number))
  m1 = max(IVec(Nv*(v1-1)+v2+1), IVec(Nv*(v2-1)+v1+1)); mx1=0.5*(x1+x2); my1=0.5*(y1+y2);
  m2 = max(IVec(Nv*(v2-1)+v3+1), IVec(Nv*(v3-1)+v2+1)); mx2=0.5*(x2+x3); my2=0.5*(y2+y3);
  m3 = max(IVec(Nv*(v1-1)+v3+1), IVec(Nv*(v3-1)+v1+1)); mx3=0.5*(x3+x1); my3=0.5*(y3+y1);

  // ensure that both elements sharing an edge are split
  for (k1=1; k1<=K; ++k1) {
    for (f1=1; f1<=Nfaces; ++f1) {
      if (edgerefineflag(k1,f1)) {
        k2 = EToE(k1,f1); 
        f2 = EToF(k1,f1);
        edgerefineflag(k2,f2) = 1;
      }
    }
  }

  // store old data
  IMat oldEToV = EToV;  DVec oldVX = VX, oldVY = VY; 

  // count the number of elements in the refined mesh
  int newK = countrefinefaces(edgerefineflag);
  EToV.resize(newK, Nfaces, true, 0);
  IMat newBCType(newK,3, "newBCType");
  
  //   kold = [];
  IVec kold(newK, "kold");  Index1D KI,KIo;

  int sk=1, skstart=0, skend=0;

  for (k=1; k<=K; ++k)
  {
    skstart = sk;

    e1 = edgerefineflag(k,1); b1 = BCType(k,1);
    e2 = edgerefineflag(k,2); b2 = BCType(k,2);
    e3 = edgerefineflag(k,3); b3 = BCType(k,3);
    ref = e1 + 2*e2 + 4*e3;
    
    switch (ref) {

    case 0: 
      EToV(sk, All) = IVec(v1(k),v2(k),v3(k));    newBCType(sk,All) = IVec(b1, b2, b3); ++sk;
      break;

    case 1:
      EToV(sk, All) = IVec(v1(k),m1(k),v3(k));    newBCType(sk,All) = IVec(b1,  0, b3); ++sk;
      EToV(sk, All) = IVec(m1(k),v2(k),v3(k));    newBCType(sk,All) = IVec(b1, b2,  0); ++sk;
      break;

    case 2:
      EToV(sk, All) = IVec(v2(k),m2(k),v1(k));    newBCType(sk,All) = IVec(b2,  0, b1); ++sk;
      EToV(sk, All) = IVec(m2(k),v3(k),v1(k));    newBCType(sk,All) = IVec(b2, b3,  0); ++sk;
      break;

    case 4:
      EToV(sk, All) = IVec(v3(k),m3(k),v2(k));    newBCType(sk,All) = IVec(b3,  0, b2); ++sk;
      EToV(sk, All) = IVec(m3(k),v1(k),v2(k));    newBCType(sk,All) = IVec(b3, b1,  0); ++sk;
      break;

    case 3:
      EToV(sk, All) = IVec(m1(k),v2(k),m2(k));    newBCType(sk,All) = IVec(b1, b2,  0); ++sk;
      if (a1(k) > a3(k)) { // split largest angle
        EToV(sk, All) = IVec(v1(k),m1(k),m2(k));  newBCType(sk,All) = IVec(b1,  0,  0); ++sk;
        EToV(sk, All) = IVec(v1(k),m2(k),v3(k));  newBCType(sk,All) = IVec( 0, b2, b3); ++sk;
      } else {
        EToV(sk, All) = IVec(v3(k),m1(k),m2(k));  newBCType(sk,All) = IVec( 0,  0, b2); ++sk;
        EToV(sk, All) = IVec(v3(k),v1(k),m1(k));  newBCType(sk,All) = IVec(b3, b1,  0); ++sk;
      }
      break;

    case 5:
      EToV(sk, All) = IVec(v1(k),m1(k),m3(k));    newBCType(sk,All) = IVec(b1,  0, b3); ++sk;
      if (a2(k) > a3(k)) { 
        // split largest angle
        EToV(sk, All) = IVec(v2(k),m3(k),m1(k));  newBCType(sk,All) = IVec( 0,  0, b1); ++sk;
        EToV(sk, All) = IVec(v2(k),v3(k),m3(k));  newBCType(sk,All) = IVec(b2, b3,  0); ++sk;
      } else {
        EToV(sk, All) = IVec(v3(k),m3(k),m1(k));  newBCType(sk,All) = IVec(b3,  0,  0); ++sk;
        EToV(sk, All) = IVec(v3(k),m1(k),v2(k));  newBCType(sk,All) = IVec( 0, b1, b2); ++sk;
      }
      break;

    case 6:
      EToV(sk, All) = IVec(v3(k),m3(k),m2(k));    newBCType(sk,All) = IVec(b3,  0, b2); ++sk;
      if (a1(k) > a2(k)) { 
        // split largest angle
        EToV(sk, All) = IVec(v1(k),m2(k),m3(k));  newBCType(sk,All) = IVec( 0, 0, b3); ++sk;
        EToV(sk, All) = IVec(v1(k),v2(k),m2(k));  newBCType(sk,All) = IVec(b1, b2,  0); ++sk;
      } else {
        EToV(sk, All) = IVec(v2(k),m2(k),m3(k));  newBCType(sk,All) = IVec(b2,  0,  0); ++sk;
        EToV(sk, All) = IVec(v2(k),m3(k),v1(k));  newBCType(sk,All) = IVec( 0 , b3, b1); ++sk;
      }
      break;

    default:
      // split all 
      EToV(sk, All) = IVec(m1(k),m2(k),m3(k)); newBCType(sk, All) = IVec( 0, 0,  0); ++sk;
      EToV(sk, All) = IVec(v1(k),m1(k),m3(k)); newBCType(sk, All) = IVec(b1, 0, b3); ++sk;
      EToV(sk, All) = IVec(v2(k),m2(k),m1(k)); newBCType(sk, All) = IVec(b2, 0, b1); ++sk;
      EToV(sk, All) = IVec(v3(k),m3(k),m2(k)); newBCType(sk, All) = IVec(b3, 0, b2); ++sk;
      break;
    }
    
    skend = sk;

    // kold = [kold; k*ones(skend-skstart, 1)];

    // element k is to be refined into (1:4) child elements.
    // store parent element numbers in array "kold" to help 
    // with accessing parent vertex data during refinement.

    KI.reset(skstart, skend-1); // ids of child elements
    kold(KI) = k;               // mark as children of element k
  }

  // Finished with edgerefineflag.  Delete if OBJ_temp
  if (edgerefineflag.get_mode() == OBJ_temp) { 
    delete (&edgerefineflag); 
  }


  // renumber new nodes contiguously
  // ids = unique([v1;v2;v3;m1;m2;m3]);
  bool unique=true; IVec IDS, ids;
  IDS = concat( concat(v1,v2,v3), concat(m1,m2,m3) );
  ids = sort(IDS, unique);
  Nv = ids.size();

  int max_id = EToV.max_val();
  umMSG(1, "max id in EToV is %d\n", max_id);

  //         M     N   nnz vals triplet
  CSi newids(max_id,1, Nv,  1,    1  );
  //  newids = sparse(max(max(EToV)),1);

  int i=0, j=1;
  for (i=1; i<=Nv; ++i) {
  //     newids(ids)= (1:Nv);
    newids.set1(ids(i),j, i);   // load 1-based triplets
  }          // row   col x
  newids.compress();            // convert to csc form


  // Matlab -----------------------------------------------
  // v1 = newids(v1); v2 = newids(v2); v3 = newids(v3);
  // m1 = newids(m1); m2 = newids(m2); m3 = newids(m3);
  //-------------------------------------------------------

  int KVi=v1.size(), KMi=m1.size();
  // read from copies, overwrite originals 
  
  // 1. reload ids for new vertices
  tvi = v1;  for (i=1;i<=KVi;++i) {v1(i) = newids(tvi(i), 1);}
  tvi = v2;  for (i=1;i<=KVi;++i) {v2(i) = newids(tvi(i), 1);}
  tvi = v3;  for (i=1;i<=KVi;++i) {v3(i) = newids(tvi(i), 1);}

  // 2. load ids for new (midpoint) vertices
  tvi = m1;  for (i=1;i<=KMi;++i) {m1(i) = newids(tvi(i), 1);}
  tvi = m2;  for (i=1;i<=KMi;++i) {m2(i) = newids(tvi(i), 1);}
  tvi = m3;  for (i=1;i<=KMi;++i) {m3(i) = newids(tvi(i), 1);}

  VX.resize(Nv); VY.resize(Nv);
  VX(v1) =  x1; VX(v2) =  x2; VX(v3) =  x3;
  VY(v1) =  y1; VY(v2) =  y2; VY(v3) =  y3;
  VX(m1) = mx1; VX(m2) = mx2; VX(m3) = mx3;
  VY(m1) = my1; VY(m2) = my2; VY(m3) = my3;


  if (newK != (sk-1)) {
    umERROR("NDG2D::ConformingHrefine2D", "Inconsistent element count: expect %d, but sk = %d", newK, (sk-1));
  } else {
    K = newK; // sk-1;
  }

  // dumpIMat(EToV, "EToV (before)");

  // EToV = newids(EToV);
  for (j=1; j<=3; ++j) {
    for (k=1; k<=K; ++k) {
      EToV(k,j) = newids(EToV(k,j), 1);
    }
  }

#if (0)
  dumpIMat(EToV, "EToV (after)");
  // umERROR("Checking ids", "Nigel, check EToV");
#endif


  BCType = newBCType;

  Nv = VX.size();
  // xold = x; yold = y;

  StartUp2D();


#if (1)
  OutputNodes(false); // volume nodes
//OutputNodes(true);  // face nodes
//umERROR("Exiting early", "Check adapted {volume,face} nodes");
#endif


  // allocate return object
  int Nfields = Qin.num_cols();
  DMat* tmpQ = new DMat(Np*K, Nfields, "newQ", OBJ_temp);
  DMat& newQ = *tmpQ;  // use a reference for syntax

  // quick return, if no interpolation is required
  if (Qin.size()<1) {
    return newQ;
  }

  
  DVec rOUT(Np),sOUT(Np),xout,yout,xy1(2),xy2(2),xy3(2),tmp(2),rhs;
  int ko=0,kv1=0,kv2=0,kv3=0,n=0;  DMat A(2,2), interp;
  DMat oldQ = const_cast<DMat&>(Qin);

  for (k=1; k<=K; ++k)
  {
    ko = kold(k); xout = x(All,k); yout = y(All,k);
    kv1=oldEToV(ko,1); kv2=oldEToV(ko,2); kv3=oldEToV(ko,3);
    xy1.set(oldVX(kv1), oldVY(kv1));
    xy2.set(oldVX(kv2), oldVY(kv2));
    xy3.set(oldVX(kv3), oldVY(kv3));
    A.set_col(1, xy2-xy1); A.set_col(2, xy3-xy1);
    
    for (i=1; i<=Np; ++i) {
      tmp.set(xout(i), yout(i));
      rhs = 2.0*tmp - xy2 - xy3;
      tmp = A|rhs;
      rOUT(i) = tmp(1);
      sOUT(i) = tmp(2);
    }

    KI.reset (Np*(k -1)+1, Np*k );  // nodes in new element k
    KIo.reset(Np*(ko-1)+1, Np*ko);  // nodes in old element ko

    interp = Vandermonde2D(N, rOUT, sOUT)*invV;

    for (n=1; n<=Nfields; ++n) 
    {
    //newQ(:,k,n)= interp*  Q(:,ko,n);
      //DVec tm1 = interp*oldQ(KIo,n);
      //dumpDVec(tm1, "tm1");
      newQ(KI,n) = interp*oldQ(KIo,n);
    }
  }
    
  return newQ;
}
Exemple #15
0
/**
 * @brief Docks the pilot on its target pilot.
 *
 *    @param p Pilot that wants to dock.
 *    @param target Pilot to dock on.
 *    @param deployed Was pilot already deployed?
 *    @return 0 on successful docking.
 */
int pilot_dock( Pilot *p, Pilot *target, int deployed )
{
   int i;
   Outfit *o = NULL;

   /* Must be close. */
   if (vect_dist(&p->solid->pos, &target->solid->pos) >
         target->ship->gfx_space->sw * PILOT_SIZE_APROX )
      return -1;

   /* Cannot be going much faster. */
   if ((pow2(VX(p->solid->vel)-VX(target->solid->vel)) +
            pow2(VY(p->solid->vel)-VY(target->solid->vel))) >
         (double)pow2(MAX_HYPERSPACE_VEL))
      return -1;

   /* Check to see if target has an available bay. */
   for (i=0; i<target->noutfits; i++) {

      /* Must have outfit. */
      if (target->outfits[i]->outfit == NULL)
         continue;

      /* Must be fighter bay. */
      if (!outfit_isFighterBay(target->outfits[i]->outfit))
         continue;

      /* Must have deployed. */
      if (deployed && (target->outfits[i]->u.ammo.deployed <= 0))
         continue;

      o = outfit_ammo(target->outfits[i]->outfit);

      /* Try to add fighter. */
      if (outfit_isFighter(o) &&
            (strcmp(p->ship->name,o->u.fig.ship)==0)) {
         if (deployed)
            target->outfits[i]->u.ammo.deployed -= 1;
         break;
      }
   }
   if ((o==NULL) || (i >= target->noutfits))
      return -1;

   /* Add the pilot's outfit. */
   if (pilot_addAmmo(target, target->outfits[i], o, 1) != 1)
      return -1;

   /* Remove from pilot's escort list. */
   if (deployed) {
      for (i=0; i<target->nescorts; i++) {
         if ((target->escorts[i].type == ESCORT_TYPE_BAY) &&
               (target->escorts[i].id == p->id))
            break;
      }
      /* Not found as pilot's escorts. */
      if (i >= target->nescorts)
         return -1;
      /* Free if last pilot. */
      if (target->nescorts == 1) {
         free(target->escorts);
         target->escorts   = NULL;
         target->nescorts  = 0;
      }
      else {
         memmove( &target->escorts[i], &target->escorts[i+1],
               sizeof(Escort_t) * (target->nescorts-i-1) );
         target->nescorts--;
      }
   }

   /* Destroy the pilot. */
   pilot_delete(p);

   return 0;
}
void Block3DDrawable::update(Uint32 ticks){

//	turningRight = true;
	//	accelerating = true;	
//	double currentSpeed= sqrt(VX()*VX()+VY()*VY() + VZ()*VZ());	

	//	std::cout << currentSpeed << std::endl;
	//accelerating
/*	if(accelerating && currentSpeed < topSpeed){
		VX(VX()+VX()*acceleration*(VX()/currentSpeed)*ticks/1000);
		VY(VY()+VY()*acceleration*(VY()/currentSpeed)*ticks/1000);
		VZ(VZ()+VZ()*acceleration*(VZ()/currentSpeed)*ticks/1000);
	}
*/
	//not accelerating
/*	if(!accelerating && currentSpeed >0){
		if(VX()> VX()*acceleration*(VX()/currentSpeed)*ticks/1000){
			VX(VX()-VX()*acceleration*(VX()/currentSpeed)*ticks/1000);
		}else{
			VX(0);
		}
		if(VY()> VY()*acceleration*(VY()/currentSpeed)*ticks/1000){
			VY(VY()-VY()*acceleration*(VY()/currentSpeed)*ticks/1000);
		}else{
			VY(0);
		}
		if(VZ()> VZ()*acceleration*(VZ()/currentSpeed)*ticks/1000){
			VZ(VZ()-VZ()*acceleration*(VZ()/currentSpeed)*ticks/1000);
		}else{
			VZ(0);
		}
	}*/
/*
	//turning right
	if(turningRight){
	
//		std::cout << "turning" << std::endl;
		VZ(VZ()- VX()*0.1);
		VX(VX()+ VZ()*0.1);
	}

	if(turningLeft){
//		std::cout << "turning" << std::endl;
		VZ(VZ()+ VX()*0.1);
		VX(VX()- VZ()*0.1);


	}

	//turning left
*/
	updateLinesPosition();

	Obj3DDrawable::update(ticks);

//	turningRight = false;
//	turningLeft = false;
	accelerating = false;
	VX(0);
	VY(0);
	VZ(0);
}
Exemple #17
0
int execute_opcode(s_emu *emu, uint16_t op) {
    //printf("Current opcode: %X\n", op);
    switch (op & 0xF000) {
    case 0x0000: {
        switch (op & 0x00FF) {
        case 0x00E0:
            return _00E0(emu, op);
        case 0x00EE:
            return _00EE(emu, op);
        case 0x00FB:
            return _00FB(emu, op);
        case 0x00FC:
            return _00FC(emu, op);
        case 0x00FD:
            return _00FD(emu, op);
        case 0x00FE:
            return _00FE(emu, op);
        case 0x00FF:
            return _00FF(emu, op);
        default:
            if (VY(op) == 0x00C0)
                return _00CN(emu, op);
            else
                break;
        }
    }
    case 0x1000:
        return _1NNN(emu, op);
    case 0x2000:
        return _2NNN(emu, op);
    case 0x3000:
        return _3XKK(emu, op);
    case 0x4000:
        return _4XKK(emu, op);
    case 0x5000:
        return _5XY0(emu, op);
    case 0x6000:
        return _6XKK(emu, op);
    case 0x7000:
        return _7XKK(emu, op);
    case 0x8000: {
        switch (op & 0xF00F) {
        case 0x8000:
            return _8XY0(emu, op);
        case 0x8001:
            return _8XY1(emu, op);
        case 0x8002:
            return _8XY2(emu, op);
        case 0x8003:
            return _8XY3(emu, op);
        case 0x8004:
            return _8XY4(emu, op);
        case 0x8005:
            return _8XY5(emu, op);
        case 0x8006:
            return _8XY6(emu, op);
        case 0x8007:
            return _8XY7(emu, op);
        case 0x800E:
            return _8XYE(emu, op);
        }
    }
    case 0x9000:
        return _9XY0(emu, op);
    case 0xA000:
        return _ANNN(emu, op);
    case 0xB000:
        return _BNNN(emu, op);
    case 0xC000:
        return _CXKK(emu, op);
    case 0xD000:
        return _DXYN(emu, op);
    case 0xE000: {
        switch (op & 0xF0FF) {
        case 0xE09E:
            return _EX9E(emu, op);
        case 0xE0A1:
            return _EXA1(emu, op);
        }
    }
    case 0xF000:
        switch (op & 0xF0FF) {
        case 0xF007:
            return _FX07(emu, op);
        case 0xF00A:
            return _FX0A(emu, op);
        case 0xF015:
            return _FX15(emu, op);
        case 0xF018:
            return _FX18(emu, op);
        case 0xF01E:
            return _FX1E(emu, op);
        case 0xF029:
            return _FX29(emu, op);
        case 0xF033:
            return _FX33(emu, op);
        case 0xF055:
            return _FX55(emu, op);
        case 0xF065:
            return _FX65(emu, op);
        case 0xF030:
            return _FX30(emu, op);
        case 0xF075:
            return _FX75(emu, op);
        case 0xF085:
            return _FX85(emu, op);
        }
        break;
    default:
        printf("%s %X\n", "Unknown opcode ", op);
    }
}
Exemple #18
0
static void add_vertices(struct line_list **first,
                         struct line_list *what,
                         double yp)
{
    struct line_list **ins,*c;
#ifdef POLYDEBUG
    char *why="unknown";
#define BECAUSE(X) (why=(X))
#else
#define BECAUSE(X)
#endif

    while (what)
    {
        what->xmin=line_xmin(what,yp,&what->yxmin);
        what->xmax=line_xmax(what,yp,&what->yxmax);

        ins=first;

#ifdef POLYDEBUG
        fprintf(stderr,"  insert %g,%g - %g,%g [%g,%g - %g,%g]\n",
                what->xmin,what->yxmin,
                what->xmax,what->yxmax,
                what->above->x,what->above->y,
                what->below->x,what->below->y);
#endif

        /* fast jump vectorgroups on the left */
        while (*ins)
        {
            if ((*ins)->xmax>what->xmin) break;
            ins=&((*ins)->next);
        }

        /* ok, place in correct y for x=what->xmin or x=(*ins)->xmin */

        while (*ins)
        {
            /* case: -what-> <-ins- */
            BECAUSE("what is left of ins");
            if ((*ins)->xmin>=what->xmax)
                break; /* place left of */

            /* case: -what-    */
            /*       <-ins-    */

            if ((*ins)->xmin==what->xmin &&
                    (*ins)->yxmin==what->yxmin)
            {
                BECAUSE("ins is above (left exact) what");
                if (VY((*ins),what->xmax)>what->yxmax) break;
                else {
                    ins=&((*ins)->next);
                    continue;
                }
            }

            /* case: -what-    */
            /*       -ins->    */

            if ((*ins)->xmax==what->xmax &&
                    (*ins)->yxmax==what->yxmax)
            {
                BECAUSE("ins is above (right exact) what");
                if (VY((*ins),what->xmin)>what->yxmin) break;
                else {
                    ins=&((*ins)->next);
                    continue;
                }
            }

            /* case: -what-    */
            /*          <-ins- */
            if ((*ins)->xmin>what->xmin)
            {
                BECAUSE("ins is below (right) what");
                if ((*ins)->yxmin>VY(what,(*ins)->xmin)) break;
            }
            /* case:   <-what-    */
            /*       -ins-        */
            else
            {
                BECAUSE("what is above ins (left)");
                if (VY((*ins),what->xmin)>what->yxmin) break;
            }

            /* case: -what->    */
            /*           -ins-  */
            if ((*ins)->xmax>what->xmax)
            {
                BECAUSE("what is above ins (right)");
                if (VY((*ins),what->xmax)>what->yxmax) break;
            }
            /* case:    -what-    */
            /*       -ins->       */
            else
            {
                BECAUSE("ins is below (left) what");
                if ((*ins)->yxmax>VY(what,(*ins)->xmax)) break;
            }

            ins=&((*ins)->next);
        }


#ifdef POLYDEBUG
        if (*ins)
            fprintf(stderr,"     before %g,%g - %g,%g [%g,%g - %g,%g] because %s\n",
                    (*ins)->xmin,(*ins)->yxmin,
                    (*ins)->xmax,(*ins)->yxmax,
                    (*ins)->above->x,(*ins)->above->y,
                    (*ins)->below->x,(*ins)->below->y,
                    why);
#endif


        c=malloc(sizeof(struct line_list));
        if(!c) return;
        *c=*what;
        c->next=*ins;
        *ins=c;

        what=what->next;
    }
}
Exemple #19
0
/**
 * @fn void player_board (void)
 *
 * @brief Attempt to board the player's target.
 *
 * Creates the window on success.
 */
void player_board (void)
{  
   Pilot *p;
   unsigned int wdw;

   if (player->target==PLAYER_ID) {
      player_message("You need a target to board first!");
      return;
   }

   p = pilot_get(player->target);

   if (!pilot_isDisabled(p)) {
      player_message("You cannot board a ship that isn't disabled!");
      return;
   }
   else if (vect_dist(&player->solid->pos,&p->solid->pos) >
         p->ship->gfx_space->sw * PILOT_SIZE_APROX) {
      player_message("You are too far away to board your target.");
      return;
   }
   else if ((pow2(VX(player->solid->vel)-VX(p->solid->vel)) +
            pow2(VY(player->solid->vel)-VY(p->solid->vel))) >
         (double)pow2(MAX_HYPERSPACE_VEL)) {
      player_message("You are going too fast to board the ship.");
      return;
   }
   else if (pilot_isFlag(p,PILOT_BOARDED)) {
      player_message("Your target cannot be boarded again.");
      return;
   };

   /* pilot will be boarded */
   pilot_setFlag(p,PILOT_BOARDED); 
   player_message("Boarding ship %s.", p->name);


   /*
    * create the boarding window
    */
   wdw = window_create( "Boarding", -1, -1, BOARDING_WIDTH, BOARDING_HEIGHT );

   window_addText( wdw, 20, -30, 120, 60,
         0, "txtCargo", &gl_smallFont, &cDConsole,
         "Credits:\n"
         "Cargo:\n"
         "Fuel:\n"
         );
   window_addText( wdw, 80, -30, 120, 60,
         0, "txtData", &gl_smallFont, &cBlack, NULL );

   window_addButton( wdw, 20, 20, BUTTON_WIDTH, BUTTON_HEIGHT,
         "btnStealCredits", "Credits", board_stealCreds);
   window_addButton( wdw, 20+BUTTON_WIDTH+20, 20, BUTTON_WIDTH, BUTTON_HEIGHT,
         "btnStealCargo", "Cargo", board_stealCargo);
   window_addButton( wdw, 20+2*(BUTTON_WIDTH+20), 20, BUTTON_WIDTH, BUTTON_HEIGHT,
         "btnStealCargo", "Fuel", board_stealFuel);

   window_addButton( wdw, -20, 20, BUTTON_WIDTH, BUTTON_HEIGHT,
         "btnBoardingClose", "Leave", board_exit );

   board_update(wdw);

   /*
    * run hook if needed
    */
   pilot_runHook(p, PILOT_HOOK_BOARD);
}
Exemple #20
0
static int polyfill_event(double xmin,
                          double xmax,
                          double yp,
                          double *buf,
                          struct line_list **pll,
                          int tog)
{
    struct line_list *c;
    struct line_list *ll=*pll;
    int mtog;

#ifdef POLYDEBUG
    fprintf(stderr," event %g,%g - %g,%g tog=%d\n",xmin,yp,xmax,yp+1.0,tog);
#endif

    /* toggle for lines ended at xmin,yp */
    c=ll;
    while (c)
    {
        if ( (c->above->y < yp) &&
                ( (c->xmax==xmin && c->yxmax==yp) ||
                  (c->xmin==xmin && c->yxmin==yp) ) )
        {
#ifdef POLYDEBUG
            fprintf(stderr,"    toggle for %g,%g - %g,%g [%g,%g - %g,%g]\n",
                    c->xmin,c->yxmin,c->xmax,c->yxmax,
                    c->above->x,c->above->y,c->below->x,c->below->y);
#endif
            tog=!tog;
        }
        c=c->next;
    }

#if 0
    /* sanity check */
    c=ll;
    while (c && c->next)
    {
        if (c->xmin > c->next->xmax ||
                ( c->xmin!=c->xmax &&
                  c->next->xmin!=c->next->xmax &&
                  c->xmax>=xmin &&
                  c->xmin<=xmin &&
                  c->next->xmax>=xmin &&
                  c->next->xmin<=xmin &&
                  (VY(c,xmin)>VY(c->next,xmin) ||
                   VY(c,xmax)>VY(c->next,xmax))) )
        {
            struct line_list *l1;
            /* resort */
#ifdef POLYDEBUG
            fprintf(stderr,"  !!! internal resort !!!\n");
            fprintf(stderr,"  on pair: %g,%g - %g,%g [%g,%g - %g,%g]\n           %g,%g - %g,%g [%g,%g - %g,%g]\n",
                    c->xmin,c->yxmin,c->xmax,c->yxmax,
                    c->above->x,c->above->y,c->below->x,c->below->y,
                    c->next->xmin,c->next->yxmin,c->next->xmax,c->next->yxmax,
                    c->next->above->x,c->next->above->y,
                    c->next->below->x,c->next->below->y);
#endif
            l1=NULL;
            add_vertices(&l1,ll,yp);

            while ((c=*pll))
            {
                *pll=c->next;
                free(c);
            }

            ll=*pll=l1;

            break;
        }
        c=c->next;
    }
#endif

    /* paint if needed */
    if (tog)
    {
#ifdef POLYDEBUG
        fprintf(stderr,"  fill %g..%g with 1.0\n",xmin,xmax);
#endif
        polyfill_row_add(buf,xmin,xmax,1.0);
    }

    /* loop over events */
    mtog=tog;
    c=ll;

    while (c)
    {
        if (c->xmin<=xmin && c->xmax>=xmax)
        {
            double y1 = VY(c,xmin);
#ifdef POLYDEBUG
            double y2 = VY(c,xmax);
            fprintf(stderr,"  use line %g,%g - %g,%g [%g,%g - %g,%g] : %g,%g - %g,%g = %+g\n",
                    c->xmin,c->yxmin,c->xmax,c->yxmax,
                    c->above->x,c->above->y,c->below->x,c->below->y,
                    xmin,y1,xmax,y2,(tog?-1.0:1.0)*((y1+y2)/2.0-yp));
#endif
            polyfill_slant_add(buf,xmin,xmax,
                               DO_NOT_WARN(tog?-1.0:1.0),
                               (yp+1)-y1,-c->dy);
            tog=!tog;
        }
        if (c->xmin>xmax) break; /* skip the rest */
        c=c->next;
    }


    return mtog;
}
Exemple #21
0
static void polyfill_some(struct image *img,
                          struct vertex *v,
                          double *buf)
{
    struct line_list *ll=NULL;
    int y=0;
    double ixmax = (double)img->xsize;
    struct vertex *to_add=v,*to_loose=v;
    /* beat row for row */

    if (y+1.0+1e-10<v->y)
        y = DOUBLE_TO_INT(v->y);

    while (y<img->ysize && (to_loose||to_add) )
    {
        double yp = y;
        struct line_list *c;
        double xmin, xmax;
        rgb_group *d;
        int tog=0;
        int i;

#ifdef POLYDEBUG
        fprintf(stderr,"\nline %d..%d\n",y,y+1);
#endif

        /* update values for current lines */
        c=ll;
        while (c)
        {
            c->xmin=line_xmin(c,yp,&c->yxmin);
            c->xmax=line_xmax(c,yp,&c->yxmax);
            c=c->next;
        }

        /* add any new vertices */
        while (to_add && to_add->y<yp+1.0)
        {
            struct vertex *vx=to_add;
            to_add=to_add->next;
            add_vertices(&ll,vx->below,yp);
        }

#ifdef POLYDEBUG
        c=ll;
        while (c)
        {
            fprintf(stderr,"  line %g,%g - %g,%g [%g,%g - %g,%g]\n",
                    c->xmin,c->yxmin,c->xmax,c->yxmax,
                    c->above->x,c->above->y,c->below->x,c->below->y);
            c=c->next;
        }

#endif

        if (!ll)
        {
            y++;
            continue;
        }

        /* begin with zeros */
        for (i=0; i<img->xsize; i++) buf[i]=0.0;

        /* sanity check */
        c=ll;
        while (c && c->next)
        {
            if (c->xmin > c->next->xmax ||
                    c->xmax > c->next->xmin ||
                    ( c->xmin!=c->xmax &&
                      c->next->xmin!=c->next->xmax &&
                      c->next->xmax>=c->xmin &&
                      c->next->xmin<=c->xmin &&
                      VY(c,c->xmin)>VY(c->next,c->xmin)))
            {
                struct line_list *l1;
                /* resort */
#ifdef POLYDEBUG
                fprintf(stderr,"  !!! resort !!!\n");
#endif
                l1=NULL;
                add_vertices(&l1,ll,yp);

                while ((c=ll))
                {
                    ll=c->next;
                    free(c);
                }

                ll=l1;

                break;
            }
            c=c->next;
        }

        /* find first horisintal event */
        xmin=ll->xmin;
        c=ll;
        while (c)
        {
            if (c->xmin<xmin) xmin=c->xmin;
            c=c->next;
        }

        /* loop through all horisontal events */
        while (xmin<ixmax)
        {
            xmax=1e10;
            c=ll;
            while (c)
            {
                /* each line has two events: beginning and end */
                if (c->xmin<xmax && c->xmin>xmin) xmax=c->xmin;
                if (c->xmax<xmax && c->xmax>xmin) xmax=c->xmax;
                c=c->next;
            }
            if (xmax==1e10) break; /* no more events */

            if (xmax>ixmax) xmax=ixmax;
            tog=polyfill_event(xmin,xmax,yp,buf,&ll,tog);

            /* shift to get next event */
            xmin = xmax;
            xmax = DO_NOT_WARN(xmin - 1.0);
        }


        /* remove any old vertices */
        while (to_loose!=to_add && to_loose->y<yp+1.0-1e-10)
        {
            struct vertex *vx=to_loose;
            to_loose=to_loose->next;
            sub_vertices(&ll,vx,yp);
        }

        /* write this row */
        d=img->img+img->xsize*y;
        if(THIS->alpha)
        {
            for (i=0; i<img->xsize; i++)
            {
#ifdef POLYDEBUG
                fprintf(stderr,"%3.2f ",buf[i]);
#endif

#define apply_alpha(x,y,alpha) \
   ((unsigned char)((y*(255L-(alpha))+x*(alpha))/255L))

                d->r = apply_alpha( d->r,
                                    DOUBLE_TO_COLORTYPE((d->r*(1.0-buf[i]))+
                                                        (img->rgb.r*buf[i])),
                                    THIS->alpha );
                d->g = apply_alpha( d->g,
                                    DOUBLE_TO_COLORTYPE((d->g*(1.0-buf[i]))+
                                                        (img->rgb.g*buf[i])),
                                    THIS->alpha );
                d->b = apply_alpha( d->b,
                                    DOUBLE_TO_COLORTYPE((d->b*(1.0-buf[i]))+
                                                        (img->rgb.b*buf[i])),
                                    THIS->alpha );
                d++;
            }
#ifdef POLYDEBUG
            fprintf(stderr,"\n");
#endif
        }
        else {
            for (i=0; i<img->xsize; i++)
            {
#ifdef POLYDEBUG
                fprintf(stderr,"%3.2f ",buf[i]);
#endif
                d->r = DOUBLE_TO_COLORTYPE((d->r*(1.0-buf[i]))+(img->rgb.r*buf[i]));
                d->g = DOUBLE_TO_COLORTYPE((d->g*(1.0-buf[i]))+(img->rgb.g*buf[i]));
                d->b = DOUBLE_TO_COLORTYPE((d->b*(1.0-buf[i]))+(img->rgb.b*buf[i]));
                d++;
            }
#ifdef POLYDEBUG
            fprintf(stderr,"\n");
#endif
        }

        y++;
    }
    while (ll)
    {
        struct line_list *c;
        ll=(c=ll)->next;
        free(c);
    }
}
//---------------------------------------------------------
void NDG2D::Output_Mesh()
//---------------------------------------------------------
{
  static int count = 0;
  string output_dir = ".";

  // Write the triangles that underlie current DG mesh
  // in vtk format. Here we write the basic triangles 
  // either read from the original .neu file, or as 
  // adapted during adaptive mesh refinement (AMR).

  string buf = umOFORM("%s/mesh2D_N%d_%04d.vtk", output_dir.c_str(), this->N, ++count);
  FILE *fp = fopen(buf.c_str(), "w");
  if (!fp) {
    umLOG(1, "Could no open %s for output!\n", buf.c_str());
    return;
  }

  // Set flags and totals

  int Ncells = 1;   // 1 "cell" per triangle
  int Npts   = 3;   // 3 vertices per triangle

  this->Nv = this->VX.length();

  // set totals for Vtk output
  int vtkTotalPoints = this->Nv;
  int vtkTotalCells  = this->K * Ncells;
  int vtkTotalConns  = (this->EToV.num_cols()+1) * this->K * Ncells;


  //-------------------------------------
  // 1. Write the VTK header details
  //-------------------------------------
  fprintf(fp, "# vtk DataFile Version 2");
  fprintf(fp, "\nNuDG++ mesh");
  fprintf(fp, "\nASCII");
  fprintf(fp, "\nDATASET UNSTRUCTURED_GRID\n");
  fprintf(fp, "\nPOINTS %d double", vtkTotalPoints);

  //-------------------------------------
  // 2. Write the vertex data
  //-------------------------------------
  // write 2D vertex data to file
  for (int i=1; i<=this->Nv; ++i) {
    fprintf(fp, "\n%20.12e %20.12e  0.0", VX(i), VY(i));
  }

  //-------------------------------------
  // 3. Write the element connectivity
  //-------------------------------------

  // Number of indices required to define connectivity
  fprintf(fp, "\n\nCELLS %d %d", vtkTotalCells, vtkTotalConns);

  // write element connectivity to file
  for (int k=1; k<=this->K; ++k) {
    fprintf(fp, "\n3  %5d  %5d  %5d", 
                EToV(k,1)-1, EToV(k,2)-1, EToV(k,3)-1);
  }


  //-------------------------------------
  // 4. Write the cell types
  //-------------------------------------

  // For each element (cell) write a single integer 
  // identifying the cell type.  The integer should 
  // correspond to the enumeration in the vtk file:
  // /VTK/Filtering/vtkCellType.h

  fprintf(fp, "\n\nCELL_TYPES %d\n", vtkTotalCells);

  for (int k=1; k<=this->K; ++k) {
    fprintf(fp, "5 ");            // 5:VTK_TRIANGLE
    if (! (k%10))
      fprintf(fp, "\n");
  }
  
  //-------------------------------------
  // 5. Write scalar "vtkCellData"
  //-------------------------------------

  // TODO: output "cell data" such as element area, 
  // or quality measures such as min/max angles, etc.

  // TODO: "FaceData" i.e. boundary conditions
  // ...


  // add final newline to output
  fprintf(fp, "\n");
  fclose(fp);
}
Exemple #23
0
//---------------------------------------------------------
void NDG3D::Hrefine3D(IVec& refineflag)
//---------------------------------------------------------
{
  DVec lVX("lVX"), lVY("lVY"), lVZ("lVZ");

  int a=1, b=2, c=3, d=4, e=5, 
      f=6, g=7, h=8, i=9, j=10;

  //             a b c d  e    f    g    h    i    j
  lVX.load(10, " 0 1 0 0  0.5  0.5  0.0  0.0  0.5  0.0 ");
  lVY.load(10, " 0 0 1 0  0.0  0.5  0.5  0.0  0.0  0.5 ");
  lVZ.load(10, " 0 0 0 1  0.0  0.0  0.0  0.5  0.5  0.5 ");

  assert(4 == Nfaces);

  IMat lEToV(8,4, "lEToV"), im84(8,4, "im84"), oFnodes(4,6, "oFnodes");

  set84(lEToV, 8,4, 
           a, e, g, h,
	         e, b, f, i,
	         g, f, c, j,
	         h, i, j, d,
	         e, g, h, i,
	         h, i, g, j,
	         e, f, g, i,
	         g, i, f, j);

  set46(oFnodes, 4,6, 
           a, e, b, f, c, g,
	         a, e, b, i, d, h,
	         b, f, c, j, d, i,
	         a, g, c, j, d, h);

  IMat vnum(gRowData, 4,3, "1 2 3  1 2 4  2 3 4  3 1 4");

  int lK = lEToV.num_rows();
  IMat lBCType(lK, Nfaces), tm1, tm2;
  IVec tv(3),tv1,tv2, oFn,vnp,ksids;
  int kk=0,ff=0,oo=0;
  for (kk=1; kk<=lK; ++kk) {
    for (ff=1; ff<=Nfaces; ++ff) {
      for (oo=1; oo<=Nfaces; ++oo) 
      {
        oFn = oFnodes.get_row(oo);
        vnp = vnum.get_row(ff);
        tm1 = lEToV(kk, vnp);  const IVec& knodes = dynamic_cast<const IVec&>(tm1);

      //tv = intersect(lEToV(k, vnum(p,All)), oFnodes(o,All));
        tv = intersect(knodes, oFn);

        if ( tv.length()==3 ) {
	        lBCType(kk, ff) = oo;
        }
      }
    }
  }

  int NV = VX.length()+1;
  int sp_len = NV + NV*NV;

  // sparse buffers   nnz  vals,triplet
  CSd newVX(sp_len,1,  NV,    1,  1);
  CSd newVY(sp_len,1,  NV,    1,  1);
  CSd newVZ(sp_len,1,  NV,    1,  1);

  Index1D II(1, NV-1);
  newVX(II,1) = VX;
  newVY(II,1) = VY;
  newVZ(II,1) = VZ;

  IVec ids("ids");
  int oldK = K, f1=0;

  for (int k1=1; k1<=oldK; ++k1) {
    if (refineflag(k1)) 
    {
      a = EToV(k1,1); 
      b = EToV(k1,2); 
      c = EToV(k1,3); 
      d = EToV(k1,4);

      e = NV + std::max(a*NV+b, b*NV + a);
      f = NV + std::max(b*NV+c, c*NV + b);
      g = NV + std::max(a*NV+c, c*NV + a);
      h = NV + std::max(a*NV+d, d*NV + a);
      i = NV + std::max(b*NV+d, d*NV + b);
      j = NV + std::max(c*NV+d, d*NV + c);

    //ks = [k1, K+1:K+7];
      IVec ks(1, k1);  ks.append(Range(K+1,K+7));

      //--------------------------
      // EToV(ks,:) = [a e g h;
		  //               e b f i;
		  //               g f c j;
		  //               h i j d;
		  //               e g h i;
		  //               h i g j;
		  //               e f g i;
		  //               g i f j];
      //--------------------------

      set84(im84, 8,4, 
            a, e, g, h,
		        e, b, f, i,
		        g, f, c, j,
		        h, i, j, d,
		        e, g, h, i,
		        h, i, g, j,
		        e, f, g, i,
		        g, i, f, j);

    //EToV(ks,All) = im84;
      EToV.merge_rows(ks, im84);

      for (f1=1; f1<=Nfaces; ++f1) 
      {
        tv = lBCType(All,f1);
        ids = find(tv, '!', 0);
        ksids = ks(ids);
        tm1 = lBCType(ids,f1);
        tm2 = BCType(k1, (const IVec&)tm1);

        // expand BCType to accommodate new range
        int maxI=ksids.max_val(), maxR=BCType.num_rows();
        if (maxI>maxR) {BCType.realloc(maxI, BCType.num_cols());}

        BCType(ksids,f1) = trans(tm2);
      }

      K += 7;

      newVX.set1(e,1, 0.5*(VX(a)+VX(b))); 
      newVX.set1(f,1, 0.5*(VX(b)+VX(c)));
      newVX.set1(g,1, 0.5*(VX(c)+VX(a)));
      newVX.set1(h,1, 0.5*(VX(a)+VX(d)));
      newVX.set1(i,1, 0.5*(VX(b)+VX(d)));
      newVX.set1(j,1, 0.5*(VX(c)+VX(d)));

      newVY.set1(e,1, 0.5*(VY(a)+VY(b)));
      newVY.set1(f,1, 0.5*(VY(b)+VY(c)));
      newVY.set1(g,1, 0.5*(VY(c)+VY(a)));
      newVY.set1(h,1, 0.5*(VY(a)+VY(d)));
      newVY.set1(i,1, 0.5*(VY(b)+VY(d)));
      newVY.set1(j,1, 0.5*(VY(c)+VY(d)));

      newVZ.set1(e,1, 0.5*(VZ(a)+VZ(b)));
      newVZ.set1(f,1, 0.5*(VZ(b)+VZ(c)));
      newVZ.set1(g,1, 0.5*(VZ(c)+VZ(a)));
      newVZ.set1(h,1, 0.5*(VZ(a)+VZ(d)));
      newVZ.set1(i,1, 0.5*(VZ(b)+VZ(d)));
      newVZ.set1(j,1, 0.5*(VZ(c)+VZ(d)));
    }
  }

  //-------------------------------------
  // drop duplicates and sort
  //-------------------------------------
  newVX.compress(true);
  newVY.compress(true);
  newVZ.compress(true);

//ids = sort(unique(EToV(:)), 'ascend');
  ids = unique(EToV);


  int len=ids.max_val(); 
  IVec gnum(len);
  gnum(ids) = Range(1,ids.length());

  VX = full( newVX, ids );
  VY = full( newVY, ids );
  VZ = full( newVZ, ids );

  // EToV = gnum(EToV);
  EToV.set_map(EToV, gnum);

  int NV_old = NV-1;        // local counters
  this->Nv = VX.length();   // update member variable

  umLOG(1, "Hrefine3D [%d] : old Nv = %4d, new Nv = %4d\n", ++refine_count, NV_old, Nv);
  umLOG(1, "                old K  = %4d, new K  = %4d\n\n", oldK, K);


#if (0)
  tetramesh(EToV, [VX', VY', VZ'])
#endif

}
//---------------------------------------------------------
void EulerShock2D::precalc_limiter_data()
//---------------------------------------------------------
{

  //---------------------------------------------
  // pre-calculate element geometry and constant 
  // factors for use in this->EulerLimiter2D()
  //---------------------------------------------

  Lim_AVE = 0.5 * MassMatrix.col_sums();
  DMat dropAVE = eye(Np) - outer(ones(Np),Lim_AVE);
  Lim_dx = dropAVE*x; 
  Lim_dy = dropAVE*y;

  // Extract coordinates of vertices of elements
  IVec v1=EToV(All,1);  Lim_xv1=VX(v1); Lim_yv1=VY(v1);
  IVec v2=EToV(All,2);  Lim_xv2=VX(v2); Lim_yv2=VY(v2);
  IVec v3=EToV(All,3);  Lim_xv3=VX(v3); Lim_yv3=VY(v3);  

  const DVec &xv1=Lim_xv1,&xv2=Lim_xv2,&xv3=Lim_xv3;
  const DVec &yv1=Lim_yv1,&yv2=Lim_yv2,&yv3=Lim_yv3;
  DMat &fnx=Lim_fnx, &fny=Lim_fny, &fL=Lim_fL;

  // Compute face unit normals and lengths
  fnx.resize(3,K); fny.resize(3,K);

  // fnx = (3,K) = [yv2-yv1; yv3-yv2; yv1-yv3];
  fnx.set_row(1, yv2-yv1); fnx.set_row(2, yv3-yv2); fnx.set_row(3, yv1-yv3);

  // fny = (3,K) =  -[xv2-xv1;xv3-xv2;xv1-xv3];
//fny.set_row(1, xv2-xv1); fny.set_row(2, xv3-xv2); fny.set_row(3, xv1-xv3);
  fny.set_row(1, xv1-xv2); fny.set_row(2, xv2-xv3); fny.set_row(3, xv3-xv1);

  fL = sqrt(sqr(fnx)+sqr(fny)); fnx.div_element(fL); fny.div_element(fL);

  //-------------------------------------------------------
  // Compute coords of element centers and face weights
  //-------------------------------------------------------

  // Find neighbors in patch
  Lim_E1=EToE(All,1); Lim_E2=EToE(All,2); Lim_E3=EToE(All,3);

  // Compute coordinates of element centers
  xc0=Lim_AVE*x; xc1=xc0(Lim_E1); xc2=xc0(Lim_E2); xc3=xc0(Lim_E3);
  yc0=Lim_AVE*y; yc1=yc0(Lim_E1); yc2=yc0(Lim_E2); yc3=yc0(Lim_E3);

  // Compute weights for face gradients 
  A0=Lim_AVE*J*TWOTHIRD;
  A1=A0+A0(Lim_E1); A2=A0+A0(Lim_E2); A3=A0+A0(Lim_E3);
  A1_A2_A3 = A1+A2+A3;

  // Find boundary faces for each face 
  Lim_id1=find(BCType.get_col(1),'!',0);
  Lim_id2=find(BCType.get_col(2),'!',0);
  Lim_id3=find(BCType.get_col(3),'!',0);

  // Compute location of centers of reflected ghost elements at boundary faces
  if (1) {
    DMat FL1=fL(1,Lim_id1), Fnx1=fnx(1,Lim_id1), Fny1=fny(1,Lim_id1);
    DVec fL1=FL1, fnx1=Fnx1, fny1=Fny1;
    DVec H1   = 2.0*(dd(A0(Lim_id1),fL1));
    xc1(Lim_id1) += 2.0*fnx1.dm(H1);
    yc1(Lim_id1) += 2.0*fny1.dm(H1);

    DMat FL2=fL(2,Lim_id2), Fnx2=fnx(2,Lim_id2), Fny2=fny(2,Lim_id2);
    DVec fL2=FL2, fnx2=Fnx2, fny2=Fny2;
    DVec H2   = 2.0*(dd(A0(Lim_id2),fL2));
    xc2(Lim_id2) += 2.0*fnx2.dm(H2);
    yc2(Lim_id2) += 2.0*fny2.dm(H2);

    DMat FL3=fL(3,Lim_id3), Fnx3=fnx(3,Lim_id3), Fny3=fny(3,Lim_id3);
    DVec fL3=FL3, fnx3=Fnx3, fny3=Fny3;
    DVec H3   = 2.0*(dd(A0(Lim_id3),fL3));
    xc3(Lim_id3) += 2.0*fnx3.dm(H3);
    yc3(Lim_id3) += 2.0*fny3.dm(H3);
  }

  // Find boundary faces
  IVec bct = trans(BCType);
  Lim_idI = find(bct, '=', (int)BC_In);
  Lim_idO = find(bct, '=', (int)BC_Out);
  Lim_idW = find(bct, '=', (int)BC_Wall);
  Lim_idC = find(bct, '=', (int)BC_Cyl);

  Lim_ctx.resize(3,K); Lim_cty.resize(3,K);
  Lim_ctx.set_row(1,xc1); Lim_ctx.set_row(2,xc2); Lim_ctx.set_row(3,xc3);
  Lim_cty.set_row(1,yc1); Lim_cty.set_row(2,yc2); Lim_cty.set_row(3,yc3);

  // load the set of ids
  Lim_ids.resize(6);
  Lim_ids(1)=1;      Lim_ids(2)=Nfp;    Lim_ids(3)=Nfp+1;
  Lim_ids(4)=2*Nfp;  Lim_ids(5)=3*Nfp;  Lim_ids(6)=2*Nfp+1;

  limQ = Q;
}