src/Renderer/Vector.cpp

   1 // Copyright 2016 The SwiftShader Authors. All Rights Reserved.
   2 //
   3 // Licensed under the Apache License, Version 2.0 (the "License");
   4 // you may not use this file except in compliance with the License.
   5 // You may obtain a copy of the License at
   6 //
   7 //    http://www.apache.org/licenses/LICENSE-2.0
   8 //
   9 // Unless required by applicable law or agreed to in writing, software
  10 // distributed under the License is distributed on an "AS IS" BASIS,
  11 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  12 // See the License for the specific language governing permissions and
  13 // limitations under the License.
  14
  15 #include "Vector.hpp"
  16
  17 #include "Math.hpp"
  18 #include "Matrix.hpp"
  19
  20 namespace sw
  21 {
  22         Vector Vector::operator+() const
  23         {
  24                 return *this;
  25         }
  26
  27         Vector Vector::operator-() const
  28         {
  29                 return Vector(-x, -y, -z);
  30         }
  31
  32         Vector &Vector::operator+=(const Vector &v)
  33         {
  34                 x += v.x;
  35                 y += v.y;
  36                 z += v.z;
  37
  38                 return *this;
  39         }
  40
  41         Vector &Vector::operator-=(const Vector &v)
  42         {
  43                 x -= v.x;
  44                 y -= v.y;
  45                 z -= v.z;
  46
  47                 return *this;
  48         }
  49
  50         Vector &Vector::operator*=(float s)
  51         {
  52                 x *= s;
  53                 y *= s;
  54                 z *= s;
  55
  56                 return *this;
  57         }
  58
  59         Vector &Vector::operator/=(float s)
  60         {
  61                 float r = 1.0f / s;
  62
  63                 return *this *= r;
  64         }
  65
  66         bool operator==(const Vector &U, const Vector &v)
  67         {
  68                 if(U.x == v.x && U.y == v.y && U.z == v.z)
  69                         return true;
  70                 else
  71                         return false;
  72         }
  73
  74         bool operator!=(const Vector &U, const Vector &v)
  75         {
  76                 if(U.x != v.x || U.y != v.y || U.z != v.z)
  77                         return true;
  78                 else
  79                         return false;
  80         }
  81
  82         bool operator>(const Vector &u, const Vector &v)
  83         {
  84                 if((u^2) > (v^2))
  85                         return true;
  86                 else
  87                         return false;
  88         }
  89
  90         bool operator<(const Vector &u, const Vector &v)
  91         {
  92                 if((u^2) < (v^2))
  93                         return true;
  94                 else
  95                         return false;
  96         }
  97
  98         Vector operator+(const Vector &u, const Vector &v)
  99         {
 100                 return Vector(u.x + v.x, u.y + v.y, u.z + v.z);
 101         }
 102
 103         Vector operator-(const Vector &u, const Vector &v)
 104         {
 105                 return Vector(u.x - v.x, u.y - v.y, u.z - v.z);
 106         }
 107
 108         float operator*(const Vector &u, const Vector &v)
 109         {
 110                 return u.x * v.x + u.y * v.y + u.z * v.z;
 111         }
 112
 113         Vector operator*(float s, const Vector &v)
 114         {
 115                 return Vector(s * v.x, s * v.y, s * v.z);
 116         }
 117
 118         Vector operator*(const Vector &v, float s)
 119         {
 120                 return Vector(v.x * s, v.y * s, v.z * s);
 121         }
 122
 123         Vector operator/(const Vector &v, float s)
 124         {
 125                 float r = 1.0f / s;
 126
 127                 return Vector(v.x * r, v.y * r, v.z * r);
 128         }
 129
 130         float operator^(const Vector &u, const Vector &v)
 131         {
 132                 return acos(u / Vector::N(u) * v / Vector::N(v));
 133         }
 134
 135         Vector operator%(const Vector &u, const Vector &v)
 136         {
 137                 return Vector(u.y * v.z - u.z * v.y, u.z * v.x - u.x * v.z, u.x * v.y - u.y * v.x);
 138         }
 139
 140         Vector operator*(const Matrix &M, const Vector &v)
 141         {
 142                 return Vector(M(1, 1) * v.x + M(1, 2) * v.y + M(1, 3) * v.z,
 143                               M(2, 1) * v.x + M(2, 2) * v.y + M(2, 3) * v.z,
 144                               M(3, 1) * v.x + M(3, 2) * v.y + M(3, 3) * v.z);
 145         }
 146
 147         Vector operator*(const Vector &v, const Matrix &M)
 148         {
 149                 return Vector(v.x * M(1, 1) + v.y * M(2, 1) + v.z * M(3, 1) + M(4, 1),
 150                               v.x * M(1, 2) + v.y * M(2, 2) + v.z * M(3, 2) + M(4, 2),
 151                               v.x * M(1, 3) + v.y * M(2, 3) + v.z * M(3, 3) + M(4, 3));
 152         }
 153
 154         Vector &operator*=(Vector &v, const Matrix &M)
 155         {
 156                 return v = v * M;
 157         }
 158
 159         float Vector::N(const Vector &v)
 160         {
 161                 return sqrt(v.x*v.x + v.y*v.y + v.z*v.z);
 162         }
 163
 164         float Vector::N2(const Vector &v)
 165         {
 166                 return v.x*v.x + v.y*v.y + v.z*v.z;
 167         }
 168
 169         Vector lerp(const Vector &u, const Vector &v, float t)
 170         {
 171                 return Vector(u.x + t * (v.x - u.x),
 172                               u.y + t * (v.y - u.y),
 173                                           u.z + t * (v.z - u.x));
 174         }
 175 }