#ifndef TMESHIMAGE_INCLUDED

#define TMESHIMAGE_INCLUDED

#include <memory></memory>

// TnzCore includes

#include "tsmartpointer.h"

#include "tpersist.h"

#include "tgeometry.h"

#include "timage.h"

// tcg includes

#include "tcg_wrap.h"

#include "tcg/tcg_vertex.h"

#include "tcg/tcg_edge.h"

#include "tcg/tcg_face.h"

#include "tcg/tcg_mesh.h"

#include "tcg/tcg_mesh_bgl.h"

#undef DVAPI

#undef DVVAR

#ifdef TVECTORIMAGE_EXPORTS

#define DVAPI DV_EXPORT_API

#define DVVAR DV_EXPORT_VAR

#else

#define DVAPI DV_IMPORT_API

#define DVVAR DV_IMPORT_VAR

#endif

//===========================================

//    Forward declarations

//===========================================

//***********************************************************************************

//    TTextureVertex (Textured Mesh Vertex Type)  declaration

//***********************************************************************************

struct RigidPoint : public TPointD {

	double rigidity;

public:

	RigidPoint() : TPointD(), rigidity(1.0) {}

	explicit RigidPoint(double x, double y, double rigidity_ = 1.0)

		: TPointD(x, y), rigidity(rigidity_) {}

	explicit RigidPoint(const TPointD &point, double rigidity_ = 1.0)

		: TPointD(point), rigidity(rigidity_) {}

	RigidPoint &operator=(const TPointD &p)

	{

		TPointD::operator=(p);

		return *this;

	}

public:

	RigidPoint operator+(const RigidPoint &other) const

	{

		return RigidPoint(x + other.x, y + other.y, rigidity + other.rigidity);

	}

	RigidPoint &operator+=(const RigidPoint &other)

	{

		x += other.x, y += other.y, rigidity += other.rigidity;

		return *this;

	}

	RigidPoint operator-(const RigidPoint &other) const

	{

		return RigidPoint(x - other.x, y - other.y, rigidity - other.rigidity);

	}

	RigidPoint &operator-=(const RigidPoint &other)

	{

		x -= other.x, y -= other.y, rigidity -= other.rigidity;

		return *this;

	}

	friend RigidPoint operator*(double a, const RigidPoint &b)

	{

		return RigidPoint(a * b.x, a * b.y, a * b.rigidity);

	}

	friend RigidPoint operator*(const RigidPoint &a, double b)

	{

		return RigidPoint(a.x * b, a.y * b, a.rigidity * b);

	}

	RigidPoint &operator*=(double a)

	{

		x *= a, y *= a, rigidity *= a;

		return *this;

	}

	friend RigidPoint operator*(const TAffine &aff, const RigidPoint &p)

	{

		return RigidPoint(aff.operator*(p), p.rigidity);

	}

};

//-----------------------------------------------------------------------------

typedef tcg::Vertex<rigidpoint> TTextureVertex;</rigidpoint>

//=================================================================================

namespace tcg

{

template <>

struct point_traits<rigidpoint> {</rigidpoint>

	typedef RigidPoint point_type;

	typedef double value_type;

	typedef double float_type;

	inline static value_type x(const point_type &p) { return p.x; }

	inline static value_type y(const point_type &p) { return p.y; }

};

} // namespace tcg

//***********************************************************************************

//    TTextureMesh (Textured Mesh Type)  declaration

//***********************************************************************************

class DVAPI TTextureMesh : public tcg::TriMesh<ttexturevertex, tcg::edge,="" tcg::facen<3="">>, public TSmartObject, public TPersist</ttexturevertex,>

{

	PERSIST_DECLARATION(TTextureMesh)

	DECLARE_CLASS_CODE

public:

	TTextureMesh();

	TTextureMesh(const TTextureMesh &);

	TTextureMesh &operator=(const TTextureMesh &);

	int faceContaining(const TPointD &p) const;

	bool faceContains(int f, const TPointD &p) const;

	TRectD getBBox() const;

	void saveData(TOStream &os);

	void loadData(TIStream &is);

};

//-----------------------------------------------------------------------------

#ifdef WIN32

template class DVAPI TSmartPointerT<ttexturemesh>;</ttexturemesh>

#endif

typedef TSmartPointerT<ttexturemesh> TTextureMeshP;</ttexturemesh>

//-----------------------------------------------------------------------------

namespace boost

{

template <>

struct graph_traits<ttexturemesh></ttexturemesh>

	: public graph_traits

									TTextureMesh::edge_type,

									TTextureMesh::face_type>> {

};

} // namespace boost

//***********************************************************************************

//    TMeshImage (Textured Mesh Image)  declaration

//***********************************************************************************

class DVAPI TMeshImage : public TImage

{

	class Imp;

	std::shared_ptr<imp> m_imp;</imp>

public:

	typedef std::vector<ttexturemeshp> meshes_container;</ttexturemeshp>

public:

	TMeshImage();

	TMeshImage(std::shared_ptr<imp> imp);</imp>

	~TMeshImage();

	TMeshImage(const TMeshImage &other);

	TMeshImage &operator=(TMeshImage other);

	TImage::Type getType() const { return TImage::MESH; }

	TRectD getBBox() const;

	TImage *cloneImage() const;

	void getDpi(double &dpix, double &dpiy) const;

	void setDpi(double dpix, double dpiy);

	const meshes_container &meshes() const;

	meshes_container &meshes();

	friend void swap(TMeshImage &a, TMeshImage &b)

	{

		std::swap(a.m_imp, b.m_imp);

	}

};

//-----------------------------------------------------------------------------

#ifdef WIN32

template class DVAPI TSmartPointerT<tmeshimage>;</tmeshimage>

template class DVAPI TDerivedSmartPointerT<tmeshimage, timage="">;</tmeshimage,>

#endif

class DVAPI TMeshImageP : public TDerivedSmartPointerT<tmeshimage, timage=""></tmeshimage,>

{

public:

	TMeshImageP() {}

	TMeshImageP(TMeshImage *image) : DerivedSmartPointer(image) {}

	TMeshImageP(TImageP image) : DerivedSmartPointer(image) {}

#if !defined(WIN32)

	TMeshImageP(TImage *image) : DerivedSmartPointer(TImageP(image))

	{

	}

#endif

	operator TImageP()

	{

		return TImageP(m_pointer);

	}

};

#endif // TMESHIMAGE_INCLUDED