/**********************************************************************
 *<
	FILE: vertex_tree_paint.cpp

	DESCRIPTION:	Modifier implementation

	CREATED BY: Christer Janson, Nikolai Sander

	HISTORY:

 *>	Copyright (c) 1997, All Rights Reserved.
 **********************************************************************/

#include "vertex_tree_paint.h"
#include "meshdelta.h"

 // flags:
#define VP_DISP_END_RESULT 0x01

static WNDPROC colorSwatchOriginalWndProc;

static	HIMAGELIST hButtonImages = NULL;

static void LoadImages()
{
	if (hButtonImages) return;
	HBITMAP hBitmap, hMask;
	hButtonImages = ImageList_Create(15, 14, ILC_MASK, 2, 0);	// 17 is kluge to center square. -SA
	hBitmap = LoadBitmap(hInstance, MAKEINTRESOURCE(IDB_BUTTONS));
	hMask = LoadBitmap(hInstance, MAKEINTRESOURCE(IDB_BUTTON_MASK));
	ImageList_Add(hButtonImages, hBitmap, hMask);
	DeleteObject(hBitmap);
	DeleteObject(hMask);
}

ClassDesc* GetVertexPaintDesc();


class VertexPaintClassDesc :public ClassDesc
{
public:
	int 			IsPublic() { return 1; }
	void *			Create(BOOL loading = FALSE) { return new VertexPaint(); }
	const TCHAR *	ClassName() { return GetString(IDS_CLASS_NAME); }
	SClass_ID		SuperClassID() { return OSM_CLASS_ID; }
	Class_ID		ClassID() { return VERTEX_TREE_PAINT_CLASS_ID; }
	const TCHAR* 	Category() { return GetString(IDS_CATEGORY); }
	void			ResetClassParams(BOOL fileReset) {}
};

static VertexPaintClassDesc VertexPaintDesc;
ClassDesc* GetVertexPaintDesc() { return &VertexPaintDesc; }

