#include "stdafx.h"
#include "editpat.h"
#include "nel/misc/time_nl.h"

using namespace NLMISC;

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

#define DBGWELD_DUMPx
#define DBGWELD_ACTIONx
#define DBG_NAMEDSELSx

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

class EPVertMapRestore : public RestoreObj 
{
public:
	BOOL gotRedo;
	EPVertMapper undo;
	EPVertMapper redo;
	EditPatchData *epd;
	
	EPVertMapRestore(EditPatchData *d) 
	{
		undo = d->vertMap;
		epd = d;
		gotRedo = FALSE;
	}
	
	void Restore(int isUndo) 
	{
		if (!gotRedo)
		{
			gotRedo = TRUE;
			redo = epd->vertMap;
		}
		epd->vertMap = undo;
	}
	
	void Redo() 
	{
		epd->vertMap = redo;
	}
	
	int Size() { return 1; }
	void EndHold() { }
	TSTR Description() { return TSTR(_T("EPVertMapRestore")); }
};

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

class FinalPatchRestore : public RestoreObj 
{
public:
	BOOL gotRedo;
	PatchMesh undo;
	PatchMesh redo;
	PatchMesh *patch;
	RPatchMesh *rundo;
	RPatchMesh *rredo;
	RPatchMesh *rpatch;
	
	FinalPatchRestore(PatchMesh *s, RPatchMesh *rs)
	{
		rundo = NULL;
		rredo = NULL;

		undo = *s;

		if (rs)
		{
			rundo=new RPatchMesh();
			*rundo = *rs;
		}

		patch = s;
		rpatch = rs;
		gotRedo = FALSE;
	}
	
	virtual ~FinalPatchRestore()
	{
		if (rundo)
			delete rundo;
		if (rredo)
			delete rredo;
	}

	void Restore(int isUndo) 
	{
		if (!gotRedo)
		{
			gotRedo = TRUE;
			redo = *patch;

			if (rpatch)
			{
				if (rredo==NULL)
					rredo=new RPatchMesh();

				*rredo = *rpatch;
			}
		}
		*patch = undo;

		if (rundo)
			*rpatch = *rundo;
	}
	
	void Redo() 
	{
		*patch = redo;

		if (rredo)
			*rpatch = *rredo;
	}
	
	int Size() { return 1; }
	void EndHold() { }
	TSTR Description() { return TSTR(_T("FinalPatchRestore")); }
};

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

EditPatchData::EditPatchData(EditPatchMod *mod)
{
	meshSteps = mod->meshSteps;
	// 3-18-99 to suport render steps and removal of the mental tesselator
	meshStepsRender = mod->meshStepsRender;
	showInterior = mod->showInterior;
	
	//	meshAdaptive = mod->meshAdaptive;	// Future use (Not used now)
	viewTess = mod->viewTess;
	prodTess = mod->prodTess;
	dispTess = mod->dispTess;
	tileLevel = mod->tileLevel;
	tileMode = mod->tileMode;
	includeMeshes = mod->includeMeshes;
	transitionType = mod->transitionType;
	keepMapping = mod->keepMapping;
	mViewTessNormals = mod->mViewTessNormals;
	mProdTessNormals = mod->mProdTessNormals;
	mViewTessWeld = mod->mViewTessWeld;
	mProdTessWeld = mod->mProdTessWeld;
	displayLattice = mod->displayLattice;
	displaySurface = mod->displaySurface;
	flags = 0;
	tempData = NULL;
}

EditPatchData::EditPatchData(EditPatchData& emc)
{
	meshSteps = emc.meshSteps;
	// 3-18-99 to suport render steps and removal of the mental tesselator
	meshStepsRender = emc.meshStepsRender;
	showInterior = emc.showInterior;
	
	//	meshAdaptive = emc.meshAdaptive;	// Future use (Not used now)
	viewTess = emc.viewTess;
	prodTess = emc.prodTess;
	dispTess = emc.dispTess;
	tileLevel = emc.tileLevel;
	transitionType = emc.transitionType;
	tileMode = emc.tileMode;
	includeMeshes = emc.includeMeshes;
	keepMapping = emc.keepMapping;
	mViewTessNormals = emc.mViewTessNormals;
	mProdTessNormals = emc.mProdTessNormals;
	mViewTessWeld = emc.mViewTessWeld;
	mProdTessWeld = emc.mProdTessWeld;
	displayLattice = emc.displayLattice;
	displaySurface = emc.displaySurface;
	flags = emc.flags;
	tempData = NULL;
	vertMap = emc.vertMap;
	finalPatch = emc.finalPatch;
	rfinalPatch = emc.rfinalPatch;
}

