105 lines
3.5 KiB
C++
105 lines
3.5 KiB
C++
#pragma once
|
|
|
|
#include <glm/glm.hpp>
|
|
|
|
#include <variant>
|
|
#include <vector>
|
|
|
|
namespace CesiumGeometry {
|
|
|
|
/**
|
|
* @brief A structure describing a vertex that results from interpolating two
|
|
* other vertices.
|
|
*
|
|
* The vertices to interpolate between are given via their indices. This is
|
|
* used as one representation of a vertex in a {@link TriangleClipVertex}.
|
|
*/
|
|
struct InterpolatedVertex {
|
|
/**
|
|
* @brief The index of the first vertex to interpolate between.
|
|
*/
|
|
int first;
|
|
|
|
/**
|
|
* @brief The index of the second vertex to interpolate between.
|
|
*/
|
|
int second;
|
|
|
|
/**
|
|
* @brief The fraction of the distance from {@link first} to {@link second} at
|
|
* which to interpolate.
|
|
*/
|
|
double t;
|
|
|
|
/**
|
|
* @brief Compares this \ref InterpolatedVertex against another.
|
|
*
|
|
* Two \ref InterpolatedVertex instances are considered equivalent if their
|
|
* \ref first and \ref second fields are equivalent and the difference between
|
|
* their \ref t fields is less than `std::numeric_limits<double>::epsilon()`.
|
|
*/
|
|
constexpr bool operator==(const InterpolatedVertex& other) const noexcept {
|
|
return this->first == other.first && this->second == other.second &&
|
|
std::fabs(this->t - other.t) <=
|
|
std::numeric_limits<double>::epsilon();
|
|
}
|
|
|
|
/** @brief The inverse of \ref InterpolatedVertex::operator== */
|
|
constexpr bool operator!=(const InterpolatedVertex& other) const noexcept {
|
|
return !(*this == other);
|
|
}
|
|
};
|
|
|
|
/**
|
|
* @brief A vertex resulting from clipping a triangle against a threshold.
|
|
*
|
|
* It may either be a simple index referring to an existing vertex,
|
|
* or an interpolation between two vertices.
|
|
*/
|
|
using TriangleClipVertex = std::variant<int, InterpolatedVertex>;
|
|
|
|
/**
|
|
* @brief Splits a 2D triangle at given axis-aligned threshold value and returns
|
|
* the resulting polygon on a given side of the threshold.
|
|
*
|
|
* The resulting polygon may have 0, 1, 2, 3, or 4 vertices.
|
|
*
|
|
* @param threshold The threshold coordinate value at which to clip the
|
|
* triangle.
|
|
* @param keepAbove true to keep the portion of the triangle above the
|
|
* threshold, or false to keep the portion below.
|
|
* @param i0 The index of the first vertex in the triangle in counter-clockwise
|
|
* order, used only to construct the TriangleClipVertex result.
|
|
* @param i1 The index of the second vertex in the triangle in counter-clockwise
|
|
* order, used only to construct the TriangleClipVertex result.
|
|
* @param i2 The index of the third vertex in the triangle in counter-clockwise
|
|
* order, used only to construct the TriangleClipVertex result.
|
|
* @param u0 The coordinate of the first vertex in the triangle, in
|
|
* counter-clockwise order.
|
|
* @param u1 The coordinate of the second vertex in the triangle, in
|
|
* counter-clockwise order.
|
|
* @param u2 The coordinate of the third vertex in the triangle, in
|
|
* counter-clockwise order.
|
|
* @param result On return, contains the polygon that results after the clip,
|
|
* specified as a list of vertices. If this vector already contains elements,
|
|
* the result is pushed onto the end of the vector.
|
|
*
|
|
* ```
|
|
* TODO port this CesiumJS example to cesium-native
|
|
* var result = Cesium.Intersections2D.clipTriangleAtAxisAlignedThreshold(0.5,
|
|
* false, 0.2, 0.6, 0.4);
|
|
* // result === [2, 0, -1, 1, 0, 0.25, -1, 1, 2, 0.5]
|
|
* ```
|
|
*/
|
|
void clipTriangleAtAxisAlignedThreshold(
|
|
double threshold,
|
|
bool keepAbove,
|
|
int i0,
|
|
int i1,
|
|
int i2,
|
|
double u0,
|
|
double u1,
|
|
double u2,
|
|
std::vector<TriangleClipVertex>& result) noexcept;
|
|
} // namespace CesiumGeometry
|