Renegade/Code/Tools/max2w3d/skin.cpp

/*
**	Command & Conquer Renegade(tm)
**	Copyright 2025 Electronic Arts 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/>.
*/

/***********************************************************************************************
 ***              C O N F I D E N T I A L  ---  W E S T W O O D  S T U D I O S               ***
 ***********************************************************************************************
 *                                                                                             *
 *                 Project Name : Commando Tools - WWSkin                                      *
 *                                                                                             *
 *                     $Archive:: /Commando/Code/Tools/max2w3d/skin.cpp                       $*
 *                                                                                             *
 *                      $Author:: Moumine_ballo                                               $*
 *                                                                                             *
 *                     $Modtime:: 2/21/02 4:56p                                               $*
 *                                                                                             *
 *                    $Revision:: 15                                                          $*
 *                                                                                             *
 *---------------------------------------------------------------------------------------------*
 * Functions:                                                                                  *
 * - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */


#include "skin.h"
#include "dllmain.h"
#include "max.h"
#include "simpmod.h"
#include "simpobj.h"
#include "resource.h"

#include "skindata.h"
#include "bpick.h"
#include "namedsel.h"
#include "boneicon.h"

#if defined W3D_MAX4		//defined as in the project (.dsp)
static GenSubObjType _SubObjectTypeVertex(1);
#endif

/*
** Static functions
*/
static BOOL CALLBACK _sot_dialog_proc(HWND hWnd,UINT message,WPARAM wParam,LPARAM lParam);
static BOOL CALLBACK _skeleton_dialog_thunk(HWND hWnd,UINT message,WPARAM wParam,LPARAM lParam);
static BOOL CALLBACK _bone_influence_dialog_thunk(HWND hWnd,UINT message,WPARAM wParam,LPARAM lParam);
static TriObject * Get_Tri_Object(TimeValue t,ObjectState & os,Interval & valid,BOOL & needsdel);
static float Bone_Distance(INode * bone,TimeValue time,const Point3 & vertex);

/*
** Static variables
*/
HWND					SkinWSMObjectClass::SotHWND = NULL;
HWND					SkinWSMObjectClass::SkeletonHWND = NULL;
HWND					SkinWSMObjectClass::BoneListHWND = NULL;
IObjParam *			SkinWSMObjectClass::InterfacePtr = NULL;
ICustButton *		SkinWSMObjectClass::AddBonesButton = NULL;
ICustButton *		SkinWSMObjectClass::RemoveBonesButton = NULL;
ISpinnerControl *	SkinWSMObjectClass::BasePoseSpin = NULL;


/*******************************************************************************
**
** Class Descriptor for SkinWSMObjectClass
**
*******************************************************************************/
class SkinWSMObjectClassDesc:public ClassDesc 
{
public:

	int 				IsPublic()								{ return 1; }
	void *			Create(BOOL loading = FALSE)		{ return new SkinWSMObjectClass; }
	const TCHAR *	ClassName()								{ return _T("WWSkin"); }
	SClass_ID		SuperClassID()							{ return WSM_OBJECT_CLASS_ID; }
	Class_ID			ClassID()								{ return SKIN_OBJ_CLASS_ID; }
	const TCHAR* 	Category()								{ return _T("Westwood Space Warps");  }
};

static SkinWSMObjectClassDesc _SkinWSMObjectDesc;
ClassDesc * Get_Skin_Obj_Desc() { return &_SkinWSMObjectDesc; }


/*******************************************************************************
**
** Class Descriptor for the SkinModifier
**
*******************************************************************************/
class SkinModClassDesc:public ClassDesc 
{
public:

	int 				IsPublic()								{ return 0; }
	void *			Create(BOOL loading = FALSE)		{ return new SkinModifierClass; }
	const TCHAR *	ClassName()								{ return _T("WWSkin"); }
	SClass_ID		SuperClassID()							{ return WSM_CLASS_ID; }
	Class_ID			ClassID()								{ return SKIN_MOD_CLASS_ID; }
	const TCHAR * 	Category()								{ return _T("Westwood Space Warps");  }
};

static SkinModClassDesc _SkinModDesc;
ClassDesc * Get_Skin_Mod_Desc() { return &_SkinModDesc; }



/*******************************************************************************
**
**		SkinWSMObjectCreateCallback
**		A class derived from CreateMouseCallBack to handle
**		the user input during the creation phase of the SkinWSMObject.
** 
*******************************************************************************/
class SkinWSMObjectCreateCallBack : public CreateMouseCallBack 
{	
public:
	int proc( ViewExp * vpt,int msg, int point, int flags, IPoint2 m, Matrix3 & mat)
	{
		if (msg == MOUSE_POINT) {
			Point3 pos = vpt->GetPointOnCP(m);
			mat.IdentityMatrix();
			mat.SetTrans(pos);
			return CREATE_STOP;	
		}
		return TRUE;
	}
};

static SkinWSMObjectCreateCallBack _SkinCreateCB;

/*******************************************************************************
**
**		SkinWSMObjectClass
**
*******************************************************************************/
SkinWSMObjectClass::SkinWSMObjectClass() 
{
	/*
	** Initialize class variables to default state!
	*/
	MeshBuilt = FALSE;
	BoneSelectionMode = BONE_SEL_MODE_NONE;
	BoneTab.SetCount(0);
	BasePoseFrame = 0;

	pblock = NULL;
}

SkinWSMObjectClass::~SkinWSMObjectClass(void) 
{
		OutputDebugString("DeletingSkinWSMObjectClass\n");
	assert(!((InterfacePtr == NULL) && (SotHWND != NULL)));
	if (SotHWND != NULL) {
		InterfacePtr->UnRegisterDlgWnd(SotHWND);		
		InterfacePtr->DeleteRollupPage(SotHWND);
	  	SotHWND = NULL;				
	}

	assert(!((InterfacePtr == NULL) && (SkeletonHWND != NULL)));
	if (SkeletonHWND != NULL) {
		InterfacePtr->UnRegisterDlgWnd(SkeletonHWND);		
		InterfacePtr->DeleteRollupPage(SkeletonHWND);
	  	SkeletonHWND = NULL;				
	}
}

void SkinWSMObjectClass::BeginEditParams(IObjParam  *ip, ULONG flags,Animatable *prev)
{
	OutputDebugString("BeginEditParams\n");
	SimpleWSMObject::BeginEditParams(ip,flags,prev);
	Interface* interf = GetCOREInterface();
	IObjParam* iop = interf->GetIObjParam();
	/*
	** save off a copy of the interface pointer
	*/
	InterfacePtr = ip;

	/*
	** Install the "supports objects of type" rollup
	*/
	if (SotHWND == NULL) {
		SotHWND = ip->AddRollupPage( 
					AppInstance, 
					MAKEINTRESOURCE(IDD_SKIN_SOT),
					_sot_dialog_proc,
					Get_String(IDS_SOT), 
					(LPARAM)InterfacePtr,
					APPENDROLL_CLOSED);
	} else {
		SetWindowLong(SotHWND,GWL_USERDATA,(LPARAM)ip);
	}

	/*
	** Install the skeleton rollup
	*/
	if (SkeletonHWND == NULL) {
		SkeletonHWND = InterfacePtr->AddRollupPage( 
					AppInstance, 
					MAKEINTRESOURCE(IDD_SKELETON_PARAMETERS),
					_skeleton_dialog_thunk,
					Get_String(IDS_SKELETON_PARAMETERS), 
					(LPARAM)this,
					0);
	} else {
		SetWindowLong(SkeletonHWND,GWL_USERDATA,(LPARAM)this);
	}

	Update_Bone_List();
}

