#include "stdafx.h"
#include "editpat.h"

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

#define DBGWELD_DUMPx
#define DBGWELD_ACTIONx
#define DBG_NAMEDSELSx

#define PROMPT_TIME	2000

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

int EditPatchMod::GetSelMatIndex()
	{
	ModContextList mcList;	
	INodeTab nodes;
	BOOL first = 1;
	int mat=-1;

	if (!ip)
		return -1;
	ip->GetModContexts(mcList, nodes);
	ClearPatchDataFlag(mcList, EPD_BEENDONE);

	for (int i = 0; i < mcList.Count(); i++)
	{
		EditPatchData *patchData =(EditPatchData*)mcList[i]->localData;
		if (!patchData)
			continue;
		if (patchData->GetFlag(EPD_BEENDONE))
			continue;
		patchData->BeginEdit(ip->GetTime());
		RPatchMesh *rpatch;
		PatchMesh *patch = patchData->TempData(this)->GetPatch(ip->GetTime(), rpatch);
		if (!patch)
			continue;
		for (int j = 0; j < patch->getNumPatches(); j++)
		{
			if (patch->patchSel[j])
			{
				if (first)
				{
					first = FALSE;
					mat   =(int)patch->getPatchMtlIndex(j);					
				} else 
				{
					if ((int)patch->getPatchMtlIndex(j) != mat)
					{
						return -1;
						}
					}
				}
			}
		}
	
	nodes.DisposeTemporary();
	return mat;
	}

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

void EditPatchMod::SetSelMatIndex(int index)
{
	ModContextList mcList;	
	INodeTab nodes;
	BOOL holdNeeded = FALSE;

	if (!ip)
		return;
	ip->GetModContexts(mcList, nodes);
	ClearPatchDataFlag(mcList, EPD_BEENDONE);	

	theHold.Begin();
	for (int i = 0; i < mcList.Count(); i++)
	{
		EditPatchData *patchData =(EditPatchData*)mcList[i]->localData;
		BOOL altered = FALSE;
		if (!patchData)
			continue;
		if (patchData->GetFlag(EPD_BEENDONE))
			continue;
		patchData->BeginEdit(ip->GetTime());
		RPatchMesh *rpatch;
		PatchMesh *patch = patchData->TempData(this)->GetPatch(ip->GetTime(), rpatch);
		if (!patch)
			continue;

		// Start a restore object...
		if (theHold.Holding())
		{
			theHold.Put(new PatchRestore(patchData, this, patch, rpatch, "SetSelMatIndex"));
			}

		for (int j = 0; j < patch->getNumPatches(); j++)
		{			
			if (patch->patchSel[j])
			{
				altered = holdNeeded = TRUE;
				patch->setPatchMtlIndex(j, (MtlID)index);			
				}
			}
		
		if (altered)
		{
			patchData->UpdateChanges(patch, rpatch, FALSE);
			patchData->TempData(this)->Invalidate(PART_TOPO);
			}
		patchData->SetFlag(EPD_BEENDONE, TRUE);		
		}	
	
	if (holdNeeded)
		theHold.Accept(GetString(IDS_TH_PATCHMTLCHANGE));
	else 
	{
		ip->DisplayTempPrompt(GetString(IDS_TH_NOPATCHESSEL), PROMPT_TIME);
		theHold.End();
		}

	nodes.DisposeTemporary();
	InvalidateSurfaceUI();
	NotifyDependents(FOREVER, PART_TOPO, REFMSG_CHANGE);
	ip->RedrawViews(ip->GetTime());
}

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

int EditPatchMod::GetSelTessU()
{
	ModContextList mcList;	
	INodeTab nodes;
	BOOL first = 1;
	int mat=-1;

	if (!ip)
		return -1;
	ip->GetModContexts(mcList, nodes);
	ClearPatchDataFlag(mcList, EPD_BEENDONE);

	for (int i = 0; i < mcList.Count(); i++)
	{
		EditPatchData *patchData =(EditPatchData*)mcList[i]->localData;
		if (!patchData)
			continue;
		if (patchData->GetFlag(EPD_BEENDONE))
			continue;
		patchData->BeginEdit(ip->GetTime());
		RPatchMesh *rpatch;
		PatchMesh *patch = patchData->TempData(this)->GetPatch(ip->GetTime(), rpatch);
		if (!patch)
			continue;
		for (int j = 0; j < patch->getNumPatches(); j++)
		{
			if (patch->patchSel[j])
			{
				if (first)
				{
					first = FALSE;
					mat = (int)rpatch->getUIPatch (j).NbTilesU;
				} 
				else 
				{
					if ((int)rpatch->getUIPatch (j).NbTilesU != mat)
					{
						return -1;
					}
				}
			}
		}
	}
	
	nodes.DisposeTemporary();
	return mat;
}

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

