#pragma once

#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 final : 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 final

    : public tcg::TriMesh<ttexturevertex, tcg::edge,="" tcg::facen<3="">>,</ttexturevertex,>

      public TSmartObject,

      public TPersist {

  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) override;

  void loadData(TIStream &is) override;

};

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

#ifdef _WIN32

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

#endif

typedef TSmartPointerT<ttexturemesh> TTextureMeshP;</ttexturemesh>

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

namespace boost {

template <>

struct graph_traits<ttexturemesh> final</ttexturemesh>

    : public graph_traits<

          tcg::Mesh

                    TTextureMesh::face_type>> {};

}  // namespace boost

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

//    TMeshImage (Textured Mesh Image)  declaration

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

class DVAPI TMeshImage final : 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 override { return TImage::MESH; }

  TRectD getBBox() const override;

  TImage *cloneImage() const override;

  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 final

    : 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