cpp-game-engine/math/src/shape.cpp

//
//  shape.cpp
//  math
//
//  Created by Sam Jaffe on 7/5/16.
//

#include "game/math/shape.hpp"

#include <iostream>
#include <vector>

#include "game/math/compare.hpp"

namespace math { namespace dim2 {
  float line::length() const {
    return (second - first).magnitude();
  }
    
  float line::slope() const {
    return safe_div(second[1] - first[1], second[0] - first[0]);
  }
  
  rectangle::operator quad() const {
    return {
      origin,
      origin + point{{size.x(), 0.0}},
      origin + size,
      origin + point{{0.0, size.y()}}
    };
  }

  square::operator rectangle() const {
    return { origin, origin + vec2{{size, size}} };
  }
  
  square::operator quad() const {
    return {
      origin,
      origin + point{{size, 0.0 }},
      origin + point{{size, size}},
      origin + point{{ 0.0, size}}
    };
  }
} }

namespace math { namespace shapes {
  std::vector<dim2::line> segments(dim2::quad const & shape) {
    return {
      {shape.ll, shape.lr}, {shape.lr, shape.ur},
      {shape.ur, shape.ul}, {shape.ul, shape.ll}
    };
  }
} }

namespace math { namespace lines {
  bool parallel(dim2::line const & lhs, dim2::line const & rhs) {
    return lhs.slope() == rhs.slope();
  }
  
  inline dim2::point intersection(float b1, float s1, float b2, float s2) {
    float const x = safe_div(b1 + b2, s1 - s2);
    return {{x, b1 + x * s1}};
  }

  inline dim2::point intersection(dim2::point const & p1, float s1,
                                  dim2::point const & p2, float s2) {
    // Solve for Inf * NaN
    float y1 = p1[0] == 0 ? 0 : s1 * p1[0];
    float y2 = p2[0] == 0 ? 0 : s2 * p2[0];
    return intersection(p1[1] - y1, s1, p2[1] - y2, s2);
  }
  
  dim2::point intersection(dim2::line const & lhs, dim2::line const & rhs) {
    return intersection(lhs.first, lhs.slope(), rhs.first, rhs.slope());
  }

  dim2::line orthogonal(dim2::line const & from, dim2::point const & to) {
    float const slope = from.slope();
    if (slope == 0 || isinf(slope)) { return {to, {{to[0], from.first[1]}}}; }
    return {to, intersection(from.first, slope, to, -1/slope)};
  }
} }