int EditPatchMod::GetSelTessV()
{
	ModContextList mcList;	
	INodeTab nodes;
	BOOL first = 1;
	int mat=-1;

	if (!ip)
		return -1;
	ip->GetModContexts(mcList, nodes);
	ClearPatchDataFlag(mcList, EPD_BEENDONE);

	for (int i = 0; i < mcList.Count(); i++)
	{
		EditPatchData *patchData =(EditPatchData*)mcList[i]->localData;
		if (!patchData)
			continue;
		if (patchData->GetFlag(EPD_BEENDONE))
			continue;
		patchData->BeginEdit(ip->GetTime());
		RPatchMesh *rpatch;
		PatchMesh *patch = patchData->TempData(this)->GetPatch(ip->GetTime(), rpatch);
		if (!patch)
			continue;
		for (int j = 0; j < patch->getNumPatches(); j++)
		{
			if (patch->patchSel[j])
			{
				if (first)
				{
					first = FALSE;
					mat = (int)rpatch->getUIPatch (j).NbTilesV;
				} 
				else 
				{
					if ((int)rpatch->getUIPatch (j).NbTilesV != mat)
					{
						return -1;
					}
				}
			}
		}
	}
	
	nodes.DisposeTemporary();
	return mat;
}

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

void EditPatchMod::SetSelTess(int nU, int nV)
{
	ModContextList mcList;	
	INodeTab nodes;
	BOOL holdNeeded = FALSE;

	if (!ip)
		return;
	ip->GetModContexts(mcList, nodes);
	ClearPatchDataFlag(mcList, EPD_BEENDONE);	

	theHold.Begin();
	for (int i = 0; i < mcList.Count(); i++)
	{
		EditPatchData *patchData =(EditPatchData*)mcList[i]->localData;
		BOOL altered = FALSE;
		if (!patchData)
			continue;
		if (patchData->GetFlag(EPD_BEENDONE))
			continue;
		patchData->BeginEdit(ip->GetTime());
		RPatchMesh *rpatch;
		PatchMesh *patch = patchData->TempData(this)->GetPatch(ip->GetTime(), rpatch);
		if (!patch)
			continue;

		// Start a restore object...
		if (theHold.Holding())
		{
			theHold.Put(new PatchRestore(patchData, this, patch, rpatch, "SetSelTess"));
		}

		for (int j = 0; j < patch->getNumPatches(); j++)
		{			
			if (patch->patchSel[j])
			{
				altered = holdNeeded = TRUE;
				rpatch->getUIPatch (j).Init (nU, nV, true);
			}
		}
		
		if (altered)
		{
			patchData->UpdateChanges(patch, rpatch, FALSE);
			patchData->TempData(this)->Invalidate(PART_TOPO);
		}

		patchData->SetFlag(EPD_BEENDONE, TRUE);		
	}	
	
	if (holdNeeded)
		theHold.Accept("Tile count in U and V change");
	else 
	{
		ip->DisplayTempPrompt(GetString(IDS_TH_NOPATCHESSEL), PROMPT_TIME);
		theHold.End();
	}

	nodes.DisposeTemporary();
	InvalidateSurfaceUI();
	NotifyDependents(FOREVER, PART_TOPO, REFMSG_CHANGE);
	ip->RedrawViews(ip->GetTime());
}

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

