// TnzCore includes

#include "tmeshimage.h"

#include "tgl.h"

#include "tundo.h"

// TnzExt includes

#include "ext/plasticdeformerstorage.h"

// tcg includes

#include "tcg/tcg_macros.h"

#include "tcg/tcg_point_ops.h"

#include "tcg/tcg_iterator_ops.h"

#include "tcg/tcg_function_types.h"

#include "tcg/tcg_deleter_types.h"

#include "tcg/tcg_unique_ptr.h"

// boost includes

#include <boost unordered_set.hpp=""></boost>

#include <boost unordered_map.hpp=""></boost>

using namespace tcg::bgl;

#include <boost breadth_first_search.hpp="" graph=""></boost>

// STD includes

#include <stack></stack>

#include "plastictool.h"

using namespace PlasticToolLocals;

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

//    Local namespace  stuff

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

namespace

{

typedef PlasticTool::MeshIndex MeshIndex;

typedef TTextureMesh::vertex_type vertex_type;

typedef TTextureMesh::edge_type edge_type;

typedef TTextureMesh::face_type face_type;

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

bool borderEdge(const TTextureMesh &mesh, int e)

{

	return (mesh.edge(e).facesCount() < 2);

}

bool borderVertex(const TTextureMesh &mesh, int v)

{

	const TTextureVertex &vx = mesh.vertex(v);

	tcg::vertex_traits<ttexturevertex>::edges_const_iterator et, eEnd(vx.edgesEnd());</ttexturevertex>

	for (et = vx.edgesBegin(); et != eEnd; ++et) {

		if (borderEdge(mesh, *et))

			return true;

	}

	return false;

}

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

bool testSwapEdge(const TTextureMesh &mesh, int e)

{

	return (mesh.edge(e).facesCount() == 2);

}

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

bool testCollapseEdge(const TTextureMesh &mesh, int e)

{

	struct Locals {

		const TTextureMesh &m_mesh;

		int m_e;

		const TTextureMesh::edge_type &m_ed;

		bool testTrianglesCount()

		{

			// There must be at least one remanining triangle

			return (m_mesh.facesCount() > m_ed.facesCount());

		}

		bool testBoundary()

		{

			// Must not join two non-adjacent boundary vertices

			return (!borderVertex(m_mesh, m_ed.vertex(0)) ||

					!borderVertex(m_mesh, m_ed.vertex(1)) ||

					borderEdge(m_mesh, m_e));

		}

		bool testAdjacency()

		{

			// See TriMesh<>::collapseEdge()

			// Retrieve allowed adjacent vertices

			int f, fCount = m_ed.facesCount();

			int allowedV[6], *avt, *avEnd = allowedV + 3 * fCount;

			for (f = 0, avt = allowedV; f != fCount; ++f, avt += 3)

				m_mesh.faceVertices(m_ed.face(f), avt[0], avt[1], avt[2]);

			// Test adjacent vertices

			int v0 = m_ed.vertex(0), v1 = m_ed.vertex(1);

			const vertex_type &vx0 = m_mesh.vertex(v0);

			tcg::vertex_traits<vertex_type>::edges_const_iterator et, eEnd = vx0.edgesEnd();</vertex_type>

			for (et = vx0.edgesBegin(); et != eEnd; ++et) {

				int otherV = m_mesh.edge(*et).otherVertex(v0);

				if (m_mesh.edgeInciding(v1, otherV) >= 0) {

					// Adjacent vertex - must be found in the allowed list

					if (std::find(allowedV, avEnd, otherV) == avEnd)

						return false;

				}

			}

			return true;

		}

	} locals = {mesh, e, mesh.edge(e)};

	return (locals.testTrianglesCount() &&

			locals.testBoundary() &&

			locals.testAdjacency());

}

} // namespace

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

//    PlasticToolLocals  stuff

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

namespace PlasticToolLocals

{

struct Closer {

	const TTextureMesh &m_mesh;

	TPointD m_pos;

	double dist2(const TTextureMesh::vertex_type &a)

	{

		return tcg::point_ops::dist2<tpointd>(a.P(), m_pos);</tpointd>

	}