static INT_PTR CALLBACK VertexPaintDlgProc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam)
{
	int numPoints;
	VertexPaint *mod = (VertexPaint*)GetWindowLongPtr(hWnd, GWLP_USERDATA);
	if (!mod && msg != WM_INITDIALOG) return FALSE;
	int		comboResult;


	// Manages Spinners.
	if (((msg == CC_SPINNER_BUTTONUP) && HIWORD(wParam)) ||
		((msg == CC_SPINNER_CHANGE)))
	{
		ISpinnerControl *spin;
		spin = (ISpinnerControl *)lParam;

		switch (LOWORD(wParam))
		{
		case IDC_TINT_SPIN:
			if ((msg == CC_SPINNER_CHANGE))
			{
				mod->fTint = spin->GetFVal() / 100;
			}
			break;
		case IDC_BEND_SPIN:
			if ((msg == CC_SPINNER_CHANGE))
			{
				mod->fGradientBend = spin->GetFVal() / 100;
			}
			break;
		}
	}

	switch (msg)
	{
	case WM_INITDIALOG:
		LoadImages();
		mod = (VertexPaint*)lParam;
		SetWindowLongPtr(hWnd, GWLP_USERDATA, lParam);
		mod->hParams = hWnd;
		mod->iPaintButton = GetICustButton(GetDlgItem(hWnd, IDC_PAINT));
		mod->iPaintButton->SetType(CBT_CHECK);
		mod->iPaintButton->SetHighlightColor(GREEN_WASH);
		mod->iPaintButton->SetCheck(mod->ip->GetCommandMode()->ID() == CID_PAINT &&
			!((PaintMouseProc *)mod->ip->GetCommandMode()->MouseProc(&numPoints))->GetPickMode());
		mod->iPaintButton->SetImage(hButtonImages, 0, 0, 0, 0, 15, 14);
		mod->iPaintButton->SetTooltip(TRUE, GetString(IDS_PAINT));

		mod->iPickButton = GetICustButton(GetDlgItem(hWnd, IDC_PICK));
		mod->iPickButton->SetType(CBT_CHECK);
		mod->iPickButton->SetHighlightColor(GREEN_WASH);
		mod->iPickButton->SetCheck(mod->ip->GetCommandMode()->ID() == CID_PAINT &&
			((PaintMouseProc *)mod->ip->GetCommandMode()->MouseProc(&numPoints))->GetPickMode());
		mod->iPickButton->SetImage(hButtonImages, 1, 1, 1, 1, 15, 14);
		mod->iPickButton->SetTooltip(TRUE, GetString(IDS_PICK));


		mod->iColor = GetIColorSwatch(GetDlgItem(hWnd, IDC_COLOR));
		// change current Color according to editMode
		mod->reloadBkupColor();

		// Get interface For ZGradient, reload bkuped colors
		mod->iColorGradient[0] = GetIColorSwatch(GetDlgItem(hWnd, IDC_PALETTE_GRAD0));
		mod->iColorGradient[1] = GetIColorSwatch(GetDlgItem(hWnd, IDC_PALETTE_GRAD1));
		mod->iColorGradient[0]->SetColor(mod->lastGradientColor[0]);
		mod->iColorGradient[1]->SetColor(mod->lastGradientColor[1]);


		// Init comboBox
		SendDlgItemMessage(hWnd, IDC_COMBO_TYPE, CB_ADDSTRING, 0, (LPARAM)"Tree Weight");
		SendDlgItemMessage(hWnd, IDC_COMBO_TYPE, CB_ADDSTRING, 0, (LPARAM)"Phase Level 1");
		SendDlgItemMessage(hWnd, IDC_COMBO_TYPE, CB_ADDSTRING, 0, (LPARAM)"Phase Level 2");
		SendDlgItemMessage(hWnd, IDC_COMBO_TYPE, CB_SETCURSEL, mod->getEditionType(), 0);

		// If paint mode at last edit.
		if (mod->_LastPaintMode)
		{
			// ActivatePaint / check button.
			mod->ActivatePaint(TRUE);
			mod->iPaintButton->SetCheck(TRUE);
		}

		break;

	case WM_POSTINIT:
		mod->InitPalettes();
		break;

	case CC_COLOR_CHANGE:
		if (LOWORD(wParam) == IDC_COLOR)
		{
			IColorSwatch* iCol = (IColorSwatch*)lParam;
			switch (mod->getEditionType())
			{
			case 0: mod->lastWeightColor = iCol->GetColor(); break;
			case 1:
			case 2:
				mod->lastPhaseColor = iCol->GetColor(); break;
			}
		}
		break;
	case WM_DESTROY:
		mod->SavePalettes();
		mod->iPaintButton = NULL;
		mod->iPickButton = NULL;
		mod->iColor = NULL;
		mod->iColorGradient[0] = NULL;
		mod->iColorGradient[1] = NULL;
		break;

	case WM_COMMAND:
		switch (LOWORD(wParam))
		{
		case IDC_PAINT:
			mod->ActivatePaint(mod->iPaintButton->IsChecked());
			break;
		case IDC_PICK:
			mod->ActivatePaint(mod->iPickButton->IsChecked(), TRUE);
			break;

		case IDC_VC_ON:
			mod->TurnVCOn(FALSE);
			break;
		case IDC_SHADED:
			mod->TurnVCOn(TRUE);
			break;
		case IDC_COMBO_TYPE:
			// Init default type.
			comboResult = SendDlgItemMessage(hWnd, IDC_COMBO_TYPE, CB_GETCURSEL, 0, 0);
			mod->setEditionType(comboResult);
			break;
		case IDC_BUTTON_FILL:
			mod->fillSelectionColor();
			break;
		case IDC_BUTTON_GRADIENT:
			mod->fillSelectionGradientColor();
			break;
		case IDC_BUTTON_GRAD0:
			mod->iColorGradient[0]->SetColor(RGB(0, 0, 0));
			mod->iColorGradient[1]->SetColor(RGB(85, 85, 85));
			break;
		case IDC_BUTTON_GRAD1:
			mod->iColorGradient[0]->SetColor(RGB(85, 85, 85));
			mod->iColorGradient[1]->SetColor(RGB(170, 170, 170));
			break;
		case IDC_BUTTON_GRAD2:
			mod->iColorGradient[0]->SetColor(RGB(170, 170, 170));
			mod->iColorGradient[1]->SetColor(RGB(255, 255, 255));
			break;
		}
		break;

	default:
		return FALSE;
	}
	return TRUE;
}

// Subclass procedure 
LRESULT APIENTRY colorSwatchSubclassWndProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
{
	switch (uMsg)
	{
	case WM_LBUTTONDOWN:
	case WM_LBUTTONUP:
	case WM_LBUTTONDBLCLK:
	{
		HWND hPanel = GetParent(hwnd);
		LONG_PTR mod = GetWindowLongPtr(hPanel, GWLP_USERDATA);
		if (mod)
		{
			((VertexPaint*)mod)->PaletteButton(hwnd);
		}
	}
						   break;
	case WM_DESTROY:
		SetWindowLongPtr(hwnd, GWLP_WNDPROC, (LONG_PTR)colorSwatchOriginalWndProc);
		// Fallthrough...
	default:
		return CallWindowProc(colorSwatchOriginalWndProc, hwnd, uMsg, wParam, lParam);
		break;
	}
	return 0;
}


IObjParam *VertexPaint::ip = NULL;
HWND VertexPaint::hParams = NULL;
VertexPaint* VertexPaint::editMod = NULL;
ICustButton* VertexPaint::iPaintButton = NULL;
ICustButton* VertexPaint::iPickButton = NULL;
IColorSwatch* VertexPaint::iColor = NULL;
COLORREF VertexPaint::lastWeightColor = RGB(85, 85, 85);
COLORREF VertexPaint::lastPhaseColor = RGB(0, 0, 0);
COLORREF VertexPaint::palColors[] =
{
	//RGB(32,  32,  32),	RGB(  96,96,96),	RGB(  160,160,160),	RGB(224,224,224) };
	RGB(0,  0,  0),	RGB(85,85,85),	RGB(170,170,170),	RGB(255,255,255),
		 RGB(42,  42,  42), RGB(127, 127, 127), RGB(212, 212, 212) };


