src/object/background.cpp

   1 //  SuperTux
   2 //  Copyright (C) 2006 Matthias Braun <matze@braunis.de>
   3 //
   4 //  This program is free software: you can redistribute it and/or modify
   5 //  it under the terms of the GNU General Public License as published by
   6 //  the Free Software Foundation, either version 3 of the License, or
   7 //  (at your option) any later version.
   8 //
   9 //  This program is distributed in the hope that it will be useful,
  10 //  but WITHOUT ANY WARRANTY; without even the implied warranty of
  11 //  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12 //  GNU General Public License for more details.
  13 //
  14 //  You should have received a copy of the GNU General Public License
  15 //  along with this program.  If not, see <http://www.gnu.org/licenses/>.
  16
  17 #include "object/background.hpp"
  18
  19 #include <iostream>
  20 #include "math/sizef.hpp"
  21 #include "supertux/globals.hpp"
  22 #include "supertux/object_factory.hpp"
  23 #include "supertux/sector.hpp"
  24 #include "util/log.hpp"
  25 #include "util/reader.hpp"
  26
  27 #include <stdexcept>
  28
  29 Background::Background() :
  30   alignment(NO_ALIGNMENT),
  31   layer(LAYER_BACKGROUND0),
  32   imagefile_top(),
  33   imagefile(),
  34   imagefile_bottom(),
  35   pos(),
  36   speed(),
  37   speed_y(),
  38   scroll_speed(),
  39   scroll_offset(),
  40   image_top(),
  41   image(),
  42   image_bottom()
  43 {
  44 }
  45
  46 Background::Background(const Reader& reader) :
  47   alignment(NO_ALIGNMENT),
  48   layer(LAYER_BACKGROUND0),
  49   imagefile_top(),
  50   imagefile(),
  51   imagefile_bottom(),
  52   pos(),
  53   speed(),
  54   speed_y(),
  55   scroll_speed(),
  56   scroll_offset(),
  57   image_top(),
  58   image(),
  59   image_bottom()
  60 {
  61   // read position, defaults to (0,0)
  62   float px = 0;
  63   float py = 0;
  64   reader.get("x", px);
  65   reader.get("y", py);
  66   this->pos = Vector(px,py);
  67
  68   speed = 1.0;
  69   speed_y = 1.0;
  70
  71   std::string alignment_str;
  72   if (reader.get("alignment", alignment_str))
  73   {
  74     if (alignment_str == "left")
  75     {
  76       alignment = LEFT_ALIGNMENT;
  77     }
  78     else if (alignment_str == "right")
  79     {
  80       alignment = RIGHT_ALIGNMENT;
  81     }
  82     else if (alignment_str == "top")
  83     {
  84       alignment = TOP_ALIGNMENT;
  85     }
  86     else if (alignment_str == "bottom")
  87     {
  88       alignment = BOTTOM_ALIGNMENT;
  89     }
  90     else if (alignment_str == "none")
  91     {
  92       alignment = NO_ALIGNMENT;
  93     }
  94     else
  95     {
  96       log_warning << "Background: invalid alignment: '" << alignment_str << "'" << std::endl;
  97       alignment = NO_ALIGNMENT;
  98     }
  99   }
 100
 101   reader.get("scroll-offset-x", scroll_offset.x);
 102   reader.get("scroll-offset-y", scroll_offset.y);
 103
 104   reader.get("scroll-speed-x", scroll_speed.x);
 105   reader.get("scroll-speed-y", scroll_speed.y);
 106
 107   layer = reader_get_layer (reader, /* default = */ LAYER_BACKGROUND0);
 108
 109   if(!reader.get("image", imagefile) || !reader.get("speed", speed))
 110     throw std::runtime_error("Must specify image and speed for background");
 111
 112   set_image(imagefile, speed);
 113   if (!reader.get("speed-y", speed_y))
 114   {
 115     speed_y = speed;
 116   }
 117
 118   if (reader.get("image-top", imagefile_top)) {
 119     image_top = Surface::create(imagefile_top);
 120   }
 121   if (reader.get("image-bottom", imagefile_bottom)) {
 122     image_bottom = Surface::create(imagefile_bottom);
 123   }
 124 }
 125
 126 Background::~Background()
 127 {
 128 }
 129
 130 void
 131 Background::update(float delta)
 132 {
 133   scroll_offset += scroll_speed * delta;
 134 }
 135
 136 void
 137 Background::set_image(const std::string& name, float speed)
 138 {
 139   this->imagefile = name;
 140   this->speed = speed;
 141
 142   image = Surface::create(name);
 143 }
 144
 145 void
 146 Background::draw_image(DrawingContext& context, const Vector& pos)
 147 {
 148   Sizef level(Sector::current()->get_width(), Sector::current()->get_height());
 149   Sizef screen(SCREEN_WIDTH, SCREEN_HEIGHT);
 150   Sizef parallax_image_size = (1.0f - speed) * screen + level * speed;
 151
 152   // FIXME: Implement proper clipping here
 153   int start_x = -parallax_image_size.width  / 2.0f / image->get_width()  - 1;
 154   int end_x   =  parallax_image_size.width  / 2.0f / image->get_width()  + 1;
 155   int start_y = -parallax_image_size.height / 2.0f / image->get_height() - 1;
 156   int end_y   =  parallax_image_size.height / 2.0f / image->get_height() + 1;
 157
 158   switch(alignment)
 159   {
 160     case LEFT_ALIGNMENT:
 161       for(int y = start_y; y <= end_y; ++y)
 162       {
 163         Vector p(pos.x - parallax_image_size.width / 2.0f,
 164                  pos.y + y * image->get_height()  - image->get_height() / 2.0f);
 165         context.draw_surface(image, p, layer);
 166       }
 167       break;
 168
 169     case RIGHT_ALIGNMENT:
 170       for(int y = start_y; y <= end_y; ++y)
 171       {
 172         Vector p(pos.x + parallax_image_size.width / 2.0f - image->get_width(),
 173                  pos.y + y * image->get_height() - image->get_height() / 2.0f);
 174         context.draw_surface(image, p, layer);
 175       }
 176       break;
 177
 178     case TOP_ALIGNMENT:
 179       for(int x = start_x; x <= end_x; ++x)
 180       {
 181         Vector p(pos.x + x * image->get_width() - image->get_width() / 2.0f,
 182                  pos.y - parallax_image_size.height / 2.0f);
 183         context.draw_surface(image, p, layer);
 184       }
 185       break;
 186
 187     case BOTTOM_ALIGNMENT:
 188       for(int x = start_x; x <= end_x; ++x)
 189       {
 190         Vector p(pos.x + x * image->get_width()  - image->get_width() / 2.0f,
 191                  pos.y - image->get_height() + parallax_image_size.height / 2.0f);
 192         context.draw_surface(image, p, layer);
 193       }
 194       break;
 195
 196     case NO_ALIGNMENT:
 197       for(int y = start_y; y <= end_y; ++y)
 198         for(int x = start_x; x <= end_x; ++x)
 199         {
 200           Vector p(pos.x + x * image->get_width()  - image->get_width()/2,
 201                    pos.y + y * image->get_height() - image->get_height()/2);
 202
 203           if (image_top.get() != NULL && (y < 0))
 204           {
 205             context.draw_surface(image_top, p, layer);
 206           }
 207           else if (image_bottom.get() != NULL && (y > 0))
 208           {
 209             context.draw_surface(image_bottom, p, layer);
 210           }
 211           else
 212           {
 213             context.draw_surface(image, p, layer);
 214           }
 215         }
 216       break;
 217   }
 218 }
 219
 220 void
 221 Background::draw(DrawingContext& context)
 222 {
 223   if(image.get() == NULL)
 224     return;
 225
 226   Sizef level_size(Sector::current()->get_width(),
 227                    Sector::current()->get_height());
 228   Sizef screen(SCREEN_WIDTH, SCREEN_HEIGHT);
 229   Sizef translation_range = level_size - screen;
 230   Vector center_offset(context.get_translation().x - translation_range.width  / 2.0f,
 231                        context.get_translation().y - translation_range.height / 2.0f);
 232
 233   // FIXME: We are not handling 'pos'
 234   draw_image(context, Vector(level_size.width / 2.0f, level_size.height / 2.0f) + center_offset * (1.0f - speed));
 235 }
 236
 237 /* EOF */