void MorphByBone::BeginEditParams( IObjParam *ip, ULONG flags,Animatable *prev )
{
this->ip = 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);
moveMode = new MoveModBoxCMode(this,ip);
rotMode = new RotateModBoxCMode(this,ip);
uscaleMode = new UScaleModBoxCMode(this,ip);
nuscaleMode = new NUScaleModBoxCMode(this,ip);
squashMode = new SquashModBoxCMode(this,ip);
selectMode = new SelectModBoxCMode(this,ip);
MorphByBoneDesc.BeginEditParams(ip, this, flags, prev);
morphbybone_param_blk.SetUserDlgProc(morphbybone_mapparams, new MorphByBoneParamsMapDlgProc(this));
morphbybone_param_blk.SetUserDlgProc(morphbybone_mapparamsprop, new MorphByBoneParamsMapDlgProcProp(this));
morphbybone_param_blk.SetUserDlgProc(morphbybone_mapparamscopy, new MorphByBoneParamsMapDlgProcCopy(this));
morphbybone_param_blk.SetUserDlgProc(morphbybone_mapparamsselection, new MorphByBoneParamsMapDlgProcSoftSelection(this));
}
INT_PTR EllipseTypeInDlgProc::DlgProc(TimeValue t,IParamMap2 *map,HWND hWnd,UINT msg,WPARAM wParam,LPARAM lParam)
{
switch (msg)
{
case WM_COMMAND:
switch (LOWORD(wParam))
{
case IDC_TI_CREATE:
{
Matrix3 tm(1);
Point3 pos = theEllispeTypeInBlock.GetPoint3(PB_TI_POS);
float length = theEllispeTypeInBlock.GetFloat(PB_TI_LENGTH);
float width = theEllispeTypeInBlock.GetFloat(PB_TI_WIDTH);
float thickness = theEllispeTypeInBlock.GetFloat(PB_TI_THICKNESS);
tm.SetTrans(pos);
ro->suspendSnap = FALSE;
EllipseObject* new_object = dynamic_cast<EllipseObject*>(ro->ip->NonMouseCreate(tm));
if(new_object)
{
new_object->GetParamBlockByID(ellipse_params)->SetValue(PB_LENGTH, t, length);
new_object->GetParamBlockByID(ellipse_params)->SetValue(PB_WIDTH, t, width);
new_object->GetParamBlockByID(ellipse_params)->SetValue(PB_THICKNESS, t, thickness);
}
return TRUE;
}
}
break;
}
return FALSE;
}
//----------------------------------------------------------------------------
bool SceneBuilder::ConvertFRGBAAttrib(IParamBlock2* paramBlock, int index,
std::string &name, PX2::Float4 &value)
{
ParamBlockDesc2 *paramDesc = paramBlock->GetDesc();
if (!paramDesc)
return false;
ParamDef ¶mDef = paramDesc->GetParamDef(paramDesc->IndextoID(index));
Point4 vectorValue;
Interval validInterval;
BOOL retrieved = false;
retrieved = paramBlock->GetValue((ParamID)index, 0 , vectorValue, validInterval);
if(retrieved)
{
TCHAR* valueName = paramDef.int_name;
if (!IsValidName(valueName))
valueName = paramBlock->GetLocalName((ParamID)index );
assertion(IsValidName(valueName), "valueName must be valuable.");
name = std::string(valueName);
value = PX2::Float4(vectorValue.x, vectorValue.y, vectorValue.z,
vectorValue.w);
if(HasAnimation(paramBlock, index))
{
}
}
return true;
}
IParamMap2 *plResponderProc::ICreateMap(IParamBlock2 *pb)
{
ParamBlockDesc2 *pd = pb->GetDesc();
// Don't show anything if there isn't a UI
if (pd->Count() < 1)
{
pb->ReleaseDesc();
return nil;
}
// Create the rollout
IParamMap2 *map = CreateCPParamMap2(0,
pb,
GetCOREInterface(),
hInstance,
MAKEINTRESOURCE(pd->dlg_template),
GetString(pd->title),
pd->flags,
pd->dlgProc,
NULL,
ROLLUP_CAT_STANDARD);
// Save the rollout in the paramblock
pb->SetMap(map);
pb->ReleaseDesc();
return map;
}
//----------------------------------------------------------------------------
bool SceneBuilder::ConvertIntListBoxAttrib (IParamBlock2* paramBlock,
int index, std::string &name,
int &value)
{
ParamBlockDesc2 *paramDesc = paramBlock->GetDesc();
if (!paramDesc)
return false;
ParamDef& paramDef = paramDesc->GetParamDef(paramDesc->IndextoID(index));
int intValue;
Interval validInverval;
BOOL retrieved = false;
retrieved = paramBlock->GetValue((ParamID)index, 0, intValue,
validInverval);
if (retrieved)
{
char* valueName = paramDef.int_name;
if (!IsValidName(valueName))
{
valueName = paramBlock->GetLocalName((ParamID)index);
assertion(IsValidName(valueName), "valueName must be valuable.");
}
name = std::string(valueName);
//3ds Max中数组从1开始,这里的index要减1
value = (intValue==-1) ? -1 : (intValue-1);
}
return true;
}
//----------------------------------------------------------------------------
bool SceneBuilder::ConvertFloatAttrib (IParamBlock2* paramBlock, int index,
std::string &name, float &value)
{
ParamBlockDesc2 *paramDesc = paramBlock->GetDesc();
if(!paramDesc)
return false;
ParamDef ¶mDef = paramDesc->GetParamDef(paramDesc->IndextoID(index));
float floatValue;
Interval validInverval;
BOOL retrieved = paramBlock->GetValue((ParamID)index, 0, floatValue, validInverval);
if(!retrieved)
{
return false;
}
char *valueName = paramDef.int_name;
if (!IsValidName(valueName))
{
valueName = paramBlock->GetLocalName((ParamID)index);
assertion(IsValidName(valueName), "valueName must be valuable.");
}
name = std::string(valueName);
//if (!HasAnimation(paramBlock, index))
{
value = floatValue;
return true;
}
return true;
}
RefResult FormationBhvr::NotifyRefChanged(const Interval& changeInt, RefTargetHandle hTarget, PartID& partID, RefMessage message, BOOL propagate)
{
switch (message)
{
case REFMSG_CHANGE:
//something changed perhaps a name?.. reset the text.
SetFollowerNodeText();
SetLeaderNodeText();
formation_pblk.InvalidateUI();
break;
case REFMSG_CONTAINER_ELEMENT_NULLED:
if (hTarget == pblock)
{
//was is something in the formation?
if (pblock->LastNotifyParamID() == follower)
{
///okay somebody in the formation was deleted..
INode *n;
int i;
int start = 0;
while (TRUE)
{
for(i=start; i<pblock->Count(follower); i++)
{
pblock->GetValue(follower, 0, n, FOREVER, i);
if(!n)
{
//This one was NULLed so remove from Tabs.
pblock->Delete(follower,i,1);
pblock->Delete(follower_matrix1,i,1);
pblock->Delete(follower_matrix2,i,1);
pblock->Delete(follower_matrix3,i,1);
pblock->Delete(follower_matrix4,i,1);
start = i;
break;
}
}
if (i >= pblock->Count(follower)) break;
}
}
}
//set up the button text due to possible changes.
SetFollowerNodeText();
SetLeaderNodeText();
formation_pblk.InvalidateUI();
break;
}
return REF_SUCCEED;
}
void EllipseObject::BeginEditParams( IObjParam *ip, ULONG flags,Animatable *prev)
{
SimpleSpline::BeginEditParams(ip, flags, prev);
this->ip = ip;
ellipseObjDesc.BeginEditParams(ip, this, flags, prev);
theEllipseParamBlock.SetUserDlgProc( new EllipseParamDlgProc(this) );
theEllispeTypeInBlock.SetUserDlgProc( new EllipseTypeInDlgProc(this) );
}
ParamDlg* BerconNoise::CreateParamDlg(HWND hwMtlEdit, IMtlParams *imp) {
IAutoMParamDlg* masterDlg = BerconNoiseDesc.CreateParamDlgs(hwMtlEdit, imp, this);
texoutDlg = texout->CreateParamDlg(hwMtlEdit, imp);
masterDlg->AddDlg(texoutDlg);
berconnoise_param_blk.SetUserDlgProc(new BerconNoiseDlgProc(this));
BerconCurve_param_blk.SetUserDlgProc(new BerconCurveDlgProcNOISE(this));
xyz_blk.SetUserDlgProc(new BerconXYZDlgProc(this));
EnableStuff();
return masterDlg;
}
void BerconGradient::SetSubTexmap(int i, Texmap *m) {
if (i >= SUBMAPCOUNT+gradient->numKeys()) return;
ReplaceReference(i+REF_OFFSET, m);
if (i == MAPTEX_NUM)
gradientmap_param_blk.InvalidateUI(pb_maptex);
else if (i == KEYTEX_NUM)
gradientmap_param_blk.InvalidateUI(pb_keyTex);
else if (i == DISTEX_NUM)
gradientmap_param_blk.InvalidateUI(pb_distex);
ivalid.SetEmpty();
}
void Noise::SwapInputs() {
Color t = col[0]; col[0] = col[1]; col[1] = t;
Texmap *x = subTex[0]; subTex[0] = subTex[1]; subTex[1] = x;
pblock->SwapControllers(noise_color1,0,noise_color2,0);
noise_param_blk.InvalidateUI(noise_color1);
noise_param_blk.InvalidateUI(noise_color2);
noise_param_blk.InvalidateUI(noise_map1);
noise_param_blk.InvalidateUI(noise_map2);
macroRecorder->FunctionCall(_T("swap"), 2, 0, mr_prop, _T("color1"), mr_reftarg, this, mr_prop, _T("color2"), mr_reftarg, this);
macroRecorder->FunctionCall(_T("swap"), 2, 0, mr_prop, _T("map1"), mr_reftarg, this, mr_prop, _T("map2"), mr_reftarg, this);
}
ParamDlg* BerconGradient::CreateParamDlg(HWND hwMtlEdit, IMtlParams *imp) {
//xyzGenDlg = xyzGen->CreateParamDlg(hwMtlEdit, imp);
IAutoMParamDlg* masterDlg = BerconGradientDesc.CreateParamDlgs(hwMtlEdit, imp, this);
texoutDlg = texout->CreateParamDlg(hwMtlEdit, imp);
//masterDlg->AddDlg(xyzGenDlg);
masterDlg->AddDlg(texoutDlg);
gradientmap_param_blk.SetUserDlgProc(new BerconGradientDlgProc(this));
BerconCurve_param_blk.SetUserDlgProc(new BerconCurveDlgProcGRADIENT(this));
xyz_blk.SetUserDlgProc(new BerconXYZDlgProc(this));
EnableStuff();
return masterDlg;
}
void Speckle::SwapInputs() {
Color t = col[0]; col[0] = col[1]; col[1] = t;
Texmap *x = subTex[0]; subTex[0] = subTex[1]; subTex[1] = x;
// pblock->SwapControllers(PB_COL1, PB_COL2);
pblock->SwapControllers(speckle_color1,0, speckle_color2,0);
speckle_param_blk.InvalidateUI(speckle_color1);
speckle_param_blk.InvalidateUI(speckle_color2);
speckle_param_blk.InvalidateUI(speckle_map1);
speckle_param_blk.InvalidateUI(speckle_map2);
macroRec->FunctionCall(_T("swap"), 2, 0, mr_prop, _T("color1"), mr_reftarg, this, mr_prop, _T("color2"), mr_reftarg, this);
macroRec->FunctionCall(_T("swap"), 2, 0, mr_prop, _T("map1"), mr_reftarg, this, mr_prop, _T("map2"), mr_reftarg, this);
}
void bhkProxyObject::BeginEditParams(IObjParam *ip,ULONG flags,Animatable *prev)
{
BaseClass::BeginEditParams(ip,flags,prev);
mIP = ip;
listDesc.BeginEditParams(ip,this,flags,prev);
param_blk.SetUserDlgProc(new ProxyParamDlgProc(this));
param_blk.SetUserDlgProc(clone_params, new CloneMeshDlgProc(this));
param_blk.SetUserDlgProc(subshape_params, new SubShapeDlgProc(this));
pmapParam = pblock2->GetMap(list_params);
this->ip = ip;
}
bool mrShaderFilter::ValidateReturnType(ParamBlockDesc2& pbDesc) {
// Go through all the parameters of the block
int count = pbDesc.Count();
for(int i = 0; i < count; ++i) {
const ParamDef& paramDef = pbDesc.GetParamDef(pbDesc.IndextoID(i));
if(ValidType(paramDef.type))
return true;
}
return false;
}
void BlobMesh::BeginEditParams(IObjParam *ip,ULONG flags,Animatable *prev)
{
this->ip = ip;
SimpleObject2::BeginEditParams(ip,flags,prev);
BlobMeshDesc.BeginEditParams(ip, this, flags, prev);
blobmesh_param_blk.SetUserDlgProc(blobmesh_pfparams,new BlobMeshDlgProc(this));
blobmesh_param_blk.ParamOption(pb_nodelist,p_validator,&validator);
blobmesh_param_blk.SetUserDlgProc(blobmesh_params,new BlobMeshParamsDlgProc(this));
}
void Mask::SetSubTexmap(int i, Texmap *m) {
ReplaceReference(i,m);
if (i==0)
{
mask_param_blk.InvalidateUI(mask_map1);
mapValid.SetEmpty();
}
else if (i==1)
{
mask_param_blk.InvalidateUI(mask_map2);
mapValid.SetEmpty();
}
}
//----------------------------------------------------------------------------
bool SceneBuilder::ConvertBitMapAttrib(IParamBlock2* paramBlock, int index,
std::string &name,
PX2::Texture2D *&tex2d)
{
ParamBlockDesc2 *paramDesc = paramBlock->GetDesc();
if (!paramDesc)
return false;
ParamDef ¶mDef = paramDesc->GetParamDef(paramDesc->IndextoID(index));
PX2_UNUSED(paramDef);
PBBitmap *pb;
Interval validInterval;
char *valueName = 0;
PX2_UNUSED(valueName);
BOOL retrieved = false;
retrieved = paramBlock->GetValue((ParamID)index, 0, pb, validInterval);
char strBitMapName[256];
memset(strBitMapName, 0, 256*sizeof(char));
if (pb)
{
if (BMMGetFullFilename(&pb->bi) == TRUE)
{
strcpy(strBitMapName, pb->bi.Name());
std::string resourcePath;
std::string fullName = std::string(strBitMapName);
std::string::size_type sizeT = fullName.find_first_not_of(mSettings->SrcRootDir);
resourcePath = std::string(strBitMapName).substr(sizeT);
tex2d = PX2::DynamicCast<PX2::Texture2D>(
PX2::ResourceManager::GetSingleton().BlockLoad(strBitMapName));
tex2d->SetResourcePath(resourcePath);
}
}
if (retrieved)
{
valueName = paramDef.int_name;
if (!IsValidName(valueName))
valueName = paramBlock->GetLocalName((ParamID)index);
assertion(IsValidName(valueName), "valueName must be valuable.");
name = valueName;
}
return true;
}
void Wood::SetSubTexmap(int i, Texmap *m)
{
ReplaceReference(i+2,m);
if (i==0)
{
wood_param_blk.InvalidateUI(wood_map1);
ivalid.SetEmpty();
}
else if (i==1)
{
wood_param_blk.InvalidateUI(wood_map2);
ivalid.SetEmpty();
}
}
// Stores the 'i-th' sub-texmap managed by the material or texture.
void Speckle::SetSubTexmap(int i, Texmap *m) {
ReplaceReference(i+2, m);
if (i==0)
{
speckle_param_blk.InvalidateUI(speckle_map1);
texValidity.SetEmpty();
}
else if (i==1)
{
speckle_param_blk.InvalidateUI(speckle_map2);
texValidity.SetEmpty();
}
// if (paramDlg)
// paramDlg->UpdateSubTexNames();
}
RefResult SmoothMod::NotifyRefChanged (const Interval& changeInt, RefTargetHandle hTarget,
PartID& partID, RefMessage message, BOOL propagate) {
switch (message) {
case REFMSG_CHANGE:
if (hTarget == pblock) {
ParamID idToUpdate = pblock->LastNotifyParamID();
smooth_param_desc.InvalidateUI (idToUpdate);
switch (idToUpdate) {
case -1:
case sm_smoothbits:
case sm_autosmooth:
if (smoothDesc.NumParamMaps() > 0) {
IParamMap2 *pmap = smoothDesc.GetParamMap(0);
if (pmap) {
HWND hWnd = pmap->GetHWnd();
if (hWnd) theSmoothDlgProc.Invalidate (hWnd);
}
}
break;
}
}
break;
}
return REF_SUCCEED;
}
void bhkListObject::BeginEditParams(IObjParam *ip,ULONG flags,Animatable *prev)
{
SimpleObject::BeginEditParams(ip,flags,prev);
mIP = ip;
//if (pmapParam == NULL) {
// pmapParam = CreateCPParamMap2(
// 0,
// pblock2,
// GetCOREInterface(),
// hInstance,
// MAKEINTRESOURCE(IDD_LISTPARAM),
// GetString(IDS_PARAMS),
// 0);
//}
listDesc.BeginEditParams(ip,this,flags,prev);
param_blk.SetUserDlgProc(new ListParamDlgProc(this));
pmapParam = pblock2->GetMap(list_params);
BeginEditRBParams(ip, flags, prev);
//pmapParam->GetIRollup()->Hide(1);
this->ip = ip;
//if(pmapParam) {
// // A callback for the type in.
// pmapParam->SetUserDlgProc(new ListParamDlgProc(this));
//}
}
bhkListObject::~bhkListObject()
{
param_blk.SetUserDlgProc();
if (pmapParam) {
pmapParam = NULL;
}
}
// Stores the 'i-th' sub-texmap managed by the material or texture.
void Smoke::SetSubTexmap(int i, Texmap *m) {
ReplaceReference(i+2, m);
if (i==0)
{
smoke_param_blk.InvalidateUI(smoke_map1);
mapValid.SetEmpty();
}
else if (i==1)
{
smoke_param_blk.InvalidateUI(smoke_map2);
mapValid.SetEmpty();
}
// if (paramDlg)
// paramDlg->UpdateSubTexNames();
}
// This method is responsible for responding to the change notification
// messages sent by the texmap dependants.
RefResult Water::NotifyRefChanged(Interval changeInt,
RefTargetHandle hTarget, PartID& partID, RefMessage message ) {
switch (message) {
case REFMSG_CHANGE:
texValidity.SetEmpty();
if (hTarget == pblock)
{
ParamID changing_param = pblock->LastNotifyParamID();
water_param_blk.InvalidateUI(changing_param);
#ifdef SHOW_3DMAPS_WITH_2D
if (changing_param != -1)
DiscardTexHandle();
#endif
}
#ifdef SHOW_3DMAPS_WITH_2D
else if (hTarget == xyzGen)
{
DiscardTexHandle();
}
#endif
// One of the texmap dependants have changed. We set our
// validity interval to empty and invalidate the dialog
// so it gets redrawn.
// texValidity.SetEmpty();
// if (hTarget != xyzGen) {
// if (paramDlg)
// paramDlg->pmap->Invalidate();
// }
break;
/*
case REFMSG_GET_PARAM_DIM: {
// This returns the 'dimension' of the parameter. This is
// the type and order of magnitude of the parameter.
GetParamDim *gpd = (GetParamDim *)partID;
switch (gpd->index) {
case PB_LEN_MIN:
case PB_LEN_MAX:
case PB_SIZE: gpd->dim = stdWorldDim; break;
case PB_AMP:
case PB_NUM:
case PB_PHASE:
gpd->dim = defaultDim; break;
case PB_COL1:
case PB_COL2: gpd->dim = stdColor255Dim; break;
}
return REF_STOP;
}
case REFMSG_GET_PARAM_NAME: {
// This returns the name that will appear in track view
// of the parameter.
GetParamName *gpn = (GetParamName *)partID;
gpn->name = GetString(nameIDs[gpn->index]);
return REF_STOP;
}
*/
}
return(REF_SUCCEED);
}
bhkSphereObject::~bhkSphereObject() {
param_blk.SetUserDlgProc();
sphereCreateCB.SetObj(NULL);
if (pmapParam) {
pmapParam = NULL;
}
}
ParamDlg* StressTexmap::CreateParamDlg(HWND hwMtlEdit, IMtlParams *imp)
{
IAutoMParamDlg* masterDlg = SkelTexmapCD.CreateParamDlgs(hwMtlEdit, imp, this);
stex_param_blk.SetUserDlgProc(new SkelTexDlgProc(this));
return masterDlg;
}
void bhkSphereObject::BeginEditParams(IObjParam *ip,ULONG flags,Animatable *prev)
{
SimpleObject::BeginEditParams(ip,flags,prev);
// Gotta make a new one.
//if (NULL == pmapParam)
//{
// pmapParam = CreateCPParamMap2(
// 0,
// pblock2,
// GetCOREInterface(),
// hInstance,
// MAKEINTRESOURCE(IDD_SPHEREPARAM2),
// GetString(IDS_RB_PARAMETERS),
// 0);
//}
this->ip = ip;
sphereDesc.BeginEditParams(ip,this,flags,prev);
param_blk.SetUserDlgProc(new SphereParamDlgProc(this));
pmapParam = pblock2->GetMap(sphere_params);
//if(pmapParam) {
// // A callback for the type in.
// pmapParam->SetUserDlgProc(new SphereParamDlgProc(this));
//}
}
RefResult Gradient::NotifyRefChanged(Interval changeInt, RefTargetHandle hTarget,
PartID& partID, RefMessage message )
{
switch (message)
{
case REFMSG_CHANGE:
{
ivalid.SetEmpty();
if (hTarget == pblock) {
// see if this message came from a changing parameter in the pblock,
// if so, limit rollout update to the changing item and update any active viewport texture
ParamID changing_param = pblock->LastNotifyParamID();
if (hTarget != uvGen && hTarget != texout)
grad_param_blk.InvalidateUI(changing_param);
if (changing_param != -1)
DiscardTexHandle();
}
// notify our dependents that we've changed
// NotifyChanged(); //DS this is redundant
break;
}
case REFMSG_UV_SYM_CHANGE:
DiscardTexHandle();
break;
}
return(REF_SUCCEED);
}
ParamDlg* CompositeMat::CreateParamDlg(HWND hwMtlEdit, IMtlParams *imp)
{
masterDlg = compositematCD.CreateParamDlgs(hwMtlEdit, imp, this);
compmat_param_blk.SetUserDlgProc(new CompMatDlgProc(this));
// dlg = new CompositeMatDlg(hwMtlEdit, imp, this);
return masterDlg;
}
