248 lines
5.5 KiB
C++
248 lines
5.5 KiB
C++
#ifndef __VECTOR_H
|
|
#define __VECTOR_H
|
|
|
|
#include "math.hpp"
|
|
#include <stdio.h>
|
|
#include <assert.h>
|
|
|
|
typedef float Vector[3];
|
|
typedef float Matrix[4][4];
|
|
|
|
template<class T> void VectorCreate(T* dst, T x, T y, T z)
|
|
{
|
|
dst[0] = x;
|
|
dst[1] = y;
|
|
dst[2] = z;
|
|
}
|
|
|
|
template<class T> void v3dabs(T* A, T* B)
|
|
{
|
|
A[0] = (T)fabs(B[0]);
|
|
A[1] = (T)fabs(B[1]);
|
|
A[2] = (T)fabs(B[2]);
|
|
}
|
|
|
|
template<class T> void v3dfloor(T* A, T* B)
|
|
{
|
|
A[0] = (T)floor(B[0]);
|
|
A[1] = (T)floor(B[1]);
|
|
A[2] = (T)floor(B[2]);
|
|
}
|
|
|
|
template<class T> void v3dceil(T* A, T* B)
|
|
{
|
|
A[0] = (T)ceil(B[0]);
|
|
A[1] = (T)ceil(B[1]);
|
|
A[2] = (T)ceil(B[2]);
|
|
}
|
|
|
|
template<class T> void v3dcpy(T* A, T* B)
|
|
{
|
|
A[0] = B[0];
|
|
A[1] = B[1];
|
|
A[2] = B[2];
|
|
}
|
|
|
|
template<class T> void VectorNegate(T* A, T* B)
|
|
{
|
|
A[0] = -B[0];
|
|
A[1] = -B[1];
|
|
A[2] = -B[2];
|
|
}
|
|
|
|
template<class T> T VectorDotProduct(T* A, T* B)
|
|
{
|
|
return A[0] * B[0] + A[1] * B[1] + A[2] * B[2];
|
|
}
|
|
|
|
template<class T> T VectorMagnitudeSquared(T* A)
|
|
{
|
|
return VectorDotProduct(A, A);
|
|
}
|
|
|
|
template<class T> T VectorMagnitude(T* A)
|
|
{
|
|
return (T)sqrt(VectorMagnitudeSquared(A));
|
|
}
|
|
|
|
template<class T> void VectorScale(T* A, T* B, T C)
|
|
{
|
|
A[0] = B[0] * C;
|
|
A[1] = B[1] * C;
|
|
A[2] = B[2] * C;
|
|
}
|
|
|
|
template<class T> void VectorSubtract(T* A, T* B, T* C)
|
|
{
|
|
A[0] = B[0] - C[0];
|
|
A[1] = B[1] - C[1];
|
|
A[2] = B[2] - C[2];
|
|
}
|
|
|
|
template<class T> void VectorAddition(T* A, T* B, T* C)
|
|
{
|
|
A[0] = B[0] + C[0];
|
|
A[1] = B[1] + C[1];
|
|
A[2] = B[2] + C[2];
|
|
}
|
|
|
|
template<class T> void VectorMultiply(T* A, T* B, T* C)
|
|
{
|
|
A[0] = B[0] * C[0];
|
|
A[1] = B[1] * C[1];
|
|
A[2] = B[2] * C[2];
|
|
}
|
|
|
|
template<class T> void VectorDivide(T* A, T* B, T* C)
|
|
{
|
|
A[0] = B[0] / C[0];
|
|
A[1] = B[1] / C[1];
|
|
A[2] = B[2] / C[2];
|
|
}
|
|
|
|
template<class T> void VectorCrossProduct(T* A, T* B, T* C)
|
|
{
|
|
T D[3];
|
|
D[0] = B[1] * C[2] - B[2] * C[1];
|
|
D[1] = B[2] * C[0] - B[0] * C[2];
|
|
D[2] = B[0] * C[1] - B[1] * C[0];
|
|
A[0] = D[0];
|
|
A[1] = D[1];
|
|
A[2] = D[2];
|
|
}
|
|
|
|
template<class T> void VectorMinimize(T* A, T* B, T* C)
|
|
{
|
|
A[0] = B[0] < C[0] ? B[0] : C[0];
|
|
A[1] = B[1] < C[1] ? B[1] : C[1];
|
|
A[2] = B[2] < C[2] ? B[2] : C[2];
|
|
}
|
|
|
|
template<class T> void VectorMaximize(T* A, T* B, T* C)
|
|
{
|
|
A[0] = B[0] > C[0] ? B[0] : C[0];
|
|
A[1] = B[1] > C[1] ? B[1] : C[1];
|
|
A[2] = B[2] > C[2] ? B[2] : C[2];
|
|
}
|
|
|
|
template<class T> void VectorSetLength(T* A, T* B, T C)
|
|
{
|
|
T magnitude = VectorMagnitude(B);
|
|
|
|
assert(magnitude != 0.0f);
|
|
|
|
VectorScale(A, B, C / magnitude);
|
|
}
|
|
|
|
template<class T> void VectorNormalize(T* A, T* B)
|
|
{
|
|
VectorSetLength(A, B, 1.0f);
|
|
}
|
|
|
|
template<class T> void VectorInterpolate(T* A, T* B, T* C, T scale)
|
|
{
|
|
A[0] = Interpolate(scale, B[0], C[0]);
|
|
A[1] = Interpolate(scale, B[1], C[1]);
|
|
A[2] = Interpolate(scale, B[2], C[2]);
|
|
}
|
|
|
|
inline void VectorRotate(Vector A, Vector B, Matrix C)
|
|
{
|
|
Vector tmp;
|
|
|
|
tmp[0] = VectorDotProduct(B, C[0]);
|
|
tmp[1] = VectorDotProduct(B, C[1]);
|
|
tmp[2] = VectorDotProduct(B, C[2]);
|
|
v3dcpy(A, tmp);
|
|
}
|
|
|
|
inline void VectorTranslate(Vector A, Vector B, Matrix C)
|
|
{
|
|
A[0] = B[0] + C[0][3];
|
|
A[1] = B[1] + C[1][3];
|
|
A[2] = B[2] + C[2][3];
|
|
}
|
|
|
|
inline void VectorTransform(Vector A, Vector B, Matrix C)
|
|
{
|
|
Vector tmp;
|
|
|
|
tmp[0] = VectorDotProduct(B, C[0]) + C[0][3];
|
|
tmp[1] = VectorDotProduct(B, C[1]) + C[1][3];
|
|
tmp[2] = VectorDotProduct(B, C[2]) + C[2][3];
|
|
|
|
v3dcpy(A, tmp);
|
|
}
|
|
|
|
inline void VectorInverseTransform(Vector A, Vector B, Matrix C)
|
|
{
|
|
Vector tmp;
|
|
|
|
tmp[0] = B[0] - C[0][3];
|
|
tmp[1] = B[1] - C[1][3];
|
|
tmp[2] = B[2] - C[2][3];
|
|
|
|
A[0] = tmp[0] * C[0][0] + tmp[1] * C[1][0] + tmp[2] * C[2][0];
|
|
A[1] = tmp[0] * C[0][1] + tmp[1] * C[1][1] + tmp[2] * C[2][1];
|
|
A[2] = tmp[0] * C[0][2] + tmp[1] * C[1][2] + tmp[2] * C[2][2];
|
|
}
|
|
|
|
template<struct T> int VectorsAreEqual(T* A, T* B)
|
|
{
|
|
return
|
|
EpsilonEqual(A[0], B[0]) &&
|
|
EpsilonEqual(A[1], B[1]) &&
|
|
EpsilonEqual(A[2], B[2]);
|
|
}
|
|
/*******************************************************************************
|
|
** VectorsArePerpendicular (Faulty!)
|
|
*******************************************************************************/
|
|
inline int
|
|
VectorsArePerpendicular(Vector A, Vector B)
|
|
{
|
|
return EpsilonEqual(VectorDotProduct(A, B), 0.0f);
|
|
}
|
|
/*******************************************************************************
|
|
** VectorsAreCollinear
|
|
*******************************************************************************/
|
|
inline int
|
|
VectorsAreCollinear(Vector A, Vector B)
|
|
{
|
|
Vector C;
|
|
|
|
VectorCrossProduct(C, A, B);
|
|
|
|
return EpsilonEqual(VectorMagnitude(C), 0.0f);
|
|
/*
|
|
Vector AA, BB;
|
|
|
|
VectorNormalize(AA, A);
|
|
VectorNormalize(BB, B);
|
|
|
|
return VectorsAreEqual(AA, BB);
|
|
*/
|
|
}
|
|
/*******************************************************************************
|
|
** VectorScan
|
|
*******************************************************************************/
|
|
inline int
|
|
VectorScan(Vector A, FILE* fp)
|
|
{
|
|
return fscanf(fp, "%f %f %f", &A[0], &A[1], &A[2]);
|
|
}
|
|
/*******************************************************************************
|
|
** VectorPrint
|
|
*******************************************************************************/
|
|
inline int
|
|
VectorPrint(Vector A, FILE* fp)
|
|
{
|
|
return fprintf(fp, "%f %f %f\n", A[0], A[1], A[2]);
|
|
}
|
|
|
|
typedef Vector** VectorArrayArray;
|
|
|
|
VectorArrayArray VectorArrayArrayCreate(int);
|
|
VectorArrayArray VectorArrayArrayRead(FILE* file);
|
|
|
|
#endif
|
|
|