Egc

------------------------------------------------------TEST1----------------------------------------------------------------
#include "mat3.h"
#include < math.h>
namespace egc{
MAT3
mat3& mat3 :: operator =(const mat3& srcMatrix){
for(int i=0;i<9;i++)
matrixData[i] =srcMatrix.matrixData[i];
return (*this);
}
mat3 mat3 :: operator *(float scalarValue) const{

mat3 result;
result.matrixData[i] =matrixData[i]*scalarValue;
return result;
}
mat3 mat3 :: operator *(const mat3& srcMatrix) const{

mat3 result;
result.matrixData[i] = 0;
for( int i=0;i<3; i++)
for(int j=0;j<3;j++)
for(int k=0;k<3;k++)
result.at(i,j) += at(i,k) * srcMatrix.at(k,j);
return result;
}
vec3 mat3 :: operator *(const vec3& srcVector) const{

vec3 result;
result.x=at(0,0)*srcVector.x + at(0,1)*srcVector.y + at(0,2)*srcVector.z;
result.y=at(1,0)*srcVector.x + at(1,1)*srcVector.y + at(1,2)*srcVector.z;
result.z=at(2,0)*srcVector.x + at(2,1)*srcVector.y + at(2,2)*srcVector.z;
return result;
}
mat3 mat3 :: operator +(const mat3& srcMatrix) const{

mat3 result;
result.matrixData[i] =matrixData[i] + srcMatrix.matrixData[i];
return result;
}
//get element by (row, column)

float& mat3 :: at(int i, int j){
return matrixData[i+3*j];
}
const float& mat3 :: at(int i, int j) const{
return matrixData[i+3*j];
}
float mat3 :: determinant() const{

return at(0,0)*at(1,1)*at(2,2)+at(1,0)*at(2,1)*at(0,2)+at(0,1)*at(1,2)*at(2,0)-
at(0,2)*at(1,1)*at(2,0)-at(0,0)*at(1,2)*at(2,1)-at(0,1)*at(1,0)*at(2,2);
}
float cofactor(const mat3 m3,int l,int c)

{
float cof[4];
int k = 0, sign = ((l + c) % 2 != 0) ? -1 : 1;
for (int i = 0; i < 3; i++)
for (int j = 0; j < 3; j++)
if (i != l && j != c)
cof[k++] = m3.at(i, j);
return sign * (cof[0] * cof[3] - cof[1] * cof[2]);
}
mat3 mat3 :: inverse() const{

mat3 inv;
float det = determinant();
inv = transpose();
for (int i = 0; i < 3; i++)
for (int j = 0; j < 3; j++)
inv.at(i, j) = (1/abs(det))*cofactor((*this), i, j);
return inv;
}
mat3 mat3 :: transpose() const{
mat3 result;
for( int i=0;i<3; i++)
result.at(j,i) = at(i,j);
return result;
}
}
------------------------------------------------------------------------------------------------------
MAT 4
#include "mat4.h"
#include "mat3.h"
namespace egc {
mat4& mat4 :: operator =(const mat4& srcMatrix) {

for (int i = 0; i<16; i++)
matrixData[i] = srcMatrix.matrixData[i];
return (*this);
}
mat4 mat4 :: operator *(float scalarValue) const {

mat4 result;
for (int i = 0; i<16; i++)
result.matrixData[i] = matrixData[i] * scalarValue;
return result;
}
mat4 mat4 :: operator *(const mat4& srcMatrix) const {

mat4 result;
for (int i = 0; i<16; i++)
result.matrixData[i] = 0;
for (int i = 0; i<4; i++)
for (int j = 0; j<4; j++)
for (int k = 0; k<4; k++)
result.at(i, j) += at(i, k) * srcMatrix.at(k, j);
return result;
}
vec4 mat4 :: operator *(const vec4& srcVector) const {

vec4 result;
result.x = at(0, 0)*srcVector.x + at(0, 1)*srcVector.y + at(0, 2)*srcVector.z+ at(0,
3)*srcVector.w;
result.y = at(1, 0)*srcVector.x + at(1, 1)*srcVector.y + at(1, 2)*srcVector.z+ at(1,
3)*srcVector.w;
result.z = at(2, 0)*srcVector.x + at(2, 1)*srcVector.y + at(2, 2)*srcVector.z+ at(2,
3)*srcVector.w;
result.w = at(3, 0)*srcVector.x + at(3, 1)*srcVector.y + at(3, 2)*srcVector.z+ at(3,
3)*srcVector.w;
return result;
}
mat4 mat4 :: operator +(const mat4& srcMatrix) const {

mat4 result;
for (int i = 0; i<16; i++)
result.matrixData[i] = matrixData[i] + srcMatrix.matrixData[i];
return result;
}
//get element by (row, column)

float& mat4::at(int i, int j) {
return matrixData[i + 4 * j];
}
const float& mat4::at(int i, int j) const {

return matrixData[i + 4 * j];
}
float cofactor(const mat4 m4, int l, int c)

{
float cof[9];
int k = 0, sign = ((l + c) % 2 != 0) ? -1 : 1;
for (int i = 0; i < 4; i++)
if (i !=l)
for (int j = 0; j < 4; j++)
if (j != c)
if (i != l && j != c)
cof[k++] = m4.at(i, j);
return sign * (cof[0] * cof[4] * cof[8] + cof[2] * cof[3] * cof[7] + cof[1] * cof[5] *
cof[6] - cof[2] * cof[4] * cof[6] - cof[1] * cof[3] * cof[8] - cof[0] * cof[5] * cof[7]);
}
float mat4::determinant() const {

return at(0, 0)*cofactor((*this), 0, 0) + at(0, 1)*cofactor((*this), 0, 1) + at(0,
2)*cofactor((*this), 0, 2) + at(0, 3)*cofactor((*this), 0, 3);
}
mat4 mat4::inverse() const {
mat4 inv;
inv = transpose();
float det = determinant();
for (int i = 0; i < 4; i++)
for (int j = 0; j < 4; j++)
inv.at(i, j) = (1 /(det))*cofactor((*this), i, j);
return inv;
}
mat4 mat4::transpose() const {

mat4 result;
for (int i = 0; i<4; i++)
for (int j = 0; j<4; j++)
result.at(j, i) = at(i, j);
return result;
}
}
-----------------------------------------------------------------------------------------------------------
#include "transform.h"
TANSFORM
namespace egc
{
//const double PI = atan(1.0) * 4;
//transformation matrices in 2D
mat3 translate(const vec2 translateArray)
{
mat3 matrix;
{
{
if(i!=j)
matrix.at(i,j)=0;
else
matrix.at(i,j)=1;
}
}
matrix.at(0,2)=translateArray.x;
matrix.at(1,2)=translateArray.y;
return matrix;
}
mat3 translate(float tx, float ty)
{
mat3 matrix;
{
{
if(i!=j)
matrix.at(i,j)=0;
else
matrix.at(i,j)=1;
}
}
matrix.at(0,2)=tx;
matrix.at(1,2)=ty;
return matrix;
}
mat3 scale(const vec2 scaleArray)

{
mat3 matrix;
{
{
if(i!=j)
matrix.at(i,j)=0;
}
}
matrix.at(0,0)=scaleArray.x;
matrix.at(1,1)=scaleArray.y;
matrix.at(2,2)=1;
return matrix;
}
mat3 scale(float sx, float sy)
{
mat3 matrix;
{
{
if(i!=j)
matrix.at(i,j)=0;
}
}
matrix.at(0,0)=sx;
matrix.at(1,1)=sy;
matrix.at(2,2)=1;
return matrix;
}
mat3 rotate(float angle)

{
mat3 matrix;
{
{
if(i!=j)
matrix.at(i,j)=0;
}
}
matrix.at(0,0)=cos(angle*PI/180);
matrix.at(0,1)=-sin(angle*PI/180);
matrix.at(1,0)=sin(angle*PI/180);
matrix.at(2,2)=1;
return matrix;
}
//transformation matrices in 3D
mat4 translate(const vec3 translateArray)
{
mat4 matrix;
{
{
if(i!=j)
matrix.at(i,j)=0;
else
matrix.at(i,j)=1;
}
}
matrix.at(0,3)=translateArray.x;
matrix.at(1,3)=translateArray.y;
matrix.at(2,3)=translateArray.z;
return matrix;
}
mat4 translate(float tx, float ty, float tz)

{
mat4 matrix;
{
{
if(i!=j)
matrix.at(i,j)=0;
else
matrix.at(i,j)=1;
}
}
matrix.at(0,3)=tx;
matrix.at(1,3)=ty;
matrix.at(2,3)=tz;
return matrix;
}
mat4 scale(const vec3 scaleArray)

{
mat4 matrix;
{
{
if(i!=j)
matrix.at(i,j)=0;
else
matrix.at(i,j)=1;
}
}
matrix.at(0,0)=scaleArray.x;
matrix.at(1,1)=scaleArray.y;
matrix.at(2,2)=scaleArray.z;
return matrix;
}
mat4 scale(float sx, float sy, float sz)

{
mat4 matrix;
{
{
if(i!=j)
matrix.at(i,j)=0;
else
matrix.at(i,j)=1;
}
}
matrix.at(0,0)=sx;
matrix.at(1,1)=sy;
matrix.at(2,2)=sz;
return matrix;
}
mat4 rotateX(float angle)

{
mat4 matrix;
{
{
if(i!=j)
matrix.at(i,j)=0;
}
}
matrix.at(0,0)=1;
matrix.at(3,3)=1;
return matrix;
}
mat4 rotateY(float angle)

{
mat4 matrix;
{
{
if(i!=j)
matrix.at(i,j)=0;
}
}
matrix.at(1,1)=1;
matrix.at(3,3)=1;
return matrix;
}
mat4 rotateZ(float angle)

{
mat4 matrix;
{
{
if(i!=j)
matrix.at(i,j)=0;
}
}
matrix.at(2,2)=1;
matrix.at(3,3)=1;
return matrix;
}
}
-----------------------------------------------------------------------------------------------------------------
VEC2
#include "vec2.h"
namespace egc
vec2& vec2::operator =(const vec2 &srcVector){
x = srcVector.x;
y = srcVector.y;
return (*this);
}
vec2 vec2::operator +(const vec2& srcVector)const {
vec2 newVector;
newVector.x = x + srcVector.x;
newVector.y = y + srcVector.y;
return newVector;
}
vec2& vec2::operator +=(const vec2& srcVector){
x += srcVector.x;
y += srcVector.y;
return (*this);
}
vec2 vec2::operator *(float scalarValue)const{
vec2 newVector;
newVector.x = x * scalarValue;
newVector.y = y * scalarValue;
return newVector;
}
vec2 vec2::operator -(const vec2& srcVector) const{
vec2 newVector;
newVector.x = x - srcVector.x;
newVector.y = y - srcVector.y;
return newVector;
}
vec2& vec2::operator -=(const vec2& srcVector){
x -= srcVector.x;
y -= srcVector.y;
return (*this);
}
vec2& vec2::operator -(){
x = -x;
y = -y;
return (*this);
}
float vec2::length() const
return sqrt(x*x+y*y);
}
vec2& vec2::normalize()
{
float len = (*this).length();
x = x / len;
y = y / len;
return (*this);
}
float dotProduct(const vec2& v1, const vec2& v2)
{
return v1.x*v2.x + v1.y*v2.y;
}
}
------------------------------------------------------------------------------------------------
#include "vec3.h"
VEC3
namespace egc
{
x = srcVector.x;
y = srcVector.y;
z = srcVector.z;
return (*this);
}
vec3 vec3::operator +(const vec3& srcVector) const{

vec3 newVec;
newVec.x = x + srcVector.x;
newVec.y = y + srcVector.y;
newVec.z = z + srcVector.z;
return newVec;
x += srcVector.x;
y += srcVector.y;
z += srcVector.z;
return (*this);
}
vec3 vec3::operator *(float scalarValue) const {
vec3 newVec;
newVec.x = x *scalarValue;
newVec.y = y *scalarValue;
newVec.z = z *scalarValue;
return newVec;
}
vec3 newVec;
newVec.x = x - srcVector.x;
newVec.y = y - srcVector.y;
newVec.z = z - srcVector.z;
return newVec;
}
x -= srcVector.x;
y -= srcVector.y;
z -= srcVector.z;
return (*this);
}
x = -x;
y = -y;
z = -z;
return (*this);
}
return sqrt(x*x + y * y+z*z);

}
{
x = x / len;
y = y / len;
z = z / len;
return (*this);
}
float dotProduct(const vec3& v1, const vec3& v2)
{
return v1.x*v2.x + v1.y*v2.y + v1.z*v2.z;
vec3 crossProduct(const vec3& v1, const vec3& v2)

{
vec3 newVec;
newVec.x = v1.y * v2.z -v1.z*v2.y;
newVec.y = v1.z * v2.x - v1.x*v2.z;

newVec.z = v1.x * v2.y - v1.y*v2.x;
return newVec;
}
--------------------------------------------------------------------------------------------------------------------
#include "vec4.h"
VEC 4
namespace egc
{
x = srcVector.x;
y = srcVector.y;
z = srcVector.z;
w = srcVector.w;
return (*this);
}
vec4 vec4::operator +(const vec4& srcVector) const{
vec4 newVec;
newVec.x = x + srcVector.x;
newVec.y = y + srcVector.y;
newVec.z = z + srcVector.z;
newVec.w = w + srcVector.w;
return newVec;
}
x += srcVector.x;
y += srcVector.y;
z += srcVector.z;
w += srcVector.w;
return (*this);
}
vec4 vec4::operator *(float scalarValue) const{
vec4 newVec;
newVec.x = x *scalarValue;
newVec.y = y *scalarValue;
newVec.z = z *scalarValue;
newVec.w = w *scalarValue;
return newVec;
}
vec4 newVec;
newVec.x = x - srcVector.x;
newVec.y = y - srcVector.y;
newVec.z = z - srcVector.z;
newVec.w = w - srcVector.w;
return newVec;
}
x -= srcVector.x;
y -= srcVector.y;
z -= srcVector.z;
w -= srcVector.w;
return (*this);
}
x = -x;
y = -y;
z = -z;
w = -w;
return (*this);
}

