A repository for the MPRI's Computer Graphics and Visualization course project. A jelly-like ball bounces around. https://wikimpri.dptinfo.ens-cachan.fr/doku.php?id=cours:c-2-39
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.

182 lines
4.4 KiB

/**
* Defines a few widely used, widely spread structures. Imported pervasively.
**/
#pragma once
#include <functional> // Hash
#include <vector>
#include <cassert>
#include <cmath>
struct Point {
Point(double x, double y, double z) : x(x), y(y), z(z) {}
double x, y, z;
double norm() const {
auto sq = [](double x) { return x * x; };
return sqrt(sq(x) + sq(y) + sq(z));
}
void normalize() {
double _norm = norm();
x /= _norm;
y /= _norm;
z /= _norm;
}
double operator[](unsigned i) const {
assert(i < 3);
switch(i) {
case 0: return x;
case 1: return y;
case 2: return z;
default: return 0;
}
}
bool operator==(const Point& pt) const {
return fabs(x - pt.x) < 1e-9
&& fabs(y - pt.y) < 1e-9
&& fabs(z - pt.z) < 1e-9;
}
Point operator+(const Point& pt) const {
return Point(
x + pt.x,
y + pt.y,
z + pt.z);
}
Point& operator+=(const Point& pt) {
x += pt.x;
y += pt.y;
z += pt.z;
return *this;
}
Point& operator-=(const Point& pt) {
return (*this += Point(-pt.x, -pt.y, -pt.z));
}
Point operator-(const Point& pt) const {
return (*this) + (-1 * pt);
}
friend Point operator*(double scalar, const Point& pt) {
return Point(
scalar * pt.x,
scalar * pt.y,
scalar * pt.z);
}
Point cross_prod(const Point& pt) const {
return Point(
(*this)[1] * pt[2] - (*this)[2] * pt[1],
(*this)[2] * pt[0] - (*this)[0] * pt[2],
(*this)[0] * pt[1] - (*this)[1] * pt[0]);
}
bool operator<(const Point& pt) const {
/// Lexicographic order on (x, y, z)
if(x == pt.x) {
if(y == pt.y)
return z < pt.z;
return y < pt.y;
}
return x < pt.x;
}
};
struct PointLoc {
/// Point location: a point with integer coordinates, used to index Points
PointLoc(int x, int y, int z): x(x), y(y), z(z) {}
int x, y, z;
bool operator<(const PointLoc& pt) const {
if(x == pt.x) {
if(y == pt.y)
return z < pt.z;
return y < pt.y;
}
return x < pt.x;
}
bool operator==(const PointLoc& pt) const {
return x == pt.x && y == pt.y && z == pt.z;
}
PointLoc operator+(const PointLoc& pt) const {
return PointLoc(x + pt.x, y + pt.y, z + pt.z);
}
};
struct Face {
Face(int v0, int v1, int v2) {
vert[0] = v0;
vert[1] = v1;
vert[2] = v2;
}
int vert[3];
int operator[](unsigned i) const {
return vert[i % 3]; // dodge errors
}
const Point& pt(int id, const std::vector<Point>& pts) const {
assert(0 <= id && id < 3);
return pts[vert[id]];
}
};
class Cuboid {
/// A 3D box
public:
static Cuboid empty() {
return Cuboid(Point(0, 0, 0), Point(0, 0, 0));
}
Cuboid(Point bd1, Point bd2);
Cuboid(const Cuboid& oth)
: lowBound(oth.lowBound), highBound(oth.highBound) {}
double low(unsigned dim) const; ///< Lower bound for a dimension
double high(unsigned dim) const; ///< Higher bound for a dimension
double length(unsigned dim) const;
Point low_pt() const;
Point high_pt() const;
double volume() const;
bool is_empty() const;
private:
Point lowBound, highBound;
};
struct Color {
Color() : r(0), g(0), b(0) {}
Color(double r, double g, double b) : r(r), g(g), b(b) {}
double r, g, b;
double operator[](int i) const {
switch(i % 3) {
case 0: return r;
case 1: return g;
case 2: return b;
}
return 0; // won't happen
}
};
namespace std {
template<> struct hash<Face>
{
typedef Face argument_type;
typedef std::size_t result_type;
result_type operator()(argument_type const& s) const noexcept
{
result_type const h1 ( std::hash<int>{}(s[0]) );
result_type const h2 ( std::hash<int>{}(s[1]) );
result_type const h3 ( std::hash<int>{}(s[2]) );
return h1 ^ h2 ^ h3;
}
};
}