SurfaceData.h

/* ScummVM - Graphic Adventure Engine
 *
 * ScummVM is the legal property of its developers, whose names
 * are too numerous to list here. Please refer to the COPYRIGHT
 * file distributed with this source distribution.
 *
 * 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 3 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, see <http://www.gnu.org/licenses/>.
 *
 */

/*
 * Copyright (C) 2006-2010 - Frictional Games
 *
 * This file is part of HPL1 Engine.
 */

#ifndef HPL_SURFACE_DATA_H
#define HPL_SURFACE_DATA_H

#include "hpl1/engine/math/MathTypes.h"
#include "hpl1/engine/physics/PhysicsMaterial.h"

namespace hpl {

#define eRollAxisFlag_X 1
#define eRollAxisFlag_Y 2
#define eRollAxisFlag_Z 4

class cPhysics;
class iPhysicsWorld;
class iPhysicsBody;
class cResources;

//----------------------------------------

class cSurfaceImpactData {
    friend class cSurfaceData;

public:
    float GetMinSpeed() { return mfMinSpeed; }

    const tString &GetSoundName() { return msSoundName; }
    void SetSoundName(const tString &asName) { msSoundName = asName; }

    const tString &GetPSName() { return msPSName; }
    void SetPSName(const tString &asName) { msPSName = asName; }

    int GetPSPrio() { return mlPSPrio; }
    void SetPSPrio(int alPrio) { mlPSPrio = alPrio; }

private:
    float mfMinSpeed;
    tString msSoundName;
    tString msPSName;
    int mlPSPrio;
};

typedef Common::Array<cSurfaceImpactData *> tSurfaceImpactDataVec;
typedef tSurfaceImpactDataVec::iterator tSurfaceImpactDataVecIt;

//----------------------------------------

class cSurfaceData {
public:
    cSurfaceData(const tString &asName, cPhysics *apPhysics, cResources *apResources);
    ~cSurfaceData();

    const tString &GetName() const { return msName; }

    void OnImpact(float afSpeed, const cVector3f &avPos, int alContacts, iPhysicsBody *apBody);
    void OnSlide(float afSpeed, const cVector3f &avPos, int alContacts, iPhysicsBody *apBody,
                 iPhysicsBody *apSlideAgainstBody);
    void CreateImpactEffect(float afSpeed, const cVector3f &avPos, int alContacts,
                            cSurfaceData *apSecondSurface);

    void UpdateRollEffect(iPhysicsBody *apBody);

    void SetElasticity(float afElasticity);
    float GetElasticity() const;
    void SetStaticFriction(float afElasticity);
    float GetStaticFriction() const;
    void SetKineticFriction(float afElasticity);
    float GetKineticFriction() const;

    void SetPriority(int alPriority);
    int GetPriority() const;

    void SetFrictionCombMode(ePhysicsMaterialCombMode aMode);
    ePhysicsMaterialCombMode GetFrictionCombMode() const;
    void SetElasticityCombMode(ePhysicsMaterialCombMode aMode);
    ePhysicsMaterialCombMode GetElasticityCombMode() const;

    const tString &GetStepType() { return msStepType; }
    void GetStepType(const tString &asX) { msStepType = asX; }

    void SetMinScrapeSpeed(float afX) { mfMinScrapeSpeed = afX; }
    void SetMinScrapeFreq(float afX) { mfMinScrapeFreq = afX; }
    void SetMinScrapeFreqSpeed(float afX) { mfMinScrapeFreqSpeed = afX; }
    void SetMaxScrapeFreq(float afX) { mfMaxScrapeFreq = afX; }
    void SetMaxScrapeFreqSpeed(float afX) { mfMaxScrapeFreqSpeed = afX; }
    void SetMiddleScrapeSpeed(float afX) { mfMiddleScrapeSpeed = afX; }
    void SetMinScrapeContacts(int alX) { mlMinScrapeContacts = alX; }
    void SetScrapeSoundName(const tString &asName) { msScrapeSoundName = asName; }

    void SetMinRollSpeed(float afX) { mfMinRollSpeed = afX; }
    void SetMinRollFreq(float afX) { mfMinRollFreq = afX; }
    void SetMinRollVolume(float afX) { mfMinRollVolume = afX; }
    void SetMinRollFreqSpeed(float afX) { mfMinRollFreqSpeed = afX; }
    void SetMaxRollFreq(float afX) { mfMaxRollFreq = afX; }
    void SetMaxRollVolume(float afX) { mfMaxRollVolume = afX; }
    void SetMaxRollFreqSpeed(float afX) { mfMaxRollFreqSpeed = afX; }
    void SetMiddleRollSpeed(float afX) { mfMiddleRollSpeed = afX; }
    void SetRollSoundName(const tString &asName) { msRollSoundName = asName; }
    void SetRollAxisFlags(tFlag aAxisFlags) { mRollAxisFlags = aAxisFlags; }

    void PreloadData();

    iPhysicsMaterial *ToMaterial(iPhysicsWorld *apWorld);

    cSurfaceImpactData *CreateImpactData(float afMinSpeed);
    cSurfaceImpactData *GetImpactData(int alIdx);
    int GetImpactDataNum();
    cSurfaceImpactData *GetImpactDataFromSpeed(float afSpeed);

    cSurfaceImpactData *CreateHitData(float afMinSpeed);
    cSurfaceImpactData *GetHitData(int alIdx);
    int GetHitDataNum();
    cSurfaceImpactData *GetHitDataFromSpeed(float afSpeed);

protected:
    cResources *mpResources;
    cPhysics *mpPhysics;
    tString msName;

    // Properties
    ePhysicsMaterialCombMode mFrictionMode;
    ePhysicsMaterialCombMode mElasticityMode;

    float mfElasticity;
    float mfStaticFriction;
    float mfKineticFriction;

    int mlPriority;

    float mfMinScrapeSpeed;
    float mfMinScrapeFreq;
    float mfMinScrapeFreqSpeed;
    float mfMaxScrapeFreq;
    float mfMaxScrapeFreqSpeed;
    float mfMiddleScrapeSpeed;
    int mlMinScrapeContacts;
    tString msScrapeSoundName;

    float mfMinRollSpeed;
    float mfMinRollFreq;
    float mfMinRollVolume;
    float mfMinRollFreqSpeed;
    float mfMaxRollFreq;
    float mfMaxRollVolume;
    float mfMaxRollFreqSpeed;
    float mfMiddleRollSpeed;
    int mlMinRollContacts;
    tString msRollSoundName;
    tFlag mRollAxisFlags;

    tString msStepType;

    tSurfaceImpactDataVec mvImpactData;

    tSurfaceImpactDataVec mvHitData;
};

} // namespace hpl

#endif // HPL_SURFACE_DATA_H