void SkinWSMObjectClass::EndEditParams(IObjParam *ip, ULONG flags,Animatable *next)
{
	OutputDebugString("SkinWSMObjectClass::EndEditParams");
	SimpleWSMObject::EndEditParams(ip,flags,next);

	if (flags & END_EDIT_REMOVEUI) {
		/*
		** Remove the Sot rollup
		*/
		if (SotHWND != NULL) {
			InterfacePtr->UnRegisterDlgWnd(SotHWND);		
			InterfacePtr->DeleteRollupPage(SotHWND);
	  		SotHWND = NULL;				
		}
	
		/*
		** Remove the info rollup
		*/
		if (SkeletonHWND != NULL) {
			InterfacePtr->UnRegisterDlgWnd(SkeletonHWND);		
			InterfacePtr->DeleteRollupPage(SkeletonHWND);
	  		SkeletonHWND = NULL;				
		}
	}

	/*
	** get rid of our copy of the interface pointer
	*/
	InterfacePtr = NULL;
}

RefTargetHandle SkinWSMObjectClass::Clone(RemapDir & remap)
{
	/*
	** create another SkinWSMObject and return it.
	*/
	SkinWSMObjectClass * sobj = new SkinWSMObjectClass();	
	return(sobj);
}

RefTargetHandle SkinWSMObjectClass::GetReference(int i)
{
	/*
	** return reference "i".  If i==0, the reference belongs
	** to SimpleWSMObject so thunk down to it.
	*/
	if (i < SimpleWSMObject::NumRefs()) {
		return SimpleWSMObject::GetReference(i);
	}

	/*
	** The rest of the references are ours.
	*/
	int boneidx = To_Bone_Index(i);
	return BoneTab[boneidx];
}

void SkinWSMObjectClass::SetReference(int i, RefTargetHandle rtarg) 
{
	if (i < SimpleWSMObject::NumRefs()) {
		SimpleWSMObject::SetReference(i,rtarg);
	} else {
		int boneidx = To_Bone_Index(i);
		assert(boneidx >= 0);
		assert(boneidx < BoneTab.Count());
		BoneTab[boneidx] = (INode *)rtarg;
	}
}		

RefResult SkinWSMObjectClass::NotifyRefChanged(Interval changeInt,RefTargetHandle hTarget,PartID& partID, RefMessage message)
{
	int i;
	switch (message) {

		case REFMSG_TARGET_DELETED:
			for (i=0; i<BoneTab.Count(); i++) {
				if (BoneTab[i] == hTarget) {
					break;
				}
			}
			if (i < BoneTab.Count()) {
				BoneTab.Delete(i,1);
				// TODO: cause all Modifier objects to re-index to accomodate
				// the deletion of this bone!!
			}
			break;

	}

	return(REF_SUCCEED);
}

CreateMouseCallBack * SkinWSMObjectClass::GetCreateMouseCallBack(void)
{
	/*
	** The "CreateMouseCallback" is used when creating the 
	** object.  Since our object doesn't need an interactive
	** creation phase, we return NULL.
	*/
	return &_SkinCreateCB;
}

Modifier * SkinWSMObjectClass::CreateWSMMod(INode *node)
{
	/*
	** create an instance of a SkinModifierClass...
	*/
	return new SkinModifierClass(node,this);
}

void SkinWSMObjectClass::BuildMesh(TimeValue t)
{
	int i;

	/*
	** We only need to build the object mesh once since it
	** doesn't change or animate...
	*/
	if (MeshBuilt) return;

	/*
	** Set our validity interval, since this mesh doesn't animate
	** we just use FOREVER.
	*/
	ivalid = FOREVER;
	
	/*
	** Ok, this is the first time BuildMesh has been called.
	** Create a mesh which will represent this space warp object in 
	** in the max viewports.  Note that we are using the mesh
	** member which is inherited from SimpleWSMObject.
	*/
	mesh.setNumVerts(NumBoneIconVerts);
	mesh.setNumFaces(NumBoneIconFaces);
	for (i=0; i<NumBoneIconVerts; i++) {
		mesh.setVert(i, Point3(BoneIconVerts[i].X, BoneIconVerts[i].Y, BoneIconVerts[i].Z));
	}
	for (i=0; i<NumBoneIconFaces; i++) {
		Build_Tri(&(mesh.faces[i]),BoneIconFaces[i].V0,BoneIconFaces[i].V1,BoneIconFaces[i].V2);
	}

	mesh.InvalidateGeomCache();
	MeshBuilt = TRUE;
}

void SkinWSMObjectClass::Build_Tri(Face * f, int a,  int b, int c) 
{
	f->setVerts(a, b, c);
	f->setSmGroup(0);
	f->setEdgeVisFlags(1,1,1);
}

void SkinWSMObjectClass::User_Picked_Bone(INode * node)
{
	OutputDebugString("SkinWSMObjectClass::User_Picked_Bone\n");
	// TODO: Undo/Redo!
	switch (BoneSelectionMode) {
		case BONE_SEL_MODE_ADD:
			Add_Bone(node);
			break;

		case BONE_SEL_MODE_REMOVE:
			Remove_Bone(node);
			break;

		default:
			assert(0);
	}
	
	Set_Bone_Selection_Mode(BONE_SEL_MODE_NONE);
	Update_Bone_List();
}

void SkinWSMObjectClass::User_Picked_Bones(INodeTab & nodetab)
{
	OutputDebugString("SkinWSMObjectClass::User_Picked_Bones\n");
	// TODO: Undo/Redo!
	switch (BoneSelectionMode) {
		case BONE_SEL_MODE_ADD_MANY:
			Add_Bones(nodetab);
			break;

		case BONE_SEL_MODE_REMOVE_MANY:
			Remove_Bones(nodetab);
			break;

		default:
			assert(0);
	}

	Set_Bone_Selection_Mode(BONE_SEL_MODE_NONE);
	Update_Bone_List();
}

void SkinWSMObjectClass::Set_Bone_Selection_Mode(int mode)
{
	assert(mode >= BONE_SEL_MODE_NONE);
	assert(mode <= BONE_SEL_MODE_REMOVE_MANY);
	
	/*
	** store the selection mode
	*/
	BoneSelectionMode = mode;

	/*
	** update the dialog box buttons
	*/
	AddBonesButton->SetCheck(mode == BONE_SEL_MODE_ADD_MANY);
	RemoveBonesButton->SetCheck(mode == BONE_SEL_MODE_REMOVE_MANY);
}

int SkinWSMObjectClass::Add_Bone(INode * node)
{	
	OutputDebugString("Adding a bone\n");
	int refidx;
	int boneidx;

	/*
	** If we already have this bone, just return
	*/
	boneidx = Find_Bone(node);
	if (boneidx != -1) {
		return boneidx;
	}

	/*
	** Otherwise, look for a NULL bone and we'll re-use
	** its slot.  This happens when a user removes a bone or 
	** a bone in the scene is deleted.
	*/
	boneidx = Find_Bone(NULL);
	if (boneidx != -1) {
		refidx = To_Ref_Index(boneidx);
		MakeRefByID(FOREVER,refidx,node);
		return boneidx;
	}
	
	/*
	** If we made it here, add the bone to the end of the 
	** reference array.
	*/
	BoneTab.Append(1,&node);		
	boneidx = BoneTab.Count() - 1;
	refidx = To_Ref_Index(boneidx);
	MakeRefByID(FOREVER,refidx,node);
	return boneidx;
}

