Beispiel #1
0
double
MeanKineticEnergy
(
    const MDConstants K,
    const Molecule **positions,
	const TurbField **turb_velocities
)
{
    double time_mean = 0;

    for (unsigned n = 0; n < K.SnapshotNum; ++n) // calc mean over time
    {
        double part_mean = 0; //for every new timestep

        for (unsigned i = 0; i < K.PartNum; ++i)//calc mean over particles
        {		
            double v_part[kDIM] = {0};
            double v_0[kDIM];  
            InitConstArray (v_0, kDIM, K.v_0);// v_0 * \vec{e_part}

            NormalizeVector (v_0, positions[n][i].direction, v_part);
            double v[kDIM]; //temp array
            SumVector (v_part, turb_velocities[n][i].direction, v);
             
			double kin_energy = KineticEnergy (v);

            part_mean += kin_energy;	assert (part_mean >= 0);
        }

        part_mean /= K.PartNum;		

        time_mean += part_mean; assert (time_mean > 0);
    }	

    time_mean /= (K.iteration_num * K.delta_t);

    return time_mean;
}
Beispiel #2
0
/*** Procesamiento de cada cuadro ***/
void Video( float elapsed )
{
    /* Limpio la pantalla */
    glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT );
    
    /* Perspectiva */
    glMatrixMode( GL_PROJECTION );
    glLoadIdentity();
    gluPerspective( 50.0f/zoom,                           // Ángulo de visión vertical
                   (GLfloat)WIDTH / (GLfloat)HEIGHT, // Aspecto
                   1.0f,                             // Plano cercano
                   2000.0f );                        // Plano lejano
    
    /* Cámara */
    glMatrixMode( GL_MODELVIEW );
    glLoadIdentity();
    
    /* Espada */
    glPushMatrix();
    glMultTransposeMatrixf(volumesEspada.matrix);
    
  //  glTranslatef(cam.pos.x, cam.pos.y + 5, cam.pos.z + 10);
    glRotatef(angX, 1.0f, 0.0f, 0.0f);
    glRotatef(angY, 0.0f, 1.0f, 0.0f);
    glRotatef(angZ, 0.0f, 0.0f, 1.0f);
    
    glCallList(modeloEspada.modelList);
    glPopMatrix();
    /*________*/
    
    
    
   
    
        
    
    
       
    
    
	VECTOR dir = SumVector(cam.pos, cam.look);
    
    gluLookAt(  cam.pos.x, cam.pos.y,  cam.pos.z,       // Posición
                dir.x, dir.y, dir.z,                    // Dirección
                0.0f, 1.0f, 0.0f );                     // Arriba
    
    
    
    
    /*Luz*/
    glPushMatrix();
    SetDirLight(GL_LIGHT0, &dirLight);
    glEnable (GL_LIGHT0);
    glPopMatrix();
    
    
    /*Terreno*/
    glPushMatrix();
    SetMaterial( &terrain.material );
    glBindTexture(GL_TEXTURE_2D, terrain.textureID);
    glCallList( terrain.terrainList );
    glPopMatrix();
    
    
    

    /*agua*/
      /*
    glPushMatrix();
    glEnable(GL_BLEND);
    SetMaterial( &agua.material );
    glBindTexture(GL_TEXTURE_2D, agua.textureID);
    glCallList( agua.terrainList );
    glDisable(GL_BLEND);
    glPopMatrix();
    
    
*/
    
    
    
    
    
    /*texto fps*/
 //   RenderText(fpstex, arialfont, 0, 0, &fontColor, GL_FALSE);
    
    
    /*SkyBox*/
    glPushMatrix();
    RenderSkybox(&skybox, &skyboxBox, &skyboxColor);
    glPopMatrix();
    
    

    

    
  
  
    
    
    
    //**texturitas!!!**//
    
    
    /* subacuatica*/
    
    
    glPushMatrix();
    

    //glLoadIdentity();
    glEnable(GL_BLEND);
    SetMaterial(&aguaMtrl);
    
    glBindTexture(GL_TEXTURE_2D, UnderwaterTex);

    glTranslatef(cam.pos.x, vWater, cam.pos.z);
    glScalef(1000.0f, 1000.0f, 1000.0f);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_MIRRORED_REPEAT);
    //  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER    , );

    
    glBegin(GL_QUADS);
    //Cara posterior
    
    
    
    glNormal3f( 0.0f,  1.0f, 0.0f);

    
    glTexCoord2f    ( 0.0f,  1.0f + movWater);
    glVertex3f      (-1.0f,  0.0f, -1.0f);
    glTexCoord2f    ( 0.0f,  0.0f + movWater);
    glVertex3f      ( 1.0f,  0.0f, -1.0f);
    glTexCoord2f    ( 1.0f,  0.0f + movWater);
    glVertex3f      ( 1.0f,  0.0f,  1.0f);
    glTexCoord2f    ( 1.0f,  1.0f + movWater);
    glVertex3f      (-1.0f,  0.0f,  1.0f);

    glEnd();
 
    glDisable(GL_BLEND);

    
    glPopMatrix();
    
    //_______________//
    //Transparencia


    
    
    
    
    /*HUD*/
    Begin2D(WIDTH, HEIGHT);
    


    
    if ( !renderUnderwater){
            }
    
    if (under){
        //glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
        Render2DTexture( UnderwaterTex, 0, 0, WIDTH, HEIGHT );
    }
    
    
    //RENDER DEL MAPA Y EL DOT
    glPushMatrix();
    glTranslatef(WIDTH*0.79 , HEIGHT * 0.79, 0);
    Render2DTexture( mapTex, 0, 0, mapWidth, mapHeight );
    Render2DTexture( dotTex, dotX, dotZ, dotX+10, dotZ+10  );

    glPopMatrix();
    Render2DTexture(hudNull, 0, 0, WIDTH, HEIGHT);
    Render2DTexture(oxBar, 0, 0, ox * 10.0f, 50.0f);
    End2D();


    
    
    
    
    
    
    
    /* Ejecutar comandos en cola */
    glFlush();
    
    /* BackBuffer=FrontBuffer(flip) */
    SDL_GL_SwapBuffers();
}
Beispiel #3
0
/*** Procesamiento de la lógica del juego ***/
void Logic( float elapsed )
{
    
//    ACC = MulVector(ACC, 5);

    vTerrain = GetHeight( &terrain , cam.pos.x, cam.pos.z ) + altura;
  //  sprintf(fpstex, "%d fps", CalculateFPS(elapsed));
    
    /*Cámara*/
    
    
    // correr
    if (Brun && (cam.pos.y <= vTerrain || under)){
        //  MulVector(VEL, 1.5f);
        run = 3.5f;
    }
    else if (Brun == GL_FALSE && (cam.pos.y <= vTerrain || under)){
        run = 1.0f;
    }
    
    // confirma si esta debajo del agua
    if (cam.pos.y <= vWater)
        under = GL_TRUE;
    else
        under = GL_FALSE;
    
    
    
    //debajo del agua
    
    if (under){
        velocityAgua   = 0.3f;
        
        if (abs(VEL.x) <velocity * 0.3){
            //VEL.x = 10.0;
            ACC.x = 0.0f; //aqui agrego la corriente
        }
        else
            ACC.x = 0.0f;

    }
    else{
        velocityAgua   = 1.0f;
//        VEL.z = 150.0f;
        ACC.x = 0.0f;
        VEL.x = 0.0f;
    }
           
    
    /*
     //bool
(runState ? 0.5f : 1.0f)
     */
 
    if( cam.walk ){
        //VEL.z = velocity * run * velocityAgua;
        Walk( &cam,velocity * run * velocityAgua * elapsed, GL_TRUE);
    }
    if( cam.walkinv ){
        //VEL.z = -velocity * 0.5 * run  * velocityAgua;
        Walk( &cam, -velocity * 0.5 * run  * velocityAgua* elapsed, GL_TRUE);
    }
    if( cam.strafe ){
        //VEL.x = velocity * 0.8 * run * velocityAgua;
        Strafe( &cam, velocity * 0.8 * run * velocityAgua * elapsed, GL_TRUE);
    }    
    if( cam.strafeinv ){
       // VEL.x = -velocity * 0.8 * run * velocityAgua;
        Strafe( &cam, -velocity * 0.8 * run * velocityAgua * elapsed, GL_TRUE);
	}
    
    
/*
    if( cam.walk ){
        VEL.z = velocity * run * velocityAgua;
        Walk( &cam,VEL.z * elapsed, GL_TRUE);
    }else if (cam.pos.y <= vTerrain)
        VEL.z = 0.0f;
    
    if( cam.walkinv ){
        VEL.z = -velocity * run  * velocityAgua;
        Walk( &cam,VEL.z * elapsed, GL_TRUE);
    }else if (cam.pos.y <= vTerrain)
        VEL.z = 0.0f;
    
    if( cam.strafe ){
        VEL.x = velocity * run * velocityAgua;
        Strafe( &cam, VEL.x * elapsed, GL_TRUE);
    }else if (cam.pos.y <= vTerrain)
        VEL.x = 0.0f;
    
    if( cam.strafeinv ){
        VEL.x = -velocity * run * velocityAgua;
        Strafe( &cam, VEL.x * elapsed, GL_TRUE);
	}else if (cam.pos.y <= vTerrain)
        VEL.x = 0.0f;
    
  */
    
    //  LOCALIZACION EN MAPA
    dotX = mapWidth * (cam.pos.x / ( 64.0f * 50.0f));
	dotZ = mapHeight * (cam.pos.z / ( 64.0f * 50.0f));

	
    

    
    //fisicas
    VEL = SumVector ( VEL, MulVector ( ACC , elapsed ) );
    //POS = SumVector ( POS, MulVector ( VEL , elapsed ) );

    cam.pos.x = ( cam.pos.x + (VEL.x * elapsed ) );
    //cam.pos.y = ( cam.pos.y + (VEL.y * elapsed ) );
    // caidas y corriente
    
    
    if (under){
        cam.pos.y = cam.pos.y + (VEL.y * 0.03 * run * elapsed );
        cam.pos.x = cam.pos.x + (VEL.x * elapsed);
    }
    else{
        cam.pos.y = cam.pos.y + (VEL.y * velocityAgua * run * elapsed );
        //cam.pos.z = cam.pos.z + (VEL.z * elapsed);
    }
    
     
     
    if (jump && cam.pos.y<= vTerrain) {
        VEL.y = 40.0f;
        jump = GL_FALSE;
    }else if (jump && (cam.pos.y <= vWater + (altura * 0.1)) ){
        
            // VEL.x = -velocity * 0.8 * run * velocityAgua;
            Fly( &cam, velocity * 0.2 * run * elapsed, GL_TRUE);
            VEL.y = 0.0f;
        if (cam.pos.y > vWater)
            cam.pos.y = vWater + (altura * 0.1f);
        
        /*
        if (cam.pos.y  > vWater -  altura){
            VEL.y = 0.0f;
            cam.pos.y = vWater;

}*/

    }
//OXIGENO
    
    if ((( (Brun && (cam.walk || cam.walkinv || cam.strafe || cam.strafeinv)))  || under) && !oxIn)
        ox -= elapsed;
    else
        ox += 0.2 * elapsed;
    
    if ( ox < 0.0f || oxIn)
        oxIn = GL_FALSE;
    
    if (ox < 0.0f) {
        oxIn = GL_FALSE;
        ox = 0.0f;
    }
    if (ox > oxlevel){
        oxIn = GL_FALSE;
        ox = oxlevel;
    }
    
    
    
//ATAQUES CON LA ESPADA...
    if (atk1){
        if (angX > -70) {
        angX -= 360.0f* elapsed;
        }
        
        if (angZ < 90) {
            angZ += 360.0f* elapsed;
        }else{
        
        angX=0.0f;
        angZ = 0.0f;
            atk1= GL_FALSE;
            
        }
        /*
        if (angZ > 500) {
            angZ -= 360.0f* elapsed;
        }*/



    }
    
    //mueve textura
    movWater +=  0.4f * (elapsed);

    
    
    //no sobrepasa el limite del suelo
    if (cam.pos.y <= vTerrain)
        cam.pos.y = vTerrain;
    
    
    
	
}