	double dist2(const TTextureMesh::edge_type &a)

	{

		const TTextureMesh::vertex_type &avx0 = m_mesh.vertex(a.vertex(0)),

										&avx1 = m_mesh.vertex(a.vertex(1));

		return sq(tcg::point_ops::segDist<tpointd>(avx0.P(), avx1.P(), m_pos));</tpointd>

	}

	bool operator()(const TTextureMesh::vertex_type &a,

					const TTextureMesh::vertex_type &b)

	{

		return (dist2(a) < dist2(b));

	}

	bool operator()(const TTextureMesh::edge_type &a,

					const TTextureMesh::edge_type &b)

	{

		return (dist2(a) < dist2(b));

	}

};

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

std::pair<double, int=""> closestVertex(const TTextureMesh &mesh, const TPointD &pos)</double,>

{

	Closer closer = {mesh, pos};

	int vIdx = int(std::min_element(mesh.vertices().begin(), mesh.vertices().end(), closer).index());

	return std::make_pair(closer.dist2(mesh.vertex(vIdx)), vIdx);

}

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

std::pair<double, int=""> closestEdge(const TTextureMesh &mesh, const TPointD &pos)</double,>

{

	Closer closer = {mesh, pos};

	int eIdx = int(std::min_element(mesh.edges().begin(), mesh.edges().end(), closer).index());

	return std::make_pair(closer.dist2(mesh.edge(eIdx)), eIdx);

}

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

std::pair<double, meshindex=""> closestVertex(const TMeshImage &mi, const TPointD &pos)</double,>

{

	std::pair<double, meshindex=""> closest((std::numeric_limits<double>::max)(), MeshIndex());</double></double,>

	const TMeshImage::meshes_container &meshes = mi.meshes();

	TMeshImage::meshes_container::const_iterator mt, mEnd = meshes.end();

	for (mt = meshes.begin(); mt != mEnd; ++mt) {

		const std::pair<double, int=""> &candidateIdx = closestVertex(**mt, pos);</double,>

		std::pair<double, meshindex=""> candidate(</double,>

			candidateIdx.first, MeshIndex(mt - meshes.begin(), candidateIdx.second));

		if (candidate < closest)

			closest = candidate;

	}

	return closest;

}

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

std::pair<double, meshindex=""> closestEdge(const TMeshImage &mi, const TPointD &pos)</double,>

{

	std::pair<double, meshindex=""> closest((std::numeric_limits<double>::max)(), MeshIndex());</double></double,>

	const TMeshImage::meshes_container &meshes = mi.meshes();

	TMeshImage::meshes_container::const_iterator mt, mEnd = meshes.end();

	for (mt = meshes.begin(); mt != mEnd; ++mt) {

		const std::pair<double, int=""> &candidateIdx = closestEdge(**mt, pos);</double,>

		std::pair<double, meshindex=""> candidate(</double,>

			candidateIdx.first, MeshIndex(mt - meshes.begin(), candidateIdx.second));

		if (candidate < closest)

			closest = candidate;

	}

	return closest;

}

} // namespace

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

//    Cut Mesh  operation

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

namespace

{

struct EdgeCut {

	int m_vIdx; //!< Vertex index to cut from.

	int m_eIdx; //!< Edge index to cut.

	EdgeCut(int vIdx, int eIdx)

		: m_vIdx(vIdx), m_eIdx(eIdx) {}

};

struct VertexOccurrence {

	int m_count;			  //!< Number of times a vertex occurs.