void EditPatchData::Apply(TimeValue t, RPO *patchOb, int selLevel)
{
	TTicks ticks=CTime::getPerformanceTime ();
	// Either just copy it from the existing cache or rebuild from previous level!
	if (!GetFlag(EPD_UPDATING_CACHE) && tempData 
		&& tempData->PatchCached(t))
	{
		RPatchMesh *rpatch;
		PatchMesh *patch=tempData->GetPatch(t, rpatch);
		patchOb->patch.DeepCopy( patch,
			PART_GEOM | SELECT_CHANNEL | PART_SUBSEL_TYPE|
			PART_DISPLAY | PART_TOPO | TEXMAP_CHANNEL);
		//rpatch->UpdateBinding (*patch, t);
		*patchOb->rpatch=*rpatch;
		patchOb->PointsWereChanged();
	}	
	else if (GetFlag(EPD_HASDATA))
	{
		// For old files, which contain exhaustive data to reconstruct the editing process
		// of patches, we'll have data in the 'changes' table.  If it's there, go ahead and
		// replay the edits, then store the alterations in our new delta format and discard
		// the change table!
		int count = changes.Count();
		if (count)
		{
			// DebugPrint("*** Applying old style (%d) ***\n", count);
			// Store the topology for future reference
			vertMap.Build(patchOb->patch);
			finalPatch = patchOb->patch;
			rfinalPatch = *patchOb->rpatch;
			for (int i = 0; i < count; ++i)
			{
				PModRecord *rec = changes[i];
				// Record the topo flags
				RecordTopologyTags(&patchOb->patch);
				BOOL result = rec->Redo(&patchOb->patch, patchOb->rpatch, 0);
				UpdateChanges(&patchOb->patch, patchOb->rpatch);
				// If we hit one that didn't play back OK, we need to flush the remainder
				if (!result)
				{
					for (int j = i; j < count; ++j)
						delete changes[j];
					changes.Delete(i, count - i);
					break;
				}
			}
			// Nuke the changes table
			count = changes.Count();
			for (int k = 0; k < count; ++k)
				delete changes[k];
			changes.Delete(0, count);
			changes.Shrink();
			count = 0;
		}
		else 
		{
			// Apply deltas to incoming shape, placing into finalPatch
			vertMap.UpdateAndApplyDeltas(patchOb->patch, finalPatch);
			patchOb->patch = finalPatch;
			*patchOb->rpatch = rfinalPatch;
		}
		patchOb->PointsWereChanged();
		// Kind of a waste when there's no animation...		
		patchOb->UpdateValidity(GEOM_CHAN_NUM, FOREVER);
		patchOb->UpdateValidity(TOPO_CHAN_NUM, FOREVER);
		patchOb->UpdateValidity(SELECT_CHAN_NUM, FOREVER);
		patchOb->UpdateValidity(SUBSEL_TYPE_CHAN_NUM, FOREVER);
		patchOb->UpdateValidity(DISP_ATTRIB_CHAN_NUM, FOREVER);
	}
	else 
	{	// No data yet -- Store initial required data
		// DebugPrint("<<<Storing Initial Data>>>\n");
		vertMap.Build(patchOb->patch);
		finalPatch = patchOb->patch;
		rfinalPatch = *patchOb->rpatch;
	}

	// Hand it its mesh interpolation info
	patchOb->SetMeshSteps(meshSteps);
	// 3-18-99 to suport render steps and removal of the mental tesselator
	patchOb->SetMeshStepsRender(meshStepsRender);
	patchOb->SetShowInterior(showInterior);

	//	patchOb->SetAdaptive(meshAdaptive);	// Future use (Not used now)
	patchOb->SetViewTess(viewTess);
	patchOb->SetProdTess(prodTess);
	patchOb->SetDispTess(dispTess);
	patchOb->rpatch->rTess.ModeTile=tileMode;
	patchOb->rpatch->rTess.TileTesselLevel=tileLevel;
	patchOb->rpatch->rTess.TransitionType=transitionType;
	patchOb->rpatch->rTess.KeepMapping=keepMapping;
	patchOb->SetViewTessNormals(mViewTessNormals);
	patchOb->SetProdTessNormals(mProdTessNormals);
	patchOb->SetViewTessWeld(mViewTessWeld);
	patchOb->SetProdTessWeld(mProdTessWeld);

	patchOb->showMesh = displaySurface;
	patchOb->SetShowLattice(displayLattice);
	patchOb->patch.dispFlags = 0;	// TH 3/3/99
	switch (selLevel)
	{
	case EP_PATCH:
		patchOb->patch.SetDispFlag(DISP_SELPATCHES);
		break;
	case EP_EDGE:
		patchOb->patch.SetDispFlag(DISP_SELEDGES);
		break;
	case EP_VERTEX:
		patchOb->patch.SetDispFlag(DISP_VERTTICKS | DISP_SELVERTS | DISP_VERTS);
		break;
	case EP_TILE:
		//patchOb->patch.SetDispFlag(DISP_VERTTICKS | DISP_SELVERTS | DISP_VERTS);
		break;
	}
	patchOb->patch.selLevel = patchLevel[selLevel];
	patchOb->rpatch->SetSelLevel (selLevel);

	/*rfinalPatch.UpdateBinding (finalPatch, t);
	patchOb->rpatch->UpdateBinding (patchOb->patch, t);*/

	if (GetFlag(EPD_UPDATING_CACHE))
	{
		nlassert(tempData);
		tempData->UpdateCache(patchOb);
		SetFlag(EPD_UPDATING_CACHE, FALSE);
	}		
	ticks=CTime::getPerformanceTime ()-ticks;
	nldebug ("%f", CTime::ticksToSecond(ticks));
}

