flyfao.cpp

<B>《Realtime Rendering》的随书源代码

		pivot*=fac;
		strncpy(skinfile,skin,63); skin[63]=0;

		fwrite(&i,1,sizeof(int),fp);
		fwrite(&nfaces,1,sizeof(int),fp);
		fwrite(&nverts,1,sizeof(int),fp);
		fwrite(&nkeys,1,sizeof(int),fp);
		fwrite(&pivot.x,3,sizeof(float),fp);
		fwrite(skinfile,1,64,fp);

		fwrite(faces,nfaces,sizeof(unsigned short)*3,fp);
		fwrite(uvs,nfaces,sizeof(float)*6,fp);

		j=nverts*nkeys*3;
		for( i=0;i<j;i++ )
		{
			f=verts[i]*fac;
			fwrite(&f,1,sizeof(float),fp);
		}
		
		j=0;
		fwrite(&j,1,sizeof(int),fp);

		fclose(fp);

		return 1;
		}
	return 0;
}

void Flyfao::delete_key(int key)
{
	if (nkeys>0 && key<nkeys && key>=0)
	if (IDYES==MessageBox(hParams,"Are you sure do delete the curent selected key ?","Fly3D fao object",MB_ICONQUESTION|MB_YESNO))
	{
		if (nkeys==1)
		{
			if (faces) delete faces;
			if (verts) delete verts;
			if (uvs) delete uvs;
			nkeys=0;
			nverts=0;
			nfaces=0;
			verts=0;
			uvs=0;
			faces=0;
			key=0;
		}
		else
		{
			float *tmp=new float[(nkeys-1)*nverts*3];
			memcpy(tmp,verts,sizeof(float)*3*key*nverts);
			memcpy(&tmp[3*key*nverts],&verts[3*nverts*(key+1)],sizeof(float)*3*nverts*(nkeys-key-1));

			delete verts;
			verts=tmp;

			nkeys--;
			if (key>=nkeys)
				key=nkeys-1;
			if (key<0) 
				key=0;
		}

		pblock->SetValue(PB_KEY,0,key);
		char str[256];
		sprintf(str,"Num faces: %i",nfaces);
		SetDlgItemText(hParams,IDC_NUMFACES,str);
		sprintf(str,"Num verts: %i",nverts);
		SetDlgItemText(hParams,IDC_NUMVERTS,str);
		sprintf(str,"Total keys: %i",nkeys);
		SetDlgItemText(hParams,IDC_NUMKEYS,str);
	}
}

void Flyfao::open_file_dialog()
{
	OPENFILENAME ofn;
	char filename[256]="";
	memset(&ofn,0,sizeof(OPENFILENAME));
	ofn.lStructSize=sizeof(OPENFILENAME);
	ofn.hwndOwner=hParams;
	ofn.hInstance=hInstance;
	ofn.lpstrFilter="Fly animated object (*.fao)\0*.fao\0";
	ofn.lpstrDefExt="fao";
	ofn.lpstrFile=filename;
	ofn.nMaxFile=255;
	ofn.lpstrTitle="Open object";
	ofn.Flags=OFN_FILEMUSTEXIST|OFN_PATHMUSTEXIST;
	if (GetOpenFileName(&ofn))
	{
		load_fao(filename);

		pblock->SetValue(PB_KEY,0,0);
		char str[256];
		sprintf(str,"Num faces: %i",nfaces);
		SetDlgItemText(hParams,IDC_NUMFACES,str);
		sprintf(str,"Num verts: %i",nverts);
		SetDlgItemText(hParams,IDC_NUMVERTS,str);
		sprintf(str,"Total keys: %i",nkeys);
		SetDlgItemText(hParams,IDC_NUMKEYS,str);
	}
}

void Flyfao::open_save_file_dialog()
{
	OPENFILENAME ofn;
	char filename[256]="";
	memset(&ofn,0,sizeof(OPENFILENAME));
	ofn.lStructSize=sizeof(OPENFILENAME);
	ofn.hwndOwner=hParams;
	ofn.hInstance=hInstance;
	ofn.lpstrFilter="Fly animated object (*.fao)\0*.fao\0";
	ofn.lpstrDefExt="fao";
	ofn.lpstrFile=filename;
	ofn.nMaxFile=255;
	ofn.lpstrTitle="Open object";
	ofn.Flags=OFN_PATHMUSTEXIST;
	if (GetOpenFileName(&ofn))
		save_fao(filename,"",Point3(0,0,0));
}

