model_sonic.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_SONIC_H
#define GRAPHICS_AURORA_MODEL_SONIC_H

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

#include "glm/vec3.hpp"
#include "glm/vec4.hpp"
#include "glm/mat4x4.hpp"

#include "src/aurora/nitrofile.h"

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

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

namespace Graphics {

namespace Aurora {

class ModelNode_Sonic;

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

    void render(RenderPass pass);

private:
    // === Loading-time ===

    enum BoneCommandID {
        kBoneNOP             = 0x00, 
        kBoneEnd             = 0x01, 
        kBoneSetInvisible    = 0x02, 
        kBoneSetPolygonStack = 0x03, 
        kBoneSetMaterial1    = 0x04, 
        kBoneSetPolygon      = 0x05, 
        kBoneConnect1        = 0x06, 
        kBoneUnknown1        = 0x08,
        kBoneLoadStack       = 0x09,
        kBoneBeginPair       = 0x0B,
        kBoneUnknown2        = 0x0C,
        kBoneSetMaterial2    = 0x24, 
        kBoneConnect2        = 0x26, 
        kBoneEndPair         = 0x2B,
        kBoneUnknown3        = 0x2C,
        kBoneSetMaterial3    = 0x44, 
        kBoneConnect3        = 0x46, 
        kBoneConnect4        = 0x66  
    };

    enum PolygonCommandID {
        kPolygonNOP             = 0x00, 

        // Matrix commands
        kPolygonMatrixMode      = 0x10, 
        kPolygonMatrixPush      = 0x11, 
        kPolygonMatrixPop       = 0x12, 
        kPolygonMatrixStore     = 0x13, 
        kPolygonMatrixRestore   = 0x14, 
        kPolygonMatrixIdentity  = 0x15, 
        kPolygonMatrixLoad4x4   = 0x16, 
        kPolygonMatrixLoad4x3   = 0x17, 
        kPolygonMatrixMult4x4   = 0x18, 
        kPolygonMatrixMult4x3   = 0x19, 
        kPolygonMatrixMult3x3   = 0x1A, 
        kPolygonMatrixScale     = 0x1B, 
        kPolygonMatrixTranslate = 0x1C, 

        // Vertex attributes
        kPolygonColor           = 0x20, 
        kPolygonNormal          = 0x21, 
        kPolygonTexCoord        = 0x22, 

        // Vertex coordinates
        kPolygonVertex16        = 0x23, 
        kPolygonVertex10        = 0x24, 
        kPolygonVertexXY        = 0x25, 
        kPolygonVertexXZ        = 0x26, 
        kPolygonVertexYZ        = 0x27, 
        kPolygonVertexDiff      = 0x28, 

        kPolygonPolygonAttrib   = 0x29, 
        kPolygonTexImageParam   = 0x2A, 

        kPolygonPaletteBase     = 0x2B, 

        // Lighting
        kPolygonDiffuseAmbient  = 0x30, 
        kPolygonSpecularEmit    = 0x31, 
        kPolygonLightVector     = 0x32, 
        kPolygonLightColor      = 0x33, 
        kPolygonShininess       = 0x34, 

        kPolygonBeginVertices   = 0x40, 
        kPolygonEndVertices     = 0x41, 

        kPolygonSwapBuffers     = 0x50, 

        kPolygonViewport        = 0x60, 

        kPolygonBoxTest         = 0x70, 
        kPolygonPosTest         = 0x71, 
        kPolygonVecTest         = 0x72  
    };

    struct Info {
        Common::UString name;

        uint32 offset;
        uint8  count;
    };
    typedef std::vector<Info> Infos;

    struct BoneCommand {
        BoneCommandID command;

        std::vector<uint8> parameters;

        BoneCommand(BoneCommandID cmd = kBoneNOP) : command(cmd) { }
    };
    typedef std::list<BoneCommand> BoneCommands;

    struct PolygonCommand {
        PolygonCommandID command;

        std::vector<uint32> parameters;

        PolygonCommand(PolygonCommandID cmd = kPolygonNOP) : command(cmd) { }
    };
    typedef std::vector<PolygonCommand> PolygonCommands;

    struct Bone {
        Common::UString name;

        glm::mat4 transform;

        uint16 nodeID;   
        uint16 parentID; 

        uint16 nodeStack;   
        uint16 parentStack; 

        Bone *parent;               
        std::list<Bone *> children; 

        ModelNode_Sonic *modelNode; 


        Bone() : nodeID(0xFFFF), parentID(0xFFFF), nodeStack(0xFFFF), parentStack(0xFFFF), parent(0),
                 modelNode(0) { }
    };
    typedef std::vector<Bone> Bones;

    struct Material {
        Common::UString name;
        Common::UString texture; 
        Common::UString palette; 

        uint16 width;
        uint16 height;

        bool wrapX; 
        bool wrapY; 
        bool flipX; 
        bool flipY; 

        uint8 scaleX; 
        uint8 scaleY; 
    };
    typedef std::vector<Material> Materials;

    struct Polygon {
        Common::UString name;

        uint16 defaultStack;
        const Material *material;

        uint32 primitiveCount; 
        uint32 primitiveSize;  

        PolygonCommands commands;

        Polygon() : defaultStack(0xFFFF), material(0), primitiveCount(0), primitiveSize(0) { }
    };
    typedef std::vector<Polygon> Polygons;

    struct StackMix {
        uint16 nodeID;
        uint16 nodeStack;
        float  ratio;

        ModelNode_Sonic *node;

        StackMix(uint16 i = 0xFFFF, uint16 s = 0xFFFF, float r = 0.0f) :
            nodeID(i), nodeStack(s), ratio(r), node(0) { }
    };
    typedef std::vector<StackMix> StackMixes;
    typedef std::map<uint32, StackMixes> StackMixMap;