int EditPatchMod::getSmoothFlags ()
{
	ModContextList mcList;	
	INodeTab nodes;
	bool notFlagged=false;
	bool flagged=false;

	if (!ip)
		return -1;
	ip->GetModContexts(mcList, nodes);
	ClearPatchDataFlag(mcList, EPD_BEENDONE);

	for (int i = 0; i < mcList.Count(); i++)
	{
		EditPatchData *patchData =(EditPatchData*)mcList[i]->localData;
		if (!patchData)
			continue;
		if (patchData->GetFlag(EPD_BEENDONE))
			continue;
		patchData->BeginEdit(ip->GetTime());
		RPatchMesh *rpatch;
		PatchMesh *patch = patchData->TempData(this)->GetPatch(ip->GetTime(), rpatch);
		if (!patch)
			continue;

		// For each edges
		for (int j = 0; j < patch->getNumEdges(); j++)
		{
			// Is edge selected
			if (patch->edgeSel[j])
			{
				// Patch num
#if (MAX_RELEASE < 4000)
				int p0=patch->edges[j].patch1;
				int p1=patch->edges[j].patch2;
				bool edgeFlag = ((p0!=-1)&&(rpatch->getUIPatch (p0).getEdgeFlag (WhereIsTheEdge (p0, j, *patch)))) ||
					((p1!=-1)&&(rpatch->getUIPatch (p1).getEdgeFlag (WhereIsTheEdge (p1, j, *patch))));
#else // (MAX_RELEASE < 4000)
				bool edgeFlag = false;
				for (int pn = 0; pn < patch->edges[j].patches.Count(); ++pn)
				{
					int p = patch->edges[j].patches[pn];
					if (rpatch->getUIPatch(p).getEdgeFlag(WhereIsTheEdge(p, j, *patch)))
					{
						edgeFlag = true;
						break;
					}
				}
#endif // (MAX_RELEASE < 4000)

				// Is edge flaged ?
				if (edgeFlag)
				{
					// Flagged !
					flagged=true;
				}
				else
				{
					// Not flagged !
					notFlagged=true;
				}
			}
		}
	}
	
	nodes.DisposeTemporary();
	return flagged?(notFlagged?2:1):0;
}

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

void EditPatchMod::setSmoothFlags (bool smooth)
{
	ModContextList mcList;	
	INodeTab nodes;
	BOOL holdNeeded = FALSE;

	if (!ip)
		return;
	ip->GetModContexts(mcList, nodes);
	ClearPatchDataFlag(mcList, EPD_BEENDONE);	

	theHold.Begin();
	for (int i = 0; i < mcList.Count(); i++)
	{
		EditPatchData *patchData =(EditPatchData*)mcList[i]->localData;
		BOOL altered = FALSE;
		if (!patchData)
			continue;
		if (patchData->GetFlag(EPD_BEENDONE))
			continue;
		patchData->BeginEdit(ip->GetTime());
		RPatchMesh *rpatch;
		PatchMesh *patch = patchData->TempData(this)->GetPatch(ip->GetTime(), rpatch);
		if (!patch)
			continue;

		// Start a restore object...
		if (theHold.Holding())
		{
			theHold.Put(new PatchRestore(patchData, this, patch, rpatch, "SetSmoothFlags"));
		}

		// For each edges
		for (int j = 0; j < patch->getNumEdges(); j++)
		{
			// Is edge selected
			if (patch->edgeSel[j])
			{
#if (MAX_RELEASE < 4000)
				// Patch num
				int p0=patch->edges[j].patch1;
				int p1=patch->edges[j].patch2;
				
				// Patch exist ?
				if (p0!=-1)
				{
					// Set the flag
					rpatch->getUIPatch (p0).setEdgeFlag (WhereIsTheEdge (p0, j, *patch), smooth);

					// Touched
					altered=TRUE;
					holdNeeded=TRUE;
				}

				// idem patch #2
				if (p1!=-1)
				{
					// Set the flag
					rpatch->getUIPatch (p1).setEdgeFlag (WhereIsTheEdge (p1, j, *patch), smooth);

					// Touched
					altered=TRUE;
					holdNeeded=TRUE;
				}
#else // (MAX_RELEASE < 4000)
				for (int pe = 0; pe < patch->edges[j].patches.Count(); ++pe)
				{
					int pn = patch->edges[j].patches[pe];

					// Set the flag
					rpatch->getUIPatch(pn).setEdgeFlag(WhereIsTheEdge(pn, j, *patch), smooth);

					// Touched
					altered=TRUE;
					holdNeeded=TRUE;
				}
#endif // (MAX_RELEASE < 4000)
			}
		}
		
		// If touched
		if (altered)
		{
			patchData->UpdateChanges(patch, rpatch, FALSE);
			patchData->TempData(this)->Invalidate(PART_TOPO);
		}

		patchData->SetFlag(EPD_BEENDONE, TRUE);		
	}	
	
	if (holdNeeded)
		theHold.Accept("Tile count in U and V change");
	else 
	{
		ip->DisplayTempPrompt(GetString(IDS_TH_NOPATCHESSEL), PROMPT_TIME);
		theHold.End();
	}

	nodes.DisposeTemporary();
	InvalidateEdgeUI();
	NotifyDependents(FOREVER, PART_TOPO, REFMSG_CHANGE);
	ip->RedrawViews(ip->GetTime());
}

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