void SkinWSMObjectClass::Add_Bones(INodeTab & nodetab)
{	OutputDebugString("Adding bones\n");

	/*
	** Add each bone individually
	*/
	for (int i=0; i<nodetab.Count(); i++) {
		Add_Bone(nodetab[i]);
	}
}

void SkinWSMObjectClass::Remove_Bone(INode * node)
{
	int boneidx = Find_Bone(node);
	if (boneidx != -1) {
		BoneTab[boneidx] = NULL;
		DeleteReference(To_Ref_Index(boneidx));
	}
}

void SkinWSMObjectClass::Remove_Bones(INodeTab & nodetab)
{
	OutputDebugString("Remove_Bones\n");
/*
	** remove each bone
	*/
	for (int i=0; i<nodetab.Count(); i++) {
		Remove_Bone(nodetab[i]);
	}
}

void SkinWSMObjectClass::Update_Bone_List(void)
{
	OutputDebugString("SkinWSMObjectClass: Update_Bone_List\n");
	assert(BoneListHWND != NULL);

	/*
	** remove all strings in the bone listbox
	*/
	SendMessage(BoneListHWND,LB_RESETCONTENT,0,0);

	/*
	** loop through the bone tab and add the name of each
	*/
	for (int i=0; i<BoneTab.Count(); i++) {
		if (BoneTab[i] != NULL) {
			SendMessage(BoneListHWND,LB_ADDSTRING,0,(LPARAM)BoneTab[i]->GetName());
		}
	}
}

int SkinWSMObjectClass::Find_Bone(INode * node)
{
	for (int i=0; i<BoneTab.Count(); i++) {
		if (BoneTab[i] == node) return i;
	}
	return -1;
}

IOResult SkinWSMObjectClass::Save(ISave * isave)
{
	ULONG nb;
	SimpleWSMObject::Save(isave);

	/*
	** Save the number of bones
	*/
	ULONG numbones = BoneTab.Count();
	if (numbones > 0) {
		isave->BeginChunk(NUM_BONES_CHUNK);
		isave->Write(&numbones,sizeof(ULONG),&nb);
		isave->EndChunk();
	}
	return IO_OK;
}

IOResult SkinWSMObjectClass::Load(ILoad * iload)
{
	SimpleWSMObject::Load(iload);

	IOResult res;
	ULONG nb;
	int level = -1;

	while (IO_OK==(res=iload->OpenChunk())) {

		switch (iload->CurChunkID())  {

			case NUM_BONES_CHUNK: {
				ULONG numbones;
				res = iload->Read(&numbones,sizeof(numbones),&nb);
				BoneTab.SetCount(numbones);
				for (int i=0; i<BoneTab.Count(); i++) {
					BoneTab[i] = NULL;
				}
			}
			break;
		}

		iload->CloseChunk();

		if (res!=IO_OK) {
			return res;
		}
	}
	return IO_OK;
}


int SkinWSMObjectClass::Find_Closest_Bone(const Point3 & vertex)
{
	float mindist = 10000.0f;
	int minindex = -1;
	TimeValue basetime = Get_Base_Pose_Time();

	for (int boneidx = 0; boneidx < BoneTab.Count(); boneidx++) {
		
		if (BoneTab[boneidx] == NULL) continue;

		float bonedist = Bone_Distance(BoneTab[boneidx],basetime,vertex);
		if (bonedist < mindist) {
			mindist = bonedist;
			minindex = boneidx;
		}
	}

	return minindex;
}



/*******************************************************************************
**
**		SkinModifierClass
**
*******************************************************************************/

SkinModifierClass::SkinModifierClass(void)
{
	Default_Init();
}

SkinModifierClass::SkinModifierClass(INode * node,SkinWSMObjectClass * skin_obj) 
{
	Default_Init();

	/*
	** Make the reference to the space warp node.
	*/
	MakeRefByID(FOREVER,NODE_REF,node);	

	/*
	** Make reference to the WSMObject
	*/
	MakeRefByID(FOREVER,OBJ_REF,skin_obj);

}

void SkinModifierClass::Default_Init(void)
{
	SubObjSelLevel = VERTEX_SEL_LEVEL;
	WSMObjectRef = NULL;
	WSMNodeRef = NULL;	
	InterfacePtr = NULL;

	BoneInfluenceHWND = NULL;
	LinkButton = NULL;
	LinkByNameButton = NULL;
	AutoLinkButton = NULL;
	UnLinkButton = NULL;
}


RefTargetHandle SkinModifierClass::Clone(RemapDir & remap)
{
	SkinModifierClass * newmod = new SkinModifierClass(WSMNodeRef,(SkinWSMObjectClass *)WSMObjectRef);
	return newmod;
}


void SkinModifierClass::BeginEditParams(IObjParam * ip, ULONG flags,Animatable * prev)
{
	OutputDebugString("SkinModifierClass::BeginEditParams\n");
	static int i=0;

	i++;

	/*
	** Grab a copy of the interface pointer
	*/
	InterfacePtr = ip;
	
	/*
	** allocate the selection command mode for use in vertex selection
	*/
	SelectMode = new SelectModBoxCMode(this,InterfacePtr);

	/*
	** register the desired sub-object selection types.
	*/
	const TCHAR * ptype[] = { "Vertices" };
#if defined W3D_MAX4		//defined as in the project (.dsp)
	InterfacePtr->SetSubObjectLevel(1);
#else
	//---This call is obsolete from version 4.   
	InterfacePtr->RegisterSubObjectTypes( ptype, 1);
#endif
	/*
	** Restore the selection level.
	*/
	ip->SetSubObjectLevel(SubObjSelLevel);

}


void SkinModifierClass::EndEditParams(IObjParam *ip, ULONG flags,Animatable *next)
{
	OutputDebugString("SkinModifierClass::EndEditParams");
	/*
	** just checking...
	*/
	assert(ip == InterfacePtr);

	/*
	** Make sure we clear out the pick mode
	*/
	InterfacePtr->ClearPickMode();

	/*
	** remove and deallocate the selection command mode
	*/
	InterfacePtr->DeleteMode(SelectMode);
	if (SelectMode ) delete SelectMode;
	SelectMode = NULL;
		
	/*
	** Remove the rollup window(s) if needed
	*/
	if (flags & END_EDIT_REMOVEUI) {		
		Remove_Bone_Influence_Dialog();
	} 

	/*
	** Make sure we don't hang onto an invalid interface
	*/
	InterfacePtr = NULL;
}

Interval SkinModifierClass::Get_Validity(TimeValue t)
{
	/*
	** Start with an infinite interval and chop it down
	** using the validity intervals of each of the controlling bones
	*/
	Interval valid = FOREVER;

	/*
	** Now intersect the validity with the validities of all of
	** the controlling bones.
	*/
	SkinWSMObjectClass * obj = (SkinWSMObjectClass *)Get_WSMObject();

//	for (int i=0; i<obj->Num_Bones(); i++) {
//		valid &= obj->Get_Bone(i)->tmValid();	//TODO: is this right?
//	}

//	return valid;
	return Interval(t,t+1); //KLUDGE - only valid for this frame
}

