C++ GetCOREInterface函数代码示例

bool DxStdMtl2::CreateAndLoadEffectData()
{
	ResetDXStates();

	if(IsDxMaterialEnabled(map))
	{
		bool useLPRT;
		TCHAR filename[MAX_PATH];
		_tcscpy(filename,GetCOREInterface()->GetDir(APP_PLUGCFG_DIR));
		_tcscat(filename,"\\DXDisplay.ini");

		useLPRT = GetPrivateProfileInt(_T("Settings"),_T("LPRTEnabled"),0,filename) ? true : false;
			
		if(!pd3dDevice)
			pd3dDevice = GetDevice();

		if(!pd3dDevice)
			return false;

		if(pEffectParser)
		{
			pEffectParser->DestroyParser();
			pEffectParser = NULL;
		}

		elementContainer.DeleteAllElements();

		UpdateSceneLights();
		DWORD numberOfPSinst = 0;
		
		//lets make sure we get the correct code for the GFX card..
		IHLSLCodeGenerator::CodeVersion code = GetPixelShaderSupport(pd3dDevice,numberOfPSinst);

		if(code == IHLSLCodeGenerator::PS_1_X)
			return false;

		IHLSLCodeGenerator * codeGen = IHLSLCodeGenerator::GetHLSLCodeGenerator();

		Tab<INode*> lights;
		for(int j=0;j<sceneLights.Count();j++){
			INode * Light = sceneLights[j]->GetLightNode();
			lights.Append(1, &Light);
		}

		TCHAR * effectString = codeGen->GenerateEffectFile(map,lights,code,bTransparency,numberOfPSinst,useLPRT);

		if(!pEffectParser)
			CreateEffectParser();
		if(pEffectParser && effectString){
			pEffectParser->SetUseLPRT(useLPRT);
			pEffectParser->LoadEffect(pd3dDevice,this,effectString,false,true);
			pEffectParser->ParseEffectFile(pd3dDevice,NULL,this);
			PatchInLightNodes();
			LoadTextureData(codeGen);
		}
		delete codeGen;

		IRenderMesh * rm = mpMeshCache->GetActiveRenderMesh(m_CurCache);
		if(rm) rm->Invalidate();

		GetCOREInterface()->ForceCompleteRedraw(FALSE);

	}

	return true;
}