    typedef std::list<Bone *> BoneList;
    typedef std::map<uint8, Bone *> StackBoneMap;
    typedef std::map<uint8, bool> BoneInvisible;


    struct ParserContext {
        Common::SeekableSubReadStreamEndian *nsbmd;

        // .--- Offsets to different parts of the NSBMD file
        uint32 offsetMDL0;
        uint32 offsetModel;

        uint32 offsetBones;
        uint32 offsetBoneCommands;
        uint32 offsetMaterials;
        uint32 offsetPolygons;

        uint32 offsetTextures;
        uint32 offsetPalettes;
        // '---

        // .--- The various model parts
        double defaultScale;

        Bones bones;
        BoneCommands boneCommands;

        Materials materials;

        Polygons polygons;
        // '---

        // .--- Processed model parts
        BoneInvisible boneInvisible;

        StackMixMap stackMix;

        BoneList     rootBones;
        StackBoneMap stackBones;
        // '---

        State *state;

        std::list<ModelNode_Sonic *> nodes;

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

        void clear();
    };

    struct Geometry;
    struct Primitive;

    // .--- Loading helpers
    void newState(ParserContext &ctx);
    void addState(ParserContext &ctx);

    void load(ParserContext &ctx);

    void readModel(ParserContext &ctx);
    void readHeader(ParserContext &ctx);
    void readModelHeader(ParserContext &ctx);

    void readBones(ParserContext &ctx);
    void readBone(ParserContext &ctx, Bone &bone, Info &info);
    void readBoneCommands(ParserContext &ctx);

    void readMaterials(ParserContext &ctx);
    void readMaterialDefinitions(ParserContext &ctx);
    void readMaterialDefinition(ParserContext &ctx, Material &material, Info &info);
    void readMaterialResource(ParserContext &ctx, uint textureOrPalette);

    void readPolygons(ParserContext &ctx);
    void readPolygon(ParserContext &ctx, Polygon &polygon, Info &info);
    void readPolygonCommands(ParserContext &ctx, Polygon &polygon, uint32 listSize);

    void parseBoneCommands(ParserContext &ctx);
    void findRootBones(ParserContext &ctx);
    void findStackBones(ParserContext &ctx);

    void createModelNodes(ParserContext &ctx);

    void findStackMixes(ParserContext &ctx);

    void createGeometry(ParserContext &ctx);
    void createPrimitives(ParserContext &ctx, Geometry &geometry, Polygon &polygon);

    void createIndices(Primitive &primitive);
    void createIndicesTriangles(Primitive &primitive);
    void createIndicesTriangleStrip(Primitive &primitive);
    void createIndicesQuads(Primitive &primitive);
    void createIndicesQuadStrip(Primitive &primitive);

    void createBound();

    uint8 readInfoOffset(ParserContext &ctx, Infos &infos, uint32 offset);
    uint8 readInfoOffsetCount(ParserContext &ctx, Infos &infos, uint32 offset);
    // '---

    // .--- Utility methods
    static double getFixedPoint(uint32 value, bool sign, uint8 iBits, uint8 fBits);

    static uint8 getPolygonParameterCount(PolygonCommandID cmd);
    static uint8 getBoneParameterCount(BoneCommandID cmd, uint8 count);

    static glm::mat4 createPivot(double a, double b, uint8 select, uint8 negate);
    // '---

    // === Run-time ===

    enum PrimitiveType {
        kPrimitiveTypeTriangles     = 0,
        kPrimitiveTypeQuads         = 1,
        kPrimitiveTypeTriangleStrip = 2,
        kPrimitiveTypeQuadStrip     = 3
    };

    struct PrimitiveNode {
        ModelNode_Sonic *node;
        float ratio;

        PrimitiveNode(ModelNode_Sonic *n = 0, float r = 0.0f) : node(n), ratio(r) { }

        PrimitiveNode &operator=(const StackMix &mix) { node = mix.node; ratio = mix.ratio; return *this; }
        PrimitiveNode(const StackMix &mix) { *this = mix; }
    };
    typedef std::vector<PrimitiveNode> PrimitiveNodes;

    struct PrimitiveVertex {
        PrimitiveNodes nodes;

        glm::vec3 vertex;
        glm::vec3 normal;
        glm::vec4 color;
        glm::vec3 texCoord;

        PrimitiveVertex() : vertex(0.0f, 0.0f, 0.0f), normal(0.0f, 0.0f, 0.0f),
        color(1.0f, 1.0f, 1.0f, 1.0f), texCoord(0.0f, 0.0f, 0.0f) { }
    };
    typedef std::vector<PrimitiveVertex> PrimitiveVertices;
    typedef std::vector<uint16> PrimitiveIndices;

    struct Primitive {
        PrimitiveType type;

        bool invalid;

        PrimitiveVertices vertices;
        PrimitiveIndices  indices;

        VertexBuffer vertexBuffer;
        IndexBuffer  indexBuffer;

        Primitive(PrimitiveType t = kPrimitiveTypeTriangles) : type(t), invalid(false) { }
    };
    typedef std::vector<Primitive> Primitives;

    struct Geometry {
        TextureHandle texture;

        Primitives primitives;
    };
    typedef std::vector<Geometry> Geometries;

    Geometries _geometries;

    void evaluateGeometry();
    void evaluatePrimitive(Primitive &primitive);

    friend class ModelNode_Sonic;
};

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

    void load(Model_Sonic::ParserContext &ctx, Model_Sonic::Bone &bone);

private:
    void createAbsoluteBound();

    friend class Model_Sonic;
};

} // End of namespace Aurora

} // End of namespace Graphics

#endif // GRAPHICS_AURORA_MODEL_SONIC_H