void EditPatchMod::BalanceSelPatch (int patch, int size, bool balanceU, std::set<int>& visitedU, std::set<int>& visitedV, RPatchMesh* rpatch, PatchMesh *ppatch)
{
	// already visited ?
	if ((balanceU&&(visitedU.find(patch)!=visitedU.end()))||((!balanceU)&&(visitedV.find(patch)!=visitedV.end())))
		return;

	// insert in the visit set
	if (balanceU)
		visitedU.insert (patch);
	else
		visitedV.insert (patch);

	// Get patch tess level..
	int nU=rpatch->getUIPatch (patch).NbTilesU;
	int nV=rpatch->getUIPatch (patch).NbTilesV;
	if (balanceU)
		nU=size;
	else
		nV=size;

	// Resize the patch
	rpatch->getUIPatch (patch).Init (nU, nV, true);

	// Call neiborhood
	for (int i=0; i<4; i++)
	{
		int nEdge=ppatch->patches[patch].edge[i];
#if (MAX_RELEASE < 4000)
		int nOtherPatch=(ppatch->edges[nEdge].patch1==patch)?ppatch->edges[nEdge].patch2:ppatch->edges[nEdge].patch1;
#else // (MAX_RELEASE < 4000)
		int nOtherPatch = (ppatch->edges[nEdge].patches.Count() > 0 && ppatch->edges[nEdge].patches[0] == patch)
						? (ppatch->edges[nEdge].patches.Count() > 1 ? ppatch->edges[nEdge].patches[1] : -1)
						: (ppatch->edges[nEdge].patches.Count() > 0 ? ppatch->edges[nEdge].patches[0] : -1);
#endif // (MAX_RELEASE < 4000)
		if (nOtherPatch>=0)
		{
			int nNeiborEdge=WhereIsTheEdge (nOtherPatch, nEdge, *ppatch);
			BalanceSelPatch (nOtherPatch, (i&1)?nU:nV, (nNeiborEdge&1)!=0, visitedU, visitedV, rpatch, ppatch);
		}
	}
}

void EditPatchMod::BalanceSelPatch ()
{
	ModContextList mcList;	
	INodeTab nodes;
	BOOL holdNeeded = FALSE;

	if (!ip)
		return;
	ip->GetModContexts(mcList, nodes);
	ClearPatchDataFlag(mcList, EPD_BEENDONE);	

	theHold.Begin();
	for (int i = 0; i < mcList.Count(); i++)
	{
		EditPatchData *patchData =(EditPatchData*)mcList[i]->localData;
		BOOL altered = FALSE;
		if (!patchData)
			continue;
		if (patchData->GetFlag(EPD_BEENDONE))
			continue;
		patchData->BeginEdit(ip->GetTime());
		RPatchMesh *rpatch;
		PatchMesh *patch = patchData->TempData(this)->GetPatch(ip->GetTime(), rpatch);
		if (!patch)
			continue;

		// Start a restore object...
		if (theHold.Holding())
		{
			theHold.Put(new PatchRestore(patchData, this, patch, rpatch, "SetSelTess"));
		}

		std::set<int> visitedU;
		std::set<int> visitedV;
		for (int j = 0; j < patch->getNumPatches(); j++)
		{			
			if (patch->patchSel[j])
			{
				altered = holdNeeded = TRUE;
				
				// insert it
				visitedU.insert (j);
				visitedV.insert (j);

				// Get patch tess level..
				int nU=rpatch->getUIPatch (j).NbTilesU;
				int nV=rpatch->getUIPatch (j).NbTilesV;
				
				// Call neiborhood
				for (int i=0; i<4; i++)
				{
					int nEdge=patch->patches[j].edge[i];
#if (MAX_RELEASE < 4000)
					int nOtherPatch=(patch->edges[nEdge].patch1==j)?patch->edges[nEdge].patch2:patch->edges[nEdge].patch1;
#else // (MAX_RELEASE < 4000)
					int nOtherPatch = (patch->edges[nEdge].patches.Count() > 0 && patch->edges[nEdge].patches[0] == j)
						? (patch->edges[nEdge].patches.Count() > 1 ? patch->edges[nEdge].patches[1] : -1)
						: (patch->edges[nEdge].patches.Count() > 0 ? patch->edges[nEdge].patches[0] : -1);
#endif // (MAX_RELEASE < 4000)
					if (nOtherPatch>=0)
					{
						int nNeiborEdge=WhereIsTheEdge (nOtherPatch, nEdge, *patch);
						BalanceSelPatch (nOtherPatch, (i&1)?nU:nV, (nNeiborEdge&1)!=0, visitedU, visitedV, rpatch, patch);
					}
				}

			}
		}
		
		if (altered)
		{
			patchData->UpdateChanges(patch, rpatch, FALSE);
			patchData->TempData(this)->Invalidate(PART_TOPO);
		}

		patchData->SetFlag(EPD_BEENDONE, TRUE);		
	}	
	
	if (holdNeeded)
		theHold.Accept("Balance tile");
	else 
	{
		ip->DisplayTempPrompt(GetString(IDS_TH_NOPATCHESSEL), PROMPT_TIME);
		theHold.End();
	}

	nodes.DisposeTemporary();
	InvalidateSurfaceUI();
	NotifyDependents(FOREVER, PART_TOPO, REFMSG_CHANGE);
	ip->RedrawViews(ip->GetTime());
}

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

