intro.c

Go to the documentation of this file.

/*
 * See Licensing and Copyright notice in naev.h
 */
#include "SDL.h"
 
#include "naev.h"
#include "intro.h"
 
#include "array.h"
#include "conf.h"
#include "font.h"
#include "log.h"
#include "menu.h"
#include "music.h"
#include "ndata.h"
#include "nstring.h"
#include "toolkit.h"
 
#define INTRO_SPEED        30. 
#define SIDE_MARGIN       100. 
#define IMAGE_WIDTH       300. 
typedef struct intro_img_t_ {
   glTexture *tex;     /* Image. */
   double x, y, w, h;  /* Position. */
   glColour c;         /* Alpha channel for fading. */
   double fade_rate;   /* Positive for fade-in, negative for fade-out. */
} intro_img_t;
 
typedef enum intro_opcode_t_ {
   INTRO_TEXT,          
   INTRO_FADEIN,        
   INTRO_FADEOUT,       
} intro_opcode_t;
 
typedef struct intro_cmd_t_ {
   intro_opcode_t opcode;
   const char *operand;
} intro_cmd_t;
 
/*
 * State.
 */
static intro_cmd_t *intro_cmds = NULL;   
static char *intro_buf = NULL;           
static glFont intro_font;                
static int has_side_gfx = 0;             /* Determines how wide to make the text. */
 
/*
 * Prototypes.
 */
static int intro_load( const char *text );
static void intro_cleanup (void);
static int intro_event_handler( int *stop, double *offset, double *vel );
static void initialize_image( intro_img_t *img );
static void load_image( intro_img_t *img, const char *img_file );
static void intro_fade_image_in( intro_img_t *side, intro_img_t *transition, const char *img_file );
static int  intro_draw_text( char **const sb_list, int sb_size, int sb_index, double offset, double line_height );
 
static int intro_load( const char *text )
{
   size_t intro_size;
   char *cur_line, *rest_of_file;
 
   has_side_gfx = 0;
 
   /* Load text. */
   intro_buf = ndata_read( text, &intro_size );
 
   /* Create intro font. */
   gl_fontInit( &intro_font, _(FONT_MONOSPACE_PATH), conf.font_size_intro, FONT_PATH_PREFIX, 0 );
 
   intro_cmds = array_create( intro_cmd_t );
   rest_of_file = intro_buf;
   while (rest_of_file) {
      cur_line = rest_of_file;
      rest_of_file = strchr(cur_line, '\n');
      /* If there's a next line, split the string and point rest_of_file to it. */
      if (rest_of_file != NULL) {
         /* Check for CRLF endings -- if present, zero both parts. */
         if (rest_of_file > cur_line && *(rest_of_file-1) == '\r')
            *(rest_of_file-1) = '\0';
         *rest_of_file++ = '\0';
      }
 
      if (strncmp( cur_line, "[fadein ", 8 ) == 0) {
         array_grow( &intro_cmds ).opcode = INTRO_FADEIN;
         array_back( intro_cmds ).operand = &cur_line[8];
         /* Zap the closing square-bracket. */
         cur_line[strlen( cur_line ) - 1] = '\0';
         /* Mark that there are graphics. */
         has_side_gfx = 1;
      }
      else if (strncmp( cur_line, "[fadeout]", 9 ) == 0)
         array_grow( &intro_cmds ).opcode = INTRO_FADEOUT;
      else {
         array_grow( &intro_cmds ).opcode = INTRO_TEXT;
         /* Translate the line if it's not the empty string. */
         array_back( intro_cmds ).operand = (cur_line[0] == '\0' ? cur_line : _(cur_line));
      }
   }
 
   return 0;
}
 
static void intro_cleanup (void)
{
   /* Free memory. */
   array_free(intro_cmds);
   intro_cmds = NULL;
   free(intro_buf);
   intro_buf = NULL;
   gl_freeFont(&intro_font);
}
 
static void initialize_image( intro_img_t *img )
{
   img->tex = NULL;
   img->c.r = 1.0;
   img->c.g = 1.0;
   img->c.b = 1.0;
   img->c.a = 1.0;
   img->fade_rate = 0.0;
}
 
static void load_image( intro_img_t *img, const char *img_file )
{
   img->tex = gl_newImage( img_file, 0 );
   img->w = MIN( img->tex->w, IMAGE_WIDTH );
   img->h = img->tex->h * img->w / img->tex->w;
   img->x = (IMAGE_WIDTH + SIDE_MARGIN - img->w) / 2.0;
   img->y = (double)SCREEN_H / 2.0 - (img->h / 2.0);
   img->c.a = 0.0;
   img->fade_rate = 0.1;
}
 
