include/Integrator.h

#ifndef _INTEGRATOR_
#define _INTEGRATOR_

#include <Level2D.h>
#include <Vector2D.h>
#include <irrlicht.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>
#include <limits>
#include <disableWarnings.h>

namespace sonus
{
        using namespace::irr;

        class Integrator
        {
                public:

                        static void getTransformAndScaleFactor( Level2D* level, Vector2D* destinationOrigin, double maxValue, 
                                                                                                        Vector2D* transformationVector, double* scaleFactor )
                        {
                                Body2D<Vector2D>* border = level->worldVector2D->getBorder();

                                Vector2D minVector;
                                minVector.setTo( DBL_MAX, DBL_MAX );
                                Vector2D maxVector;
                                maxVector.setTo( DBL_MIN, DBL_MIN );
                                Vector2D tempVector;

                                for ( int i = 1; i < border->getSize(); i++ )
                                {
                                        tempVector = *border->getElementAt( i );
                                        if ( tempVector.x < minVector.x )
                                        {
                                                minVector.x = tempVector.x;
                                        }
                                        if ( tempVector.y < minVector.y )
                                        {
                                                minVector.y = tempVector.y;
                                        }
                                        if ( tempVector.x > maxVector.x )
                                        {
                                                maxVector.x = tempVector.x;
                                        }
                                        if ( tempVector.y > maxVector.y )
                                        {
                                                maxVector.y = tempVector.y;
                                        }
                                }

                                double dX = maxVector.x - minVector.x;
                                double dY = maxVector.y - minVector.y;
                                *scaleFactor = maxValue / ( dX > dY ? dX : dY );

                                *transformationVector = ( *destinationOrigin / *scaleFactor  ) 
                                        - minVector + 0.5 * ( maxVector - minVector );
                        }

                        static void transform( Vector2D* value, Vector2D* transformationVector, double scaleFactor )
                        {
                                *value -= *transformationVector;
                                *value *= scaleFactor;
                        }

                        static void reTransform( Vector2D* value, Vector2D* transformationVector, double scaleFactor )
                        {
                                *value /= scaleFactor;
                                *value += *transformationVector;
                        }

                        static Vector2D* transformInvertY( Vector2D* value, Vector2D* transformationVector, double scaleFactor )
                        {
                                Vector2D* temp = new Vector2D();
                                *temp = *value;
                                *temp -= *transformationVector;
                                *temp *= scaleFactor;
                                temp->y *= -1;

                                return temp; 
                        }

                        static Vector2D* reTransformInvertY( Vector2D* value, Vector2D* transformationVector, double scaleFactor )
                        {
                                Vector2D* temp = new Vector2D();
                                *temp = *value;

                                *temp /= scaleFactor;
                                *temp += *transformationVector;
                                temp->y *= -1;

                                return temp; 
                        }

                        static Vector2D* transformInvertX( Vector2D* value, Vector2D* transformationVector, double scaleFactor )
                        {
                                Vector2D* temp = new Vector2D();
                                *temp = *value;
                                *temp -= *transformationVector;
                                *temp *= scaleFactor;
                                temp->x *= -1;

                                return temp;  
                        }

                        static Vector2D* reTransformInvertX( Vector2D* value, Vector2D* transformationVector, double scaleFactor )
                        {
                                Vector2D* temp = new Vector2D();
                                *temp = *value;

                                *temp /= scaleFactor;
                                *temp += *transformationVector;
                                temp->x *= -1;

                                return temp;  
                        }

                        static double getAngleFromUnifiedVector( Vector2D v )
                        {
                                if ( v.y == 0 )
                                {
                                        v.y = 0.0000001;
                                }
                                return ( atan( v.x / v.y ) * core::RADTODEG ) + ( v.y < 0 ? +180 : 0 );
                        }

                        static double getAngleFromVector( Vector2D v )
                        {
                                v.unify();
                                return getAngleFromUnifiedVector( v );
                        }

                        static double getFixedAngleFromVector( Vector2D v, double threshold )
                        {
                                double angle = getAngleFromVector( v );
                                int factor = 1.0f/threshold * 10;
                                int tempRes = angle * factor;
                                tempRes = tempRes % 10;
                                double result = double(tempRes) / double(factor);
                                return angle - result;
                        }
        };
}

#endif

---