/*==LICENSE==*

CyanWorlds.com Engine - MMOG client, server and tools
Copyright (C) 2011  Cyan Worlds, Inc.

This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program.  If not, see <http://www.gnu.org/licenses/>.

You can contact Cyan Worlds, Inc. by email legal@cyan.com
 or by snail mail at:
      Cyan Worlds, Inc.
      14617 N Newport Hwy
      Mead, WA   99021

*==LICENSE==*/
#include "plMaterialUpdate.h"

#define MAXR3
#define MAXR4

//#include "OldMat/hsMaxMtl.h"
#include "OldMat/hsMaxLayer.h"

#include "../MaxPlasmaMtls/Layers/plLayerTex.h"
#include "../MaxPlasmaMtls/Layers/plLayerTexBitmapPB.h"

#include "../MaxPlasmaMtls/Materials/plPassMtl.h"
#include "../MaxPlasmaMtls/Materials/plPassMtlBase.h"
#include "../MaxPlasmaMtls/Materials/plPassMtlBasicPB.h"
#include "../MaxPlasmaMtls/Materials/plPassMtlAdvPB.h"
#include "../MaxPlasmaMtls/Materials/plPassMtlLayersPB.h"

#include "../MaxExport/plExportProgressBar.h"

#define PLMATERIALUPDATE_CLASS_ID	Class_ID(0x70acddfe, 0x68f42f3f)

#include <map>

class plMaterialUpdate : public UtilityObj
{
protected:
	HWND		fhPanel;
	Interface	*fInterface;
	std::map<MtlBase*, MtlBase*> fDoneMaterials;
	bool fConvertSecondLayer;

	plMaterialUpdate();

public:
	static plMaterialUpdate &Instance();

	~plMaterialUpdate();
	void DeleteThis() {}

	void BeginEditParams(Interface *ip,IUtil *iu);
	void EndEditParams(Interface *ip,IUtil *iu);

	bool ConvertAllMtls(INode *node, plExportProgressBar *bar);

protected:
	static BOOL CALLBACK DlgProc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam);

	void IRenameMtls(MtlBase *oldMtl, MtlBase *newMtl);

	void IConvert(INode *node);
	plPassMtl *IConvertMtl(Mtl *mtl, Mtl *multi=NULL, int subNum=-1);
	plLayerTex *IConvertLayer(hsMaxLayer *layer);

	void ICopyMtlParams(plPassMtl *mtl, hsMaxLayer *layer);
};

class plMaterialUpdateClassDesc:public ClassDesc2 {
	public:
	int 			IsPublic() { return TRUE; }
	void *			Create(BOOL loading = FALSE) { return &plMaterialUpdate::Instance(); }
	const TCHAR *	ClassName() { return "Plasma Material Converter"; }
	SClass_ID		SuperClassID() { return UTILITY_CLASS_ID; }
	Class_ID		ClassID() { return PLMATERIALUPDATE_CLASS_ID; }
	const TCHAR* 	Category() { return GetString(IDS_CATEGORY); }

	const TCHAR*	InternalName() { return _T("plMaterialConverter"); }	// returns fixed parsable name (scripter-visible name)
	HINSTANCE		HInstance() { return hInstance; }				// returns owning module handle
};

static plMaterialUpdateClassDesc plMaterialUpdateDesc;
ClassDesc2* GetMaterialUpdateDesc() { return &plMaterialUpdateDesc; }

plMaterialUpdate &plMaterialUpdate::Instance()
{
	static plMaterialUpdate theInstance;
	return theInstance;
}

plMaterialUpdate::plMaterialUpdate() : fInterface(NULL), fhPanel(NULL), fConvertSecondLayer(false)
{
}

plMaterialUpdate::~plMaterialUpdate()
{
}

BOOL plMaterialUpdate::DlgProc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam)
{
	switch (msg)
	{
	case WM_COMMAND:
		if (LOWORD(wParam) == IDC_BUTTON1 && HIWORD(wParam) == BN_CLICKED)
		{
			plMaterialUpdate &p = Instance();

			plExportProgressBar bar;
			bar.Start("Convert Materials");

			if (IsDlgButtonChecked(hWnd, IDC_CHECK1) == BST_CHECKED)
				p.fConvertSecondLayer = true;

			p.ConvertAllMtls(p.fInterface->GetRootNode(), &bar);

			p.fInterface->RedrawViews(p.fInterface->GetTime());
			p.fDoneMaterials.clear();
			return TRUE;
		}
		break;
	}

	return FALSE;
}

void plMaterialUpdate::BeginEditParams(Interface *ip, IUtil *iu) 
{
	fInterface = ip;
	fhPanel = fInterface->AddRollupPage(
		hInstance,
		MAKEINTRESOURCE(IDD_PANEL),
		DlgProc,
		GetString(IDS_PARAMS),
		0);
}
	
void plMaterialUpdate::EndEditParams(Interface *ip, IUtil *iu) 
{
	fInterface->DeleteRollupPage(fhPanel);
	fInterface = NULL;
	fhPanel = NULL;
}