/*void EditPatchMod::SetTileNum (ULONG nU)
{
	ModContextList mcList;	
	INodeTab nodes;
	BOOL holdNeeded = FALSE;

	if (!ip)
		return;
	ip->GetModContexts(mcList, nodes);
	ClearPatchDataFlag(mcList, EPD_BEENDONE);	

	theHold.Begin();
	for (int i = 0; i < mcList.Count(); i++)
	{
		EditPatchData *patchData =(EditPatchData*)mcList[i]->localData;
		BOOL altered = FALSE;
		if (!patchData)
			continue;
		if (patchData->GetFlag(EPD_BEENDONE))
			continue;
		patchData->BeginEdit(ip->GetTime());
		RPatchMesh *rpatch;
		PatchMesh *patch = patchData->TempData(this)->GetPatch(ip->GetTime(), rpatch);
		if (!patch)
			continue;

		// Start a restore object...
		if (theHold.Holding())
		{
			theHold.Put(new PatchRestore(patchData, this, patch, rpatch, "SetTileNum"));
		}

		nlassert (patch->numPatches==(int)rpatch->UIPatch.size());
		for (int j = 0; j < patch->getNumPatches(); j++)
		{
			int nTileU=1<<rpatch->UIPatch[j].NbTilesU;
			int nTileV=1<<rpatch->UIPatch[j].NbTilesV;

			for (int v = 0; v < nTileV; v++)
			for (int u= 0; u < nTileU; u++)
			{
				if (rpatch->tileSel[rpatch->GetTileNumber(j, u, v)])
				{
					altered = holdNeeded = TRUE;
					rpatch->UIPatch[j].Tile[u+v*nTileU].MatID = nU;
				}
			}
		}
		
		if (altered)
		{
			patchData->UpdateChanges(patch, rpatch, FALSE);
			patchData->TempData(this)->Invalidate(PART_TOPO);
		}

		patchData->SetFlag(EPD_BEENDONE, TRUE);		
	}	
	
	if (holdNeeded)
		theHold.Accept("Tile number change");
	else 
	{
		ip->DisplayTempPrompt("No tile selected", PROMPT_TIME);
		theHold.End();
	}

	nodes.DisposeTemporary();
	InvalidateSurfaceUI();
	NotifyDependents(FOREVER, PART_TOPO, REFMSG_CHANGE);
	ip->RedrawViews(ip->GetTime());
}*/

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

