Transform.h

/*
 * Gamedev Framework (gf)
 * Copyright (C) 2016-2021 Julien Bernard
 *
 * This software is provided 'as-is', without any express or implied
 * warranty.  In no event will the authors be held liable for any damages
 * arising from the use of this software.
 *
 * Permission is granted to anyone to use this software for any purpose,
 * including commercial applications, and to alter it and redistribute it
 * freely, subject to the following restrictions:
 *
 * 1. The origin of this software must not be misrepresented; you must not
 *    claim that you wrote the original software. If you use this software
 *    in a product, an acknowledgment in the product documentation would be
 *    appreciated but is not required.
 * 2. Altered source versions must be plainly marked as such, and must not be
 *    misrepresented as being the original software.
 * 3. This notice may not be removed or altered from any source distribution.
 */
#ifndef GF_TRANSFORM_H
#define GF_TRANSFORM_H

#include <cmath>

#include "CoreApi.h"
#include "Matrix.h"
#include "Rect.h"
#include "Vector.h"

namespace gf {
#ifndef DOXYGEN_SHOULD_SKIP_THIS
inline namespace v1 {
#endif

  struct GF_CORE_API Rotation {
    float cos; 
    float sin; 

    Rotation()
    : cos(1.0f), sin(0.0f)
    {
    }

    Rotation(float angle)
    : cos(std::cos(angle)), sin(std::sin(angle))
    {
    }

    void setAngle(float angle) {
      cos = std::cos(angle);
      sin = std::sin(angle);
    }

    float getAngle() const {
      return std::atan2(sin, cos);
    }
  };

  constexpr
  Vector2f transform(const Rotation& rotation, Vector2f point) {
    return {
      rotation.cos * point.x - rotation.sin * point.y,
      rotation.sin * point.x + rotation.cos * point.y
    };
  }

  constexpr
  Vector2f inverseTransform(const Rotation& rotation, Vector2f point) {
    return {
       rotation.cos * point.x + rotation.sin * point.y,
      -rotation.sin * point.x + rotation.cos * point.y
    };
  }

  struct GF_CORE_API Translation {
    Vector2f offset; 

    Translation()
    : offset(0.0f, 0.0f)
    {
    }

    Translation(Vector2f translationOffset)
    : offset(translationOffset)
    {
    }

    void setOffset(Vector2f newOffset) noexcept {
      offset = newOffset;
    }

    Vector2f getOffset() const noexcept {
      return offset;
    }
  };

  constexpr
  Vector2f transform(const Translation& translation, Vector2f point) {
    return { point.x + translation.offset.x, point.y + translation.offset.y };
  }

  constexpr
  Vector2f inverseTransform(const Translation& translation, Vector2f point) {
    return { point.x - translation.offset.x, point.y - translation.offset.y };
  }

  struct GF_CORE_API Transform {
    Rotation rotation; 
    Translation translation; 

    Transform()
    {
    }

    Transform(float angle, Vector2f offset)
    : rotation(angle), translation(offset)
    {
    }

    Transform(float angle)
    : rotation(angle)
    {
    }

    Transform(Vector2f offset)
    : translation(offset)
    {
    }

    void setAngle(float angle) {
      rotation.setAngle(angle);
    }

    float getAngle() const {
      return rotation.getAngle();
    }

    void setOffset(Vector2f offset) noexcept {
      translation.setOffset(offset);
    }

    Vector2f getOffset() const noexcept {
      return translation.getOffset();
    }

  };

  constexpr
  Vector2f transform(const Transform& trans, Vector2f point) {
    return transform(trans.translation, transform(trans.rotation, point));
  }

  constexpr
  Vector2f inverseTransform(const Transform& trans, Vector2f point) {
    return inverseTransform(trans.rotation, inverseTransform(trans.translation, point));
  }

  // https://en.wikipedia.org/wiki/Homogeneous_coordinates

  constexpr
  Vector2f transform(const Matrix3f& mat, Vector2f point) {
    return { mat.xx * point.x + mat.xy * point.y + mat.xz, mat.yx * point.x + mat.yy * point.y + mat.yz };
  }

  GF_CORE_API RectF transform(const Matrix3f& mat, const RectF& rect);


  constexpr Matrix3f identityTransform() {
    return Matrix3f(1.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 0.0f, 1.0f);
  }

  inline
  Matrix3f translation(Vector2f offset) {
    return Matrix3f{
      1.0f, 0.0f, offset.x,
      0.0f, 1.0f, offset.y,
      0.0f, 0.0f, 1.0f
    };
  }

  GF_CORE_API void translate(Matrix3f& mat, Vector2f offset);

  inline
  Matrix3f rotation(float angle) {
    float cos = std::cos(angle);
    float sin = std::sin(angle);
    return Matrix3f{
       cos, -sin, 0.0f,
       sin,  cos, 0.0f,
      0.0f, 0.0f, 1.0f
    };
  }

  inline
  Matrix3f rotation(float angle, Vector2f center) {
    float cos = std::cos(angle);
    float sin = std::sin(angle);
    return Matrix3f{
       cos, -sin, center.x * (1 - cos) + center.y * sin,
       sin,  cos, center.y * (1 - cos) - center.x * sin,
      0.0f, 0.0f, 1.0f
    };
  }

  GF_CORE_API void rotate(Matrix3f& mat, float angle);

  GF_CORE_API void rotate(Matrix3f& mat, float angle, Vector2f center);

  inline
  Matrix3f scaling(Vector2f factor) {
    return Matrix3f{
      factor.x,     0.0f, 0.0f,
          0.0f, factor.y, 0.0f,
          0.0f,     0.0f, 1.0f
    };
  }

  inline
  Matrix3f scaling(Vector2f factor, Vector2f center) {
    return Matrix3f{
      factor.x,     0.0f, center.x * (1.0f - factor.x),
          0.0f, factor.y, center.y * (1.0f - factor.y),
          0.0f,     0.0f, 1.0f
    };
  }

  GF_CORE_API void scale(Matrix3f& mat, Vector2f factor);

  GF_CORE_API void scale(Matrix3f& mat, Vector2f factor, Vector2f center);

#ifndef DOXYGEN_SHOULD_SKIP_THIS
}
#endif
}

#endif // GF_TRANSFORM_H