RefTargetHandle SkinModifierClass::GetReference(int i)
{
	switch (i) {
		case OBJ_REF:			return WSMObjectRef;
		case NODE_REF:			return WSMNodeRef;
		default:					return NULL;
	}
}

void SkinModifierClass::SetReference(int i, RefTargetHandle rtarg)
{
	switch (i) {
		case OBJ_REF:			WSMObjectRef = (SkinWSMObjectClass *)rtarg; break;
		case NODE_REF:			WSMNodeRef = (INode *)rtarg; break;
	}
}

RefResult SkinModifierClass::NotifyRefChanged(Interval changeInt, RefTargetHandle hTarget, PartID& partID, RefMessage message) 
{
	switch (message) {

		case REFMSG_TARGET_DELETED:
	
			/*
			** This means the WSM node is being deleted. As a result,
			** we must delete ourselves. 
			*/
			DeleteMe();		// also deletes all refs and 
								// sends REFMSG_TARGET_DELETED to all Dependents
			return REF_STOP;
	}

	return(REF_SUCCEED);

}

void SkinModifierClass::ModifyObject(TimeValue t, ModContext & mc, ObjectState * os, INode * node)
{
	/*
	** Get a TriObject from the object state
	*/
	assert(os->obj->IsSubClassOf(triObjectClassID));
	TriObject *triobj = (TriObject *)os->obj;

	/*
	** Get the skin data from the ModContext.
	*/
	SkinDataClass * skindata = (SkinDataClass *)mc.localData;
	
	/*
	** If there is no skin data, allocate it
	** Also, do an initial auto attach.
	*/
	if (skindata == NULL) {
		mc.localData = skindata = new SkinDataClass(&triobj->mesh);
	}

	if (!skindata->IsValid()) {
		skindata->Validate(&triobj->mesh);
	}
	
	/*
	** If in vertex selection mode, tell the mesh to display the 
	** selected vertices and turn on vertex tick marks.  Otherwise
	** make sure vertex tick marks are off.
	*/
	if (SubObjSelLevel == VERTEX_SEL_LEVEL) {
		triobj->mesh.vertSel = skindata->VertSel;
		triobj->mesh.SetDispFlag(DISP_VERTTICKS|DISP_SELVERTS);

		if (triobj->mesh.selLevel != MESH_VERTEX) {	
			triobj->mesh.selLevel = MESH_VERTEX;
		}
	} else {
		triobj->mesh.selLevel = MESH_OBJECT;
		triobj->mesh.ClearDispFlag(DISP_VERTTICKS|DISP_SELVERTS);
	}

	/*
	** Loop through the points in the deformable object
	*/
	for (int vidx = 0; vidx < triobj->NumPoints(); vidx++) {


		// TODO: Allow multiple bone influences here...
		// issues - UI to set the weights, rebalance weights whenever
		// a bone is deleted, should also then never get NULL bones
		// and remove the need to check for NULL bones in this routine...
 
		/*
		** Get a pointer to the bone that this vertex is attached to
		*/
		InfluenceStruct * inf = &(skindata->VertData[vidx]);

		int boneidx = inf->BoneIdx[0];
		if ((boneidx != -1) && (boneidx < WSMObjectRef->Num_Bones())) {
				
			INode * bone = WSMObjectRef->Get_Bone(inf->BoneIdx[0]);

			if (bone == NULL) {
				/*
				** this bone has gone away for some reason so
				** clear this vert's bone influence index
				*/
				inf->BoneIdx[0] = -1;
	
			} else {
					
				/*
				** Ok, got the bone, now transform the point and
				** give it back to the mesh
				*/
				Point3 pnew;
				Matrix3 tm;

				pnew = triobj->GetPoint(vidx);
				
				if (os->GetTM()) {
					tm = *(os->GetTM());
				} else {
					tm.IdentityMatrix();
				}

				pnew = tm * pnew;
								
				TimeValue basetime = WSMObjectRef->Get_Base_Pose_Time();
				Matrix3 basetm = bone->GetObjectTM(basetime);
				Matrix3 curtm = bone->GetObjectTM(t);
				pnew = (pnew * Inverse(basetm)) * curtm;
				
				pnew = Inverse(tm) * pnew;

				triobj->SetPoint(vidx,pnew);
			}
		}
	}

	/*
	** Tell the object that points were changed
	*/
	triobj->PointsWereChanged();		

	/*
	** Set the validity of the updated geometry data
	*/
	triobj->UpdateValidity(GEOM_CHAN_NUM,Get_Validity(t));	
}

IOResult SkinModifierClass::Save(ISave * isave)
{
	ULONG nb;
	Modifier::Save(isave);

	/*
	** Save the sub object selection level
	*/
	short sl = SubObjSelLevel;
	isave->BeginChunk(SEL_LEVEL_CHUNK);
	isave->Write(&sl,sizeof(short),&nb);
	isave->EndChunk();

	return IO_OK;
}

IOResult SkinModifierClass::Load(ILoad * iload)
{
	Modifier::Load(iload);

	IOResult res;
	ULONG nb;
	int level = -1;

	while (IO_OK==(res=iload->OpenChunk())) {

		switch (iload->CurChunkID())  {

			case SEL_LEVEL_CHUNK: {
				short sl;
				res = iload->Read(&sl,sizeof(short),&nb);
				SubObjSelLevel = sl;
			}
			break;
		}

		iload->CloseChunk();

		if (res!=IO_OK) {
			return res;
		}
	}
	return IO_OK;
}

IOResult SkinModifierClass::SaveLocalData(ISave *isave, LocalModData *ld)
{
	SkinDataClass * skindata = (SkinDataClass *)ld;

	return skindata->Save(isave);
}

IOResult SkinModifierClass::LoadLocalData(ILoad *iload, LocalModData **pld)
{
	/*
	** Create a new SkinDataClass
	*/
	if (*pld==NULL) {
		*pld = (SkinDataClass *) new SkinDataClass();
	}
	SkinDataClass * newskin = (SkinDataClass *)*pld;

	/*
	** Initialize it from ILoad...
	*/
	return newskin->Load(iload);
}


void SkinModifierClass::ActivateSubobjSel(int level, XFormModes & modes)
{
	/*
	** Storing the current sub-object selection level
	*/
	SubObjSelLevel = level;

	/*
	** Set the appropriate command mode.  We only want selection.
	*/
	switch (SubObjSelLevel) 
	{
		case OBJECT_SEL_LEVEL:
			Remove_Bone_Influence_Dialog();
			break;

		case VERTEX_SEL_LEVEL: // Modifying Vertices
			modes = XFormModes(NULL,NULL,NULL,NULL,NULL,SelectMode);
			Install_Bone_Influence_Dialog();
			break;
	}

	/*
	** Put our named subobject selection sets into the drop down list
	*/
	Create_Named_Selection_Sets();
	
	/*
	** Notify our dependents that the subselection type, 
	** and the display have changed
	*/
	NotifyDependents(FOREVER, PART_SUBSEL_TYPE|PART_DISPLAY, REFMSG_CHANGE);

	/*
	** Notify the pipeline that the selection level has changed.
	*/
	InterfacePtr->PipeSelLevelChanged();

	/*
	** Notify our dependents that the selection channel, 
	** display attributes, and subselection type channels have changed
	*/
	NotifyDependents(FOREVER, SELECT_CHANNEL|DISP_ATTRIB_CHANNEL|SUBSEL_TYPE_CHANNEL, REFMSG_CHANGE);
}

