plane.cpp

/** @file plane.h World map plane.
 *
 * @authors Copyright © 2003-2013 Jaakko Keränen <jaakko.keranen@iki.fi>
 * @authors Copyright © 2006-2013 Daniel Swanson <danij@dengine.net>
 *
 * @par License
 * GPL: http://www.gnu.org/licenses/gpl.html
 *
 * <small>This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by the
 * Free Software Foundation; either version 2 of the License, or (at your
 * option) any later version. This program is distributed in the hope that it
 * will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty
 * of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General
 * Public License for more details. You should have received a copy of the GNU
 * General Public License along with this program; if not, write to the Free
 * Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
 * 02110-1301 USA</small>
 */

#include <QList>

#include <de/Log>

#include "de_base.h"

#include "audio/s_environ.h"

#include "Line"
#include "world/map.h" /// @todo remove me.
#include "world/r_world.h" // ddMapSetup
#include "world/world.h"

#include "render/r_main.h" // frameTimePos

#include "world/plane.h"

using namespace de;

DENG2_PIMPL(Plane)
{
    /// Sector that owns the plane.
    Sector *sector;

    /// Sound emitter.
    ddmobj_base_t soundEmitter;

    /// Index of the plane in the owning sector.
    int inSectorIndex;

    /// Current @em sharp height relative to @c 0 on the map up axis (positive is up).
    coord_t height;

    /// @em sharp height change tracking buffer (for smoothing).
    coord_t oldHeight[2];

    /// Target @em sharp height.
    coord_t targetHeight;

    /// Visual plane height (smoothed).
    coord_t visHeight;

    /// Delta between the current @em sharp height and the visual height.
    coord_t visHeightDelta;

    /// Movement speed (map space units per tic).
    coord_t speed;

    /// Plane surface.
    Surface surface;

    Instance(Public *i, Sector &sector, coord_t height)
        : Base(i),
          sector(&sector),
          inSectorIndex(-1),
          height(height),
          targetHeight(height),
          visHeight(height),
          visHeightDelta(0),
          speed(0),
          surface(dynamic_cast<MapElement &>(*i))
    {
        oldHeight[0] = oldHeight[1] = height;
        zap(soundEmitter);
    }

    ~Instance()
    {
#ifdef __CLIENT__
        Map &map = App_World().map();

        // If this plane is currently being watched, remove it.
        /// @todo Map should observe Deletion.
        map.trackedPlanes().remove(&self);

        // If this plane's surface is in the moving list, remove it.
        /// @todo Map should observe Deletion.
        map.scrollingSurfaces().remove(&surface);

        // If this plane's surface is in the glowing list, remove it.
        /// @todo Map should observe Deletion.
        map.glowingSurfaces().remove(&surface);

        // If this plane's surface is in the decorated list, remove it.
        /// @todo Map should observe Deletion.
        map.decoratedSurfaces().remove(&surface);

#endif // __CLIENT__

        DENG2_FOR_PUBLIC_AUDIENCE(Deletion, i) i->planeBeingDeleted(self);
    }

    void notifyHeightChanged(coord_t oldHeight)
    {
        DENG2_FOR_PUBLIC_AUDIENCE(HeightChange, i)
        {
            i->planeHeightChanged(self, oldHeight);
        }
    }

    void applySharpHeightChange(coord_t newHeight)
    {
        // No change?
        if(de::fequal(newHeight, height))
            return;

        coord_t oldHeight = height;
        height = newHeight;

        if(!ddMapSetup)
        {
            // Update the sound emitter origin for the plane.
            self.updateSoundEmitterOrigin();

#ifdef __CLIENT__
            // We need the decorations updated.
            surface.markAsNeedingDecorationUpdate();
#endif
        }

        // Notify interested parties of the change.
        notifyHeightChanged(oldHeight);

#ifdef __CLIENT__
        /// @todo Map should observe.
        if(!ddMapSetup)
        {
            if(App_World().hasMap())
            {
                App_World().map().trackedPlanes().insert(&self);
            }

            markDependantSurfacesForDecorationUpdate();
        }
#endif
    }

#ifdef __CLIENT__
    /**
     * To be called when the height changes to update the plotted decoration
     * origins for surfaces whose material offset is dependant upon this.
     *
     * @todo Sector should observe instead.
     */
    void markDependantSurfacesForDecorationUpdate()
    {
        if(ddMapSetup) return;

        // "Middle" planes have no dependent surfaces.
        if(inSectorIndex > Sector::Ceiling) return;

        // Mark the decor lights on the sides of this plane as requiring
        // an update.
        foreach(Line::Side *side, sector->sides())
        {
            if(side->hasSections())
            {
                side->middle().markAsNeedingDecorationUpdate();
                side->bottom().markAsNeedingDecorationUpdate();
                side->top().markAsNeedingDecorationUpdate();
            }

            if(side->back().hasSections())
            {
                Line::Side &back = side->back();
                back.middle().markAsNeedingDecorationUpdate();
                back.bottom().markAsNeedingDecorationUpdate();
                back.top().markAsNeedingDecorationUpdate();
            }
        }
    }
#endif // __CLIENT__
};

