Untuk membuat projectnya buka visual studio - new - project - pilih visual c++ -pilih win32 project - pilih windows application...
disitu sudah tersedia contoh untuk windows application dasar (kita dapat merubahnya nanti) silahkan tekan f5 untuk melihat menu windownya...
Lalu di menu solution explorer klik kanan - add - header file - tuliskan namanya menjadi Vector2D.h...
sudah?
nah sekarang kita harus menuliskan kode program untuk semua operasi vector yang nantinya akan dipakai untuk menggambar lapangan, pergerakan pemain, dan pergerakan bola...
Vector2D.h
#ifndef VECTOR2D_H
#define VECTOR2D_H
#include
#include
#include
#include
#include "utils.h" //tar dibuat file header utils.h
struct Vector2D
{
double x;
double y;
Vector2D(): x(0,0), y(0,0){} // ctor tanpa parameter
Vector2D(double a, double b) : x(a),y(b){} // ctor dengan parameter
void Nol() {x=0,0; y=0,0;}
bool isNol()const {return (x*x + y*y)< MinDouble;} // nah MinDouble itu nanti ada di utils.h
inline double Length()const;
inline double Lengthsq()const; // bedanya klo Lengthsq tanpa pke sqrt (akar)
inline void Normalize();
inline double Dot(const Vector2D& v2)const;
inline int Sign(const Vector2D& v2)const; // Vektor memiliki arah, tujuannya untuk
//Menentukan arah vektor positif atau negatif
inline Vector2D Perp()const;
inline void Truncate(double max);
//Jarak antara vektor
inline double Distance(const Vector2D &v2)const;
//akarkan Vektor diatas.
inline double DistanceSq(const Vector2D &v2)const;
inline void Reflect(const Vector2D& norm);
//kembalikan nilai vektor yang direverse
inline Vector2D GetReverse()const;
//Overload operator
const Vector2D& operator+=(const Vector2D &rhs)
{
x += rhs.x;
y += rhs.y;
return *this;
}
const Vector2D& operator-=(const Vector2D &rhs)
{
x -= rhs.x;
y -= rhs.y;
return *this;
}
const Vector2D& operator*=(const double& rhs)
{
x *= rhs;
y *= rhs;
return *this;
}
const Vector2D& operator/=(const double& rhs)
{
x /= rhs;
y /= rhs;
return *this;
}
bool operator==(const Vector2D& rhs)const
{
return (isEqual(x, rhs.x) && isEqual(y,rhs.y) );
}
bool operator!=(const Vector2D& rhs)const
{
return (x != rhs.x) || (y != rhs.y);
}
};
//---------------------------------------------------beberapa overload operator
inline Vector2D operator*(const Vector2D &lhs, double rhs);
inline Vector2D operator*(double lhs, const Vector2D &rhs);
inline Vector2D operator-(const Vector2D &lhs, const Vector2D &rhs);
inline Vector2D operator+(const Vector2D &lhs, const Vector2D &rhs);
inline Vector2D operator/(const Vector2D &lhs, double val);
std::ostream& operator<<(std::ostream& os, const Vector2D& rhs);
std::ifstream& operator>>(std::ifstream& is, Vector2D& lhs);
//------------------------------------------------------------------------Fungsi member
//------------------------- Length ---------------------------------------
//
// returns the length of a 2D vector
//------------------------------------------------------------------------
inline double Vector2D::Length()const
{
return sqrt(x * x + y * y);
}
//------------------------- LengthSq -------------------------------------
//
// returns the squared length of a 2D vector
//------------------------------------------------------------------------
inline double Vector2D::LengthSq()const
{
return (x * x + y * y);
}
//------------------------- Vec2DDot -------------------------------------
//
// calculates the dot product
//------------------------------------------------------------------------
inline double Vector2D::Dot(const Vector2D &v2)const
{
return x*v2.x + y*v2.y;
}
//------------------------ Sign (penanda positif atau negatif----------------------------------
//
// Positif jika vektor searah jarum jam,
// negatif jika vektor berlawanan arah jarum jam (Y axis kebawah, X axis to kanan)
//------------------------------------------------------------------------
enum {clockwise = 1, anticlockwise = -1};
inline int Vector2D::Sign(const Vector2D& v2)const
{
if (y*v2.x > x*v2.y)
{
return anticlockwise;
}
else
{
return clockwise;
}
}
//------------------------------ Perpendicular ------------------------------------
//
// Prependicular vektor
//------------------------------------------------------------------------
inline Vector2D Vector2D::Perp()const
{
return Vector2D(-y, x);
}
//------------------------------ Distance --------------------------------
//
// calculates the euclidean distance between two vectors
//------------------------------------------------------------------------
inline double Vector2D::Distance(const Vector2D &v2)const
{
double ySeparation = v2.y - y;
double xSeparation = v2.x - x;
return sqrt(ySeparation*ySeparation + xSeparation*xSeparation);
}
//------------------------------ DistanceSq (jarak tanpa sqrt) ------------------------------
//
// calculates the euclidean distance squared between two vectors
//------------------------------------------------------------------------
inline double Vector2D::DistanceSq(const Vector2D &v2)const
{
double ySeparation = v2.y - y;
double xSeparation = v2.x - x;
return ySeparation*ySeparation + xSeparation*xSeparation;
}
//----------------------------- Truncate (pemotongan) ---------------------------------
//
// truncates a vector so that its length does not exceed max
//------------------------------------------------------------------------
inline void Vector2D::Truncate(double max)
{
if (this->Length() > max)
{
this->Normalize();
*this *= max;
}
}
//---------------------------REFLEKSI -------------------------------------
inline void Vector2D::Reflect(const Vector2D& norm)
{
*this += 2.0 * this->Dot(norm) * norm.GetReverse();
}
//----------------------- REVERSE ----------------------------------------
//
// returns the vector that is the reverse of this vector
//------------------------------------------------------------------------
inline Vector2D Vector2D::GetReverse()const
{
return Vector2D(-this->x, -this->y);
}
//------------------------- Normalize ------------------------------------
//
// normalizes a 2D Vector
//------------------------------------------------------------------------
inline void Vector2D::Normalize()
{
double vector_length = this->Length();
if (vector_length > std::numeric_limits
{
this->x /= vector_length;
this->y /= vector_length;
}
}
//------------------------------------------------------------------------Fungsi yang bukan //member vektor
inline Vector2D Vec2DNormalize(const Vector2D &v)
{
Vector2D vec = v;
double vector_length = vec.Length();
if (vector_length > std::numeric_limits
{
vec.x /= vector_length;
vec.y /= vector_length;
}
return vec;
}
inline double Vec2DDistance(const Vector2D &v1, const Vector2D &v2)
{
double ySeparation = v2.y - v1.y;
double xSeparation = v2.x - v1.x;
return sqrt(ySeparation*ySeparation + xSeparation*xSeparation);
}
inline double Vec2DDistanceSq(const Vector2D &v1, const Vector2D &v2)
{
double ySeparation = v2.y - v1.y;
double xSeparation = v2.x - v1.x;
return ySeparation*ySeparation + xSeparation*xSeparation;
}
inline double Vec2DLength(const Vector2D& v)
{
return sqrt(v.x*v.x + v.y*v.y);
}
inline double Vec2DLengthSq(const Vector2D& v)
{
return (v.x*v.x + v.y*v.y);
}
inline Vector2D POINTStoVector(const POINTS& p)
{
return Vector2D(p.x, p.y);
}
inline Vector2D POINTtoVector(const POINT& p)
{
return Vector2D((double)p.x, (double)p.y);
}
inline POINTS VectorToPOINTS(const Vector2D& v)
{
POINTS p;
p.x = (short)v.x;
p.y = (short)v.y;
return p;
}
inline POINT VectorToPOINT(const Vector2D& v)
{
POINT p;
p.x = (long)v.x;
p.y = (long)v.y;
return p;
}
// Overload Operator
inline Vector2D operator*(const Vector2D &lhs, double rhs)
{
Vector2D result(lhs);
result *= rhs;
return result;
}
inline Vector2D operator*(double lhs, const Vector2D &rhs)
{
Vector2D result(rhs);
result *= lhs;
return result;
}
//overload the - operator
inline Vector2D operator-(const Vector2D &lhs, const Vector2D &rhs)
{
Vector2D result(lhs);
result.x -= rhs.x;
result.y -= rhs.y;
return result;
}
//overload the + operator
inline Vector2D operator+(const Vector2D &lhs, const Vector2D &rhs)
{
Vector2D result(lhs);
result.x += rhs.x;
result.y += rhs.y;
return result;
}
//overload the / operator
inline Vector2D operator/(const Vector2D &lhs, double val)
{
Vector2D result(lhs);
result.x /= val;
result.y /= val;
return result;
}
///////////////////////////////////////////////////////////////////////////////
inline void WrapAround(Vector2D &pos, int MaxX, int MaxY)
{
if (pos.x > MaxX) {pos.x = 0.0;}
if (pos.x < 0) {pos.x = (double)MaxX;}
if (pos.y < 0) {pos.y = (double)MaxY;}
if (pos.y > MaxY) {pos.y = 0.0;}
}
inline bool NotInsideRegion(Vector2D p,
Vector2D top_left,
Vector2D bot_rgt)
{
return (p.x <> bot_rgt.x) ||
(p.y <> bot_rgt.y);
}
inline bool InsideRegion(Vector2D p,
Vector2D top_left,
Vector2D bot_rgt)
{
return !((p.x <> bot_rgt.x) ||
(p.y <> bot_rgt.y));
}
inline bool InsideRegion(Vector2D p, int left, int top, int right, int bottom)
{
return !( (p.x <> right) || (p.y <> bottom) );
}
inline bool isSecondInFOVOfFirst(Vector2D posFirst,
Vector2D facingFirst,
Vector2D posSecond,
double fov)
{
Vector2D toTarget = Vec2DNormalize(posSecond - posFirst);
return facingFirst.Dot(toTarget) >= cos(fov/2.0);
}
#endif
}
-bingung? baca lagi Pengantar C++ nya....
-Kenapa menggunakan C++ ? karena dia full support untuk OOP...
-beberapa operasi vektor pada kode diatas adalah jumlah operasi vektor yang sebenarnya (aljabar linear lanjutan)