static void intro_fade_image_in( intro_img_t *side, intro_img_t *transition,
                                 const char *img_file )
{
   if (NULL == side->tex)
      load_image( side, img_file ); /* Simple fade-in. */
   else {
      /*
       * Transition or on-deck. The difference is whether one image is
       * replacing the other (transition), or whether the first must fade out
       * completely before the second comes in (on-deck).
       *
       * We can determine which is the case by seeing whether [fadeout] has been
       * called. I.e., is side->fade_rate < 0?
       */
      if (NULL != transition->tex) {
         /* Scrolling is happening faster than fading... */
         WARN( _("Intro scrolling too fast!") );
         gl_freeTexture( transition->tex );
      }
      load_image( transition, img_file );
      if (side->fade_rate < 0.0)
         transition->fade_rate = 0.0; /* put an image on deck. */
      else {
         /* transition. */
         side->fade_rate = -0.1; /* begin fading out. */
         side->c.a = 0.99;
      }
   }
}
 
static int intro_event_handler( int *stop, double *offset, double *vel )
{
   SDL_Event event; /* user key-press, mouse-push, etc. */
   while (SDL_PollEvent(&event)) {
      if (event.type == SDL_QUIT) {
         if (naev_isQuit() || menu_askQuit()) {
            naev_quit();
            return 1;
         }
      }
 
      if (event.type == SDL_WINDOWEVENT &&
            event.window.event == SDL_WINDOWEVENT_RESIZED) {
         naev_resize();
         continue;
      }
 
      if (event.type != SDL_KEYDOWN)
         continue;
 
      /* Escape skips directly. */
      if (event.key.keysym.sym == SDLK_ESCAPE) {
         *stop = 1;
         break;
      }
 
      /* Slow down the text. */
      else if (event.key.keysym.sym == SDLK_UP) {
         *vel -= 8.0;
         if (*vel < 0.0)
            *vel = 0.0;
      }
 
      /* Speed up the text. */
      else if (event.key.keysym.sym == SDLK_DOWN) {
         *vel += 8.0;
         if (*vel > 100.0)
            *vel = 100.0;
      }
 
      /* Jump down. */
      else if ((event.key.keysym.sym == SDLK_SPACE) ||
            (event.key.keysym.sym == SDLK_RETURN))
         *offset += 100;
 
      /* Jump up. */
      else if (event.key.keysym.sym == SDLK_BACKSPACE)
         *offset -= 100;
 
      /* User is clearly flailing on keyboard. */
      else
         *vel = 16.;
   }
   return 0;
}
 
static int intro_draw_text( char **const sb_list, int sb_size, int sb_index, double offset, double line_height )
{
   double       x, y; /* render position. */
   int          i;
   register int stop = 1;
 
   x = SIDE_MARGIN;
   if (has_side_gfx)
      x += IMAGE_WIDTH;
 
   i = sb_index;
   y = SCREEN_H + offset - line_height;
   do {
      if ( sb_list[ i ] != NULL ) {
         stop = 0;
         gl_printRaw( &intro_font, x, y, &cFontGreen, -1, sb_list[ i ] );
      }
 
      y -= line_height;
      i = ( i + 1 ) % sb_size;
   } while ( i != sb_index );
 
   return stop;
}
 