BOOL flyfaoDlg::DlgProc(
		TimeValue t,IParamMap *map,
		HWND hWnd,UINT msg,WPARAM wParam,LPARAM lParam)
{
	switch(msg)
	{
	case WM_INITDIALOG:
		{
		char str[256];
		ff->hParams=hWnd;
		sprintf(str,"Num faces: %i",ff->nfaces);
		SetDlgItemText(hWnd,IDC_NUMFACES,str);
		sprintf(str,"Num verts: %i",ff->nverts);
		SetDlgItemText(hWnd,IDC_NUMVERTS,str);
		sprintf(str,"Total keys: %i",ff->nkeys);
		SetDlgItemText(hWnd,IDC_NUMKEYS,str);
		}
		break;
	case WM_COMMAND:
		switch(wParam)
		{
		case IDC_ADDKEY:
			thePickMode.ff  = ff;
			ff->ip->SetPickMode(&thePickMode);
			break;
		case IDC_DELETEKEY:
			{
			int key;
			ff->pblock->GetValue(PB_KEY,ff->ip->GetTime(),key,FOREVER);
			ff->delete_key(key);
			}
			break;
		case IDC_LOAD:
			ff->open_file_dialog();
			break;
		case IDC_SAVE:
			ff->open_save_file_dialog();
			break;
		}
		break;
	}
	return FALSE;
}

void Flyfao::BeginEditParams(IObjParam *ip,ULONG flags,Animatable *prev)
{
	this->ip = ip;
	flyfaodlg.ff=this;
	SimpleObject::BeginEditParams(ip,flags,prev);

	if(pmapParam) {
		pmapParam->SetParamBlock(pblock);
	} else {
		pmapParam = CreateCPParamMap(
			descParam, PARAMDESC_LENGTH,
			pblock, 
			ip, 
			hInstance, 
			MAKEINTRESOURCE(IDD_PANEL),
			GetString(IDS_PARAMS), 
			0);
	}
	pmapParam->SetUserDlgProc(&flyfaodlg);
}

void Flyfao::EndEditParams( IObjParam *ip, ULONG flags,Animatable *next )
{
	SimpleObject::EndEditParams(ip,flags,next);
	if (flags&END_EDIT_REMOVEUI ) {
		DestroyCPParamMap(pmapParam);
		pmapParam  = NULL;
	}
	this->ip = NULL;
}

BOOL Flyfao::HasUVW() 
{ 
	return TRUE; 
}

void Flyfao::SetGenUVW(BOOL sw) 
{  
	if (sw==HasUVW()) return;
}

int FlyfaoCreateCallBack::proc(ViewExp *vpt,int msg, int point, int flags, IPoint2 m, Matrix3& mat )
{
	switch(msg)
	{
	case MOUSE_POINT:
	case MOUSE_MOVE:
		switch(point) 
		{
		case 0: 
			ob->suspendSnap = TRUE;
			sp0 = m;
			p0 = vpt->SnapPoint(m,m,NULL,SNAP_IN_PLANE);
			mat.SetTrans(p0);
			break;
		case 1:
			return CREATE_STOP;
		}
		break;
	case MOUSE_ABORT:
		return CREATE_ABORT;
	}

	return TRUE;
}

CreateMouseCallBack* Flyfao::GetCreateMouseCallBack() 
{
	FlyfaoCreateCB.SetObj(this);
	return(&FlyfaoCreateCB);
}