bool plMaterialUpdate::ConvertAllMtls(INode *node, plExportProgressBar *bar)
{
	IConvert(node);

	bool cancel = bar->Update();
	if (cancel)
		return false;

	for (int i = 0; i < node->NumChildren(); i++)
	{
		if (!ConvertAllMtls(node->GetChildNode(i), bar))
			return false;
	}
	
	return true;
}

void plMaterialUpdate::IConvert(INode *node)
{
	Mtl *mtl = node->GetMtl();
	if (!mtl)
		return;

	if (mtl->ClassID() == hsMaxMtlClassID)
	{
		plPassMtl *pass = IConvertMtl(mtl);
		node->SetMtl(pass);
	}
	else if (mtl->ClassID() == Class_ID(MULTI_CLASS_ID,0))
	{
		for (int i = 0; i < mtl->NumSubMtls(); i++)
		{
			Mtl *subMtl = mtl->GetSubMtl(i);
			if (subMtl->ClassID() == hsMaxMtlClassID)
			{
				plPassMtl *pass = IConvertMtl(subMtl, mtl, i);
				mtl->SetSubMtl(i, pass);
			}
		}
	}
}

void plMaterialUpdate::IRenameMtls(MtlBase *oldMtl, MtlBase *newMtl)
{
	char buf[256];
	const char *name = oldMtl->GetName();
	newMtl->SetName(name);
	strcpy(buf, name);
	strcat(buf, " old");
	oldMtl->SetName(buf);
}

plPassMtl *plMaterialUpdate::IConvertMtl(Mtl *mtl, Mtl *multi, int subNum)
{
	// We've already converted this material, use the new one we already made
	if (fDoneMaterials.find(mtl) != fDoneMaterials.end())
		return (plPassMtl*)fDoneMaterials[mtl];

	plPassMtl *newMtl = (plPassMtl*)CreateInstance(MATERIAL_CLASS_ID, PASS_MTL_CLASS_ID);
	IParamBlock2 *layersPB = newMtl->GetParamBlockByID(plPassMtl::kBlkLayers);

	IRenameMtls(mtl, newMtl);

	if (mtl->NumSubTexmaps() > 0)
	{
		Texmap *map = mtl->GetSubTexmap(0);
		if (map->ClassID() == hsMaxLayerClassID)
		{
			plLayerTex *layer = IConvertLayer((hsMaxLayer*)map);

//			layer->SetMtlFlag(MTL_TEX_DISPLAY_ENABLED, TRUE);
//			layer->ActivateTexDisplay(TRUE);
			
			newMtl->SetSubTexmap(0, layer);
/*			newMtl->SetActiveTexmap(layer);
			newMtl->SetMtlFlag(MTL_TEX_DISPLAY_ENABLED, TRUE);

			if (multi)
				GetCOREInterface()->ActivateTexture(layer, multi, subNum);
			else
				GetCOREInterface()->ActivateTexture(layer, newMtl);
*/
			ICopyMtlParams(newMtl, (hsMaxLayer*)map);
		}
	}

	if (mtl->NumSubTexmaps() > 1 && fConvertSecondLayer && mtl->SubTexmapOn(1))
	{
		Texmap *map = mtl->GetSubTexmap(1);
		if (map->ClassID() == hsMaxLayerClassID)
		{
			hsMaxLayer *oldLayer = (hsMaxLayer*)map;
			plLayerTex *layer = IConvertLayer(oldLayer);
			newMtl->SetSubTexmap(1, layer);

			IParamBlock2 *layersPB = newMtl->GetParamBlockByID(plPassMtl::kBlkLayers);
			layersPB->SetValue(kPassLayTopOn, 0, TRUE);

			if (oldLayer->GetBlendFlags() & hsMaxLayerBase::kBlendAlpha)
				layersPB->SetValue(kPassLayBlend, 0, plPassMtlBase::kBlendAlpha);
			else if (oldLayer->GetBlendFlags() & hsMaxLayerBase::kBlendAdd)
				layersPB->SetValue(kPassLayBlend, 0, plPassMtlBase::kBlendAdd);
		}
	}

//MtlBaseLib& Interface::GetMaterialLibrary()
	
	// Add this to our converted materials
	fDoneMaterials[mtl] = newMtl;
		
	return newMtl;
}

