/*==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 <windowsx.h>

#include "HeadSpin.h"
#include "max.h"
#include "resource.h"
#include "hsTemplates.h"
#include "hsResMgr.h"
#include "plQuality.h"
#include "../pnMessage/plRefMsg.h"
#include "../../PubUtilLib/plSurface/hsGMaterial.h"
#include "../MaxMain/plMaxNode.h"
#include "../MaxConvert/hsMaterialConverter.h"

#include "plComponent.h"
#include "plComponentReg.h"
#include "plGrassComponent.h"
#include "../../PubUtilLib/plSurface/plGrassShaderMod.h"

#include "../pnKeyedObject/plUoid.h"
#include "../pnMessage/plObjRefMsg.h"
#include "../MaxMain/plPluginResManager.h"

void DummyCodeIncludeFuncGrassShader()
{
}

class GrassCompDlgProc : public ParamMap2UserDlgProc
{
public:
	GrassCompDlgProc() {}
	~GrassCompDlgProc() {}

protected:
	void ISetToWave(int wave, HWND hWnd, IParamBlock2 *pb, IParamMap2 *map)
	{
		HWND cbox = GetDlgItem(hWnd, IDC_GRASS_WAVE);
		SendMessage(cbox, CB_SETCURSEL, wave, 0);
		pb->SetValue(ParamID(plGrassComponent::kWave), 0, wave);
		pb->SetValue(ParamID(plGrassComponent::kDistX), 0, pb->GetFloat(ParamID(plGrassComponent::kDistXTab), 0, wave));
		pb->SetValue(ParamID(plGrassComponent::kDistY), 0, pb->GetFloat(ParamID(plGrassComponent::kDistYTab), 0, wave));
		pb->SetValue(ParamID(plGrassComponent::kDistZ), 0, pb->GetFloat(ParamID(plGrassComponent::kDistZTab), 0, wave));
		pb->SetValue(ParamID(plGrassComponent::kDirX), 0, pb->GetFloat(ParamID(plGrassComponent::kDirXTab), 0, wave));
		pb->SetValue(ParamID(plGrassComponent::kDirY), 0, pb->GetFloat(ParamID(plGrassComponent::kDirYTab), 0, wave));
		pb->SetValue(ParamID(plGrassComponent::kSpeed), 0, pb->GetFloat(ParamID(plGrassComponent::kSpeedTab), 0, wave));
		map->Invalidate();
	}

public:
	BOOL DlgProc(TimeValue t, IParamMap2 *map, HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam)
	{
		int id = LOWORD(wParam);
		int code = HIWORD(wParam);

		IParamBlock2 *pb = map->GetParamBlock();
		HWND cbox = NULL;

		int selection;
		switch (msg)
		{
		case WM_INITDIALOG:
			cbox = GetDlgItem(hWnd, IDC_GRASS_WAVE);
			SendMessage(cbox, CB_ADDSTRING, 0, (LPARAM)"1");
			SendMessage(cbox, CB_ADDSTRING, 1, (LPARAM)"2");
			SendMessage(cbox, CB_ADDSTRING, 2, (LPARAM)"3");
			SendMessage(cbox, CB_ADDSTRING, 3, (LPARAM)"4");

			selection = pb->GetInt(plGrassComponent::kWave);
			ISetToWave(selection, hWnd, pb, map);
			return TRUE;

		case WM_COMMAND:
		case CC_SPINNER_CHANGE:
			int wave = SendMessage(GetDlgItem(hWnd, IDC_GRASS_WAVE), CB_GETCURSEL, 0, 0);
			if (id == IDC_GRASS_WAVE)
			{
				if (wave != pb->GetInt(ParamID(plGrassComponent::kWave)))
					ISetToWave(wave, hWnd, pb, map);
			}
			else if (id == IDC_GRASS_DIST_X || id == IDC_GRASS_DIST_X_SPIN)
				pb->SetValue(plGrassComponent::kDistXTab, 0, pb->GetFloat(ParamID(plGrassComponent::kDistX)), wave);
			else if (id == IDC_GRASS_DIST_Y || id == IDC_GRASS_DIST_Y_SPIN)
				pb->SetValue(plGrassComponent::kDistYTab, 0, pb->GetFloat(ParamID(plGrassComponent::kDistY)), wave);
			else if (id == IDC_GRASS_DIST_Z || id == IDC_GRASS_DIST_Z_SPIN)
				pb->SetValue(plGrassComponent::kDistZTab, 0, pb->GetFloat(ParamID(plGrassComponent::kDistZ)), wave);
			else if (id == IDC_GRASS_DIR_X || id == IDC_GRASS_DIR_X_SPIN)
				pb->SetValue(plGrassComponent::kDirXTab, 0, pb->GetFloat(ParamID(plGrassComponent::kDirX)), wave);
			else if (id == IDC_GRASS_DIR_Y || id == IDC_GRASS_DIR_Y_SPIN)
				pb->SetValue(plGrassComponent::kDirYTab, 0, pb->GetFloat(ParamID(plGrassComponent::kDirY)), wave);
			else if (id == IDC_GRASS_SPEED || id == IDC_GRASS_SPEED_SPIN)
				pb->SetValue(plGrassComponent::kSpeedTab, 0, pb->GetFloat(ParamID(plGrassComponent::kSpeed)), wave);

			return TRUE;
		}
		return FALSE;
	}
	void DeleteThis() {}
};
static GrassCompDlgProc gGrassCompDlgProc;

CLASS_DESC(plGrassComponent, gGrassDesc, "Grass",  "Grass", COMP_TYPE_SHADERS, GRASS_COMPONENT_CLASS_ID)

ParamBlockDesc2 gGrassBk
(

	plComponent::kBlkComp, _T("Grass"), 0, &gGrassDesc, P_AUTO_CONSTRUCT + P_AUTO_UI, plComponent::kRefComp,

	//Roll out
	IDD_COMP_GRASS, IDS_COMP_GRASS_ROLL, 0, 0, &gGrassCompDlgProc,


	plGrassComponent::kWave, _T("Wave"), TYPE_INT, 0, 0,
		p_default, 0,
		end,

	plGrassComponent::kDistX, _T("DistX"), TYPE_FLOAT, 0, 0,
		p_default, 0.0,
		p_range, -10.0, 10.0,
		p_ui, TYPE_SPINNER, EDITTYPE_FLOAT,
		IDC_GRASS_DIST_X, IDC_GRASS_DIST_X_SPIN, 0.1,
		end,

	plGrassComponent::kDistY, _T("DistY"), TYPE_FLOAT, 0, 0,
		p_default, 0.0,
		p_range, -10.0, 10.0,
		p_ui, TYPE_SPINNER, EDITTYPE_FLOAT,
		IDC_GRASS_DIST_Y, IDC_GRASS_DIST_Y_SPIN, 0.1,
		end,

	plGrassComponent::kDistZ, _T("DistZ"), TYPE_FLOAT, 0, 0,
		p_default, 0.0,
		p_range, -10.0, 10.0,
		p_ui, TYPE_SPINNER, EDITTYPE_FLOAT,
		IDC_GRASS_DIST_Z, IDC_GRASS_DIST_Z_SPIN, 0.1,
		end,

	plGrassComponent::kDirX, _T("DirX"), TYPE_FLOAT, 0, 0,
		p_default, 0.0,
		p_range, -10.0, 10.0,
		p_ui, TYPE_SPINNER, EDITTYPE_FLOAT,
		IDC_GRASS_DIR_X, IDC_GRASS_DIR_X_SPIN, 0.1,
		end,

	plGrassComponent::kDirY, _T("DirY"), TYPE_FLOAT, 0, 0,
		p_default, 0.0,
		p_range, -10.0, 10.0,
		p_ui, TYPE_SPINNER, EDITTYPE_FLOAT,
		IDC_GRASS_DIR_Y, IDC_GRASS_DIR_Y_SPIN, 0.1,
		end,

	plGrassComponent::kSpeed, _T("Speed"), TYPE_FLOAT, 0, 0,
		p_default, 0.0,
		p_range, -10.0, 10.0,
		p_ui, TYPE_SPINNER, EDITTYPE_FLOAT,
		IDC_GRASS_SPEED, IDC_GRASS_SPEED_SPIN, 0.1,
		end,

		plGrassComponent::kDistXTab, _T("DistXTab"), TYPE_FLOAT_TAB, plGrassShaderMod::kNumWaves, 0, 0,
		p_default, 0.0,
		p_range, -10.0, 10.0,
		end,

	plGrassComponent::kDistYTab, _T("DistYTab"), TYPE_FLOAT_TAB, plGrassShaderMod::kNumWaves, 0, 0,
		p_default, 0.0,
		p_range, -10.0, 10.0,
		end,

	plGrassComponent::kDistZTab, _T("DistZTab"), TYPE_FLOAT_TAB, plGrassShaderMod::kNumWaves, 0, 0,
		p_default, 0.0,
		p_range, -10.0, 10.0,
		end,

	plGrassComponent::kDirXTab, _T("DirXTab"), TYPE_FLOAT_TAB, plGrassShaderMod::kNumWaves, 0, 0,
		p_default, 0.0,
		p_range, -10.0, 10.0,
		end,

	plGrassComponent::kDirYTab, _T("DirYTab"), TYPE_FLOAT_TAB, plGrassShaderMod::kNumWaves, 0, 0,
		p_default, 0.0,
		p_range, -10.0, 10.0,
		end,

	plGrassComponent::kSpeedTab, _T("SpeedTab"), TYPE_FLOAT_TAB, plGrassShaderMod::kNumWaves, 0, 0,
		p_default, 0.0,
		p_range, -10.0, 10.0,
		end,

	end
);

plGrassComponent::plGrassComponent() : fShader(nil)
{
	fClassDesc = &gGrassDesc;
	fClassDesc->MakeAutoParamBlocks(this);
}

hsBool plGrassComponent::PreConvert(plMaxNode *node, plErrorMsg *pErrMsg)
{
	fShader = TRACKED_NEW plGrassShaderMod();

	plLoadMask loadMask;
	int qual = 1;
	int cap = plQuality::kPS_1_1;
	plLoadMask::ComputeRepMasks(1, &qual, &cap, &loadMask);
	plKey modKey = hsgResMgr::ResMgr()->NewKey(IGetUniqueName(node), fShader, node->GetLocation(), loadMask);

	int i;
	for (i = 0; i < plGrassShaderMod::kNumWaves; i++)
	{
		fShader->fWaves[i].fDistX = fCompPB->GetFloat(ParamID(kDistXTab), 0, i);
		fShader->fWaves[i].fDistY = fCompPB->GetFloat(ParamID(kDistYTab), 0, i);
		fShader->fWaves[i].fDistZ = fCompPB->GetFloat(ParamID(kDistZTab), 0, i);
		fShader->fWaves[i].fDirX = fCompPB->GetFloat(ParamID(kDirXTab), 0, i);
		fShader->fWaves[i].fDirY = fCompPB->GetFloat(ParamID(kDirYTab), 0, i);
		fShader->fWaves[i].fSpeed = fCompPB->GetFloat(ParamID(kSpeedTab), 0, i);
	}

	// Add a ref to the shader.
	fShader->GetKey()->RefObject();

	return true;
}

hsBool plGrassComponent::Convert(plMaxNode *node, plErrorMsg *pErrMsg)
{
	plObjRefMsg* refMsg = TRACKED_NEW plObjRefMsg(node->GetKey(), plRefMsg::kOnRequest, -1, plObjRefMsg::kModifier);
	hsgResMgr::ResMgr()->AddViaNotify(fShader->GetKey(), refMsg, plRefFlags::kActiveRef);

	hsTArray<hsGMaterial*> mats;
	hsMaterialConverter::Instance().CollectConvertedMaterials(hsMaterialConverter::Instance().GetBaseMtl(node), mats);
	hsgResMgr::ResMgr()->SendRef(mats[0]->GetKey(), TRACKED_NEW plGenRefMsg(fShader->GetKey(), plRefMsg::kOnRequest, 0, plGrassShaderMod::kRefMaterial), plRefFlags::kActiveRef);

	return TRUE;
}

hsBool plGrassComponent::DeInit(plMaxNode* node, plErrorMsg* pErrMsg)
{
	if( fShader )
		fShader->GetKey()->UnRefObject();
	fShader = nil;

	return true;
}

plGrassShaderMod* plGrassComponent::GetShader(INode* node)
{
	if( !node )
		return nil;

	plComponentBase *comp = ((plMaxNodeBase*)node)->ConvertToComponent();
	if( !comp )
		return nil;

	if( comp->ClassID() != GRASS_COMPONENT_CLASS_ID )
		return nil;

	plGrassComponent *shader = (plGrassComponent*)comp;
	return shader->fShader;
}

plGrassShaderMod* plGrassComponent::GetShaderNode(plMaxNode* node)
{
	if( !node )
		return nil;

	int n = node->NumAttachedComponents();
	int i;
	for( i = 0; i < n; i++ )
	{
		plComponentBase* comp = node->GetAttachedComponent(i);
		if( comp && (comp->ClassID() == GRASS_COMPONENT_CLASS_ID) )
		{
			plGrassComponent* shader = (plGrassComponent*)comp;
			return shader->fShader;
		}
	}
	return nil;
}