	int m_adjacentEdgeIdx[2]; //!< Edge indexes of which a vertex is endpoint.

};

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

bool buildEdgeCuts(const TMeshImage &mi, const PlasticTool::MeshSelection &edgesSelection,

				   int &meshIdx, std::vector<edgecut> &edgeCuts)</edgecut>

{

	typedef PlasticTool::MeshSelection::objects_container edges_container;

	typedef PlasticTool::MeshIndex MeshIndex;

	typedef boost::unordered_map<int, vertexoccurrence=""> VertexOccurrencesMap;</int,>

	struct locals {

		static bool differentMesh(const MeshIndex &a, const MeshIndex &b)

		{

			return (a.m_meshIdx != b.m_meshIdx);

		}

		static int testSingleMesh(const edges_container &edges)

		{

			assert(!edges.empty());

			return (std::find_if(

						edges.begin(), edges.end(), tcg::bind2nd(&differentMesh, edges.front())) == edges.end())

					   ? edges.front().m_meshIdx

					   : -1;

		}

		static bool testNoBoundaryEdge(

			const TTextureMesh &mesh, const edges_container &edges)

		{

			edges_container::const_iterator et, eEnd = edges.end();

			for (et = edges.begin(); et != eEnd; ++et)

				if (::borderEdge(mesh, et->m_idx))

					return false;

			return true;

		}

		static bool buildVertexOccurrences(

			const TTextureMesh &mesh, const edges_container &edges,

			VertexOccurrencesMap &vertexOccurrences)

		{

			// Calculate vertex occurrences as edge endpoints

			edges_container::const_iterator et, eEnd = edges.end();

			for (et = edges.begin(); et != eEnd; ++et) {

				const edge_type &ed = mesh.edge(et->m_idx);

				int v0 = ed.vertex(0), v1 = ed.vertex(1);

				VertexOccurrence &vo0 = vertexOccurrences[v0],

								 &vo1 = vertexOccurrences[v1];

				if (vo0.m_count > 1 || vo1.m_count > 1)

					return false;

				vo0.m_adjacentEdgeIdx[vo0.m_count++] =

					vo1.m_adjacentEdgeIdx[vo1.m_count++] = et->m_idx;

			}

			return true;

		}

		static bool buildEdgeCuts(

			const TTextureMesh &mesh, const edges_container &edges,

			std::vector<edgecut> &edgeCuts)</edgecut>

		{

			VertexOccurrencesMap vertexOccurrences;

			if (!buildVertexOccurrences(mesh, edges, vertexOccurrences))

				return false;

			// Build endpoints (exactly 2)

			int endPoints[2];

			int epCount = 0;

			VertexOccurrencesMap::iterator ot, oEnd = vertexOccurrences.end();

			for (ot = vertexOccurrences.begin(); ot != oEnd; ++ot) {

				if (ot->second.m_count == 1) {

					if (epCount > 1)

						return false;

					endPoints[epCount++] = ot->first;

				}

			}

			if (epCount != 2)

				return false;

			// Pick the first endpoint on the boundary, if any (otherwise, just pick one)

			int *ept, *epEnd = endPoints + 2;

			ept = std::find_if(endPoints, epEnd, tcg::bind1st(&borderVertex, mesh));

			if (ept == epEnd) {

				// There is no boundary endpoint

				if (edges.size() < 2) // We should not cut the mesh on a

					return false;	 // single edge - no vertex to duplicate!

				ept = endPoints;

			}

			// Build the edge cuts list, expanding the edges selection from

			// the chosen endpoint

			edgeCuts.push_back(EdgeCut( // Build the first EdgeCut separately

				*ept, vertexOccurrences[*ept].m_adjacentEdgeIdx[0]));

			int e, eCount = int(edges.size()); // Build the remaining ones

			for (e = 1; e != eCount; ++e) {

				const EdgeCut &lastCut = edgeCuts.back();

				int vIdx = mesh.edge(lastCut.m_eIdx).otherVertex(lastCut.m_vIdx);

				const int(&adjEdges)[2] = vertexOccurrences[vIdx].m_adjacentEdgeIdx;

				int eIdx = (adjEdges[0] == lastCut.m_eIdx) ? adjEdges[1] : adjEdges[0];

				edgeCuts.push_back(EdgeCut(vIdx, eIdx));

			}

			return true;

		}

	};

	const edges_container &edges = edgesSelection.objects();

	// Trivial early bailouts

	if (edges.empty())

		return false;

	// Selected edges must lie on the same mesh

	meshIdx = locals::testSingleMesh(edges);

	if (meshIdx < 0)

		return false;

	const TTextureMesh &mesh = *mi.meshes()[meshIdx];

	// No selected edge must be on the boundary

	return (locals::testNoBoundaryEdge(mesh, edges) &&

			locals::buildEdgeCuts(mesh, edges, edgeCuts));

}

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

inline bool testCutMesh(const TMeshImage &mi, const PlasticTool::MeshSelection &edgesSelection)

{

	std::vector<edgecut> edgeCuts;</edgecut>

	int meshIdx;

	return buildEdgeCuts(mi, edgesSelection, meshIdx, edgeCuts);

}

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

void slitMesh(TTextureMesh &mesh, int e) //! Opens a slit along the specified edge index.

{

	TTextureMesh::edge_type &ed = mesh.edge(e);

	assert(ed.facesCount() == 2);

	// Duplicate the edge and pass one face to the duplicate

	TTextureMesh::edge_type edDup(ed.vertex(0), ed.vertex(1));

	int f = ed.face(1);

	edDup.addFace(f);

	ed.eraseFace(ed.facesBegin() + 1);

	int eDup = mesh.addEdge(edDup);

	// Alter the face to host the duplicate

	TTextureMesh::face_type &fc = mesh.face(f);

	(fc.edge(0) == e) ? fc.setEdge(0, eDup) : (fc.edge(1) == e) ? fc.setEdge(1, eDup) : fc.setEdge(2, eDup);

}

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

/*!

  \brief    Duplicates a mesh edge-vertex pair (the 'cut') and separates their

            connections to adjacent mesh primitives.

  \remark   The starting vertex is supposed to be on the mesh boundary.

  \remark   Edges with a single neighbouring face can be duplicated, too.

*/

void cutEdge(TTextureMesh &mesh, const EdgeCut &edgeCut)

{

	struct locals {

		static void transferEdge(

			TTextureMesh &mesh, int e, int vFrom, int vTo)

		{

			edge_type &ed = mesh.edge(e);

			vertex_type &vxFrom = mesh.vertex(vFrom),

						&vxTo = mesh.vertex(vTo);

			(ed.vertex(0) == vFrom) ? ed.setVertex(0, vTo) : ed.setVertex(1, vTo);

			vxTo.addEdge(e);

			vxFrom.eraseEdge(std::find(vxFrom.edges().begin(), vxFrom.edges().end(), e));

		}

		static void transferFace(

			TTextureMesh &mesh, int eFrom, int eTo)

		{

			edge_type &edFrom = mesh.edge(eFrom),

					  &edTo = mesh.edge(eTo);

			int f = mesh.edge(eFrom).face(1);

			{

				face_type &fc = mesh.face(f);

				(fc.edge(0) == eFrom) ? fc.setEdge(0, eTo) : (fc.edge(1) == eFrom) ? fc.setEdge(1, eTo) : fc.setEdge(2, eTo);

				edTo.addFace(f);

				edFrom.eraseFace(edFrom.facesBegin() + 1);

			}

		}

	}; // locals

	int vOrig = edgeCut.m_vIdx,

		eOrig = edgeCut.m_eIdx;

	// Create a new vertex at the same position of the original

	int vDup = mesh.addVertex(vertex_type(mesh.vertex(vOrig).P()));

	int e = eOrig;

	if (mesh.edge(e).facesCount() == 2) {

		// Duplicate the cut edge

		e = mesh.addEdge(edge_type(vDup, mesh.edge(eOrig).otherVertex(vOrig)));

		// Transfer one face from the original to the duplicate

		locals::transferFace(mesh, eOrig, e);

	} else {

		// Transfer the original edge to the duplicate vertex

		locals::transferEdge(mesh, eOrig, vOrig, vDup);

	}

	// Edges adjacent to the original vertex that are also adjacent

	// to the transferred face above must be transferred too

	int f = mesh.edge(e).face(0);

	while (f >= 0) {

		// Retrieve the next edge to transfer

		int otherE = mesh.otherFaceEdge(f, mesh.edge(e).otherVertex(vDup));

		// NOTE: Not "mesh.edgeInciding(vOrig, mesh.otherFaceVertex(f, e))" in the calculation

		//       of otherE. This is required since by transferring each edge at a time,

		//       we're 'breaking' faces up - f is adjacent to both vOrig AND vDup!

		//

		//       The chosen calculation, instead, just asks for the one edge which does

		//       not have a specific vertex in common to the 2 other edges in the face.

		locals::transferEdge(mesh, otherE, vOrig, vDup);

		// Update e and f

		e = otherE;

		f = mesh.edge(otherE).otherFace(f);

	}

}

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

}

