camera.c

Go to the documentation of this file.

/*
 * See Licensing and Copyright notice in naev.h
 */

#include "naev.h"
 
#include "camera.h"
 
#include "background.h"
#include "conf.h"
#include "gui.h"
#include "nebula.h"
#include "ntracing.h"
#include "pause.h"
#include "player.h"
#include "sound.h"
#include "space.h"
 
#define CAMERA_DIR ( M_PI / 2. )
 
static unsigned int camera_followpilot = 0; 
static int zoom_override = 0; 
/* Current camera position. */
static double camera_Z = 1.; 
static double camera_X = 0.; 
static double camera_Y = 0.; 
static double camera_DX =
   0.; 
static double camera_DY =
   0.; 
static double camera_VX = 0.;
static double camera_VY = 0.;
/* Old is used to compensate pilot movement. */
static double old_X = 0.; 
static double old_Y = 0.; 
/* Target is used why flying over with a target set. */
static double target_Z         = 0.; 
static double target_X         = 0.; 
static double target_Y         = 0.; 
static int    camera_fly       = 0;  
static double camera_flyspeed  = 0.; 
static double camera_zoomspeed = 0.; 
 
/*
 * Prototypes.
 */
static void cam_updateFly( double x, double y, double dt );
static void cam_updatePilot( Pilot *follow, double dt );
static void cam_updatePilotZoom( const Pilot *follow, const Pilot *target,
                                 double dt );
static void cam_updateManualZoom( double dt );

void cam_zoomOverride( int enable )
{
   zoom_override = enable;
}

void cam_setZoom( double zoom )
{
   camera_Z = CLAMP( conf.zoom_far, conf.zoom_near, zoom );
}

void cam_setZoomTarget( double zoom, double speed )
{
   target_Z         = CLAMP( conf.zoom_far, conf.zoom_near, zoom );
   camera_zoomspeed = speed;
}

double cam_getZoom( void )
{
   return camera_Z;
}

double cam_getZoomTarget( void )
{
   return target_Z;
}

void cam_getPos( double *x, double *y )
{
   *x = camera_X;
   *y = camera_Y;
}

void cam_getDPos( double *dx, double *dy )
{
   *dx = camera_DX;
   *dy = camera_DY;
}

void cam_getVel( double *vx, double *vy )
{
   *vx = camera_VX;
   *vy = camera_VY;
}

void cam_vel( double vx, double vy )
{
   camera_VX = vx;
   camera_VY = vy;
}

void cam_setTargetPilot( unsigned int follow, int soft_over )
{
   double dir;
 
   /* Set the target. */
   camera_followpilot = follow;
   dir                = CAMERA_DIR;
 
   /* Set camera if necessary. */
   if ( !soft_over ) {
      if ( follow != 0 ) {
         Pilot *p = pilot_get( follow );
         if ( p != NULL ) {
            double x, y;
            dir      = p->solid.dir;
            x        = p->solid.pos.x;
            y        = p->solid.pos.y;
            camera_X = x;
            camera_Y = y;
            old_X    = x;
            old_Y    = y;
         }
      }
      camera_fly = 0;
   } else {
      old_X           = camera_X;
      old_Y           = camera_Y;
      camera_fly      = 1;
      camera_flyspeed = (double)soft_over;
   }
   sound_updateListener( dir, camera_X, camera_Y, 0., 0. );
}

void cam_setTargetPos( double x, double y, int soft_over )
{
   /* Disable pilot override. */
   camera_followpilot = 0;
 
   /* Handle non soft. */
   if ( !soft_over ) {
      camera_X   = x;
      camera_Y   = y;
      old_X      = x;
      old_Y      = y;
      camera_fly = 0;
   } else {
      target_X        = x;
      target_Y        = y;
      old_X           = camera_X;
      old_Y           = camera_Y;
      camera_fly      = 1;
      camera_flyspeed = (double)soft_over;
   }
   sound_updateListener( CAMERA_DIR, camera_X, camera_Y, 0., 0. );
}

int cam_getTarget( void )
{
   return camera_followpilot;
}