void plCreateMenu()
{
#if MAX_VERSION_MAJOR <= 11
    AddPlasmaExportMenu();
#endif

    IMenuManager* pMenuMan = GetCOREInterface()->GetMenuManager();
    bool newlyRegistered = pMenuMan->RegisterMenuBarContext(kMyMenuContextId, kMenuName);

    // Is the Max menu version the most recent?
    bool wrongVersion = GetPrivateProfileIntW(L"Menu", L"Version", 0, plMaxConfig::GetPluginIni().WideString().data()) < kMenuVersion;
    if (wrongVersion)
    {
        // Delete the old version of the menu
        IMenu *oldMenu = pMenuMan->FindMenu(kMenuName);
        if (oldMenu)
            pMenuMan->UnRegisterMenu(oldMenu);

        // Update the menu version
        wchar_t buf[12];
        snwprintf(buf, arrsize(buf), L"%d", kMenuVersion);
        WritePrivateProfileStringW(L"Menu", L"Version", buf, plMaxConfig::GetPluginIni().WideString().data());
    }
    
    if (wrongVersion || newlyRegistered)
    {
        IMenu *pMainMenu = pMenuMan->GetMainMenuBar();
        if (!pMainMenu)
        {
            hsAssert(0, "Main menu not found");
            return;
        }

        // Get our action table
        ActionTable* pActionTable = GetCOREInterface()->GetActionManager()->FindTable(kActionId);
        if (!pActionTable)
        {
            hsAssert(0, "Action table not found");
            return;
        }

        // Create the Plasma menu
        IMenu* pPlasmaMenu = GetIMenu();
        pPlasmaMenu->SetTitle(kMenuName);

        // Register the new menu with the system
        pMenuMan->RegisterMenu(pPlasmaMenu, 0);

        /////////////////////////////////////////////////
        // Add the menu items
        //
        IMenuItem* pMenuItem;
 
#if MAX_VERSION_MAJOR >= 12
        // Add the export action to the menu
        pMenuItem = GetIMenuItem();
        pMenuItem->SetActionItem(pActionTable->GetAction(kActionExport));
        pPlasmaMenu->AddItem(pMenuItem);
#endif

        // Add the save selected action to the menu
        pMenuItem = GetIMenuItem();
        pMenuItem->SetActionItem(pActionTable->GetAction(kActionSaveSel));
        pPlasmaMenu->AddItem(pMenuItem);

        // Add the merge action to the menu
        pMenuItem = GetIMenuItem();
        pMenuItem->SetActionItem(pActionTable->GetAction(kActionMerge));
        pPlasmaMenu->AddItem(pMenuItem);

        // Add the component copy action to the menu
        pMenuItem = GetIMenuItem();
        pMenuItem->SetActionItem(pActionTable->GetAction(kActionCompCopy));
        pPlasmaMenu->AddItem(pMenuItem);

        // Add a separator
        pMenuItem = GetIMenuItem();
        pMenuItem->ActAsSeparator();
        pPlasmaMenu->AddItem(pMenuItem);
    
        // Add the component manager to the menu
        pMenuItem = GetIMenuItem();
        pMenuItem->SetActionItem(pActionTable->GetAction(kActionComponent));
        pPlasmaMenu->AddItem(pMenuItem);

        // Add the resource collector to the menu
        pMenuItem = GetIMenuItem();
        pMenuItem->SetActionItem(pActionTable->GetAction(kActionResCollect));
        pPlasmaMenu->AddItem(pMenuItem);

        // Add the texture search to the menu
        pMenuItem = GetIMenuItem();
        pMenuItem->SetActionItem(pActionTable->GetAction(kActionTexSearch));
        pPlasmaMenu->AddItem(pMenuItem);

        // Add the age description to the menu
        pMenuItem = GetIMenuItem();
        pMenuItem->SetActionItem(pActionTable->GetAction(kActionAgeDesc));
        pPlasmaMenu->AddItem(pMenuItem);

//.........这里部分代码省略.........

// Generate all the optimzation and geometry data
void morphChannel::buildFromNode( INode *node , BOOL resetTime, TimeValue t, BOOL picked )
{
	// fix for defect 1346773 - Crash deleting progressive morph target
	if (NULL == node ) {
		return;
	}

	if(resetTime) t = GetCOREInterface()->GetTime();

	ObjectState os = node->EvalWorldState(t);

	int tPc = os.obj->NumPoints();
	int x,id = 0;
	Point3 DeltP;
	double wtmp;
	Point3 tVert;

	if(tPc!=mp->MC_Local.Count) {
		mNumPoints = 0;
		mActive = FALSE;
		mInvalid = TRUE;
		goto CantLoadThis;
	}
	if(!mp->MC_Local.CacheValid) goto CantLoadThis;


	mInvalid = FALSE;

	// if the channel hasn't been edited yet, change the 'empty'
	// name to that of the chosen object.
	if( !mModded || picked) mName = node->GetName();

	// Set the data into the morphChannel
	mActive = TRUE;
	mModded = TRUE;

	
	// Prepare the channel
	AllocBuffers(tPc, tPc);
	mSel.SetSize(tPc);
	mSel.ClearAll();


	mNumPoints = 0;

	for(x=0;x<tPc;x++)
	{
		tVert = os.obj->GetPoint(x);
		wtmp = os.obj->GetWeight(x);

		// calculate the delta cache
		DeltP.x=(tVert.x-mp->MC_Local.oPoints[x].x)/100.0f;
		DeltP.y=(tVert.y-mp->MC_Local.oPoints[x].y)/100.0f;
		DeltP.z=(tVert.z-mp->MC_Local.oPoints[x].z)/100.0f;
		mDeltas[x] = DeltP;

		mWeights[x] = os.obj->GetWeight(x);
		mSel.Set( x, os.obj->IsPointSelected(x)?1:0);

		mPoints[x] = tVert;
		mNumPoints++;
	}


	// Update *everything*
	mp->NotifyDependents(FOREVER,PART_ALL,REFMSG_CHANGE);
	mp->NotifyDependents(FOREVER,PART_ALL,REFMSG_SUBANIM_STRUCTURE_CHANGED);
	mp->Update_channelFULL();
	mp->Update_channelParams();

	CantLoadThis:
	tPc=0;
}

BOOL plPlasmaMAXLayer::HandleBitmapSelection(int index /* = 0 */)
{
    static ICustButton* bmSelectBtn;

    PBBitmap *pbbm = GetPBBitmap( index );

#ifdef MAXASS_AVAILABLE
    MaxAssInterface* maxAssInterface = GetMaxAssInterface();
#endif
    
    // If the control key is held, we want to get rid of this texture
    if ((GetKeyState(VK_CONTROL) & 0x8000) && pbbm != nil)
    {
        char msg[512];
        sprintf(msg, "Are you sure you want to change this bitmap from %s to (none)?", pbbm->bi.Name());
        if (hsMessageBox(msg, "Remove texture?", hsMessageBoxYesNo) == hsMBoxYes)
        {
            SetBitmap(nil, index);
            return TRUE;
        }
        return FALSE;
    }
    // if we have the assetman plug-in, then try to use it, unless shift is held down
#ifdef MAXASS_AVAILABLE
    else if(maxAssInterface && !(GetKeyState(VK_SHIFT) & 0x8000))
    {
        jvUniqueId assetId;
        GetBitmapAssetId(assetId, index);

        char filename[MAX_PATH];
        if (maxAssInterface->OpenBitmapDlg(assetId, filename, sizeof(filename)))
        {
            SetBitmapAssetId(assetId, index);

            BitmapInfo bi;
            bi.SetName(filename);
            SetBitmap(&bi, index);
            return TRUE;
        }
    }
#endif
    else
    {
        BitmapInfo bi;
        if( pbbm != NULL )
            bi.SetName( pbbm->bi.Name() );

        BOOL selectedNewBitmap = TheManager->SelectFileInput(&bi,
                                                            GetCOREInterface()->GetMAXHWnd(),
                                                            _T("Select Bitmap Image File"));
        if (selectedNewBitmap)
        {
#ifdef MAXASS_AVAILABLE
            // Set the assetId to empty so our new, unmanaged texture will take
            jvUniqueId emptyId;
            SetBitmapAssetId(emptyId, index);
#endif

            SetBitmap(&bi, index);
            return TRUE;
        }
    }

    return FALSE;
}

//.........这里部分代码省略.........
			iret = TRUE;
			break;
			}

		case IDC_NAMELISTGLOBAL_DROP :
			{
			if (GetAffectSelectedOnly())
				SetAffectSelectedOnly(FALSE);
			else SetAffectSelectedOnly(TRUE);
			iret = TRUE;
			break;
			}

		case IDC_JBUIMETHOD :
			{
			if (GetJBMethod())
				SetJBMethod(FALSE);
			else SetJBMethod(TRUE);
			iret = TRUE;
			break;
			}
		case IDC_SHOWMENU :
			{
			if (GetShowMenu())
				SetShowMenu(FALSE);
			else SetShowMenu(TRUE);
			iret = TRUE;
			break;
			}
		case IDC_SHOWSETUI :
			{
			if (GetShowSetUI())
				SetShowSetUI(FALSE);
			else SetShowSetUI(TRUE);
			iret = TRUE;
			break;
			}
		case IDC_SHOWOPTIONSUI :
			{
			if (GetShowOptionsUI())
				SetShowOptionsUI(FALSE);
			else SetShowOptionsUI(TRUE);
			iret = TRUE;
			break;
			}
		case IDC_SHOWCOPYPASTEUI :
			{
			if (GetShowCopyPasteUI())
				SetShowCopyPasteUI(FALSE);
			else SetShowCopyPasteUI(TRUE);
			iret = TRUE;
			break;
			}

		case IDC_DRAGMODE :
			{
			if (GetDragLeftMode())
				SetDragLeftMode(FALSE);
			else SetDragLeftMode(TRUE);
			iret = TRUE;
			break;
			}

		case IDC_DEBUGMODE :
			{
			if (GetDebugMode())
				SetDebugMode(FALSE);
			else SetDebugMode(TRUE);
			iret = TRUE;
			break;
			}


		case IDC_SHOWMARKER :
			{
			if (GetShowMarker())
				SetShowMarker(FALSE);
			else SetShowMarker(TRUE);
			iret = TRUE;
			break;
			}

//5.1.01
		case IDC_RIGHTJUSTIFY: 
			{
			if (GetRightJustify())
				SetRightJustify(FALSE);
			else SetRightJustify(TRUE);
			break;
			}


		}
	
	IMenuBarContext* pContext = (IMenuBarContext*) GetCOREInterface()->GetMenuManager()->GetContext(kWeightTableMenuBar);
	if (pContext)
		pContext->UpdateWindowsMenu();

	return iret;
	}

