Level.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 LEVEL_H
#define LEVEL_H

#include <QMap>
#include <QQuickItem>
#include <QSet>
#include <limits>
#include <memory>
#include "Actor.h"

class ParticleLayer;
class ParticleRendererItem;
class b2World;

class Level : public QQuickItem {
    Q_OBJECT

    Q_PROPERTY(QRectF cameraBoundary READ getCameraBoundary WRITE setCameraBoundary
            NOTIFY cameraBoundaryChanged)
    Q_PROPERTY(bool fillCamera READ shouldFillCamera WRITE setFillCamera NOTIFY fillCameraChanged)
    Q_PROPERTY(QString name READ getName WRITE setName NOTIFY nameChanged)
    // TODO: Remove this property when then QML Loader bug is fixed.
    Q_PROPERTY(QString fileName READ getFileName WRITE setFileName NOTIFY fileNameChanged)
    Q_PROPERTY(QPointF gravity READ getGravity WRITE setGravity NOTIFY gravityChanged)
    Q_PROPERTY(int startingNumPickups READ getStartingNumPickups)
    Q_PROPERTY(QPointF parallaxOrigin READ getParallaxOrigin WRITE setParallaxOrigin
            NOTIFY parallaxOriginChanged)
    Q_PROPERTY(QPointF parallaxStrength READ getParallaxStrength WRITE setParallaxStrength
            NOTIFY parallaxStrengthChanged)
    Q_PROPERTY(int particleLayer READ getParticleLayer WRITE setParticleLayer
            NOTIFY particleLayerChanged)
    Q_PROPERTY(float particleAlpha READ getParticleAlpha WRITE setParticleAlpha
            NOTIFY particleAlphaChanged)
    Q_PROPERTY(QQmlListProperty<ParticleLayer> particleLayers READ getParticleLayerListProperty
            NOTIFY particleLayersChanged)
    Q_PROPERTY(int completionThreshold READ getCompletionThreshold WRITE setCompletionThreshold
            NOTIFY completionThresholdChanged)
    Q_PROPERTY(Actor* portal READ getPortal)

public:
    explicit Level();
    virtual ~Level();

    QRectF getCameraBoundary() const { return mCameraBoundary; }
    void setCameraBoundary(const QRectF& value);
    bool shouldFillCamera() const { return mFillCamera; }
    void setFillCamera(bool value);
    const QString& getName() const { return mName; }
    void setName(const QString& value);
    const QString& getFileName() const { return mFileName; }
    void setFileName(const QString& value);
    QPointF getGravity() const { return mGravity; }
    void setGravity(const QPointF& value);
    int getStartingNumPickups() const { return mStartingNumPickups; }
    QPointF getParallaxOrigin() const { return mParallaxOrigin; }
    void setParallaxOrigin(const QPointF& value);
    QPointF getParallaxStrength() const { return mParallaxStrength; }
    void setParallaxStrength(const QPointF& value);
    int getParticleLayer() const { return mParticleLayer; }
    void setParticleLayer(int value);
    float getParticleAlpha() { return mParticleAlpha; }
    void setParticleAlpha(float value);
    const QList<ParticleLayer*>& getParticleLayers() const { return mParticleLayers; }
    void setParticleLayers(const QList<ParticleLayer*>& value);
    QQmlListProperty<ParticleLayer> getParticleLayerListProperty();
    int getCompletionThreshold() const {
        return (mCompletionThreshold >= 0) ? mCompletionThreshold : mStartingNumPickups;
    }
    void setCompletionThreshold(int value);
    Actor* getPortal() const { return mPortal; }

    void addActor(Actor* actor);
    const QSet<Actor*>& getActors(Actor::ActorType type) const;
    b2World* getWorld() const { return mWorld.get(); }

signals:
    void cameraBoundaryChanged();
    void fillCameraChanged();
    void nameChanged();
    void fileNameChanged();
    void gravityChanged();
    void parallaxOriginChanged();
    void parallaxStrengthChanged();
    void particleLayerChanged();
    void particleAlphaChanged();
    void particleLayersChanged();
    void completionThresholdChanged();

protected:
    virtual void componentComplete() override;

private:
    void updateParticleRendererItemZ();

    QString mName;
    QString mFileName;
    std::unique_ptr<b2World> mWorld;
    QMap<Actor::ActorType, QSet<Actor*>> mActors;
    int mStartingNumPickups = 0;
    int mCompletionThreshold = -1;
    QPointF mGravity = QPointF(0.0f, 9.8f);
    QPointF mParallaxOrigin = QPointF(0.0f, 0.0f);
    QPointF mParallaxStrength = QPointF(1.0f, 0.0f);
    int mParticleLayer = 0;
    float mParticleAlpha = 1.0f;
    float mParticleRadius = 0.05f;
    float mParticleDensity = 1.2f;
    float mParticleGravityScale = 0.4f;
    QList<ParticleLayer*> mParticleLayers;
    ParticleRendererItem* mParticleRendererItem = nullptr;
    QRectF mCameraBoundary = QRectF(
            QPointF(-std::numeric_limits<float>::max(), -std::numeric_limits<float>::max()),
            QPointF(std::numeric_limits<float>::max(),  std::numeric_limits<float>::max()));
    bool mFillCamera = false;
    Actor* mPortal = nullptr;

    static const float PARTICLE_RENDERER_LAYER_ZBIAS;
};
Q_DECLARE_METATYPE(Level*)

#endif // LEVEL_H