struct LandScape
{
 BYTE * heightfield;//guesss what
 WORD LeadId[4];//contains the indices of the lanscape parts
                  touching this part in North(=[0]),
                  Est,South and West
}

//Rot_Edges[0]=upper left
//Rot_Edges[1]=upper right
//Rot_Edges[2]=lower left
//Rot_Edges[3]=lower right

Vector VLeft=(Rot_Edges[2]-Rot_Edges[0])/height_of_heightfield;
Vector VDown=(Rot_Edges[3]-Rot_Edges[1])/width_of_heightfield;

Vector pos=Rot_Edges[0]+VLeft*5+VDown*4;

texadd.x=dist(Rot_Edges[2],Rot_Edges[0])/height_of_heightfield;
texadd.y=dist(Rot_Edges[3],Rot_Edges[1])/width_of_heightfield;

//again for heightfield[5][4]
tex.x=5*texadd.x;
tex.y=4*texadd.y;

struct Particle_
{
 long color;
 Vec Pos;//Pos relative to ..\Pos
 Vec Move;//how to contonue Pos
 bool active;
};

struct Particle_effect
{
 int Num_particles;
 Particle_ Particle[MAX_PARTICLES];
 int part_eff_act_livetime;//how long are we existing??
 int part_eff_livetime;//how long are we allowed to be there??
 bool grav;
 bool active;
};

//update func for particles...called every frame...
yet the particles' motion is framerate dependent.had no time to hange
that...

void _fastcall G_ProcessParticles(_Particles * MP,DWORD WorldTime,Vec Pos,
float xw, float yw , float zw)
{
 Vec RPos;
 G_VMUL(&Pos,1.f,&RPos);
 grDepthMask(0);//no zwrites
 grFogMode(GR_FOG_DISABLE); //no fog...
  if(yw)
  {
   G_Set_Actscbuf(0);// I use some statemachine for sin and cos...I have a
buffer (size = 3)..this command say the next sin+cos calced should be stored
in buffer[0]
   G_Get_SinCos(yw);//xw,yw,zw are the angles to rotate the world about to
get viewpos
  }
  if(xw)
  {
   G_Set_Actscbuf(1);
   G_Get_SinCos(xw);
  }
  if(zw)
  {
   G_Set_Actscbuf(2);
   G_Get_SinCos(zw);
  }

 for(int i=0;i<MP->Num_particles;i++)
 {
  if((MP->Particles+i)->used)//go through all particle_collections
                              and check weather processing is needed
  {
   int Not_Used=0;
   A_Particle * AP=(MP->Particles+i)->Parts;
   A_Particle LP;
   if((MP->Particles+i)->glow)//additive blending gives best result...they
sprites are munged...
   {
    if((MP->Particles+i)->add)
    {
     grAlphaBlendFunction( GR_BLEND_ONE,GR_BLEND_ONE,
GR_BLEND_ONE,GR_BLEND_ZERO );
     grColorCombine(GR_COMBINE_FUNCTION_SCALE_OTHER_MINUS_LOCAL,
GR_COMBINE_FACTOR_ONE, GR_COMBINE_LOCAL_ITERATED, GR_COMBINE_OTHER_TEXTURE,
false);
    }
    else
    {
     grAlphaBlendFunction( GR_BLEND_DST_COLOR, GR_BLEND_ZERO,GR_BLEND_ZERO,
GR_BLEND_ZERO );
     grColorCombine(GR_COMBINE_FUNCTION_SCALE_OTHER_MINUS_LOCAL,
GR_COMBINE_FACTOR_ONE, GR_COMBINE_LOCAL_ITERATED, GR_COMBINE_OTHER_TEXTURE,
true);
    }

   }
   for(int i2=0;i2<(MP->Particles+i)->Num_parts;i2++)//go through all single
particles
   {
    if(AP->used)
    {
     if(WorldTime-AP->StartTime>AP->LiveTime)//see if it died due to time
out
     {
      if((MP->Particles+i)->loop)/if died and loop recreate
      {
       AP->Light=AP->Orig_Light;
       AP->Pos=AP->Orig_Pos;
       AP->Size=AP->Orig_Size;
       AP->Dir=AP->Orig_Dir;
       AP->LiveTime=AP->Orig_LT;
       AP->StartTime=WorldTime;
       AP->AnimLight=AP->Orig_AnimL;

       AP->faded=0;
      }
      else AP->used=0;
     }
     else
     {
      AP->Dir.y+=GRAVITY*AP->Grav_Power;//apply garviy(if desired)
      G_VADD(&AP->Pos,&AP->Dir,&AP->Pos);//move particle (corresponding to
its motion)
      AP->Size+=AP->AnimSize;//animate size+light
      G_VADD(&AP->Light,&AP->AnimLight,&AP->Light);


if(!AP->faded&&WorldTime-AP->StartTime>(AP->LiveTime-(AP->LiveTime/5)))//if
short before dying fade out
      {
       float x,y,z;
       x=((WorldTime-AP->StartTime)-(AP->LiveTime-(AP->LiveTime/5)))*2.f;
       y=x;
       z=x;
       x=((255-AP->Light.x)/x);
       AP->AnimLight.x=x;
       y=((255-AP->Light.y)/y);
       AP->AnimLight.y=y;
       z=((255-AP->Light.z)/z);
       AP->AnimLight.z=z;
       AP->faded=1;
      }

     }
     G_VSUB(&AP->Pos,&RPos,&LP.Pos);

     if(yw)
     {
      G_Set_Actscbuf(0);//activate the buffer[0]..now it's values will be
used for the rotation calcs
      G_PROTY(&LP.Pos,&LP.Pos,yw);
     }
     if(xw)
     {
      G_Set_Actscbuf(1);
      G_PROTX(&LP.Pos,&LP.Pos,xw);
     }
     if(zw)
     {
      G_Set_Actscbuf(0);
      G_PROTZ(&LP.Pos,&LP.Pos,zw);
     }
     if(LP.Pos.z>0&&LP.Pos.z<C_ZBACK)//if on screen
     {
      G_Makepers(&LP.Pos);//do perpective projection
      float add=(LP.Pos.x+AP->Size/2)/(1+LP.Pos.z*ZMUL);
      extern bool Indoor;
      extern float Scale;

if(!CL_Clip_Single_Point(&LP.Pos))D_DrawParticle((MP->Particles+i),AP,LP.Pos
,add*Scale);//and draw the particle
     }
    }
    else Not_Used++;
    AP++;
   }
   if(Not_Used>=(MP->Particles+i)->Num_parts)(MP->Particles+i)->used=0;//if
all particles died free this particle_colection..so another one can be
started
   if((MP->Particles+i)->glow)//return old state
   {
    grAlphaBlendFunction( GR_BLEND_SRC_ALPHA,GR_BLEND_ONE_MINUS_SRC_ALPHA,
GR_BLEND_ONE,GR_BLEND_ZERO );
    grColorCombine(GR_COMBINE_FUNCTION_SCALE_OTHER_MINUS_LOCAL,
GR_COMBINE_FACTOR_ONE, GR_COMBINE_LOCAL_ITERATED, GR_COMBINE_OTHER_TEXTURE,
FXFALSE);
   }
  }
 }
 grDepthMask(1);
 grFogMode(GR_FOG_WITH_TABLE);
}