IColorSwatch* VertexPaint::iColorGradient[] = { NULL, NULL };
COLORREF VertexPaint::lastGradientColor[] = { RGB(0,  0,  0), RGB(85,  85,  85) };


//--- VertexPaint -------------------------------------------------------
VertexPaint::VertexPaint() : iTint(NULL), fTint(1.0f), iGradientBend(NULL), fGradientBend(0.0f)
{
	flags = 0x0;
	_EditType = 0;
	_LastPaintMode = false;
}

VertexPaint::~VertexPaint()
{
}

Interval VertexPaint::LocalValidity(TimeValue t)
{
	return FOREVER;
}

BOOL VertexPaint::DependOnTopology(ModContext &mc)
{
	return TRUE;
}

RefTargetHandle VertexPaint::Clone(RemapDir& remap)
{
	VertexPaint* newmod = new VertexPaint();
	return(newmod);
}

void VertexPaint::NotifyInputChanged(Interval changeInt, PartID partID, RefMessage message, ModContext *mc)
{
	if (!mc->localData) return;
	((VertexPaintData*)mc->localData)->FreeCache();

}

void VertexPaint::ModifyObject(TimeValue t, ModContext &mc, ObjectState * os, INode *node)
{
	if (!os->obj->IsSubClassOf(triObjectClassID)) return;

	os->obj->ReadyChannelsForMod(GEOM_CHANNEL | TOPO_CHANNEL | VERTCOLOR_CHANNEL | TEXMAP_CHANNEL);

	TriObject *tobj = (TriObject*)os->obj;
	VertexPaintData *d = (VertexPaintData*)mc.localData;

	Mesh* mesh = &tobj->GetMesh();

	if (mesh)
	{
		// We don't have any VColors yet, so we allocate the vcfaces
		// and set all vcolors to black (index 0)

		if (!mesh->vcFace)
		{
			mesh->setNumVCFaces(mesh->getNumFaces());
			mesh->setNumVertCol(1);

			mesh->vertCol[0] = Color(0, 0, 0);

			for (int f = 0; f < mesh->getNumFaces(); f++)
			{
				mesh->vcFace[f].t[0] = 0;
				mesh->vcFace[f].t[1] = 0;
				mesh->vcFace[f].t[2] = 0;
			}
		}

		if (!d) mc.localData = d = new VertexPaintData(tobj->GetMesh());
		if (!d->GetMesh()) d->SetCache(*mesh);


		{
			MeshDelta md(*mesh);
			//MeshDelta mdc;
			//if(cache) mdc.InitToMesh(*cache);

			// If the incoming Mesh had no vertex colors, this will add a default map to start with.
			// The default map has the same topology as the Mesh (so one color per vertex),
			// with all colors set to white.
			if (!mesh->mapSupport(0)) md.AddVertexColors();
			//if (cache && !cache->mapSupport(0)) mdc.AddVertexColors ();

			// We used two routines -- VCreate to add new map vertices, and FRemap to make the
			// existing map faces use the new verts.  frFlags tell FRemap which vertices on a face
			// should be "remapped", and the ww array contains the new locations.			
			VertColor nvc;
			int j;
			for (int v = 0; v < d->GetNumColors(); v++)
			{
				ColorData cd = d->GetColorData(v);

				// Edition Mode ??
				if (editMod == this)
				{
					nvc = Color(cd.color);
					// change color to view only monochromatic info for this channel;
					switch (_EditType)
					{
					case 0: nvc.y = nvc.z = nvc.x;
						nvc.y *= 0.7f;
						nvc.z *= 0.7f;
						break;
					case 1: nvc.x = nvc.z = nvc.y;
						nvc.x *= 0.7f;
						nvc.z *= 0.7f;
						break;
					case 2: nvc.x = nvc.y = nvc.z;
						nvc.x *= 0.7f;
						nvc.y *= 0.7f;
						break;
					}
				}
				else
				{
					// replace the VertexColor of the outgoing mesh
					nvc = Color(cd.color);
				}

				DWORD ww[3], frFlags;

				md.map->VCreate(&nvc);

				// increase the number of vcol's and set the vcfaces as well	
				for (int i = 0; i < d->GetNVert(v).faces.Count(); i++)
				{
					j = d->GetNVert(v).whichVertex[i];
					frFlags = (1 << j);
					ww[j] = md.map->outVNum() - 1;
					md.map->FRemap(d->GetNVert(v).faces[i], frFlags, ww);

				}
			}

			md.Apply(*mesh);
		}


		NotifyDependents(FOREVER, PART_VERTCOLOR, REFMSG_CHANGE);
		os->obj->UpdateValidity(VERT_COLOR_CHAN_NUM, Interval(t, t));
	}
}

static bool oldShowEnd;