namespace locals_

{						// Need to use a named namespace due to

						// a known gcc 4.2 bug with compiler-generated

struct VertexesRecorder // copy constructors.

	{

	boost::unordered_set<int> &m_examinedVertexes;</int>

public:

	typedef boost::on_examine_vertex event_filter;

public:

	VertexesRecorder(boost::unordered_set<int> &examinedVertexes)</int>

		: m_examinedVertexes(examinedVertexes) {}

	void operator()(int v, const TTextureMesh &)

	{

		m_examinedVertexes.insert(v);

	}

};

}

namespace

{ //

void splitUnconnectedMesh(TMeshImage &mi, int meshIdx)

{

	struct locals {

		static void buildConnectedComponent(

			const TTextureMesh &mesh, boost::unordered_set<int> &vertexes)</int>

		{

			// Prepare BFS algorithm

			tcg::unique_ptr<uchar, tcg::freer=""> colorMapP(</uchar,>

				(UCHAR *)calloc(mesh.vertices().nodesCount(), sizeof(UCHAR)));

			locals_::VertexesRecorder vertexesRecorder(vertexes);

			std::stack<int> verticesQueue;</int>

			// Launch it

			boost::breadth_first_visit(mesh, int(mesh.vertices().begin().index()),

									   verticesQueue, boost::make_bfs_visitor(vertexesRecorder), colorMapP.get());

		}

	}; // locals

	// Retrieve the list of vertexes in the first connected component

	TTextureMesh &origMesh = *mi.meshes()[meshIdx];

	boost::unordered_set<int> firstComponent;</int>

	locals::buildConnectedComponent(origMesh, firstComponent);

	if (firstComponent.size() == origMesh.verticesCount())

		return;

	// There are (exactly) 2 connected components. Just duplicate the mesh

	// and keep/delete found vertexes.

	TTextureMeshP dupMeshPtr(new TTextureMesh(origMesh));

	TTextureMesh &dupMesh = *dupMeshPtr;

	TTextureMesh::vertices_container &vertices = origMesh.vertices();

	TTextureMesh::vertices_container::iterator vt, vEnd = vertices.end();

	for (vt = vertices.begin(); vt != vEnd;) {

		int v = int(vt.index());

		++vt;

		if (firstComponent.count(v))

			dupMesh.removeVertex(v);

		else

			origMesh.removeVertex(v);

	}

	dupMesh.squeeze();

	origMesh.squeeze();

	mi.meshes().push_back(dupMeshPtr);

}

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

void splitMesh(TMeshImage &mi, int meshIdx, int lastBoundaryVertex)

{

	// Retrieve a cutting edge with a single adjacent face - cutting that

	// will just duplicate the vertex and separate the mesh in 2 connected

	// components

	TTextureMesh &mesh = *mi.meshes()[meshIdx];

	int e;

	{

		const vertex_type &lbVx = mesh.vertex(lastBoundaryVertex);

		vertex_type::edges_const_iterator et =

			std::find_if(lbVx.edgesBegin(), lbVx.edgesEnd(), tcg::bind1st(&borderEdge, mesh));

		assert(et != lbVx.edgesEnd());

		e = *et;

	}

	cutEdge(mesh, EdgeCut(lastBoundaryVertex, e));

	// At this point, separate the 2 resulting connected components

	// in 2 separate meshes (if necessary)

	splitUnconnectedMesh(mi, meshIdx);

}

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

bool cutMesh(TMeshImage &mi, const PlasticTool::MeshSelection &edgesSelection)

{

	struct locals {

		static int lastVertex(

			const TTextureMesh &mesh, const std::vector<edgecut> &edgeCuts)</edgecut>

		{

			return mesh.edge(edgeCuts.back().m_eIdx)

				.otherVertex(edgeCuts.back().m_vIdx);

		}

		static int lastBoundaryVertex(

			const TTextureMesh &mesh, const std::vector<edgecut> &edgeCuts)</edgecut>

		{

			int v = lastVertex(mesh, edgeCuts);

			return ::borderVertex(mesh, v) ? v : -1;

		}

	}; // locals

	std::vector<edgecut> edgeCuts;</edgecut>

	int meshIdx;

	if (!::buildEdgeCuts(mi, edgesSelection, meshIdx, edgeCuts))

		return false;

	TTextureMesh &mesh = *mi.meshes()[meshIdx];

	int lastBoundaryVertex = locals::lastBoundaryVertex(mesh, edgeCuts);

	// Slit the mesh on the first edge, in case the cuts do not start

	// on the mesh boundary

	std::vector<edgecut>::iterator ecBegin = edgeCuts.begin();</edgecut>

	if (!::borderVertex(mesh, ecBegin->m_vIdx)) {

		::slitMesh(mesh, ecBegin->m_eIdx);

		++ecBegin;

	}

	// Cut edges, in the order specified by edgeCuts

	std::for_each(ecBegin, edgeCuts.end(),

				  tcg::bind1st(&cutEdge, mesh));

	// Finally, the mesh could have been split in 2 - we need to separate

	// the pieces if needed

	if (lastBoundaryVertex >= 0)

		splitMesh(mi, meshIdx, lastBoundaryVertex);

	return true;

}

} // namespace

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

