From c82d7e77dcbc9c41b4d2853790aa4a6616db43ac Mon Sep 17 00:00:00 2001 From: Yann Herklotz Date: Fri, 28 Jul 2017 00:10:45 +0100 Subject: Updating docs --- README.md | 1 - body_8hpp_source.html | 3 +- dir_5ac3a90c14a160db9539610948ce4998.html | 7 ++ files.html | 2 +- math_8hpp_source.html | 3 +- matrix_8hpp.html | 175 ++++++++++++++++++++++++++++++ matrix_8hpp_source.html | 8 +- md_docs_README.html | 75 +++++++++++++ pages.html | 3 +- particlebody_8hpp_source.html | 3 +- search/all_2.js | 3 +- search/all_3.js | 5 +- search/all_4.js | 6 +- search/all_5.js | 6 +- search/all_6.js | 7 +- search/all_7.js | 7 +- search/all_8.js | 6 +- search/all_9.js | 5 +- search/all_a.js | 7 +- search/all_b.js | 7 +- search/all_c.js | 2 +- search/all_d.html | 26 +++++ search/all_d.js | 4 + search/files_0.html | 26 +++++ search/files_0.js | 4 + search/pages_0.js | 2 +- search/pages_1.html | 26 +++++ search/pages_1.js | 4 + search/searchdata.js | 11 +- 29 files changed, 399 insertions(+), 45 deletions(-) delete mode 100644 README.md create mode 100644 matrix_8hpp.html create mode 100644 md_docs_README.html create mode 100644 search/all_d.html create mode 100644 search/all_d.js create mode 100644 search/files_0.html create mode 100644 search/files_0.js create mode 100644 search/pages_1.html create mode 100644 search/pages_1.js diff --git a/README.md b/README.md deleted file mode 100644 index 6228a7f5..00000000 --- a/README.md +++ /dev/null @@ -1 +0,0 @@ -My gh-pages branch diff --git a/body_8hpp_source.html b/body_8hpp_source.html index 623d10ec..a2c250a8 100644 --- a/body_8hpp_source.html +++ b/body_8hpp_source.html @@ -67,7 +67,8 @@ $(function() {
body.hpp
-
1 /* ----------------------------------------------------------------------------
2  * body.hpp
3  *
4  * Copyright (c) 2017 Yann Herklotz Grave <ymherklotz@gmail.com> -- MIT License
5  * See file LICENSE for more details
6  * ----------------------------------------------------------------------------
7  */
8 
9 #ifndef YAGE_BODY_HPP
10 #define YAGE_BODY_HPP
11 
12 #include "Math/matrix.hpp"
13 
14 namespace yage
15 {
16 
17 class Body
18 {
19 public:
20  // gravity constant
21  static const double GRAVITY;
22 protected:
23  // center of mass of the object
24  Vector2d position_=Vector2d(0, 0);
25 
26  // mass of the object
27  double mass_=1;
28 
29  // current velocity of the object
30  Vector2d velocity_=Vector2d(0, 0);
31 
32  // boolean that defines if gravity can act on the object
33  bool gravity_=true;
34 
35  // current acceleration
36  Vector2d acceleration_=Vector2d(0, 0);
37 
38  // force acting on the body
39  Vector2d force_=Vector2d(0, 0);
40 
41 public:
42  virtual ~Body();
43 
44  // apply force to the object and update the velocity
45  virtual void applyForce(const Vector2d &force)=0;
46  virtual void update()=0;
47 
48  double xPosition() const;
49  double yPosition() const;
50 protected:
51  // protected constructor to initialize member variables
52  Body(const Vector2d &position=Vector2d(0, 0),
53  double mass=1,
54  const Vector2d &velocity=Vector2d(0, 0),
55  bool gravity=false);
56 };
57 
58 } // yage
59 
60 #endif
+
1 /* ----------------------------------------------------------------------------
2  * body.hpp
3  *
4  * Copyright (c) 2017 Yann Herklotz Grave <ymherklotz@gmail.com> -- MIT License
5  * See file LICENSE for more details
6  * ----------------------------------------------------------------------------
7  */
8 
9 #ifndef YAGE_BODY_HPP
10 #define YAGE_BODY_HPP
11 
12 #include "Math/matrix.hpp"
13 
14 namespace yage
15 {
16 
17 class Body
18 {
19 public:
20  // gravity constant
21  static const double GRAVITY;
22 protected:
23  // center of mass of the object
24  Vector2d position_=Vector2d(0, 0);
25 
26  // mass of the object
27  double mass_=1;
28 
29  // current velocity of the object
30  Vector2d velocity_=Vector2d(0, 0);
31 
32  // boolean that defines if gravity can act on the object
33  bool gravity_=true;
34 
35  // current acceleration
36  Vector2d acceleration_=Vector2d(0, 0);
37 
38  // force acting on the body
39  Vector2d force_=Vector2d(0, 0);
40 
41 public:
42  virtual ~Body();
43 
44  // apply force to the object and update the velocity
45  virtual void applyForce(const Vector2d &force)=0;
46  virtual void update()=0;
47 
48  double xPosition() const;
49  double yPosition() const;
50 protected:
51  // protected constructor to initialize member variables
52  Body(const Vector2d &position=Vector2d(0, 0),
53  double mass=1,
54  const Vector2d &velocity=Vector2d(0, 0),
55  bool gravity=false);
56 };
57 
58 } // yage
59 
60 #endif
matrix.hpp
Templated matrix class.
+
yage::Body
Definition: body.hpp:17
yage
Definition: camera2d.hpp:17
diff --git a/dir_5ac3a90c14a160db9539610948ce4998.html b/dir_5ac3a90c14a160db9539610948ce4998.html index f14855f3..9e4e2ab8 100644 --- a/dir_5ac3a90c14a160db9539610948ce4998.html +++ b/dir_5ac3a90c14a160db9539610948ce4998.html @@ -67,6 +67,13 @@ $(function() {
Math Directory Reference
+ + + + + +

+Files

file  matrix.hpp [code]
 Templated matrix class.
 
diff --git a/files.html b/files.html index e20fcf02..b68ff8b6 100644 --- a/files.html +++ b/files.html @@ -69,7 +69,7 @@ $(function() {  ▼ YAGE  ▼ Math  math.hpp - matrix.hpp + matrix.hppTemplated matrix class  ▼ Physics  body.hpp  collider.hpp diff --git a/math_8hpp_source.html b/math_8hpp_source.html index 1840b993..255cdbda 100644 --- a/math_8hpp_source.html +++ b/math_8hpp_source.html @@ -67,7 +67,8 @@ $(function() {
math.hpp
-
1 /* ----------------------------------------------------------------------------
2  * math.hpp
3  *
4  * Copyright (c) 2017 Yann Herklotz Grave <ymherklotz@gmail.com> -- MIT License
5  * See file LICENSE for more details
6  * ----------------------------------------------------------------------------
7  */
8 
9 #ifndef YAGE_MATH_HPP
10 #define YAGE_MATH_HPP
11 
12 #include "matrix.hpp"
13 
14 #endif
+
1 /* ----------------------------------------------------------------------------
2  * math.hpp
3  *
4  * Copyright (c) 2017 Yann Herklotz Grave <ymherklotz@gmail.com> -- MIT License
5  * See file LICENSE for more details
6  * ----------------------------------------------------------------------------
7  */
8 
9 #ifndef YAGE_MATH_HPP
10 #define YAGE_MATH_HPP
11 
12 #include "matrix.hpp"
13 
14 #endif
matrix.hpp
Templated matrix class.
+
Generated by   diff --git a/matrix_8hpp.html b/matrix_8hpp.html new file mode 100644 index 00000000..b58b709f --- /dev/null +++ b/matrix_8hpp.html @@ -0,0 +1,175 @@ + + + + + + + +YAGE: include/YAGE/Math/matrix.hpp File Reference + + + + + + + + + + +
+
+Classes | +Typedefs | +Functions
+
+
matrix.hpp File Reference
+
+
+ +

Templated matrix class. +More...

+
#include <algorithm>
+#include <exception>
+#include <iostream>
+#include <sstream>
+#include <string>
+#include <vector>
+
+

Go to the source code of this file.

+ + + + + + + + + + + + +

+Classes

class  yage::Matrix< Rows, Cols, Type >
 
class  yage::detail::Row< Rows, Cols, Type >
 
class  yage::Matrix< Rows, Cols, Type >
 
class  yage::Vector< Rows, Type >
 
class  yage::Vector2< Type >
 
+ + + +

+Typedefs

+typedef Vector2< double > yage::Vector2d
 
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

+Functions

+template<int M, int N, class T >
Matrix< M, N, T > yage::operator+ (Matrix< M, N, T > lhs, const Matrix< M, N, T > &rhs)
 
+template<int M, int N, class T >
Matrix< M, N, T > yage::operator- (Matrix< M, N, T > lhs, const Matrix< M, N, T > &rhs)
 
+template<int M, int N, class T >
Matrix< M, N, T > yage::operator+ (Matrix< M, N, T > lhs, const T &rhs)
 
+template<int M, int N, class T >
Matrix< M, N, T > yage::operator+ (const T &lhs, Matrix< M, N, T > rhs)
 
+template<int M, int N, class T >
Matrix< M, N, T > yage::operator- (Matrix< M, N, T > lhs, const T &rhs)
 
+template<int M, int N, class T >
Matrix< M, N, T > yage::operator- (const T &lhs, Matrix< M, N, T > rhs)
 
+template<int M, int N, class T >
Matrix< M, N, T > yage::operator* (Matrix< M, N, T > lhs, const T &rhs)
 
+template<int M, int N, class T >
Matrix< M, N, T > yage::operator* (const T &lhs, Matrix< M, N, T > rhs)
 
+template<int M, int N, class T >
Matrix< M, N, T > yage::operator/ (Matrix< M, N, T > lhs, const T &rhs)
 
+template<int M, int N, class T >
bool yage::operator== (const Matrix< M, N, T > &lhs, const Matrix< M, N, T > &rhs)
 
+template<int M, int N, class T >
std::ostream & yage::operator<< (std::ostream &os, const Matrix< M, N, T > &mat)
 
+template<int M, int N, class T >
Matrix< N, M, T > yage::matrix::transpose (const Matrix< M, N, T > &m)
 
+template<int R, class T >
T yage::matrix::dot (const Matrix< R, 1, T > &m1, const Matrix< R, 1, T > &m2)
 
+template<int M, int N, int P, int Q, class T >
Matrix< M, Q, T > yage::matrix::multiply (const Matrix< M, N, T > &m1, const Matrix< P, Q, T > &m2)
 
+

Detailed Description

+

Templated matrix class.

+

Matrix and Vector class with arbitrary type and precision.

+
+ +
+Generated by   +doxygen + 1.8.13 +
+ + diff --git a/matrix_8hpp_source.html b/matrix_8hpp_source.html index 7b652138..ff189d16 100644 --- a/matrix_8hpp_source.html +++ b/matrix_8hpp_source.html @@ -67,10 +67,10 @@ $(function() {
matrix.hpp
-
1 /* ----------------------------------------------------------------------------
2  * matrix.hpp
3  *
4  * Copyright (c) 2017 Yann Herklotz Grave <ymherklotz@gmail.com> -- MIT License
5  * See file LICENSE for more details
6  * ----------------------------------------------------------------------------
7  */
8 
9 #ifndef YAGE_MATH_MATRIX_HPP
10 #define YAGE_MATH_MATRIX_HPP
11 
12 #include <algorithm>
13 #include <exception>
14 #include <iostream>
15 #include <sstream>
16 #include <string>
17 #include <vector>
18 
19 namespace yage
20 {
21 
22 template<int Rows, int Cols, class Type> class Matrix;
23 
24 // includes implementation details that should not be accessible to the user
25 namespace detail
26 {
27 
28 // Row class
29 //
30 // Used to implement the double square bracket operator and be able
31 // to return the value by reference of the array.
32 template<int Rows, int Cols, class Type> class Row
33 {
34 private:
35  Matrix<Rows, Cols, Type> *parent_;
36  int index_;
37 
38 public:
39  Row<Rows, Cols, Type>(Matrix<Rows, Cols, Type> *parent, int index) :
40  parent_(parent), index_(index)
41  {}
42 
43  Type& operator[](int col)
44  {
45  // the index is the y-position of the element in the matrix
46  return parent_->data_[index_*Cols+col];
47  }
48 
49  const Type& operator[](int col) const
50  {
51  return parent_->data_[index_*Cols+col];
52  }
53 };
54 
55 } // detail
56 
57 // Matrix class
58 //
59 // Implements the base Matrix class that is inherited by other classes to make them more
60 // specific.
61 template<int Rows=4, int Cols=4, class Type=double> class Matrix
62 {
63  // friended with the row class so that it can access protected member data
64  friend class detail::Row<Rows, Cols, Type>;
65 protected:
66  std::vector<Type> data_;
67 
68 public:
69  Matrix<Rows, Cols, Type>() : data_(Rows*Cols) {}
70 
71  int rowSize() const
72  {
73  return Rows;
74  }
75 
76  int colSize() const
77  {
78  return Cols;
79  }
80 
81  // returns the row in a row matrix
82  Matrix<1, Cols, Type> getRow(int row) const
83  {
84  Matrix<1, Cols, Type> rowMatrix;
85  for(int i=0; i<Cols; ++i)
86  {
87  rowMatrix[0][i]=data_[row][i];
88  }
89  return rowMatrix;
90  }
91 
92  // returns the column in a column matrix
93  Matrix<Rows, 1, Type> getCol(int col) const
94  {
95  Matrix<Rows, 1, Type> colMatrix;
96  for(int i=0; i<Rows; ++i)
97  {
98  colMatrix[i][0]=data_[i][col];
99  }
100  return colMatrix;
101  }
102 
103  // iterator support for begin
104  typename std::vector<Type>::iterator begin()
105  {
106  return data_.begin();
107  }
108 
109  // iterator support for end
110  typename std::vector<Type>::iterator end()
111  {
112  return data_.end();
113  }
114 
115  // prints out the matrix, but can also be implemented by other classes to print data
116  // differently
117  virtual std::string toString() const
118  {
119  std::stringstream ss;
120  ss<<'[';
121  for(int i=0; i<Rows-1; ++i)
122  {
123  ss<<'[';
124  for(int j=0; j<Cols-1; ++j)
125  {
126  ss<<data_[i*Cols+j]<<' ';
127  }
128  ss<<data_[(Rows-1)*Cols+Cols-1]<<"],";
129  }
130  ss<<'[';
131  for(int j=0; j<Cols-1; ++j)
132  {
133  ss<<data_[(Rows-1)*Cols+j]<<' ';
134  }
135  ss<<data_[(Rows-1)*Cols+Cols-1]<<"]]";
136  return ss.str();
137  }
138 
139  detail::Row<Rows, Cols, Type> operator[](int row)
140  {
141  return detail::Row<Rows, Cols, Type>(this, row);
142  }
143 
144  detail::Row<Rows, Cols, Type> operator[](int row) const
145  {
146  // TODO got to fix this
147  return detail::Row<Rows, Cols, Type>((Matrix<Rows, Cols, Type>*)this, row);
148  }
149 
150  Matrix<Rows, Cols, Type>& operator=(const Matrix<Rows, Cols, Type> &other)
151  {
152  if(this!=&other)
153  {
154  data_=other.data_;
155  }
156  return *this;
157  }
158 
159  Matrix<Rows, Cols, Type>& operator+=(const Matrix<Rows, Cols, Type> &rhs)
160  {
161  std::vector<Type> out;
162  out.reserve(data_.size());
163  std::transform(data_.begin(), data_.end(), rhs.data_.begin(), std::back_inserter(out),
164  [] (Type a, Type b) {
165  return a+b;
166  });
167  data_=std::move(out);
168  return *this;
169  }
170 
171  Matrix<Rows, Cols, Type>& operator-=(const Matrix<Rows, Cols, Type> &rhs)
172  {
173  std::vector<Type> out;
174  out.reserve(data_.size());
175  std::transform(data_.begin(), data_.end(), rhs.begin(), std::back_inserter(out),
176  [] (Type a, Type b) {
177  return a-b;
178  });
179  data_=std::move(out);
180  return *this;
181  }
182 };
183 
184 template<int M, int N, class T>
185 Matrix<M, N, T> operator+(Matrix<M, N, T> lhs, const Matrix<M, N, T> &rhs)
186 {
187  lhs+=rhs;
188  return lhs;
189 }
190 
191 template<int M, int N, class T>
192 Matrix<M, N, T> operator-(Matrix<M, N, T> lhs, const Matrix<M, N, T> &rhs)
193 {
194  lhs-=rhs;
195  return lhs;
196 }
197 
198 template<int M, int N, class T>
199 Matrix<M, N, T> operator+(Matrix<M, N, T> lhs, const T &rhs)
200 {
201  for(auto &data : lhs)
202  {
203  data+=rhs;
204  }
205  return lhs;
206 }
207 
208 template<int M, int N, class T>
209 Matrix<M, N, T> operator+(const T &lhs, Matrix<M, N, T> rhs)
210 {
211  for(auto &data : rhs)
212  {
213  data+=lhs;
214  }
215  return rhs;
216 }
217 
218 template<int M, int N, class T>
219 Matrix<M, N, T> operator-(Matrix<M, N, T> lhs, const T &rhs)
220 {
221  for(auto &data : lhs)
222  {
223  data-=rhs;
224  }
225  return lhs;
226 }
227 
228 template<int M, int N, class T>
229 Matrix<M, N, T> operator-(const T &lhs, Matrix<M, N, T> rhs)
230 {
231  for(auto &data : rhs)
232  {
233  data=lhs-data;
234  }
235  return rhs;
236 }
237 
238 template<int M, int N, class T>
239 Matrix<M, N, T> operator*(Matrix<M, N, T> lhs, const T &rhs)
240 {
241  for(auto &data : lhs)
242  {
243  data*=rhs;
244  }
245  return lhs;
246 }
247 
248 template<int M, int N, class T>
249 Matrix<M, N, T> operator*(const T &lhs, Matrix<M, N, T> rhs)
250 {
251  for(auto &data : rhs)
252  {
253  data*=lhs;
254  }
255  return rhs;
256 }
257 
258 template<int M, int N, class T>
259 Matrix<M, N, T> operator/(Matrix<M, N, T> lhs, const T &rhs)
260 {
261  for(auto &data : lhs)
262  {
263  data/=rhs;
264  }
265  return lhs;
266 }
267 
268 template<int M, int N, class T>
269 bool operator==(const Matrix<M, N, T> &lhs, const Matrix<M, N, T> &rhs)
270 {
271  for(int i=0; i<M; ++i)
272  for(int j=0; j<N; ++j)
273  if(lhs[i][j]!=rhs[i][j])
274  return false;
275  return true;
276 }
277 
278 template<int M, int N, class T>
279 std::ostream& operator<<(std::ostream &os, const Matrix<M, N, T> &mat)
280 {
281  return os<<mat.toString();
282 }
283 
284 template<int Rows=2, class Type=double> class Vector : public Matrix<Rows, 1, Type>
285 {
286 public:
287  Vector<Rows, Type>() : Matrix<Rows, 1, Type>() {}
288  explicit Vector<Rows, Type>(const Matrix<Rows, 1, Type> &other) : Matrix<Rows, 1, Type>(other) {}
289 
290  Type& operator[](int col)
291  {
292  return this->data_[col];
293  }
294 
295  const Type& operator[](int col) const
296  {
297  return this->data_[col];
298  }
299 
300  virtual std::string toString() const
301  {
302  std::stringstream ss;
303  ss<<"[";
304  for(std::size_t i=0; i<this->data_.size()-1; ++i)
305  {
306  ss<<this->data_[i]<<" ";
307  }
308  ss<<this->data_[this->data_.size()-1]<<"]";
309  return ss.str();
310  }
311 };
312 
313 template<class Type=double> class Vector2 : public Vector<2, Type>
314 {
315 public:
316  Vector2<Type>() : Vector<2, Type>() {}
317 
318  Vector2<Type>(Type x, Type y)
319  {
320  this->data_[0]=x;
321  this->data_[1]=y;
322  }
323 
324  Vector2<Type>(const Matrix<2, 1, Type> &other) : Vector<2, Type>(other) {}
325 
326  Type& x()
327  {
328  return this->data_[0];
329  }
330 
331  const Type& x() const
332  {
333  return this->data_[0];
334  }
335 
336  Type& y()
337  {
338  return this->data_[1];
339  }
340 
341  const Type& y() const
342  {
343  return this->data_[1];
344  }
345 };
346 
347 typedef Vector2<double> Vector2d;
348 
349 namespace matrix
350 {
351 
352 template<int M, int N, class T> Matrix<N, M, T> transpose(const Matrix<M, N, T> &m)
353 {
354  Matrix<N, M, T> trans;
355  for(int i=0; i<M; ++i)
356  {
357  for(int j=0; j<N; ++j)
358  {
359  trans[j][i]=m[i][j];
360  }
361  }
362  return trans;
363 }
364 
365 template<int R, class T> T dot(const Matrix<R, 1, T> &m1, const Matrix<R, 1, T> &m2)
366 {
367  T sum=0;
368  for(int i=0; i<R; ++i)
369  {
370  sum += m1[i][0]*m2[i][0];
371  }
372  return sum;
373 }
374 
375 template<int M, int N, int P, int Q, class T>
376 Matrix<M, Q, T> multiply(const Matrix<M, N, T> &m1, const Matrix<P, Q, T> &m2)
377 {
378  if(N!=P)
379  {
380  throw std::runtime_error("Matrices don't have the right dimensions for multiplication");
381  }
382 
383  Matrix<M, Q, T> res;
384 
385  for(int i=0; i<M; ++i)
386  {
387  for(int j=0; j<Q; ++j)
388  {
389  res[i][j] = dot(transpose(m1.getRow(i)), m2.getCol(j));
390  }
391  }
392 
393  return res;
394 }
395 
396 } // matrix
397 
398 } // yage
399 
400 #endif
yage::Vector2
Definition: matrix.hpp:313
-
yage::detail::Row
Definition: matrix.hpp:32
-
yage::Vector
Definition: matrix.hpp:284
-
yage::Matrix
Definition: matrix.hpp:22
+Go to the documentation of this file.
1 /* ----------------------------------------------------------------------------
2  * matrix.hpp
3  *
4  * Copyright (c) 2017 Yann Herklotz Grave <ymherklotz@gmail.com> -- MIT License
5  * See file LICENSE for more details
6  * ----------------------------------------------------------------------------
7  */
8 
16 #ifndef YAGE_MATH_MATRIX_HPP
17 #define YAGE_MATH_MATRIX_HPP
18 
19 #include <algorithm>
20 #include <exception>
21 #include <iostream>
22 #include <sstream>
23 #include <string>
24 #include <vector>
25 
26 namespace yage
27 {
28 
29 template<int Rows, int Cols, class Type> class Matrix;
30 
31 // includes implementation details that should not be accessible to the user
32 namespace detail
33 {
34 
35 // Row class
36 //
37 // Used to implement the double square bracket operator and be able
38 // to return the value by reference of the array.
39 template<int Rows, int Cols, class Type> class Row
40 {
41 private:
42  Matrix<Rows, Cols, Type> *parent_;
43  int index_;
44 
45 public:
46  Row<Rows, Cols, Type>(Matrix<Rows, Cols, Type> *parent, int index) :
47  parent_(parent), index_(index)
48  {}
49 
50  Type& operator[](int col)
51  {
52  // the index is the y-position of the element in the matrix
53  return parent_->data_[index_*Cols+col];
54  }
55 
56  const Type& operator[](int col) const
57  {
58  return parent_->data_[index_*Cols+col];
59  }
60 };
61 
62 } // detail
63 
64 // Matrix class
65 //
66 // Implements the base Matrix class that is inherited by other classes to make them more
67 // specific.
68 template<int Rows=4, int Cols=4, class Type=double> class Matrix
69 {
70  // friended with the row class so that it can access protected member data
71  friend class detail::Row<Rows, Cols, Type>;
72 protected:
73  std::vector<Type> data_;
74 
75 public:
76  Matrix<Rows, Cols, Type>() : data_(Rows*Cols) {}
77 
78  int rowSize() const
79  {
80  return Rows;
81  }
82 
83  int colSize() const
84  {
85  return Cols;
86  }
87 
88  // returns the row in a row matrix
89  Matrix<1, Cols, Type> getRow(int row) const
90  {
91  Matrix<1, Cols, Type> rowMatrix;
92  for(int i=0; i<Cols; ++i)
93  {
94  rowMatrix[0][i]=data_[row][i];
95  }
96  return rowMatrix;
97  }
98 
99  // returns the column in a column matrix
100  Matrix<Rows, 1, Type> getCol(int col) const
101  {
102  Matrix<Rows, 1, Type> colMatrix;
103  for(int i=0; i<Rows; ++i)
104  {
105  colMatrix[i][0]=data_[i][col];
106  }
107  return colMatrix;
108  }
109 
110  // iterator support for begin
111  typename std::vector<Type>::iterator begin()
112  {
113  return data_.begin();
114  }
115 
116  // iterator support for end
117  typename std::vector<Type>::iterator end()
118  {
119  return data_.end();
120  }
121 
122  // prints out the matrix, but can also be implemented by other classes to print data
123  // differently
124  virtual std::string toString() const
125  {
126  std::stringstream ss;
127  ss<<'[';
128  for(int i=0; i<Rows-1; ++i)
129  {
130  ss<<'[';
131  for(int j=0; j<Cols-1; ++j)
132  {
133  ss<<data_[i*Cols+j]<<' ';
134  }
135  ss<<data_[(Rows-1)*Cols+Cols-1]<<"],";
136  }
137  ss<<'[';
138  for(int j=0; j<Cols-1; ++j)
139  {
140  ss<<data_[(Rows-1)*Cols+j]<<' ';
141  }
142  ss<<data_[(Rows-1)*Cols+Cols-1]<<"]]";
143  return ss.str();
144  }
145 
146  detail::Row<Rows, Cols, Type> operator[](int row)
147  {
148  return detail::Row<Rows, Cols, Type>(this, row);
149  }
150 
151  detail::Row<Rows, Cols, Type> operator[](int row) const
152  {
153  // TODO got to fix this
154  return detail::Row<Rows, Cols, Type>((Matrix<Rows, Cols, Type>*)this, row);
155  }
156 
157  Matrix<Rows, Cols, Type>& operator=(const Matrix<Rows, Cols, Type> &other)
158  {
159  if(this!=&other)
160  {
161  data_=other.data_;
162  }
163  return *this;
164  }
165 
166  Matrix<Rows, Cols, Type>& operator+=(const Matrix<Rows, Cols, Type> &rhs)
167  {
168  std::vector<Type> out;
169  out.reserve(data_.size());
170  std::transform(data_.begin(), data_.end(), rhs.data_.begin(), std::back_inserter(out),
171  [] (Type a, Type b) {
172  return a+b;
173  });
174  data_=std::move(out);
175  return *this;
176  }
177 
178  Matrix<Rows, Cols, Type>& operator-=(const Matrix<Rows, Cols, Type> &rhs)
179  {
180  std::vector<Type> out;
181  out.reserve(data_.size());
182  std::transform(data_.begin(), data_.end(), rhs.begin(), std::back_inserter(out),
183  [] (Type a, Type b) {
184  return a-b;
185  });
186  data_=std::move(out);
187  return *this;
188  }
189 };
190 
191 template<int M, int N, class T>
192 Matrix<M, N, T> operator+(Matrix<M, N, T> lhs, const Matrix<M, N, T> &rhs)
193 {
194  lhs+=rhs;
195  return lhs;
196 }
197 
198 template<int M, int N, class T>
199 Matrix<M, N, T> operator-(Matrix<M, N, T> lhs, const Matrix<M, N, T> &rhs)
200 {
201  lhs-=rhs;
202  return lhs;
203 }
204 
205 template<int M, int N, class T>
206 Matrix<M, N, T> operator+(Matrix<M, N, T> lhs, const T &rhs)
207 {
208  for(auto &data : lhs)
209  {
210  data+=rhs;
211  }
212  return lhs;
213 }
214 
215 template<int M, int N, class T>
216 Matrix<M, N, T> operator+(const T &lhs, Matrix<M, N, T> rhs)
217 {
218  for(auto &data : rhs)
219  {
220  data+=lhs;
221  }
222  return rhs;
223 }
224 
225 template<int M, int N, class T>
226 Matrix<M, N, T> operator-(Matrix<M, N, T> lhs, const T &rhs)
227 {
228  for(auto &data : lhs)
229  {
230  data-=rhs;
231  }
232  return lhs;
233 }
234 
235 template<int M, int N, class T>
236 Matrix<M, N, T> operator-(const T &lhs, Matrix<M, N, T> rhs)
237 {
238  for(auto &data : rhs)
239  {
240  data=lhs-data;
241  }
242  return rhs;
243 }
244 
245 template<int M, int N, class T>
246 Matrix<M, N, T> operator*(Matrix<M, N, T> lhs, const T &rhs)
247 {
248  for(auto &data : lhs)
249  {
250  data*=rhs;
251  }
252  return lhs;
253 }
254 
255 template<int M, int N, class T>
256 Matrix<M, N, T> operator*(const T &lhs, Matrix<M, N, T> rhs)
257 {
258  for(auto &data : rhs)
259  {
260  data*=lhs;
261  }
262  return rhs;
263 }
264 
265 template<int M, int N, class T>
266 Matrix<M, N, T> operator/(Matrix<M, N, T> lhs, const T &rhs)
267 {
268  for(auto &data : lhs)
269  {
270  data/=rhs;
271  }
272  return lhs;
273 }
274 
275 template<int M, int N, class T>
276 bool operator==(const Matrix<M, N, T> &lhs, const Matrix<M, N, T> &rhs)
277 {
278  for(int i=0; i<M; ++i)
279  for(int j=0; j<N; ++j)
280  if(lhs[i][j]!=rhs[i][j])
281  return false;
282  return true;
283 }
284 
285 template<int M, int N, class T>
286 std::ostream& operator<<(std::ostream &os, const Matrix<M, N, T> &mat)
287 {
288  return os<<mat.toString();
289 }
290 
291 template<int Rows=2, class Type=double> class Vector : public Matrix<Rows, 1, Type>
292 {
293 public:
294  Vector<Rows, Type>() : Matrix<Rows, 1, Type>() {}
295  explicit Vector<Rows, Type>(const Matrix<Rows, 1, Type> &other) : Matrix<Rows, 1, Type>(other) {}
296 
297  Type& operator[](int col)
298  {
299  return this->data_[col];
300  }
301 
302  const Type& operator[](int col) const
303  {
304  return this->data_[col];
305  }
306 
307  virtual std::string toString() const
308  {
309  std::stringstream ss;
310  ss<<"[";
311  for(std::size_t i=0; i<this->data_.size()-1; ++i)
312  {
313  ss<<this->data_[i]<<" ";
314  }
315  ss<<this->data_[this->data_.size()-1]<<"]";
316  return ss.str();
317  }
318 };
319 
320 template<class Type=double> class Vector2 : public Vector<2, Type>
321 {
322 public:
323  Vector2<Type>() : Vector<2, Type>() {}
324 
325  Vector2<Type>(Type x, Type y)
326  {
327  this->data_[0]=x;
328  this->data_[1]=y;
329  }
330 
331  Vector2<Type>(const Matrix<2, 1, Type> &other) : Vector<2, Type>(other) {}
332 
333  Type& x()
334  {
335  return this->data_[0];
336  }
337 
338  const Type& x() const
339  {
340  return this->data_[0];
341  }
342 
343  Type& y()
344  {
345  return this->data_[1];
346  }
347 
348  const Type& y() const
349  {
350  return this->data_[1];
351  }
352 };
353 
354 typedef Vector2<double> Vector2d;
355 
356 namespace matrix
357 {
358 
359 template<int M, int N, class T> Matrix<N, M, T> transpose(const Matrix<M, N, T> &m)
360 {
361  Matrix<N, M, T> trans;
362  for(int i=0; i<M; ++i)
363  {
364  for(int j=0; j<N; ++j)
365  {
366  trans[j][i]=m[i][j];
367  }
368  }
369  return trans;
370 }
371 
372 template<int R, class T> T dot(const Matrix<R, 1, T> &m1, const Matrix<R, 1, T> &m2)
373 {
374  T sum=0;
375  for(int i=0; i<R; ++i)
376  {
377  sum += m1[i][0]*m2[i][0];
378  }
379  return sum;
380 }
381 
382 template<int M, int N, int P, int Q, class T>
383 Matrix<M, Q, T> multiply(const Matrix<M, N, T> &m1, const Matrix<P, Q, T> &m2)
384 {
385  if(N!=P)
386  {
387  throw std::runtime_error("Matrices don't have the right dimensions for multiplication");
388  }
389 
390  Matrix<M, Q, T> res;
391 
392  for(int i=0; i<M; ++i)
393  {
394  for(int j=0; j<Q; ++j)
395  {
396  res[i][j] = dot(transpose(m1.getRow(i)), m2.getCol(j));
397  }
398  }
399 
400  return res;
401 }
402 
403 } // matrix
404 
405 } // yage
406 
407 #endif
yage::Vector2
Definition: matrix.hpp:320
+
yage::detail::Row
Definition: matrix.hpp:39
+
yage::Vector
Definition: matrix.hpp:291
+
yage::Matrix
Definition: matrix.hpp:29
yage
Definition: camera2d.hpp:17
diff --git a/md_docs_README.html b/md_docs_README.html new file mode 100644 index 00000000..7aba4657 --- /dev/null +++ b/md_docs_README.html @@ -0,0 +1,75 @@ + + + + + + + +YAGE: Documentation + + + + + + + + + +
+
+ + + + + + +
+
YAGE +
+
Yet Another Game Engine
+
+
+ + + + + + + + +
+
+ + +
+ +
+ +
+
+
+
Documentation
+
+
+

Visit this page for the documentation.

+
+ +
+Generated by   +doxygen + 1.8.13 +
+ + diff --git a/pages.html b/pages.html index 2cd05aae..41187ae1 100644 --- a/pages.html +++ b/pages.html @@ -65,7 +65,8 @@ $(function() {
Here is a list of all related documentation pages:
- + +
 YAGE
 Documentation
 YAGE
diff --git a/particlebody_8hpp_source.html b/particlebody_8hpp_source.html index 4d0fb0c3..1b4af3dd 100644 --- a/particlebody_8hpp_source.html +++ b/particlebody_8hpp_source.html @@ -67,7 +67,8 @@ $(function() {
particlebody.hpp
-
1 /* ----------------------------------------------------------------------------
2  * particlebody.hpp
3  *
4  * Copyright (c) 2017 Yann Herklotz Grave <ymherklotz@gmail.com> -- MIT License
5  * See file LICENSE for more details
6  * ----------------------------------------------------------------------------
7  */
8 
9 #ifndef YAGE_PARTICLE_BODY_HPP
10 #define YAGE_PARTICLE_BODY_HPP
11 
12 #include "Math/matrix.hpp"
13 
14 #include "body.hpp"
15 
16 namespace yage
17 {
18 
19 class ParticleBody : public Body
20 {
21 public:
22  ParticleBody(const Vector2d &position=Vector2d(0, 0),
23  double mass=1,
24  const Vector2d &velocity=Vector2d(0, 0),
25  bool gravity=true);
26 
27  // apply a force to the rigid body
28  virtual void applyForce(const Vector2d &force);
29  virtual void update();
30 };
31 
32 } // yage
33 
34 #endif
+
1 /* ----------------------------------------------------------------------------
2  * particlebody.hpp
3  *
4  * Copyright (c) 2017 Yann Herklotz Grave <ymherklotz@gmail.com> -- MIT License
5  * See file LICENSE for more details
6  * ----------------------------------------------------------------------------
7  */
8 
9 #ifndef YAGE_PARTICLE_BODY_HPP
10 #define YAGE_PARTICLE_BODY_HPP
11 
12 #include "Math/matrix.hpp"
13 
14 #include "body.hpp"
15 
16 namespace yage
17 {
18 
19 class ParticleBody : public Body
20 {
21 public:
22  ParticleBody(const Vector2d &position=Vector2d(0, 0),
23  double mass=1,
24  const Vector2d &velocity=Vector2d(0, 0),
25  bool gravity=true);
26 
27  // apply a force to the rigid body
28  virtual void applyForce(const Vector2d &force);
29  virtual void update();
30 };
31 
32 } // yage
33 
34 #endif
matrix.hpp
Templated matrix class.
+
yage::ParticleBody
Definition: particlebody.hpp:19
yage::Body
Definition: body.hpp:17
yage
Definition: camera2d.hpp:17
diff --git a/search/all_2.js b/search/all_2.js index 2376c33c..733d4232 100644 --- a/search/all_2.js +++ b/search/all_2.js @@ -1,5 +1,4 @@ var searchData= [ - ['glslprogram',['GlslProgram',['../classyage_1_1GlslProgram.html',1,'yage']]], - ['glyph',['Glyph',['../classyage_1_1Glyph.html',1,'yage']]] + ['documentation',['Documentation',['../md_docs_README.html',1,'']]] ]; diff --git a/search/all_3.js b/search/all_3.js index 04ae98e8..2376c33c 100644 --- a/search/all_3.js +++ b/search/all_3.js @@ -1,6 +1,5 @@ var searchData= [ - ['imageloader',['ImageLoader',['../classyage_1_1ImageLoader.html',1,'yage']]], - ['inputmanager',['InputManager',['../classyage_1_1InputManager.html',1,'yage']]], - ['iomanager',['IoManager',['../classyage_1_1IoManager.html',1,'yage']]] + ['glslprogram',['GlslProgram',['../classyage_1_1GlslProgram.html',1,'yage']]], + ['glyph',['Glyph',['../classyage_1_1Glyph.html',1,'yage']]] ]; diff --git a/search/all_4.js b/search/all_4.js index b3ac49ff..04ae98e8 100644 --- a/search/all_4.js +++ b/search/all_4.js @@ -1,6 +1,6 @@ var searchData= [ - ['matrix',['Matrix',['../classyage_1_1Matrix.html',1,'yage']]], - ['matrix_3c_20rows_2c_201_2c_20double_20_3e',['Matrix< Rows, 1, double >',['../classyage_1_1Matrix.html',1,'yage']]], - ['matrix_3c_20rows_2c_201_2c_20type_20_3e',['Matrix< Rows, 1, Type >',['../classyage_1_1Matrix.html',1,'yage']]] + ['imageloader',['ImageLoader',['../classyage_1_1ImageLoader.html',1,'yage']]], + ['inputmanager',['InputManager',['../classyage_1_1InputManager.html',1,'yage']]], + ['iomanager',['IoManager',['../classyage_1_1IoManager.html',1,'yage']]] ]; diff --git a/search/all_5.js b/search/all_5.js index d616947f..b656eba7 100644 --- a/search/all_5.js +++ b/search/all_5.js @@ -1,5 +1,7 @@ var searchData= [ - ['particlebody',['ParticleBody',['../classyage_1_1ParticleBody.html',1,'yage']]], - ['position',['Position',['../structyage_1_1Position.html',1,'yage']]] + ['matrix',['Matrix',['../classyage_1_1Matrix.html',1,'yage']]], + ['matrix_2ehpp',['matrix.hpp',['../matrix_8hpp.html',1,'']]], + ['matrix_3c_20rows_2c_201_2c_20double_20_3e',['Matrix< Rows, 1, double >',['../classyage_1_1Matrix.html',1,'yage']]], + ['matrix_3c_20rows_2c_201_2c_20type_20_3e',['Matrix< Rows, 1, Type >',['../classyage_1_1Matrix.html',1,'yage']]] ]; diff --git a/search/all_6.js b/search/all_6.js index 1f9a4487..d616947f 100644 --- a/search/all_6.js +++ b/search/all_6.js @@ -1,8 +1,5 @@ var searchData= [ - ['rectanglecollider',['RectangleCollider',['../classyage_1_1RectangleCollider.html',1,'yage']]], - ['renderbatch',['RenderBatch',['../classyage_1_1RenderBatch.html',1,'yage']]], - ['resourcemanager',['ResourceManager',['../classyage_1_1ResourceManager.html',1,'yage']]], - ['rigidbody',['RigidBody',['../classyage_1_1RigidBody.html',1,'yage']]], - ['row',['Row',['../classyage_1_1detail_1_1Row.html',1,'yage::detail']]] + ['particlebody',['ParticleBody',['../classyage_1_1ParticleBody.html',1,'yage']]], + ['position',['Position',['../structyage_1_1Position.html',1,'yage']]] ]; diff --git a/search/all_7.js b/search/all_7.js index 8d412bde..1f9a4487 100644 --- a/search/all_7.js +++ b/search/all_7.js @@ -1,5 +1,8 @@ var searchData= [ - ['sprite',['Sprite',['../classyage_1_1Sprite.html',1,'yage']]], - ['spritebatch',['SpriteBatch',['../classyage_1_1SpriteBatch.html',1,'yage']]] + ['rectanglecollider',['RectangleCollider',['../classyage_1_1RectangleCollider.html',1,'yage']]], + ['renderbatch',['RenderBatch',['../classyage_1_1RenderBatch.html',1,'yage']]], + ['resourcemanager',['ResourceManager',['../classyage_1_1ResourceManager.html',1,'yage']]], + ['rigidbody',['RigidBody',['../classyage_1_1RigidBody.html',1,'yage']]], + ['row',['Row',['../classyage_1_1detail_1_1Row.html',1,'yage::detail']]] ]; diff --git a/search/all_8.js b/search/all_8.js index de48a562..8d412bde 100644 --- a/search/all_8.js +++ b/search/all_8.js @@ -1,7 +1,5 @@ var searchData= [ - ['test',['Test',['../structTest.html',1,'']]], - ['testbench',['TestBench',['../classTestBench.html',1,'']]], - ['texture',['Texture',['../structyage_1_1Texture.html',1,'yage']]], - ['texturecache',['TextureCache',['../classyage_1_1TextureCache.html',1,'yage']]] + ['sprite',['Sprite',['../classyage_1_1Sprite.html',1,'yage']]], + ['spritebatch',['SpriteBatch',['../classyage_1_1SpriteBatch.html',1,'yage']]] ]; diff --git a/search/all_9.js b/search/all_9.js index 92c686bb..de48a562 100644 --- a/search/all_9.js +++ b/search/all_9.js @@ -1,4 +1,7 @@ var searchData= [ - ['uv',['UV',['../structyage_1_1UV.html',1,'yage']]] + ['test',['Test',['../structTest.html',1,'']]], + ['testbench',['TestBench',['../classTestBench.html',1,'']]], + ['texture',['Texture',['../structyage_1_1Texture.html',1,'yage']]], + ['texturecache',['TextureCache',['../classyage_1_1TextureCache.html',1,'yage']]] ]; diff --git a/search/all_a.js b/search/all_a.js index afb8654e..92c686bb 100644 --- a/search/all_a.js +++ b/search/all_a.js @@ -1,9 +1,4 @@ var searchData= [ - ['vector',['Vector',['../classyage_1_1Vector.html',1,'yage']]], - ['vector2',['Vector2',['../classyage_1_1Vector2.html',1,'yage']]], - ['vector2_3c_20double_20_3e',['Vector2< double >',['../classyage_1_1Vector2.html',1,'yage']]], - ['vector_3c_202_2c_20double_20_3e',['Vector< 2, double >',['../classyage_1_1Vector.html',1,'yage']]], - ['vector_3c_202_2c_20type_20_3e',['Vector< 2, Type >',['../classyage_1_1Vector.html',1,'yage']]], - ['vertex',['Vertex',['../structyage_1_1Vertex.html',1,'yage']]] + ['uv',['UV',['../structyage_1_1UV.html',1,'yage']]] ]; diff --git a/search/all_b.js b/search/all_b.js index 50e8b3e6..afb8654e 100644 --- a/search/all_b.js +++ b/search/all_b.js @@ -1,4 +1,9 @@ var searchData= [ - ['window',['Window',['../classyage_1_1Window.html',1,'yage']]] + ['vector',['Vector',['../classyage_1_1Vector.html',1,'yage']]], + ['vector2',['Vector2',['../classyage_1_1Vector2.html',1,'yage']]], + ['vector2_3c_20double_20_3e',['Vector2< double >',['../classyage_1_1Vector2.html',1,'yage']]], + ['vector_3c_202_2c_20double_20_3e',['Vector< 2, double >',['../classyage_1_1Vector.html',1,'yage']]], + ['vector_3c_202_2c_20type_20_3e',['Vector< 2, Type >',['../classyage_1_1Vector.html',1,'yage']]], + ['vertex',['Vertex',['../structyage_1_1Vertex.html',1,'yage']]] ]; diff --git a/search/all_c.js b/search/all_c.js index 950425e7..50e8b3e6 100644 --- a/search/all_c.js +++ b/search/all_c.js @@ -1,4 +1,4 @@ var searchData= [ - ['yage',['YAGE',['../md_README.html',1,'']]] + ['window',['Window',['../classyage_1_1Window.html',1,'yage']]] ]; diff --git a/search/all_d.html b/search/all_d.html new file mode 100644 index 00000000..9986c9cb --- /dev/null +++ b/search/all_d.html @@ -0,0 +1,26 @@ + + + + + + + + + +
+
Loading...
+
+ +
Searching...
+
No Matches
+ +
+ + diff --git a/search/all_d.js b/search/all_d.js new file mode 100644 index 00000000..950425e7 --- /dev/null +++ b/search/all_d.js @@ -0,0 +1,4 @@ +var searchData= +[ + ['yage',['YAGE',['../md_README.html',1,'']]] +]; diff --git a/search/files_0.html b/search/files_0.html new file mode 100644 index 00000000..4f272b83 --- /dev/null +++ b/search/files_0.html @@ -0,0 +1,26 @@ + + + + + + + + + +
+
Loading...
+
+ +
Searching...
+
No Matches
+ +
+ + diff --git a/search/files_0.js b/search/files_0.js new file mode 100644 index 00000000..7ca716f6 --- /dev/null +++ b/search/files_0.js @@ -0,0 +1,4 @@ +var searchData= +[ + ['matrix_2ehpp',['matrix.hpp',['../matrix_8hpp.html',1,'']]] +]; diff --git a/search/pages_0.js b/search/pages_0.js index 950425e7..733d4232 100644 --- a/search/pages_0.js +++ b/search/pages_0.js @@ -1,4 +1,4 @@ var searchData= [ - ['yage',['YAGE',['../md_README.html',1,'']]] + ['documentation',['Documentation',['../md_docs_README.html',1,'']]] ]; diff --git a/search/pages_1.html b/search/pages_1.html new file mode 100644 index 00000000..aedb14ee --- /dev/null +++ b/search/pages_1.html @@ -0,0 +1,26 @@ + + + + + + + + + +
+
Loading...
+
+ +
Searching...
+
No Matches
+ +
+ + diff --git a/search/pages_1.js b/search/pages_1.js new file mode 100644 index 00000000..950425e7 --- /dev/null +++ b/search/pages_1.js @@ -0,0 +1,4 @@ +var searchData= +[ + ['yage',['YAGE',['../md_README.html',1,'']]] +]; diff --git a/search/searchdata.js b/search/searchdata.js index 45dbfb48..b9610786 100644 --- a/search/searchdata.js +++ b/search/searchdata.js @@ -1,21 +1,24 @@ var indexSectionsWithContent = { - 0: "bcgimprstuvwy", + 0: "bcdgimprstuvwy", 1: "bcgimprstuvw", - 2: "y" + 2: "m", + 3: "dy" }; var indexSectionNames = { 0: "all", 1: "classes", - 2: "pages" + 2: "files", + 3: "pages" }; var indexSectionLabels = { 0: "All", 1: "Classes", - 2: "Pages" + 2: "Files", + 3: "Pages" }; -- cgit