void cam_update( double dt )
{
   NTracingZone( _ctx, 1 );
   Pilot *p;
   double ox, oy;
 
   /* Calculate differential. */
   camera_DX = camera_X;
   camera_DY = camera_Y;
   ox        = old_X;
   oy        = old_Y;
 
   /* Going to position. */
   p = NULL;
   if ( camera_fly ) {
      if ( camera_followpilot != 0 ) {
         p = pilot_get( camera_followpilot );
         if ( p == NULL ) {
            camera_followpilot = 0;
            camera_fly         = 0;
         } else {
            cam_updateFly( p->solid.pos.x, p->solid.pos.y, dt );
            cam_updatePilotZoom( p, NULL, dt );
         }
      } else
         cam_updateFly( target_X, target_Y, dt );
   } else {
      /* Track pilot. */
      if ( camera_followpilot != 0 ) {
         p = pilot_get( camera_followpilot );
         if ( p == NULL )
            camera_followpilot = 0;
         else
            cam_updatePilot( p, dt );
      }
   }
 
   /* Update manual zoom. */
   if ( conf.zoom_manual || zoom_override )
      cam_updateManualZoom( dt );
 
   /* Set the sound. */
   if ( ( p == NULL ) || !SOUND_PILOT_RELATIVE ) {
      double dx = dt * ( ox - camera_X );
      double dy = dt * ( oy - camera_Y );
      sound_updateListener( CAMERA_DIR, camera_X, camera_Y, dx, dy );
   } else {
      sound_updateListener( p->solid.dir, p->solid.pos.x, p->solid.pos.y,
                            p->solid.vel.x, p->solid.vel.y );
   }
 
   /* Compute the position differential. */
   camera_DX = ( camera_X - camera_DX );
   camera_DY = ( camera_Y - camera_DY );
 
   /* Compute velocity. */
   if ( dt > DOUBLE_TOL ) {
      camera_VX = camera_DX / dt;
      camera_VY = camera_DY / dt;
   }
 
   NTracingZoneEnd( _ctx );
}

static void cam_updateFly( double x, double y, double dt )
{
   double k, dx, dy, max;
 
   max = camera_flyspeed * dt;
   k   = 25. * dt;
   dx  = ( x - camera_X ) * k;
   dy  = ( y - camera_Y ) * k;
   if ( pow2( dx ) + pow2( dy ) > pow2( max ) ) {
      double a = atan2( dy, dx );
      double r = max;
      dx       = r * cos( a );
      dy       = r * sin( a );
   }
   camera_X += dx;
   camera_Y += dy;
   background_moveDust( -dx, -dy );
 
   /* Stop within 100 pixels. */
   if ( FABS( ( pow2( camera_X ) + pow2( camera_Y ) ) -
              ( pow2( x ) + pow2( y ) ) ) < 100 * 100 ) {
      old_X      = camera_X;
      old_Y      = camera_Y;
      camera_fly = 0;
   }
}

static void cam_updatePilot( Pilot *follow, double dt )
{
   Pilot *target;
   double dir, k;
   double x, y, dx, dy, mx, my, targ_x, targ_y, bias_x, bias_y, vx, vy;
 
   /* Get target. */
   if ( !pilot_isFlag( follow, PILOT_HYPERSPACE ) &&
        ( follow->target != follow->id ) )
      target = pilot_getTarget( follow );
   else
      target = NULL;
 
   /* Real diagonal might be a bit too harsh since it can cut out the ship,
    * we'll just use the largest of the two. */
   /*diag2 = pow2(SCREEN_W) + pow2(SCREEN_H);*/
   /*diag2 = pow2( MIN(SCREEN_W, SCREEN_H) );*/
   const double diag2 = 100 * 100;
   x                  = follow->solid.pos.x;
   y                  = follow->solid.pos.y;
 
   /* Compensate player movement. */
   mx = x - old_X;
   my = y - old_Y;
   camera_X += mx;
   camera_Y += my;
 
   /* Set old position. */
   old_X = x;
   old_Y = y;
 
   /* No bias by default. */
   bias_x = 0.;
   bias_y = 0.;
 
   /* Bias towards target. */
   if ( target != NULL ) {
      bias_x += target->solid.pos.x - x;
      bias_y += target->solid.pos.y - y;
   }
 
   /* Bias towards velocity and facing. */
   vx  = follow->solid.vel.x * 1.5;
   vy  = follow->solid.vel.y * 1.5;
   dir = angle_diff( atan2( vy, vx ), follow->solid.dir );
   dir = ( M_PI - FABS( dir ) ) / M_PI; /* Normalize. */
   vx *= dir;
   vy *= dir;
   bias_x += vx;
   bias_y += vy;
 
   /* Limit bias. */
   if ( pow2( bias_x ) + pow2( bias_y ) > diag2 / 2. ) {
      double a = atan2( bias_y, bias_x );
      double r = sqrt( diag2 ) / 2.;
      bias_x   = r * cos( a );
      bias_y   = r * sin( a );
   }
 
   /* Compose the target. */
   targ_x = x + bias_x;
   targ_y = y + bias_y;
 
   /* Head towards target. */
   k  = 0.5 * dt / dt_mod;
   dx = ( targ_x - camera_X ) * k;
   dy = ( targ_y - camera_Y ) * k;
   background_moveDust( -( mx + dx ), -( my + dy ) );
 
   /* Update camera. */
   camera_X += dx;
   camera_Y += dy;
 
   /* Update zoom. */
   cam_updatePilotZoom( follow, target, dt );
}