//    Undo  definitions

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

namespace

{

class MoveVertexUndo_Mesh : public TUndo

{

	int m_row, m_col; //!< Xsheet coordinates

	std::vector<meshindex> m_vIdxs;	//!< Moved vertices</meshindex>

	std::vector<tpointd> m_origVxsPos; //!< Original vertex positions</tpointd>

	TPointD m_posShift;				   //!< Vertex positions shift

public:

	MoveVertexUndo_Mesh(

		const std::vector<meshindex> &vIdxs,</meshindex>

		const std::vector<tpointd> &origVxsPos,</tpointd>

		const TPointD &posShift)

		: m_row(::row()), m_col(::column()), m_vIdxs(vIdxs), m_origVxsPos(origVxsPos), m_posShift(posShift)

	{

		assert(m_vIdxs.size() == m_origVxsPos.size());

	}

	int getSize() const { return int(sizeof(*this) + m_vIdxs.size() * (sizeof(int) + 2 * sizeof(TPointD))); }

	void redo() const

	{

		PlasticTool::TemporaryActivation tempActivate(m_row, m_col);

		l_plasticTool.setMeshVertexesSelection(m_vIdxs);

		l_plasticTool.moveVertex_mesh(m_origVxsPos, m_posShift);

		l_plasticTool.invalidate();

		l_plasticTool.notifyImageChanged(); // IMPORTANT: In particular, sets the level's

	}										//            dirty flag, so Toonz knows it has