Vec inline CreateRndVec(float rnd)//create a vec with random values between
+/- md
{
 Vec Add;
 Add.x=random(rnd);
 if(random(2)<1)Add.x=-Add.x;
 Add.y=random(rnd);
 if(random(2)<1)Add.y=-Add.y;
 Add.z=random(rnd);
 if(random(2)<1)Add.z=-Add.z;
 return Add;
}

void CreateA_Particle(A_Particle * AP,Vec Pos,int ID,DWORD WT,DWORD LT,float
rnd)// create some mtions/aniations...
{
 Vec Add;
 switch(ID)
 {
  case ID_EXPLOSION:
    AP->used=1;
    Add=CreateRndVec(0.1f);
    G_VADD(&Pos,&Add,&AP->Orig_Pos);
    AP->Orig_Dir.x=0;
    AP->Orig_Dir.y=0;
    AP->Orig_Dir.z=-0.08f;
    Add=CreateRndVec(0.0143f);
    G_VADD(&AP->Orig_Dir,&Add,&AP->Orig_Dir);
    Add=CreateRndVec(-0.0143f);
    G_VADD(&AP->Orig_Dir,&Add,&AP->Orig_Dir);
    //AP->Orig_Dir.y=0;
    AP->Orig_Light.x=random(20);
    AP->Orig_Light.y=100-random(50);
    AP->Orig_Light.z=200;

    Add=CreateRndVec(0.01f);

    AP->AnimLight=Add;
    G_VADD(&AP->Orig_Light,&Add,&AP->Orig_Light);
    AP->faded=0;

    AP->Orig_Size=random(1.5f);
    AP->AnimSize=random(0.001f);
    AP->StartTime=WT;
    AP->LiveTime=(LT/2.5f)/10.f+random(((LT/2.5f)/10.f)*9.f);

    AP->Orig_LT=AP->LiveTime;
    AP->Light=AP->Orig_Light;
    AP->Pos=AP->Orig_Pos;
    AP->Size=AP->Orig_Size;
    AP->Dir=AP->Orig_Dir;
    AP->Alpha=200+random(rnd*4);
    AP->Grav_Power=0;//0.80f+random(0.04f);
    AP->Orig_AnimL=AP->AnimLight;

  break;
  default:return;
 }
}

int _fastcall G_CreateParticles(_Particles * MP,DWORD WorldTime,Vec
Pos,DWORD LiveTime,int ID,int Num,bool loop,float random, int tnum)//init
new particle_collision
{
 Part_Coll * PP=MP->Particles;

 for(int i=0;i<PARTICLE_COLLS;i++)
 {
  if(!PP->used)
  {
   MP->Num_particles++;
   PP->ID=ID;//type..maybe explosion...
   PP->loop=loop;
   if(Num>PARTICLES_PER_COLL)Num=PARTICLES_PER_COLL;
   PP->Num_parts=Num;
   PP->used=1;
   PP->glow=1;
   PP->add=1;
   PP->TNUM=tnum;//number of the texture in my texarray
   for(int i2=0;i2<PP->Num_parts;i2++)
   {
    CreateA_Particle((PP->Parts+i2),Pos,PP->ID,WorldTime,LiveTime,random);
   }
   return i;
  }
  PP++;
 }
 return -1;//full with running effects
}