INT_PTR CapsuleParamDlgProc::DlgProc(TimeValue t,IParamMap2 *map,HWND hWnd,UINT msg,WPARAM wParam,LPARAM lParam)
{
   thishWnd=hWnd;
   switch (msg) 
   {
   case WM_INITDIALOG: 
      {
		  mCbMaterial.init(GetDlgItem(hWnd, IDC_CB_MATERIAL));
		  mCbMaterial.add("<Default>");
		  for (const char **str = NpHvkMaterialNames; *str; ++str)
			  mCbMaterial.add(*str);
		  Interval valid;
		  int sel = NP_INVALID_HVK_MATERIAL;
		  so->pblock2->GetValue( PB_MATERIAL, 0, sel, valid);
		  mCbMaterial.select( sel + 1 );

         Update(t);
         break;
      }
   case WM_COMMAND:
      switch (LOWORD(wParam)) 
      {
      case IDC_CB_MATERIAL:
         if (HIWORD(wParam)==CBN_SELCHANGE) {
            so->pblock2->SetValue( PB_MATERIAL, 0, mCbMaterial.selection() - 1);
         }
         break;
      }
      break;	
   }
   return FALSE;
}
INT_PTR RigidBodyParamDlgProc::DlgProc(TimeValue t,IParamMap *map,HWND hWnd,UINT msg,WPARAM wParam,LPARAM lParam)
{
   thishWnd=hWnd;
   switch (msg) 
   {
   case WM_INITDIALOG: 
      {
         mCbLayer.init(GetDlgItem(hWnd, IDC_CB_LAYER));
		 InitLayerTypeCombo(hWnd, IDC_CB_LAYER);

         mCbMotionSystem.init(GetDlgItem(hWnd, IDC_CB_MOTION_SYSTEM));         
         for (const TCHAR **str = NpHvkMotionSystems; *str; ++str)
            mCbMotionSystem.add(*str);

         mCbQualityType.init(GetDlgItem(hWnd, IDC_CB_QUALITY_TYPE));
         for (const TCHAR **str = NpHvkQualityTypes; *str; ++str)
            mCbQualityType.add(*str);

         Update(t);
         break;
      }
   case WM_COMMAND:
      switch (LOWORD(wParam))
      {
      case IDC_CB_LAYER:
         if (HIWORD(wParam)==CBN_SELCHANGE) {
            so->SetLayer( mCbLayer.selection(), t );
         }
         break;

      case IDC_CB_MOTION_SYSTEM:
         if (HIWORD(wParam)==CBN_SELCHANGE) {
            so->SetMotionSystem( mCbMotionSystem.selection(), t );
         }
         break;

      case IDC_CB_QUALITY_TYPE:
         if (HIWORD(wParam)==CBN_SELCHANGE) {
            so->SetQualityType( mCbQualityType.selection(), t );
         }
         break;
      }
      break;
   }
   return FALSE;
}
INT_PTR bhkRigidBodyModifierDlgProc::DlgProc (TimeValue t,IParamMap2 *map,HWND hWnd,UINT msg,WPARAM wParam,LPARAM lParam)
{
   switch (msg) 
   {
   case WM_INITDIALOG:
	   {
		   mCbMaterial.init(GetDlgItem(hWnd, IDC_CB_MATERIAL));
		   mCbMaterial.add(_T("<Default>"));
		   for (const wchar_t **str = NpHvkMaterialNames; *str; ++str)
			   mCbMaterial.add(*str);
		   Interval valid;
		   int sel = NP_INVALID_HVK_MATERIAL;
		   mod->pblock->GetValue( PB_MATERIAL, 0, sel, valid);
		   mCbMaterial.select( sel + 1 );
		   EnableWindow(GetDlgItem(hWnd, IDC_RDO_CAPSULE), CanCalcCapsule() ? TRUE : FALSE);
 		   EnableWindow(GetDlgItem(hWnd, IDC_RDO_OBB), CanCalcOrientedBox() ? TRUE : FALSE);
		   Update(t);
		   break;
	   }

   case WM_DESTROY:
	   break;

   case WM_COMMAND:
	   switch (LOWORD(wParam))
	   {
	   case IDC_CB_MATERIAL:
		   if (HIWORD(wParam)==CBN_SELCHANGE) {
			   mod->pblock->SetValue( PB_MATERIAL, 0, mCbMaterial.selection() - 1 );
		   }
		   break;

	   case IDC_BTN_CLONE:
		   mod->CreateMesh();
		   break;

	   default:
		   return FALSE;
	   }
   }
   return FALSE;
}
Beispiel #4
0
void NifProps::BeginEditParams(Interface *ip, IUtil *iu) 
{
	mIP = ip;
	mIU = iu;

	mPanel = ip->AddRollupPage(
		hInstance,
		MAKEINTRESOURCE(IDD_PANEL),
		NifPropsDlgProc,
		GetString(IDS_PARAMS),
		0);

	mSpins[IDC_SP_CENTER_X] = 
		SetupFloatSpinner(mPanel, IDC_SP_CENTER_X, IDC_ED_CENTER_X, -9999, 9999, 0, .1f);
	mSpins[IDC_SP_CENTER_Y] = 
		SetupFloatSpinner(mPanel, IDC_SP_CENTER_Y, IDC_ED_CENTER_Y, -9999, 9999, 0, .1f);
	mSpins[IDC_SP_CENTER_Z] = 
		SetupFloatSpinner(mPanel, IDC_SP_CENTER_Z, IDC_ED_CENTER_Z, -9999, 9999, 0, .1f);

	mSpins[IDC_SP_MASS] = 
		SetupFloatSpinner(mPanel, IDC_SP_MASS, IDC_ED_MASS, 0, 1000, 0, .1f);
	mSpins[IDC_SP_FRICTION] = 
		SetupFloatSpinner(mPanel, IDC_SP_FRICTION, IDC_ED_FRICTION, 0, 10, 0, .1f);
	mSpins[IDC_SP_RESTITUTION] = 
		SetupFloatSpinner(mPanel, IDC_SP_RESTITUTION, IDC_ED_RESTITUTION, 0, 10, 0, .1f);

	mSpins[IDC_SP_LINEAR_DAMPING] = 
		SetupFloatSpinner(mPanel, IDC_SP_LINEAR_DAMPING, IDC_ED_LINEAR_DAMPING, 0, 10, 0, .1f);
	mSpins[IDC_SP_ANGULAR_DAMPING] = 
		SetupFloatSpinner(mPanel, IDC_SP_ANGULAR_DAMPING, IDC_ED_ANGULAR_DAMPING, 0, 10, 0, .1f);

	mSpins[IDC_SP_MAX_LINEAR_VELOCITY] = 
		SetupFloatSpinner(mPanel, IDC_SP_MAX_LINEAR_VELOCITY, IDC_ED_MAX_LINEAR_VELOCITY, 0, 10, 0, .1f);
	mSpins[IDC_SP_MAX_ANGULAR_VELOCITY] = 
		SetupFloatSpinner(mPanel, IDC_SP_MAX_ANGULAR_VELOCITY, IDC_ED_MAX_ANGULAR_VELOCITY, 0, 10, 0, .1f);

	mSpins[IDC_SP_PENETRATION_DEPTH] = 
		SetupFloatSpinner(mPanel, IDC_SP_PENETRATION_DEPTH, IDC_ED_PENETRATION_DEPTH, 0, 10, 0, .1f);

	mNode = NULL;

	const char **str;
	str = NpHvkMaterialNames;
	while (*str)
	{
		mCbMaterial.add(*str);
		str++;
	}

	str = NpHvkLayerNames;
	while (*str)
	{
		mCbLayer.add(*str);
		str++;
	}

	str = NpHvkMotionSystems;
	while (*str)
	{
		mCbMotionSystem.add(*str);
		str++;
	}

	str = NpHvkQualityTypes;
	while (*str)
	{
		mCbQualityType.add(*str);
		str++;
	}

   
   //mAnimPanel = ip->AddRollupPage(
   //   hInstance,
   //   MAKEINTRESOURCE(IDD_ANIM_PANEL),
   //   NifAnimPropsDlgProc,
   //   GetString(IDS_ANIM_PARAMS),
   //   0);

   mSpins[IDC_SP_ANIM_PRIORITY] = 
      SetupFloatSpinner(mPanel, IDC_SP_ANIM_PRIORITY, IDC_ED_ANIM_PRIORITY, 0, 255, 25, .1f);

	selectionChanged();
}