model.h

Go to the documentation of this file.

/* xoreos - A reimplementation of BioWare's Aurora engine
 *
 * xoreos is the legal property of its developers, whose names
 * can be found in the AUTHORS file distributed with this source
 * distribution.
 *
 * xoreos 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.
 *
 * xoreos 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 xoreos. If not, see <http://www.gnu.org/licenses/>.
 */

#ifndef GRAPHICS_AURORA_MODEL_H
#define GRAPHICS_AURORA_MODEL_H

#include <vector>
#include <list>
#include <map>

#include "glm/mat4x4.hpp"

#include "src/common/ustring.h"
#include "src/common/boundingbox.h"

#include "src/graphics/types.h"
#include "src/graphics/glcontainer.h"
#include "src/graphics/renderable.h"

#include "src/graphics/aurora/modelnode.h"
#include "src/graphics/aurora/types.h"

#include "src/graphics/shader/shaderrenderable.h"

namespace Common {
    class SeekableReadStream;
}

namespace Graphics {

namespace Aurora {

class Animation;
class AnimationThread;
class AnimationChannel;

enum AnimationChannelName {
    kAnimationChannelAll  = 0,
    kAnimationChannelHead = 1
};

class Model : public GLContainer, public Renderable {
public:
    Model(ModelType type = kModelTypeObject);
    ~Model();

    void show();
    void hide();

    ModelType getType() const; 

    const Common::UString &getName() const;

    float getWidth () const; 
    float getHeight() const; 
    float getDepth () const; 

    void drawBound(bool enabled);
    void drawSkeleton(bool enabled, bool showInvisible);

    void setEnvironmentMap(const Common::UString &environmentMap = "");

    void setSkinned(bool skinned);

    bool isIn(float x, float y) const;
    bool isIn(float x, float y, float z) const;
    bool isIn(float x1, float y1, float z1, float x2, float y2, float z2) const;


    // Positioning

    void getScale   (float &x, float &y, float &z) const;
    void getOrientation(float &x, float &y, float &z, float &angle) const;
    void getPosition(float &x, float &y, float &z) const;

    void getAbsolutePosition(float &x, float &y, float &z) const;

    void setScale   (float x, float y, float z);
    void setOrientation(float x, float y, float z, float angle);
    void setPosition(float x, float y, float z);

    void scale (float x, float y, float z);
    void rotate(float x, float y, float z, float angle);
    void move  (float x, float y, float z);

    void getTooltipAnchor(float &x, float &y, float &z) const;

    // States

    const std::list<Common::UString> &getStates() const;
    void setState(const Common::UString &name = "");
    const Common::UString &getState() const;


    // Nodes

    bool hasNode(const Common::UString &node) const;

    ModelNode *getNode(const Common::UString &node);
    const ModelNode *getNode(const Common::UString &node) const;
    ModelNode *getNode(const Common::UString &stateName, const Common::UString &node);
    const ModelNode *getNode(const Common::UString &stateName, const Common::UString &node) const;
    ModelNode *getNode(uint16 nodeNumber);
    const ModelNode *getNode(uint16 nodeNumber) const;

    const std::list<ModelNode *> &getNodes();

    void attachModel(const Common::UString &nodeName, Model *model);

    // Animation

    bool hasAnimation(const Common::UString &anim) const;

    float getAnimationScale(const Common::UString &anim);

    void addAnimationChannel(AnimationChannelName name);
    AnimationChannel *getAnimationChannel(AnimationChannelName name);

    void clearDefaultAnimations();
    void addDefaultAnimation(const Common::UString &anim, uint8 probability);
    void playDefaultAnimation();

    void playAnimation(const Common::UString &anim,
                       bool restart = true,
                       float length = 0.0f,
                       float speed = 1.0f);


    // Renderable
    void calculateDistance();
    void render(RenderPass pass);
    void renderImmediate(const glm::mat4 &parentTransform);
    void queueRender(const glm::mat4 &parentTransform);
    void advanceTime(float dt);

    void flushNodeBuffers();

    Model *getAttachedModel(const Common::UString &node);


protected:
    typedef std::list<ModelNode *> NodeList;
    typedef std::map<Common::UString, ModelNode *, Common::UString::iless> NodeMap;
    typedef std::map<Common::UString, Animation *, Common::UString::iless> AnimationMap;
    typedef std::map<AnimationChannelName, AnimationChannel *> AnimationChannelMap;

    struct State {
        Common::UString name; 

        NodeList nodeList; 
        NodeMap  nodeMap;  

        NodeList rootNodes; 
    };

    typedef std::list<State *> StateList;
    typedef std::map<Common::UString, State *> StateMap;


    ModelType _type; 

    Common::UString _fileName; 

    Common::UString _name; 

    Common::UString _superModelName; 
    Model *_superModel; 

    StateList _stateList;   
    StateMap  _stateMap;    
    State   *_currentState; 

    std::list<Common::UString> _stateNames; 

    AnimationMap _animationMap; 

    AnimationChannelMap _animationChannels;

    float _animationScale; 

    float _scale      [3]; 
    float _orientation[4]; 
    float _position   [3]; 

    float _center[3]; 

    glm::mat4 _absolutePosition;

    Common::BoundingBox _boundBox;
    Common::BoundingBox _absoluteBoundBox;

    bool _skinned;
    bool _positionRelative;


    // Rendering
    void queueDrawBound();
    void doDrawBound();
    void doDrawSkeleton();

    // Animation

    Animation *getAnimation(const Common::UString &anim);


    void finalize();


    // GLContainer
    void doRebuild();
    void doDestroy();

    // Shader renderable, containing information on rendering something.
    Shader::ShaderRenderable _boundRenderable;
    glm::mat4 _boundTransform;

private:
    bool _drawBound;
    bool _drawSkeleton;
    bool _drawSkeletonInvisible;

    std::map<Common::UString, Model *> _attachedModels;

    void createStateNamesList(std::list<Common::UString> *stateNames = 0);
    void createBound();

    void createAbsolutePosition();

    void manageAnimations(float dt);

public:
    // General loading helpers

    static void readValue(Common::SeekableReadStream &stream, uint32 &value);
    static void readValue(Common::SeekableReadStream &stream, float  &value);

    static void readArrayDef(Common::SeekableReadStream &stream,
                             uint32 &offset, uint32 &count);

    template<typename T>
    static void readArray(Common::SeekableReadStream &stream,
                          uint32 offset, uint32 count, std::vector<T> &values);

    friend class ModelNode;
    friend class Animation;
    friend class AnimationThread;
    friend class AnimationChannel;
};

} // End of namespace Aurora

} // End of namespace Graphics

#endif // GRAPHICS_AURORA_MODEL_H