util.hpp

Go to the documentation of this file.

#pragma once
 
extern "C" {
    #include <stdlib.h>
    #include "cmdfx/physics/util.h"
}
 
#include <vector>
 
namespace CmdFX {
    class Vector final {
        private:
            CmdFX_Vector* vector;
 
        public:
            Vector(CmdFX_Vector* vector) : vector(vector) {}
            Vector(double x, double y) {
                vector = Vector_create(x, y);
            }
 
            ~Vector() {
                if (vector) { free(vector); }
            }
 
            CmdFX_Vector* getVector() { return vector; }
 
            double getX() const { return vector->x; }
            double getY() const { return vector->y; }
            double getMagnitude() const { return Vector_getMagnitude(vector); }
 
            void setX(double x) { vector->x = x; }
            void setY(double y) { vector->y = y; }
 
            Vector operator+(const Vector& other) const {
                CmdFX_Vector* result = Vector_add(vector, other.vector);
                return Vector(result);
            }
 
            Vector operator+(const std::vector<Vector>& vectors) const {
                CmdFX_Vector** vArray = new CmdFX_Vector*[vectors.size() + 1];
                vArray[0] = vector;
 
                for (size_t i = 0; i < vectors.size(); ++i) {
                    vArray[i + 1] = vectors[i].vector;
                }
 
                CmdFX_Vector* result = Vector_addAll(vArray, vectors.size() + 1);
                delete[] vArray;
 
                return Vector(result);
            }
 
            Vector& operator+=(const Vector& other) {
                CmdFX_Vector* result = Vector_add(vector, other.vector);
                free(vector);
                vector = result;
                
                return *this;
            }
 
            Vector operator-(const Vector& other) const {
                CmdFX_Vector* result = Vector_subtract(vector, other.vector);
                return Vector(result);
            }
 
            Vector& operator-=(const Vector& other) {
                CmdFX_Vector* result = Vector_subtract(vector, other.vector);
                free(vector);
                vector = result;
                
                return *this;
            }
 
            Vector operator*(double scalar) const {
                Vector result(vector->x, vector->y);
                Vector_multiply(result.vector, scalar);
                return result;
            }
 
            Vector& operator*=(double scalar) {
                Vector_multiply(vector, scalar);
                return *this;
            }
 
            Vector operator/(double scalar) const {
                Vector result(vector->x, vector->y);
                Vector_divide(result.vector, scalar);
                return result;
            }
 
            Vector& operator/=(double scalar) {
                Vector_divide(vector, scalar);
                return *this;
            }
 
            int rotate(double radians) {
                return Vector_rotate(vector, radians);
            }
 
            double getAngle() {
                return Vector_getAngle(vector);
            }
 
            int flipX() {
                return Vector_flipX(vector);
            }
 
            int flipY() {
                return Vector_flipY(vector);
            }
 
            int flip() {
                return Vector_flip(vector);
            }
 
            int dot(const Vector& other) const {
                return Vector_dot(vector, other.vector);
            }
    };
}