void EditPatchData::Invalidate(PartID part, BOOL patchValid)
{
	if (tempData)
	{
		tempData->Invalidate(part, patchValid);
	}
}

void EditPatchData::BeginEdit(TimeValue t)
{
	nlassert(tempData);
	if (!GetFlag(EPD_HASDATA))
		SetFlag(EPD_HASDATA, TRUE);
}

EPTempData *EditPatchData::TempData(EditPatchMod *mod)
{
	if (!tempData)
	{
		nlassert(mod->ip);
		tempData = new EPTempData(mod, this);
	}
	return tempData;
}

void EditPatchData::RescaleWorldUnits(float f) 
{
	// Scale the deltas inside the vertex map
	vertMap.RescaleWorldUnits(f);
	// Now rescale stuff inside our data structures
	Matrix3 stm = ScaleMatrix(Point3(f, f, f));
	finalPatch.Transform(stm);
}

void EditPatchData::RecordTopologyTags(PatchMesh *patch) 
{
	// First, stuff all -1's into aux fields
	int i;
	for (i = 0; i < patch->numVerts; ++i)
		patch->verts[i].aux1 = 0xffffffff;
	for (i = 0; i < patch->numVecs; ++i)
		patch->vecs[i].aux1 = 0xffffffff;
	for (i = 0; i < patch->numPatches; ++i)
		patch->patches[i].aux1 = 0xffffffff;
	// Now put in our tags
	vertMap.RecordTopologyTags(*patch);
}

GenericNamedSelSetList &EditPatchData::GetSelSet(EditPatchMod *mod) 
{
	switch (mod->GetSubobjectLevel())
	{
	case EP_VERTEX:
		return vselSet;
	case EP_EDGE:
		return eselSet;
	case EP_PATCH:
	case EP_TILE:
	default:
		return pselSet;
	}
}

GenericNamedSelSetList &EditPatchData::GetSelSet(int level) 
{
	switch (level + EP_VERTEX)
	{
	case EP_VERTEX:
		return vselSet;
	case EP_EDGE:
		return eselSet;
	case EP_PATCH:
	case EP_TILE:
	default:
		return pselSet;
	}
}