int intro_display( const char *text, const char *mus )
{
   double       offset;           /* distance from bottom of the top line. */
   double       line_height;      /* # pixels per line. */
   int          lines_per_screen; /* max appearing lines on the screen. */
   char **      sb_arr;           /* array of lines to render. */
   int          sb_index;         /* Position in the line array. */
   double       vel  = 16.;       /* velocity: speed of text. */
   int          stop = 0;         /* stop the intro. */
   unsigned int tcur, tlast, tlag;/* timers. */
   double       delta;            /* time diff from last render to this one. */
   int          cmd_index = 0;   /* index into the big list of intro lines. */
   intro_img_t  side_image;       /* image to go along with the text. */
   intro_img_t  transition;       /* image for transitioning. */
   glPrintLineIterator iter;      /* the renderable lines coming from the current text directive. */
 
   /* Load the introduction. */
   if (intro_load(text) < 0)
      return -1;
 
   /* Change music to intro music. */
   if (mus != NULL)
      music_choose(mus);
 
   /* We need to clear key repeat to avoid infinite loops. */
   toolkit_clearKey();
 
   /* Do a few calculations to figure out how many lines can be present on the
      screen at any given time. */
   line_height = (double)intro_font.h * 1.3;
   lines_per_screen = (int)(SCREEN_H / line_height + 1.5); /* round up + 1 */
 
   /* Initialize the lines. */
   gl_printLineIteratorInit( &iter, &intro_font, "", SCREEN_W - 2*SIDE_MARGIN - IMAGE_WIDTH );
   (void) gl_printLineIteratorNext( &iter );
   sb_arr   = calloc( lines_per_screen, sizeof( char * ) );
   sb_index = 0;
 
   /* Force the first line to be loaded immediately. */
   offset = line_height;
 
   /* Unset the side image. */
   initialize_image( &side_image );
   initialize_image( &transition );
 
   tlast = SDL_GetTicks();
   while (!stop) {
      tcur = SDL_GetTicks();
      delta = (double)(tcur - tlast) / 1000.;
      tlast = tcur;
 
      /* Increment position. */
      offset += vel * delta;
      while (! (offset < line_height)) {
         /* One line has scrolled off, and another one on. */
         if (gl_printLineIteratorNext( &iter )) {
            free( sb_arr[sb_index] );
            sb_arr[sb_index] = strndup( &iter.text[iter.l_begin], iter.l_end - iter.l_begin );
            offset -= line_height;
            sb_index = ( sb_index + 1 ) % lines_per_screen;
         }
         else if (cmd_index < array_size(intro_cmds)) {
            switch (intro_cmds[cmd_index].opcode) {
            case INTRO_TEXT:
               gl_printLineIteratorInit( &iter, &intro_font, intro_cmds[cmd_index].operand, iter.width );
               break;
            case INTRO_FADEIN:
               intro_fade_image_in( &side_image, &transition, intro_cmds[cmd_index].operand );
               break;
            case INTRO_FADEOUT:
               if (NULL == side_image.tex) {
                  WARN(_("Tried to fade out without an image.") );
                  break;
               }
               side_image.fade_rate = -0.1;
               side_image.c.a = 0.99;
               break;
            }
            ++cmd_index;
         } else {
            free( sb_arr[sb_index] );
            sb_arr[sb_index] = NULL;
            offset -= line_height;
            sb_index = ( sb_index + 1 ) % lines_per_screen;
         }
      } /* while (offset > line_height) */
 
      /* Fade the side image. */
      if (side_image.tex != NULL && side_image.c.a < 1.0) {
         side_image.c.a += delta * vel * side_image.fade_rate;
 
         if (transition.tex != NULL && transition.fade_rate > 0.0)
            transition.c.a += delta * vel * transition.fade_rate;
 
         if (side_image.c.a > 1.0) {
            /* Faded in... */
            side_image.c.a = 1.0;
            side_image.fade_rate = 0.0;
         }
         else if (side_image.c.a < 0.0) {
            /* Faded out... */
            gl_freeTexture( side_image.tex );
            if (transition.tex != NULL) {
               side_image.tex = transition.tex;
               side_image.c.a = transition.c.a;
               side_image.w   = transition.w;
               side_image.h   = transition.h;
               side_image.y   = transition.y;
               side_image.fade_rate = 0.1;
               transition.tex = NULL;
               transition.c.a = 1.0;
            }
            else {
               side_image.c.a = 1.0;
               side_image.tex = NULL;
               side_image.fade_rate = 0.0;
            }
         }
      }
 
      /* Clear stuff. */
      glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
 
      /* Only thing we actually care about updating is music. */
      music_update( delta );
 
      /* Draw text. */
      stop = intro_draw_text( sb_arr, lines_per_screen, sb_index, offset, line_height );
 
      if (NULL != side_image.tex)
         /* Draw the image next to the text. */
         gl_renderScale( side_image.tex, side_image.x, side_image.y,
                       side_image.w, side_image.h, &side_image.c );
 
      if (NULL != transition.tex && transition.c.a > 0.0)
         /* Draw the image in transition. */
         gl_renderScale( transition.tex, transition.x, transition.y,
                       transition.w, transition.h, &transition.c );
 
      /* Display stuff. */
      SDL_GL_SwapWindow( gl_screen.window );
 
      tlag = SDL_GetTicks() - tcur;
      if (tlag < 25) /* No need to burn CPU. Note: swapping may involve a wait for vblank; 25 is 1.5 frames @60fps. */
         SDL_Delay( 25 - tlag );
 
      /* Handle user events. */
      if (intro_event_handler( &stop, &offset, &vel ))
         break;
 
   } /* while (!stop) */
 
   /* free malloc'd memory. */
   free( sb_arr );
   gl_freeTexture( side_image.tex );
   gl_freeTexture( transition.tex );
 
   /* Stop music, normal music will start shortly after. */
   music_stop(0);
 
   /* Clean up after the introduction. */
   intro_cleanup();
 
   return 0;
}