static void cam_updateManualZoom( double dt )
{
   double d;
 
   if ( player.p == NULL )
      return;
 
   /* Gradually zoom in/out. */
   d = CLAMP( -camera_zoomspeed, camera_zoomspeed, target_Z - camera_Z );
   d *= dt / dt_mod; /* Remove dt dependence. */
   if ( d < 0. )     
      d *= 2.;
   camera_Z = CLAMP( conf.zoom_far, conf.zoom_near, camera_Z + d );
}

static void cam_updatePilotZoom( const Pilot *follow, const Pilot *target,
                                 double dt )
{
   double d, x, y, z, tz, dx, dy;
   double zfar, znear;
   double c;
 
   /* Must have auto zoom enabled. */
   if ( conf.zoom_manual || zoom_override )
      return;
 
   /* Minimum depends on velocity normally.
    *
    * w*h = A, cte    area constant
    * w/h = K, cte    proportion constant
    * d^2 = A, cte    geometric longitud
    *
    * A_v = A*(1+v/d)   area of view is based on speed
    * A_v / A = (1 + v/d)
    *
    * z = A / A_v = 1. / (1 + v/d)
    */
   d     = sqrt( SCREEN_W * SCREEN_H );
   znear = MIN( conf.zoom_near, 1. / ( 0.8 + VMOD( follow->solid.vel ) / d ) );
 
   /* Maximum is limited by nebulae. */
   if ( cur_system->nebu_density > 0. ) {
      c    = MIN( SCREEN_W, SCREEN_H ) / 2;
      zfar = CLAMP( conf.zoom_far, conf.zoom_near, c / nebu_getSightRadius() );
   } else
      zfar = conf.zoom_far;
   znear = MAX( znear, zfar );
 
   /*
    * Set Zoom to pilot target.
    */
   z = cam_getZoom();
   if ( pilot_isFlag( follow, PILOT_STEALTH ) ) {
      tz = zfar;
   } else {
      if ( target != NULL ) {
         /* Get current relative target position. */
         gui_getOffset( &x, &y );
         x += target->solid.pos.x - follow->solid.pos.x;
         y += target->solid.pos.y - follow->solid.pos.y;
 
         /* Get distance ratio. */
         dx = ( SCREEN_W / 2. ) / ( FABS( x ) + 2. * target->ship->size );
         dy = ( SCREEN_H / 2. ) / ( FABS( y ) + 2. * target->ship->size );
 
         /* Get zoom. */
         tz = MIN( dx, dy );
      } else
         tz = znear; /* Aim at in. */
   }
 
   /* Gradually zoom in/out. */
   d = CLAMP( -conf.zoom_speed, conf.zoom_speed, tz - z );
   d *= dt / dt_mod; /* Remove dt dependence. */
   if ( d < 0. )     
      d *= 2.;
   camera_Z = CLAMP( zfar, znear, z + d );
}