void Flyfao::BuildMesh(TimeValue t)
{
	int key;
	ivalid = FOREVER;
	pblock->GetValue(PB_KEY,t,key,FOREVER);
	if (key<0)
	{
		pblock->SetValue(PB_KEY,0,0);
		return;
	}
	if (key>=nkeys)
	{
		pblock->SetValue(PB_KEY,0,nkeys-1);
		return;
	}
	if (nkeys==0)
	{
		mesh.setNumVerts(0);
		mesh.setNumFaces(0);
		mesh.setNumTVerts(0);
		mesh.setNumTVFaces(0);
		return;
	}
	mesh.setNumVerts(nverts);
	mesh.setNumFaces(nfaces);
	mesh.setNumTVerts(nfaces*3);
	mesh.setNumTVFaces(nfaces);
	int i,j=nverts*key;
	for( i=0;i<nverts;i++ )
		mesh.setVert(i,verts[(j+i)*3],verts[(j+i)*3+1],verts[(j+i)*3+2]);
	for( i=0;i<nfaces;i++ )
	{
		mesh.faces[i].v[0]=faces[i*3];
		mesh.faces[i].v[1]=faces[i*3+1];
		mesh.faces[i].v[2]=faces[i*3+2];
		mesh.faces[i].flags=EDGE_ALL;
		mesh.faces[i].smGroup=1;
	}
	for( i=0;i<nfaces;i++ )
	{
		mesh.tvFace[i].t[0]=i*3;
		mesh.tvFace[i].t[1]=i*3+1;
		mesh.tvFace[i].t[2]=i*3+2;
		mesh.tVerts[i*3].x=uvs[i*6];
		mesh.tVerts[i*3].y=1.0f-uvs[i*6+1];
		mesh.tVerts[i*3].z=0;
		mesh.tVerts[i*3+1].x=uvs[i*6+2];
		mesh.tVerts[i*3+1].y=1.0f-uvs[i*6+3];
		mesh.tVerts[i*3+1].z=0;
		mesh.tVerts[i*3+2].x=uvs[i*6+4];
		mesh.tVerts[i*3+2].y=1.0f-uvs[i*6+5];
		mesh.tVerts[i*3+2].z=0;
	}
	mesh.InvalidateGeomCache();
	mesh.InvalidateTopologyCache();
	mesh.BuildStripsAndEdges();
}

BOOL Flyfao::OKtoDisplay(TimeValue t) 
{
	return TRUE;
}

void Flyfao::InvalidateUI() 
{
	if (pmapParam) pmapParam->Invalidate();
}

ParamDimension *Flyfao::GetParameterDim(int pbIndex) 
{
	return defaultDim;
}

TSTR Flyfao::GetParameterName(int pbIndex) 
{
	return GetString(IDS_PARAMS);
}

BOOL Flyfao::SetValue(int i, TimeValue t, int v) 
{
	return TRUE;
}

BOOL Flyfao::SetValue(int i, TimeValue t, float v)
{
	return TRUE;
}

BOOL Flyfao::SetValue(int i, TimeValue t, Point3 &v) 
{
	return TRUE;
}

BOOL Flyfao::GetValue(int i, TimeValue t, int &v, Interval &ivalid) 
{
	return TRUE;
}

BOOL Flyfao::GetValue(int i, TimeValue t, float &v, Interval &ivalid) 
{
	return TRUE;
}

BOOL Flyfao::GetValue(int i, TimeValue t, Point3 &v, Interval &ivalid) 
{	
	return TRUE;
}

Object* Flyfao::ConvertToType(TimeValue t, Class_ID obtype)
{
	return SimpleObject::ConvertToType(t,obtype);
}

int Flyfao::CanConvertToType(Class_ID obtype)
{
	if (obtype==defObjectClassID ||
		obtype==triObjectClassID ||
		obtype==FLYFAO_CLASS_ID) {
		return 1;
	} else {		
	return SimpleObject::CanConvertToType(obtype);
		}
}

int Flyfao::IntersectRay(
		TimeValue t, Ray& ray, float& at, Point3& norm)
{
	return FALSE;
}

void Flyfao::GetCollapseTypes(Tab<Class_ID> &clist,Tab<TSTR*> &nlist)
{
    Object::GetCollapseTypes(clist, nlist);
}

RefTargetHandle Flyfao::Clone(RemapDir& remap) 
{
	Flyfao* newob = new Flyfao();	
	if (nkeys)
	{
		newob->nkeys=nkeys;
		newob->nverts=nverts;
		newob->nfaces=nfaces;

		newob->faces=new unsigned short[nfaces*3];
		newob->uvs=new float[nfaces*6];
		newob->verts=new float[nkeys*nverts*3];

		memcpy(newob->faces,faces,sizeof(unsigned short)*3*nfaces);
		memcpy(newob->uvs,uvs,sizeof(float)*6*nfaces);
		memcpy(newob->verts,verts,sizeof(float)*3*nverts*nkeys);
	}
	newob->ReplaceReference(0,pblock->Clone(remap));
	newob->ivalid.SetEmpty();
	return(newob);
}