int SkinModifierClass::HitTest
(
	TimeValue		t, 
	INode *			inode,
	int				type, 
	int				crossing, 
	int				flags, 
	IPoint2 *		p, 
	ViewExp *		vpt, 
	ModContext *	mc
)
{
	Interval valid = FOREVER;
	int needsdel;
	int savedLimits;
	int res = 0;
	HitRegion hr;
	Matrix3 mat;

	MakeHitRegion(hr,type, crossing,4,p);
	mat = inode->GetObjectTM(t);

	/*
	** Set up the graphics window to do the hit test
	*/
	GraphicsWindow *gw = vpt->getGW();
	gw->setHitRegion(&hr);
	gw->setTransform(mat);	
	gw->setRndLimits(((savedLimits = gw->getRndLimits()) | GW_PICK) & ~GW_ILLUM);
	
	if (1 /*IgnoreBackfaces*/) {
		gw->setRndLimits(gw->getRndLimits() |  GW_BACKCULL);
	} else {
		gw->setRndLimits(gw->getRndLimits() & ~GW_BACKCULL);
	}

	gw->clearHitCode();

	/*
	** Do the hit test!
	*/
	SubObjHitList hitlist;
	MeshSubHitRec * rec;	
	
	ObjectState os = inode->EvalWorldState(InterfacePtr->GetTime());
	TriObject * tobj = Get_Tri_Object(InterfacePtr->GetTime(),os,valid,needsdel);
	res = tobj->mesh.SubObjectHitTest(gw,gw->getMaterial(),&hr,flags | SUBHIT_VERTS,hitlist);
	
	/*
	** Record all of the hits
	*/
	rec = hitlist.First();
	while (rec) 
	{
		/*
		** rec->index is the index of vertex which was hit!
		** Remember that we are always turning on vertex hit testing;
		** if we were testing for edges, index would be the edge index.
		*/
		vpt->LogHit(inode,mc,rec->dist,rec->index,NULL);
		rec = rec->Next();
	}

	/*
	** Cleanup
	*/
	gw->setRndLimits(savedLimits);	
	
	if (needsdel) {
		tobj->DeleteThis();
	}

	return res;	
}

void SkinModifierClass::SelectSubComponent(HitRecord *hitRec, BOOL selected, BOOL all, BOOL invert)
{
	SkinDataClass * skindata = NULL;
	int count = 0;

	switch (SubObjSelLevel) {
		
		case VERTEX_SEL_LEVEL:

			while (hitRec) {				

				skindata = (SkinDataClass *)hitRec->modContext->localData;				

				/*
				** Undo/Redo functionality
				*/
#if 0
				if (theHold.Holding() && !SelData->held) {
					theHold.Put(new SubSelRestore(this,SelData));
				}
				theHold.Accept(_T("Select Vertex"));
#endif
				
				BitArray * array = &(skindata->VertSel);

				if (all & invert) {

					/*
					** hitRec->hitInfo is the MeshSubHitRec::index that was stored in the
					** HitTest method through LogHit
					*/
					if ((*array)[hitRec->hitInfo]) {
						array->Clear(hitRec->hitInfo);
					} else {
						array->Set(hitRec->hitInfo,selected);
					}
				} else {
					array->Set(hitRec->hitInfo,selected);
				}
				
				if (!all) break;
				hitRec = hitRec->Next();
			}
			break;
	}

	NotifyDependents(FOREVER, PART_SELECT, REFMSG_CHANGE);
}

void SkinModifierClass::ClearSelection(int selLevel)
{
	int needsdel = 0;
	Interval valid = FOREVER;
	ModContextList mcList;
	INodeTab nodes;

	if (!InterfacePtr ) return;	
	
	InterfacePtr->GetModContexts(mcList,nodes);
	InterfacePtr->ClearCurNamedSelSet();

	for (int i = 0; i < mcList.Count(); i++) {

		SkinDataClass * skindata = (SkinDataClass *)mcList[i]->localData;
		
		if (skindata==NULL) continue;		
		
		ObjectState os = nodes[i]->EvalWorldState(InterfacePtr->GetTime());
		TriObject * tobj = Get_Tri_Object(InterfacePtr->GetTime(),os,valid,needsdel);

		switch (SubObjSelLevel) {
#if 0
			case OBJECT_SEL_LEVEL:
				assert(0);
				return;
#endif

			case VERTEX_SEL_LEVEL:	
#if 0 // undo/redo
				if (theHold.Holding()) {
					theHold.Put(new VertexSelRestore(meshData,this));
				}
#endif
				tobj->mesh.vertSel.ClearAll();
				skindata->VertSel.ClearAll();
				break;
		}

		if (needsdel) {
			tobj->DeleteThis();
		}
	}
	
	/*
	** Get rid of the temporary copies of the INodes.
	*/
	nodes.DisposeTemporary();

	/*
	** Tell our dependents that the selection set has changed
	*/
	NotifyDependents(FOREVER, PART_SELECT, REFMSG_CHANGE);

}

void SkinModifierClass::SelectAll(int selLevel)
{
	int needsdel = 0;
	Interval valid = FOREVER;
	ModContextList mclist;
	INodeTab nodes;

	if (!InterfacePtr) return;	
	
	InterfacePtr->GetModContexts(mclist,nodes);
	InterfacePtr->ClearCurNamedSelSet();

	for (int i = 0; i < mclist.Count(); i++) {

		SkinDataClass * skindata = (SkinDataClass *)mclist[i]->localData;
		
		if (skindata==NULL) continue;		
		
		ObjectState os = nodes[i]->EvalWorldState(InterfacePtr->GetTime());
		TriObject * tobj = Get_Tri_Object(InterfacePtr->GetTime(),os,valid,needsdel);

		switch (SubObjSelLevel) {

			case OBJECT_SEL_LEVEL:
				assert(0);
				return;

			case VERTEX_SEL_LEVEL:	
#if 0 // undo/redo
				if (theHold.Holding()) {
					theHold.Put(new VertexSelRestore(meshData,this));
				}
#endif
				tobj->mesh.vertSel.SetAll();
				skindata->VertSel.SetAll();
				break;
		}

		if (needsdel) {
			tobj->DeleteThis();
		}
	}
	
	/*
	** Get rid of the temporary copies of the INodes.
	*/
	nodes.DisposeTemporary();

	/*
	** Tell our dependents that the selection set has changed
	*/
	NotifyDependents(FOREVER, PART_SELECT, REFMSG_CHANGE);
}