Plane::Plane(Sector &sector, Vector3f const &normal, coord_t height)
    : MapElement(DMU_PLANE), d(new Instance(this, sector, height))
{
    setNormal(normal);
}

Sector &Plane::sector()
{
    return *d->sector;
}

Sector const &Plane::sector() const
{
    return *d->sector;
}

int Plane::inSectorIndex() const
{
    return d->inSectorIndex;
}

void Plane::setInSectorIndex(int newIndex)
{
    d->inSectorIndex = newIndex;
}

bool Plane::isSectorFloor() const
{
    return this == &sector().floor();
}

bool Plane::isSectorCeiling() const
{
    return this == &sector().ceiling();
}

Surface &Plane::surface()
{
    return d->surface;
}

Surface const &Plane::surface() const
{
    return d->surface;
}

ddmobj_base_t &Plane::soundEmitter()
{
    return d->soundEmitter;
}

ddmobj_base_t const &Plane::soundEmitter() const
{
    return const_cast<ddmobj_base_t const &>(const_cast<Plane &>(*this).soundEmitter());
}

void Plane::updateSoundEmitterOrigin()
{
    LOG_AS("Plane::updateSoundEmitterOrigin");

    d->soundEmitter.origin[VX] = d->sector->soundEmitter().origin[VX];
    d->soundEmitter.origin[VY] = d->sector->soundEmitter().origin[VY];
    d->soundEmitter.origin[VZ] = d->height;
}

coord_t Plane::height() const
{
    return d->height;
}

coord_t Plane::targetHeight() const
{
    return d->targetHeight;
}

coord_t Plane::speed() const
{
    return d->speed;
}

#ifdef __CLIENT__

coord_t Plane::visHeight() const
{
    // $smoothplane
    return d->visHeight;
}

coord_t Plane::visHeightDelta() const
{
    // $smoothplane
    return d->visHeightDelta;
}

void Plane::lerpVisHeight()
{
    // $smoothplane
    d->visHeightDelta = d->oldHeight[0] * (1 - frameTimePos) + d->height * frameTimePos - d->height;

    // Visible plane height.
    d->visHeight = d->height + d->visHeightDelta;

    d->markDependantSurfacesForDecorationUpdate();
}

void Plane::resetVisHeight()
{
    // $smoothplane
    d->visHeightDelta = 0;
    d->visHeight = d->oldHeight[0] = d->oldHeight[1] = d->height;

    d->markDependantSurfacesForDecorationUpdate();
}

void Plane::updateHeightTracking()
{
    // $smoothplane
    d->oldHeight[0] = d->oldHeight[1];
    d->oldHeight[1] = d->height;

    if(d->oldHeight[0] != d->oldHeight[1])
    {
        if(de::abs(d->oldHeight[0] - d->oldHeight[1]) >= MAX_SMOOTH_MOVE)
        {
            // Too fast: make an instantaneous jump.
            d->oldHeight[0] = d->oldHeight[1];
        }
    }
}

#endif // __CLIENT__

void Plane::setNormal(Vector3f const &newNormal)
{
    d->surface.setNormal(newNormal); // will normalize
}

int Plane::property(DmuArgs &args) const
{
    switch(args.prop)
    {
    case DMU_EMITTER:
        args.setValue(DMT_PLANE_EMITTER, &d->soundEmitter, 0);
        break;
    case DMU_SECTOR:
        args.setValue(DMT_PLANE_SECTOR, &d->sector, 0);
        break;
    case DMU_HEIGHT:
        args.setValue(DMT_PLANE_HEIGHT, &d->height, 0);
        break;
    case DMU_TARGET_HEIGHT:
        args.setValue(DMT_PLANE_TARGET, &d->targetHeight, 0);
        break;
    case DMU_SPEED:
        args.setValue(DMT_PLANE_SPEED, &d->speed, 0);
        break;
    default:
        return MapElement::property(args);
    }

    return false; // Continue iteration.
}

int Plane::setProperty(DmuArgs const &args)
{
    switch(args.prop)
    {
    case DMU_HEIGHT: {
        coord_t newHeight = d->height;
        args.value(DMT_PLANE_HEIGHT, &newHeight, 0);
        d->applySharpHeightChange(newHeight);
        break; }
    case DMU_TARGET_HEIGHT:
        args.value(DMT_PLANE_TARGET, &d->targetHeight, 0);
        break;
    case DMU_SPEED:
        args.value(DMT_PLANE_SPEED, &d->speed, 0);
        break;
    default:
        return MapElement::setProperty(args);
    }

    return false; // Continue iteration.
}