InterpolationLogic.h

/*
 * Copyright (C) 2014 Google Inc.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

#ifndef INTERPOLATIONLOGIC_H
#define INTERPOLATIONLOGIC_H

#include <QSet>
#include <memory>
#include <queue>
#include "Logic.h"
#include "audio/SoundEffectInstance.h"

class TriggerEvent;

class InterpolationLogic : public Logic {
    Q_OBJECT

    Q_PROPERTY(QObject* target READ getTarget WRITE setTarget NOTIFY targetChanged)
    Q_PROPERTY(QString targetProperty READ getTargetProperty WRITE setTargetProperty
               NOTIFY targetPropertyChanged)
    Q_PROPERTY(QVariant beginValue READ getBeginValue WRITE setBeginValue NOTIFY beginValueChanged)
    Q_PROPERTY(QVariant endValue READ getEndValue WRITE setEndValue NOTIFY endValueChanged)
    Q_PROPERTY(float forwardDuration READ getForwardDuration WRITE setForwardDuration
            NOTIFY forwardDurationChanged)
    Q_PROPERTY(float backwardDuration READ getBackwardDuration WRITE setBackwardDuration
            NOTIFY backwardDurationChanged)
    Q_PROPERTY(float smoothing READ getSmoothing WRITE setSmoothing
            NOTIFY smoothingChanged)
    Q_PROPERTY(State state READ getState WRITE setState NOTIFY stateChanged)
    Q_PROPERTY(QString interpolatingSound READ getInterpolatingSound WRITE setInterpolatingSound
            NOTIFY interpolatingSoundChanged)
public:
    Q_ENUMS(State)
    enum State {
        Paused = 0,
        Forward,
        Backward,
    };

    explicit InterpolationLogic(QObject* parent = nullptr);

    QObject* getTarget() const { return mUnresolvedTarget; }
    void setTarget(QObject* value);
    const QString& getTargetProperty() const { return mUnresolvedTargetProperty; }
    void setTargetProperty(const QString& value);
    QVariant getBeginValue() const { return mBeginValue; }
    void setBeginValue(QVariant value);
    QVariant getEndValue() const { return mEndValue; }
    void setEndValue(QVariant value);
    float getForwardDuration() const { return mForwardDuration; }
    void setForwardDuration(float value);
    float getBackwardDuration() const { return mBackwardDuration; }
    void setBackwardDuration(float value);
    float getSmoothing() const { return mSmoothing; }
    void setSmoothing(float value);
    State getState() const { return mState; }
    void setState(State value);
    const QString& getInterpolatingSound() const { return mInterpolatingSound; }
    void setInterpolatingSound(const QString& value);

    virtual void init() override;
    virtual void update() override;

signals:
    void targetChanged();
    void targetPropertyChanged();
    void beginValueChanged();
    void endValueChanged();
    void forwardDurationChanged();
    void backwardDurationChanged();
    void smoothingChanged();
    void stateChanged();
    void interpolatingSoundChanged();

private:
    enum Behavior {
        Bidirectional = 0,
        ForwardOnly,
        BackwardOnly,
    };

    void resolveTargetAndProperty();
    QVariant getInterpolatedValue();
    QVariant getInterpolatedValue(int primitiveType);
    void updateInterpolatingSound();

    QObject* mUnresolvedTarget = nullptr;
    QString mUnresolvedTargetProperty;
    QObject* mTarget = nullptr;
    QString mTargetProperty;
    QString mTargetNonPrimitiveProperty;
    QVariant mBeginValue;
    QVariant mEndValue;
    float mForwardDuration = 1.0f;
    float mBackwardDuration = 1.0f;
    bool mHasSmoothing = false;
    float mSmoothing = 0.0f;
    State mState = Paused;
    Behavior mBehavior = Bidirectional;
    float mTime = 0.0f;
    QString mInterpolatingSound;
    SoundEffectInstance mInterpolatingSoundInstance;

    const static QSet<int> sValidPrimitiveTypes;
    const static QSet<int> sValidNonPrimitiveTypes;
};
Q_DECLARE_METATYPE(InterpolationLogic*)

#endif // INTERPOLATIONLOGIC_H