Cinematicable.h

Go to the documentation of this file.

#ifndef VULKAN_CINEMATICABLE
#define VULKAN_CINEMATICABLE
 
#include "Moveable.h"
#include "Foundations.h"
#include "Field.h"
 
 
namespace Vulkan::Physics::FieldFunctions {
    Force emptyField(const Position&, const Cinematicable&);
}
 
 
namespace Vulkan::Physics {
    
    class Cinematicable : public Moveable {
    public:
 
        Cinematicable(Position position = { 0.0f, 0.0f, 0.0f }, glm::vec3 rotationEuler = { 0.0f, 0.0f, 0.0f }, Mass mass = 1.0f, Speed initialSpeed = { 0.0f, 0.0f, 0.0f }, Acceleration initialAcceleration = { 0.0f, 0.0f, 0.0f }, Force internalForce = { 0.0f, 0.0f, 0.0f }, float angularSpeed = 0.0f, Field emittedField = Field{ {0.0f, 0.0f, 0.0f}, FieldFunctions::emptyField }) :
            Moveable{ position, rotationEuler }, mass{ mass }, speed{ initialSpeed }, acceleration{ initialAcceleration }, internalForce{ internalForce }, angularSpeed{ angularSpeed }, emittedField {
            emittedField
        } {}
 
 
        virtual void setMass(Mass mass) {
            this->mass = mass;
        }
 
        virtual Mass getMass() const {
            return mass;
        }
 
        virtual void setSpeed(Speed speed) {
            this->speed = speed;
        }
 
        virtual const Speed& getSpeed() const {
            return speed;
        }
 
        virtual void setAcceleration(Acceleration acceleration) {
            this->acceleration = acceleration;
        }
 
        virtual const Acceleration& getAcceleration() const {
            return acceleration;
        }
 
        virtual void setInternalForce(Force internalForce) {
            this->internalForce = internalForce;
        }
 
        virtual const Force& getInternalForce() const {
            return internalForce;
        }
 
        virtual Field getEmittedField() {
            return emittedField;
        }
 
        virtual void setPosition(Position position) override {
            DeltaSpace delta = position - getPosition();
            Moveable::setPosition(position);
            emittedField.setPosition(emittedField.getPosition() + delta); //the field "follows" the object it is attached to
        }
 
        virtual Cinematicable& translate(DeltaSpace delta) override {
            setPosition(getPosition() + delta);
            return *this;
        };
 
 
        virtual float getAngularSpeed() const {
            return angularSpeed;
        }
 
 
        virtual void setAngularSpeed(float angularSpeed) {
            this->angularSpeed = angularSpeed;
        }
 
 
        virtual void addExternalForce(Force externalForce) {
            impulsiveForce += externalForce;
        }
 
 
        virtual void reset(Position position) {
            setPosition(position);
            speed = { 0.0f, 0.0f, 0.0f };
            acceleration = { 0.0f, 0.0f, 0.0f };
            impulsiveForce = { 0.0f, 0.0f, 0.0f };
            angularSpeed = 0.0f;
        }
 
 
        virtual void move(Time elapsedTime) {
            //FIXTHIS /10.0f 
            if (float(mass) == std::numeric_limits<float>::max()/10.0f) {
                setAcceleration({ 0.0f, 0.0f, 0.0f });
            }
            else {
                setAcceleration((impulsiveForce + internalForce) / mass); // F = m*a (Newton III)
            }
            impulsiveForce = { 0.0f, 0.0f, 0.0f }; //reset impulsive forces
            setSpeed(speed + acceleration * elapsedTime); // ds = a/t --> s' = s + a/t
            translate(speed * elapsedTime); // dp = s/t --> p' = p + v/t (this consider a movement at a uniform speed, which is the final speed)
            rotate(angularSpeed * float(elapsedTime), glm::vec3(0.0f, 0.0f, 1.0f)); //only xy plane for now, and only arbitrary velocity (no angular acceleration based on momentum)
        }
 
    protected:
        Mass mass;
        Speed speed;
        Acceleration acceleration;
        Force internalForce;
        Force impulsiveForce; //externalForces which act on the body now. This is reset when move is called.
        Field emittedField;
        float angularSpeed; //only xy plane considered
    };
 
}
 
 
#endif