#pragma warning( disable:4800 )
#include <map>
#include "NifProps.h"
#include "NifStrings.h"
#include "NifPlugins.h"
#include "NifGui.h"
#include "bhkRigidBodyInterface.h"
using namespace std;
#define PBLOCK_REF 0
const Class_ID BHKRIGIDBODYMODIFIER_CLASS_ID = Class_ID(0x398fd801, 0x303e44e5);
class PickObjectMode;
extern void BuildBox(Mesh&mesh, float l, float w, float h);
extern void BuildSphere(Mesh&mesh, float radius, int segs=32, int smooth=1, float startAng = 0.0f);
extern void BuildScubaMesh(Mesh &mesh, int segs, int smooth, int llsegs,
float radius1, float radius2, float cylh);
void CalcAxisAlignedBox(Mesh& mesh, Box3& box)
{
int nv = mesh.getNumVerts();
box.IncludePoints(mesh.getVertPtr(0), nv, NULL);
}
// Calculate bounding sphere using minimum-volume axis-align bounding box. Its fast but not a very good fit.
void CalcAxisAlignedSphere(Mesh& mesh, Point3& center, float& radius)
{
//--Calculate center & radius--//
//Set lows and highs to first vertex
int nv = mesh.getNumVerts();
Point3 lows = mesh.getVert(0);
Point3 highs = mesh.getVert(0);
//Iterate through the vertices, adjusting the stored values
//if a vertex with lower or higher values is found
for ( unsigned int i = 0; i < nv; ++i ) {
const Point3 & v = mesh.getVert(i);
if ( v.x > highs.x ) highs.x = v.x;
else if ( v.x < lows.x ) lows.x = v.x;
if ( v.y > highs.y ) highs.y = v.y;
else if ( v.y < lows.y ) lows.y = v.y;
if ( v.z > highs.z ) highs.z = v.z;
else if ( v.z < lows.z ) lows.z = v.z;
}
//Now we know the extent of the shape, so the center will be the average
//of the lows and highs
center = (highs + lows) / 2.0f;
//The radius will be the largest distance from the center
Point3 diff;
float dist2(0.0f), maxdist2(0.0f);
for ( unsigned int i = 0; i < nv; ++i ) {
const Point3 & v = mesh.getVert(i);
diff = center - v;
dist2 = diff.x * diff.x + diff.y * diff.y + diff.z * diff.z;
if ( dist2 > maxdist2 ) maxdist2 = dist2;
};
radius = sqrt(maxdist2);
}
// Calculate bounding sphere using average position of the points. Better fit but slower.
void CalcCenteredSphere(Mesh& mesh, Point3& center, float& radius)
{
int nv = mesh.getNumVerts();
Point3 sum;
for (int i=0; i<nv; ++i)
sum += mesh.getVert(i);
center = sum / float(nv);
float radsq = 0.0f;
for (int i=0; i<nv; ++i){
Point3 diff = mesh.getVert(i) - center;
float mag = diff.LengthSquared();
radsq = max(radsq, mag);
}
radius = Sqrt(radsq);
}
class bhkValidatorClass : public PBValidator
{
public:
class bhkRigidBodyModifier *mod;
private:
BOOL Validate(PB2Value &v)
{
INode *node = (INode*) v.r;
if (node->TestForLoop(FOREVER,(ReferenceMaker *) mod)!=REF_SUCCEED) return FALSE;
ObjectState os = node->EvalWorldState(0);
//Allow only tri object derived objects
if (os.obj->CanConvertToType(triObjectClassID) && os.obj->SuperClassID() != SHAPE_CLASS_ID) {
return TRUE;
}
// and out objects which support the RigidBodyInterface
if (os.obj->SuperClassID() == HELPER_CLASS_ID && NULL != GetInterface(BHKRIGIDBODYINTERFACE_DESC)) {
return TRUE;
}
if (os.obj->SuperClassID() == HELPER_CLASS_ID && os.obj->ClassID().PartB() == BHKRIGIDBODYCLASS_DESC.PartB() ) {
return TRUE;
}
return FALSE;
};
};
enum { bv_type_none, bv_type_box, bv_type_sphere, bv_type_capsule, bv_type_mesh }; // pblock ID
class bhkRigidBodyModifier : public Modifier, public bhkRigidBodyIfcHelper
{
public:
bhkRigidBodyModifier();
~bhkRigidBodyModifier();
void DeleteThis() { delete this; }
void GetClassName(TSTR& s) { s = "bhkRigidBodyModifier"; }
virtual Class_ID ClassID() { return BHKRIGIDBODYMODIFIER_CLASS_ID; }
RefTargetHandle Clone(RemapDir& remap);
TCHAR *GetObjectName() { return "bhkRigidBodyModifier"; }
// From modifier
ChannelMask ChannelsUsed() {return PART_GEOM|PART_TOPO;}
ChannelMask ChannelsChanged() {return PART_GEOM;}
// ChannelMask ChannelsUsed() { return 0; }
// ChannelMask ChannelsChanged() { return 0; }
Class_ID InputType() { return mapObjectClassID; }
void ModifyObject (TimeValue t, ModContext &mc, ObjectState *os, INode *node);
Interval LocalValidity(TimeValue t) { return GetValidity(t); }
Interval GetValidity (TimeValue t);
BOOL DependOnTopology(ModContext &mc) { return TRUE; }
void NotifyInputChanged(Interval changeInt, PartID partID, RefMessage message, ModContext *mc);
void BeginEditParams (IObjParam *ip, ULONG flags,Animatable *prev);
void EndEditParams (IObjParam *ip,ULONG flags,Animatable *next);
int Display(TimeValue t, INode* inode, ViewExp *vpt, int flagst, ModContext *mc);
void SelectionSetChanged(Interface *ip,IUtil *iu);
void selectionChanged();
void saveState();
INT_PTR dlgProc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam);
// ParamBlock2 access:
int NumParamBlocks () { return 1; }
IParamBlock2* GetParamBlock(int i)
{
if (i == 0) return pblock;
return NULL;
}
IParamBlock2* GetParamBlockByID(BlockID id) {
if (pblock->ID() == id) return pblock;
return NULL;
}
CreateMouseCallBack* GetCreateMouseCallBack() {return NULL;}
virtual int NumRefs();
virtual RefTargetHandle GetReference(int i);
virtual void SetReference(int i, RefTargetHandle rtarg);
virtual RefResult NotifyRefChanged(Interval,RefTargetHandle,PartID &,RefMessage);
int NumSubs() {return 1;}
Animatable* SubAnim(int i) { return GetReference(i); }
TSTR SubAnimName(int i) {return GetString (IDS_PARAMS);}
BOOL SetObject(INode *newNode);
INode* GetObject();
void UpdateBVDialogs();
BaseInterface *GetInterface(Interface_ID id) {
if (id == BHKRIGIDBODYINTERFACE_DESC)
return this;
return Modifier::GetInterface(id);
}
public:
friend class PickObjectMode;
StdMat2* collMat;
Mesh mesh;
PickObjectMode *pickObMode;
IParamBlock2 *pblock;
IParamMap2 *pmapParam;
IParamMap2 *pbvParams[4]; //box, sphere, capsule, proxy
Interface *mIP;
Tab<INode*> mNodes;
NpComboBox mCbLayer;
NpComboBox mCbMaterial;
NpComboBox mCbMotionSystem;
NpComboBox mCbQualityType;
bhkValidatorClass validator;
ICustButton *iPickButton;
void enableGUI(BOOL object, BOOL hvk, BOOL anim);
};
extern ClassDesc2* GetbhkRigidBodyModifierDesc();
static ParamBlockDesc2& get_havok_param_blk();
class bhkRigidBodyModifierClassDesc : public ClassDesc2
{
public:
bhkRigidBodyModifierClassDesc() {
get_havok_param_blk().SetClassDesc(this);
}
int IsPublic() { return TRUE; }
void * Create(BOOL loading = FALSE) {
return new bhkRigidBodyModifier();
}
const TCHAR * ClassName() { return GetString(IDS_RB_CLASS_NAME); }
SClass_ID SuperClassID() { return OSM_CLASS_ID; }
Class_ID ClassID() { return BHKRIGIDBODYMODIFIER_CLASS_ID; }
const TCHAR* Category() { return GetString(IDS_CATEGORY); }
const TCHAR* InternalName() { return _T("bhkRigidBodyModifier"); }
HINSTANCE HInstance() { return hInstance; }
};
// Parameter and ParamBlock IDs
enum { havok_params, bv_box, bv_sphere, bv_capsule, bv_mesh}; // pblock ID
enum { PB_BOUND_TYPE, PB_MESHLIST, };
enum { havok_params_panel, };
class BVTypePBAccessor : public PBAccessor
{
public:
void Set(PB2Value& v, ReferenceMaker* owner, ParamID id, int tabIndex, TimeValue t) // set from v
{
bhkRigidBodyModifier* p = (bhkRigidBodyModifier*)owner;
switch (id)
{
case PB_BOUND_TYPE:
{
switch (v.i)
{
case bv_type_none:
// Delete mesh.
break;
case bv_type_box: // Box
//BuildBox(mesh,,,)
break;
case bv_type_sphere: // Sphere
//BuildSphere();
break;
case bv_type_capsule: // Capsule
//BuildScubaMesh();
break;
case bv_type_mesh:
break;
}
}
}
}
};
static BVTypePBAccessor bv_type_accessor;
static ParamBlockDesc2 havok_param_blk (
havok_params, _T("BoundingVolumes"), 0, NULL, P_AUTO_CONSTRUCT + P_AUTO_UI + P_MULTIMAP, PBLOCK_REF,
//rollout
2,
havok_params, IDD_RB_MOD_PANEL, IDS_PARAMS, 0, 0, NULL,
bv_mesh, IDD_RB_MOD_PANEL4, IDS_RB_MOD_PANEL4, 0, 0, NULL,
PB_BOUND_TYPE, _T("boundType"), TYPE_INT, 0, IDS_BV_BOUNDING_TYPE,
p_default, 0,
p_range, 0, 4,
p_ui, havok_params, TYPE_RADIO, 5, IDC_RDO_NO_COLL, IDC_RDO_AXIS_ALIGNED_BOX, IDC_RDO_SPHERE, IDC_RDO_CAPSULE, IDC_RDO_PROXY_MESH,
p_accessor, &bv_type_accessor,
end,
PB_MESHLIST, _T("meshList"), TYPE_INODE_TAB, 0, P_AUTO_UI|P_VARIABLE_SIZE, IDS_MESHLIST,
p_ui, bv_mesh, TYPE_NODELISTBOX, IDC_LIST1,IDC_ADD,0,IDC_REMOVE,
end,
#if 0
// params
PB_RB_LAYER, _T("Layer"), TYPE_INT, 0, IDS_DS_LAYER,
p_default, NP_DEFAULT_HVK_LAYER,
end,
PB_RB_MATERIAL, _T("Material"), TYPE_INT, 0, IDS_DS_MATERIAL,
p_default, NP_DEFAULT_HVK_MATERIAL,
end,
PB_RB_MASS, _T("mass"), TYPE_FLOAT, 0, IDS_DS_MASS,
p_default, NP_DEFAULT_HVK_MASS,
p_range, 0.0, 1000.0,
p_ui, TYPE_SPINNER, EDITTYPE_UNIVERSE, IDC_ED_MASS, IDC_SP_MASS, SPIN_AUTOSCALE,
end,
PB_RB_FRICTION, _T("friction"), TYPE_FLOAT, 0, IDS_DS_FRICTION,
p_default, NP_DEFAULT_HVK_FRICTION,
p_range, 0.0, 10.0,
p_ui, TYPE_SPINNER, EDITTYPE_UNIVERSE, IDC_ED_FRICTION, IDC_SP_FRICTION, SPIN_AUTOSCALE,
end,
PB_RB_RESTITUTION, _T("restitution"), TYPE_FLOAT, 0, IDS_DS_RESTITUTION,
p_default, NP_DEFAULT_HVK_RESTITUTION,
p_range, 0.0, 10.0,
p_ui, TYPE_SPINNER, EDITTYPE_UNIVERSE, IDC_ED_RESTITUTION, IDC_SP_RESTITUTION, SPIN_AUTOSCALE,
end,
PB_RB_LINEAR_DAMPING, _T("linear_damping"), TYPE_FLOAT, 0, IDS_DS_LINEAR_DAMPING,
p_default, NP_DEFAULT_HVK_LINEAR_DAMPING,
p_range, 0.0, 10.0,
p_ui, TYPE_SPINNER, EDITTYPE_UNIVERSE, IDC_ED_LINEAR_DAMPING, IDC_SP_LINEAR_DAMPING, SPIN_AUTOSCALE,
end,
PB_RB_ANGULAR_DAMPING, _T("angular_damping"), TYPE_FLOAT, 0, IDS_DS_ANGULAR_DAMPING,
p_default, NP_DEFAULT_HVK_ANGULAR_DAMPING,
p_range, 0.0, 10.0,
p_ui, TYPE_SPINNER, EDITTYPE_UNIVERSE, IDC_ED_ANGULAR_DAMPING, IDC_SP_ANGULAR_DAMPING, SPIN_AUTOSCALE,
end,
PB_RB_MAX_LINEAR_VELOCITY, _T("max_linear_velocity"), TYPE_FLOAT, 0, IDS_DS_MAX_LINEAR_VELOCITY,
p_default, NP_DEFAULT_HVK_MAX_LINEAR_VELOCITY,
p_range, 0.0, 10.0,
p_ui, TYPE_SPINNER, EDITTYPE_UNIVERSE, IDC_ED_MAX_LINEAR_VELOCITY, IDC_SP_MAX_LINEAR_VELOCITY, SPIN_AUTOSCALE,
end,
PB_RB_MAX_ANGULAR_VELOCITY, _T("max_angular_velocity"), TYPE_FLOAT, 0, IDS_DS_MAX_ANGULAR_VELOCITY,
p_default, NP_DEFAULT_HVK_MAX_ANGULAR_VELOCITY,
p_range, 0.0, 10.0,
p_ui, TYPE_SPINNER, EDITTYPE_UNIVERSE, IDC_ED_MAX_ANGULAR_VELOCITY, IDC_SP_MAX_ANGULAR_VELOCITY, SPIN_AUTOSCALE,
end,
PB_RB_PENETRATION_DEPTH, _T("penetration_depth"), TYPE_FLOAT, 0, IDS_DS_PENETRATION_DEPTH,
p_default, NP_DEFAULT_HVK_PENETRATION_DEPTH,
p_range, 0.0, 10.0,
p_ui, TYPE_SPINNER, EDITTYPE_UNIVERSE, IDC_ED_PENETRATION_DEPTH, IDC_SP_PENETRATION_DEPTH, SPIN_AUTOSCALE,
end,
PB_RB_MOTION_SYSTEM, _T("motion_system"), TYPE_INT, 0, IDS_DS_MOTION_SYSTEM,
p_default, NP_DEFAULT_HVK_MOTION_SYSTEM,
end,
PB_RB_QUALITY_TYPE, _T("quality_type"), TYPE_INT, 0, IDS_DS_QUALITY_TYPE,
p_default, NP_DEFAULT_HVK_QUALITY_TYPE,
end,
#endif
//PB_HK_NODE, _T("node"), TYPE_INODE, 0, IDS_DS_NODE,
// p_ui, TYPE_PICKNODEBUTTON, IDC_PICK_NODE,
// p_prompt, IDS_PICKNODE_PROMPT,
// //p_validator, &validator,
end,
end
);
static bhkRigidBodyModifierClassDesc bhkRigidBodyModifierDesc;
ClassDesc2* GetbhkRigidBodyModifierDesc() { return &bhkRigidBodyModifierDesc; }
ParamBlockDesc2& get_havok_param_blk() {
return havok_param_blk;
}
class PickObjectMode :
public PickModeCallback,
public PickNodeCallback {
public:
bhkRigidBodyModifier *mod;
BOOL HitTest(IObjParam *ip,HWND hWnd,ViewExp *vpt,IPoint2 m,int flags);
BOOL Pick(IObjParam *ip,ViewExp *vpt);
void EnterMode(IObjParam *ip);
void ExitMode(IObjParam *ip);
BOOL RightClick(IObjParam *ip,ViewExp *vpt) {return TRUE;}
BOOL Filter(INode *node);
PickNodeCallback *GetFilter() {return this;}
};
//--- PickObjectMode ------------------------------------------------
BOOL PickObjectMode::Filter(INode *node)
{
if (node) {
node->BeginDependencyTest();
mod->NotifyDependents(FOREVER,0,REFMSG_TEST_DEPENDENCY);
if (node->EndDependencyTest()) {
return FALSE;
}
////added code for looptest
//if (node->TestForLoop(FOREVER,(ReferenceMaker *) mod)!=REF_SUCCEED)
// return FALSE;
for (int i = 0;i < mod->pblock->Count(PB_MESHLIST); i++) {
INode *tnode = NULL;
mod->pblock->GetValue(PB_MESHLIST,0,tnode,FOREVER,i);
if (node == tnode)
return FALSE;
}
ObjectState os = node->EvalWorldState(0);
//added code such that lines are not selected
if ( (os.obj->IsSubClassOf(triObjectClassID) || os.obj->CanConvertToType(triObjectClassID))
&& (os.obj->SuperClassID() != SHAPE_CLASS_ID)
)
{
return TRUE;
}
if (os.obj->SuperClassID() == HELPER_CLASS_ID && os.obj->ClassID().PartB() == BHKRIGIDBODYCLASS_DESC.PartB() ) {
return TRUE;
}
}
return FALSE;
}
BOOL PickObjectMode::HitTest(
IObjParam *ip,HWND hWnd,ViewExp *vpt,IPoint2 m,int flags)
{
INode *node = mod->mIP->PickNode(hWnd,m, this); //added "this" argument such that the Filter above is used
return node?TRUE:FALSE;
}
BOOL PickObjectMode::Pick(IObjParam *ip,ViewExp *vpt)
{
BOOL rv = FALSE;
if (INode *node = vpt->GetClosestHit()) {
theHold.Begin();
ObjectState os = node->EvalWorldState(0);
if (os.obj->CanConvertToType(triObjectClassID)) {
mod->pblock->Append(PB_MESHLIST,1,&node,1);
rv = TRUE;
}
theHold.Accept(GetString(IDS_ADD_MESH));
}
return rv;
}
void PickObjectMode::EnterMode(IObjParam *ip)
{mod->iPickButton->SetCheck(TRUE);}
void PickObjectMode::ExitMode(IObjParam *ip)
{mod->iPickButton->SetCheck(FALSE);}
static PickObjectMode thePickMode;
class bhkRigidBodyModifierDlgProc : public ParamMap2UserDlgProc {
public:
bhkRigidBodyModifier *mod;
bhkRigidBodyModifierDlgProc(bhkRigidBodyModifier* m) {mod = m;}
INT_PTR DlgProc(TimeValue t,IParamMap2 *map,HWND hWnd,UINT msg,WPARAM wParam,LPARAM lParam);
void DeleteThis() {delete this;}
};
INT_PTR bhkRigidBodyModifierDlgProc::DlgProc (TimeValue t,IParamMap2 *map,HWND hWnd,UINT msg,WPARAM wParam,LPARAM lParam)
{
switch (msg)
{
case WM_INITDIALOG:
//mod->iPickButton = GetICustButton(GetDlgItem(hWnd, IDC_ADD));
//mod->iPickButton->SetType(CBT_CHECK);
//mod->iPickButton->SetHighlightColor(GREEN_WASH);
break;
case WM_DESTROY:
if (mod && mod->iPickButton != NULL) {
ReleaseICustButton(mod->iPickButton);
mod->iPickButton = NULL;
}
break;
case WM_COMMAND:
switch (LOWORD(wParam))
{
case IDC_ADD:
{
thePickMode.mod = mod;
GetCOREInterface()->SetPickMode(&thePickMode);
break;
}
}
break;
default:
return FALSE;
}
return TRUE;
}
//--- bhkRigidBodyModifier -------------------------------------------------------
bhkRigidBodyModifier::bhkRigidBodyModifier()
{
mIP = NULL;
pblock = NULL;
pmapParam = NULL;
pickObMode = NULL;
validator.mod = this;
iPickButton = NULL;
bhkRigidBodyModifierDesc.MakeAutoParamBlocks(this);
collMat = NewDefaultStdMat();
collMat->SetDiffuse(Color(1.0f, 0.0f, 0.0f), 0);
collMat->SetWire(TRUE);
}
bhkRigidBodyModifier::~bhkRigidBodyModifier()
{
havok_param_blk.SetUserDlgProc();
#if 0
if (NULL != pickObMode) {
delete pickObMode;
pickObMode = NULL;
}
#endif
if (pmapParam) {
DestroyCPParamMap2 (pmapParam);
pmapParam = NULL;
}
}
RefTargetHandle bhkRigidBodyModifier::Clone(RemapDir& remap) {
bhkRigidBodyModifier *mod = new bhkRigidBodyModifier();
mod->ReplaceReference(0,remap.CloneRef(GetReference(0)));
mod->ReplaceReference(1,remap.CloneRef(GetReference(1)));
BaseClone(this, mod, remap);
return mod;
}
int bhkRigidBodyModifier::NumRefs()
{
return 2;
}
RefTargetHandle bhkRigidBodyModifier::GetReference(int i)
{
if (i==0) return pblock;
if (i==1) return GetRBBlock();
return NULL;
}
void bhkRigidBodyModifier::SetReference(int i, RefTargetHandle rtarg)
{
if (i==0) pblock = (IParamBlock2*)rtarg;
}
RefResult bhkRigidBodyModifier::NotifyRefChanged(
Interval changeInt,
RefTargetHandle hTarget,
PartID& partID,
RefMessage message)
{
switch (message)
{
case REFMSG_CHANGE:
ParamID changing_param = pblock->LastNotifyParamID();
havok_param_blk.InvalidateUI(changing_param);
if (changing_param == PB_MESHLIST)
{
if (partID == PART_TOPO) {
NotifyDependents(FOREVER,GEOM_CHANNEL,REFMSG_CHANGE);
}
}
break;
}
return REF_SUCCEED;
}
Interval bhkRigidBodyModifier::GetValidity (TimeValue t) {
Interval ret = FOREVER;
pblock->GetValidity (t, ret);
return ret;
}
void bhkRigidBodyModifier::ModifyObject (TimeValue t, ModContext &mc, ObjectState *os, INode *inode)
{
OutputDebugString("bhkRigidBodyModifier::ModifyObject\n");
Box3 box; box.Init();
if (TriObject *tri = (TriObject *)os->obj->ConvertToType(t, Class_ID(TRIOBJ_CLASS_ID, 0)))
{
CalcAxisAlignedBox(tri->GetMesh(), box);
BuildBox(mesh, box.Max().x-box.Min().x, box.Max().y-box.Min().y, box.Max().z-box.Min().z);
}
//Modifier::ModifyObject(t, mc, os, inode);
}
void bhkRigidBodyModifier::NotifyInputChanged(Interval changeInt, PartID partID, RefMessage message, ModContext *mc)
{
OutputDebugString("bhkRigidBodyModifier::NotifyInputChanged\n");
Modifier::NotifyInputChanged(changeInt, partID, message, mc);
}
struct ParamMapInfo
{
MapID mapid;
DWORD idd;
DWORD ids;
};
static ParamMapInfo pminfo[] = {
{bv_box, IDD_RB_MOD_PANEL1, IDS_RB_MOD_PANEL1},
{bv_sphere, IDD_RB_MOD_PANEL2, IDS_RB_MOD_PANEL2},
{bv_capsule,IDD_RB_MOD_PANEL3, IDS_RB_MOD_PANEL3},
{bv_mesh, IDD_RB_MOD_PANEL4, IDS_RB_MOD_PANEL4},
};
void bhkRigidBodyModifier::UpdateBVDialogs()
{
//if (NULL != pmapParam)
//{
// int bvType = pblock2->GetInt(PB_BOUND_TYPE);
// if (bvType > 0) // none
// {
// int adjBvType = bvType - 1; //adjusted bvtype (ignoring none).
// for (int i=0; i<_countof(pminfo), ++i){
// if (pbvParams[i] != NULL && adjBvType != i) {
// DestroyCPParamMap2( pbvParams[i] );
// pbvParams[i] = 0;
// }
// }
// Interface *ifc = GetCOREInterface();
// if (pbvParams[adjBvType] == NULL) {
// pbvParams[adjBvType] = CreateCPParamMap2( pminfo[adjBvType], pblock2, ifc, hInstance,
// MAKEINTRESOURCE(pminfo[adjBvType]), GetString([adjBvType]), 0);
// }
// }
//}
//else
//{
// // hide em all
// for (int i=0; i<_countof(pminfo), ++i){
// if (pbvParams[i] != NULL) {
// DestroyCPParamMap2( pbvParams[i] );
// pbvParams[i] = 0;
// }
// }
//}
}
void bhkRigidBodyModifier::BeginEditParams(IObjParam *ip, ULONG flags,Animatable *prev)
{
Modifier::BeginEditParams(ip, flags, prev);
mIP = ip;
TimeValue t = ip->GetTime();
NotifyDependents(Interval(t,t), PART_ALL, REFMSG_BEGIN_EDIT);
NotifyDependents(Interval(t,t), PART_ALL, REFMSG_MOD_DISPLAY_ON);
SetAFlag(A_MOD_BEING_EDITED);
bhkRigidBodyModifierDesc.BeginEditParams(ip,this,flags,prev);
//havok_param_blk.SetUserDlgProc(bv_mesh, new bhkRigidBodyModifierDlgProc(this));
pmapParam = pblock->GetMap(havok_params);
UpdateBVDialogs();
//pmapParam->GetIRollup()->Hide(1);
//pmapParam->GetIRollup()->Hide(3);
BeginEditRBParams(ip, flags, prev);
mNodes.ZeroCount();
}
void bhkRigidBodyModifier::EndEditParams (IObjParam *ip,ULONG flags,Animatable *next)
{
Modifier::EndEditParams(ip,flags,next);
//saveState();
mNodes.ZeroCount();
mIP = NULL;
// NOTE: This flag must be cleared before sending the REFMSG_END_EDIT
ClearAFlag(A_MOD_BEING_EDITED);
TimeValue t = ip->GetTime();
NotifyDependents(Interval(t,t), PART_ALL, REFMSG_END_EDIT);
NotifyDependents(Interval(t,t), PART_ALL, REFMSG_MOD_DISPLAY_OFF);
havok_param_blk.SetUserDlgProc();
if (flags&END_EDIT_REMOVEUI) {
pmapParam = NULL;
UpdateBVDialogs();
}
if (iPickButton != NULL) {
ReleaseICustButton(iPickButton);
iPickButton = NULL;
}
// For PB2 we ask the ClassDesc2 to take care of the EndEditParams - NH
bhkRigidBodyModifierDesc.EndEditParams(ip,this,flags,next);
EndEditRBParams(ip, flags, next);
}
class CollisionWireMtl: public Material
{
public:
CollisionWireMtl();
};
static CollisionWireMtl swMtl;
CollisionWireMtl::CollisionWireMtl():Material()
{
Ks[0] = Kd[0] = 1.0f;
Ks[1] = Kd[1] = 0.0f;
Ks[2] = Kd[2] = 0.0f;
shininess = (float)0.0;
shadeLimit = GW_WIREFRAME|GW_BACKCULL;
selfIllum = (float)1.0;
}
int bhkRigidBodyModifier::Display(TimeValue t, INode* inode, ViewExp *vpt, int flagst, ModContext *mc)
{
//OutputDebugString("bhkRigidBodyModifier::Display\n");
if (!Modifier::IsEnabled())
return 0;
Matrix3 m;
GraphicsWindow *gw = vpt->getGW();
int wrgb = inode->GetWireColor();
inode->SetWireColor( RGB(255,0,0) );
Material *mtl = &swMtl;
//gw->setTransform(mat);
if (inode->Selected())
gw->setColor( LINE_COLOR, GetSelColor());
else if(!inode->IsFrozen())
gw->setColor(LINE_COLOR,GetUIColor(COLOR_SPACE_WARPS));
m = inode->GetObjectTM(t);
gw->setTransform(m);
DWORD rlim = gw->getRndLimits();
DWORD newrlim = GW_WIREFRAME/*|GW_Z_BUFFER*/;
#if VERSION_3DSMAX >= ((5000<<16)+(15<<8)+0) // Version 5+
newrlim |= GW_EDGES_ONLY;
#endif
gw->setRndLimits(newrlim);
//UpdateMesh(t);
gw->setMaterial(swMtl);
gw->setColor(LINE_COLOR, 1.0f, 0.0f, 0.0f);
gw->setColor(FILL_COLOR, 1.0f, 0.0f, 0.0f);
mesh.render( gw, mtl, NULL, COMP_ALL);
inode->SetWireColor(wrgb);
gw->setRndLimits(rlim);
return 0;
}