/* 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