											//            to be saved!

	void undo() const

	{

		PlasticTool::TemporaryActivation tempActivate(m_row, m_col);

		l_plasticTool.setMeshVertexesSelection(m_vIdxs);

		l_plasticTool.moveVertex_mesh(m_origVxsPos, TPointD());

		l_plasticTool.invalidate();

		l_plasticTool.notifyImageChanged();

	}

};

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

class SwapEdgeUndo : public TUndo

{

	int m_row, m_col;			 //!< Xsheet coordinates

	mutable MeshIndex m_edgeIdx; //!< Edge index

public:

	SwapEdgeUndo(const MeshIndex &edgeIdx)

		: m_row(::row()), m_col(::column()), m_edgeIdx(edgeIdx) {}

	int getSize() const { return sizeof(*this); }

	void redo() const

	{

		PlasticTool::TemporaryActivation tempActivate(m_row, m_col);

		const TMeshImageP &mi = TMeshImageP(TTool::getImage(true));

		assert(mi);

		// Perform swap

		TTextureMesh &mesh = *mi->meshes()[m_edgeIdx.m_meshIdx];

		m_edgeIdx.m_idx = mesh.swapEdge(m_edgeIdx.m_idx);

		assert(m_edgeIdx.m_idx >= 0);

		// Invalidate any deformer associated with mi

		PlasticDeformerStorage::instance()->releaseMeshData(mi.getPointer());

		// Update tool selection

		l_plasticTool.setMeshEdgesSelection(m_edgeIdx);

		l_plasticTool.invalidate();

		l_plasticTool.notifyImageChanged();

	}

