diff --git a/Simulations/SphereSystemSimulator.cpp b/Simulations/SphereSystemSimulator.cpp new file mode 100644 index 0000000..09de9de --- /dev/null +++ b/Simulations/SphereSystemSimulator.cpp @@ -0,0 +1,11 @@ +#include "SphereSystemSimulator.h" + +std::function SphereSystemSimulator::m_Kernels[5] = { + [](float x) {return 1.0f; }, // Constant, m_iKernel = 0 + [](float x) {return 1.0f - x; }, // Linear, m_iKernel = 1, as given in the exercise Sheet, x = d/2r + [](float x) {return (1.0f - x)*(1.0f - x); }, // Quadratic, m_iKernel = 2 + [](float x) {return 1.0f / (x)-1.0f; }, // Weak Electric Charge, m_iKernel = 3 + [](float x) {return 1.0f / (x*x) - 1.0f; }, // Electric Charge, m_iKernel = 4 +}; + +// SphereSystemSimulator member functions \ No newline at end of file diff --git a/Simulations/SphereSystemSimulator.h b/Simulations/SphereSystemSimulator.h new file mode 100644 index 0000000..6085574 --- /dev/null +++ b/Simulations/SphereSystemSimulator.h @@ -0,0 +1,49 @@ +#ifndef SPHSYSTEMSIMULATOR_h +#define SPHSYSTEMSIMULATOR_h +#include "Simulator.h" +//#include "spheresystem.h", add your sphere system header file + +#define NAIVEACC 0 +#define GRIDACC 1 + +class SphereSystemSimulator:public Simulator{ +public: + // Construtors + SphereSystemSimulator(); + // Functions + const char * getTestCasesStr(); + void initUI(DrawingUtilitiesClass * DUC); + void reset(); + void drawFrame(ID3D11DeviceContext* pd3dImmediateContext); + void notifyCaseChanged(int testCase); + void externalForcesCalculations(float timeElapsed); + void simulateTimestep(float timeStep); + void onClick(int x, int y); + void onMouse(int x, int y); + +protected: + // Attributes + Vec3 externalForce; + Point2D m_mouse; + Point2D m_trackmouse; + Point2D m_oldtrackmouse; + float m_fMass; + float m_fRadius; + float m_fForceScaling; + float m_fDamping; + int m_iNumSpheres; + + int m_iKernel; // index of the m_Kernels[5], more detials in SphereSystemSimulator.cpp + static std::function m_Kernels[5]; + + int m_iAccelerator; // switch between NAIVEACC and GRIDACC, (optionally, KDTREEACC, 2) + + //SphereSystem * m_pSphereSystem; // add your own sphere system member! + // for Demo 3 only: + // you will need multiple SphereSystem objects to do comparisons in Demo 3 + // m_iAccelerator should be ignored. + // SphereSystem * m_pSphereSystemGrid; + +}; + +#endif \ No newline at end of file diff --git a/Simulations/main.cpp b/Simulations/main.cpp index 017be58..f41c4ad 100644 --- a/Simulations/main.cpp +++ b/Simulations/main.cpp @@ -20,10 +20,10 @@ using namespace GamePhysics; //#define ADAPTIVESTEP -#define TEMPLATE_DEMO +//#define TEMPLATE_DEMO //#define MASS_SPRING_SYSTEM //#define RIGID_BODY_SYSTEM -//#define SPH_SYSTEM +#define SPHERE_SYSTEM #ifdef TEMPLATE_DEMO #include "TemplateSimulator.h" @@ -32,10 +32,10 @@ using namespace GamePhysics; #include "MassSpringSystemSimulator.h" #endif #ifdef RIGID_BODY_SYSTEM -//#include "RigidBodySystemSimulator.h" +#include "RigidBodySystemSimulator.h" #endif -#ifdef SPH_SYSTEM -//#include "SPHSystemSimulator.h" +#ifdef SPHERE_SYSTEM +#include "SphereSystemSimulator.h" #endif DrawingUtilitiesClass * g_pDUC; @@ -204,9 +204,7 @@ void CALLBACK OnMouse( bool bLeftButtonDown, bool bRightButtonDown, bool bMiddle g_pSimulator->onClick(xPos,yPos); } else - { g_pSimulator->onMouse(xPos, yPos); - } } @@ -365,10 +363,10 @@ int main(int argc, char* argv[]) g_pSimulator= new MassSpringSystemSimulator(); #endif #ifdef RIGID_BODY_SYSTEM - //g_pSimulator= new RigidBodySystemSimulator(); + g_pSimulator= new RigidBodySystemSimulator(); #endif -#ifdef SPH_SYSTEM - //g_pSimulator= new SPHSystemSimulator(); +#ifdef SPHERE_SYSTEM + g_pSimulator= new SphereSystemSimulator(); #endif g_pSimulator->reset(); diff --git a/Simulations/util/vector4d.h b/Simulations/util/vector4d.h index 633ae2f..2e70227 100644 --- a/Simulations/util/vector4d.h +++ b/Simulations/util/vector4d.h @@ -14,29 +14,29 @@ namespace GamePhysics // basic inlined vector class template -class ntlVector4Dim +class vector4Dim { public: //! Constructor - inline ntlVector4Dim() : x(0),y(0),z(0),t(0) {} + inline vector4Dim() : x(0),y(0),z(0),t(0) {} //! Copy-Constructor - inline ntlVector4Dim ( const ntlVector4Dim &v ) : x(v.x), y(v.y), z(v.z),t(v.t) {} + inline vector4Dim ( const vector4Dim &v ) : x(v.x), y(v.y), z(v.z),t(v.t) {} //! Copy-Constructor - inline ntlVector4Dim ( const float * v) : x((Scalar)v[0]), y((Scalar)v[1]), z((Scalar)v[2]), t((Scalar)v[3]) {} + inline vector4Dim ( const float * v) : x((Scalar)v[0]), y((Scalar)v[1]), z((Scalar)v[2]), t((Scalar)v[3]) {} //! Copy-Constructor - inline ntlVector4Dim ( const double * v) : x((Scalar)v[0]), y((Scalar)v[1]), z((Scalar)v[2]), t((Scalar)v[3]) {} + inline vector4Dim ( const double * v) : x((Scalar)v[0]), y((Scalar)v[1]), z((Scalar)v[2]), t((Scalar)v[3]) {} //! Construct a vector from one Scalar - inline ntlVector4Dim ( Scalar v) : x(v), y(v), z(v), t(v) {} + inline vector4Dim ( Scalar v) : x(v), y(v), z(v), t(v) {} //! Construct a vector from four Ss - inline ntlVector4Dim ( Scalar vx, Scalar vy, Scalar vz, Scalar vw) : x(vx), y(vy), z(vz), t(vw) {} + inline vector4Dim ( Scalar vx, Scalar vy, Scalar vz, Scalar vw) : x(vx), y(vy), z(vz), t(vw) {} //! Construct a vector from four Ss - //inline ntlVector4Dim(DirectX::XMVECTOR &v ); // TODO CHECK! + //inline vector4Dim(DirectX::XMVECTOR &v ); // TODO CHECK! // get address of array for OpenGL Scalar *getAddress() { return value; } @@ -44,7 +44,7 @@ public: // Operators //! Assignment operator - inline const ntlVector4Dim& operator= ( const ntlVector4Dim& v ) { + inline const vector4Dim& operator= ( const vector4Dim& v ) { x = v.x; y = v.y; z = v.z; @@ -52,12 +52,12 @@ public: return *this; } //! Assignment operator - inline const ntlVector4Dim& operator= ( Scalar s ) { + inline const vector4Dim& operator= ( Scalar s ) { x = y = z = t = s; return *this; } //! Assign and add operator - inline const ntlVector4Dim& operator+= ( const ntlVector4Dim& v ) { + inline const vector4Dim& operator+= ( const vector4Dim& v ) { x += v.x; y += v.y; z += v.z; @@ -65,7 +65,7 @@ public: return *this; } //! Assign and add operator - inline const ntlVector4Dim& operator+= ( Scalar s ) { + inline const vector4Dim& operator+= ( Scalar s ) { x += s; y += s; z += s; @@ -73,7 +73,7 @@ public: return *this; } //! Assign and sub operator - inline const ntlVector4Dim& operator-= ( const ntlVector4Dim& v ) { + inline const vector4Dim& operator-= ( const vector4Dim& v ) { x -= v.x; y -= v.y; z -= v.z; @@ -81,7 +81,7 @@ public: return *this; } //! Assign and sub operator - inline const ntlVector4Dim& operator-= ( Scalar s ) { + inline const vector4Dim& operator-= ( Scalar s ) { x -= s; y -= s; z -= s; @@ -89,7 +89,7 @@ public: return *this; } //! Assign and mult operator - inline const ntlVector4Dim& operator*= ( const ntlVector4Dim& v ) { + inline const vector4Dim& operator*= ( const vector4Dim& v ) { x *= v.x; y *= v.y; z *= v.z; @@ -97,7 +97,7 @@ public: return *this; } //! Assign and mult operator - inline const ntlVector4Dim& operator*= ( Scalar s ) { + inline const vector4Dim& operator*= ( Scalar s ) { x *= s; y *= s; z *= s; @@ -105,7 +105,7 @@ public: return *this; } //! Assign and div operator - inline const ntlVector4Dim& operator/= ( const ntlVector4Dim& v ) { + inline const vector4Dim& operator/= ( const vector4Dim& v ) { x /= v.x; y /= v.y; z /= v.z; @@ -113,7 +113,7 @@ public: return *this; } //! Assign and div operator - inline const ntlVector4Dim& operator/= ( Scalar s ) { + inline const vector4Dim& operator/= ( Scalar s ) { x /= s; y /= s; z /= s; @@ -121,29 +121,29 @@ public: return *this; } - inline void safeDivide (const ntlVector4Dim& v); + inline void safeDivide (const vector4Dim& v); //! Negation operator - inline ntlVector4Dim operator- () const { - return ntlVector4Dim (-x, -y, -z, -t); + inline vector4Dim operator- () const { + return vector4Dim (-x, -y, -z, -t); } // binary operator add - inline ntlVector4Dim operator+ (const ntlVector4Dim&) const; + inline vector4Dim operator+ (const vector4Dim&) const; // binary operator add - inline ntlVector4Dim operator+ (Scalar) const; + inline vector4Dim operator+ (Scalar) const; // binary operator sub - inline ntlVector4Dim operator- (const ntlVector4Dim&) const; + inline vector4Dim operator- (const vector4Dim&) const; // binary operator sub - inline ntlVector4Dim operator- (Scalar) const; + inline vector4Dim operator- (Scalar) const; // binary operator mult - inline ntlVector4Dim operator* (const ntlVector4Dim&) const; + inline vector4Dim operator* (const vector4Dim&) const; // binary operator mult - inline ntlVector4Dim operator* (Scalar) const; + inline vector4Dim operator* (Scalar) const; // binary operator div - inline ntlVector4Dim operator/ (const ntlVector4Dim&) const; + inline vector4Dim operator/ (const vector4Dim&) const; // binary operator div - inline ntlVector4Dim operator/ (Scalar) const; + inline vector4Dim operator/ (Scalar) const; //! Get smallest component //inline Scalar min() const { return ( x ZERO; + static const vector4Dim ZERO; protected: @@ -196,9 +196,9 @@ protected: //************************************************************************ //! Addition operator template -inline ntlVector4Dim ntlVector4Dim::operator+ ( const ntlVector4Dim &v) const +inline vector4Dim vector4Dim::operator+ ( const vector4Dim &v) const { - return ntlVector4Dim (value[0]+v.value[0], + return vector4Dim (value[0]+v.value[0], value[1]+v.value[1], value[2]+v.value[2], value[3]+v.value[3]); @@ -206,42 +206,42 @@ inline ntlVector4Dim ntlVector4Dim::operator+ ( const ntlVector4 //! Addition operator template -inline ntlVector4Dim -ntlVector4Dim::operator+(Scalar s) const +inline vector4Dim +vector4Dim::operator+(Scalar s) const { - return ntlVector4Dim(value[0]+s, + return vector4Dim(value[0]+s, value[1]+s, value[2]+s, value[3]+s); } template -inline ntlVector4Dim -operator+(float s, ntlVector4Dim v) +inline vector4Dim +operator+(float s, vector4Dim v) { return v + s; } template -inline ntlVector4Dim -operator+(double s, ntlVector4Dim v) +inline vector4Dim +operator+(double s, vector4Dim v) { return v + s; } template -inline ntlVector4Dim -operator+(int s, ntlVector4Dim v) +inline vector4Dim +operator+(int s, vector4Dim v) { return v + s; } //! Subtraction operator template -inline ntlVector4Dim -ntlVector4Dim::operator-( const ntlVector4Dim &v ) const +inline vector4Dim +vector4Dim::operator-( const vector4Dim &v ) const { - return ntlVector4Dim(value[0]-v.value[0], + return vector4Dim(value[0]-v.value[0], value[1]-v.value[1], value[2]-v.value[2], value[3]-v.value[3]); @@ -249,10 +249,10 @@ ntlVector4Dim::operator-( const ntlVector4Dim &v ) const //! Subtraction operator template -inline ntlVector4Dim -ntlVector4Dim::operator-(Scalar s ) const +inline vector4Dim +vector4Dim::operator-(Scalar s ) const { - return ntlVector4Dim(value[0]-s, + return vector4Dim(value[0]-s, value[1]-s, value[2]-s, value[3]-s,); @@ -260,50 +260,50 @@ ntlVector4Dim::operator-(Scalar s ) const //! Multiplication operator template -inline ntlVector4Dim -ntlVector4Dim::operator* ( const ntlVector4Dim& v ) const +inline vector4Dim +vector4Dim::operator* ( const vector4Dim& v ) const { - return ntlVector4Dim(value[0]*v.value[0], + return vector4Dim(value[0]*v.value[0], value[1]*v.value[1], value[2]*v.value[2], value[3]*v.value[3]); } //! Multiplication operator template -inline ntlVector4Dim -ntlVector4Dim::operator* (Scalar s) const +inline vector4Dim +vector4Dim::operator* (Scalar s) const { - return ntlVector4Dim(value[0]*s, value[1]*s, value[2]*s, value[3]*s); + return vector4Dim(value[0]*s, value[1]*s, value[2]*s, value[3]*s); } //! Multiplication operator template -inline ntlVector4Dim -operator* (float s, ntlVector4Dim v) +inline vector4Dim +operator* (float s, vector4Dim v) { return v * s; } template -inline ntlVector4Dim -operator*(double s, ntlVector4Dim v) +inline vector4Dim +operator*(double s, vector4Dim v) { return v * s; } template -inline ntlVector4Dim -operator*(int s, ntlVector4Dim v) +inline vector4Dim +operator*(int s, vector4Dim v) { return v * s; } //! Division operator template -inline ntlVector4Dim -ntlVector4Dim::operator/ (const ntlVector4Dim & v) const +inline vector4Dim +vector4Dim::operator/ (const vector4Dim & v) const { - return ntlVector4Dim (value[0]/v.value[0], + return vector4Dim (value[0]/v.value[0], value[1]/v.value[1], value[2]/v.value[2], value[3]/v.value[3]); @@ -311,10 +311,10 @@ ntlVector4Dim::operator/ (const ntlVector4Dim & v) const //! Division operator template -inline ntlVector4Dim -ntlVector4Dim::operator / (Scalar s) const +inline vector4Dim +vector4Dim::operator / (Scalar s) const { - return ntlVector4Dim (value[0]/s, + return vector4Dim (value[0]/s, value[1]/s, value[2]/s, value[3]/s); @@ -322,7 +322,7 @@ ntlVector4Dim::operator / (Scalar s) const //! Safe divide template -inline void ntlVector4Dim::safeDivide( const ntlVector4Dim &v ) +inline void vector4Dim::safeDivide( const vector4Dim &v ) { value[0] = (v.value[0]!=0) ? (value[0] / v.value[0]) : 0; value[1] = (v.value[1]!=0) ? (value[1] / v.value[1]) : 0; @@ -336,14 +336,14 @@ inline void ntlVector4Dim::safeDivide( const ntlVector4Dim &v ) //! Dot product template -inline Scalar dot ( const ntlVector4Dim &t, const ntlVector4Dim &v ) { +inline Scalar dot ( const vector4Dim &t, const vector4Dim &v ) { return t.x*v.x + t.y*v.y + t.z*v.z + t.t*v.t; } //! Cross product /*template -inline ntlVector4Dim cross ( const ntlVector4Dim &t, const ntlVector4Dim &v ) { - NYI ntlVector4Dim cp ( +inline vector4Dim cross ( const vector4Dim &t, const vector4Dim &v ) { + NYI vector4Dim cp ( ( ( t.y*v.z ) - ( t.z*v.y ) ), ( ( t.z*v.x ) - ( t.x*v.z ) ), ( ( t.x*v.y ) - ( t.y*v.x ) ) ); @@ -353,36 +353,36 @@ inline ntlVector4Dim cross ( const ntlVector4Dim &t, const ntlVe //! Compute the magnitude (length) of the vector template -inline Scalar norm ( const ntlVector4Dim& v ) { +inline Scalar norm ( const vector4Dim& v ) { Scalar l = v.x*v.x + v.y*v.y + v.z*v.z + v.t*v.t; return ( fabs ( l-1. ) < VECTOR_EPSILON*VECTOR_EPSILON ) ? 1. : sqrt ( l ); } //! Compute squared magnitude template -inline Scalar normSquare ( const ntlVector4Dim& v ) { +inline Scalar normSquare ( const vector4Dim& v ) { return v.x*v.x + v.y*v.y + v.z*v.z + v.t*v.t; } //! Returns a normalized vector template -inline ntlVector4Dim getNormalized ( const ntlVector4Dim& v ) { +inline vector4Dim getNormalized ( const vector4Dim& v ) { Scalar l = v.x*v.x + v.y*v.y + v.z*v.z + v.t*v.t; if ( fabs ( l-1. ) < VECTOR_EPSILON*VECTOR_EPSILON ) return v; /* normalized "enough"... */ else if ( l > VECTOR_EPSILON*VECTOR_EPSILON ) { Scalar fac = 1./sqrt ( l ); - return ntlVector4Dim ( v.x*fac, v.y*fac, v.z*fac , v.t*fac ); + return vector4Dim ( v.x*fac, v.y*fac, v.z*fac , v.t*fac ); } else - return ntlVector4Dim ( ( Scalar ) 0 ); + return vector4Dim ( ( Scalar ) 0 ); } //! Compute the norm of the vector and normalize it. /*! \return The value of the norm */ template -inline Scalar normalize ( ntlVector4Dim &v ) { +inline Scalar normalize ( vector4Dim &v ) { Scalar norm; Scalar l = v.x*v.x + v.y*v.y + v.z*v.z + v.t*v.t; if ( fabs ( l-1. ) < VECTOR_EPSILON*VECTOR_EPSILON ) { @@ -391,14 +391,14 @@ inline Scalar normalize ( ntlVector4Dim &v ) { norm = sqrt ( l ); v *= 1./norm; } else { - v = ntlVector4Dim::ZERO; + v = vector4Dim::ZERO; norm = 0.; } return ( Scalar ) norm; } template -inline bool equal(const ntlVector4Dim &v, const ntlVector4Dim &c) +inline bool equal(const vector4Dim &v, const vector4Dim &c) { return (ABS(v[0]-c[0]) + ABS(v[1]-c[1]) + @@ -407,7 +407,7 @@ inline bool equal(const ntlVector4Dim &v, const ntlVector4Dim &c } //! Outputs the object in human readable form as string -template std::string ntlVector4Dim::toString() const { +template std::string vector4Dim::toString() const { char buf[256]; snprintf ( buf,256,"<%f,%f,%f,%f>", ( double ) ( *this ) [0], ( double ) ( *this ) [1], ( double ) ( *this ) [2] , ( double ) ( *this ) [3] ); return std::string ( buf ); @@ -415,7 +415,7 @@ template std::string ntlVector4Dim::toString() const { //! Outputs the object in human readable form to stream template -std::ostream& operator<< ( std::ostream& os, const ntlVector4Dim& i ) { +std::ostream& operator<< ( std::ostream& os, const vector4Dim& i ) { char buf[256]; snprintf ( buf,256,"[%d,%d,%d,%d]", (double) i[0], (double) i[1], (double) i[2] , (double) i[3] ); os << std::string ( buf ); @@ -424,7 +424,7 @@ std::ostream& operator<< ( std::ostream& os, const ntlVector4Dim& i ) { //! Reads the contents of the object from a stream template -std::istream& operator>> ( std::istream& is, ntlVector4Dim& i ) { +std::istream& operator>> ( std::istream& is, vector4Dim& i ) { char c; char dummy[4]; is >> c >> i[0] >> dummy >> i[1] >> dummy >> i[2] >> dummy >> i[3] >> c; @@ -436,16 +436,16 @@ std::istream& operator>> ( std::istream& is, ntlVector4Dim& i ) { /**************************************************************************/ //! 3D vector class of type Real (typically float) -typedef ntlVector4Dim Vec4; +typedef vector4Dim Vec4; // a 3D vector with double precision -typedef ntlVector4Dim nVec4d; +typedef vector4Dim nVec4d; // a 3D vector with single precision -typedef ntlVector4Dim nVec4f; +typedef vector4Dim nVec4f; //! 3D vector class of type int -typedef ntlVector4Dim nVec4i; +typedef vector4Dim nVec4i; /* convert int,float and double vectors */ template inline nVec4i vec42I(T v) { return nVec4i((int)v[0],(int)v[1],(int)v[2],(int)v[3]); }