CUAccelerometer.h

//
//  CUAcclerometer.h
//  Cornell University Game Library (CUGL)
//
//  This class provides basic acclerometer support. It uses the joystick
//  subsystem, which is guaranteed to work on both iOS and Android.
//
//  This class is a singleton and should never be allocated directly.  It
//  should only be accessed via the Input dispatcher.
//
//  CUGL zlib License:
//      This software is provided 'as-is', without any express or implied
//      warranty.  In no event will the authors be held liable for any damages
//      arising from the use of this software.
//
//      Permission is granted to anyone to use this software for any purpose,
//      including commercial applications, and to alter it and redistribute it
//      freely, subject to the following restrictions:
//
//      1. The origin of this software must not be misrepresented; you must not
//      claim that you wrote the original software. If you use this software
//      in a product, an acknowledgment in the product documentation would be
//      appreciated but is not required.
//
//      2. Altered source versions must be plainly marked as such, and must not
//      be misrepresented as being the original software.
//
//      3. This notice may not be removed or altered from any source distribution.
//
//  Author: Walker White
//  Version: 7/12/16
//
#ifndef __CU_ACCELEROMETER_H__
#define __CU_ACCELEROMETER_H__

#include "CUInput.h"
#include "../math/CUVec3.h"

namespace cugl {

class AccelerationEvent {
public:
    Timestamp timestamp;
    Vec3 axis;
    Vec3 delta;
    
    AccelerationEvent() { }
    
    AccelerationEvent(const Vec3& roll, const Vec3& diff, const Timestamp& stamp) {
        axis = roll; delta = diff; timestamp = stamp;
    }
    
};
    
#pragma mark -
#pragma mark AccelerationListener

typedef std::function<void(const AccelerationEvent& event, bool focus)> AccelerationListener;

#pragma mark -

class Accelerometer : public InputDevice {
private:
    SDL_Joystick* _input;
    float _threshold;
    
    bool _update;
    Vec3 _current;
    Vec3 _previous;
    Vec3 _anchor;
    
    int _xaxis;
    int _yaxis;
    
    std::unordered_map<Uint32, AccelerationListener> _listeners;

#pragma mark Constructor

    Accelerometer();
    
    virtual ~Accelerometer() { dispose(); }
    
    virtual bool init() override;
    
    virtual void dispose() override;

public:
#pragma mark Data Polling

    float getTreshold() const { return _threshold; }
    
    void setThreshold(float value) const;
    
    float getAccelerationX() const { return _current.x; }

    float getAccelerationY() const { return _current.y; }

    float getAccelerationZ() const { return _current.z; }
    
    const Vec3& getAcceleration() const { return _current; }

    float getDeltaX() const { return _current.x-_previous.x; }
    
    float getDeltaY() const { return _current.y-_previous.y; }
    
    float getDeltaZ() const { return _current.z-_previous.z; }
    
    const Vec3 getDelta() const { return _current-_previous; }

#pragma mark Listeners

    virtual bool requestFocus(Uint32 key) override;
    
    bool isListener(Uint32 key) const;
    
    const AccelerationListener getListener(Uint32 key) const;
    
    bool addListener(Uint32 key, AccelerationListener listener);
    
    bool removeListener(Uint32 key);
    
    
#pragma mark Input Device

    virtual void clearState() override;
    
    virtual bool updateState(const SDL_Event& event, const Timestamp& stamp) override;
    
    virtual void queryEvents(std::vector<Uint32>& eventset) override;
    
    // Apparently friends are not inherited
    friend class Input;

    
};

}

#endif /* __CU_ACCELEROMETER_H__ */