	void undo() const { redo(); } // Operation is idempotent (indices

								  // are perfectly restored, too)

};

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

class TTextureMeshUndo : public TUndo

{

protected:

	int m_row, m_col; //!< Xsheet coordinates

	int m_meshIdx;					 //!< Mesh index in the image at stored xsheet coords

	mutable TTextureMesh m_origMesh; //!< Copy of the original mesh

public:

	TTextureMeshUndo(int meshIdx)

		: m_row(::row()), m_col(::column()), m_meshIdx(meshIdx) {}

	// Let's say 1MB each - storing the mesh is costly

	int getSize() const { return 1 << 20; }

	TMeshImageP getMeshImage() const

	{

		const TMeshImageP &mi = TMeshImageP(TTool::getImage(true));

		assert(mi);

		return mi;

	}

};

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

class CollapseEdgeUndo : public TTextureMeshUndo

{

	int m_eIdx; //!< Collapsed edge index

public:

	CollapseEdgeUndo(const MeshIndex &edgeIdx)

		: TTextureMeshUndo(edgeIdx.m_meshIdx), m_eIdx(edgeIdx.m_idx) {}

	void redo() const

	{

		PlasticTool::TemporaryActivation tempActivate(m_row, m_col);

		const TMeshImageP &mi = getMeshImage();

		// Store the original mesh

		TTextureMesh &mesh = *mi->meshes()[m_meshIdx];

		m_origMesh = mesh;

		// Collapse

		mesh.collapseEdge(m_eIdx);

		mesh.squeeze();

		// Invalidate any cached deformer associated with the modified mesh image

		PlasticDeformerStorage::instance()->releaseMeshData(mi.getPointer());

		// Refresh the tool

		l_plasticTool.clearMeshSelections();

		l_plasticTool.invalidate();

		l_plasticTool.notifyImageChanged();

	}

	void undo() const

	{

		PlasticTool::TemporaryActivation tempActivate(m_row, m_col);

		const TMeshImageP &mi = getMeshImage();

		// Restore the original mesh

		TTextureMesh &mesh = *mi->meshes()[m_meshIdx];

		mesh = m_origMesh;

		PlasticDeformerStorage::instance()->releaseMeshData(mi.getPointer());

		// Restore selection

		l_plasticTool.setMeshEdgesSelection(MeshIndex(m_meshIdx, m_eIdx));

		l_plasticTool.invalidate();

		l_plasticTool.notifyImageChanged();

	}

};

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

class SplitEdgeUndo : public TTextureMeshUndo

{

	int m_eIdx; //!< Split edge index

public:

	SplitEdgeUndo(const MeshIndex &edgeIdx)

		: TTextureMeshUndo(edgeIdx.m_meshIdx), m_eIdx(edgeIdx.m_idx) {}

	void redo() const

	{

		PlasticTool::TemporaryActivation tempActivate(m_row, m_col);

		const TMeshImageP &mi = getMeshImage();

		// Store the original mesh

		TTextureMesh &mesh = *mi->meshes()[m_meshIdx];

		m_origMesh = mesh;

		// Split

		mesh.splitEdge(m_eIdx);

		//mesh.squeeze();                                                     // There should be no need to squeeze

		assert(mesh.vertices().size() == mesh.vertices().nodesCount()); //

		assert(mesh.edges().size() == mesh.edges().nodesCount());		//

		assert(mesh.faces().size() == mesh.faces().nodesCount());		//

		PlasticDeformerStorage::instance()->releaseMeshData(mi.getPointer());

		l_plasticTool.clearMeshSelections();

		l_plasticTool.invalidate();

		l_plasticTool.notifyImageChanged();

	}