void EditPatchData::UpdateChanges(PatchMesh *patch, RPatchMesh *rpatch, BOOL checkTopology) 
{
	if (theHold.Holding())
	{
		theHold.Put(new EPVertMapRestore(this));
		//theHold.Put(new FinalPatchRestore(&finalPatch, &rfinalPatch));
		if (rpatch)
			theHold.Put(new FinalPatchRestore(&finalPatch, &rfinalPatch));
		else
			theHold.Put(new FinalPatchRestore(&finalPatch, NULL));
	}
	// Update the mapper's indices
	if (checkTopology)
		vertMap.UpdateMapping(*patch);
	// Update mapper's XYZ deltas
	vertMap.RecomputeDeltas(*patch);
	// Store the final shape
	finalPatch = *patch;

	if (rpatch)
		rfinalPatch = *rpatch;
}

#define EPD_GENERAL_CHUNK		0x1000	// Obsolete as of 11/12/98 (r3)
#define CHANGE_CHUNK			0x1010 	// Obsolete as of 11/12/98 (r3)
#define EPD_R3_GENERAL_CHUNK	0x1015
#define MESH_ATTRIB_CHUNK		0x1020
#define DISP_PARTS_CHUNK		0x1030
#define VTESS_ATTRIB_CHUNK		0x1070
#define PTESS_ATTRIB_CHUNK		0x1080
#define DTESS_ATTRIB_CHUNK		0x1090
#define NORMAL_TESS_ATTRIB_CHUNK	0x1110
#define WELD_TESS_ATTRIB_CHUNK	0x1120
#define VERTMAP_CHUNK			0x1130
#define FINALPATCH_CHUNK		0x1140
#define RENDERSTEPS_CHUNK		0x1150
#define SHOWINTERIOR_CHUNK		0x1160

// Named sel set chunks
#define VSELSET_CHUNK		0x1040
#define ESELSET_CHUNK		0x1050
#define PSELSET_CHUNK		0x1060

#define RPO_MODE_TILE 0x4000
#define RFINALPATCH_CHUNK 0x4001
#define RPO_MODE_TILE_TRANSITION 0x4002
#define RPO_INCLUDE_MESHES 0x4003

IOResult EditPatchData::Save(ISave *isave) 
{
	ULONG nb;
	isave->BeginChunk(EPD_R3_GENERAL_CHUNK);
	isave->Write(&flags, sizeof(DWORD), &nb);
	isave->EndChunk();
	isave->BeginChunk(MESH_ATTRIB_CHUNK);
	isave->Write(&meshSteps, sizeof(int), &nb);
	// Future use (Not used now)
	BOOL fakeAdaptive = FALSE;	
	isave->Write(&fakeAdaptive, sizeof(BOOL), &nb);
	//	isave->Write(&meshAdaptive,sizeof(BOOL),&nb);	// Future use (Not used now)
	isave->EndChunk();
	
	// 3-18-99 to suport render steps and removal of the mental tesselator
	isave->BeginChunk(RENDERSTEPS_CHUNK);
	if ((meshStepsRender < 0) ||(meshStepsRender > 100))
	{
		meshStepsRender = 5;
		nlassert(0);
	}
	isave->Write(&meshStepsRender, sizeof(int), &nb);
	isave->EndChunk();
	isave->BeginChunk(SHOWINTERIOR_CHUNK);
	isave->Write(&showInterior, sizeof(BOOL), &nb);
	isave->EndChunk();
	
	
	isave->BeginChunk(VTESS_ATTRIB_CHUNK);
	viewTess.Save(isave);
	isave->EndChunk();
	isave->BeginChunk(PTESS_ATTRIB_CHUNK);
	prodTess.Save(isave);
	isave->EndChunk();
	isave->BeginChunk(DTESS_ATTRIB_CHUNK);
	dispTess.Save(isave);
	isave->EndChunk();
	isave->BeginChunk(DISP_PARTS_CHUNK);
	isave->Write(&displaySurface, sizeof(BOOL), &nb);
	isave->Write(&displayLattice, sizeof(BOOL), &nb);
	isave->EndChunk();
	
	isave->BeginChunk(NORMAL_TESS_ATTRIB_CHUNK);
	isave->Write(&mViewTessNormals, sizeof(BOOL), &nb);
	isave->Write(&mProdTessNormals, sizeof(BOOL), &nb);
	isave->EndChunk();
	
	isave->BeginChunk(WELD_TESS_ATTRIB_CHUNK);
	isave->Write(&mViewTessWeld, sizeof(BOOL), &nb);
	isave->Write(&mProdTessWeld, sizeof(BOOL), &nb);
	isave->EndChunk();
	
	isave->BeginChunk(RPO_MODE_TILE);
	isave->Write(&tileMode, sizeof(tileMode), &nb);
	isave->Write(&tileLevel, sizeof(tileLevel), &nb);
	isave->Write(&keepMapping, sizeof(keepMapping), &nb);
	isave->EndChunk();
	
	isave->BeginChunk(RPO_INCLUDE_MESHES);
	isave->Write(&includeMeshes, sizeof(includeMeshes), &nb);
	isave->EndChunk();

	isave->BeginChunk(RPO_MODE_TILE_TRANSITION);
	isave->Write(&transitionType, sizeof(transitionType), &nb);
	isave->EndChunk();
	
	// Save named sel sets
	if (vselSet.Count())
	{
		isave->BeginChunk(VSELSET_CHUNK);
		vselSet.Save(isave);
		isave->EndChunk();
	}
	if (eselSet.Count())
	{
		isave->BeginChunk(ESELSET_CHUNK);
		eselSet.Save(isave);
		isave->EndChunk();
	}
	if (pselSet.Count())
	{
		isave->BeginChunk(PSELSET_CHUNK);
		pselSet.Save(isave);
		isave->EndChunk();
	}
	
	isave->BeginChunk(VERTMAP_CHUNK);
	vertMap.Save(isave);
	isave->EndChunk();
	isave->BeginChunk(FINALPATCH_CHUNK);
	finalPatch.Save(isave);
	isave->EndChunk();
	
	isave->BeginChunk(RFINALPATCH_CHUNK);
	rfinalPatch.Save(isave);
	isave->EndChunk();	
	
	return IO_OK;
}