/*ULONG EditPatchMod::GetTileNum ()
{
	ModContextList mcList;	
	INodeTab nodes;
	BOOL first = 1;
	ULONG num=0xffffffff;

	if (!ip)
		return -1;
	ip->GetModContexts(mcList, nodes);
	ClearPatchDataFlag(mcList, EPD_BEENDONE);

	for (int i = 0; i < mcList.Count(); i++)
	{
		EditPatchData *patchData =(EditPatchData*)mcList[i]->localData;
		if (!patchData)
			continue;
		if (patchData->GetFlag(EPD_BEENDONE))
			continue;
		patchData->BeginEdit(ip->GetTime());
		RPatchMesh *rpatch;
		PatchMesh *patch = patchData->TempData(this)->GetPatch(ip->GetTime(), rpatch);
		if (!patch)
			continue;

		nlassert (patch->numPatches==(int)rpatch->UIPatch.size());
		for (int j = 0; j < patch->getNumPatches(); j++)
		{
			int nTileU=1<<rpatch->UIPatch[j].NbTilesU;
			int nTileV=1<<rpatch->UIPatch[j].NbTilesV;

			for (int v = 0; v < nTileV; v++)
			for (int u= 0; u < nTileU; u++)
			{
				if (rpatch->tileSel[rpatch->GetTileNumber(j, u, v)])
				{
					if (first)
					{
						first = FALSE;
						num = rpatch->UIPatch[j].Tile[u+v*nTileU].MatID;
					} 
					else 
					{
						if (rpatch->UIPatch[j].Tile[u+v*nTileU].MatID != num)
						{
							return 0xffffffff;
						}
					}
				}
			}
		}
	}
	
	nodes.DisposeTemporary();
	return num;
}*/

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

/*void EditPatchMod::SetTileRot (int nRot)
{
	ModContextList mcList;	
	INodeTab nodes;
	BOOL holdNeeded = FALSE;

	if (!ip)
		return;
	ip->GetModContexts(mcList, nodes);
	ClearPatchDataFlag(mcList, EPD_BEENDONE);	

	theHold.Begin();
	for (int i = 0; i < mcList.Count(); i++)
	{
		EditPatchData *patchData =(EditPatchData*)mcList[i]->localData;
		BOOL altered = FALSE;
		if (!patchData)
			continue;
		if (patchData->GetFlag(EPD_BEENDONE))
			continue;
		patchData->BeginEdit(ip->GetTime());
		RPatchMesh *rpatch;
		PatchMesh *patch = patchData->TempData(this)->GetPatch(ip->GetTime(), rpatch);
		if (!patch)
			continue;

		// Start a restore object...
		if (theHold.Holding())
		{
			theHold.Put(new PatchRestore(patchData, this, patch, rpatch, "SetTileRot"));
		}

		nlassert (patch->numPatches==(int)rpatch->UIPatch.size());
		for (int j = 0; j < patch->getNumPatches(); j++)
		{
			int nTileU=1<<rpatch->UIPatch[j].NbTilesU;
			int nTileV=1<<rpatch->UIPatch[j].NbTilesV;

			for (int v = 0; v < nTileV; v++)
			for (int u= 0; u < nTileU; u++)
			{
				if (rpatch->tileSel[rpatch->GetTileNumber(j, u, v)])
				{
					altered = holdNeeded = TRUE;
					rpatch->UIPatch[j].Tile[u+v*nTileU].Rotate = nRot;
				}
			}
		}
		
		if (altered)
		{
			patchData->UpdateChanges(patch, rpatch, FALSE);
			patchData->TempData(this)->Invalidate(PART_TOPO);
		}

		patchData->SetFlag(EPD_BEENDONE, TRUE);		
	}	
	
	if (holdNeeded)
		theHold.Accept("Tile rotation change");
	else 
	{
		ip->DisplayTempPrompt("No tile selected", PROMPT_TIME);
		theHold.End();
	}

	nodes.DisposeTemporary();
	InvalidateSurfaceUI();
	NotifyDependents(FOREVER, PART_TOPO, REFMSG_CHANGE);
	ip->RedrawViews(ip->GetTime());
}*/

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

