model_dragonage.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_DRAGONAGE_H
#define GRAPHICS_AURORA_MODEL_DRAGONAGE_H

#include "glm/vec4.hpp"

#include "src/aurora/types.h"

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

namespace Common {
    class SeekableReadStream;
}

namespace Graphics {

namespace Aurora {

class ModelNode_DragonAge;

class Model_DragonAge : public Model {
public:
    Model_DragonAge(const Common::UString &name, ModelType type = kModelTypeObject);
    ~Model_DragonAge();

private:
    struct ParserContext {
        Common::UString mmhFile;
        Common::UString mshFile;

        Common::UString mmhName;
        Common::UString mshName;

        ::Aurora::GFF4File *mmh;
        ::Aurora::GFF4File *msh;

        const ::Aurora::GFF4Struct *mmhTop;
        const ::Aurora::GFF4Struct *mshTop;

        State *state;

        std::list<ModelNode_DragonAge *> nodes;

        ParserContext(const Common::UString &name);
        ~ParserContext();

        void open(const Common::UString &name);
        void clear();
    };


    void newState(ParserContext &ctx);
    void addState(ParserContext &ctx);

    void load(ParserContext &ctx);

    friend class ModelNode_DragonAge;
};

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

    void load(Model_DragonAge::ParserContext &ctx, const ::Aurora::GFF4Struct &nodeGFF);

private:
    enum MeshDeclUse {
        kMeshDeclUsePosition     =  0, 
        kMeshDeclUseBlendWeight  =  1, 
        kMeshDeclUseBlendIndices =  2, 
        kMeshDeclUseNormal       =  3, 
        kMeshDeclUsePSize        =  4, 
        kMeshDeclUseTexCoord     =  5, 
        kMeshDeclUseTangent      =  6, 
        kMeshDeclUseBinormal     =  7, 
        kMeshDeclUseTessFactor   =  8, 
        kMeshDeclUsePositionT    =  9, 
        kMeshDeclUseColor        = 10, 
        kMeshDeclUseFog          = 11, 
        kMeshDeclUseDepth        = 12, 
        kMeshDeclUseSample       = 13, 

        kMeshDeclUseUnused =  0xFFFFFFFF
    };

    enum MeshDeclType {
        kMeshDeclTypeFloat32_1 =  0, 
        kMeshDeclTypeFloat32_2 =  1, 
        kMeshDeclTypeFloat32_3 =  2, 
        kMeshDeclTypeFloat32_4 =  3, 
        kMeshDeclTypeColor     =  4, 
        kMeshDeclTypeUint8_4   =  5, 
        kMeshDeclTypeSint16_2  =  6, 
        kMeshDeclTypeSint16_4  =  7, 
        kMeshDeclTypeUint8_4n  =  8, 
        kMeshDeclTypeSint16_2n =  9, 
        kMeshDeclTypeSint16_4n = 10, 
        kMeshDeclTypeUint16_2n = 11, 
        kMeshDeclTypeUint16_4n = 12, 
        kMeshDeclType1010102   = 13, 
        kMeshDeclType1010102n  = 14, 
        kMeshDeclTypeFloat16_2 = 15, 
        kMeshDeclTypeFloat16_4 = 16, 

        kMeshDeclTypeUnused = 0xFFFFFFFF
    };

    struct MeshDeclaration {
        MeshDeclUse use;
        const ::Aurora::GFF4Struct *gff;

        int32 offset;
        MeshDeclType type;

        MeshDeclaration(MeshDeclUse u = kMeshDeclUseUnused, const ::Aurora::GFF4Struct *g = 0,
                        int32 o = -1, MeshDeclType t = kMeshDeclTypeUnused) :
            use(u), gff(g), offset(o), type(t) {
        }
    };
    typedef std::list<MeshDeclaration> MeshDeclarations;

    struct MaterialObject {
        Common::UString material;
        Common::UString defaultSemantic;

        std::map<Common::UString, float> floats;
        std::map<Common::UString, glm::vec4> vectors;
        std::map<Common::UString, Common::UString> textures;
    };

    void readTransformation(const ::Aurora::GFF4Struct &nodeGFF);
    void readChildren(Model_DragonAge::ParserContext &ctx, const ::Aurora::GFF4Struct &nodeGFF);

    void readMesh(Model_DragonAge::ParserContext &ctx, const ::Aurora::GFF4Struct &meshGFF);

    void sanityCheckMeshChunk(const ::Aurora::GFF4Struct &meshChunk);
    void readMeshDecl(const ::Aurora::GFF4Struct &meshChunk, MeshDeclarations &meshDecl);

    void createIndexBuffer (const ::Aurora::GFF4Struct &meshChunk, Common::SeekableReadStream &indexData);
    void createVertexBuffer(const ::Aurora::GFF4Struct &meshChunk, Common::SeekableReadStream &vertexData,
                            const MeshDeclarations &meshDecl);

    void readMAO(const Common::UString &materialName, MaterialObject &material);
    void readMAOGFF(Common::SeekableReadStream *maoStream, MaterialObject &material);
    void readMAOXML(Common::SeekableReadStream *maoStream, MaterialObject &material,
                    const Common::UString &fileName);

    void loadTextures(const std::vector<Common::UString> &textures, const MaterialObject &material);

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

    static void read2Float32(Common::ReadStream &stream, MeshDeclType type, float *&f);
    static void read3Float32(Common::ReadStream &stream, MeshDeclType type, float *&f);
    static void read4Float32(Common::ReadStream &stream, MeshDeclType type, float *&f);
};

} // End of namespace Aurora

} // End of namespace Graphics

#endif // GRAPHICS_AURORA_MODEL_DRAGONAGE_H