Solar-System/geometry.h at main · Meshford/Solar-System · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
#pragma once
#ifndef __GEOMETRY_H__
#define __GEOMETRY_H__
#include <cmath>
#include <vector>
#include <cassert>
#include <iostream>

template <size_t DIM, typename Tname > struct vec  // Êîíñòðóêòîð. Ñîçäàëè øàáëîííóþ ñòðóêòóðó âåêòîð è çàïîëíèëè åãî ïàìÿòü ìåñòîì
{												   //  çàäàííîãî òèïà(Tname) è çàäàííîé äëèíû(DIM - ðàçìåðíîñòü), íî íè÷åì íå çàïîëíÿëè
	vec()
	{
		for (size_t i = DIM; i--; data_[i] = Tname());
	}
	Tname& operator[](const size_t i)   // Ïåðåãðóçêà îïåðàòîðà èíäåêñèðîâàíèÿ
	{
		assert(i < DIM);
		return data_[i];
	}
	const Tname& operator[](const size_t i) const
	{
		assert(i < DIM);
		return data_[i];
	}
private:
	Tname data_[DIM];   // Âûäåëèëè îäíî ïîëå - ìàññèâ çíà÷åíèé( ò.ê. âåêòîð) òèïà Tname
};

typedef vec<2, float> Vec2f;  // Ïåðåèìåíîâàëè øàáëîííûå âåêòîðà â ïîíÿòíûå îáîçíà÷åíèÿ
typedef vec<3, float> Vec3f;

template <typename Tname> struct vec<2, Tname>  // Êîíñòðóêòîð è îïåðàòîð èíäåêñèðîâàíèÿ äëÿ 2-ãî âåêòîðà
{
	vec() : x(Tname()), y(Tname()) {}
	vec(Tname X, Tname Y) : x(X), y(Y) {}
	template <class U> vec<2, Tname>(const vec<2, U> &v);
	Tname& operator[](const size_t i)
	{
		assert(i < 2);
		return i <= 0 ? x : y;
	}
	const Tname& operator[](const size_t i) const
	{
		assert(i < 2);
		return i <= 0 ? x : y;
	}
	Tname x, y;  // Ïîëÿ âåêòîðà
};

template <typename Tname> struct vec<3, Tname> // Êîíñòðóêòîð è îïåðàòîð èíäåêñèðîâàíèÿ äëÿ 3-ãî âåêòîðà
{
	vec() : x(Tname()), y(Tname()), z(Tname()) {}
	vec(Tname X, Tname Y, Tname Z) : x(X), y(Y), z(Z) {}
	Tname& operator[](const size_t i)
	{
		assert(i < 3);
		return i <= 0 ? x : (1 == i ? y : z);
	}
	const Tname& operator[](const size_t i) const
	{
		assert(i < 3);
		return i <= 0 ? x : (1 == i ? y : z);
	}
	float norm()
	{
		return std::sqrt(x*x + y * y + z * z);
	}
	vec<3, Tname> & normalize(Tname l = 1)
	{
		*this = (*this)*(l / norm()); return *this;
	}
	Tname x, y, z; // Ïîëÿ âåêòîðà
};

template<size_t DIM, typename Tname> Tname operator*(const vec<DIM, Tname>& lhs, const vec<DIM, Tname>& rhs) // Ñêàëÿðíîå ïðîèçâåäåíèå
{
	Tname ret = Tname();
	for (size_t i = DIM; i--; ret += lhs[i] * rhs[i]);
	return ret;
}

template<size_t DIM, typename Tname>vec<DIM, Tname> operator+(vec<DIM, Tname> lhs, const vec<DIM, Tname>& rhs)  // Ñëîæåíèå
{
	for (size_t i = DIM; i--; lhs[i] += rhs[i]);
	return lhs;
}

template<size_t DIM, typename Tname>vec<DIM, Tname> operator-(vec<DIM, Tname> lhs, const vec<DIM, Tname>& rhs) // Âû÷èòàíèå
{
	for (size_t i = DIM; i--; lhs[i] -= rhs[i]);
	return lhs;
}

template<size_t DIM, typename Tname, typename U> vec<DIM, Tname> operator*(const vec<DIM, Tname> &lhs, const U& rhs) // Âåêòîðíîå-ïðîèçâåäåèå
{
	vec<DIM, Tname> ret;
	for (size_t i = DIM; i--; ret[i] = lhs[i] * rhs);
	return ret;
}

template<size_t DIM, typename Tname> vec<DIM, Tname> operator-(const vec<DIM, Tname> &lhs)  // Âû÷èòàíèå
{
	return lhs * Tname(-1);
}

template <typename Tname> vec<3, Tname> cross(vec<3, Tname> v1, vec<3, Tname> v2)  // 3-õ ìåðíîãî âåêòîðà
{
	return vec<3, Tname>(v1.y*v2.z - v1.z*v2.y, v1.z*v2.x - v1.x*v2.z, v1.x*v2.y - v1.y*v2.x);
}

template <size_t DIM, typename Tname> std::ostream& operator<<(std::ostream& out, const vec<DIM, Tname>& v) // Âûâîä
{
	for (unsigned int i = 0; i < DIM; i++) {
		out << v[i] << " ";
	}
	return out;
}
#endif //__GEOMETRY_H__