INT_PTR EffectsDlgProc::DlgProc(TimeValue t, IParamMap2 *map, HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam) { switch (msg) { case WM_INITDIALOG: { HWND hwndeffect = GetDlgItem(hWnd, IDC_EFFECTLIST); SendMessage(hwndeffect, CB_RESETCONTENT, 0L, 0L); for (int i = 0; i < vl->NumShaders(); i++) { ClassDesc* pClassD = vl->GetEffectCD(i); int n = SendMessage(hwndeffect, CB_ADDSTRING, 0L, (LPARAM)(pClassD->ClassName()) ); } SendMessage(hwndeffect, CB_INSERTSTRING, 0L, (LPARAM)GetString(IDS_STR_NONE)); SendMessage(hwndeffect, CB_SETCURSEL, vl->effectIndex,0L); if (vl->IsCurrentEffectSupported()) { vl->EnableDlgItem(IDC_ENABLED, TRUE); } else { vl->SetCurrentEffectEnabled(false); vl->EnableDlgItem(IDC_ENABLED, FALSE); } vl->EnableDlgItem(IDC_SAVE_FX, vl->IsSaveFxSupported()); return TRUE; } } return FALSE; }
const TCHAR * ViewportLoader::GetActiveEffectName() { ClassDesc* pCD = GetEffectCD(effectIndex-1); if(pCD) return (TCHAR*)pCD->ClassName(); else return NULL; }
//----------------------------------------------------------------------- bool IsDynamicDxMaterial(MtlBase * newMtl) { DllDir * lookup = GetCOREInterface()->GetDllDirectory(); ClassDirectory & dirLookup = lookup->ClassDir(); ClassDesc * cd = dirLookup.FindClass(MATERIAL_CLASS_ID, newMtl->ClassID()); if(cd && cd->SubClassID() == DXMATERIAL_DYNAMIC_UI){ return true; } return false; }
void ViewportLoader::LoadEffect(ClassDesc * pd) { ReferenceTarget * newEffect; ReferenceTarget * oldEffect; if (theHold.Holding()) { oldEffect = effect; // theHold.Suspend(); if(pd == NULL){ newEffect = NULL; } else{ newEffect = (ReferenceTarget *)pd->Create(FALSE); DbgAssert(newEffect && _M("Plug-in instance creation failed. Possible cause: deferred plug-in failed to load.")); if(!newEffect) { // maybe deferred ClassDesc * def = FindandLoadDeferedEffect(pd); if(def) { newEffect = (ReferenceTarget *)def->Create(FALSE); } } } // theHold.Resume(); if (theHold.Holding()) theHold.Put(new AddEffectRestore(this,oldEffect,newEffect)); SwapEffect(newEffect); } }
bool NatLightAssemblyClassDesc::IsValidSun( ClassDesc& cd) { bool bValidSun = ((cd.ClassID() == NatLightAssembly::GetStandardSunClass()) != FALSE); if (!bValidSun) { INaturalLightClass* pNC = GetNaturalLightClassInterface(&cd); if (pNC != NULL && (pNC->GetDesc()->flags & FP_STATIC_METHODS)) { bValidSun = (pNC->IsSun() != FALSE); } } return bValidSun; }
bool VDMClassDesc::IsCompatibleWithRenderer(ClassDesc& rendererClassDesc) { Class_ID classID = rendererClassDesc.ClassID(); if((classID == MRRENDERER_CLASSID) /* || (classID == SCANLINERENDERER_CLASS_ID) */ ) { return true; } else { // Return 'true' only if the renderer doesn't implement the compatibility interface. // This ensures that we are compatible with all renderers unless they specify the contrary. IMtlRender_Compatibility_Renderer* rendererCompatibility = Get_IMtlRender_Compatibility_Renderer(rendererClassDesc); return (rendererCompatibility == NULL); } }
bool mrShaderFilter::ValidateReturnType(ClassDesc& classDesc) { SClass_ID superClassID = classDesc.SuperClassID(); if(superClassID == MATERIAL_CLASS_ID) { // Validate if we want a TYPE_MTL return type //return ValidType(TYPE_MTL); // Do not validate types for materials. Only use the apply type for validatoin. return true; } else if(superClassID == TEXMAP_CLASS_ID) { imrShaderClassDesc* shaderClassDesc = Get_mrShaderClassDesc(&classDesc); if(shaderClassDesc == NULL) { // Assume that the texture returns a color return ValidType(static_cast<ParamType2>(TYPE_RGBA)); } else { // Go through the results structure ParamBlockDesc2* pbDesc = shaderClassDesc->GetResultPBDesc(); if((pbDesc != NULL) && ValidateReturnType(*pbDesc)) { return true; } // Go through the sub-structures, is allowed if(m_acceptStructs) { Tab<ParamBlockDesc2*>& resultDescs = shaderClassDesc->GetResultPBDescs(); int count = resultDescs.Count(); for(int i = 0; i < count; ++i) { ParamBlockDesc2* pbDesc = resultDescs[i]; if((pbDesc != NULL) && ValidateReturnType(*pbDesc)) { return true; } } } return false; } } else { // Shouldn't occur DbgAssert(false); return false; } }
void TapeHelpCreationManager::CreateNewObject() { tapeObject = (TapeHelpObject*)cDesc->Create(); lastPutCount = theHold.GetGlobalPutCount(); macroRec->BeginCreate(cDesc); // Start the edit params process if ( tapeObject ) { tapeObject->SetAFlag(A_OBJ_LONG_CREATE); #ifndef NO_CREATE_TASK // russom - 12/04/01 tapeObject->BeginEditParams( (IObjParam*)createInterface, BEGIN_EDIT_CREATE, NULL ); #endif } }
void CreateSWrapObjectProc::CreateNewObject() { SWrapObj = (SWrapObject*)cDesc->Create(); lastPutCount = theHold.GetGlobalPutCount(); // Start the edit params process if ( SWrapObj ) { #ifndef NO_CREATE_TASK // russom - 12/04/01 SWrapObj->BeginEditParams( (IObjParam*)createInterface, BEGIN_EDIT_CREATE, NULL ); #endif #ifdef _OSNAP SWrapObj->SetAFlag(A_OBJ_LONG_CREATE); #endif } }
bool mrShaderFilter::ValidateApplyType(ClassDesc& classDesc) { SClass_ID superClassID = classDesc.SuperClassID(); if(superClassID == MATERIAL_CLASS_ID) { // Validate if materials are accepted return ((m_applyTypes & imrShaderClassDesc::kApplyFlag_MtlPhen) != 0); } else if(superClassID == TEXMAP_CLASS_ID) { // First, query for a possible custom apply type imrShaderTranslation_ClassInfo* customClassInfo = Get_imrShaderTranslation_ClassInfo(classDesc); if(customClassInfo != NULL) { unsigned int customApplyType = customClassInfo->GetApplyTypes(); return ((customApplyType & m_applyTypes) != 0); } else { imrShaderClassDesc* shaderClassDesc = Get_mrShaderClassDesc(&classDesc); if(shaderClassDesc == NULL) { // Not a mr shader. Validate if texture shaders are accepted. return ((m_applyTypes & imrShaderClassDesc::kApplyFlag_Texture) != 0); } else { // Depends on the apply type of the shader unsigned int shaderApplyTypes = shaderClassDesc->GetApplyTypes(); return ((shaderApplyTypes & m_applyTypes) != 0); } } } else { // Shouldn't occur DbgAssert(false); return false; } }
void plComponentDlg::IOpenRightClickMenu() { HWND hTree = GetDlgItem(fhDlg, IDC_TREE); // Get the position of the cursor in screen and tree client coords POINT point, localPoint; GetCursorPos(&point); localPoint = point; ScreenToClient(hTree, &localPoint); // Check if there is a tree item at that point TVHITTESTINFO hitTest; hitTest.pt = localPoint; TreeView_HitTest(hTree, &hitTest); if (!(hitTest.flags & TVHT_ONITEMLABEL)) return; // Check if the tree item has an lParam (is a component) TVITEM item; item.mask = TVIF_PARAM; item.hItem = hitTest.hItem; TreeView_GetItem(hTree, &item); HMENU menu = nil; if (IIsComponent(item.lParam)) menu = fCompMenu; else if (IIsType(item.lParam)) menu = fTypeMenu; else return; // Select the item we're working with, so the user isn't confused TreeView_SelectItem(hTree, item.hItem); // Create the popup menu and get the option the user selects SetForegroundWindow(fhDlg); int sel = TrackPopupMenu(menu, TPM_NONOTIFY | TPM_RETURNCMD, point.x, point.y, 0, fhDlg, NULL); switch(sel) { case kMenuDelete: IDeleteComponent((plMaxNode*)item.lParam); break; case kMenuRename: TreeView_EditLabel(hTree, hitTest.hItem); break; case kMenuCopy: { // Component to copy INode *node = (INode*)item.lParam; INodeTab tab; tab.Append(1, &node); // Copy INodeTab copy; // Make the copy fInterface->CloneNodes(tab, Point3(0,0,0), true, NODE_COPY, NULL, ©); // Delete the targets for the copy and add it to the tree plMaxNode *newNode = (plMaxNode*)copy[0]; newNode->ConvertToComponent()->DeleteAllTargets(); HTREEITEM hItem = IAddComponent(GetDlgItem(fhDlg, IDC_TREE), newNode); TreeView_SelectItem(GetDlgItem(fhDlg, IDC_TREE), hItem); } break; case kMenuHide: { ClassDesc *desc = plComponentMgr::Inst().Get(item.lParam-1); std::vector<Class_ID>::iterator it; it = std::find(fHiddenComps.begin(), fHiddenComps.end(), desc->ClassID()); TSTR name = desc->ClassName(); if (it == fHiddenComps.end()) { fHiddenComps.push_back(desc->ClassID()); name.Append(" (Hidden)"); } else fHiddenComps.erase(it); item.mask = TVIF_TEXT; item.pszText = name; TreeView_SetItem(GetDlgItem(fhDlg, IDC_TREE), &item); plComponentUtil::Instance().IUpdateRollups(); } break; } PostMessage(fhDlg, WM_USER, 0, 0); }
BOOL plComponentDlg::DlgProc(HWND hDlg, UINT msg, WPARAM wParam, LPARAM lParam) { switch (msg) { case WM_INITDIALOG: fhDlg = hDlg; IAddComponentsRecur(GetDlgItem(hDlg, IDC_TREE), (plMaxNode*)GetCOREInterface()->GetRootNode()); ICreateMenu(); ICreateRightClickMenu(); return TRUE; case WM_SIZING: IPositionControls((RECT*)lParam, wParam); return TRUE; case WM_ACTIVATE: if (LOWORD(wParam) == WA_INACTIVE) plMaxAccelerators::Enable(); else plMaxAccelerators::Disable(); return TRUE; case WM_COMMAND: if (HIWORD(wParam) == BN_CLICKED && LOWORD(wParam) == IDCANCEL) { ShowWindow(hDlg, SW_HIDE); fInterface->UnRegisterDlgWnd(hDlg); return TRUE; } else if (HIWORD(wParam) == BN_CLICKED && LOWORD(wParam) == IDC_ATTACH) { IAttachTreeSelection(); return TRUE; } else if (HIWORD(wParam) == EN_KILLFOCUS && LOWORD(wParam) == IDC_COMMENTS) { IGetComment(); return TRUE; } // "Refresh" menu item else if (HIWORD(wParam) == BN_CLICKED && LOWORD(wParam) == ID_REFRESH) { IRefreshTree(); return TRUE; } // "Remove unused components" menu item else if (HIWORD(wParam) == BN_CLICKED && LOWORD(wParam) == ID_REMOVE_UNUSED) { IRemoveUnusedComps(); return TRUE; } // Item selected from 'New' menu else if (HIWORD(wParam) == BN_CLICKED && LOWORD(wParam) >= MENU_ID_START) { ClassDesc *desc = plComponentMgr::Inst().Get(LOWORD(wParam)-MENU_ID_START); // If this is a component type (not a category) if (desc) { // Create an object of that type and a node to reference it Object *obj = (Object*)GetCOREInterface()->CreateInstance(desc->SuperClassID(), desc->ClassID()); INode *node = GetCOREInterface()->CreateObjectNode(obj); plComponentBase *comp = (plComponentBase*)obj; node->Hide(!comp->AllowUnhide()); node->Freeze(TRUE); // Add the new component to the tree HWND hTree = GetDlgItem(hDlg, IDC_TREE); HTREEITEM item = IAddComponent(hTree, (plMaxNode*)node); TreeView_SelectItem(hTree, item); TreeView_EnsureVisible(hTree, item); } } break; case WM_NOTIFY: NMHDR *nmhdr = (NMHDR*)lParam; if (nmhdr->idFrom == IDC_TREE) { switch (nmhdr->code) { case TVN_SELCHANGED: { NMTREEVIEW *tv = (NMTREEVIEW*)lParam; IGetComment(); bool isComponent = IIsComponent(tv->itemNew.lParam); // If the new selection is a component, enable the attach button and comment field EnableWindow(GetDlgItem(hDlg, IDC_ATTACH), isComponent); SendDlgItemMessage(hDlg, IDC_COMMENTS, EM_SETREADONLY, !isComponent, 0); if (isComponent) { fCommentNode = (plMaxNode*)tv->itemNew.lParam; TSTR buf; fCommentNode->GetUserPropBuffer(buf); SetDlgItemText(hDlg, IDC_COMMENTS, buf); } else { fCommentNode = nil; SetDlgItemText(hDlg, IDC_COMMENTS, ""); } return TRUE; } break; case TVN_BEGINLABELEDIT: // If this isn't a component, don't allow the edit if (!IIsComponent(((NMTVDISPINFO*)lParam)->item.lParam)) { SetWindowLong(hDlg, DWL_MSGRESULT, TRUE); return TRUE; } // The edit box this creates kills the focus on our window, causing // accelerators to be enabled. Add an extra disable to counteract that. plMaxAccelerators::Disable(); return TRUE; // Finishing changing the name of a component case TVN_ENDLABELEDIT: { NMTVDISPINFO *di = (NMTVDISPINFO*)lParam; char* text = di->item.pszText; // If the name was changed... if (text && *text != '\0') { // Update the name of the node plMaxNode *node = IGetTreeSelection(); node->SetName(text); // Update the name in the panel too if (plComponentUtil::Instance().IsOpen()) plComponentUtil::Instance().IUpdateNodeName(node); // Make sure Max knows the file was changed SetSaveRequiredFlag(); // Return true to keep the changes SetWindowLong(hDlg, DWL_MSGRESULT, TRUE); } plMaxAccelerators::Enable(); } return TRUE; // User double-clicked. Select the objects the selected component is attached to. case NM_DBLCLK: ISelectTreeSelection(); return TRUE; case NM_RCLICK: IOpenRightClickMenu(); return TRUE; case TVN_KEYDOWN: // User pressed delete if (((NMTVKEYDOWN*)lParam)->wVKey == VK_DELETE) { IDeleteComponent(IGetTreeSelection()); return TRUE; } break; } } break; } return FALSE; }
bool mrTwoSidedShader::mrShaderTwoSidedShader_ClassDesc::IsCompatibleWithRenderer(ClassDesc& rendererClassDesc) { // Compatible only with the mental ray renderer return ((rendererClassDesc.ClassID() == MRRENDERER_CLASSID) != 0); }
// From IMtlRender_Compatibility_MtlBase bool IsCompatibleWithRenderer(ClassDesc& rendererClassDesc) { // Only compatible with mental ray and harmony return ((rendererClassDesc.ClassID() == MRRENDERER_CLASSID) != 0); }
void ViewportLoader::LoadEffectsList() { // loads static shader list with name-sorted Shader ClassDesc*'s bool bdx9 = false; GraphicsWindow *gw = NULL; ViewExp& vpt = GetCOREInterface()->GetActiveViewExp(); if(vpt.IsAlive()) { gw = vpt.getGW(); if(gw && gw->GetInterface(D3D9_GRAPHICS_WINDOW_INTERFACE_ID)) { bdx9 = true; } } effectsList.ZeroCount(); SubClassList* scList = GetCOREInterface()->GetDllDir().ClassDir().GetClassList(REF_TARGET_CLASS_ID); theHold.Suspend(); // LAM - 3/24/03 - defect 446356 - doing a DeleteThis on created effects, need to make sure hold is off for (long i = 0, j = 0; i < scList->Count(ACC_ALL); ++i) { if ( (*scList)[ i ].IsPublic() ) { ClassDesc* pClassD = (*scList)[ i ].CD(); const TCHAR *cat = pClassD->Category(); TCHAR *defcat = GetString(IDS_DX_VIEWPORT_EFFECT); if ((cat) && (_tcscmp(cat,defcat) == 0)) { ReferenceTarget * effect = (ReferenceTarget *)pClassD->Create(TRUE); if(effect) { IDX9DataBridge * vp = (IDX9DataBridge*)effect->GetInterface(VIEWPORT_SHADER9_CLIENT_INTERFACE); if( vp) { if(bdx9) { if(vp->GetDXVersion() >=9.0f || vp->GetDXVersion() == 1.0f) { effectsList.Append(1, &pClassD); } } else { if(vp->GetDXVersion() < 9.0f) { effectsList.Append(1, &pClassD); } } } else { IDXDataBridge * vp = (IDXDataBridge*)effect->GetInterface(VIEWPORT_SHADER_CLIENT_INTERFACE); if(vp && !bdx9) { effectsList.Append(1, &pClassD); } } effect->MaybeAutoDelete(); } } } } theHold.Resume(); effectsList.Sort(&classDescListCompare); }
StructuralContext::Impl::Impl(const ClassDescriptor* rootClassDesc) : m_rootClassDesc(rootClassDesc) { list<ClassDesc> pending; set<ClassDesc> processed; pending.push_back(rootClassDesc); while (!pending.empty()) { ClassDesc current = pending.front(); pending.pop_front(); if (processed.count(current)) { continue; } // Class hierachy ClassDesc parent = current->getParentClassDescriptor(); if (parent) { if (!processed.count(parent)) { pending.push_back(parent); } m_classInfoMap[parent].subclasses.insert(current); ClassDesc predecessor = current; while ((predecessor = predecessor->getParentClassDescriptor())) { m_classInfoMap[predecessor].allSubclasses.insert(current); } } auto features = current->getFeatureDescriptors(); for (auto feature : features) { auto typeDesc = feature->getTypeDescriptor(); list<IterationItem> path; IterationItem item; item.desc = typeDesc; path.push_back(item); while (!path.empty()) { IterationItem currentItem = path.front(); auto typeDesc = currentItem.desc; path.pop_front(); switch (typeDesc->getKind()) { case TypeDescriptor::kClass: { auto classDesc = typeDesc->as<ClassDescriptor>(); const Reference ref{currentItem.referenceType, current, feature, classDesc}; m_classInfoMap[classDesc].inReferences.push_back(ref); m_classInfoMap[current].outReferences.push_back(ref); m_allReferences.insert(feature); pending.push_back(classDesc); } break; case TypeDescriptor::kPointer: { if (currentItem.referenceType != Reference::kContained) { throw runtime_error("Invalid model"); } auto ptrDesc = typeDesc->as<PointerTypeDescriptor>(); currentItem.desc = ptrDesc->getPointedTypeDescriptor(); currentItem.referenceType = getReferenceType(ptrDesc->getPointerType()); path.push_back(currentItem); } break; case TypeDescriptor::kPair: { auto pairDesc = typeDesc->as<PairTypeDescriptor>(); currentItem.desc = pairDesc->getFirstTypeDescriptor(); path.push_back(currentItem); currentItem.desc = pairDesc->getSecondTypeDescriptor(); path.push_back(currentItem); } break; // Containers case TypeDescriptor::kList: case TypeDescriptor::kMap: case TypeDescriptor::kSet: { auto containerDesc = typeDesc->as<ContainerTypeDescriptor>(); currentItem.desc = containerDesc->getValueTypeDescriptor(); path.push_back(currentItem); } break; default: break; } } } processed.insert(current); } m_allClasses = {processed.begin(), processed.end()}; // All references for (auto& it: m_classInfoMap) { ClassInfo& classInfo = it.second; for (const auto& subclass: classInfo.allSubclasses) { ClassInfo& subClassInfo = m_classInfoMap[subclass]; subClassInfo.allOutReferences.insert( subClassInfo.allOutReferences.end(), classInfo.outReferences.begin(), classInfo.outReferences.end()); subClassInfo.allInReferences.insert( subClassInfo.allInReferences.end(), classInfo.inReferences.begin(), classInfo.inReferences.end()); } } for (auto& it: m_classInfoMap) { ClassInfo& classInfo = it.second; classInfo.allOutReferences.insert( classInfo.allOutReferences.end(), classInfo.outReferences.begin(), classInfo.outReferences.end()); classInfo.allInReferences.insert( classInfo.allInReferences.end(), classInfo.inReferences.begin(), classInfo.inReferences.end()); } }
const TCHAR * ViewportLoader::GetEffectName(int i) { ClassDesc* pClassD = GetEffectCD(i-1); return (TCHAR*)pClassD->ClassName(); }