void SkinModifierClass::InvertSelection(int selLevel)
{
	int needsdel = 0;
	Interval valid = FOREVER;
	ModContextList mclist;
	INodeTab nodes;

	if (!InterfacePtr) return;	
	
	InterfacePtr->GetModContexts(mclist,nodes);
	InterfacePtr->ClearCurNamedSelSet();

	for (int i = 0; i < mclist.Count(); i++) {

		SkinDataClass * skindata = (SkinDataClass *)mclist[i]->localData;
		
		if (skindata==NULL) continue;		
		
		ObjectState os = nodes[i]->EvalWorldState(InterfacePtr->GetTime());
		TriObject * tobj = Get_Tri_Object(InterfacePtr->GetTime(),os,valid,needsdel);

		switch (SubObjSelLevel) {

			case OBJECT_SEL_LEVEL:
				assert(0);
				return;

			case VERTEX_SEL_LEVEL:	
#if 0 // undo/redo
				if (theHold.Holding()) {
					theHold.Put(new VertexSelRestore(meshData,this));
				}
#endif
				for (int j=0; j<tobj->mesh.vertSel.GetSize(); j++) {
					if (tobj->mesh.vertSel[j]) tobj->mesh.vertSel.Clear(j);
					else tobj->mesh.vertSel.Set(j);
				}				
				skindata->VertSel = tobj->mesh.vertSel;
				break;
		}

		if (needsdel) {
			tobj->DeleteThis();
		}
	}
	
	/*
	** Get rid of the temporary copies of the INodes.
	*/
	nodes.DisposeTemporary();

	/*
	** Tell our dependents that the selection set has changed
	*/
	NotifyDependents(FOREVER, PART_SELECT, REFMSG_CHANGE);

}

void SkinModifierClass::User_Picked_Bone(INode * node)
{
	assert(InterfacePtr != NULL);

	/*
	** Get a pointer to the ModContext and SkinData for
	** the mesh currently being messed with.
	*/
	ModContext * mc = NULL;
	ModContextList mclist;
	INodeTab nodelist;

	InterfacePtr->GetModContexts(mclist,nodelist);
	
	/*
	** This seems wrong... But I always get only one ModContext and
	** it is the one that I want so I'll just use it...  
	** I believe that OS Modifiers can get multiple ones but WS modifiers
	** don't
	*/
	mc = mclist[0];
	assert(mc != NULL);
	SkinDataClass * skindata = (SkinDataClass *)(mc->localData);

	/*
	** Add this bone to the influences of all selected vertices
	*/
	int boneidx = WSMObjectRef->Find_Bone(node);
	assert(boneidx != -1);
	skindata->Add_Influence(boneidx);

	/*
	** Recreate all of the named selection sets!
	*/
	Create_Named_Selection_Sets();

	/*
	** Update dependents and redraw the views.
	*/
	NotifyDependents(FOREVER, PART_ALL, REFMSG_CHANGE);
	InterfacePtr->RedrawViews(InterfacePtr->GetTime());
}
	
void SkinModifierClass::User_Picked_Bones(INodeTab & nodetab)
{
	/*
	** One by one, add the selected bones to the influences of
	** all selected vertices.  
	*/
	for (int i=0; i<nodetab.Count() && i<2; i++) {
		User_Picked_Bone(nodetab[i]);
	}
}

void SkinModifierClass::ActivateSubSelSet(TSTR & setname)
{OutputDebugString("SkinModifierClass::ActivateSubSelSet\n");

	ModContextList mclist;
	INodeTab nodes;
	
	if (InterfacePtr == NULL) return;

	InterfacePtr->GetModContexts(mclist,nodes);

	for (int i = 0; i < mclist.Count(); i++) {

		SkinDataClass * skindata = (SkinDataClass *)mclist[i]->localData;
		if (!skindata) continue;		
	
		int index = skindata->VertSelSets.Find_Set(setname);
		if (index < 0) continue;

		int needsdel;
		Interval valid;
		ObjectState os = nodes[i]->EvalWorldState(InterfacePtr->GetTime());
		TriObject * tobj = Get_Tri_Object(InterfacePtr->GetTime(),os,valid,needsdel);
		Mesh * mesh = &(tobj->mesh);
		
		// TODO: undo redo
#if 0
		if (theHold.Holding()) {
			theHold.Put(new VertexSelRestore(meshData,this));
		}
#endif
				
		if (skindata->VertSelSets[index].GetSize() != mesh->getNumVerts()) {
			skindata->VertSelSets[index].SetSize(mesh->getNumVerts(),TRUE);
		}
		mesh->vertSel  = skindata->VertSelSets[index];
		skindata->VertSel = mesh->vertSel;
	
		if (needsdel) {
			tobj->DeleteThis();
		}
	}
	
	nodes.DisposeTemporary();	

	NotifyDependents(FOREVER, PART_SELECT, REFMSG_CHANGE);
	InterfacePtr->RedrawViews(InterfacePtr->GetTime());
}

void SkinModifierClass::NewSetFromCurSel(TSTR &setname)
{
	Install_Named_Selection_Sets();
}

void SkinModifierClass::RemoveSubSelSet(TSTR &setname)
{
	Install_Named_Selection_Sets();
}

void SkinModifierClass::Create_Named_Selection_Sets(void)
{
	/*
	** This function creates a named selection set of vertices
	** for each bone in the skeleton.  
	*/
	if (InterfacePtr == NULL) return;

	SkinWSMObjectClass * skinobj = WSMObjectRef;
	if (skinobj == NULL) return;

	ModContextList mclist;
	INodeTab nodes;
	InterfacePtr->GetModContexts(mclist,nodes);
	SkinDataClass * skindata = (SkinDataClass *)mclist[0]->localData;
	if (skindata == NULL) return;

	/*
	** Clear out the old selection sets
	*/
	skindata->VertSelSets.Reset();

	/*
	** Create and add a set for each bone
	*/
	for (int boneidx = 0; boneidx < skinobj->Num_Bones(); boneidx++) {

		if (skinobj->Get_Bone(boneidx) != NULL) {
			BitArray boneverts;
			boneverts.SetSize(skindata->VertData.Count());
			
			for (int vertidx = 0; vertidx < skindata->VertData.Count(); vertidx++) {
				if (skindata->VertData[vertidx].BoneIdx[0] == boneidx) boneverts.Set(vertidx);
				else boneverts.Clear(vertidx);
			}

			TSTR bonename = skinobj->Get_Bone(boneidx)->GetName();

			skindata->VertSelSets.Append_Set(boneverts,bonename);
		}
	}

	Install_Named_Selection_Sets();

	nodes.DisposeTemporary();	
}

void SkinModifierClass::Install_Named_Selection_Sets(void)
{
	/*
	** If we are in sub-object selection mode add the sets
	** to the drop down box.
	*/
	if ((SubObjSelLevel == VERTEX_SEL_LEVEL) && (InterfacePtr != NULL)) {

		ModContextList mclist;
		INodeTab nodes;
		InterfacePtr->GetModContexts(mclist,nodes);
		SkinDataClass * skindata = (SkinDataClass *)mclist[0]->localData;
		if (skindata == NULL) return;
		
		InterfacePtr->ClearSubObjectNamedSelSets();
		for (int i=0; i < skindata->VertSelSets.Count(); i++) {
			InterfacePtr->AppendSubObjectNamedSelSet(*skindata->VertSelSets.Names[i]);
		}

		nodes.DisposeTemporary();
	}	
}

