src/viewport.cpp

   1 /*********************************
   2 ** Tsunagari Tile Engine        **
   3 ** viewport.cpp                 **
   4 ** Copyright 2011-2012 OmegaSDG **
   5 *********************************/
   6
   7 #include <Gosu/Graphics.hpp> // for Gosu::screenWidth/Height()
   8 #include <Gosu/Math.hpp>
   9
  10 #include "area.h"
  11 #include "vec.h"
  12 #include "viewport.h"
  13 #include "window.h"
  14
  15
  16 Viewport::Viewport(icoord vsize)
  17         : off(0, 0),
  18           virtRes(vsize.x, vsize.y),
  19           mode(TM_MANUAL),
  20           area(NULL)
  21 {
  22         double width = (double)Gosu::screenWidth();
  23         double height = (double)Gosu::screenHeight();
  24         aspectRatio = width / height;
  25 }
  26
  27 Viewport::~Viewport()
  28 {
  29 }
  30
  31
  32 void Viewport::tick(unsigned long)
  33 {
  34         update();
  35 }
  36
  37 void Viewport::turn()
  38 {
  39         update();
  40 }
  41
  42 rvec2 Viewport::getMapOffset() const
  43 {
  44         return off;
  45 }
  46
  47 rvec2 Viewport::getLetterboxOffset() const
  48 {
  49         return addLetterboxOffset(rvec2(0.0, 0.0));
  50 }
  51
  52 rvec2 Viewport::getScale() const
  53 {
  54         const GameWindow& window = GameWindow::instance();
  55         rvec2 letterbox = getLetterbox();
  56         rvec2 physRes = rvec2(
  57                 (double)window.width(),
  58                 (double)window.height()
  59         );
  60
  61         return rvec2(
  62                 physRes.x / virtRes.x * (1 - letterbox.x),
  63                 physRes.y / virtRes.y * (1 - letterbox.y)
  64         );
  65 }
  66
  67 rvec2 Viewport::getPhysRes() const
  68 {
  69         const GameWindow& window = GameWindow::instance();
  70         return rvec2(
  71                 (double)window.width(),
  72                 (double)window.height()
  73         );
  74 }
  75
  76 rvec2 Viewport::getVirtRes() const
  77 {
  78         return virtRes;
  79 }
  80
  81 // Immediatly center render offset. Stop any tracking.
  82 void Viewport::jumpToPt(ivec2 pt)
  83 {
  84         jumpToPt(rvec2((double)pt.x, (double)pt.y));
  85 }
  86
  87 void Viewport::jumpToPt(rvec2 pt)
  88 {
  89         mode = TM_MANUAL;
  90         off = offsetForPt(pt);
  91 }
  92
  93 void Viewport::jumpToEntity(const Entity* e)
  94 {
  95         mode = TM_MANUAL; // API implies mode change.
  96         _jumpToEntity(e);
  97 }
  98
  99
 100 // Continuously follow.
 101 void Viewport::trackEntity(const Entity* e)
 102 {
 103         mode = TM_FOLLOW_ENTITY;
 104         targete = e;
 105 }
 106
 107
 108 void Viewport::setArea(const Area* a)
 109 {
 110         area = a;
 111 }
 112
 113
 114 void Viewport::update()
 115 {
 116         switch (mode) {
 117         case TM_MANUAL:
 118                 // Do nothing.
 119                 break;
 120         case TM_FOLLOW_ENTITY:
 121                 _jumpToEntity(targete);
 122                 break;
 123         };
 124 }
 125
 126 void Viewport::_jumpToEntity(const Entity* e)
 127 {
 128         rcoord pos = e->getPixelCoord();
 129         ivec2 td = area->getTileDimensions();
 130         rvec2 center = rvec2(
 131                 pos.x + td.x/2,
 132                 pos.y + td.y/2
 133         );
 134         off = offsetForPt(center);
 135 }
 136
 137
 138 rvec2 Viewport::getLetterbox() const
 139 {
 140         rvec2 physRes = getPhysRes();
 141         double physAspect = physRes.x / physRes.y;
 142         double virtAspect = virtRes.x / virtRes.y;
 143
 144         if (physAspect > virtAspect) {
 145                 // Letterbox cuts off left-right.
 146                 double cut = 1 - virtAspect / physAspect;
 147                 return rvec2(cut, 0);
 148         }
 149         else {
 150                 // Letterbox cuts off top-bottom.
 151                 double cut = 1 - physAspect / virtAspect;
 152                 return rvec2(0, cut);
 153         }
 154 }
 155
 156 rvec2 Viewport::offsetForPt(rvec2 pt) const
 157 {
 158         return boundToArea(centerOn(pt));
 159 }
 160
 161 rvec2 Viewport::centerOn(rvec2 pt) const
 162 {
 163         return pt - virtRes / 2;
 164 }
 165
 166 rvec2 Viewport::boundToArea(rvec2 pt) const
 167 {
 168         icoord ad = area->getDimensions();
 169         ivec2 td = area->getTileDimensions();
 170         double areaWidth = ad.x * td.x;
 171         double areaHeight = ad.y * td.y;
 172         bool loopX = area->loopsInX();
 173         bool loopY = area->loopsInY();
 174
 175         return rvec2(
 176                 boundDimension(virtRes.x, areaWidth,  pt.x, loopX),
 177                 boundDimension(virtRes.y, areaHeight, pt.y, loopY)
 178         );
 179 }
 180
 181 double Viewport::boundDimension(double screen, double area, double pt,
 182                                 bool loop) const
 183 {
 184         // Since looping areas continue without bound, this is a no-op.
 185         if (loop)
 186                 return pt;
 187
 188         // If the Area is smaller than the screen, center the Area. Otherwise,
 189         // allow the screen to move to the edge of the Area, but not past.
 190         double wiggleRoom = area - screen;
 191         return wiggleRoom <= 0 ?
 192                wiggleRoom/2 :
 193                Gosu::boundBy(pt, 0.0, wiggleRoom);
 194 }
 195
 196 rvec2 Viewport::addLetterboxOffset(rvec2 pt) const
 197 {
 198         rvec2 physRes = getPhysRes();
 199         rvec2 letterbox = getLetterbox();
 200         return pt - letterbox * physRes / 2;
 201 }
 202