spriter.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 2
 * 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, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
 *
 * Spriter - 3D Renderer
 */
 
#ifndef TINSEL_SPRITER_H
#define TINSEL_SPRITER_H
 
#include "tinsel/dw.h"
#include "common/rect.h"
#include "common/stack.h"
#include "common/str.h"
 
#include "math/vector3d.h"
#include "math/vector2d.h"
#include "math/matrix4.h"
 
#if defined(USE_TINYGL)
#include "graphics/tinygl/tinygl.h"
#endif
 
namespace Tinsel {
 
typedef Common::FixedStack<Math::Matrix4, 30> MatrixStack;
 
enum RenderProgramOp : uint16 {
    MATRIX_DUPLICATE    = 1,
    MATRIX_REMOVE       = 2,
    UNUSED              = 3,
    TRANSFORM           = 4,
    TRANSLATE_X         = 5,
    TRANSLATE_Y         = 6,
    TRANSLATE_Z         = 7,
    TRANSLATE_XYZ       = 8,
    ROTATE_X            = 9,
    ROTATE_Y            = 10,
    ROTATE_Z            = 11,
    ROTATE_XYZ          = 17,
    STOP                = 16,
};
 
struct AnimationInfo {
    Common::String name;
 
    uint meshNum;
 
    uint translateTablesHunk;
    uint translateTables;
    uint translateNum;
 
    uint rotateTablesHunk;
    uint rotateTables;
    uint rotateNum;
 
    uint scaleTablesHunk;
    uint scaleTables;
    uint scaleNum;
 
    uint maxFrame;
};
 
struct MeshInfo {
    uint meshTablesHunk;
    uint meshTables;
 
    uint programHunk;
    uint program;
};
 
struct Hunk {
    Common::Array<uint8> data;
    Common::Array<uint> mappingIdx;
    uint size;
    uint flags;
};
 
typedef Common::Array<Hunk> Hunks;
 
typedef Common::Array<Math::Vector3d> Vectors;
 
struct Primitive {
    uint indices[8];
    uint color;
    Math::Vector2d uv[4];
    uint texture;
};
 
enum MeshPartType {
    MESH_PART_TYPE_COLOR,
    MESH_PART_TYPE_SOLID,
    MESH_PART_TYPE_TEXTURE,
};
 
struct MeshPart {
    MeshPartType type;
    uint cull;
    uint numVertices;
    Common::Array<Primitive> primitives;
};
 
struct Mesh {
    Common::Array<Math::Vector3d> vertices;
    Common::Array<Math::Vector3d> normals;
    Common::Array<MeshPart> parts;
    Common::Array<MeshPart> parts2;
};
 
struct Meshes {
    uint vertexCount;
    uint normalCount;
 
    Common::Array<Mesh> meshes;
};
 
typedef  Common::Array<Vectors> AnimationData;
 
struct ModelTables {
    Vectors translations;
    Vectors rotations;
    Vectors scales;
    Meshes  meshes;
};
 
enum ModelFlags {
    MODEL_HAS_TRANSLATION_TABLE = 1,
    MODEL_HAS_SCALE_TABLE = 2,
    MODEL_HAS_ROTATION_TABLE = 4
};
 
struct Model {
    Hunks hunks;
    Hunks hunksOverlay; // The game script can load additional data to supplement the main model. E.g. a special animation.
    uint animationCount;
    uint field_0xe;
    uint field_0xf;
    uint8* program;
 
    // animation tables
    AnimationData startTranslateTables;
    AnimationData startRotateTables;
    AnimationData startScaleTables;
    AnimationData endTranslateTables;
    AnimationData endRotateTables;
    AnimationData endScaleTables;
    int startFrame;
    int endFrame;
 
    uint flags;
    uint field_0x32;
    uint field_0x33;
 
    ModelTables tables;
 
    Math::Vector3d position;
    Math::Vector3d rotation;
    Math::Vector3d scale;
 