void SkinModifierClass::Auto_Attach_Verts(BOOL all)
{
	assert(InterfacePtr);

	/*
	** Get the skin data. 
	*/
	ModContextList mclist;
	INodeTab nodes;
	InterfacePtr->GetModContexts(mclist,nodes);
	SkinDataClass * skindata = (SkinDataClass *)mclist[0]->localData;
	if (skindata == NULL) return;
	
	/*
	** get the skin WSM object.
	*/
	SkinWSMObjectClass * skinobj = WSMObjectRef;
	if (skinobj == NULL) return;

	/*
	** Get a triobject representing the object state in the base pose.
	*/
	Interval valid;
	BOOL needsdel;

	TimeValue basetime = WSMObjectRef->Get_Base_Pose_Time();
	ObjectState os = nodes[0]->EvalWorldState(basetime);
	TriObject * triobj = Get_Tri_Object(basetime,os,valid,needsdel);
		
	/*
	** Attach each selected vertex (or all of them) to their closest bone.
	*/
	for (int vertidx = 0; vertidx < skindata->VertData.Count(); vertidx++){
		if (skindata->VertSel[vertidx] || all) {
			
			Point3 vert = triobj->GetPoint(vertidx);
			if (os.GetTM()) vert = vert * (*os.GetTM());
			int boneidx = skinobj->Find_Closest_Bone(vert);
			skindata->VertData[vertidx].Set_Influence(boneidx);
		}
	}

	/*
	** Re-create the named selection sets
	*/
	Create_Named_Selection_Sets();

	/*
	** Update dependents and redraw the views.
	*/
	NotifyDependents(FOREVER, PART_ALL, REFMSG_CHANGE);
	InterfacePtr->RedrawViews(InterfacePtr->GetTime());

	/*
	** Cleanup...
	*/
	nodes.DisposeTemporary();
	
	if (needsdel) {
		triobj->DeleteThis();
	}
}

void SkinModifierClass::Unlink_Verts(void)
{
	assert(InterfacePtr);

	/*
	** Get the skin data. 
	*/
	ModContextList mclist;
	INodeTab nodes;
	InterfacePtr->GetModContexts(mclist,nodes);
	SkinDataClass * skindata = (SkinDataClass *)mclist[0]->localData;
	if (skindata == NULL) return;
	
	/*
	** Unlink each selected vertex (give them bone index -1)
	*/
	for (int vertidx = 0; vertidx < skindata->VertData.Count(); vertidx++){
		if (skindata->VertSel[vertidx]) {
			skindata->VertData[vertidx].Set_Influence(-1);
		}
	}

	/*
	** Re-create the named selection sets
	*/
	Create_Named_Selection_Sets();

	/*
	** Update dependents and redraw the views.
	*/
	NotifyDependents(FOREVER, PART_ALL, REFMSG_CHANGE);
	InterfacePtr->RedrawViews(InterfacePtr->GetTime());

	/*
	** Cleanup...
	*/
	nodes.DisposeTemporary();
}


/****************************************************************************
**
**    DIALOG BOX JUNK
**
****************************************************************************/

void SkinModifierClass::Install_Bone_Influence_Dialog(void)
{
	if (BoneInfluenceHWND != NULL) return;

	/*
	** loading resource string for the name of the dialog
	*/
	static int loaded = 0;
	static TCHAR string[MAX_STRING_LENGTH];

	if (!loaded) {
		LoadString(AppInstance,IDS_BONE_INFLUENCE_PARAMS,string,MAX_STRING_LENGTH);
		loaded = 1;
	}

	/*
	** Put up the UI that is used to assign vertices to bones
	*/
	BoneInfluenceHWND = InterfacePtr->AddRollupPage( 
				AppInstance,
				MAKEINTRESOURCE(IDD_BONE_INFLUENCE_PARAMS),
				_bone_influence_dialog_thunk,
				string, 
				(LPARAM)this,
				0);
}

void SkinModifierClass::Remove_Bone_Influence_Dialog(void)
{
	/*
	** If it is currently up, remove the bone influences dialog
	*/
	if (BoneInfluenceHWND != NULL) {
		InterfacePtr->UnRegisterDlgWnd(BoneInfluenceHWND);
		InterfacePtr->DeleteRollupPage(BoneInfluenceHWND);
		BoneInfluenceHWND = NULL;
	}
}

/*********************************************************************************
*
* _sot_dialog_proc
*
*********************************************************************************/
static BOOL CALLBACK _sot_dialog_proc(HWND hWnd,UINT message,WPARAM wParam,LPARAM lParam)
{
	IObjParam *ip = (IObjParam*)GetWindowLong(hWnd,GWL_USERDATA);

	switch (message) {
		case WM_INITDIALOG:
			SetWindowLong(hWnd,GWL_USERDATA,lParam);
			break;

		case WM_LBUTTONDOWN:
		case WM_LBUTTONUP:
		case WM_MOUSEMOVE:
			if (ip) ip->RollupMouseMessage(hWnd,message,wParam,lParam);
			return FALSE;

		default:
			return FALSE;
	}
	return TRUE;
}


/*********************************************************************************
*
* _skeleton_dialog_proc
*
*********************************************************************************/
static BOOL CALLBACK _skeleton_dialog_thunk(HWND hWnd,UINT message,WPARAM wParam,LPARAM lParam)
{
	SkinWSMObjectClass * skinobj = (SkinWSMObjectClass *)GetWindowLong(hWnd,GWL_USERDATA);
	if (!skinobj && message != WM_INITDIALOG) return FALSE;
	
	if (message == WM_INITDIALOG) {
		skinobj = (SkinWSMObjectClass *)lParam;
		SetWindowLong(hWnd,GWL_USERDATA,(LONG)skinobj);			
	}

	return skinobj->Skeleton_Dialog_Proc(hWnd,message,wParam,lParam);
}

BOOL SkinWSMObjectClass::Skeleton_Dialog_Proc(HWND hWnd,UINT message,WPARAM wParam,LPARAM lParam)
{
	switch (message) {

		case WM_INITDIALOG:

			BoneListHWND = GetDlgItem(hWnd,IDC_BONE_LIST);

			/*
			** Intitialize the add bone and remove bone check buttons
			*/
			AddBonesButton = GetICustButton(GetDlgItem(hWnd, IDC_ADD_BONES_BUTTON));
			RemoveBonesButton = GetICustButton(GetDlgItem(hWnd, IDC_REMOVE_BONES_BUTTON));
			
			AddBonesButton->SetType(CBT_CHECK);
			AddBonesButton->SetHighlightColor(GREEN_WASH);
			AddBonesButton->SetTooltip(TRUE, _T("Add bones by name"));

			RemoveBonesButton->SetType(CBT_CHECK);
			RemoveBonesButton->SetHighlightColor(GREEN_WASH);
			RemoveBonesButton->SetTooltip(TRUE, _T("Remove bones by name"));
	
			/*
			** Initialize the "Base Pose Frame" spinner
			*/
			BasePoseSpin = GetISpinner(GetDlgItem(hWnd, IDC_BASE_POSE_SPIN));
			BasePoseSpin->SetLimits(0,9999, FALSE);
			BasePoseSpin->SetValue(0,FALSE);
			BasePoseSpin->SetResetValue(0);
			BasePoseSpin->LinkToEdit(GetDlgItem(hWnd,IDC_BASE_POSE_EDIT),EDITTYPE_INT);
			return TRUE;

		case WM_DESTROY:
			ReleaseICustButton(AddBonesButton);
			ReleaseICustButton(RemoveBonesButton);
			ReleaseISpinner(BasePoseSpin);
			
			AddBonesButton = NULL;
			RemoveBonesButton = NULL;
			BasePoseSpin = NULL;
			BoneListHWND = NULL;
			
			return FALSE;
	
		case CC_SPINNER_CHANGE:
			switch (LOWORD(wParam)) 
			{
				case IDC_BASE_POSE_SPIN:
					BasePoseFrame = BasePoseSpin->GetIVal();						
					break;
			}
			NotifyDependents(FOREVER, PART_ALL, REFMSG_CHANGE);
			InterfacePtr->RedrawViews(InterfacePtr->GetTime(),REDRAW_INTERACTIVE);
			return TRUE;

		case CC_SPINNER_BUTTONUP:
			NotifyDependents(FOREVER, PART_ALL, REFMSG_CHANGE);
			InterfacePtr->RedrawViews(InterfacePtr->GetTime(),REDRAW_END);
			return TRUE;

		
		case WM_LBUTTONDOWN:
		case WM_LBUTTONUP:
		case WM_MOUSEMOVE:
			InterfacePtr->RollupMouseMessage(hWnd,message,wParam,lParam);
			return FALSE;

		case WM_COMMAND:
			switch (LOWORD(wParam)) 
			{

				case IDC_ADD_BONES_BUTTON:
					TheBonePicker.Set_User(this);
					Set_Bone_Selection_Mode(BONE_SEL_MODE_ADD_MANY);
					InterfacePtr->DoHitByNameDialog(&TheBonePicker);
					Set_Bone_Selection_Mode(BONE_SEL_MODE_NONE);
					break;

				case IDC_REMOVE_BONES_BUTTON:
					TheBonePicker.Set_User(this,FALSE,&(BoneTab));
					Set_Bone_Selection_Mode(BONE_SEL_MODE_REMOVE_MANY);
					InterfacePtr->DoHitByNameDialog(&TheBonePicker);
					Set_Bone_Selection_Mode(BONE_SEL_MODE_NONE);
					break;
			}

		default:
			return FALSE;
	}
}

