gmodexporter.cpp

liu7788414

/**********************************************************************
 *<
	FILE: GModExporter.cpp

	DESCRIPTION:	Appwizard generated plugin

	CREATED BY: 

	HISTORY: 

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

#include "GModExporter.h"
#include "ModData.h"	// Added by ClassView
#include "SceneReader.h"

#define GMODEXPORTER_CLASS_ID	Class_ID(0x227b8169, 0x3eaca03f)


class GModExporter : public SceneExport {
public:
		CMesh m_mesh;


		static HWND hParams;


		int				ExtCount();					// Number of extensions supported
		const TCHAR *	Ext(int n);					// Extension #n (i.e. "3DS")
		const TCHAR *	LongDesc();					// Long ASCII description (i.e. "Autodesk 3D Studio File")
		const TCHAR *	ShortDesc();				// Short ASCII description (i.e. "3D Studio")
		const TCHAR *	AuthorName();				// ASCII Author name
		const TCHAR *	CopyrightMessage();			// ASCII Copyright message
		const TCHAR *	OtherMessage1();			// Other message #1
		const TCHAR *	OtherMessage2();			// Other message #2
		unsigned int	Version();					// Version number * 100 (i.e. v3.01 = 301)
		void			ShowAbout(HWND hWnd);		// Show DLL's "About..." box

		BOOL SupportsOptions(int ext, DWORD options);
		int				DoExport(const TCHAR *name,ExpInterface *ei,Interface *i, BOOL suppressPrompts=FALSE, DWORD options=0);


		
		//Constructor/Destructor

		GModExporter();
		~GModExporter();		

};


class GModExporterClassDesc:public ClassDesc2 {
	public:
	int 			IsPublic() { return TRUE; }
	void *			Create(BOOL loading = FALSE) { return new GModExporter(); }
	const TCHAR *	ClassName() { return GetString(IDS_CLASS_NAME); }
	SClass_ID		SuperClassID() { return SCENE_EXPORT_CLASS_ID; }
	Class_ID		ClassID() { return GMODEXPORTER_CLASS_ID; }
	const TCHAR* 	Category() { return GetString(IDS_CATEGORY); }

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

};



static GModExporterClassDesc GModExporterDesc;
ClassDesc2* GetGModExporterDesc() { return &GModExporterDesc; }

BOOL CALLBACK GModExporterTypeSelectProc(HWND hWnd,UINT message,WPARAM wParam,LPARAM lParam)
{
		static int *type = NULL;
		
		switch(message) {
		case WM_INITDIALOG:
			
			type = (int *)lParam;

			CenterWindow(hWnd,GetParent(hWnd));			
			CheckRadioButton(hWnd, IDC_RADIO1, IDC_RADIO2, (*type == 0)?IDC_RADIO1:IDC_RADIO2);
			
			return TRUE;
			
			case WM_CLOSE:
				*type = -1;
				EndDialog(hWnd, 0);
				return TRUE;
				
			case WM_COMMAND:
				switch(LOWORD(wParam))
				{
				case IDOK:					
					EndDialog(hWnd,0);
					break;
					
				case IDCANCEL:
					*type = -1;
					EndDialog(hWnd,0);
					break;

				case IDC_RADIO1:
					*type = 0;
					break;

				case IDC_RADIO2:
					*type = 1;
					break;
					
				default:
					break;
				}
		}
		return FALSE;
}


void UpdateList(HWND hwnd, list<SampleMethod> &actionlist)
{
	GetDlgItem(hwnd, IDC_LIST_SAMPLE);
	list<SampleMethod>::iterator itr = actionlist.begin();
	int count = actionlist.size();
	char data[100];
	for (int i=0; i<count; i++, itr++)
	{		
		sprintf( data, "%s: %d, %d, %d", itr->ActionName, itr->startTime, itr->endTime, itr->FrameCount);
		SendMessage(hwnd, LB_ADDSTRING, 0, (LPARAM)data); 
	}
}

BOOL CALLBACK GModExporterOptionsDlgProc(HWND hWnd,UINT message,WPARAM wParam,LPARAM lParam) {
	
	//static GModExporter *imp = NULL;	
	TCHAR buff[8];
	static ExportOptions *options = NULL;
	
	switch(message) {
		case WM_INITDIALOG:
			
			options = (ExportOptions *)lParam;
			//imp = (GModExporter *)lParam;
			CenterWindow(hWnd,GetParent(hWnd));

			CheckDlgButton(hWnd, IDC_CHECK_ADDANIMATION, 
				options->bHaveAnimation ? BST_CHECKED : BST_UNCHECKED);
			CheckDlgButton(hWnd, IDC_HAVENORMAL, 
				options->bHaveVertexNormal ? BST_CHECKED : BST_UNCHECKED);
			
			switch (options->format)
			{
			case 0:
				CheckRadioButton(hWnd,IDC_FORMAT_BIN,IDC_FORMAT_ASCII,IDC_FORMAT_BIN);
				break;
				
			case 1:
				CheckRadioButton(hWnd,IDC_FORMAT_BIN,IDC_FORMAT_ASCII,IDC_FORMAT_ASCII);
				break;
			}
			
			switch (options->unit)
			{
			case UNIT_NORMAL:
				CheckRadioButton(hWnd,IDC_UNITNORMAL,IDC_UNITDIV16,IDC_UNITNORMAL);
				break;
				
			case UNIT_DIV16:
				CheckRadioButton(hWnd,IDC_UNITNORMAL,IDC_UNITDIV16,IDC_UNITDIV16);
				break;
			}

			switch (options->iAnimationType)
			{
			case VERTEX_ANIMATION:
				CheckRadioButton(hWnd,IDC_BONEANIM,IDC_VERTEXANIM,IDC_VERTEXANIM);
				break;
				
			case BONE_ANIMATION:
				CheckRadioButton(hWnd,IDC_BONEANIM,IDC_VERTEXANIM,IDC_BONEANIM);
				break;
			}
						
			switch (options->iMaxBoneCount)
			{
			case MAX_ONE_BONE:
				CheckRadioButton(hWnd,IDC_TWOBONES, IDC_ONEBONE,IDC_ONEBONE);
				break;
				
			case MAX_TWO_BONES:
				CheckRadioButton(hWnd,IDC_TWOBONES,IDC_ONEBONE,IDC_TWOBONES);
				break;
			}
			
			_stprintf(buff,_T("%d"),options->m_curSample.startTime);
			SetDlgItemText(hWnd,IDC_STARTTIME,buff);
			_stprintf(buff,_T("%d"),options->m_curSample.endTime);
			SetDlgItemText(hWnd,IDC_ENDTIME,buff);
			_stprintf(buff,_T("%d"),options->m_curSample.FrameCount);
			SetDlgItemText(hWnd,IDC_FRAMECOUNT,buff);
			SetDlgItemText(hWnd,IDC_ACTIONNAME,options->m_curSample.ActionName);
//			SetDlgItemText(hWnd,IDC_SAMPLE_RATE,buff);
			return TRUE;

		case WM_CLOSE:
			options->bExport = FALSE;
			EndDialog(hWnd, 0);
			return TRUE;
			
		case WM_COMMAND:
			switch(LOWORD(wParam))
			{
			case IDC_EXPORT:
				options->bExport = TRUE;
				
				EndDialog(hWnd,0);
				break;
				
			case IDC_CANCEL:
				options->bExport = FALSE;
				
				EndDialog(hWnd,0);
				break;
				
			case IDC_FORMAT_ASCII:
				options->format = 1;
				break;
				
			case IDC_FORMAT_BIN:
				options->format = 0;
				break;

			case IDC_UNITNORMAL:
				options->unit = UNIT_NORMAL;
				break;
				
			case IDC_UNITDIV16:
				options->unit = UNIT_DIV16;
				break;
				
			case IDC_ONEBONE:
				options->iMaxBoneCount = MAX_ONE_BONE;
				break;
				
			case IDC_TWOBONES:
				options->iMaxBoneCount = MAX_TWO_BONES;
				break;

			case IDC_BONEANIM:
				options->iAnimationType = BONE_ANIMATION;
				break;
				
			case IDC_VERTEXANIM:
				options->iAnimationType = VERTEX_ANIMATION;
				break;
				
			case IDC_CHECK_ADDANIMATION:
				options->bHaveAnimation = !options->bHaveAnimation;
				break;

			case IDC_HAVENORMAL:
				options->bHaveVertexNormal = !options->bHaveVertexNormal;
				break;
				
			case IDC_STARTTIME:
				GetDlgItemText(hWnd,IDC_STARTTIME,buff,sizeof(buff) / sizeof(TCHAR));				
				options->m_curSample.startTime = _ttoi(buff);
				break;
				
			case IDC_ENDTIME:
				GetDlgItemText(hWnd,IDC_ENDTIME,buff,sizeof(buff) / sizeof(TCHAR));				
				options->m_curSample.endTime = _ttoi(buff);
				break;

			case IDC_FRAMECOUNT:
				GetDlgItemText(hWnd,IDC_FRAMECOUNT,buff,sizeof(buff) / sizeof(TCHAR));				
				options->m_curSample.FrameCount = _ttoi(buff);
				break;

			case IDC_ACTIONNAME:
				GetDlgItemText(hWnd,IDC_ACTIONNAME,options->m_curSample.ActionName,sizeof(buff) / sizeof(TCHAR));				
				break;

			case IDC_ADDACTION:
				options->m_Sample.push_back(options->m_curSample);

				char data[100];
				sprintf( data, "%s: %d, %d, %d", options->m_curSample.ActionName, 
					options->m_curSample.startTime, options->m_curSample.endTime, options->m_curSample.FrameCount);
				SendMessage(GetDlgItem(hWnd,IDC_LIST_SAMPLE), LB_ADDSTRING, 0, (LPARAM)data); 
				break;
				
			case IDC_REMOVEACTION:
				{
					int count = options->m_Sample.size();
					list<SampleMethod>::iterator itr = options->m_Sample.begin();
					for (int i=0; i<options->m_curSelect; i++, itr++);
					options->m_Sample.erase(itr);
					SendMessage(GetDlgItem(hWnd,IDC_LIST_SAMPLE), LB_DELETESTRING, options->m_curSelect, 0); 
					break;			
				}
				
			case IDC_LIST_SAMPLE:				
				switch(HIWORD(wParam))
				{
					case LBN_SELCHANGE:
						options->m_curSelect = SendMessage((HWND)lParam, LB_GETCURSEL, 0, 0);
						break;
				}
				break;

			default:
				break;
			}
	}
	return FALSE;
}

//--- GModExporter -------------------------------------------------------
GModExporter::GModExporter()
{

}

GModExporter::~GModExporter() 
{

}

int GModExporter::ExtCount()
{
	//TODO: Returns the number of file name extensions supported by the plug-in.
	return 1;
}

const TCHAR *GModExporter::Ext(int n)
{		
	//TODO: Return the 'i-th' file name extension (i.e. "3DS").
	return _T("GMOD");
}

const TCHAR *GModExporter::LongDesc()
{
	//TODO: Return long ASCII description (i.e. "Targa 2.0 Image File")
	return _T("Gameloft model file with animation data");
}
	
const TCHAR *GModExporter::ShortDesc() 
{			
	//TODO: Return short ASCII description (i.e. "Targa")
	return _T("GLModel");
}

const TCHAR *GModExporter::AuthorName()
{			
	//TODO: Return ASCII Author name
	return _T("Tao Qing");
}

const TCHAR *GModExporter::CopyrightMessage() 
{	
	// Return ASCII Copyright message
	return _T("Copyright 2004, Gameloft. [e-mail]");
}

const TCHAR *GModExporter::OtherMessage1() 
{		
	//TODO: Return Other message #1 if any
	return _T("");
}

const TCHAR *GModExporter::OtherMessage2() 
{		
	//TODO: Return other message #2 in any
	return _T("");
}

unsigned int GModExporter::Version()
{				
	//TODO: Return Version number * 100 (i.e. v3.01 = 301)
	return 1; //version 0.01
}

void GModExporter::ShowAbout(HWND hWnd)
{			
	// Optional
}

BOOL GModExporter::SupportsOptions(int ext, DWORD options)
{
	// TODO Decide which options to support.  Simply return
	// true for each option supported by each Extension 
	// the exporter supports.

	return TRUE;
}


int	GModExporter::DoExport(const TCHAR *name,ExpInterface *ei,Interface *i, BOOL suppressPrompts, DWORD options)
{
	//TODO: Implement the actual file Export here and 
	//		return TRUE If the file is exported properly
	
	ExportOptions DlgOptions;
	DlgOptions.bHaveAnimation = FALSE;
	DlgOptions.bHaveVertexNormal = FALSE;
	DlgOptions.format = 0; //binary
	DlgOptions.unit = UNIT_NORMAL; //normal
//	DlgOptions.iAnimSamplingRate = 10;
	DlgOptions.bExport = FALSE;
	DlgOptions.bExportSelected = ((options == SCENE_EXPORT_SELECTED)? TRUE: FALSE);
	DlgOptions.m_curSelect = -1;
	strcpy(DlgOptions.m_curSample.ActionName, "");
	DlgOptions.m_curSample.startTime = 0;
	DlgOptions.m_curSample.endTime = 0;
	DlgOptions.m_curSample.FrameCount = 0;
	DlgOptions.iAnimationType = BONE_ANIMATION;
	DlgOptions.iMaxBoneCount = MAX_ONE_BONE;
	ei->theScene->FlagFGSelected(0);
	
	int type = 0;
	if(!suppressPrompts)
	{
		if (DlgOptions.bExportSelected)
		{
			DialogBoxParam(hInstance, 
				MAKEINTRESOURCE(IDD_SELECT_TYPE), 
				GetActiveWindow(), 
				GModExporterTypeSelectProc, (LPARAM)&type);
		}
		if (type == 0)
		{
			DialogBoxParam(hInstance, 
				MAKEINTRESOURCE(IDD_PANEL), 
				GetActiveWindow(), 
				GModExporterOptionsDlgProc, (LPARAM)&DlgOptions);
		}
		else if (type == -1)
		{ 		
			return FALSE;
		}
	}
	
	if (DlgOptions.bExport && type == 0)
	{		
		m_mesh.GenerateFromScene(ei->theScene, i, DlgOptions.bExportSelected);
		m_mesh.SaveToFile(name, &DlgOptions);
		return TRUE;
	}
	else if (type == 1)
	{
		//EXPORT THE SELECT OBJECT'S POSITION AND ROTATION	
		CSceneReader reader(ei->theScene, i);
		reader.ExportSelectedNodePath(name);
		return TRUE;
	}
	return FALSE;
}