void VertexPaint::BeginEditParams(IObjParam *ip, ULONG flags, Animatable *prev)
{

	this->ip = ip;
	editMod = this;
	if (!hParams)
	{
		hParams = ip->AddRollupPage(hInstance, MAKEINTRESOURCE(IDD_PANEL), VertexPaintDlgProc, GetString(IDS_PARAMS), (LPARAM)this);

		// Subclass the palette controls
		hPaletteWnd[0] = GetDlgItem(hParams, IDC_PALETTE_1);
		hPaletteWnd[1] = GetDlgItem(hParams, IDC_PALETTE_2);
		hPaletteWnd[2] = GetDlgItem(hParams, IDC_PALETTE_3);
		hPaletteWnd[3] = GetDlgItem(hParams, IDC_PALETTE_4);
		hPaletteWnd[4] = GetDlgItem(hParams, IDC_PALETTE_5);
		hPaletteWnd[5] = GetDlgItem(hParams, IDC_PALETTE_6);
		hPaletteWnd[6] = GetDlgItem(hParams, IDC_PALETTE_7);

		int	i;
		for (i = 0; i < NUMPALETTES; i++)
		{
			colorSwatchOriginalWndProc = (WNDPROC)SetWindowLongPtr(hPaletteWnd[i], GWLP_WNDPROC, (LONG_PTR)colorSwatchSubclassWndProc);
		}

		SendMessage(hParams, WM_POSTINIT, 0, 0);
	}
	else
	{
		SetWindowLongPtr(hParams, GWLP_USERDATA, (LONG_PTR)this);
	}

	iTint = SetupIntSpinner(hParams, IDC_TINT_SPIN, IDC_TINT, 0, 100, (int)(fTint*100.0f));

	// Init Gradient Bend spinner
	iGradientBend = SetupIntSpinner(hParams, IDC_BEND_SPIN, IDC_BEND, 0, 100, (int)(fGradientBend*100.0f));


	// Set show end result.
	oldShowEnd = ip->GetShowEndResult() ? TRUE : FALSE;
	ip->SetShowEndResult(GetFlag(VP_DISP_END_RESULT));

	// Force an eval to update caches.
	NotifyDependents(FOREVER, PART_VERTCOLOR, REFMSG_CHANGE);
}

void VertexPaint::EndEditParams(IObjParam *ip, ULONG flags, Animatable *next)
{
	// Dsiable Painting.
	bool	lpm = _LastPaintMode;
	ActivatePaint(FALSE);
	// bkup lastPainMode
	_LastPaintMode = lpm;

	ReleaseISpinner(iTint);
	ReleaseISpinner(iGradientBend);

	ModContextList list;
	INodeTab nodes;
	ip->GetModContexts(list, nodes);
	for (int i = 0; i < list.Count(); i++)
	{
		VertexPaintData *vd = (VertexPaintData*)list[i]->localData;
		if (vd) vd->FreeCache();
	}
	nodes.DisposeTemporary();

	// Reset show end result
	SetFlag(VP_DISP_END_RESULT, ip->GetShowEndResult() ? TRUE : FALSE);
	ip->SetShowEndResult(oldShowEnd);


	// Exit editMod => draw true colored weights.
	editMod = NULL;
	NotifyDependents(FOREVER, PART_VERTCOLOR, REFMSG_CHANGE);


	ip->DeleteRollupPage(hParams);
	hParams = NULL;
	iTint = NULL;
	iGradientBend = NULL;
	this->ip = NULL;
}


//From ReferenceMaker 
RefResult VertexPaint::NotifyRefChanged(const Interval& changeInt, RefTargetHandle hTarget, PartID& partID, RefMessage message, BOOL propagate)
{
	return REF_SUCCEED;
}

int VertexPaint::NumRefs()
{
	return 0;
}

RefTargetHandle VertexPaint::GetReference(int i)
{
	return NULL;
}

void VertexPaint::SetReference(int i, RefTargetHandle rtarg)
{
}

int VertexPaint::NumSubs()
{
	return 0;
}

Animatable* VertexPaint::SubAnim(int i)
{
	return NULL;
}

TSTR VertexPaint::SubAnimName(int i)
{
	return _T("");
}


#define VERSION_CHUNKID			0x100
#define COLORLIST_CHUNKID		0x120

static int currentVersion = 1;

IOResult VertexPaint::Load(ILoad *iload)
{
	IOResult res;
	ULONG nb;
	int version = 1;
	Modifier::Load(iload);

	while (IO_OK == (res = iload->OpenChunk()))
	{
		switch (iload->CurChunkID())
		{
		case VERSION_CHUNKID:
			iload->Read(&version, sizeof(version), &nb);
			break;
		}
		iload->CloseChunk();
		if (res != IO_OK) return res;
	}

	return IO_OK;
}

IOResult VertexPaint::Save(ISave *isave)
{
	IOResult res;
	ULONG nb;

	Modifier::Save(isave);

	isave->BeginChunk(VERSION_CHUNKID);
	res = isave->Write(&currentVersion, sizeof(int), &nb);
	isave->EndChunk();

	return IO_OK;
}