{
return sqrt(x*x + y * y+ z*z+ w*w);
}
{
x = x / len;
y = y / len;
z = z / len;
w = w / len;
return (*this);
}
}
---------------------------------------------------TEST2--------------------------------------------------------------------
#include "clip.h"
#define max(a,b) ( (a>b) ? a : b )
#define min(a,b) ( (a<b) ? a : b )
#define max4(a,b,c,d) ( max(max(max(a,b),c),d) )
#define min4(a,b,c,d) ( min(min(min(a,b),c),d) )
namespace egc {
ComputeClippingWindowNormals
void ComputeClippingWindowNormals(std::vector<edge> &clipWindow) {
for(int i=0;i<clipWindow.size();i++){
float dx = clipWindow[i].b.x - clipWindow[i].a.x;
float dy = clipWindow[i].b.y - clipWindow[i].a.y;
clipWindow[i].normal.x = dy;
clipWindow[i].normal.y =-dx;
}
}
isPointOutsideClippingWindow
bool isPointOutsideClippingWindow(const vec3 &p, const std::vector<edge>
&clippingWindow) {
for(int i=0;i<clippingWindow.size();i++){
vec3 v = clippingWindow[i].a - p;
if(dotProduct(v,clipWindow[i].normal > 0)
return true;
}
return false;
areTwoEdgesParallel
bool areTwoEdgesParallel(const edge &edgeToBeClipped, const edge &e) {
float m1,m2;
m1 = (edgeToBeClipped.b.y - edgeToBeClipped.a.y )/(edgeToBeClipped.b.x -
edgeToBeClipped.a.x);
m2 = (e.b.y - e.a.y)/(e.b.x-e.a.x);
if(m1==m2)
return true;
else return false;
}
isPotentialEnteringPoint
bool isPotentialEnteringPoint(const edge &e, const edge &edgeToBeClipped) {
vec3 D = edgeToBeClipped.b - edgeToBeClipped.a;
float dotprod = dotProduct(D,e.normal);
if(dotprod>0)
return true;
else return false;
}
lineClip_CyrusBeck
// CYRUS BECK fara functii create de noi
int lineClip_CyrusBeck(std::vector<edge> clipWindow, vec3& p0, vec3& p1) {
ComputeClippingWindowNormals(clipWindow);
if(p0 == p1) // degenerates into a point
return -1;
float tE=0, tL=1;
float t;
vec3 D = p1-p0;
float dotprod = dotProduct(clipWindow[i].normal,D);
if(dotprod!=0){
t = -dotProduct(clipWindow[i].normal, p0-clipWindow[i].a)/dotprod;
if(t>= 0 && t<= 1){
if(dotprod > 0)
tE=std::max(tE,t);
else
tL=std::min(tL,t);
}
}
}
if(tE>tL)
return -1;
else{
vec3 p0final = p0 + D*tE;
vec3 p1final = p1 + D*tL;
p0=p0final;
p1=p1final;
return 1;
}
}
computeEdgeNormal
void computeEdgeNormal(edge &e) {
float dx = e.b.x- e.a.x;
float dy = e.b.y- e.a.y;
e.normal.x = dy;
e.normal.y = -dx;
}
isPointInsideClippingWindow
bool isPointInsideClippingWindow(const vec3 &p, const std::vector<edge>
&clippingWindow) {
for(int i=0;i<clippingWindow.size();i++){
vec3 v = p - clippingWindow[i].a;
if(dotProduct(v,clippingWindow[i].normal > 0)
return false;
}
return true;
}
computeIntersectionPoint
float computeIntersectionPoint(const edge &lineToBeClipped, const edge e) {
vec3 D = lineToBeClipped.b - lineToBeClipped.a;
return -dotProduct(e.normal, lineToBeClipped.a - e.a)/dotProduct(D,e.normal);
}
update_tE_or_tL
void update_tE_or_tL(const float t, float &tE, float &tL, const edge e, const edge
&lineToBeClipped) {
vec3 D = lineToBeClipped.b - lineToBeClipped.a;
float dotProd = dotProduct(D,e.normal);
if(dotProd>0)
tE=std::max(tE,t); else
tL=std::min(tL,t);
}
computeCode
std::vector<int> computeCode(std::vector<edgeCS> clipWindow, const vec3 p) {
float xMin,xMax,yMin,yMax;
if(clipWindow[i].a.x > xMax)
xMax = clipWindow[i].a.x;
else if(clipWindow[i].a.x < xMin)
xMin = clipWindow[i].a.x;
if(clipWindow[i].a.y > yMax)
yMax = clipWindow[i].a.y;
else if(clipWindow[i].a.y < yMin)
yMin = clipWindow[i].a.y;
}
//UDRL
std::vector<int> cod;
if(p.y > yMax)
cod.push_back(1);
else
cod.push_back(0);
if(p.y < yMin)
cod.push_back(1);
else
cod.push_back(0);
if(p.x > xMax)
cod.push_back(1);
else
cod.push_back(0);
if(p.x < xMin)
cod.push_back(1);
else
cod.push_back(0);
return cod;
}
// din clip.h
simpleRejection
bool simpleRejection(std::vector<int> cod1, std::vector<int> cod2) {
for(int i=0;i<cod1.size();i++){
if(cod1[i]==1 && cod2[i] ==1)
return true;
}
return false;
}
// din clip.h
simpleAcceptance
bool simpleAcceptance(std::vector<int> cod1, std::vector<int> cod2) {
for(int i=0;i<cod1.size();i++){
if(cod1[i]==1 || cod2[i]==1)
return false;
}
return true;
}
isInsideOrOutside
bool isInsideOrOutside(std::vector<int> cod) { //pentru punct
for(int i=0;i<cod.size();i++){
if(cod[i]==1)
return false;
}
return true;
}
isLineInsideOrOutside
int isLineInsideOrOutside(edgeCS &edgeToBeclipped) { //pentru linie
bool accept=true;
bool reject=false;
std::vector<int> cod1 = edgeToBeClipped.code1;
std::vector<int> cod2 = edgeToBeClipped.code2;
for(int i=0;i<cod1.size;i++){
if(cod1[i] == 1 || cod2[i]==1)
accept = false;
}
for(int i=0;i<cod1.size;i++){
if(cod1[i] == 1 && cod2[i]==1)
reject = true;
}
if(accept && !reject)
return 0;
else if(!accept && reject)
return -1;
return -2;
}
invertPoints
void invertPoints(edgeCS &e) {
vec3 auxv;
std::vector<int> auxc;
auxv=e.vertex1;
e.vertex1=e.vertex2;
e.vertex2=auxv;
auxc=e.code1;
e.code1=e.code2;
e.code2=auxc;
}
lineClip_CohenSutherland
int lineClip_CohenSutherland(std::vector<edge> clipWindow, vec3& p1, vec3&
p2) {
float xMin,xMax,yMin,yMax;
if(clipWindow[i].a.x > xMax)
xMax = clipWindow[i].a.x;
else if(clipWindow[i].a.x < xMin)
xMin = clipWindow[i].a.x;
if(clipWindow[i].a.y > yMax)
yMax = clipWindow[i].a.y;
else if(clipWindow[i].a.y < yMin)
yMin = clipWindow[i].a.y;
}
bool done = false;
while(!done){
std::vector<int> cod1 = computeCode(clipWindow,p1);
std::vector<int> cod2 = computeCode(clipWindow,p2);
if(simpleRejection(cod1,cod2){
done=true;
return -1;
}
else{
if(simpleAcceptance(cod1,cod2){
done=true;
return 0;
} else{
if(isInside(cod1){
vec3 auxv;
std::vector<int> auxc;
auxv=p0;
p0=p1;
p1=auxv;
auxc=cod1;
cod1=cod2;
cod2=auxc;
}
if(cod1[0]==1 && p0.y!=p1.y){
p0.x = p0.x+(p1.x-p0.x)*(ymax-p0.y)/(p1.y-p0.y);
p0.y = ymax;
}
if(cod1[1]==1 && p0.y!=p1.y){
p0.x = p0.x+(p1.x-p0.x)*(ymin-p0.y)/(p1.y-p0.y);
p0.y = ymin;
}
if(cod1[2]==1 && p0.x!=p1.x){
p0.y = p0.y+(p1.y-p0.y)*(xmax-p0.x)/(p1.x-p0.x);
p0.y = xmax;
}
if(cod1[3]==1 && p0.x!=p1.x){
p0.y = p0.y+(p1.y-p0.y)*(xmin-p0.x)/(p1.x-p0.x);
p0.y = xmin;
}
}
}
}
}
}
---------------------------------------------TEST 3 ----------------------------------------------------
(pe pagina urmatoare sunt rezolvari)
1. findBoundingBox
2. isPointInsideTriangle
3. isPointOutsideTriangle
(pe pagina urmatoare sunt rezolvari)
1. isTriangleBackFacing
2. isTriangleFrontFacing
3. findCenterPointOfTriangle
4. findNormalVectorOfTriangle

Egc

Uploaded by

Document Information

Original Description:

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Egc

Uploaded by

Copyright:

Available Formats

------------------------------------------------------TEST1----------------------------------------------------------------

mat3 mat3 :: operator *(float scalarValue) const{

mat3 mat3 :: operator *(const mat3& srcMatrix) const{

vec3 mat3 :: operator *(const vec3& srcVector) const{

mat3 mat3 :: operator +(const mat3& srcMatrix) const{

//get element by (row, column)

float mat3 :: determinant() const{

float cofactor(const mat3 m3,int l,int c)

mat3 mat3 :: inverse() const{

mat4& mat4 :: operator =(const mat4& srcMatrix) {

mat4 mat4 :: operator *(float scalarValue) const {

mat4 mat4 :: operator *(const mat4& srcMatrix) const {

vec4 mat4 :: operator *(const vec4& srcVector) const {

mat4 mat4 :: operator +(const mat4& srcMatrix) const {

//get element by (row, column)

const float& mat4::at(int i, int j) const {

float cofactor(const mat4 m4, int l, int c)

float mat4::determinant() const {

mat4 mat4::inverse() const {

mat4 mat4::transpose() const {

mat3 scale(const vec2 scaleArray)

mat3 rotate(float angle)

mat4 translate(float tx, float ty, float tz)

mat4 scale(const vec3 scaleArray)

mat4 scale(float sx, float sy, float sz)

mat4 rotateX(float angle)

mat4 rotateY(float angle)

mat4 rotateZ(float angle)

vec2& vec2::operator =(const vec2 &srcVector){

vec2 vec2::operator +(const vec2& srcVector)const {

vec2& vec2::operator +=(const vec2& srcVector){

vec2 vec2::operator *(float scalarValue)const{

vec2 vec2::operator -(const vec2& srcVector) const{

vec2& vec2::operator -=(const vec2& srcVector){

vec2& vec2::operator -(){

float vec2::length() const

float dotProduct(const vec2& v1, const vec2& v2)

vec3& vec3::operator =(const vec3 &srcVector){

vec3 vec3::operator +(const vec3& srcVector) const{

vec3& vec3::operator +=(const vec3& srcVector){

vec3 vec3::operator *(float scalarValue) const {

vec3& vec3::operator -=(const vec3& srcVector){

vec3& vec3::operator -(){

return sqrt(x*x + y * y+z*z);

float len = (*this).length();

float dotProduct(const vec3& v1, const vec3& v2)

vec3 crossProduct(const vec3& v1, const vec3& v2)

newVec.x = v1.y * v2.z -v1.z*v2.y;

newVec.y = v1.z * v2.x - v1.x*v2.z;

vec4& vec4::operator =(const vec4 &srcVector){

vec4 vec4::operator +(const vec4& srcVector) const{

vec4 vec4::operator *(float scalarValue) const{

vec4 vec4::operator -(const vec4& srcVector) const{

vec4& vec4::operator -=(const vec4& srcVector){

vec4& vec4::operator -(){

float vec4::length() const

float len = (*this).length();

You might also like

return sqrt(xx + y y+z*z);