IOResult EditPatchData::Load(ILoad *iload) 
{
IOResult res;
ULONG nb;
PModRecord *theChange;
while (IO_OK == (res = iload->OpenChunk())) 
{
	switch (iload->CurChunkID())
	{
		// The following code is here to load pre-release 3 files.
	case EPD_GENERAL_CHUNK:
		iload->SetObsolete();
		iload->Read(&flags, sizeof(DWORD), &nb);
		break;
	case CLEARVERTSELRECORD_CHUNK:
		theChange = new ClearPVertSelRecord;
		goto load_change;
	case SETVERTSELRECORD_CHUNK:
		theChange = new SetPVertSelRecord;
		goto load_change;
	case INVERTVERTSELRECORD_CHUNK:
		theChange = new InvertPVertSelRecord;
		goto load_change;
	case CLEAREDGESELRECORD_CHUNK:
		theChange = new ClearPEdgeSelRecord;
		goto load_change;
	case SETEDGESELRECORD_CHUNK:
		theChange = new SetPEdgeSelRecord;
		goto load_change;
	case INVERTEDGESELRECORD_CHUNK:
		theChange = new InvertPEdgeSelRecord;
		goto load_change;
	case CLEARPATCHSELRECORD_CHUNK:
		theChange = new ClearPatchSelRecord;
		goto load_change;
	case SETPATCHSELRECORD_CHUNK:
		theChange = new SetPatchSelRecord;
		goto load_change;
	case INVERTPATCHSELRECORD_CHUNK:
		theChange = new InvertPatchSelRecord;
		goto load_change;
	case VERTSELRECORD_CHUNK:
		theChange = new PVertSelRecord;
		goto load_change;
	case EDGESELRECORD_CHUNK:
		theChange = new PEdgeSelRecord;
		goto load_change;
	case PATCHSELRECORD_CHUNK:
		theChange = new PatchSelRecord;
		goto load_change;
	case PATCHDELETERECORD_CHUNK:
		theChange = new PatchDeleteRecord;
		goto load_change;
	case VERTMOVERECORD_CHUNK:
		theChange = new PVertMoveRecord;
		goto load_change;
	case PATCHCHANGERECORD_CHUNK:
		theChange = new PatchChangeRecord;
		goto load_change;
	case VERTCHANGERECORD_CHUNK:
		theChange = new PVertChangeRecord;
		goto load_change;
	case PATCHADDRECORD_CHUNK:
		theChange = new PatchAddRecord;
		goto load_change;
	case EDGESUBDIVIDERECORD_CHUNK:
		theChange = new EdgeSubdivideRecord;
		goto load_change;
	case PATCHSUBDIVIDERECORD_CHUNK:
		theChange = new PatchSubdivideRecord;
		goto load_change;
	case PATTACHRECORD_CHUNK:
		theChange = new PAttachRecord;
		goto load_change;
	case PATCHDETACHRECORD_CHUNK:
		theChange = new PatchDetachRecord;
		goto load_change;
	case PATCHMTLRECORD_CHUNK:
		theChange = new PatchMtlRecord;
		goto load_change;
	case VERTWELDRECORD_CHUNK:
		theChange = new PVertWeldRecord;
		goto load_change;
	case VERTDELETERECORD_CHUNK:
		theChange = new PVertDeleteRecord;
		// Intentional fall-thru!
load_change:
		changes.Append(1, &theChange);
		changes[changes.Count() - 1]->Load(iload);
		break;
		//
		// The following code is used for post-release 3 files
		//
	case EPD_R3_GENERAL_CHUNK:
		res = iload->Read(&flags, sizeof(DWORD), &nb);
		break;
	case VERTMAP_CHUNK:
		res = vertMap.Load(iload);
		break;
	case FINALPATCH_CHUNK:
		res = finalPatch.Load(iload);
		break;
	case RFINALPATCH_CHUNK:
		res = rfinalPatch.Load(iload);
		break;
		//
		// The following code is common to all versions' files
		//
	case MESH_ATTRIB_CHUNK:
		iload->Read(&meshSteps, sizeof(int), &nb);
		res = iload->Read(&meshAdaptive, sizeof(BOOL), &nb);	// Future use (Not used now)
		break;
		// 3-18-99 to suport render steps and removal of the mental tesselator
	case RENDERSTEPS_CHUNK:
		iload->Read(&meshStepsRender, sizeof(int), &nb);
		if ((meshStepsRender < 0) ||(meshStepsRender > 100))
		{
			meshStepsRender = 5;
			nlassert(0);
		}
		
		break;
	case SHOWINTERIOR_CHUNK:
		iload->Read(&showInterior, sizeof(BOOL), &nb);
		break;
		
	case VTESS_ATTRIB_CHUNK:
		viewTess.Load(iload);
		break;
	case PTESS_ATTRIB_CHUNK:
		prodTess.Load(iload);
		break;
	case DTESS_ATTRIB_CHUNK:
		dispTess.Load(iload);
		break;
	case NORMAL_TESS_ATTRIB_CHUNK:
		iload->Read(&mViewTessNormals, sizeof(BOOL), &nb);
		res = iload->Read(&mProdTessNormals, sizeof(BOOL), &nb);
		break;
	case WELD_TESS_ATTRIB_CHUNK:
		iload->Read(&mViewTessWeld, sizeof(BOOL), &nb);
		res = iload->Read(&mProdTessWeld, sizeof(BOOL), &nb);
		break;
	case DISP_PARTS_CHUNK:
		iload->Read(&displaySurface, sizeof(BOOL), &nb);
		res = iload->Read(&displayLattice, sizeof(BOOL), &nb);
		break;
		// Load named selection sets
	case VSELSET_CHUNK:
		res = vselSet.Load(iload);
		break;
	case PSELSET_CHUNK:
		res = pselSet.Load(iload);
		break;
	case ESELSET_CHUNK:
		res = eselSet.Load(iload);
		break;

	case RPO_MODE_TILE:
		res = iload->Read(&tileMode, sizeof(tileMode), &nb);
		res = iload->Read(&tileLevel, sizeof(tileLevel), &nb);
		res = iload->Read(&keepMapping, sizeof(keepMapping), &nb);
		break;

	case RPO_INCLUDE_MESHES:
		res = iload->Read(&includeMeshes, sizeof(includeMeshes), &nb);
		break;

	case RPO_MODE_TILE_TRANSITION:
		res = iload->Read(&transitionType, sizeof(transitionType), &nb);
		break;
		}
		iload->CloseChunk();
		if (res != IO_OK) 
			return res;
	}
	return IO_OK;
}