IOResult VertexPaint::SaveLocalData(ISave *isave, LocalModData *ld)
{
	VertexPaintData*	d = (VertexPaintData*)ld;
	IOResult	res;
	ULONG		nb;
	int			numColors;
	ColorData	col;

	isave->BeginChunk(VERSION_CHUNKID);
	res = isave->Write(&currentVersion, sizeof(int), &nb);
	isave->EndChunk();

	isave->BeginChunk(COLORLIST_CHUNKID);
	numColors = d->GetNumColors();
	res = isave->Write(&numColors, sizeof(int), &nb);
	for (int i = 0; i < numColors; i++)
	{
		col = d->GetColorData(i);
		isave->Write(&col.color, sizeof(col.color), &nb);
	}

	isave->EndChunk();
	return IO_OK;
}

IOResult VertexPaint::LoadLocalData(ILoad *iload, LocalModData **pld)
{
	VertexPaintData *d = new VertexPaintData;
	IOResult	res;
	ULONG		nb;
	int			version = 1;
	int			numColors;
	ColorData	col;

	*pld = d;

	while (IO_OK == (res = iload->OpenChunk()))
	{
		switch (iload->CurChunkID())
		{
		case VERSION_CHUNKID:
			iload->Read(&version, sizeof(version), &nb);
			break;
		case COLORLIST_CHUNKID:
		{
			iload->Read(&numColors, sizeof(int), &nb);
			d->AllocColorData(numColors);
			for (int i = 0; i < numColors; i++)
			{
				iload->Read(&col.color, sizeof(col.color), &nb);
				d->SetColor(i, col);
			}
		}
		break;
		}
		iload->CloseChunk();
		if (res != IO_OK) return res;
	}
	return IO_OK;
}

void VertexPaint::PaletteButton(HWND hWnd)
{
	IColorSwatch* iPal = GetIColorSwatch(hWnd);
	if (iPal && iColor)
	{
		iColor->SetColor(iPal->GetColor(), TRUE);
	}
}

void VertexPaint::InitPalettes()
{
	IColorSwatch* c;
	for (int i = 0; i < NUMPALETTES; i++)
	{
		c = GetIColorSwatch(hPaletteWnd[i]);
		c->SetColor(palColors[i]);
		ReleaseIColorSwatch(c);
	}
}

void VertexPaint::SavePalettes()
{
	IColorSwatch* c;
	for (int i = 0; i < NUMPALETTES; i++)
	{
		c = GetIColorSwatch(hPaletteWnd[i]);
		palColors[i] = c->GetColor();
		ReleaseIColorSwatch(c);
	}
	// Save Gradient Palettes.
	lastGradientColor[0] = iColorGradient[0]->GetColor();
	lastGradientColor[1] = iColorGradient[1]->GetColor();
}