/*int EditPatchMod::GetTileRot ()
{
	ModContextList mcList;	
	INodeTab nodes;
	BOOL first = 1;
	int rot=-1;

	if (!ip)
		return -1;
	ip->GetModContexts(mcList, nodes);
	ClearPatchDataFlag(mcList, EPD_BEENDONE);

	for (int i = 0; i < mcList.Count(); i++)
	{
		EditPatchData *patchData =(EditPatchData*)mcList[i]->localData;
		if (!patchData)
			continue;
		if (patchData->GetFlag(EPD_BEENDONE))
			continue;
		patchData->BeginEdit(ip->GetTime());
		RPatchMesh *rpatch;
		PatchMesh *patch = patchData->TempData(this)->GetPatch(ip->GetTime(), rpatch);
		if (!patch)
			continue;

		nlassert (patch->numPatches==(int)rpatch->UIPatch.size());
		for (int j = 0; j < patch->getNumPatches(); j++)
		{
			int nTileU=1<<rpatch->UIPatch[j].NbTilesU;
			int nTileV=1<<rpatch->UIPatch[j].NbTilesV;

			for (int v = 0; v < nTileV; v++)
			for (int u= 0; u < nTileU; u++)
			{
				if (rpatch->tileSel[rpatch->GetTileNumber(j, u, v)])
				{
					if (first)
					{
						first = FALSE;
						rot = rpatch->UIPatch[j].Tile[u+v*nTileU].Rotate;
					} 
					else 
					{
						if (rpatch->UIPatch[j].Tile[u+v*nTileU].Rotate != rot)
						{
							return -1;
						}
					}
				}
			}
		}
	}
	
	nodes.DisposeTemporary();
	return rot;
}*/

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

void EditPatchMod::SelectByMat(int index, BOOL clear)
	{
	ModContextList mcList;	
	INodeTab nodes;

	if (!ip)
		return;
	ip->GetModContexts(mcList, nodes);
	ClearPatchDataFlag(mcList, EPD_BEENDONE);
	
	theHold.Begin();

	for (int i = 0; i < mcList.Count(); i++)
	{
		EditPatchData *patchData =(EditPatchData*)mcList[i]->localData;
		if (!patchData)
			continue;
		if (patchData->GetFlag(EPD_BEENDONE))
			continue;
		patchData->BeginEdit(ip->GetTime());
		RPatchMesh *rpatch;
		PatchMesh *patch = patchData->TempData(this)->GetPatch(ip->GetTime(), rpatch);
		if (!patch)
			continue;

		// Start a restore object...
		if (theHold.Holding())
		{
			theHold.Put(new PatchSelRestore(patchData, this, patch));
			}
		
		if (clear)
			patch->patchSel.ClearAll();

		for (int j = 0; j < patch->getNumPatches(); j++)
		{			
			if (patch->getPatchMtlIndex(j) == index)
				patch->patchSel.Set(j);
			}
		
		patchData->UpdateChanges(patch, rpatch, FALSE);
		patchData->SetFlag(EPD_BEENDONE, TRUE);
		patchData->TempData(this)->Invalidate(PART_SELECT);
		}
		
	PatchSelChanged();
	theHold.Accept(GetString(IDS_RB_SELECTBYMATID));
	
	nodes.DisposeTemporary();
	NotifyDependents(FOREVER, PART_SELECT, REFMSG_CHANGE);
	ip->RedrawViews(ip->GetTime());
	}

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

MtlID EditPatchMod::GetNextAvailMtlID(ModContext* mc) 
{
	if (!mc)
		return 1;
	EditPatchData *patchData =(EditPatchData*)mc->localData;
	if (!patchData)
		return 1;

	// If the mesh isn't yet cache, this will cause it to get cached.
	RPatchMesh *rpatch;
	PatchMesh *patch = patchData->TempData(this)->GetPatch(ip->GetTime(), rpatch);
	if (!patch)
		return 1;
	
	int mtlID = GetSelFaceUniqueMtlID(mc);

	if (mtlID == -1)
	{
		int i;
 		
		MtlID min, max;
		BOOL first = TRUE;

		int p;
		for (p = 0; p < patch->numPatches; ++p)
		{
			MtlID thisID = patch->getPatchMtlIndex(p);
			if (first)
			{
				min = max = thisID;
				first = FALSE;
				}
			else
			if (thisID < min)
				min = thisID;
			else
			if (thisID > max)
				max = thisID;
			}
		// If room below, return it
		if (min > 0)
			return min - 1;
		// Build a bit array to find any gaps		
		BitArray b;
		int bits = max - min + 1;
		b.SetSize(bits);
		b.ClearAll();
		for (p = 0; p < patch->numPatches; ++p)
			b.Set(patch->getPatchMtlIndex(p) - min);
		for (i = 0; i < bits; ++i)
		{
			if (!b[i])
				return (MtlID)(i + min);
			}
		// No gaps!  If room above, return it
		if (max < 65535)
			return max + 1;
		}
	return (MtlID)mtlID;
	}

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

