Vector3.h

Go to the documentation of this file.

// Copyright (c) 2004-2012  Sundog Software, LLC All rights reserved worldwide.
 
#ifdef SWIG
%module TritonVector3
#define TRITONAPI
%{
#include "Vector3.h"
using namespace Triton;
%}
#endif
 
#ifndef TRITON_VECTOR3_H
#define TRITON_VECTOR3_H
 
#if defined(__INTEL_COMPILER)
#include <mathimf.h>
#else
#include <math.h>
#endif
 
#include "MemAlloc.h"
#include <stdio.h>
#include <iostream>
 
#pragma pack(push)
#pragma pack(8)
 
namespace Triton
{
class Vector3 : public MemObject
{
public:
    Vector3() {
        x = y = z = 0;
    }
 
    Vector3(double px, double py, double pz) : x(px), y(py), z(pz) {
    }
 
    Vector3(const double *p) : x(p[0]), y(p[1]), z(p[2]) {
    }
 
    Vector3(const Vector3& v) : x(v.x), y(v.y), z(v.z) {
    }
 
    double TRITONAPI Length() const {
        return sqrt(x*x + y*y + z*z);
    }
 
    double TRITONAPI SquaredLength() const {
        return (x*x + y*y + z*z);
    }
 
    void TRITONAPI Normalize() {
        if (SquaredLength() > 0) {
            double n = 1.0 / Length();
            x *= n;
            y *= n;
            z *= n;
        }
    }
 
    double TRITONAPI Dot (const Vector3& v) const {
        return x * v.x + y * v.y + z * v.z;
    }
 
    Vector3 TRITONAPI Cross (const Vector3& v) const {
        Vector3 kCross;
 
        kCross.x = y*v.z - z*v.y;
        kCross.y = z*v.x - x*v.z;
        kCross.z = x*v.y - y*v.x;
 
        return kCross;
    }
 
    Vector3 TRITONAPI operator * (double n) const {
        return Vector3(x*n, y*n, z*n);
    }
 
    Vector3 TRITONAPI operator * (const Vector3& v) const {
        return Vector3(x*v.x, y*v.y, z*v.z);
    }
 
    Vector3 TRITONAPI operator + (double n) const {
        return Vector3(x+n, y+n, z+n);
    }
 
    Vector3 TRITONAPI operator - (const Vector3& v) const {
        return Vector3(x - v.x, y - v.y, z- v.z);
    }
 
    Vector3 TRITONAPI operator + (const Vector3& v) const {
        return Vector3(x + v.x, y + v.y, z + v.z);
    }
 
    bool TRITONAPI operator == (const Vector3& v) const {
        return (v.x == x && v.y ==y && v.z == z);
    }
 
    bool TRITONAPI operator != (const Vector3& v) const {
        return (v.x != x || v.y != y || v.z != z);
    }
 
    void TRITONAPI Serialize(std::ostream& s) const {
        s.write((char *)&x, sizeof(double));
        s.write((char *)&y, sizeof(double));
        s.write((char *)&z, sizeof(double));
    }
 
    void TRITONAPI Unserialize(std::istream& s) {
        s.read((char *)&x, sizeof(double));
        s.read((char *)&y, sizeof(double));
        s.read((char *)&z, sizeof(double));
    }
 
    double x, y, z;
};
 
class Vector3f : public MemObject
{
public:
    Vector3f() {
    }
 
    Vector3f(const Triton::Vector3& v) : x((float)v.x), y((float)v.y), z((float)v.z) {
    }
 
    Vector3f(float px, float py, float pz) : x(px), y(py), z(pz) {
    }
 
    float TRITONAPI Length() {
        return (float)sqrt(x*x + y*y + z*z);
    }
 
    void TRITONAPI Normalize() {
        float n = 1.0f / Length();
        x *= n;
        y *= n;
        z *= n;
    }
 
    double TRITONAPI Dot (const Vector3f& v) const {
        return x * v.x + y * v.y + z * v.z;
    }
 
    Vector3f TRITONAPI operator - (const Vector3f& v) const {
        return Vector3(x - v.x, y - v.y, z- v.z);
    }
 
    Vector3f TRITONAPI operator + (const Vector3f& v) const {
        return Vector3(x + v.x, y + v.y, z + v.z);
    }
 
    Vector3f TRITONAPI operator * (const Vector3f& v) const {
        return Vector3f(x*v.x, y*v.y, z*v.z);
    }
 
    Vector3f TRITONAPI operator * (float n) const {
        return Vector3f(x*n, y*n, z*n);
    }
 
    float x, y, z;
};
 
 
//JWH
class TBoundingBox : public MemObject
{
public:
    TBoundingBox() 
        {
    }
 
    TBoundingBox(const Triton::Vector3& vMin, const Triton::Vector3& vMax)
        {
                m_vMin = vMin;
                m_vMax = vMax;
    }
 
        TBoundingBox(double minX, double minY, double minZ, double maxX, double maxY, double maxZ)
        {
                m_vMin = Triton::Vector3(minX, minY, minZ);
                m_vMax = Triton::Vector3(maxX, maxY, maxZ);
        }
 
        inline bool Contains (const Triton::Vector3& v) const
        {
                return ((v.x >= m_vMin.x) && (v.y >= m_vMin.y) && (v.z >= m_vMin.z) && 
                        (v.x <= m_vMax.x) && (v.y <= m_vMax.y) && (v.z <= m_vMax.z));
        }
 
   Vector3 m_vMin;
   Vector3 m_vMax;
};
}
 
#pragma pack(pop)
 
#endif