INT_PTR CALLBACK RigidBodyWorld::Proc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam)
{
	RigidBodyWorld* const world = (RigidBodyWorld *)GetWindowLong (hWnd, GWLP_USERDATA);
	RigidBodyWorldDesc* const desc = (RigidBodyWorldDesc*) RigidBodyWorldDesc::GetDescriptor();

	switch (msg) 
	{
		case WM_INITDIALOG:
		{
			
			RigidBodyWorld* const world = (RigidBodyWorld *)lParam;
			SetWindowLong(hWnd, GWLP_USERDATA, (LONG)world);

			world->m_myWindow = hWnd;
			world->RigidBodyWorld::InitUI(hWnd);
			break;
		}

		case WM_DESTROY:
		{
			world->StopsSimulation ();
			world->RigidBodyWorld::DestroyUI(hWnd);
			break;
		}

		case WM_ENABLE:
		{
			//EnableWindow(obj->m_worldPaneHandle, (BOOL) wParam);
			break;
		}

		case WM_TIMER:
		{
			world->UpdatePhysics ();
			break;
		}


		case WM_COMMAND:
		{
			switch (LOWORD(wParam)) 
			{
				case IDC_MAKE_RIGIDBODY:
				{
					world->StopsSimulation ();
					Interface* const ip = GetCOREInterface();
					int selectionCount = ip->GetSelNodeCount();
					for (int i = 0; i < selectionCount; i ++) {
						INode* const node = ip->GetSelNode(i);
						Object* const obj = node->GetObjOrWSMRef();
						if (obj) {
							world->AttachRigiBodyController (node);
						}
					}
					world->UpdateViewPorts();
					break;
				}

				case IDC_DELETE_RIGIDBODY:
				{
					world->StopsSimulation ();
					Interface* const ip = GetCOREInterface();
					int selectionCount = ip->GetSelNodeCount();
					for (int i = 0; i < selectionCount; i ++) {
						INode* const node = ip->GetSelNode(i);
						world->DetachRigiBodyController (node);
					}
					world->UpdateViewPorts ();

					break;
				}

				case IDC_SHOW_GIZMOS:
				{
					world->StopsSimulation ();
					for (NewtonBody* body = NewtonWorldGetFirstBody(desc->m_newton); body; body = NewtonWorldGetNextBody(desc->m_newton, body)) {
						INode* const node = (INode*)NewtonBodyGetUserData(body);
						RigidBodyController* const bodyInfo = (RigidBodyController*)desc->GetRigidBodyControl(node);
						_ASSERTE (bodyInfo);
						bodyInfo->m_hideGizmos = FALSE;
					}
					world->UpdateViewPorts();
					break;
				}

				case IDC_HIDE_GIZMOS:
				{
					world->StopsSimulation ();
					for (NewtonBody* body = NewtonWorldGetFirstBody(desc->m_newton); body; body = NewtonWorldGetNextBody(desc->m_newton, body)) {
						INode* const node = (INode*)NewtonBodyGetUserData(body);
						RigidBodyController* const bodyInfo = (RigidBodyController*)desc->GetRigidBodyControl(node);
						_ASSERTE (bodyInfo);
						bodyInfo->m_hideGizmos = TRUE;
					}
					world->UpdateViewPorts();
					break;
				}

				case IDC_SELECT_ALL:
				{
//.........这里部分代码省略.........

void
ConeAngleManipulator::GenerateShapes(TimeValue t)
{
    Point3 direction;

    float distance, angle, aspect;
    BOOL  useSquare;
    mValid = FOREVER;
    mpPblock->GetValue(kConeAngleAngle,     t, angle, mValid);
    mpPblock->GetValue(kConeAngleDistance,  t, distance, mValid);
    mpPblock->GetValue(kConeAngleDirection, t, direction, mValid);
    mpPblock->GetValue(kConeAngleUseSquare, t, useSquare, mValid);
    mpPblock->GetValue(kConeAngleAspect,    t, aspect, mValid);

    ClearPolyShapes();
    // Create the circle at the base of the cone

    float ta = (float)tan(0.5 * angle);   
    float rad = distance * ta;

    IManipulatorMgr* pMM = (IManipulatorMgr*) GetCOREInterface(MANIP_MGR_INTERFACE);
    assert(pMM);

    if (!useSquare) {
        // Use a circle gizmo
        GizmoShape* pGizmo = pMM->MakeCircle(Point3(0.0f, 0.0f, -distance), rad, 28);
        
        AppendGizmo(pGizmo, 0, GetUnselectedColor());
        
        delete pGizmo;

        // if a stand-alone manip, draw the struts
        if (!mhTarget) {
            pGizmo = pMM->MakeGizmoShape();
            pGizmo->AppendPoint(Point3(0,0,0));
            pGizmo->AppendPoint(Point3(rad, 0.0f, -distance));
            pGizmo->StartNewLine();

            pGizmo->AppendPoint(Point3(0,0,0));
            pGizmo->AppendPoint(Point3(-rad, 0.0f, -distance));
            pGizmo->StartNewLine();

            pGizmo->AppendPoint(Point3(0,0,0));
            pGizmo->AppendPoint(Point3(0.0f, rad, -distance));
            pGizmo->StartNewLine();

            pGizmo->AppendPoint(Point3(0,0,0));
            pGizmo->AppendPoint(Point3(0.0f, -rad, -distance));
            
            AppendGizmo(pGizmo, 0, GetUnselectedColor(), GetUnselectedColor());
            delete pGizmo;
        }
    } else {
        // Use a square gizmo
        float radAspect = rad * (float) sqrt(aspect);
        float radInvAspect = radAspect / aspect;

        GizmoShape* pGizmo = pMM->MakeGizmoShape();
        pGizmo->AppendPoint(Point3(-radAspect, -radInvAspect, -distance));
        pGizmo->AppendPoint(Point3(-radAspect,  radInvAspect, -distance));
        pGizmo->StartNewLine();
        pGizmo->AppendPoint(Point3( radAspect, -radInvAspect, -distance));
        pGizmo->AppendPoint(Point3( radAspect,  radInvAspect, -distance));
        
        AppendGizmo(pGizmo, 0, GetUnselectedColor());
        delete pGizmo;
        
        pGizmo = pMM->MakeGizmoShape();
        pGizmo->AppendPoint(Point3(-radAspect,  radInvAspect, -distance));
        pGizmo->AppendPoint(Point3( radAspect,  radInvAspect, -distance));
        pGizmo->StartNewLine();
        pGizmo->AppendPoint(Point3(-radAspect, -radInvAspect, -distance));
        pGizmo->AppendPoint(Point3( radAspect, -radInvAspect, -distance));

        AppendGizmo(pGizmo, 0, GetUnselectedColor());
        delete pGizmo;

        // if a stand-alone manip, draw the struts
        if (!mhTarget) {
            pGizmo = pMM->MakeGizmoShape();
            pGizmo->AppendPoint(Point3(0,0,0));
            pGizmo->AppendPoint(Point3(-radAspect, -radInvAspect, -distance));
            pGizmo->StartNewLine();
            
            pGizmo->AppendPoint(Point3(0,0,0));
            pGizmo->AppendPoint(Point3(-radAspect,  radInvAspect, -distance));
            pGizmo->StartNewLine();
            
            pGizmo->AppendPoint(Point3(0,0,0));
            pGizmo->AppendPoint(Point3( radAspect, -radInvAspect, -distance));
            pGizmo->StartNewLine();
            
            pGizmo->AppendPoint(Point3(0,0,0));
            pGizmo->AppendPoint(Point3( radAspect,  radInvAspect, -distance));
            
            AppendGizmo(pGizmo, 0, GetUnselectedColor(), GetUnselectedColor());
            delete pGizmo;
        }
    }
}

//From MtlBase
void BerconTile::Reset() {
	TimeValue t = GetCOREInterface()->GetTime();

	if (texout) texout->Reset();
	else ReplaceReference( OUTPUT_REF, GetNewDefaultTextureOutput());
									   
	for (int i=0; i<TILE_NSUBTEX; i++) 
		DeleteReference(i+2);	

	pblock->SetValue( noise_color1, t, Color(1.f, 1.f, 1.f));
	pblock->SetValue( noise_color2, t, Color(0.f, 0.f, 0.f));
	pblock->SetValue( noise_color3, t, Color(.5f, .5f, .5f));
	pblock->SetValue( noise_map1_on, t, TRUE);
	pblock->SetValue( noise_map2_on, t,	TRUE);
	pblock->SetValue( noise_map2_on, t,	TRUE);
	pblock->SetValue( distortion_str, t, .1f);
	pblock->SetValue( use_distortion, t, FALSE);
	pblock->SetValue( lock_edge, t, TRUE);

	pblock->SetValue( tile_style,    t, 3);
	pblock->SetValue( tile_size,     t, 1.0f);
	pblock->SetValue( tile_width,    t, 4.f);
	pblock->SetValue( tile_height,   t, 2.f);
	pblock->SetValue( edge_width,    t, .1f);
	pblock->SetValue( edge_height,   t, .1f);
	pblock->SetValue( tile_width2,   t, 0.f);
	pblock->SetValue( tile_height2,  t, 0.f);
	pblock->SetValue( edge_width2,   t, 0.f);
	pblock->SetValue( edge_height2,  t, 0.f);

	pblock->SetValue( soften, t, 2);
	pblock->SetValue( soften_rad, t, .1f);
	pblock->SetValue( pb_round, t,	TRUE);
	pblock->SetValue( round_rad, t, .1f);

	pblock->SetValue( pb_map_uv, t, FALSE);	
	pblock->SetValue( pb_uv_channel, t, 1);
	pblock->SetValue( pb_auto, t, 2);
	
	pblock->SetValue( pb_randX,   t, 0.f);
	pblock->SetValue( pb_randY,   t, 0.f);
	pblock->SetValue( pb_randSX,  t, 0.f);
	pblock->SetValue( pb_randSY,  t, 0.f);
	pblock->SetValue( pb_lock,  t, 1);	

	pblock->SetValue( pb_rotUV,  t, 0);	
	pblock->SetValue( pb_randRot,  t, 180.f);

	pblock->SetValue( pb_center,  t, 0);
	pblock->SetValue( pb_center_channel,  t, 2);

	pblock->SetValue( pb_flipX,  t, 1);
	pblock->SetValue( pb_flipY,  t, 1);

	pblock->SetValue( pb_randZ,  t, 1);	

	pblock->SetValue(pb_pattern, t, L"0,1,1/.5,.5,1");

	// Maps
	for (int i=2; i<4; i++)
		pbMap->SetValue(i, t, TRUE);	

	berconXYZ.reset(pbXYZ, ivalid, 1, 0, 0, 0);

	ivalid.SetEmpty();
}

		void SetThing(ReferenceTarget *m) {
			tile = (BerconTile*)m;
			tile->EnableStuff(GetCOREInterface()->GetTime());
		}

int TapeHelpCreationManager::proc(
    HWND hwnd,
    int msg,
    int point,
    int flag,
    IPoint2 m )
{
    int res = TRUE;
    TSTR targName;
    ViewExp& vpx = createInterface->GetViewExp(hwnd);
    assert( vpx.IsAlive() );
    DWORD hideflags;

    switch ( msg ) {
    case MOUSE_POINT:
        switch ( point ) {
        case 0: {
            pt0 = m;
            assert( tapeObject );
            if ( createInterface->SetActiveViewport(hwnd) ) {
                return FALSE;
            }

            if (createInterface->IsCPEdgeOnInView()) {
                res = FALSE;
                goto done;
            }

            // if helpers were hidden by category, re-display them
            hideflags = GetCOREInterface()->GetHideByCategoryFlags();
            if(hideflags & (HIDE_HELPERS))
            {
                hideflags = hideflags & ~(HIDE_HELPERS);
                GetCOREInterface()->SetHideByCategoryFlags(hideflags);
                hideflags = GetCOREInterface()->GetHideByCategoryFlags();
            }

            if ( attachedToNode ) {
                // send this one on its way
                tapeObject->EndEditParams( (IObjParam*)createInterface, 0, NULL);

                macroRec->EmitScript();
                // Get rid of the reference.
                if (tapeNode)
                    DeleteReference(0);

                // new object
                CreateNewObject();   // creates tapeObject
            }

            needToss = theHold.GetGlobalPutCount()!=lastPutCount;

            theHold.Begin();   // begin hold for undo
            mat.IdentityMatrix();

            // link it up
            INode *l_tapeNode = createInterface->CreateObjectNode( tapeObject);
            attachedToNode = TRUE;
            assert( l_tapeNode );
            createCB = tapeObject->GetCreateMouseCallBack();
            createInterface->SelectNode( l_tapeNode );

            // Create target object and node
            targObject = (Object*) createInterface->CreateInstance(GEOMOBJECT_CLASS_ID,Class_ID(TARGET_CLASS_ID,0));
            targObject->SetAFlag(A_OBJ_LONG_CREATE);
            assert(targObject);
            targNode = createInterface->CreateObjectNode( targObject);
            assert(targNode);
            targName = l_tapeNode->GetName();
            targName += GetString(IDS_DB_DOT_TARGET);
            macroRec->Disable();
            targNode->SetName(targName);
            macroRec->Enable();

            // hook up camera to target using lookat controller.
            createInterface->BindToTarget(l_tapeNode,targNode);

            // Reference the new node so we'll get notifications.
            theHold.Suspend();
            ReplaceReference( 0, l_tapeNode);
            theHold.Resume();

            // Position camera and target at first point then drag.
            mat.IdentityMatrix();
            //mat[3] = vpx.GetPointOnCP(m);
#ifdef _3D_CREATE
            mat.SetTrans( vpx.SnapPoint(m,m,NULL,SNAP_IN_3D) );
#else
            mat.SetTrans(vpx.SnapPoint(m,m,NULL,SNAP_IN_PLANE));
#endif
            createInterface->SetNodeTMRelConstPlane(tapeNode, mat);
            createInterface->SetNodeTMRelConstPlane(targNode, mat);
            tapeObject->Enable(1);

            ignoreSelectionChange = TRUE;
            createInterface->SelectNode( targNode,0);
            ignoreSelectionChange = FALSE;
            res = TRUE;
        }
        break;
//.........这里部分代码省略.........

//.........这里部分代码省略.........


	Object *obj = CreateNURBSObject(mpIp, &nset, mat);
	INode *node = mpIp->CreateObjectNode(obj);
	node->SetName(GetString(IDS_TEST_OBJECT));




	NURBSSet addNset;
	// build a point surface
	int addptSurf = AddTestPointSurface(addNset);

	// add an iso curve to the previously created CV Surface
	NURBSId id = nset.GetNURBSObject(cvSurf)->GetId();
	int addIsoCrv = AddTestIsoCurve(addNset, id);

	AddNURBSObjects(obj, mpIp, &addNset);




	// now test some changing functionality
	// Let's change the name of the CVSurface
	NURBSObject* nObj = nset.GetNURBSObject(cvSurf);
	nObj->SetName(_T("New CVSurf Name"));  // testing only, no need to localize

	// now let's change the position of one of the points in the point curve
	NURBSPointCurve* ptCrvObj = (NURBSPointCurve*)nset.GetNURBSObject(ptCrv);
	ptCrvObj->GetPoint(0)->SetPosition(0, Point3(10, 160, 0)); // moved from 0,150,0

	// now let's change the position and weight of one of the CVs
	// in the CV Surface
	NURBSCVSurface* cvSurfObj = (NURBSCVSurface*)nset.GetNURBSObject(cvSurf);
	cvSurfObj->GetCV(0, 0)->SetPosition(0, Point3(-150.0, -100.0, 20.0)); // moved from 0,0,0
	cvSurfObj->GetCV(0, 0)->SetWeight(0, 2.0); // from 1.0


	// now let's do a transform of a curve.
	NURBSIdTab xfmTab;
	NURBSId nid = nset.GetNURBSObject(jc1)->GetId();
	xfmTab.Append(1, &nid);
	Matrix3 xfmMat;
	xfmMat = TransMatrix(Point3(10, 10, -10));
	SetXFormPacket xPack(xfmMat);
	NURBSResult res = Transform(obj, xfmTab, xPack, xfmMat, 0);




	// Now let's Join two curves
	NURBSId jc1id = nset.GetNURBSObject(jc1)->GetId(),
			jc2id = nset.GetNURBSObject(jc2)->GetId();
	JoinCurves(obj, jc1id, jc2id, FALSE, TRUE, 20.0, 1.0f, 1.0f, 0);

	// Now let's Join two surfaces
	NURBSId js1id = nset.GetNURBSObject(js1)->GetId(),
			js2id = nset.GetNURBSObject(js2)->GetId();
	JoinSurfaces(obj, js1id, js2id, 1, 0, 20.0, 1.0f, 1.0f, 0);

	// Break a Curve
	NURBSId bcid = nset.GetNURBSObject(bc)->GetId();
	BreakCurve(obj, bcid, .5, 0);

	// Break a Surface
	NURBSId bsid = nset.GetNURBSObject(bs)->GetId();
	BreakSurface(obj, bsid, TRUE, .5, 0);

	mpIp->RedrawViews(mpIp->GetTime());
	nset.DeleteObjects();
	addNset.DeleteObjects();


	// now do a detach
	NURBSSet detset;
	Matrix3 detmat;
	detmat.IdentityMatrix();
	// build a cv curve
	int detcvCrv = MakeTestCVCurve(detset, detmat);

	// now a point curve
	int detptCrv = MakeTestPointCurve(detset, detmat);

	// Blend the two curves
	int detblendCrv = MakeTestBlendCurve(detset, detcvCrv, detptCrv);

	Object *detobj = CreateNURBSObject(mpIp, &detset, detmat);
	INode *detnode = mpIp->CreateObjectNode(detobj);
	detnode->SetName("Detach From");

	BOOL copy = TRUE;
	BOOL relational = TRUE;
	NURBSIdList detlist;
	NURBSId oid = detset.GetNURBSObject(detblendCrv)->GetId();
	detlist.Append(1, &oid);
	DetachObjects(GetCOREInterface()->GetTime(), detnode, detobj,
					detlist, "Detach Test", copy, relational);
	mpIp->RedrawViews(mpIp->GetTime());

}

DisplayState BendManip::MouseLeavesObject(TimeValue t, ViewExp* pVpt, IPoint2& m, ManipHitData* pHitData)
{
	mouseWithin = FALSE;
	GetCOREInterface()->NodeInvalidateRect(node);
	return kFullRedrawNeeded;
}

void DxStdMtl2::LoadTextureData(IHLSLCodeGenerator * codeGen)
{
	Bitmap * bmap;
	BitmapInfo stBI;

	TimeValue t = GetCOREInterface()->GetTime();
	int nWidth,nHeight;

	int numberOfTextures = elementContainer.NumberofElementsByType(EffectElements::kEleTex);
	for(int i=0; i<numberOfTextures;i++)
	{
		bool bBump;
		TextureElement * texEle = static_cast<TextureElement*>(elementContainer.GetElementByType(i,EffectElements::kEleTex));

		TSTR mapType = texEle->GetMapName();
		Texmap *texmap = codeGen->GetShaderDefinedTexmap(map,mapType.data(),bBump);

		if(texmap)
		{
			BMM_Color_64 *p;
			nWidth = nHeight = DIMDEFAULT;
			BitmapDimensions(nWidth,nHeight,texmap);
			// load and create the D3D texture;
/*			if(texmap->ClassID() == Class_ID(BMTEX_CLASS_ID, 0))
			{
				BitmapTex *pBT;
				Bitmap *pTex;
				pBT = (BitmapTex *)texmap;
				pTex = pBT->GetBitmap(t);
				if (pTex)
				{
					nWidth = getClosestPowerOf2(pTex->Width());
					nHeight = getClosestPowerOf2(pTex->Height());
				}

			}
*/				
			stBI.SetType(BMM_TRUE_32);
			stBI.SetWidth(nWidth);
			stBI.SetHeight(nHeight);        
			bmap = TheManager->Create(&stBI);

			if (bmap)
			{
//				LPDIRECT3DTEXTURE9 pRenderTex = texEle->GetD3DTexture();

				texmap->RenderBitmap(t, bmap, MAPSCALE3D * 2.0f);
				p = new BMM_Color_64[nWidth*nHeight];

				for (int y = 0; y < nHeight; y++)
					bmap->GetLinearPixels(0, y, nWidth, p + y * nWidth);
			
				if(texEle->pTex)
				{
					D3DSURFACE_DESC stLD;
					texEle->pTex->GetLevelDesc(0, &stLD);
					if (stLD.Width != nWidth || stLD.Height != nHeight)
					{
						SAFE_RELEASE(texEle->pTex);
					}

				}
				if(!texEle->pTex)
					pd3dDevice->CreateTexture(nWidth,nHeight, 0,D3DUSAGE_AUTOGENMIPMAP,	D3DFMT_A8R8G8B8,D3DPOOL_MANAGED,&texEle->pTex, NULL);

				if(texEle->pTex)
				{
					PIXELFMT *pT;
					D3DLOCKED_RECT stLR;
					texEle->pTex->LockRect(0, &stLR, 0, 0);
					pT = (PIXELFMT *)stLR.pBits;

					for (int i = 0; i < nWidth * nHeight; i++)
					{
						pT[i].r = p[i].r >> 8;
						pT[i].g = p[i].g >> 8;
						pT[i].b = p[i].b >> 8;
						pT[i].a = p[i].a >> 8;
					}
					texEle->pTex->UnlockRect(0);
				
					if(bBump && texmap->ClassID() != GNORMAL_CLASS_ID)
					{
//						LPDIRECT3DTEXTURE9 normalTex = texEle->GetD3DBumpTexture();
						
						if(texEle->pBumpTex)
						{
							D3DSURFACE_DESC stLD;
							texEle->pBumpTex->GetLevelDesc(0, &stLD);
							if (stLD.Width != nWidth || stLD.Height != nHeight)
							{
								SAFE_RELEASE(texEle->pBumpTex);
							}
						}
						if(!texEle->pBumpTex)
							pd3dDevice->CreateTexture(nWidth,nHeight, 0,D3DUSAGE_AUTOGENMIPMAP,	D3DFMT_A8R8G8B8,D3DPOOL_MANAGED,&texEle->pBumpTex, NULL);

						D3DXComputeNormalMap(texEle->pBumpTex,texEle->pTex,NULL, NULL, D3DX_CHANNEL_RED,30.0f);

						if(texEle->GetParamHandle())
//.........这里部分代码省略.........

void SideBarUI::Setup(HINSTANCE hInstance, HWND rollupHWND, const MCHAR *iniFile)
{
	//setup rollup
	mRollupHwnd = rollupHWND;

	GetCOREInterface()->RegisterDlgWnd ( mRollupHwnd );

	IRollupWindow *irollup = GetIRollup(rollupHWND);
	if(NULL == irollup)
	{
		return;
	}

	irollup->AppendRollup(hInstance,MAKEINTRESOURCE(IDD_SIDEBAR_ROLLUP1),SideBar1RollupDialogProc, GetString(IDS_QUICKTRANSFORM),(LPARAM)mMod );
	irollup->AppendRollup(hInstance,MAKEINTRESOURCE(IDD_SIDEBAR_ROLLUP2),SideBar1RollupDialogProc, GetString(IDS_RESHAPEELEMENTS),(LPARAM)mMod );
	irollup->AppendRollup(hInstance,MAKEINTRESOURCE(IDD_SIDEBAR_ROLLUP3),SideBar1RollupDialogProc, GetString(IDS_STITCH),(LPARAM)mMod );
	irollup->AppendRollup(hInstance,MAKEINTRESOURCE(IDD_SIDEBAR_ROLLUP4),SideBar1RollupDialogProc, GetString(IDS_EXPLODE),(LPARAM)mMod );
	irollup->AppendRollup(hInstance,MAKEINTRESOURCE(IDD_SIDEBAR_ROLLUP5),SideBar1RollupDialogProc, GetString(IDS_PEEL),(LPARAM)mMod );
	irollup->AppendRollup(hInstance,MAKEINTRESOURCE(IDD_SIDEBAR_ROLLUP6),SideBar1RollupDialogProc, GetString(IDS_ARRANGEELEMENTS),(LPARAM)mMod );
	irollup->AppendRollup(hInstance,MAKEINTRESOURCE(IDD_SIDEBAR_ROLLUP7),SideBar1RollupDialogProc, GetString(IDS_ELEMENTPROPERTIES),(LPARAM)mMod );


	for (int i = 0; i < 7; i++)
		irollup->Show(i);

	UnwrapCustomUI* pUIManager = mMod->GetUIManager();
	if(NULL == pUIManager)
	{
		return;
	}

	bool bResult = pUIManager->GetIniFileCache().InitCacheFromIniFile(TSTR(iniFile));

	//quick transform
	if (bResult && pUIManager->LoadSingleFromIniFile(iniFile,100,irollup->GetPanelDlg(0),GetDlgItem(irollup->GetPanelDlg(0),IDC_S1_1_TOOLBAR)) > 0)
		LoadInActions(100);
	else
		SetDefaults(100,irollup->GetPanelDlg(0));

	if (bResult && pUIManager->LoadSingleFromIniFile(iniFile,101,irollup->GetPanelDlg(0),GetDlgItem(irollup->GetPanelDlg(0),IDC_S1_2_TOOLBAR)) > 0)
		LoadInActions(101);
	else
		SetDefaults(101,irollup->GetPanelDlg(0));

	if (bResult && pUIManager->LoadSingleFromIniFile(iniFile,102,irollup->GetPanelDlg(0),GetDlgItem(irollup->GetPanelDlg(0),IDC_S1_3_TOOLBAR)) > 0)
		LoadInActions(102);
	else
		SetDefaults(102,irollup->GetPanelDlg(0));

	if (bResult && pUIManager->LoadSingleFromIniFile(iniFile,103,irollup->GetPanelDlg(0),GetDlgItem(irollup->GetPanelDlg(0),IDC_S1_4_TOOLBAR)) > 0)
		LoadInActions(103);
	else
		SetDefaults(103,irollup->GetPanelDlg(0));

	if (bResult && pUIManager->LoadSingleFromIniFile(iniFile,104,irollup->GetPanelDlg(0),GetDlgItem(irollup->GetPanelDlg(0),IDC_S1_5_TOOLBAR)) > 0)
		LoadInActions(104);
	else
		SetDefaults(104,irollup->GetPanelDlg(0));


	if (bResult && pUIManager->LoadSingleFromIniFile(iniFile,110,irollup->GetPanelDlg(1),GetDlgItem(irollup->GetPanelDlg(1),IDC_S2_1_TOOLBAR)) > 0)
		LoadInActions(110);
	else
		SetDefaults(110,irollup->GetPanelDlg(1));

	if (bResult && pUIManager->LoadSingleFromIniFile(iniFile,120,irollup->GetPanelDlg(2),GetDlgItem(irollup->GetPanelDlg(2),IDC_S3_1_TOOLBAR)) > 0)
		LoadInActions(120);
	else
		SetDefaults(120,irollup->GetPanelDlg(2));

	if (bResult && pUIManager->LoadSingleFromIniFile(iniFile,130,irollup->GetPanelDlg(3),GetDlgItem(irollup->GetPanelDlg(3),IDC_S4_1_TOOLBAR)) > 0)
		LoadInActions(130);
	else
		SetDefaults(130,irollup->GetPanelDlg(3));

	if (bResult && pUIManager->LoadSingleFromIniFile(iniFile,131,irollup->GetPanelDlg(3),GetDlgItem(irollup->GetPanelDlg(3),IDC_S4_2_TOOLBAR)) > 0)
		LoadInActions(131);
	else
		SetDefaults(131,irollup->GetPanelDlg(3));

	if (bResult && pUIManager->LoadSingleFromIniFile(iniFile,132,irollup->GetPanelDlg(3),GetDlgItem(irollup->GetPanelDlg(3),IDC_S4_3_TOOLBAR)) > 0)
		LoadInActions(132);
	else
		SetDefaults(132,irollup->GetPanelDlg(3));

	if (bResult && pUIManager->LoadSingleFromIniFile(iniFile,140,irollup->GetPanelDlg(4),GetDlgItem(irollup->GetPanelDlg(4),IDC_S5_1_TOOLBAR)) > 0)
		LoadInActions(140);
	else
		SetDefaults(140,irollup->GetPanelDlg(4));

	if (bResult && pUIManager->LoadSingleFromIniFile(iniFile,141,irollup->GetPanelDlg(4),GetDlgItem(irollup->GetPanelDlg(4),IDC_S5_2_TOOLBAR)) > 0)
		LoadInActions(141);
	else
		SetDefaults(141,irollup->GetPanelDlg(4));

	if (bResult && pUIManager->LoadSingleFromIniFile(iniFile,142,irollup->GetPanelDlg(4),GetDlgItem(irollup->GetPanelDlg(4),IDC_S5_0_TOOLBAR)) > 0)
		LoadInActions(142);
	else
		SetDefaults(142,irollup->GetPanelDlg(4));

//.........这里部分代码省略.........

      ULONG LocalRequirements(int subMtlNum) {  
#if 1
         ULONG flags  =  fogBG  ?  ( fogObjDepth ? 0 : MTLREQ_NOATMOS )  :  MTLREQ_NOATMOS;

         // > 10/9/02 - 2:38pm --MQM-- 
         // if the tone operator is active, we need to match it's
         // "process background" flag for our material requirements.  
         // otherwise we will have a matte-plane that gets tone-op'd 
         // hovering over a background plane that doesn't.
         ToneOperatorInterface* toneOpInterface = static_cast<ToneOperatorInterface*>( GetCOREInterface(TONE_OPERATOR_INTERFACE) );
         if ( toneOpInterface )
         {
            ToneOperator *pToneOp = toneOpInterface->GetToneOperator();
            if ( pToneOp )
            {
               if ( !pToneOp->GetProcessBackground() )
                  flags |= MTLREQ_NOEXPOSURE;   // <-- new MTLREQ flag to disable toneop
            }
         }
         
         return flags;
#else
         return fogBG  ?  ( fogObjDepth ? 0 : MTLREQ_NOATMOS )  :  MTLREQ_NOATMOS;
#endif
         }