/*********************************************************************************
*
* Bone_Influence_Dialog_Proc
*
*********************************************************************************/
static BOOL CALLBACK _bone_influence_dialog_thunk(HWND hWnd,UINT message,WPARAM wParam,LPARAM lParam)
{
	SkinModifierClass * skinmod = (SkinModifierClass *)GetWindowLong(hWnd,GWL_USERDATA);
	if (!skinmod && message != WM_INITDIALOG) return FALSE;
	
	if (message == WM_INITDIALOG) {
			skinmod = (SkinModifierClass *)lParam;
			SetWindowLong(hWnd,GWL_USERDATA,(LONG)skinmod);			
	}

	return skinmod->Bone_Influence_Dialog_Proc(hWnd,message,wParam,lParam);
}


BOOL SkinModifierClass::Bone_Influence_Dialog_Proc(HWND hWnd,UINT message,WPARAM wParam,LPARAM lParam)
{
	switch (message) {

		case WM_INITDIALOG:
			/*
			** Intitialize the bone influence buttons
			*/
			LinkButton = GetICustButton(GetDlgItem(hWnd, IDC_LINK_BUTTON));
			LinkByNameButton = GetICustButton(GetDlgItem(hWnd, IDC_LINK_BY_NAME_BUTTON));
			AutoLinkButton = GetICustButton(GetDlgItem(hWnd, IDC_AUTO_LINK_BUTTON));
			UnLinkButton = GetICustButton(GetDlgItem(hWnd, IDC_UNLINK_BUTTON));
			
			LinkButton->SetType(CBT_PUSH);
			LinkButton->SetTooltip(TRUE, _T("Link Vertices to a bone by selecting the bone"));

			LinkByNameButton->SetType(CBT_PUSH);
			LinkByNameButton->SetTooltip(TRUE, _T("Link Vertices to a bone by name"));
			
			AutoLinkButton->SetType(CBT_PUSH);
			AutoLinkButton->SetTooltip(TRUE, _T("Link Vertices to nearest bone"));
			
			UnLinkButton->SetType(CBT_PUSH);
			UnLinkButton->SetTooltip(TRUE, _T("Unlink selected vertices"));
			
			return TRUE;

		case WM_DESTROY:
			ReleaseICustButton(LinkButton);
			ReleaseICustButton(LinkByNameButton);
			ReleaseICustButton(AutoLinkButton);
			ReleaseICustButton(UnLinkButton);

			LinkButton = NULL;
			LinkByNameButton = NULL;
			AutoLinkButton = NULL;
			UnLinkButton = NULL;
			return FALSE;

		case WM_LBUTTONDOWN:
		case WM_LBUTTONUP:
		case WM_MOUSEMOVE:
			InterfacePtr->RollupMouseMessage(hWnd,message,wParam,lParam);
			return FALSE;

		case WM_COMMAND:
			switch (LOWORD(wParam)) 
			{
				case IDC_LINK_BUTTON:
				{
					/*
					** user picks a bone out of the scene to link to.
					*/
					assert(WSMObjectRef != NULL);
					INodeTab * bonetab = &(WSMObjectRef->Get_Bone_List());
					TheBonePicker.Set_User(this,TRUE,bonetab);
					InterfacePtr->SetPickMode(&TheBonePicker); 
					break;
				}

				case IDC_LINK_BY_NAME_BUTTON:
				{
					/*
					** pop up a bone selection dialog
					*/
					assert(WSMObjectRef != NULL);
					INodeTab * bonetab = &(WSMObjectRef->Get_Bone_List());
					TheBonePicker.Set_User(this,TRUE,bonetab);
					InterfacePtr->DoHitByNameDialog(&TheBonePicker);
					break;
				}

				case IDC_AUTO_LINK_BUTTON:
				{
					Auto_Attach_Verts();					
					break;
				}
				
				case IDC_UNLINK_BUTTON:
				{
					Unlink_Verts();
					break;
				}
			}

		default:
			return FALSE;
	}
}

static TriObject * Get_Tri_Object(TimeValue t,ObjectState & os,Interval & valid,BOOL & needsdel)
{	
	needsdel = FALSE;
	valid &= os.Validity(t);
	
	if (os.obj->IsSubClassOf(triObjectClassID)) {
		return (TriObject *)os.obj;
	} else {
		if (os.obj->CanConvertToType(triObjectClassID)) {
			Object * oldObj = os.obj;
			TriObject * tobj = (TriObject *)os.obj->ConvertToType(t,triObjectClassID);			
			needsdel = (tobj != oldObj);			
			return tobj;
		}
	}
	return NULL;
}


float Bone_Distance(INode * bone,TimeValue time,const Point3 & vertex)
{
	/*
	** Average the pivot point of this bone with the pivot points of
	** all of its children.
	*/
	Point3 icenter = bone->GetObjectTM(time).GetTrans();

	for (int ci=0; ci<bone->NumberOfChildren(); ci++) {
		icenter += bone->GetChildNode(ci)->GetObjectTM(time).GetTrans();
	}

	icenter = icenter / (float)(bone->NumberOfChildren() + 1);

	return Length(icenter - vertex);
}

#if defined W3D_MAX4		//defined as in the project (.dsp)

int SkinModifierClass::NumSubObjTypes()
{
	return 1;
}
////////////////////////////////////////////////////////////////////////////////////////
ISubObjType *SkinModifierClass::GetSubObjType(int i) 
{

	static bool _initialized = false;
	if(!_initialized){
		_initialized = true;
		_SubObjectTypeVertex.SetName("Vertices");
	}
	if(i == -1){
		if(GetSubObjectLevel() > 0){
			return GetSubObjType(GetSubObjectLevel()-1);
		}
	}
	return &_SubObjectTypeVertex;
}
#endif