PlayerHands.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 Penumbra Overture.
 */

#ifndef GAME_PLAYER_HANDS_H
#define GAME_PLAYER_HANDS_H

#include "hpl1/engine/engine.h"
#include "hpl1/penumbra-overture/GameTypes.h"

using namespace hpl;

class cInit;

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

class cHudModelPose {
public:
    cHudModelPose() {}
    cHudModelPose(const cVector3f &avPos, const cVector3f &avRot) {
        mvPos = avPos;
        mvRot = avRot;
    }

    cMatrixf ToMatrix() {
        cMatrixf mtxPose = cMath::MatrixRotate(mvRot, eEulerRotationOrder_XYZ);
        mtxPose.SetTranslation(mvPos);
        return mtxPose;
    }

    cVector3f mvPos;
    cVector3f mvRot;
};

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

enum eHudModelState {
    eHudModelState_Idle,
    eHudModelState_Equip,
    eHudModelState_Unequip
};

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

cHudModelPose GetPoseFromElem(const tString &asName, TiXmlElement *apElem);

cMatrixf InterpolatePosesToMatrix(float afT, const cHudModelPose &aPoseA, const cHudModelPose &aPoseB);

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

class iHudModel {
    friend class cPlayerHands;

public:
    iHudModel(ePlayerHandType aType);
    virtual ~iHudModel() = default;

    cMeshEntity *GetEntity() { return mpEntity; }

    void LoadEntities();
    void DestroyEntities();

    void EquipEffect(bool abJustCreated);
    void UnequipEffect();

    void Reset();

    tString msName;
    tString msModelFile;

    cHudModelPose mEquipPose;
    cHudModelPose mUnequipPose;

    tString msEquipSound;
    tString msUnequipSound;

    float mfEquipTime;
    float mfUnequipTime;

    eHudModelState GetState() { return mState; }

    Common::Array<cParticleSystem3D *> mvParticleSystems;
    Common::Array<cBillboard *> mvBillboards;
    Common::Array<iLight3D *> mvLights;
    Common::Array<cColor> mvLightColors;
    Common::Array<float> mvLightRadii;
    Common::Array<cSoundEntity *> mvSoundEntities;

    virtual void LoadData(TiXmlElement *apRootElem) = 0;

protected:
    virtual void ResetExtraData() = 0;

    virtual bool UpdatePoseMatrix(cMatrixf &aPoseMtx, float afTimeStep) { return false; }

    virtual void LoadExtraEntites() {}
    virtual void DestroyExtraEntities() {}

    virtual void PostSceneDraw() {}

    ePlayerHandType mType;

    cInit *mpInit;

    cMesh *mpMesh;
    cMeshEntity *mpEntity;

    eHudModelState mState;

    float mfTime;

    tString msNextModel;
};

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

class cHudModel_Normal : iHudModel {
    friend class cPlayerHands;

public:
    cHudModel_Normal() : iHudModel(ePlayerHandType_Normal) {}
    virtual ~cHudModel_Normal() = default;

    void LoadData(TiXmlElement *apRootElem) {}

    void ResetExtraData() {}
};

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

typedef Common::StableMap<tString, iHudModel *> tHudModelMap;
typedef tHudModelMap::iterator tHudModelMapIt;

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

class cPlayerHands : public iUpdateable {
public:
    cPlayerHands(cInit *apInit);
    ~cPlayerHands();

    void OnStart();
    void Update(float afTimeStep);
    void Reset();
    void OnDraw();

    void OnWorldExit();
    void OnWorldLoad();

    void AddHudModel(iHudModel *apHudModel);
    bool AddModelFromFile(const tString &asFile);

    iHudModel *GetModel(const tString &asName);

    void SetCurrentModel(int alNum, const tString &asName);
    iHudModel *GetCurrentModel(int alNum) { return mvCurrentHudModels[alNum]; }

private:
    void UpdatePrevPositions();

    cInit *mpInit;
    cMeshManager *mpMeshManager;

    tVector3fList mlstPositions;
    tVector3fList mlstRotations;
    int mlMaxPositions;
    int mlMaxRotations;

    cVector3f mvSmoothCameraPos;
    cVector3f mvSmoothCameraRot;

    tHudModelMap m_mapHudModels;
    iHudModel *mvCurrentHudModels[2];
    int mlCurrentModelNum;
};

#endif // GAME_PLAYER_HANDS_H