Small OpenGL based c++ rendering library
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.

punkt3d.cpp 4.6KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250
  1. #include "punkt3d.h"
  2. namespace segl {
  3. Punkt3D::Punkt3D() {
  4. x = y = z = 0.0f;
  5. }
  6. Punkt3D::Punkt3D(float _x, float _y, float _z) {
  7. set(_x, _y, _z);
  8. }
  9. void Punkt3D::set(float _x, float _y, float _z) {
  10. x = _x;
  11. y = _y;
  12. z = _z;
  13. }
  14. float Punkt3D::abs() const {
  15. return sqrt(x*x+y*y+z*z);
  16. }
  17. Punkt3D Punkt3D::kreuzprodukt(const Punkt3D &b) const {
  18. Punkt3D erg;
  19. erg.x = y*b.z - z*b.y;
  20. erg.y = z*b.x - x*b.z;
  21. erg.z = x*b.y - y*b.x;
  22. return erg;
  23. }
  24. void Punkt3D::normalize() {
  25. float a = abs();
  26. x /= a;
  27. y /= a;
  28. z /= a;
  29. }
  30. Punkt3D Punkt3D::getNormalized() const {
  31. Punkt3D ret(*this);
  32. ret.normalize();
  33. return ret;
  34. }
  35. bool Punkt3D::isNormalized() const {
  36. return (abs()==1.0f);
  37. }
  38. float Punkt3D::calcAngle(Punkt3D b) const {
  39. if(abs()*b.abs()==0.0f)
  40. return 0.0f;
  41. return rad2deg(std::acos(((*this)*b)/(abs()*b.abs())));
  42. }
  43. Punkt3D Punkt3D::getOrtographic() const {
  44. Punkt3D erg;
  45. if(!x) {
  46. erg.x = 0.0f;
  47. erg.y = z;
  48. erg.z = -y;
  49. } else if(!y) {
  50. erg.x = z;
  51. erg.y = 0;
  52. erg.z = -x;
  53. } else {
  54. // z, oder genereller fall
  55. erg.x = y;
  56. erg.y = -x;
  57. erg.z = 0.0f;
  58. }
  59. return erg;
  60. }
  61. Punkt3D Punkt3D::getOrtographic2() const {
  62. Punkt3D nullvec;
  63. Punkt3D erg;
  64. erg.set(y, -x, 0.0f);
  65. if(erg!=nullvec)
  66. return erg;
  67. erg.set(z, 0.0f, -x);
  68. if(erg!=nullvec)
  69. return erg;
  70. erg.set(0.0f, z, -y);
  71. return erg;
  72. }
  73. void Punkt3D::print(std::string coordname) const {
  74. if(coordname!="")
  75. coordname.append(" ");
  76. std::cout << coordname << "Coord: (" << x << ", " << y << ", " << z << ")" << std::endl;
  77. }
  78. Punkt3D Punkt3D::operator+(const Punkt3D &b) const {
  79. Punkt3D c;
  80. c.x = x + b.x;
  81. c.y = y + b.y;
  82. c.z = z + b.z;
  83. return c;
  84. }
  85. Punkt3D Punkt3D::operator-(const Punkt3D &b) const {
  86. Punkt3D c;
  87. c.x = x - b.x;
  88. c.y = y - b.y;
  89. c.z = z - b.z;
  90. return c;
  91. }
  92. Punkt3D& Punkt3D::operator+=(const Punkt3D &b) {
  93. x += b.x;
  94. y += b.y;
  95. z += b.z;
  96. return *this;
  97. }
  98. Punkt3D& Punkt3D::operator-=(const Punkt3D &b) {
  99. x -= b.x;
  100. y -= b.y;
  101. z -= b.z;
  102. return *this;
  103. }
  104. Punkt3D Punkt3D::operator+(const float &_m) const {
  105. return Punkt3D(x+_m, y+_m, z+_m);
  106. }
  107. Punkt3D Punkt3D::operator-(const float &_m) const {
  108. return Punkt3D(x-_m, y-_m, z-_m);
  109. }
  110. Punkt3D Punkt3D::operator*(const float &_m) const {
  111. return Punkt3D(x*_m, y*_m, z*_m);
  112. }
  113. Punkt3D Punkt3D::operator/(const float &_m) const {
  114. return Punkt3D(x/_m, y/_m, z/_m);
  115. }
  116. Punkt3D& Punkt3D::operator+=(const float &_m) {
  117. x += _m;
  118. y += _m;
  119. z += _m;
  120. return *this;
  121. }
  122. Punkt3D& Punkt3D::operator-=(const float &_m) {
  123. x -= _m;
  124. y -= _m;
  125. z -= _m;
  126. return *this;
  127. }
  128. Punkt3D& Punkt3D::operator*=(const float &_m) {
  129. x *= _m;
  130. y *= _m;
  131. z *= _m;
  132. return *this;
  133. }
  134. Punkt3D& Punkt3D::operator/=(const float &_m) {
  135. x /= _m;
  136. y /= _m;
  137. z /= _m;
  138. return *this;
  139. }
  140. float Punkt3D::operator*(const Punkt3D& _m) const {
  141. return x * _m.x + y * _m.y + z * _m.z;
  142. }
  143. Punkt3D Punkt3D::operator-() const {
  144. return Punkt3D(-x, -y, -z);
  145. }
  146. bool Punkt3D::operator==(const Punkt3D& b) const {
  147. return ( x==b.x && y==b.y && z==b.z);
  148. }
  149. bool Punkt3D::operator!=(const Punkt3D& b) const {
  150. return !(*this==b);
  151. }
  152. // Freunde
  153. segl::Punkt3D operator+(const float& _m, const segl::Punkt3D& b) {
  154. return segl::Punkt3D(b.x+_m, b.y+_m, b.z+_m);
  155. }
  156. segl::Punkt3D operator-(const float& _m, const segl::Punkt3D& b) {
  157. return segl::Punkt3D(b.x-_m, b.y-_m, b.z-_m);
  158. }
  159. segl::Punkt3D operator*(const float& _m, const segl::Punkt3D& b) {
  160. return segl::Punkt3D(b.x*_m, b.y*_m, b.z*_m);
  161. }
  162. segl::Punkt3D operator/(const float& _m, const segl::Punkt3D& b) {
  163. return segl::Punkt3D(b.x/_m, b.y/_m, b.z/_m);
  164. }
  165. std::ostream &operator<<(std::ostream &ostr, const segl::Punkt3D &r) {
  166. return ostr << "(" << r.x << ", " << r.y << ", " << r.z << ")";
  167. }
  168. } // namespace segl
  169. float abs(const segl::Punkt3D &p) {
  170. return p.abs();
  171. }
  172. // OpenGL Funktionen f�r Punkt3D
  173. void glVertex3f(const segl::Punkt3D &p) {
  174. glVertex3f(p.x, p.y, p.z);
  175. }
  176. void glTranslatef(const segl::Punkt3D &p) {
  177. glTranslatef(p.x, p.y, p.z);
  178. }
  179. void glNormal3f(const segl::Punkt3D &p) {
  180. glNormal3f(p.x, p.y, p.z);
  181. }
  182. void glRotatef(const float &deg, const segl::Punkt3D &vec) {
  183. glRotatef(deg, vec.x, vec.y, vec.z);
  184. }
  185. // Funktionen mit richtgen bezeichnern
  186. void glVertexP3D(const segl::Punkt3D &p) {
  187. glVertex3f(p.x, p.y, p.z);
  188. }
  189. void glTranslateP3D(const segl::Punkt3D &p) {
  190. glTranslatef(p.x, p.y, p.z);
  191. }
  192. void glNormalP3D(const segl::Punkt3D &p) {
  193. glNormal3f(p.x, p.y, p.z);
  194. }
  195. void glRotateP3D(const float &deg, const segl::Punkt3D &vec) {
  196. glRotatef(deg, vec.x, vec.y, vec.z);
  197. }
  198. void gluLookAt(const segl::Punkt3D &pos, const segl::Punkt3D &viewport, const segl::Punkt3D &normal) {
  199. gluLookAt( pos.x, pos.y, pos.z,
  200. viewport.x, viewport.y, viewport.z,
  201. normal.x, normal.y, normal.z );
  202. }