plLayerTex *plMaterialUpdate::IConvertLayer(hsMaxLayer *layer)
{
	plLayerTex *newLayer = (plLayerTex*)CreateInstance(TEXMAP_CLASS_ID, LAYER_TEX_CLASS_ID);
	IParamBlock2 *bitmapPB = newLayer->GetParamBlockByID(plLayerTex::kBlkBitmap);

	IRenameMtls(layer, newLayer);

	// Copy the bitmap
	if (layer->GetMiscFlags() & hsMaxLayerBase::kMiscUseBitmap)
	{
		bitmapPB->SetValue(kBmpUseBitmap, 0, 1);

		const char *name = layer->GetMapName();
		PBBitmap pbb;
		pbb.bi.SetName(name);

		// Disable annoying missing texture warning
		BOOL bmmSilentMode = TheManager->SilentMode();
		TheManager->SetSilentMode(TRUE);

		bitmapPB->SetValue(kBmpBitmap, 0, &pbb);
	
		TheManager->SetSilentMode(bmmSilentMode);
	}

	// Copy the UVGen
	newLayer->ReplaceReference(plLayerTex::kRefUVGen, layer->GetUVGen());

	// Copy the cropping
	if (layer->GetApplyCrop())
	{
		bitmapPB->SetValue(kBmpApply, 0, TRUE);
		bitmapPB->SetValue(kBmpCropPlace, 0, layer->GetPlaceImage());

		bitmapPB->SetValue(kBmpClipU, 0, layer->GetClipU(0));
		bitmapPB->SetValue(kBmpClipV, 0, layer->GetClipV(0));
		bitmapPB->SetValue(kBmpClipW, 0, layer->GetClipW(0));
		bitmapPB->SetValue(kBmpClipH, 0, layer->GetClipH(0));
	}

	// Misc
	if (layer->GetBlendFlags() & hsMaxLayerBase::kBlendNoColor)
		bitmapPB->SetValue(kBmpDiscardColor, 0, TRUE);
	if (layer->GetBlendFlags() & hsMaxLayerBase::kBlendInvertColor)
		bitmapPB->SetValue(kBmpInvertColor, 0, TRUE);
	if (layer->GetAlphaSource() == 2)
		bitmapPB->SetValue(kBmpDiscardAlpha, 0, TRUE);
	if (layer->GetBlendFlags() & hsMaxLayerBase::kBlendInvertAlpha)
		bitmapPB->SetValue(kBmpInvertAlpha, 0, TRUE);

/*
	// Texture quality
	kBmpNonCompressed,
	kBmpScaling,
*/

	// Mipmap
	if (layer->GetFilterType() == 2)
		bitmapPB->SetValue(kBmpNoFilter, 0, TRUE);

	float blur = layer->GetMipMapBlur(TimeValue(0));
	bitmapPB->SetValue(kBmpMipBlur, 0, blur);
	
	if (layer->GetZFlags() & hsMaxLayerBase::kZLODBias)
	{
		bitmapPB->SetValue(kBmpMipBias, 0, TRUE);
		bitmapPB->SetValue(kBmpMipBiasAmt, 0, layer->GetLODBias(TimeValue(0)));
	}
	
	// Detail
	if (layer->GetBlendFlags() & hsMaxLayerBase::kBlendDetail ||
		layer->GetBlendFlags() & hsMaxLayerBase::kBlendDetailAdd)
	{
		bitmapPB->SetValue(kBmpUseDetail, 0, TRUE);

		bitmapPB->SetValue(kBmpDetailStartSize, 0, layer->GetDetailDropoffStart(0));
		bitmapPB->SetValue(kBmpDetailStopSize, 0, layer->GetDetailDropoffStop(0));
		bitmapPB->SetValue(kBmpDetailStartOpac, 0, layer->GetDetailMax(0));
		bitmapPB->SetValue(kBmpDetailStopOpac, 0, layer->GetDetailMin(0));
	}

	return newLayer;
}

void plMaterialUpdate::ICopyMtlParams(plPassMtl *mtl, hsMaxLayer *layer)
{
	IParamBlock2 *basicPB = mtl->GetParamBlockByID(plPassMtl::kBlkBasic);
	IParamBlock2 *layersPB = mtl->GetParamBlockByID(plPassMtl::kBlkLayers);

	basicPB->SetValue(kPassBasColorAmb, 0, layer->GetAmbient());
	basicPB->SetValue(kPassBasColor, 0, layer->GetColor());

	basicPB->SetValue(kPassBasOpacity, 0, int(layer->GetOpacity(0)*100.f));

	if (layer->GetBlendFlags() & hsMaxLayerBase::kBlendAlpha)
		layersPB->SetValue(kPassLayOutputBlend, 0, plPassMtlBase::kBlendAlpha);
	else if (layer->GetBlendFlags() & hsMaxLayerBase::kBlendAdd)
		layersPB->SetValue(kPassLayOutputBlend, 0, plPassMtlBase::kBlendAdd);

/*
	kPassAdvUseSpec,
	kPassAdvSpecType,
	kPassAdvShine,
	kPassAdvShineStr,

	// Misc
	kPassAdvWire,
	kPassAdvMeshOutlines,
	kPassAdvTwoSided,

	// Shading
	kPassAdvSoftShadow,
	kPassAdvNoProj,
	kPassAdvVertexShade,
	kPassAdvNoShade,
	kPassAdvNoFog,
	kPassAdvWhite,

	// Z
	kPassAdvZOnly,
	kPassAdvZClear,
	kPassAdvZNoRead,
	kPassAdvZNoWrite,
	kPassAdvZInc,
*/
}