#pragma region CPL License
/*
Nuclex Native Framework
Copyright (C) 2002-2015 Nuclex Development Labs

This library is free software; you can redistribute it and/or
modify it under the terms of the IBM Common Public License as
published by the IBM Corporation; either version 1.0 of the
License, or (at your option) any later version.

This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
IBM Common Public License for more details.

You should have received a copy of the IBM Common Public
License along with this library
*/
#pragma endregion // CPL License

#ifndef NUCLEX_GEOMETRY_VOLUMES_TRACERS_HEIGHTFIELD3TRACER_H
#define NUCLEX_GEOMETRY_VOLUMES_TRACERS_HEIGHTFIELD3TRACER_H

#include "Nuclex/Geometry/Config.h"
#include "Nuclex/Geometry/Point3.h"
#include "Nuclex/Geometry/Vector3.h"
#include "Nuclex/Geometry/Volumes/HeightField3.h"

namespace Nuclex { namespace Geometry { namespace Volumes { namespace Tracers {

  // ------------------------------------------------------------------------------------------- //

  /// <summary>Detects the contacts of a line against a height field</summary>
  template <typename TScalar>
  class HeightField3Tracer {

    /// <summary>Traces a ray through the height field</summary>
    /// <param name="heightField">Height field the ray will be traced against</param>
    /// <param name="start">Starting location of the ray</param>
    /// <param name="direction">Direction of the ray</param>
    /// <returns>
    ///   The distance from the ray's origin at which the height field is hit or
    ///   infinity if the ray will not hit the height field.
    /// </returns>
    public: static TScalar Trace(
      const HeightField3<TScalar> &heightField,
      const Point3<TScalar> &start, const Vector3<TScalar> &direction
    ) {

      // See whether the ray starts inside of the terrain. If so, the started in solid
      // matter and we can directly return a collision at time 0.0.
      TScalar heightAtStart = heightField.LinearInterpolateHeightAt(start.X, start.Y);
      if(start.Z <= heightAtStart) {
        return 0;
      }

      // If the ray is perfectly vertical, it will stay above the point it is now, so
      // we can easily calculate the time of impact or conclude no impact happens.
      bool isVertical = (direction.X == 0) && (direction.Y == 0);
      if(isVertical) {
        if(direction.Z >= 0) {
          return std::numeric_limits<TScalar>::signaling_NaN();
        } else {
          return start.Z - heightAtStart;
        }
      }

      // The ray is traveling horizontally (at least to some degree) and didn't begin
      // inside solid matter, so now we can trace it.
      return traceNonVerticalRay(
        Point3<TScalar>(
          start.X - heightField.Position.X,
          start.Y - heightField.Position.Y,
          start.Z
        )
      );

    }

    /// <summary>Traces a ray that is not traveling purely vertical</summary>
    /// <param name="heightField">Height field across which the ray is traced</param>
    /// <param name="localStart">Location the ray started at in local coordinates</param>
    /// <param name="direction">Direction in which the ray travels</param>
    /// <returns>The distance after which the ray will hit the height field</returns>
    private: static TScalar traceNonVerticalRay(
      const HeightField3<TScalar> &heightField,
      Point3<TScalar> &localStart, const Vector3<TScalar> &direction
    ) {
      return 0;
    }

  };

  // ------------------------------------------------------------------------------------------- //

}}}} // namespace Nuclex::Geometry::Volumes::Tracers

#endif // NUCLEX_GEOMETRY_VOLUMES_TRACERS_HEIGHTFIELD3TRACER_H