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; }