#include  "stdafx.h"

#include  "NiObjects/NiSMemory.h"
#include  "Rotation.h"
#include  "MessageBoxDLG.h"
#include  "WinTools.h"

#include  "anm_data.h"



/*
使用するパラメータ
	appParam.animationUUID		CSetAnimation
*/




CNiSMemory::CNiSMemory(void)
{
	indexHandle  = NULL;
	ptrAnimIndex = NULL;
		
	for (int i=0; i<SL_MAX_JOINT_NUM; i++) {
		mapHandle[i]  = NULL;
		ptrMapData[i] = NULL;
	}

	isCreated = createSharedMemory();

	appParam.init();
}





CNiSMemory::~CNiSMemory(void)
{
	DEBUG_ERR("DESTRUCTOR: CNiSMemory");

	closeSharedMemory();
}






///////////////////////////////////////////////////////////////////////////


BOOL  CNiSMemory::createSharedMemory(void)
{
	BOOL ret = TRUE;

	for (int i=0; i<SL_MAX_JOINT_NUM; i++) {
		mapHandle[i] = CreateFileMapping(INVALID_HANDLE_VALUE, NULL, PAGE_READWRITE, 0, 
								ANM_COM_LEN_DATA*NISMEM_CHANNEL_NUM, (LPCTSTR)mbs2ts((char*)SLJointName(i).c_str())); 
		if (mapHandle[i]==NULL) {
			ret = FALSE;
			break;
		}
		ptrMapData[i] = (double*)MapViewOfFile(mapHandle[i], FILE_MAP_ALL_ACCESS, 0, 0, 0);
		if (ptrMapData[i]==NULL) {
			ret = FALSE;
			break;
		}
		memset((char*)ptrMapData[i], 0, ANM_COM_LEN_DATA*NISMEM_CHANNEL_NUM);
	}

	// Index
	if (ret) {
		indexHandle = CreateFileMapping(INVALID_HANDLE_VALUE, NULL, PAGE_READWRITE, 0, 
										NISMEM_INDEX_LEN*NISMEM_CHANNEL_NUM, _T(NISMEM_INDEX_NAME)); 
		if (indexHandle!=NULL) ptrAnimIndex = (char*)MapViewOfFile(indexHandle, FILE_MAP_ALL_ACCESS, 0, 0, 0);
		if (indexHandle==NULL || ptrAnimIndex==NULL) ret = FALSE;
	}

	if (!ret) closeSharedMemory();

	clearSharedMemory();
	return ret;
}





void  CNiSMemory::closeSharedMemory(void)
{
	clearSharedMemory();

	for (int i=0; i<SL_MAX_JOINT_NUM; i++) {
		if (ptrMapData[i]!=NULL) {
			memset((char*)ptrMapData[i], 0, ANM_COM_LEN_DATA*NISMEM_CHANNEL_NUM);
			UnmapViewOfFile(ptrMapData[i]);
			ptrMapData[i] = NULL;
		}
		if (mapHandle[i]!=NULL) {
			CloseHandle(mapHandle[i]);
			mapHandle[i] = NULL;
		}
	}


	if (ptrAnimIndex!=NULL) {
		memset(ptrAnimIndex, 0, NISMEM_INDEX_LEN*NISMEM_CHANNEL_NUM);
		UnmapViewOfFile(ptrAnimIndex);
		ptrAnimIndex = NULL;
	}
	
	if (indexHandle!=NULL) {
		CloseHandle(indexHandle);
		indexHandle = NULL;
	}

	isCreated = FALSE;
}




void  CNiSMemory::clearSharedMemory(void)
{
	clearLocalAnimationIndex();
	clearNetworkAnimationIndex();

	clearAnimationData();
}




///////////////////////////////////////////////////////////////////////////
// Index


void  CNiSMemory::setAnimationIndex(char* uuid, int n)
{
	if (ptrAnimIndex==NULL) return;

	char* ptr = ptrAnimIndex + n*NISMEM_INDEX_LEN;
	memcpy(ptr, uuid, ANM_COM_LEN_UUID);
}




void  CNiSMemory::setLocalAnimationIndex(void)
{
	if (appParam.animationUUID!="") {
		char* mbstr = ts2mbs(appParam.animationUUID);
		setAnimationIndex(mbstr, 0);
		::free(mbstr);
	}
}




