标签：right const 艾孜尔江 float Vector4 getX getY Vector 设计
设计（头文件）
#pragma once
#include <iostream>
namespace RenderEngine {
class Vector2
{
public:
Vector2() : m_x(0), m_y(0) {};
Vector2(const Vector2& vecToBeCopied) {
this->setX(vecToBeCopied.getX());
this->setY(vecToBeCopied.getY());
};
Vector2(float param) : m_x(param), m_y(param) {};
Vector2(const float& a0, const float& a1) :
m_x(a0), m_y(a1) {};
~Vector2() {};
void operator =(const Vector2& right);
Vector2 operator +(const Vector2& right)const;
Vector2 operator -(const Vector2& right)const;
template<typename T>
Vector2 operator *(const T& right) const;
Vector2 operator /(const float& right) const;
float operator *(const Vector2& right)const;
bool operator ==(const float aNumbuer) {
return (this->getX() == aNumbuer && this->getY() && aNumbuer);
}
bool operator ==(const Vector2& rightVec) {
return (this->getX() == rightVec.getX() && this->getY() == rightVec.getY());
}
static void swap(Vector2& vecA, Vector2& vecB);
float getX()const { return m_x; }
float getY()const { return m_y; }
void setX(const float& x) { m_x = x; }
void setY(const float& y) { m_y = y; }
float getLength();
private:
float m_x;
float m_y;
};
class Vector3
{
public:
Vector3() : m_x(0), m_y(0), m_z(0) {};
Vector3(const Vector3& vecToBeCopied) {
this->setX(vecToBeCopied.getX());
this->setY(vecToBeCopied.getY());
this->setZ(vecToBeCopied.getZ());
};
Vector3(float param) : m_x(param), m_y(param), m_z(param) {};
Vector3(const float& a0, const float& a1, const float& a2) :
m_x(a0), m_y(a1), m_z(a2) {};
~Vector3() {};
bool operator ==(float right)const;
bool operator ==(const Vector3& right) const;
Vector3 operator +(const Vector3& right)const;
Vector3 operator -(const Vector3& right)const;
Vector3 operator *(const float k)const;
float operator *(const Vector3& right)const;
template<typename T>
Vector3 operator *(const T& right) const;
Vector3 operator ^(const Vector3& right)const; // vector cross product
void Normalize();
static Vector3 Normalize(const Vector3& vecToBeNormalized);
float getX()const { return m_x; }
float getY()const { return m_y; }
float getZ()const { return m_z; }
float getR()const { return m_x; }
float getG()const { return m_y; }
float getB()const { return m_z; }
void setX(const float& x) { m_x = x; }
void setY(const float& y) { m_y = y; }
void setZ(const float& z) { m_z = z; }
void setR(const float& x) { m_x = x; }
void setG(const float& y) { m_y = y; }
void setB(const float& z) { m_z = z; }
float getLength();
private:
float m_x;
float m_y;
float m_z;
};
class Vector4
{
public:
Vector4() :
m_x(0), m_y(0), m_z(0), m_w(0) {};
Vector4(const Vector4& vecToBeCopied) {
this->setX(vecToBeCopied.getX());
this->setY(vecToBeCopied.getY());
this->setZ(vecToBeCopied.getZ());
this->setW(vecToBeCopied.getW());
};
Vector4(const Vector3& vecToBeCopied, bool isPoint = false) {
this->setX(vecToBeCopied.getX());
this->setY(vecToBeCopied.getY());
this->setZ(vecToBeCopied.getZ());
if (isPoint)this->setW(1);
else this->setW(0);
};
Vector4(const float& a0, const float& a1, const float& a2, const float& a3 = 0) :
m_x(a0), m_y(a1), m_z(a2), m_w(a3) {};
~Vector4() {};
bool operator ==(float right)const;
bool operator ==(const Vector4& right)const;
bool operator !=(const Vector4& right)const;
Vector4 operator +(const Vector4& right)const;
Vector4 operator -(const Vector4& right)const;
Vector4 operator *(const float k)const;
Vector4 operator /(const float k)const;
float operator *(const Vector4& right)const;
Vector4 operator ^(const Vector4& right)const; // vector cross product
Vector4 getInterpolateVector(const Vector4& vecA, const Vector4& vecB, float factor);
Vector4 getQuaternion(const Vector3 & lastPoint, const Vector3 & currentPoint);
void Normalize();
Vector4 GetNormalizedVector() const;
static bool swap(Vector4& v1, Vector4& v2);
float getX()const { return m_x; }
float getY()const { return m_y; }
float getZ()const { return m_z; }
float getW()const { return m_w; }
float getR()const { return m_x; }
float getG()const { return m_y; }
float getB()const { return m_z; }
float getA()const { return m_w; }
void setX(const float& x) { m_x = x; }
void setY(const float& y) { m_y = y; }
void setZ(const float& z) { m_z = z; }
void setW(const float& w) { m_w = w; }
void setR(const float& r) { m_x = r; }
void setG(const float& g) { m_y = g; }
void setB(const float& b) { m_z = b; }
void setA(const float& a) { m_w = a; }
private:
float m_x;
float m_y;
float m_z;
float m_w;
};
inline std::ostream& operator <<(std::ostream& os, const Vector4& vec4) { os << "x: " << vec4.getX() << "; y: " << vec4.getY() << "; z: " << vec4.getZ() << "; w: " << vec4.getW() << ". "; return os; }
inline std::ostream& operator <<(std::ostream& os, const Vector3& vec3) { os << "x: " << vec3.getX() << "; y: " << vec3.getY() << "; z: " << vec3.getZ() << ". "; return os; }
inline std::ostream& operator <<(std::ostream& os, const Vector2& vec2) { os << "x: " << vec2.getX() << "; y: " << vec2.getY() << ". "; return os; }
}
实现（C++文件）
#include <math.h>
#include "Vector.h"
#include "Math.h"
namespace RenderEngine {
/************************************************************************/
/* Vector2 */
/************************************************************************/
void Vector2::operator=(const Vector2 & right)
{
this->setX(right.getX());
this->setY(right.getY());
}
Vector2 Vector2::operator+(const Vector2& right) const
{
Vector2 result(this->getX() + right.getX(), this->getY() + right.getY());
return result;
}
Vector2 Vector2::operator-(const Vector2& right) const
{
Vector2 result(this->getX() - right.getX(), this->getY() - right.getY());
return result;
}
template<typename T>
Vector2 Vector2::operator*(const T& k) const
{
Vector2 result(this->getX() * k, this->getY() * k);
return result;
}
Vector2 Vector2::operator /(const float& k) const
{
if (k == 0.f || abs(k - 0.f) < EPSILON) {
return Vector2();
}
float reciprocalK = 1 / k;
Vector2 result(this->getX()*reciprocalK, this->getY()*reciprocalK);
return result;
}
float Vector2::operator*(const Vector2& right) const
{
return (this->getX() * right.getX() + this->getY() * right.getY());
}
void Vector2::swap(Vector2 & vecA, Vector2 & vecB)
{
if (vecA == vecB)return;
Vector2 tmp(vecA.getX(), vecA.getY());
vecA = vecB;
vecB = tmp;
}
float Vector2::getLength()
{
return sqrtf(powf(this->getX(), 2) + powf(this->getY(), 2));
}
/************************************************************************/
/* Vector3 */
/************************************************************************/
bool Vector3::operator==(const float right) const
{
bool xIsEqual = fabsf(this->getX() - right) <= EPSILON;
bool yIsEqual = fabsf(this->getY() - right) <= EPSILON;
bool zIsEqual = fabsf(this->getZ() - right) <= EPSILON;
return (xIsEqual && yIsEqual && zIsEqual);
}
bool Vector3::operator==(const Vector3 & right) const
{
bool xIsEqual = fabsf(this->getX() - right.getX()) <= EPSILON;
bool yIsEqual = fabsf(this->getY() - right.getY()) <= EPSILON;
bool zIsEqual = fabsf(this->getZ() - right.getZ()) <= EPSILON;
return (xIsEqual && yIsEqual && zIsEqual);
}
Vector3 Vector3::operator+(const Vector3 & right) const
{
Vector3 result(this->getX() + right.getX(), this->getY() + right.getY(), this->getZ() + right.getZ());
return result;
}
Vector3 Vector3::operator-(const Vector3 & right) const
{
Vector3 result(this->getX() - right.getX(), this->getY() - right.getY(), this->getZ() - right.getZ());
return result;
}
Vector3 Vector3::operator*(const float k) const
{
Vector3 result(this->getX() * k, this->getY() * k, this->getZ() * k);
return result;
}
float Vector3::operator*(const Vector3 & right) const
{
return (this->getX()*right.getX() + this->getY()*right.getY() + this->getZ()*right.getZ());
}
template<typename T>
Vector3 Vector3::operator*(const T& right) const
{
Vector3 result(
this->getX()*right.matrix[0][0] + this->getY()*right.matrix[0][1] + this->getZ() * right.matrix[0][2],
this->getY()*right.matrix[1][0] + this->getY()*right.matrix[1][1] + this->getZ() * right.matrix[1][2],
this->getZ()*right.matrix[2][0] + this->getY()*right.matrix[2][1] + this->getZ() * right.matrix[2][2]);
return result;
}
Vector3 Vector3::operator^(const Vector3 & right) const
{
Vector3 result;
result.setX(this->getY() * right.getZ() - this->getZ() * right.getY());
result.setY(this->getZ() * right.getX() - this->getX() * right.getZ());
result.setZ(this->getX() * right.getY() - this->getY() * right.getX());
return result;
}
void Vector3::Normalize()
{
float length = sqrtf(powf(this->getX(), 2) + powf(this->getY(), 2) + powf(this->getZ(), 2));
this->setX(this->getX() / length);
this->setY(this->getY() / length);
this->setZ(this->getZ() / length);
}
Vector3 Vector3::Normalize(const Vector3& vecToBeNormalized)
{
Vector3 result;
float length = sqrtf(powf(vecToBeNormalized.getX(), 2) + powf(vecToBeNormalized.getY(), 2) + powf(vecToBeNormalized.getZ(), 2));
result.setX(vecToBeNormalized.getX() / length);
result.setY(vecToBeNormalized.getY() / length);
result.setZ(vecToBeNormalized.getZ() / length);
return result;
}
float Vector3::getLength()
{
return sqrtf(powf(this->getX(), 2) + powf(this->getY(), 2) + powf(this->getZ(), 2));
}
/************************************************************************/
/* Vector4 */
/************************************************************************/
bool Vector4::operator==(float right) const
{
bool xIsEqual = fabsf(this->getX() - right) <= EPSILON;
bool yIsEqual = fabsf(this->getY() - right) <= EPSILON;
bool zIsEqual = fabsf(this->getZ() - right) <= EPSILON;
bool wIsEqual = fabsf(this->getW() - right) <= EPSILON;
return (xIsEqual && yIsEqual && zIsEqual && wIsEqual);
}
bool Vector4::operator==(const Vector4 & right) const
{
bool xIsEqual = fabsf(this->getX() - right.getX()) <= EPSILON;
bool yIsEqual = fabsf(this->getY() - right.getY()) <= EPSILON;
bool zIsEqual = fabsf(this->getZ() - right.getZ()) <= EPSILON;
bool wIsEqual = fabsf(this->getW() - right.getW()) <= EPSILON;
return (xIsEqual && yIsEqual && zIsEqual && wIsEqual);
}
bool Vector4::operator!=(const Vector4 & right) const
{
bool xIsInequal = fabsf(this->getX() - right.getX()) > EPSILON;
bool yIsInequal = fabsf(this->getY() - right.getY()) > EPSILON;
bool zIsInequal = fabsf(this->getZ() - right.getZ()) > EPSILON;
bool wIsInequal = fabsf(this->getW() - right.getW()) > EPSILON;
return (xIsInequal || yIsInequal || zIsInequal || wIsInequal);
}
Vector4 Vector4::operator +(const Vector4 & right) const
{
Vector4 result(this->getX() + right.getX(), this->getY() + right.getY(), this->getZ() + right.getZ(), this->getW() + right.getW());
return result;
}
Vector4 Vector4::operator-(const Vector4 & right) const
{
Vector4 result(this->getX() - right.getX(), this->getY() - right.getY(), this->getZ() - right.getZ(), this->getW() - right.getW());
return result;
}
Vector4 Vector4::operator*(const float k) const
{
Vector4 result(this->getX()*k, this->getY()*k, this->getZ() *k, this->getW() *k);
return result;
}
Vector4 Vector4::operator/(const float k) const
{
float reciprocalK = 1 / k;
Vector4 result(this->getX()*reciprocalK, this->getY()*reciprocalK, this->getZ() *reciprocalK, this->getW() *reciprocalK);
return result;
}
float Vector4::operator *(const Vector4 & right) const
{
return this->getX()*right.getX() + this->getY()*right.getY() + this->getZ()*right.getZ() + this->getW()*right.getW();
}
Vector4 Vector4::operator ^(const Vector4& right) const
{
Vector4 result(this->getY()*right.getZ() - this->getZ()*right.getY(),
this->getZ()*right.getX() - this->getX()*right.getZ(),
this->getX()* right.getY() - this->getY()*right.getX());
return result;
}
Vector4 Vector4::getInterpolateVector(const Vector4 & vecA, const Vector4 & vecB, float factor)
{
Vector4 result(
LinearInerpolate(vecA.getX(), vecB.getX(), factor),
LinearInerpolate(vecA.getY(), vecB.getY(), factor),
LinearInerpolate(vecA.getZ(), vecB.getZ(), factor),
1.f
);
return result;
}
Vector4 Vector4::getQuaternion(const Vector3 & lastPoint, const Vector3 & currentPoint)
{
Vector4 result;
Vector3 perp = lastPoint ^ currentPoint;
if (perp.getLength() > EPSILON)
{
result.setX(perp.getX());
result.setY(perp.getY());
result.setZ(perp.getZ());
// w=cos(rotationAngle/2) ---> formula
result.setW(lastPoint * currentPoint);
}
else
{
result.setX(.0f);
result.setY(.0f);
result.setZ(.0f);
result.setW(.0f);
}
return result;
}
void Vector4::Normalize()
{
float length = sqrtf(powf(this->getX(), 2) + powf(this->getY(), 2) + powf(this->getZ(), 2));
this->setX(this->getX() / length);
this->setY(this->getY() / length);
this->setZ(this->getZ() / length);
}
Vector4 Vector4::GetNormalizedVector() const
{
Vector4 result;
float length = sqrtf(powf(this->getX(), 2) + powf(this->getY(), 2) + powf(this->getZ(), 2));
result.setX(this->getX() / length);
result.setY(this->getY() / length);
result.setZ(this->getZ() / length);
return result;
}
bool Vector4::swap(Vector4 & v1, Vector4 & v2)
{
if (v1 != v2)
{
std::swap(v1.m_x, v2.m_x);
std::swap(v1.m_y, v2.m_y);
std::swap(v1.m_z, v2.m_z);
std::swap(v1.m_w, v2.m_w);
}
return true;
}
}
作者：艾孜尔江·艾尔斯兰
标签：right,const,艾孜尔江,float,Vector4,getX,getY,Vector,设计 来源： https://blog.csdn.net/weixin_43867242/article/details/117898875
本站声明： 1. iCode9 技术分享网（下文简称本站）提供的所有内容，仅供技术学习、探讨和分享； 2. 关于本站的所有留言、评论、转载及引用，纯属内容发起人的个人观点，与本站观点和立场无关； 3. 关于本站的所有言论和文字，纯属内容发起人的个人观点，与本站观点和立场无关； 4. 本站文章均是网友提供，不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属；如您发现该文章侵犯了您的权益，可联系我们第一时间进行删除； 5. 本站为非盈利性的个人网站，所有内容不会用来进行牟利，也不会利用任何形式的广告来间接获益，纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。