zoom.h

// Aseprite Render Library
// Copyright (c) 2019 Igara Studio S.A.
// Copyright (c) 2001-2016 David Capello
//
// This file is released under the terms of the MIT license.
// Read LICENSE.txt for more information.

#ifndef RENDER_ZOOM_H_INCLUDED
#define RENDER_ZOOM_H_INCLUDED
#pragma once

#include "gfx/rect.h"

namespace render {

class Zoom {
public:
  Zoom(int num, int den);

  double scale() const { return static_cast<double>(m_num) / static_cast<double>(m_den); }

  // This value isn't used in operator==() or operator!=()
  double internalScale() const { return m_internalScale; }

  template<typename T>
  T apply(T x) const
  {
    return (x * m_num / m_den);
  }

  template<typename T>
  T remove(T x) const
  {
    return (x * m_den / m_num);
  }

  int removeCeiling(int x) const;

  gfx::Rect apply(const gfx::Rect& r) const;
  gfx::Rect remove(const gfx::Rect& r) const;

  bool in();
  bool out();

  // Returns an linear zoom scale. This position can be incremented
  // or decremented to get a new zoom value.
  int linearScale() const;

  bool operator==(const Zoom& other) const { return m_num == other.m_num && m_den == other.m_den; }

  bool operator!=(const Zoom& other) const { return !operator==(other); }

  // Returns true if this zoom level can be handled by simpler
  // rendering techniques.
  bool isSimpleZoomLevel() const { return (m_num == 1 || m_den == 1); }

  static Zoom fromScale(double scale);
  static Zoom fromLinearScale(int i);
  static int linearValues();

private:
  static int findClosestLinearScale(double scale);

  int m_num;
  int m_den;

  // Internal scale value used for precise zooming purposes.
  double m_internalScale;
};

template<>
inline int Zoom::remove(int x) const
{
  if (x < 0)
    return (x * m_den / m_num) - 1;
  return (x * m_den / m_num);
}

inline int Zoom::removeCeiling(int x) const
{
  int v = x * m_den;
  if (x < 0)
    return (v / m_num);
  return (v / m_num) + (v % m_num != 0);
}

inline gfx::Rect Zoom::apply(const gfx::Rect& r) const
{
  return gfx::Rect(apply(r.x),
                   apply(r.y),
                   apply(r.x + r.w) - apply(r.x),
                   apply(r.y + r.h) - apply(r.y));
}

inline gfx::Rect Zoom::remove(const gfx::Rect& r) const
{
  return gfx::Rect(remove(r.x),
                   remove(r.y),
                   remove(r.x + r.w) - remove(r.x),
                   remove(r.y + r.h) - remove(r.y));
}

} // namespace render

#endif // RENDER_ZOOM_H_INCLUDED