001:
002:
003:
004:
005:
006:
007:
008:
009:
010:
011:
012:
013:
014:
015:
016:
017:
018:
019:
020:
021:
022:
023:
024:
025:
026:
027:
028:
029:
030:
031:
032:
033:
034:
035:
036:
037:
038:
039:
040:
041:
042:
043:
044:
045:
046:
047:
048:
049:
050:
051:
052:
053:
054:
055:
056:
057:
058:
059:
060:
061:
062:
063:
064:
065:
066:
067:
068:
069:
070:
071:
072:
073:
074:
075:
076:
077:
078:
079:
080:
081:
082:
083:
084:
085:
086:
087:
088:
089:
090:
091:
092:
093:
094:
095:
096:
097:
098:
099:
100:
101:
102:
103:
104:
105:
106:
107:
108:
109:
110:
111:
112:
113:
114:
115:
116:
117:
118:
119:
120:
121:
122:
123:
124:
125:
126:
127:
128:
129:
130:
131:
132:
133:
134:
135:
136:
137:
138:
139:
140:
141:
142:
143:
144:
145:
146:
147:
148:
149:
150:
151:
152:
153:
154:
155:
156:
157:
158:
159:
160:
161:
162:
163:
164:
165:
166:
167:
168:
169:
170:
171:
172:
173:
174:
175:
176:
177:
178:
179:
180:
181:
182:
183:
184:
185:
186:
187:
188:
189:
190:
191:
192:
193:
194:
195:
196:
197:
198:
199:
200:
201:
202:
203:
204:
205:
206:
207:
208:
209:
210:
211:
212:
213:
214:
215:
216:
217:
218:
219:
220:
221:
222:
223:
224:
225:
226:
227:
228:
229:
230:
231:
232:
233:
234:
235:
236:
237:
238:
239:
240:
241:
242:
243:
244:
245:
246:
247:
248:
249:
250:
251:
252:
253:
254:
255:
256:
257:
258:
259:
260:
261:
262:
263:
264:
265:
266:
267:
268:
269:
270:
271:
272:
273:
274:
275:
276:
277:
278:
279:
280:
281:
282:
283:
284:
285:
286:
287:
288:
289:
290:
291:
292:
293:
294:
295:
296:
297:
298:
299:
300:
301:
302:
303:
304:
305:
306:
307:
308:
309:
310:
311:
312:
313:
314:
315:
316:
317:
318:
319:
320:
321:
322:
323:
324:
325:
326:
327:
328:
329:
330:
331:
332:
333:
334:
335:
336:
337:
338:
339:
340:
341:
342:
343:
344:
345:
346:
347:
348:
349:
350:
351:
352:
353:
354:
355:
356:
357:
358:
359:
360:
361:
362:
363:
364:
365:
366:
367:
368:
369:
370:
371:
372:
373:
374:
375:
376:
377:
378:
379:
380:
381:
382:
383:
384:
385:
386:
387:
388:
389:
390:
391:
392:
393:
394:
395:
396:
397:
398:
399:
400:
401:
402:
403:
404:
405:
406:
407:
408:
409:
410:
411:
412:
413:
414:
415:
416:
417:
418:
419:
420:
421:
422:
423:
424:
425:
426:
427:
428:
429:
430:
431:
432:
433:
434:
435:
436:
437:
438:
439:
440:
441:
442:
443:
444:
445:
446:
447:
448:
449:
450:
451:
452:
453:
454:
455:
456:
457:
458:
459:
460:
461:
462:
463:
464:
465:
466:
467:
468:
469:
470:
471:
472:
473:
474:
475:
476:
477:
478:
479:
480:
481:
482:
483:
484:
485:
486:
487:
488:
489:
490:
491:
492:
493:
494:
495:
496:
497:
498:
499:
500:
501:
502:
503:
504:
505:
506:
507:
508:
509:
510:
511:
512:
513:
514:
515:
516:
517:
518:
519:
520:
521:
522:
523:
524:
525:
526:
527:
528:
529:
530:
531:
532:
533:
534:
535:
536:
537:
538:
539:
540:
541:
542:
543:
544:
545:
546:
547:
548:
549:
550:
551:
552:
553:
554:
555:
556:
557:
558:
559:
560:
561:
562:
563:
564:
565:
566:
567:
568:
569:
570:
571:
572:
573:
574:
575:
576:
577:
578:
579:
580:
581:
582:
583:
584:
585:
586:
587:
588:
589:
590:
591:
592:
593:
594:
595:
596:
597:
598:
599:
600:
601:
602:
603:
604:
605:
606:
607:
608:
609:
610:
611:
612:
613:
614:
615:
616:
617:
618:
619:
620:
621:
622:
623:
624:
625:
626:
627:
628:
629:
630:
631:
632:
633:
634:
635:
636:
637:
638:
639:
640:
641:
642:
643:
644:
645:
646:
647:
648:
649:
650:
651:
652:
653:
654:
655:
656:
657:
658:
659:
660:
661:
662:
663:
664:
665:
666:
667:
668:
669:
670:
671:
672:
673:
674:
675:
676:
677:
678:
679:
680:
681:
682:
683:
684:
685:
686:
687:
688:
689:
690:
691:
692:
693:
694:
695:
696:
697:
698:
699:
700:
701:
702:
703:
704:
705:
706:
707:
708:
709:
710:
711:
712:
713:
714:
715:
716:
717:
718:
719:
720:
721:
722:
723:
724:
725:
726:
727:
728:
729:
730:
731:
732:
733:
734:
735:
736:
737:
738:
739:
740:
741:
742:
743:
744:
745:
746:
747:
748:
749:
750:
751:
752:
753:
754:
755:
756:
757:
758:
759:
760:
761:
762:
/*
* Copyright (c), Zeriph Enterprises
* All rights reserved.
*
* Contributor(s):
* Zechariah Perez, omni (at) zeriph (dot) com
*
* THIS SOFTWARE IS PROVIDED BY ZERIPH AND CONTRIBUTORS "AS IS" AND ANY
* EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL ZERIPH AND CONTRIBUTORS BE LIABLE FOR ANY
* DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
* ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#if !defined(OMNI_VECTOR3_HPP)
#define OMNI_VECTOR3_HPP 1
#include <omni/defs/global.hpp>
#include <omni/defs/class_macros.hpp>
#include <omni/geometry/point3d.hpp>
#if defined(OMNI_SAFE_VECTOR3)
#include <omni/sync/basic_lock.hpp>
#define OMNI_SAFE_VEC3MTX_FW ,m_mtx()
#define OMNI_SAFE_VEC3LOCK_FW this->m_mtx.lock();
#define OMNI_SAFE_VEC3UNLOCK_FW this->m_mtx.unlock();
#define OMNI_SAFE_VEC3ALOCK_FW omni::sync::scoped_basic_lock uuid12345(&this->m_mtx);
#define OMNI_SAFE_VEC3OALOCK_FW(o) omni::sync::scoped_basic_lock uuid54321(&o.m_mtx);
#else
#define OMNI_SAFE_VEC3MTX_FW
#define OMNI_SAFE_VEC3LOCK_FW
#define OMNI_SAFE_VEC3UNLOCK_FW
#define OMNI_SAFE_VEC3ALOCK_FW
#define OMNI_SAFE_VEC3OALOCK_FW(o)
#endif
namespace omni {
namespace geometry {
template < typename V >
class vector3
{
public:
typedef V coordinate_t;
typedef omni::geometry::point3d<V> point3d_t;
vector3() :
OMNI_CTOR_FW(omni::geometry::vector3)
m_sx(0.0), m_sy(0.0), m_sz(0.0), m_x(), m_y(), m_z()
OMNI_SAFE_VEC3MTX_FW
{
}
vector3(const omni::geometry::vector3<V>& cp) :
OMNI_CPCTOR_FW(cp)
m_sx(cp.start_x()), m_sy(cp.start_y()), m_sz(cp.start_z()), m_x(cp.x()), m_y(cp.y()), m_z(cp.z())
OMNI_SAFE_VEC3MTX_FW
{
}
template < typename T >
vector3(const omni::geometry::point3d<T>& head) :
OMNI_CTOR_FW(omni::geometry::vector3)
m_sx(0.0), m_sy(0.0), m_sz(0.0), m_x(head.x()), m_y(head.y()), m_z(head.z())
OMNI_SAFE_VEC3MTX_FW
{
}
template < typename T >
vector3(const omni::geometry::point3d<T>& tail, const omni::geometry::point3d<T>& head) :
OMNI_CTOR_FW(omni::geometry::vector3)
m_sx(tail.x()), m_sy(tail.y()), m_sz(tail.z()), m_x(head.x()), m_y(head.y()), m_z(head.z())
OMNI_SAFE_VEC3MTX_FW
{
}
template < typename T >
vector3(const omni::math::dimensional<T, 3>& head) :
OMNI_CTOR_FW(omni::geometry::vector3)
m_sx(0.0), m_sy(0.0), m_sz(0.0), m_x(head[0]), m_y(head[1]), m_z(head[2])
OMNI_SAFE_VEC3MTX_FW
{
}
template < typename T >
vector3(const omni::math::dimensional<T, 3>& tail, const omni::math::dimensional<T, 3>& head) :
OMNI_CTOR_FW(omni::geometry::vector3)
m_sx(tail[0]), m_sy(tail[1]), m_sz(tail[2]), m_x(head[0]), m_y(head[1]), m_z(head[2])
OMNI_SAFE_VEC3MTX_FW
{
}
vector3(V x, V y, V z) :
m_sx(0.0), m_sy(0.0), m_sz(0.0), m_x(x), m_y(y), m_z(z)
OMNI_SAFE_VEC3MTX_FW
{
}
vector3(V start_x, V start_y, V start_z, V x, V y, V z) :
m_sx(start_x), m_sy(start_y), m_sz(start_z), m_x(x), m_y(y), m_z(z)
OMNI_SAFE_VEC3MTX_FW
{
}
~vector3()
{
OMNI_TRY_FW
OMNI_DTOR_FW
OMNI_CATCH_FW
OMNI_D5_FW("destroyed");
}
double angle_between(const omni::geometry::vector3<V>& b)
{
OMNI_SAFE_VEC3ALOCK_FW
return OMNI_RAD_TO_DEG((this->_dot_product(b) / (this->_magnitude() * b._magnitude())));
}
omni::geometry::vector3<V>& assign(V start_x, V start_y, V start_z, V x, V y, V z)
{
OMNI_SAFE_VEC3ALOCK_FW
this->m_sx = start_x;
this->m_sy = start_y;
this->m_sz = start_z;
this->m_x = x;
this->m_y = y;
this->m_z = z;
return *this;
}
template < typename T >
omni::geometry::vector3<V>& assign(const omni::geometry::point3d<T>& tail, const omni::geometry::point3d<T>& head)
{
return this->assign(
static_cast<V>(tail.x()),
static_cast<V>(tail.y()),
static_cast<V>(tail.z()),
static_cast<V>(head.x()),
static_cast<V>(head.y()),
static_cast<V>(head.z())
);
}
template < typename T >
omni::geometry::vector3<V>& assign(const omni::math::dimensional<T, 3>& tail, const omni::math::dimensional<T, 3>& head)
{
return this->assign(
static_cast<V>(tail[0]),
static_cast<V>(tail[1]),
static_cast<V>(tail[2]),
static_cast<V>(head[0]),
static_cast<V>(head[1]),
static_cast<V>(head[2])
);
}
omni::geometry::vector3<V>& assign_head(V x, V y, V z)
{
OMNI_SAFE_VEC3ALOCK_FW
this->m_x = x;
this->m_y = y;
this->m_z = z;
return *this;
}
template < typename T >
omni::geometry::vector3<V>& assign_head(const omni::geometry::point3d<T>& head)
{
return this->assign_head(
static_cast<V>(head.x()),
static_cast<V>(head.y()),
static_cast<V>(head.z())
);
}
template < typename T >
omni::geometry::vector3<V>& assign_head(const omni::math::dimensional<T, 3>& head)
{
return this->assign_head(
static_cast<V>(head[0]),
static_cast<V>(head[1]),
static_cast<V>(head[2])
);
}
omni::geometry::vector3<V>& assign_tail(V start_x, V start_y, V start_z)
{
OMNI_SAFE_VEC3ALOCK_FW
this->m_sx = start_x;
this->m_sy = start_y;
this->m_sz = start_z;
return *this;
}
template < typename T >
omni::geometry::vector3<V>& assign_tail(const omni::geometry::point3d<T>& tail)
{
return this->assign_tail(
static_cast<V>(tail.x()),
static_cast<V>(tail.y()),
static_cast<V>(tail.z())
);
}
template < typename T >
omni::geometry::vector3<V>& assign_tail(const omni::math::dimensional<T, 3>& tail)
{
return this->assign_tail(
static_cast<V>(tail[0]),
static_cast<V>(tail[1]),
static_cast<V>(tail[2])
);
}
omni::geometry::vector3<V> cross_product(const omni::geometry::vector3<V>& b) const
{
OMNI_SAFE_VEC3ALOCK_FW
if (this != &b) {
OMNI_SAFE_VEC3OALOCK_FW(b)
/*
3d
c.x = a.y * b.z − a.z * b.y
c.y = a.z * b.x − a.x * b.z
c.z = a.x * b.y − a.y * b.x
*/
OMNI_BITS_WILL_MUL_OVER_FW(this->m_y, b.m_z)
OMNI_BITS_WILL_MUL_OVER_FW(this->m_z, b.m_y)
OMNI_BITS_WILL_MUL_OVER_FW(this->m_z, b.m_x)
OMNI_BITS_WILL_MUL_OVER_FW(this->m_x, b.m_z)
OMNI_BITS_WILL_MUL_OVER_FW(this->m_x, b.m_y)
OMNI_BITS_WILL_MUL_OVER_FW(this->m_y, b.m_x)
return omni::geometry::vector3<V>(
((this->m_y * b.m_z) - (this->m_z * b.m_y)), // x
((this->m_z * b.m_x) - (this->m_x * b.m_z)), // y
((this->m_x * b.m_y) - (this->m_y * b.m_x)) // z
);
}
OMNI_BITS_WILL_MUL_OVER_FW(this->m_y, b.m_z)
OMNI_BITS_WILL_MUL_OVER_FW(this->m_z, b.m_y)
OMNI_BITS_WILL_MUL_OVER_FW(this->m_z, b.m_x)
OMNI_BITS_WILL_MUL_OVER_FW(this->m_x, b.m_z)
OMNI_BITS_WILL_MUL_OVER_FW(this->m_x, b.m_y)
OMNI_BITS_WILL_MUL_OVER_FW(this->m_y, b.m_x)
return omni::geometry::vector3<V>(
((this->m_y * b.m_z) - (this->m_z * b.m_y)), // x
((this->m_z * b.m_x) - (this->m_x * b.m_z)), // y
((this->m_x * b.m_y) - (this->m_y * b.m_x)) // z
);
}
V dot_product(const omni::geometry::vector3<V>& b) const
{
OMNI_SAFE_VEC3ALOCK_FW
if (this != &b) {
OMNI_SAFE_VEC3OALOCK_FW(b)
return this->_dot_product(b);
}
return this->_dot_product(b);
}
double direction_x() const
{
OMNI_SAFE_VEC3ALOCK_FW
return this->_direction_x();
}
double direction_y() const
{
OMNI_SAFE_VEC3ALOCK_FW
return this->_direction_y();
}
double direction_z() const
{
OMNI_SAFE_VEC3ALOCK_FW
return this->_direction_z();
}
omni::geometry::point3d<double> direction_cosines() const
{
OMNI_SAFE_VEC3ALOCK_FW
return omni::geometry::point3d<double>(
std::cos(this->_x() / this->_magnitude()),
std::cos(this->_y() / this->_magnitude()),
std::cos(this->_z() / this->_magnitude())
);
}
long double distance_from(const omni::geometry::vector3<V>& b)
{
OMNI_SAFE_VEC3ALOCK_FW
if (this != &b) {
OMNI_SAFE_VEC3OALOCK_FW(b)
return std::sqrt(
((b._x() - this->_x()) * (b._x() - this->_x())) +
((b._y() - this->_y()) * (b._y() - this->_y())) +
((b._z() - this->_z()) * (b._z() - this->_z()))
);
}
return std::sqrt(
((b._x() - this->_x()) * (b._x() - this->_x())) +
((b._y() - this->_y()) * (b._y() - this->_y())) +
((b._z() - this->_z()) * (b._z() - this->_z()))
);
}
int32_t hash_code() const
{
OMNI_SAFE_VEC3ALOCK_FW
return (
static_cast<int32_t>(this->m_sx) ^
((static_cast<int32_t>(this->m_sy) << 13) | (static_cast<int32_t>(this->m_sy) >> 19)) ^
((static_cast<int32_t>(this->m_sz) << 20) | (static_cast<int32_t>(this->m_sz) >> 14)) ^
((static_cast<int32_t>(this->m_x) << 26) | (static_cast<int32_t>(this->m_x) >> 6)) ^
((static_cast<int32_t>(this->m_y) << 7) | (static_cast<int32_t>(this->m_y) >> 25)) ^
((static_cast<int32_t>(this->m_z) << 24) | (static_cast<int32_t>(this->m_z) >> 8))
);
}
point3d_t head() const
{
OMNI_SAFE_VEC3ALOCK_FW
return point3d_t(this->m_x, this->m_y, this->m_z);
}
bool is_standard_form() const
{
OMNI_SAFE_VEC3ALOCK_FW
return (
omni::math::are_equal<V>(this->m_sx, 0) &&
omni::math::are_equal<V>(this->m_sy, 0) &&
omni::math::are_equal<V>(this->m_sz, 0)
);
}
V length() const
{
return this->magnitude();
}
V magnitude() const
{
OMNI_SAFE_VEC3ALOCK_FW
return this->_magnitude();
}
omni::geometry::vector3<V>& set_start_x(V start_x)
{
OMNI_SAFE_VEC3ALOCK_FW
this->m_sx = start_x;
return *this;
}
omni::geometry::vector3<V>& set_start_y(V start_y)
{
OMNI_SAFE_VEC3ALOCK_FW
this->m_sy = start_y;
return *this;
}
omni::geometry::vector3<V>& set_start_z(V start_z)
{
OMNI_SAFE_VEC3ALOCK_FW
this->m_sz = start_z;
return *this;
}
omni::geometry::vector3<V>& set_x(V x)
{
OMNI_SAFE_VEC3ALOCK_FW
this->m_x = x;
return *this;
}
omni::geometry::vector3<V>& set_y(V y)
{
OMNI_SAFE_VEC3ALOCK_FW
this->m_y = y;
return *this;
}
omni::geometry::vector3<V>& set_z(V z)
{
OMNI_SAFE_VEC3ALOCK_FW
this->m_z = z;
return *this;
}
V start_x() const
{
OMNI_SAFE_VEC3ALOCK_FW
return this->m_sx;
}
V start_y() const
{
OMNI_SAFE_VEC3ALOCK_FW
return this->m_sy;
}
V start_z() const
{
OMNI_SAFE_VEC3ALOCK_FW
return this->m_sz;
}
void swap(vector3& o)
{
if (this != &o) {
OMNI_SAFE_VEC3ALOCK_FW
OMNI_SAFE_VEC3OALOCK_FW(o)
std::swap(this->m_sx, o.m_sx);
std::swap(this->m_sy, o.m_sy);
std::swap(this->m_sz, o.m_sz);
std::swap(this->m_x, o.m_x);
std::swap(this->m_y, o.m_y);
std::swap(this->m_z, o.m_z);
}
}
point3d_t tail() const
{
OMNI_SAFE_VEC3ALOCK_FW
return point3d_t(this->m_sx, this->m_sy, this->m_sz);
}
omni::geometry::vector3<V> to_standard_form() const
{
OMNI_SAFE_VEC3ALOCK_FW
return omni::geometry::vector3<V>(this->_x(), this->_y(), this->_z());
}
omni::geometry::vector3<V> unit_vector() const
{
return *this / this->magnitude();
}
V x() const
{
OMNI_SAFE_VEC3ALOCK_FW
return this->m_x;
}
V y() const
{
OMNI_SAFE_VEC3ALOCK_FW
return this->m_y;
}
V z() const
{
OMNI_SAFE_VEC3ALOCK_FW
return this->m_z;
}
V x_component() const
{
OMNI_SAFE_VEC3ALOCK_FW
return this->_x();
}
V y_component() const
{
OMNI_SAFE_VEC3ALOCK_FW
return this->_y();
}
V z_component() const
{
OMNI_SAFE_VEC3ALOCK_FW
return this->_z();
}
omni::string_t to_string_t() const
{
omni::sstream_t s;
OMNI_SAFE_VEC3LOCK_FW
s << "{" << this->m_x << ","
<< this->m_y << ","
<< this->m_z << ";"
<< this->_direction_x() << ","
<< this->_direction_y() << ","
<< this->_direction_z() << ","
<< this->_magnitude() << "}";
OMNI_SAFE_VEC3UNLOCK_FW
return s.str();
}
std::string to_string() const
{
std::stringstream s;
OMNI_SAFE_VEC3LOCK_FW
s << "{" << this->m_x << ","
<< this->m_y << ","
<< this->m_z << ";"
<< this->_direction_x() << ","
<< this->_direction_y() << ","
<< this->_direction_z() << ","
<< this->_magnitude() << "}";
OMNI_SAFE_VEC3UNLOCK_FW
return s.str();
}
std::wstring to_wstring() const
{
std::wstringstream s;
OMNI_SAFE_VEC3LOCK_FW
s << "{" << this->m_x << ","
<< this->m_y << ","
<< this->m_z << ";"
<< this->_direction_x() << ","
<< this->_direction_y() << ","
<< this->_direction_z() << ","
<< this->_magnitude() << "}";
OMNI_SAFE_VEC3UNLOCK_FW
return s.str();
}
operator std::string() const
{
return this->to_string();
}
operator std::wstring() const
{
return this->to_wstring();
}
template < typename T >
operator omni::geometry::point3d<T>() const
{
OMNI_SAFE_VEC3ALOCK_FW
return omni::geometry::point3d<T>(
static_cast<T>(this->_x()),
static_cast<T>(this->_y()),
static_cast<T>(this->_z())
);
}
bool operator==(const omni::geometry::vector3<V>& b) const
{
if (this == &b) { return true; }
OMNI_SAFE_VEC3ALOCK_FW
OMNI_SAFE_VEC3OALOCK_FW(b)
return (
omni::math::are_equal(this->_magnitude(), b._magnitude()) &&
omni::math::are_equal(this->_direction_x(), b._direction_x()) &&
omni::math::are_equal(this->_direction_y(), b._direction_y()) &&
omni::math::are_equal(this->_direction_z(), b._direction_z())
)
OMNI_EQUAL_FW(b);
}
bool operator!=(const omni::geometry::vector3<V>& b) const
{
return !(*this == b);
}
omni::geometry::vector3<V>& operator=(const omni::geometry::vector3<V>& b)
{
if (this != &b) {
OMNI_SAFE_VEC3ALOCK_FW
OMNI_SAFE_VEC3OALOCK_FW(b)
OMNI_ASSIGN_FW(b)
this->m_sx = b.m_sx;
this->m_sy = b.m_sy;
this->m_sz = b.m_sz;
this->m_x = b.m_x;
this->m_y = b.m_y;
this->m_z = b.m_z;
}
return *this;
}
template < typename T >
omni::geometry::vector3<V>& operator=(const omni::geometry::point3d<T>& point)
{
OMNI_SAFE_VEC3ALOCK_FW
this->m_x = static_cast<V>(point.x());
this->m_y = static_cast<V>(point.y());
this->m_z = static_cast<V>(point.z());
return *this;
}
omni::geometry::vector3<V> operator-(const omni::geometry::vector3<V>& b) const
{
OMNI_SAFE_VEC3ALOCK_FW
if (this != &b) {
OMNI_SAFE_VEC3OALOCK_FW(b)
OMNI_BITS_WILL_ADD_OVER_FW(this->m_x, (-b.m_x))
OMNI_BITS_WILL_ADD_OVER_FW(this->m_y, (-b.m_y))
OMNI_BITS_WILL_ADD_OVER_FW(this->m_z, (-b.m_z))
return omni::geometry::vector3<V>(
this->m_sx,
this->m_sy,
this->m_sz,
(this->m_x + (-b.m_x)),
(this->m_y + (-b.m_y)),
(this->m_z + (-b.m_z))
);
}
OMNI_BITS_WILL_ADD_OVER_FW(this->m_x, (-b.m_x))
OMNI_BITS_WILL_ADD_OVER_FW(this->m_y, (-b.m_y))
OMNI_BITS_WILL_ADD_OVER_FW(this->m_z, (-b.m_z))
return omni::geometry::vector3<V>(
this->m_sx,
this->m_sy,
this->m_sz,
(this->m_x + (-b.m_x)),
(this->m_y + (-b.m_y)),
(this->m_z + (-b.m_z))
);
}
omni::geometry::vector3<V> operator+(const omni::geometry::vector3<V>& b) const
{
OMNI_SAFE_VEC3ALOCK_FW
if (this != &b) {
OMNI_SAFE_VEC3OALOCK_FW(b)
OMNI_BITS_WILL_ADD_OVER_FW(this->m_x, b.m_x)
OMNI_BITS_WILL_ADD_OVER_FW(this->m_y, b.m_y)
OMNI_BITS_WILL_ADD_OVER_FW(this->m_z, b.m_z)
return omni::geometry::vector3<V>(
this->m_sx,
this->m_sy,
this->m_sz,
(this->m_x + b.m_x),
(this->m_y + b.m_y),
(this->m_z + b.m_z)
);
}
OMNI_BITS_WILL_ADD_OVER_FW(this->m_x, b.m_x)
OMNI_BITS_WILL_ADD_OVER_FW(this->m_y, b.m_y)
OMNI_BITS_WILL_ADD_OVER_FW(this->m_z, b.m_z)
return omni::geometry::vector3<V>(
this->m_sx,
this->m_sy,
this->m_sz,
(this->m_x + b.m_x),
(this->m_y + b.m_y),
(this->m_z + b.m_z)
);
}
// scalar multiplication
omni::geometry::vector3<V> operator*(V scalar) const
{
OMNI_SAFE_VEC3ALOCK_FW
OMNI_BITS_WILL_MUL_OVER_FW(this->m_x, scalar)
OMNI_BITS_WILL_MUL_OVER_FW(this->m_y, scalar)
OMNI_BITS_WILL_MUL_OVER_FW(this->m_z, scalar)
return omni::geometry::vector3<V>(
this->m_sx,
this->m_sy,
this->m_sz,
(this->m_x * scalar),
(this->m_y * scalar),
(this->m_z * scalar)
);
}
// scalar division
omni::geometry::vector3<V> operator/(V scalar) const
{
OMNI_SAFE_VEC3ALOCK_FW
return omni::geometry::vector3<V>(
this->m_sx,
this->m_sy,
this->m_sz,
(this->m_x / scalar),
(this->m_y / scalar),
(this->m_z / scalar)
);
}
OMNI_MEMBERS_FW(omni::geometry::vector3<V>) // disposing,name,type(),hash()
OMNI_OSTREAM_FW(omni::geometry::vector3<V>)
private:
V m_sx;
V m_sy;
V m_sz;
V m_x;
V m_y;
V m_z;
#if defined(OMNI_SAFE_VECTOR3)
mutable omni::sync::basic_lock m_mtx;
#endif
inline V _dot_product(const omni::geometry::vector3<V>& b) const
{
OMNI_BITS_WILL_MUL_OVER_FW(this->_x(), b._x())
OMNI_BITS_WILL_MUL_OVER_FW(this->_y(), b._y())
OMNI_BITS_WILL_MUL_OVER_FW(this->_z(), b._z())
return (this->_x() * b._x()) + (this->_y() * b._y()) + (this->_z() * b._z());
}
inline double _direction_x() const
{
return omni::math::rad_to_deg(std::atan(this->_x() / this->_magnitude()));
}
inline double _direction_y() const
{
return omni::math::rad_to_deg(std::atan(this->_y() / this->_magnitude()));
}
inline double _direction_z() const
{
return omni::math::rad_to_deg(std::atan(this->_z() / this->_magnitude()));
}
inline V _magnitude() const
{
OMNI_BITS_WILL_MUL_OVER_FW(this->_x(), this->_x())
OMNI_BITS_WILL_MUL_OVER_FW(this->_y(), this->_y())
OMNI_BITS_WILL_MUL_OVER_FW(this->_z(), this->_z())
return std::sqrt(
(this->_x() * this->_x()) +
(this->_y() * this->_y()) +
(this->_z() * this->_z())
);
}
inline V _x() const
{
OMNI_BITS_WILL_SUB_UNDER_FW(this->m_x, this->m_sx)
return (this->m_x - this->m_sx);
}
inline V _y() const
{
OMNI_BITS_WILL_SUB_UNDER_FW(this->m_y, this->m_sy)
return (this->m_y - this->m_sy);
}
inline V _z() const
{
OMNI_BITS_WILL_SUB_UNDER_FW(this->m_z, this->m_sz)
return (this->m_z - this->m_sz);
}
};
typedef omni::geometry::vector3<float> vector3F_t;
typedef omni::geometry::vector3<double> vector3D_t;
}
}
namespace std {
template < typename V >
inline void swap(omni::geometry::vector3<V>& a, omni::geometry::vector3<V>& b)
{
a.swap(b);
}
}
#endif // OMNI_VECTOR3_HPP