void  CNiSMemory::clearLocalAnimationIndex(void)
{
	if (ptrAnimIndex!=NULL) {
		memset(ptrAnimIndex, 0, NISMEM_INDEX_LEN);
	}
}




int	 CNiSMemory::getNetworkAnimationIndexNum(void)
{
	int n = 0;
	char* ptr = ptrAnimIndex + NISMEM_INDEX_LEN;

	for (int i=1; i<NISMEM_CHANNEL_NUM; i++) {
		if (*ptr!=0x00) n++;
		ptr += NISMEM_INDEX_LEN;
	}

	return n;
}




int	 CNiSMemory::checkNetworkAnimationIndex(char* uuid)
{
	if (ptrAnimIndex==NULL) return -1;

	int   n, spidx = -1;
	char* ptr = ptrAnimIndex + NISMEM_INDEX_LEN;

	for (n=1; n<NISMEM_CHANNEL_NUM; n++) {
		if (!strncasecmp(ptr, uuid, ANM_COM_LEN_UUID)) break;
		else if (spidx==-1 && *ptr==0x00) spidx = n;
		ptr += NISMEM_INDEX_LEN;
	}

	if (n==NISMEM_CHANNEL_NUM) {
		if (spidx!=-1) {
			ptr = ptrAnimIndex + spidx*NISMEM_INDEX_LEN;
			memcpy(ptr, uuid, ANM_COM_LEN_UUID);
		}
		n = spidx;
	}

	return n;
}




int  CNiSMemory::clearNetworkAnimationIndex(char* uuid)
{
	char* ptr = ptrAnimIndex;
	if (ptr==NULL) return -1;

	int n;
	for (n=1; n<NISMEM_CHANNEL_NUM; n++) {
		if (!strncasecmp(ptr, uuid, ANM_COM_LEN_UUID)) {
			memset(ptr, 0, NISMEM_INDEX_LEN);
			break;
		}
		ptr += NISMEM_INDEX_LEN;
	}

	if (n<NISMEM_CHANNEL_NUM) return n;
	return -1;
}




void  CNiSMemory::clearNetworkAnimationIndex()
{
	if (ptrAnimIndex!=NULL) {
		memset(ptrAnimIndex+NISMEM_INDEX_LEN, 0, NISMEM_INDEX_LEN*(NISMEM_CHANNEL_NUM-1));
	}
}





//////////////////////////////////////////////////////////////////////////
// Data

void  CNiSMemory::updateLocalAnimationData(Vector<double>* posVect, Quaternion* rotQuat, NiSDK_Lib lib, int joints_num)
{
	double* shm = NULL;

	// Position
	if (appParam.outDataCoord) {
		for (int j=0; j<joints_num; j++) {
			int n = NiSDK2SLPosJointNum(j, lib);
			if (n>=0) {
				shm = ptrMapData[n];
				if (shm!=NULL) {
					if (posVect[j].c>=0.0) {
						shm[1] = posVect[j].x;
						shm[2] = posVect[j].y;
						shm[3] = posVect[j].z;
					}
				}
			}
		}
	}

	
	// Quaternion
	if (appParam.outDataQuate) {
		// Positon of Root Joint
		if (!appParam.outDataCoord) {
			int n = NiSDK2SLPosJointNum(0, lib);
			if (n>=0) {
				shm = ptrMapData[n];
				if (shm!=NULL) {
					if (posVect[0].c>=0.0) {
						shm[1] = posVect[0].x;
						shm[2] = posVect[0].y;
						shm[3] = posVect[0].z;
					}
				}
			}
		}

		for (int j=0; j<joints_num; j++) {
			int n = NiSDK2SLRotJointNum(j, lib);
			if (n>=0) {
				shm = ptrMapData[n];
				if (shm!=NULL) {
					if (rotQuat[j].c>=0.0) {
						shm[4] = rotQuat[j].x;
						shm[5] = rotQuat[j].y;
						shm[6] = rotQuat[j].z;
						shm[7] = rotQuat[j].s;
					}
				}
			}
		}
	}
}




void  CNiSMemory::clearLocalAnimationData(void)
{
	for (int i=0; i<SL_MAX_JOINT_NUM; i++) {
		if (ptrMapData[i]!=NULL) {
			memset((char*)ptrMapData[i], 0, ANM_COM_LEN_DATA);
		}
	}
}