    uint time; // interpolant
};
 
struct Viewport {
    int ap;
    float width;
    float height;
 
    Common::Rect rect;
};
 
struct View {
    int centerX;
    int centerY;
 
    Common::Rect viewRect;
    Common::Rect screenRect;
 
    Viewport viewport;
 
    Math::Vector3d position;
    Math::Vector3d rotation;
};
 
class Spriter {
private:
    MatrixStack _modelMatrix;
    MatrixStack* _currentMatrix;
 
    Common::Array<AnimationInfo> _animMain;
    AnimationInfo _animShadow;
 
    MeshInfo _meshMain;
    Common::Array<MeshInfo> _meshShadow;
 
    View _view;
 
    Common::Array<uint8> _palette;
    Common::Array<uint8> _textureData;
 
    bool _textureGenerated;
#if defined(USE_TINYGL)
    uint _texture[4];
#endif
 
    bool _modelIdle;
 
    uint _animId;
    uint _animSpeed;
    uint _animDelay;
    uint _animDelayMax;
 
    uint _sequencesCount;
 
    uint _direction;
 
public:
    Model _modelMain;
    Model _modelShadow;
 
public:
    Spriter();
    virtual ~Spriter();
 
    void Init(int width, int height);
    void SetCamera(int rotX, int rotY, int rotZ, int posX, int posY, int posZ, int cameraAp);
    void TransformSceneXYZ(int x, int y, int z, int& xOut, int& yOut);
    void Load(const Common::String& modelName, const Common::String& textureName);
 
    void SetPalette(SCNHANDLE hPalette);
 
    void SetSequence(uint animId, uint delay);
    Common::Rect Draw(int direction, int x, int y, int z, int tDelta);
 
private:
    const Math::Matrix4& MatrixCurrent() const;
 
    void MatrixReset();
 
    void MatrixPop();
    void MatrixPush();
    void MatrixTranslate(float x, float y, float z);
    void MatrixScale(float x, float y, float z);
    void MatrixRotateX(float angle);
    void MatrixRotateY(float angle);
    void MatrixRotateZ(float angle);
 
    void SetViewport(int ap);
 
    // Loading of the model
    void LoadH(const Common::String& modelName);
    void LoadGBL(const Common::String& modelName);
    void LoadRBH(const Common::String& modelName, Hunks& hunks);
    void LoadVMC(const Common::String& textureName);
 
    void UpdateTextures();
 
    Meshes LoadMeshes(const Hunks &hunks, uint hunk, uint offset, int frame);
    template<bool convert>
    AnimationData LoadAnimationData(const Hunks &hunks, uint hunk, uint offset);
    void InitModel(Model& model, MeshInfo& meshInfo, Common::Array<AnimationInfo>& animInfo, uint flags);
 
    // Processing of the model
    void RunRenderProgram(Model &model, bool preprocess);
 
    void FindSimilarVertices(Mesh& mesh, Vectors& vertices, Common::Array<uint16>& sameVertices) const;
    void MergeVertices(Mesh& mesh, Common::Array<uint16>& sameVertices);
 
    void TransformMesh(Mesh& mesh, Vectors& vertices);
    void CalculateNormals(Mesh& mesh, Vectors& vertices, Vectors &normals);
 
    // Rendering
    void RenderModel(Model& model);
    void RenderMesh(Mesh& mesh, Vectors& vertices, Vectors &normals);
    void RenderMeshPartColor(MeshPart& part, Vectors& vertices, Vectors &normals);
    void RenderMeshPartTexture(MeshPart& part, Vectors& vertices, Vectors &normals);
 
    // Animation
    bool SetStartFrame(Model &model, const AnimationInfo &anim, int frame);
    bool SetEndFrame(Model &model, const AnimationInfo &anim, int frame);
};
 
} // End of namespace Tinsel
 
#endif  // TINSEL_SPRITER_H