BOOL EditPatchMod::HasFaceSelection(ModContext* mc) 
{
	// Are we the edited object?
	if (ip == NULL)
		return FALSE;

	EditPatchData *patchData =(EditPatchData*)mc->localData;
	if (!patchData)
		return FALSE;

	// If the mesh isn't yet cache, this will cause it to get cached.
	RPatchMesh *rpatch;
	PatchMesh *patch = patchData->TempData(this)->GetPatch(ip->GetTime(), rpatch);
	if (!patch)
		return FALSE;

	// Is Patch selection active?
	if (selLevel == EP_PATCH && patch->patchSel.NumberSet())
		return TRUE;
	
	return FALSE;
	}

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

void EditPatchMod::SetSelFaceMtlID(ModContext* mc, MtlID id, BOOL bResetUnsel) 
{
	int altered = 0;
	EditPatchData *patchData =(EditPatchData*)mc->localData;
	if (!patchData)
		return;

	// If the mesh isn't yet cache, this will cause it to get cached.
	RPatchMesh *rpatch;
	PatchMesh *patch = patchData->TempData(this)->GetPatch(ip->GetTime(), rpatch);
	if (!patch)
		return;
	
	// If this is the first edit, then the delta arrays will be allocated
	patchData->BeginEdit(ip->GetTime());

	if (theHold.Holding())
		theHold.Put(new PatchRestore(patchData, this, patch, rpatch));

	for (int p = 0; p < patch->numPatches; ++p)
	{
		if (patch->patchSel[p])
		{
			altered = TRUE;
			patch->setPatchMtlIndex(p, id);
			}
		}

	if (altered)
	{
		patchData->UpdateChanges(patch, rpatch, FALSE);
		InvalidateSurfaceUI();
		}

	NotifyDependents(FOREVER, PART_TOPO, REFMSG_CHANGE);
	ip->RedrawViews(ip->GetTime());
	}

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

int	EditPatchMod::GetSelFaceUniqueMtlID(ModContext* mc) 
{
	int	mtlID;

	mtlID = GetSelFaceAnyMtlID(mc);
	if (mtlID == -1)
		return mtlID;

	EditPatchData *patchData =(EditPatchData*)mc->localData;
	if (!patchData)
		return 1;

	// If the mesh isn't yet cache, this will cause it to get cached.
	RPatchMesh *rpatch;
	PatchMesh *patch = patchData->TempData(this)->GetPatch(ip->GetTime(), rpatch);
	if (!patch)
		return 1;

	for (int p = 0; p < patch->numPatches; ++p)
	{
		if (patch->patchSel[p])
			continue;
		if (patch->getPatchMtlIndex(p) != mtlID)
			continue;
		mtlID = -1;
		}
	return mtlID;
	}

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

int	EditPatchMod::GetSelFaceAnyMtlID(ModContext* mc) 
{
	int				mtlID = -1;
	BOOL			bGotFirst = FALSE;

	EditPatchData *patchData =(EditPatchData*)mc->localData;
	if (!patchData)
		return 1;

	// If the mesh isn't yet cache, this will cause it to get cached.
	RPatchMesh *rpatch;
	PatchMesh *patch = patchData->TempData(this)->GetPatch(ip->GetTime(), rpatch);
	if (!patch)
		return 1;

	for (int p = 0; p < patch->numPatches; ++p)
	{
		if (!patch->patchSel[p])
			continue;
		if (bGotFirst)
		{
			if (mtlID != patch->getPatchMtlIndex(p))
			{
				mtlID = -1;
				break;
				}
			}
		else 
		{
			mtlID = patch->getPatchMtlIndex(p);
			bGotFirst = TRUE;
			}
		}
	return mtlID;
	}

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

int	EditPatchMod::GetMaxMtlID(ModContext* mc) 
{
	MtlID mtlID = 0;

	EditPatchData *patchData =(EditPatchData*)mc->localData;
	if (!patchData)
		return 1;

	// If the mesh isn't yet cache, this will cause it to get cached.
	RPatchMesh *rpatch;
	PatchMesh *patch = patchData->TempData(this)->GetPatch(ip->GetTime(), rpatch);
	if (!patch)
		return 1;

	for (int p = 0; p < patch->numPatches; ++p)
		mtlID = std::max(mtlID, patch->getPatchMtlIndex(p));

	return mtlID;
	}

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