void VertexPaint::TurnVCOn(BOOL shaded)
{
	ModContextList list;
	INodeTab NodeTab;

	// Only the selected nodes will be affected
	ip->GetModContexts(list, NodeTab);

	for (int i = 0; i < NodeTab.Count(); i++)
	{
		if (shaded)
			NodeTab[i]->SetShadeCVerts(!NodeTab[i]->GetShadeCVerts());
		else
			NodeTab[i]->SetCVertMode(!NodeTab[i]->GetCVertMode());

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


// *****************************************************************
void	VertexPaint::setEditionType(int editMode)
{
	if (editMode < 0)	editMode = 0;
	if (editMode > 2)	editMode = 2;

	// backup current Color according to editMode
	backupCurrentColor();

	_EditType = editMode;

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

	// Change Color Swatch according to editMode.
	IColorSwatch* c;
	for (int i = 0; i < NUMPALETTES; i++)
	{
		// Change palColors[i].
		int	val;
		if (editMode == 0)
			val = i * 255 / (4 - 1);		// 0, 85, 170, 255
		else
			val = (i * 256 + 128) / 4;		// 32, 96, 160, 224
		// Change Addditional Palette colors.
		if (i >= 4)
		{
			if (editMode == 0)
				val = 42 + (i - 4) * 255 / (4 - 1);	// 42, 127, 212
			else
				val = 0;		// Phase not used
		}
		// Setup Color
		palColors[i] = RGB(val, val, val);


		c = GetIColorSwatch(hPaletteWnd[i]);
		c->SetColor(palColors[i]);
		ReleaseIColorSwatch(c);
	}

	// change current Color according to editMode
	reloadBkupColor();
}

// *****************************************************************
void	VertexPaint::backupCurrentColor()
{
	switch (getEditionType())
	{
	case 0: lastWeightColor = iColor->GetColor(); break;
	case 1:
	case 2: lastPhaseColor = iColor->GetColor(); break;
	}
}
void	VertexPaint::reloadBkupColor()
{
	// Change current color according to editMode.
	switch (getEditionType())
	{
	case 0: iColor->SetColor(lastWeightColor); break;
	case 1:
	case 2: iColor->SetColor(lastPhaseColor); break;
	}
}


// *****************************************************************
void	VertexPaint::fillSelectionColor()
{
	int		mci;

	// Put Data in Undo/Redo List.
	if (!theHold.Holding())
		theHold.Begin();

	ModContextList	modContexts;
	INodeTab		nodeTab;

	GetCOREInterface()->GetModContexts(modContexts, nodeTab);

	for (mci = 0; mci < modContexts.Count(); mci++)
	{
		ModContext *mc = modContexts[mci];
		if (mc && mc->localData)
			theHold.Put(new VertexPaintRestore((VertexPaintData*)mc->localData, this));
	}

	theHold.Accept(GetString(IDS_RESTORE_FILL));


	// Which Component to change??
	VertexPaintData::TComponent	whichComponent;
	switch (getEditionType())
	{
	case 0: whichComponent = VertexPaintData::Red; break;
	case 1: whichComponent = VertexPaintData::Green; break;
	case 2: whichComponent = VertexPaintData::Blue; break;
	}


	// Modify all meshes.
	for (mci = 0; mci < modContexts.Count(); mci++)
	{
		ModContext *mc = modContexts[mci];
		if (mc && mc->localData)
		{
			VertexPaintData* d = (VertexPaintData*)mc->localData;
			Mesh*		mesh = d->GetMesh();
			if (mesh && mesh->vertCol)
			{
				// For all faces of the mesh
				for (int fi = 0; fi < mesh->getNumFaces(); fi++)
				{
					Face* f = &mesh->faces[fi];

					for (int i = 0; i < 3; i++)
					{
						// Skip painting because not selected??
						if (mesh->selLevel == MESH_VERTEX && !mesh->VertSel()[f->v[i]])
							continue;
						if (mesh->selLevel == MESH_FACE && !mesh->FaceSel()[fi])
							continue;
						// Also skip if face is hidden.
						if (f->Hidden())
							continue;

						// Apply painting
						d->SetColor(f->v[i], 1, GetActiveColor(), whichComponent);
					}
				}
			}
		}
	}

	// refresh
	NotifyDependents(FOREVER, PART_VERTCOLOR, REFMSG_CHANGE);
	ip->RedrawViews(ip->GetTime());
}

// *****************************************************************
void	VertexPaint::fillSelectionGradientColor()
{
	int		mci;

	// Put Data in Undo/Redo List.
	if (!theHold.Holding())
		theHold.Begin();

	ModContextList	modContexts;
	INodeTab		nodeTab;

	GetCOREInterface()->GetModContexts(modContexts, nodeTab);

	for (mci = 0; mci < modContexts.Count(); mci++)
	{
		ModContext *mc = modContexts[mci];
		if (mc && mc->localData)
			theHold.Put(new VertexPaintRestore((VertexPaintData*)mc->localData, this));
	}

	theHold.Accept(GetString(IDS_RESTORE_GRADIENT));


	// Which Component to change??
	VertexPaintData::TComponent	whichComponent;
	switch (getEditionType())
	{
	case 0: whichComponent = VertexPaintData::Red; break;
	case 1: whichComponent = VertexPaintData::Green; break;
	case 2: whichComponent = VertexPaintData::Blue; break;
	}
	COLORREF	grad0 = iColorGradient[0]->GetColor();
	COLORREF	grad1 = iColorGradient[1]->GetColor();


	// Get Matrix to viewport.
	Matrix3		viewMat;
	{
		ViewExp *ve = GetCOREInterface()->GetActiveViewport();
		// The affine TM transforms from world coords to view coords
		ve->GetAffineTM(viewMat);
		GetCOREInterface()->ReleaseViewport(ve);
	}


	// Modify all meshes.
	for (mci = 0; mci < modContexts.Count(); mci++)
	{
		ModContext *mc = modContexts[mci];
		if (mc && mc->localData)
		{
			VertexPaintData* d = (VertexPaintData*)mc->localData;
			Mesh*		mesh = d->GetMesh();
			if (mesh && mesh->vertCol)
			{
				float	yMini = FLT_MAX;
				float	yMaxi = -FLT_MAX;

				// 1st, For all faces of the mesh, comute BBox of selection.
				int fi;
				for (fi = 0; fi < mesh->getNumFaces(); fi++)
				{
					Face* f = &mesh->faces[fi];

					for (int i = 0; i < 3; i++)
					{
						// Skip painting because not selected??
						if (mesh->selLevel == MESH_VERTEX && !mesh->VertSel()[f->v[i]])
							continue;
						if (mesh->selLevel == MESH_FACE && !mesh->FaceSel()[fi])
							continue;
						// Also skip if face is hidden.
						if (f->Hidden())
							continue;

						// Transform to viewSpace.
						Point3	p = viewMat*mesh->getVert(f->v[i]);
						// extend bbox.
						yMini = p.y < yMini ? p.y : yMini;
						yMaxi = p.y > yMaxi ? p.y : yMaxi;
					}
				}

				// 2nd, For all faces of the mesh, fill with gradient
				for (fi = 0; fi < mesh->getNumFaces(); fi++)
				{
					Face* f = &mesh->faces[fi];

					for (int i = 0; i < 3; i++)
					{
						// Skip painting because not selected??
						if (mesh->selLevel == MESH_VERTEX && !mesh->VertSel()[f->v[i]])
							continue;
						if (mesh->selLevel == MESH_FACE && !mesh->FaceSel()[fi])
							continue;
						// Also skip if face is hidden.
						if (f->Hidden())
							continue;

						// Compute gradientValue.
						float	gradValue;
						Point3	p = viewMat*mesh->getVert(f->v[i]);
						gradValue = (p.y - yMini) / (yMaxi - yMini);
						// Modifie with bendPower. 1->6.
						float	pow = 1 + fGradientBend * 5;
						gradValue = powf(gradValue, pow);

						// Apply painting
						// Reset To 0.
						d->SetColor(f->v[i], 1, grad0, whichComponent);
						// Blend with gradientValue.
						d->SetColor(f->v[i], gradValue, grad1, whichComponent);
					}
				}

			}
		}
	}

	// refresh
	NotifyDependents(FOREVER, PART_VERTCOLOR, REFMSG_CHANGE);
	ip->RedrawViews(ip->GetTime());
}


// *****************************************************************
VertexPaintData::VertexPaintData(Mesh& m) : mesh(NULL), colordata(NULL), nverts(NULL),
nvcverts(NULL), numColors(0), numnverts(0), numnvcverts(0)
{
	SetCache(m);
}

VertexPaintData::VertexPaintData() : mesh(NULL), colordata(NULL), nverts(NULL),
nvcverts(NULL), numColors(0), numnverts(0), numnvcverts(0)
{

}

VertexPaintData::~VertexPaintData()
{
	FreeCache();

	if (colordata) delete[] colordata;
	if (nverts) delete[] nverts;
	if (nvcverts) delete[] nvcverts;

	nverts = NULL;
	nvcverts = NULL;
	colordata = NULL;

	numColors = 0;
	numnverts = 0;
	numnvcverts = 0;
}

void VertexPaintData::SetCache(Mesh& m)
{
	FreeCache();
	mesh = new Mesh(m);
	SynchVerts(m);
	AllocColorData(mesh->getNumVerts());

}

void VertexPaintData::FreeCache()
{
	if (mesh) delete mesh;
	if (nverts) delete[] nverts;
	if (nvcverts) delete[] nvcverts;

	mesh = NULL;
	nverts = NULL;
	nvcverts = NULL;
	numnverts = 0;
	numnvcverts = 0;
}

Mesh* VertexPaintData::GetMesh()
{
	return mesh;
}

NVert&  VertexPaintData::GetNVert(int i)
{
	static NVert nv;

	if (numnverts > i)
		return nverts[i];
	else
		return nv;
}

NVert& VertexPaintData::GetNVCVert(int i)
{
	static NVert nv;

	if (numnvcverts > i)
		return nvcverts[i];
	else
		return nv;
}

COLORREF& VertexPaintData::GetColor(int i)
{
	static COLORREF c = RGB(0, 0, 0);
	if (numColors > i)
		return colordata[i].color;
	else
		return c;
}

ColorData& VertexPaintData::GetColorData(int i)
{
	static ColorData c;

	if (numColors > i)
		return colordata[i];
	else
		return c;
}

void VertexPaintData::SetColor(int i, float bary, COLORREF c, TComponent whichComp)
{

	if (colordata && numColors > i)
	{
		// change color.
		COLORREF	oldColor = colordata[i].color;
		int			oldVal;
		int			editVal;
		int			newVal;

		// Mask good component.
		switch (whichComp)
		{
		case  Red:
			oldVal = GetRValue(colordata[i].color);
			editVal = GetRValue(c);
			break;
		case  Green:
			oldVal = GetGValue(colordata[i].color);
			editVal = GetGValue(c);
			break;
		case  Blue:
			oldVal = GetBValue(colordata[i].color);
			editVal = GetBValue(c);
			break;
		}

		// Blend Color component
		// This color was set before !
		float alpha = (1.0f - bary);

		// Compute new value
		newVal = (int)(alpha*oldVal + bary*editVal);

		// Mask good component.
		switch (whichComp)
		{
		case  Red:
			colordata[i].color = (RGB(newVal, 0, 0)) | (oldColor & RGB(0, 255, 255));
			break;
		case  Green:
			colordata[i].color = (RGB(0, newVal, 0)) | (oldColor & RGB(255, 0, 255));
			break;
		case  Blue:
			colordata[i].color = (RGB(0, 0, newVal)) | (oldColor & RGB(255, 255, 0));
			break;
		}

	}
}

void VertexPaintData::SetColor(int i, const ColorData &c)
{
	if (colordata && numColors > i)
	{
		colordata[i] = c;
	}
}

int VertexPaintData::GetNumColors()
{
	return numColors;
}

void VertexPaintData::AllocColorData(int numcols)
{
	ColorData* newColorData;

	// Colors already exist.
	if (numColors == numcols)
		return;

	if (numColors > 0)
	{
		// If the new number of colors is bigger than what we have in the colordata array
		if (numcols > numColors)
		{
			// Allocate a new color list and fill in as many as
			// we have from the previous set
			newColorData = new ColorData[numcols];

			for (int i = 0; i < numcols; i++)
			{
				if (i < numColors)
				{
					newColorData[i] = colordata[i];
				}
			}
			delete[] colordata;

			colordata = newColorData;

			numColors = numcols;

		}
		else
		{
			numColors = numcols;
		}
	}
	else
	{
		// Allocate a complete new set of colors
		numColors = numcols;
		colordata = new ColorData[numColors];
	}
}

LocalModData* VertexPaintData::Clone()
{
	VertexPaintData* d = new VertexPaintData();

	if (colordata)
	{
		d->colordata = new ColorData[numColors];
		d->numColors = numColors;
		for (int i = 0; i < numColors; i++)
		{
			d->colordata[i] = colordata[i];
		}
	}
	if (nverts)
	{
		d->nverts = new NVert[numnverts];
		for (int i = 0; i < numnverts; i++)
		{
			d->nverts[i] = nverts[i];
		}

	}
	if (nvcverts)
	{
		d->nvcverts = new NVert[numnvcverts];
		for (int i = 0; i < numnvcverts; i++)
		{
			d->nvcverts[i] = nvcverts[i];
		}

	}

	return d;
}

void VertexPaintData::SynchVerts(Mesh &m)
{
	if (mesh == NULL)
	{
		nlwarning("mesh == NULL");
		return;
	}

	if (nverts)
		delete[] nverts;

	numnverts = m.getNumVerts();

	nverts = new NVert[numnverts];

	if (nvcverts)
		delete[] nvcverts;

	numnvcverts = m.getNumVertCol();

	nvcverts = new NVert[numnvcverts];

	for (int i = 0; i < mesh->getNumFaces(); i++)
	{
		// for each vertex of each face
		for (int j = 0; j < 3; j++)
		{
			int iCur = nverts[mesh->faces[i].v[j]].faces.Count();

			// Tell the vertex, which to which face it belongs and which 
			// of the three face v-indices corresponds to the vertex

			nverts[mesh->faces[i].v[j]].faces.SetCount(iCur + 1);
			nverts[mesh->faces[i].v[j]].whichVertex.SetCount(iCur + 1);

			nverts[mesh->faces[i].v[j]].faces[iCur] = i;
			nverts[mesh->faces[i].v[j]].whichVertex[iCur] = j;


			if (mesh->vcFace)
			{
				// Do the same for texture vertices
				iCur = nvcverts[mesh->vcFace[i].t[j]].faces.Count();

				nvcverts[mesh->vcFace[i].t[j]].faces.SetCount(iCur + 1);
				nvcverts[mesh->vcFace[i].t[j]].whichVertex.SetCount(iCur + 1);

				nvcverts[mesh->vcFace[i].t[j]].faces[iCur] = i;
				nvcverts[mesh->vcFace[i].t[j]].whichVertex[iCur] = j;

			}
			else
				nlassert(0);
		}
	}
}


//***************************************************************************
//**
//** NVert
//**
//***************************************************************************



NVert::NVert()
{
	faces.SetCount(0);
	whichVertex.SetCount(0);
}

NVert& NVert::operator= (NVert &nvert)
{
	faces = nvert.faces;
	whichVertex = nvert.whichVertex;
	return *this;
}

//***************************************************************************
//**
//** ColorData 
//**
//***************************************************************************


ColorData::ColorData(DWORD col) : color(col)
{
}

ColorData::ColorData() : color(0)
{
}

//***************************************************************************
//**
//** VertexPaintRestore : public RestoreObj
//**
//***************************************************************************

VertexPaintRestore::VertexPaintRestore(VertexPaintData *pLocalData, VertexPaint *pVPaint)
	: pMod(pVPaint), pPaintData(pLocalData), redoColordata(NULL)
{
	colordata = new ColorData[pPaintData->numColors];
	for (int i = 0; i < pPaintData->numColors; i++)
	{
		colordata[i] = pPaintData->colordata[i];
	}
	numcolors = pPaintData->numColors;

}

VertexPaintRestore::~VertexPaintRestore()
{
	if (colordata)
		delete[] colordata;

	if (redoColordata)
		delete[] redoColordata;
}

void VertexPaintRestore::Restore(int isUndo)
{
	if (isUndo)
	{
		nlassert(pPaintData->colordata);

		redoColordata = pPaintData->colordata;
		redonumcolors = pPaintData->numColors;

		pPaintData->colordata = colordata;
		pPaintData->numColors = numcolors;

		colordata = NULL;

		pMod->NotifyDependents(FOREVER, PART_VERTCOLOR, REFMSG_CHANGE);
		GetCOREInterface()->RedrawViews(GetCOREInterface()->GetTime());
	}
}

void VertexPaintRestore::Redo()
{
	nlassert(pPaintData->colordata);

	colordata = pPaintData->colordata;
	numcolors = pPaintData->numColors;

	pPaintData->colordata = redoColordata;
	pPaintData->numColors = redonumcolors;

	redoColordata = NULL;

	pMod->NotifyDependents(FOREVER, PART_VERTCOLOR, REFMSG_CHANGE);
	GetCOREInterface()->RedrawViews(GetCOREInterface()->GetTime());

}

int  VertexPaintRestore::Size()
{
	int iSize = 0;

	if (colordata)
		iSize += sizeof(ColorData) * numcolors;

	if (redoColordata)
		iSize += sizeof(ColorData) * redonumcolors;

	return iSize;
}