void  CNiSMemory::clearNetworkAnimationData(void)
{
	for (int i=0; i<SL_MAX_JOINT_NUM; i++) {
		if (ptrMapData[i]!=NULL) {
			memset((char*)ptrMapData[i]+ANM_COM_LEN_DATA, 0, ANM_COM_LEN_DATA*(NISMEM_CHANNEL_NUM-1));
		}
	}
}




void  CNiSMemory::clearAnimationData(void)
{
	for (int i=0; i<SL_MAX_JOINT_NUM; i++) {
		if (ptrMapData[i]!=NULL) {
			memset((char*)ptrMapData[i], 0, ANM_COM_LEN_DATA*NISMEM_CHANNEL_NUM);
		}
	}
}





//////////////////////////////////////////////////////////////////////////
// Index + Data

void  CNiSMemory::updateNetworkAnimation(char* data, char* uuid, int joints, int size)
{
	//if (data==NULL) {
	//	clearNetworkAnimation(uuid);
	//	return;
	//}

	int channel = checkNetworkAnimationIndex(uuid);
	if (channel<0) return;
	int chnlpos = channel*ANM_COM_NUM_DATA;
	unsigned short* mode = NULL;

	// Float Data
	if (size==4) {
		float* net = (float*)data;
		for (int i=0; i<joints; i++) {
			mode = (unsigned short*)net;
			int n = mode[1];
			//
			if (n>=0 && n<SL_MAX_JOINT_NUM && ptrMapData[n]!=NULL) {
				double* shm = ptrMapData[n] + chnlpos;
				net++;

				if (mode[0]&ANM_COM_DATA_POSITION || mode[0]==0x00) {
					shm[1] = (double)net[0];
					shm[2] = (double)net[1];
					shm[3] = (double)net[2];
					net += 3;
				}
				if (mode[0]&ANM_COM_DATA_ROTATION || mode[0]==0x00) {
					shm[4] = (double)net[0];
					shm[5] = (double)net[1];
					shm[6] = (double)net[2];
					shm[7] = (double)net[3];
					net += 4;
				}
			}
			//
			else {
				net++;		
				if (mode[0]&ANM_COM_DATA_POSITION || mode[0]==0x00) {
					net += 3;
				}
				if (mode[0]&ANM_COM_DATA_ROTATION || mode[0]==0x00) {
					net += 4;
				}
			}
		}
	}

	// Double Data
	else {
		double* net = (double*)data;
		for (int i=0; i<joints; i++) {
			mode = (unsigned short*)net;
			int n = mode[1];
			//
			if (n>=0 && n<SL_MAX_JOINT_NUM && ptrMapData[n]!=NULL) {
				double* shm = ptrMapData[n] + chnlpos;
				net++;
					
				if (mode[0]&ANM_COM_DATA_POSITION || mode[0]==0x00) {
					memcpy((char*)(shm+1), (char*)net, ANM_COM_LEN_POS);
					net += 3;
				}
				if (mode[0]&ANM_COM_DATA_ROTATION || mode[0]==0x00) {
					memcpy((char*)(shm+4), (char*)net, ANM_COM_LEN_ROT);
					net += 4;
				}
			}
			//
			else {
				net++;		
				if (mode[0]&ANM_COM_DATA_POSITION || mode[0]==0x00) {
					net += 3;
				}
				if (mode[0]&ANM_COM_DATA_ROTATION || mode[0]==0x00) {
					net += 4;
				}
			}
		}
	}
}





void  CNiSMemory::clearNetworkAnimation(char* uuid)
{
	char* ptr = ptrAnimIndex;
	if (ptr==NULL) return;

	int n;
	for (n=1; n<NISMEM_CHANNEL_NUM; n++) {
		if (!strncasecmp(ptr, uuid, ANM_COM_LEN_UUID)) {
			memset(ptr, 0, NISMEM_INDEX_LEN);
			break;
		}
		ptr += NISMEM_INDEX_LEN;
	}

	if (n<NISMEM_CHANNEL_NUM) {
		for (int i=0; i<SL_MAX_JOINT_NUM; i++) {
			if (ptrMapData[i]!=NULL) {
				memset((char*)ptrMapData[i]+ANM_COM_LEN_DATA*n, 0, ANM_COM_LEN_DATA);
			}
		}
	}

	return;
}