nigger/CnC_Generals_Zero_Hour
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
CnC_Generals_Zero_Hour/GeneralsMD/Code/Tools/WW3D/max2w3d/skin.cpp

1917 lines
45 KiB
C++
Raw Permalink Normal View History

Initial commit of Command & Conquer Generals and Command & Conquer Generals Zero Hour source code.
2025-02-27 17:34:39 +00:00
/*
** Command & Conquer Generals Zero Hour(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:: Greg_h $*
* *
* $Modtime:: 4/24/01 5:15p $*
* *
* $Revision:: 13 $*
* *
*---------------------------------------------------------------------------------------------*
* 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)
{
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)
{
SimpleWSMObject::BeginEditParams(ip,flags,prev);
/*
** 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)
{
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)
{
// 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)
{
// 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)
{
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)
{
/*
** 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)
{
/*
** remove each bone
*/
for (int i=0; i<nodetab.Count(); i++) {
Remove_Bone(nodetab[i]);
}
}
void SkinWSMObjectClass::Update_Bone_List(void)
{
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)
{
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)
{
/*
** 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)
{
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
Reference in New Issue Copy Permalink