modelnode.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_MODELNODE_H
#define GRAPHICS_AURORA_MODELNODE_H

#include <list>
#include <vector>

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

#include "src/graphics/types.h"
#include "src/graphics/indexbuffer.h"
#include "src/graphics/vertexbuffer.h"

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

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

namespace Graphics {

namespace Aurora {

class Model;

struct PositionKeyFrame {
    float time;
    float x;
    float y;
    float z;
};

struct QuaternionKeyFrame {
    float time;
    float x;
    float y;
    float z;
    float q;
};

class ModelNode {
public:
    ModelNode(Model &model);
    virtual ~ModelNode();

    const Common::UString &getName() const;

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

    void setInvisible(bool invisible);

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

    // Positioning

    void getPosition(float &x, float &y, float &z) const;
    void getRotation(float &x, float &y, float &z) const;
    void getOrientation(float &x, float &y, float &z, float &a) const;

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

    glm::mat4 getAbsolutePosition() const;

    uint16 getNodeNumber() const;

    void setPosition(float x, float y, float z);
    void setRotation(float x, float y, float z);
    void setOrientation(float x, float y, float z, float a);

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

    void setTextures(const std::vector<Common::UString> &textures);

    void computeInverseBindPose();
    void computeAbsoluteTransform();

    float getAlpha();

    void setAlpha(float alpha, bool isRecursive = true);

    float getScaleX() { return _scale[0]; }
    float getScaleY() { return _scale[1]; }
    float getScaleZ() { return _scale[2]; }

    enum EnvironmentMapMode {
        kModeEnvironmentBlendedUnder, 
        kModeEnvironmentBlendedOver   
    };

    struct DanglyData {
        std::vector<float> constraints;
    };

    struct Dangly {
        float period;
        float tightness;
        float displacement;

        DanglyData *data;

        Dangly();
    };

    struct Skin {
        std::vector<float>       boneMapping;
        uint32                   boneMappingCount;
        std::vector<float>       boneWeights;
        std::vector<float>       boneMappingId;
        std::vector<ModelNode *> boneNodeMap;

        Skin();
    };

    struct MeshData {
        Graphics::Mesh::Mesh *rawMesh; 

        std::vector<float> initialVertexCoords; 

        std::vector<TextureHandle> textures; 

        TextureHandle      envMap;     
        EnvironmentMapMode envMapMode; 

        MeshData();
    };

    struct Mesh {
        float wirecolor[3]; 
        float ambient  [3]; 
        float diffuse  [3]; 
        float specular [3]; 
        float selfIllum[3]; 
        float shininess;    

        float alpha;

        int tilefade;

        bool render; 
        bool shadow; 

        bool beaming;
        bool inheritcolor;
        bool rotatetexture;

        bool isTransparent;

        bool hasTransparencyHint;
        bool transparencyHint;
        uint32 transparencyHintFull;

        bool isBackgroundGeometry;

        MeshData *data;
        Dangly   *dangly;
        Skin     *skin;
        // TODO Anim, AABB Meshes

        Mesh();
    };

protected:
    Model *_model; 

    ModelNode *_parent;               
    std::list<ModelNode *> _children; 

    Model *_attachedModel; 

    uint32 _level;

    Common::UString _name; 

    std::vector<Shader::ShaderRenderable> _renderableArray;  

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

    float _alpha;          

    std::vector<PositionKeyFrame> _positionFrames;      
    std::vector<QuaternionKeyFrame> _orientationFrames; 

    glm::mat4 _absolutePosition;
    glm::mat4 _renderTransform;

    bool _render; 
    bool _dirtyRender; 
    bool _dirtyMesh;  

    Mesh *_mesh;
    ModelNode *_rootStateNode;

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

    uint16 _nodeNumber;

    glm::mat4 _invBindPose;       
    glm::mat4 _absoluteTransform; 

    // .--- Node position and geometry buffers
    float _positionBuffer[3];
    bool _positionBuffered;
    float _orientationBuffer[4];
    bool _orientationBuffered;
    std::vector<float> _vertexCoordsBuffer;
    bool _vertexCoordsBuffered;
    // '---

    Shader::ShaderMaterial *_material;
    Shader::ShaderRenderable *_shaderRenderable;

    // Loading helpers
    void loadTextures(const std::vector<Common::UString> &textures);
    void createBound();
    void createCenter();

    void createAbsoluteBound();
    void createAbsoluteBound(Common::BoundingBox parentPosition);

    void render(RenderPass pass);
    void drawSkeleton(const glm::mat4 &parent, bool showInvisible);

    void calcRenderTransform(const glm::mat4 &parentTransform);
    void renderImmediate(const glm::mat4 &parentTransform);
    void queueRender(const glm::mat4 &parentTransform);

    void lockFrame();
    void unlockFrame();

    void lockFrameIfVisible();
    void unlockFrameIfVisible();

    void setBufferedPosition(float x, float y, float z);
    void setBufferedOrientation(float x, float y, float z, float angle);
    void flushBuffers();

    TextureHandle *getTextures(uint32 &count);
    TextureHandle *getEnvironmentMap(EnvironmentMapMode &mode);

    void setMaterial(Shader::ShaderMaterial *material);
    virtual void buildMaterial();

private:
    const Common::BoundingBox &getAbsoluteBound() const;

    void orderChildren();

    static void renderGeometry(Mesh &mesh);
    static void renderGeometryNormal(Mesh &mesh);
    static void renderGeometryEnvMappedUnder(Mesh &mesh);
    static void renderGeometryEnvMappedOver(Mesh &mesh);

    static bool renderableMesh(Mesh *mesh);

public:
    // General helpers

    ModelNode *getParent();             
    const ModelNode *getParent() const; 

    void setParent(ModelNode *parent); 

    std::list<ModelNode *> &getChildren(); 

    Mesh *getMesh() const;

    bool isInFrontOf(const ModelNode &node) const;

    void inheritPosition(ModelNode &node) const;
    void inheritOrientation(ModelNode &node) const;

    friend class Model;
    friend class Animation;
    friend class AnimationChannel;
};

} // End of namespace Aurora

} // End of namespace Graphics

#endif // GRAPHICS_AURORA_MODELNODE_H