857 lines
21 KiB
C++
857 lines
21 KiB
C++
|
|
/**********************************************************************
|
|
*<
|
|
FILE: editpat.cpp
|
|
|
|
DESCRIPTION: Edit Patch OSM
|
|
|
|
CREATED BY: Tom Hudson, Dan Silva & Rolf Berteig
|
|
|
|
HISTORY: created 23 June, 1995
|
|
|
|
IMPORTANT USAGE NOTE:
|
|
|
|
When you do an operation in edit patch which will change the topology, the form
|
|
of the code should look like this code, taken from the vertex deletion:
|
|
|
|
-----
|
|
|
|
ip->GetModContexts(mcList, nodes);
|
|
ClearPatchDataFlag(mcList, EPD_BEENDONE);
|
|
|
|
theHold.Begin();
|
|
--> RecordTopologyTags();
|
|
for (int i = 0; i < mcList.Count(); i++)
|
|
{
|
|
int altered = 0;
|
|
EditPatchData *patchData =(EditPatchData*)mcList[i]->localData;
|
|
if (!patchData)
|
|
continue;
|
|
if (patchData->GetFlag(EPD_BEENDONE))
|
|
continue;
|
|
|
|
// If the mesh isn't yet cache, this will cause it to get cached.
|
|
PatchMesh *patch = patchData->TempData(this)->GetPatch(t);
|
|
if (!patch)
|
|
continue;
|
|
--> patchData->RecordTopologyTags(patch);
|
|
|
|
// If this is the first edit, then the delta arrays will be allocated
|
|
patchData->BeginEdit(t);
|
|
|
|
// If any bits are set in the selection set, let's DO IT!!
|
|
if (patch->vertSel.NumberSet())
|
|
{
|
|
altered = holdNeeded = 1;
|
|
if (theHold.Holding())
|
|
theHold.Put(new PatchRestore(patchData, this, patch, "DoVertDelete"));
|
|
// Call the vertex delete function
|
|
DeleteSelVerts(patch);
|
|
--> patchData->UpdateChanges(patch);
|
|
patchData->TempData(this)->Invalidate(PART_TOPO);
|
|
}
|
|
patchData->SetFlag(EPD_BEENDONE, TRUE);
|
|
}
|
|
|
|
if (holdNeeded)
|
|
{
|
|
--> ResolveTopoChanges();
|
|
theHold.Accept(GetString(IDS_TH_VERTDELETE));
|
|
}
|
|
else
|
|
{
|
|
ip->DisplayTempPrompt(GetString(IDS_TH_NOVERTSSEL), PROMPT_TIME);
|
|
theHold.End();
|
|
}
|
|
|
|
nodes.DisposeTemporary();
|
|
ClearPatchDataFlag(mcList, EPD_BEENDONE);
|
|
|
|
-----
|
|
|
|
The key elements in the "changed topology" case are the calls noted by arrows.
|
|
These record special tags inside the object so that after the topology is changed
|
|
by the modifier code, the UpdateChanges code can make a new mapping from the old
|
|
object topology to the new.
|
|
|
|
If the operation doesn't change the topology, then the three topology tag calls
|
|
aren't needed and the UpdateChanges call becomes:
|
|
|
|
patchData->UpdateChanges(patch, FALSE);
|
|
|
|
This tells UpdateChanges not to bother remapping the topology.
|
|
|
|
*> Copyright(c) 1994, All Rights Reserved.
|
|
**********************************************************************/
|
|
#include "stdafx.h"
|
|
#include "editpat.h"
|
|
#include "../nel_patch_lib/vertex_neighborhood.h"
|
|
|
|
#define DBGWELD_DUMPx
|
|
#define DBGWELD_ACTIONx
|
|
|
|
#define DBG_NAMEDSELSx
|
|
|
|
// Uncomment this for vert mapper debugging
|
|
//#define VMAP_DEBUG 1
|
|
|
|
// Forward references
|
|
BOOL CALLBACK PatchSelectDlgProc(HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam);
|
|
BOOL CALLBACK PatchOpsDlgProc(HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam);
|
|
BOOL CALLBACK PatchObjSurfDlgProc(HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam);
|
|
BOOL CALLBACK PatchSurfDlgProc(HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam);
|
|
BOOL CALLBACK PatchTileDlgProc(HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam);
|
|
BOOL CALLBACK PatchEdgeDlgProc(HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam);
|
|
|
|
void ResetVert (PatchMesh *patch);
|
|
|
|
// A handy zero point
|
|
Point3 zeroPoint(0, 0, 0);
|
|
|
|
// Our temporary prompts last 2 seconds:
|
|
#define PROMPT_TIME 2000
|
|
|
|
// in mods.cpp
|
|
extern HINSTANCE hInstance;
|
|
|
|
// Select by material parameters
|
|
int sbmParams[4] = {1, 1, RPO_DEFAULT_TESSEL, RPO_DEFAULT_TESSEL};
|
|
|
|
// Select by smooth parameters
|
|
DWORD sbsParams[3] = {1, 1, 0};
|
|
|
|
float weldThreshold = 0.1f;
|
|
|
|
// Checkbox items for rollup pages
|
|
|
|
int attachReorient = 0;
|
|
// This is a special override value which allows us to hit-test on
|
|
// any sub-part of a patch
|
|
|
|
extern int patchHitOverride; // If zero, no override is done
|
|
|
|
void SetPatchHitOverride(int value)
|
|
{
|
|
patchHitOverride = value;
|
|
}
|
|
|
|
void ClearPatchHitOverride()
|
|
{
|
|
patchHitOverride = 0;
|
|
}
|
|
|
|
|
|
|
|
|
|
PatchDeleteUser pDel;
|
|
extern PatchRightMenu pMenu;
|
|
|
|
/*-------------------------------------------------------------------*/
|
|
|
|
static EditPatchClassDesc editPatchDesc;
|
|
extern ClassDesc* GetEditPatchModDesc() { return &editPatchDesc; }
|
|
|
|
void EditPatchClassDesc::ResetClassParams(BOOL fileReset)
|
|
{
|
|
sbmParams[0] = 1;
|
|
sbmParams[1] = 1;
|
|
sbmParams[2] = RPO_DEFAULT_TESSEL;
|
|
sbmParams[3] = RPO_DEFAULT_TESSEL;
|
|
EditPatchMod::condenseMat = FALSE;
|
|
EditPatchMod::attachMat = ATTACHMAT_IDTOMAT;
|
|
}
|
|
|
|
/*-------------------------------------------------------------------*/
|
|
|
|
int EditPatchMod::Display(TimeValue t, INode* inode, ViewExp *vpt, int flags, ModContext *mc)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
void EditPatchMod::GetWorldBoundBox(TimeValue t, INode* inode, ViewExp *vpt, Box3& box, ModContext *mc)
|
|
{
|
|
box.Init();
|
|
}
|
|
|
|
//---------------------------------------------------------------------
|
|
// UI stuff
|
|
|
|
void EditPatchMod::RecordTopologyTags()
|
|
{
|
|
ModContextList mcList;
|
|
INodeTab nodes;
|
|
TimeValue t = ip->GetTime();
|
|
ip->GetModContexts(mcList, nodes);
|
|
ClearPatchDataFlag(mcList, EPD_BEENDONE);
|
|
|
|
for (int i = 0; i < mcList.Count(); i++)
|
|
{
|
|
EditPatchData *patchData =(EditPatchData*)mcList[i]->localData;
|
|
if (!patchData)
|
|
continue;
|
|
if (patchData->GetFlag(EPD_BEENDONE))
|
|
continue;
|
|
|
|
// If the mesh isn't yet cache, this will cause it to get cached.
|
|
RPatchMesh *rpatch;
|
|
PatchMesh *patch = patchData->TempData(this)->GetPatch(t, rpatch);
|
|
if (!patch)
|
|
continue;
|
|
patch->RecordTopologyTags();
|
|
patchData->SetFlag(EPD_BEENDONE, TRUE);
|
|
}
|
|
|
|
nodes.DisposeTemporary();
|
|
ClearPatchDataFlag(mcList, EPD_BEENDONE);
|
|
}
|
|
|
|
class ChangeNamedSetRestore : public RestoreObj
|
|
{
|
|
public:
|
|
BitArray oldset, newset;
|
|
int index;
|
|
GenericNamedSelSetList *setList;
|
|
|
|
ChangeNamedSetRestore(GenericNamedSelSetList *sl, int ix, BitArray *o)
|
|
{
|
|
setList = sl;
|
|
index = ix;
|
|
oldset = *o;
|
|
}
|
|
void Restore(int isUndo)
|
|
{
|
|
newset = *(setList->sets[index]);
|
|
*(setList->sets[index]) = oldset;
|
|
}
|
|
void Redo()
|
|
{
|
|
*(setList->sets[index]) = newset;
|
|
}
|
|
|
|
TSTR Description() {return TSTR(_T("Change Named Sel Set"));}
|
|
};
|
|
|
|
// Selection set, misc fixup utility function
|
|
// This depends on PatchMesh::RecordTopologyTags being called prior to the topo changes
|
|
void EditPatchMod::ResolveTopoChanges()
|
|
{
|
|
ModContextList mcList;
|
|
INodeTab nodes;
|
|
TimeValue t = ip->GetTime();
|
|
ip->GetModContexts(mcList, nodes);
|
|
ClearPatchDataFlag(mcList, EPD_BEENDONE);
|
|
|
|
for (int i = 0; i < mcList.Count(); i++)
|
|
{
|
|
EditPatchData *patchData =(EditPatchData*)mcList[i]->localData;
|
|
if (!patchData)
|
|
continue;
|
|
if (patchData->GetFlag(EPD_BEENDONE))
|
|
continue;
|
|
|
|
// If the mesh isn't yet cache, this will cause it to get cached.
|
|
RPatchMesh *rpatch;
|
|
PatchMesh *patch = patchData->TempData(this)->GetPatch(t, rpatch);
|
|
if (!patch)
|
|
continue;
|
|
// First, the vertex selections
|
|
int set;
|
|
for (set = 0; set < patchData->vselSet.Count(); ++set)
|
|
{
|
|
BitArray *oldVS = &patchData->vselSet[set];
|
|
BitArray newVS;
|
|
newVS.SetSize(patch->numVerts);
|
|
for (int vert = 0; vert < patch->numVerts; ++vert)
|
|
{
|
|
// Get the knot's previous location, then copy that selection into the new set
|
|
int tag = patch->verts[vert].aux1;
|
|
if (tag >= 0)
|
|
newVS.Set(vert, (*oldVS)[tag]);
|
|
else
|
|
newVS.Clear(vert);
|
|
}
|
|
if (theHold.Holding())
|
|
theHold.Put(new ChangeNamedSetRestore(&patchData->vselSet, set, oldVS));
|
|
patchData->vselSet[set] = newVS;
|
|
}
|
|
// Now the edge selections
|
|
for (set = 0; set < patchData->eselSet.Count(); ++set)
|
|
{
|
|
BitArray *oldES = &patchData->eselSet[set];
|
|
BitArray newES;
|
|
newES.SetSize(patch->numEdges);
|
|
for (int edge = 0; edge < patch->numEdges; ++edge)
|
|
{
|
|
// Get the knot's previous location, then copy that selection into the new set
|
|
int tag = patch->edges[edge].aux1;
|
|
if (tag >= 0)
|
|
newES.Set(edge, (*oldES)[tag]);
|
|
else
|
|
newES.Clear(edge);
|
|
}
|
|
if (theHold.Holding())
|
|
theHold.Put(new ChangeNamedSetRestore(&patchData->eselSet, set, oldES));
|
|
patchData->eselSet[set] = newES;
|
|
}
|
|
// Now the patch selections
|
|
for (set = 0; set < patchData->pselSet.Count(); ++set)
|
|
{
|
|
BitArray *oldPS = &patchData->pselSet[set];
|
|
BitArray newPS;
|
|
newPS.SetSize(patch->numPatches);
|
|
for (int p = 0; p < patch->numPatches; ++p)
|
|
{
|
|
// Get the knot's previous location, then copy that selection into the new set
|
|
int tag = patch->patches[p].aux1;
|
|
if (tag >= 0)
|
|
newPS.Set(p, (*oldPS)[tag]);
|
|
else
|
|
newPS.Clear(p);
|
|
}
|
|
if (theHold.Holding())
|
|
theHold.Put(new ChangeNamedSetRestore(&patchData->pselSet, set, oldPS));
|
|
patchData->pselSet[set] = newPS;
|
|
}
|
|
|
|
// watje 4-16-99
|
|
patch->HookFixTopology();
|
|
|
|
patchData->SetFlag(EPD_BEENDONE, TRUE);
|
|
}
|
|
|
|
nodes.DisposeTemporary();
|
|
ClearPatchDataFlag(mcList, EPD_BEENDONE);
|
|
}
|
|
|
|
class EPModContextEnumProc : public ModContextEnumProc
|
|
{
|
|
float f;
|
|
public:
|
|
EPModContextEnumProc(float f) { this->f = f; }
|
|
BOOL proc(ModContext *mc); // Return FALSE to stop, TRUE to continue.
|
|
};
|
|
|
|
BOOL EPModContextEnumProc::proc(ModContext *mc)
|
|
{
|
|
EditPatchData *patchData =(EditPatchData*)mc->localData;
|
|
if (patchData)
|
|
patchData->RescaleWorldUnits(f);
|
|
return TRUE;
|
|
}
|
|
|
|
// World scaling
|
|
void EditPatchMod::RescaleWorldUnits(float f)
|
|
{
|
|
if (TestAFlag(A_WORK1))
|
|
return;
|
|
SetAFlag(A_WORK1);
|
|
|
|
// rescale all our references
|
|
for (int i = 0; i < NumRefs(); i++)
|
|
{
|
|
ReferenceMaker *srm = GetReference(i);
|
|
if (srm)
|
|
srm->RescaleWorldUnits(f);
|
|
}
|
|
|
|
// Now rescale stuff inside our data structures
|
|
EPModContextEnumProc proc(f);
|
|
EnumModContexts(&proc);
|
|
NotifyDependents(FOREVER, PART_GEOM, REFMSG_CHANGE);
|
|
}
|
|
|
|
void EditPatchMod::InvalidateSurfaceUI()
|
|
{
|
|
if (hSurfPanel && selLevel == EP_PATCH)
|
|
{
|
|
InvalidateRect(hSurfPanel, NULL, FALSE);
|
|
patchUIValid = FALSE;
|
|
}
|
|
}
|
|
|
|
void EditPatchMod::InvalidateTileUI()
|
|
{
|
|
if (hTilePanel && selLevel == EP_TILE)
|
|
{
|
|
InvalidateRect(hTilePanel, NULL, FALSE);
|
|
tileUIValid = FALSE;
|
|
}
|
|
}
|
|
|
|
void EditPatchMod::InvalidateEdgeUI()
|
|
{
|
|
if (hEdgePanel && selLevel == EP_EDGE)
|
|
{
|
|
InvalidateRect(hEdgePanel, NULL, FALSE);
|
|
edgeUIValid = FALSE;
|
|
}
|
|
}
|
|
|
|
BitArray *EditPatchMod::GetLevelSelectionSet(PatchMesh *patch, RPatchMesh *rpatch)
|
|
{
|
|
switch (selLevel)
|
|
{
|
|
case EP_VERTEX:
|
|
return &patch->vertSel;
|
|
|
|
case EP_PATCH:
|
|
return &patch->patchSel;
|
|
|
|
case EP_EDGE:
|
|
return &patch->edgeSel;
|
|
|
|
case EP_TILE:
|
|
return &rpatch->tileSel;
|
|
}
|
|
nlassert(0);
|
|
return NULL;
|
|
}
|
|
|
|
void EditPatchMod::UpdateSelectDisplay()
|
|
{
|
|
TSTR buf;
|
|
int num, j;
|
|
|
|
if (!hSelectPanel)
|
|
return;
|
|
|
|
ModContextList mcList;
|
|
INodeTab nodes;
|
|
if (!ip)
|
|
return;
|
|
ip->GetModContexts(mcList, nodes);
|
|
|
|
switch (GetSubobjectLevel())
|
|
{
|
|
case EP_OBJECT:
|
|
buf.printf(GetString(IDS_TH_OBJECT_SEL));
|
|
break;
|
|
|
|
case EP_VERTEX:
|
|
{
|
|
num = 0;
|
|
PatchMesh *thePatch = NULL;
|
|
for (int i = 0; i < mcList.Count(); i++)
|
|
{
|
|
EditPatchData *patchData =(EditPatchData*)mcList[i]->localData;
|
|
if (!patchData)
|
|
continue;
|
|
|
|
if (patchData->tempData && patchData->TempData(this)->PatchCached(ip->GetTime()))
|
|
{
|
|
RPatchMesh *rpatch;
|
|
PatchMesh *patch = patchData->TempData(this)->GetPatch(ip->GetTime(), rpatch);
|
|
if (!patch)
|
|
continue;
|
|
int thisNum = patch->vertSel.NumberSet();
|
|
if (thisNum)
|
|
{
|
|
num += thisNum;
|
|
thePatch = patch;
|
|
}
|
|
}
|
|
}
|
|
if (num == 1)
|
|
{
|
|
for (j = 0; j < thePatch->vertSel.GetSize(); j++)
|
|
if (thePatch->vertSel[j])
|
|
break;
|
|
buf.printf(GetString(IDS_TH_NUMVERTSEL), j + 1);
|
|
}
|
|
else
|
|
buf.printf(GetString(IDS_TH_NUMVERTSELP), num);
|
|
}
|
|
break;
|
|
|
|
case EP_PATCH:
|
|
{
|
|
num = 0;
|
|
PatchMesh *thePatch = NULL;
|
|
for (int i = 0; i < mcList.Count(); i++)
|
|
{
|
|
EditPatchData *patchData =(EditPatchData*)mcList[i]->localData;
|
|
if (!patchData)
|
|
continue;
|
|
|
|
if (patchData->tempData && patchData->TempData(this)->PatchCached(ip->GetTime()))
|
|
{
|
|
RPatchMesh *rpatch;
|
|
PatchMesh *patch = patchData->TempData(this)->GetPatch(ip->GetTime(), rpatch);
|
|
if (!patch)
|
|
continue;
|
|
int thisNum = patch->patchSel.NumberSet();
|
|
if (thisNum)
|
|
{
|
|
num += thisNum;
|
|
thePatch = patch;
|
|
}
|
|
}
|
|
}
|
|
if (num == 1)
|
|
{
|
|
for (j = 0; j < thePatch->patchSel.GetSize(); j++)
|
|
if (thePatch->patchSel[j])
|
|
break;
|
|
buf.printf(GetString(IDS_TH_NUMPATCHSEL), j + 1);
|
|
}
|
|
else
|
|
buf.printf(GetString(IDS_TH_NUMPATCHSELP), num);
|
|
}
|
|
break;
|
|
|
|
case EP_EDGE:
|
|
{
|
|
num = 0;
|
|
PatchMesh *thePatch = NULL;
|
|
for (int i = 0; i < mcList.Count(); i++)
|
|
{
|
|
EditPatchData *patchData =(EditPatchData*)mcList[i]->localData;
|
|
if (!patchData)
|
|
continue;
|
|
|
|
if (patchData->tempData && patchData->TempData(this)->PatchCached(ip->GetTime()))
|
|
{
|
|
RPatchMesh *rpatch;
|
|
PatchMesh *patch = patchData->TempData(this)->GetPatch(ip->GetTime(), rpatch);
|
|
if (!patch)
|
|
continue;
|
|
int thisNum = patch->edgeSel.NumberSet();
|
|
if (thisNum)
|
|
{
|
|
num += thisNum;
|
|
thePatch = patch;
|
|
}
|
|
}
|
|
}
|
|
if (num == 1)
|
|
{
|
|
for (j = 0; j < thePatch->edgeSel.GetSize(); j++)
|
|
if (thePatch->edgeSel[j])
|
|
break;
|
|
buf.printf(GetString(IDS_TH_NUMEDGESEL), j + 1);
|
|
}
|
|
else
|
|
buf.printf(GetString(IDS_TH_NUMEDGESELP), num);
|
|
}
|
|
break;
|
|
|
|
case EP_TILE:
|
|
{
|
|
num = 0;
|
|
RPatchMesh *thePatch = NULL;
|
|
for (int i = 0; i < mcList.Count(); i++)
|
|
{
|
|
EditPatchData *patchData =(EditPatchData*)mcList[i]->localData;
|
|
if (!patchData)
|
|
continue;
|
|
|
|
if (patchData->tempData && patchData->TempData(this)->PatchCached(ip->GetTime()))
|
|
{
|
|
RPatchMesh *rpatch;
|
|
PatchMesh *patch = patchData->TempData(this)->GetPatch(ip->GetTime(), rpatch);
|
|
if (!patch)
|
|
continue;
|
|
int thisNum = rpatch->tileSel.NumberSet();
|
|
if (thisNum)
|
|
{
|
|
num += thisNum;
|
|
thePatch = rpatch;
|
|
}
|
|
}
|
|
}
|
|
if (num == 1)
|
|
{
|
|
for (j = 0; j < thePatch->tileSel.GetSize(); j++)
|
|
if (thePatch->tileSel[j])
|
|
break;
|
|
buf.printf("Tile %d Selected", j + 1);
|
|
}
|
|
else
|
|
buf.printf("%d Tiles Selected", num);
|
|
}
|
|
break;
|
|
}
|
|
|
|
nodes.DisposeTemporary();
|
|
SetDlgItemText(hSelectPanel, IDC_NUMSEL_LABEL, buf);
|
|
}
|
|
|
|
void EditPatchMod::DoVertWeld()
|
|
{
|
|
ModContextList mcList;
|
|
INodeTab nodes;
|
|
TimeValue t = ip->GetTime();
|
|
int holdNeeded = 0;
|
|
BOOL hadSel = FALSE;
|
|
|
|
if (!ip)
|
|
return;
|
|
|
|
ip->GetModContexts(mcList, nodes);
|
|
ClearPatchDataFlag(mcList, EPD_BEENDONE);
|
|
|
|
theHold.Begin();
|
|
RecordTopologyTags();
|
|
for (int i = 0; i < mcList.Count(); i++)
|
|
{
|
|
BOOL altered = FALSE;
|
|
EditPatchData *patchData =(EditPatchData*)mcList[i]->localData;
|
|
if (!patchData)
|
|
continue;
|
|
if (patchData->GetFlag(EPD_BEENDONE))
|
|
continue;
|
|
|
|
|
|
// If the mesh isn't yet cache, this will cause it to get cached.
|
|
RPatchMesh *rpatch;
|
|
PatchMesh *patch = patchData->TempData(this)->GetPatch(t, rpatch);
|
|
if (!patch)
|
|
continue;
|
|
patchData->RecordTopologyTags(patch);
|
|
|
|
// If this is the first edit, then the delta arrays will be allocated
|
|
patchData->BeginEdit(t);
|
|
|
|
// If any bits are set in the selection set, let's DO IT!!
|
|
if (patch->vertSel.NumberSet() > 1)
|
|
{
|
|
hadSel = TRUE;
|
|
if (theHold.Holding())
|
|
theHold.Put(new PatchRestore(patchData, this, patch, rpatch, "DoVertWeld"));
|
|
// Call the patch weld function
|
|
if (patch->Weld(weldThreshold))
|
|
{
|
|
rpatch->Weld (patch);
|
|
altered = holdNeeded = TRUE;
|
|
patchData->UpdateChanges(patch, rpatch);
|
|
patchData->TempData(this)->Invalidate(PART_TOPO);
|
|
}
|
|
}
|
|
patchData->SetFlag(EPD_BEENDONE, TRUE);
|
|
}
|
|
|
|
if (holdNeeded)
|
|
{
|
|
ResolveTopoChanges();
|
|
theHold.Accept(GetString(IDS_TH_VERTWELD));
|
|
}
|
|
else
|
|
{
|
|
if (!hadSel)
|
|
ip->DisplayTempPrompt(GetString(IDS_TH_NOVERTSSEL), PROMPT_TIME);
|
|
else
|
|
ip->DisplayTempPrompt(GetString(IDS_TH_NOWELDPERFORMED), PROMPT_TIME);
|
|
theHold.End();
|
|
}
|
|
|
|
nodes.DisposeTemporary();
|
|
ClearPatchDataFlag(mcList, EPD_BEENDONE);
|
|
NotifyDependents(FOREVER, PART_TOPO, REFMSG_CHANGE);
|
|
ip->RedrawViews(ip->GetTime(), REDRAW_NORMAL);
|
|
}
|
|
|
|
void EditPatchMod::DoVertReset ()
|
|
{
|
|
ModContextList mcList;
|
|
INodeTab nodes;
|
|
TimeValue t = ip->GetTime();
|
|
int holdNeeded = 0;
|
|
BOOL hadSel = FALSE;
|
|
|
|
if (!ip)
|
|
return;
|
|
|
|
ip->GetModContexts(mcList, nodes);
|
|
ClearPatchDataFlag(mcList, EPD_BEENDONE);
|
|
|
|
theHold.Begin();
|
|
RecordTopologyTags();
|
|
for (int i = 0; i < mcList.Count(); i++)
|
|
{
|
|
BOOL altered = FALSE;
|
|
EditPatchData *patchData =(EditPatchData*)mcList[i]->localData;
|
|
if (!patchData)
|
|
continue;
|
|
if (patchData->GetFlag(EPD_BEENDONE))
|
|
continue;
|
|
|
|
|
|
// If the mesh isn't yet cache, this will cause it to get cached.
|
|
RPatchMesh *rpatch;
|
|
PatchMesh *patch = patchData->TempData(this)->GetPatch(t, rpatch);
|
|
if (!patch)
|
|
continue;
|
|
patchData->RecordTopologyTags(patch);
|
|
|
|
// If this is the first edit, then the delta arrays will be allocated
|
|
patchData->BeginEdit(t);
|
|
|
|
// If any bits are set in the selection set, let's DO IT!!
|
|
if (patch->vertSel.NumberSet() > 0)
|
|
{
|
|
hadSel = TRUE;
|
|
if (theHold.Holding())
|
|
theHold.Put(new PatchRestore(patchData, this, patch, rpatch, "DoVertReset"));
|
|
// Call the patch weld function
|
|
ResetVert (patch);
|
|
patchData->UpdateChanges(patch, rpatch);
|
|
patchData->TempData(this)->Invalidate(PART_GEOM);
|
|
/*if (patch->Weld(weldThreshold))
|
|
{
|
|
rpatch->Weld (patch);
|
|
altered = holdNeeded = TRUE;
|
|
patchData->UpdateChanges(patch, rpatch);
|
|
patchData->TempData(this)->Invalidate(PART_TOPO);
|
|
}*/
|
|
}
|
|
patchData->SetFlag(EPD_BEENDONE, TRUE);
|
|
}
|
|
|
|
ResolveTopoChanges();
|
|
theHold.Accept("Reset Vertex");
|
|
/*if (holdNeeded)
|
|
{
|
|
ResolveTopoChanges();
|
|
theHold.Accept(GetString(IDS_TH_VERTWELD));
|
|
}
|
|
else
|
|
{
|
|
if (!hadSel)
|
|
ip->DisplayTempPrompt(GetString(IDS_TH_NOVERTSSEL), PROMPT_TIME);
|
|
else
|
|
ip->DisplayTempPrompt(GetString(IDS_TH_NOWELDPERFORMED), PROMPT_TIME);
|
|
theHold.End();
|
|
}*/
|
|
|
|
nodes.DisposeTemporary();
|
|
ClearPatchDataFlag(mcList, EPD_BEENDONE);
|
|
NotifyDependents(FOREVER, PART_GEOM, REFMSG_CHANGE);
|
|
ip->RedrawViews(ip->GetTime(), REDRAW_NORMAL);
|
|
}
|
|
|
|
void EditPatchMod::PatchSelChanged()
|
|
{
|
|
SelectionChanged();
|
|
if (hSurfPanel && selLevel == EP_PATCH)
|
|
InvalidateSurfaceUI();
|
|
if (hTilePanel && selLevel == EP_TILE)
|
|
InvalidateTileUI();
|
|
if (hEdgePanel && selLevel == EP_EDGE)
|
|
InvalidateEdgeUI();
|
|
}
|
|
|
|
/*
|
|
class AdvParams
|
|
{
|
|
public:
|
|
TessSubdivStyle mStyle;
|
|
int mMin, mMax;
|
|
int mTris;
|
|
};
|
|
*/
|
|
|
|
|
|
|
|
|
|
|
|
void EditPatchMod::LocalDataChanged()
|
|
{
|
|
}
|
|
|
|
int GetPointIndex (int nVertex, int nPatch, PatchMesh* patch)
|
|
{
|
|
for (int n=0; n<4; n++)
|
|
{
|
|
if (patch->patches[nPatch].v[n]==nVertex)
|
|
return n;
|
|
}
|
|
nlassert (0);
|
|
return 0;
|
|
}
|
|
|
|
Point3 GetInterior (int nPatch, int nInt, PatchMesh* patch)
|
|
{
|
|
return patch->vecs[patch->patches[nPatch].interior[nInt]].p;
|
|
}
|
|
|
|
void ResetVert (PatchMesh *patch)
|
|
{
|
|
// Make a edge table
|
|
// Static table to avoid alloc prb
|
|
CVertexNeighborhood& edgeTab=vertexNeighborhoodGlobal;
|
|
edgeTab.build (*patch);
|
|
|
|
// For each vertices
|
|
for (int nV=0; nV<patch->numVerts; nV++)
|
|
{
|
|
// Selected ?
|
|
if (patch->vertSel[nV])
|
|
{
|
|
Point3 vert=patch->verts[nV].p;
|
|
Point3 normal (0,0,0);
|
|
|
|
// Count of neigbor for vertex n
|
|
uint listSize=edgeTab.getNeighborCount (nV);
|
|
|
|
// List of neigbor
|
|
const uint* pList=edgeTab.getNeighborList (nV);
|
|
|
|
// For each neigbor
|
|
uint nn;
|
|
for (nn=0; nn<listSize; nn++)
|
|
{
|
|
#if (MAX_RELEASE < 4000)
|
|
// Compute average plane
|
|
if (patch->edges[pList[nn]].patch1!=-1)
|
|
normal+=patch->PatchNormal(patch->edges[pList[nn]].patch1);
|
|
if (patch->edges[pList[nn]].patch2!=-1)
|
|
normal+=patch->PatchNormal(patch->edges[pList[nn]].patch2);
|
|
#else // (MAX_RELEASE <= 4000)
|
|
// Compute average plane
|
|
if (patch->edges[pList[nn]].patches[0]!=-1)
|
|
normal+=patch->PatchNormal(patch->edges[pList[nn]].patches[0]);
|
|
if (patch->edges[pList[nn]].patches[1]!=-1)
|
|
normal+=patch->PatchNormal(patch->edges[pList[nn]].patches[1]);
|
|
#endif // (MAX_RELEASE <= 4000)
|
|
}
|
|
|
|
// Normalize
|
|
normal=normal.Normalize();
|
|
|
|
// Plane
|
|
float fD=-DotProd(normal, vert);
|
|
|
|
// Reset normales
|
|
float fNorme=0.f;
|
|
|
|
// For each neigbor
|
|
for (nn=0; nn<listSize; nn++)
|
|
{
|
|
Point3 vect2=patch->verts[(patch->edges[pList[nn]].v1==nV)?patch->edges[pList[nn]].v2:patch->edges[pList[nn]].v1].p;
|
|
vect2-=vert;
|
|
vect2/=3.f;
|
|
Point3 tmp1=CrossProd (vect2, normal);
|
|
tmp1=CrossProd (normal, tmp1);
|
|
tmp1=Normalize(tmp1);
|
|
int nTang=(patch->edges[pList[nn]].v1==nV)?patch->edges[pList[nn]].vec12:patch->edges[pList[nn]].vec21;
|
|
patch->vecs[nTang].p=vert+tmp1*DotProd (tmp1,vect2);
|
|
tmp1=patch->vecs[nTang].p;
|
|
tmp1-=vert;
|
|
fNorme+=tmp1.Length();
|
|
}
|
|
|
|
// Renorme new normal
|
|
/*fNorme/=(float)edgeTab[nV].size();
|
|
ite=edgeTab[nV].begin();
|
|
while (ite!=edgeTab[nV].end())
|
|
{
|
|
int nTang=(patch->edges[pList[nn]].v1==nV)?patch->edges[pList[nn]].vec12:patch->edges[pList[nn]].vec21;
|
|
patch->vecs[nTang].p=fNorme*(Normalize(patch->vecs[nTang].p-vert))+vert;
|
|
|
|
ite++;
|
|
}*/
|
|
}
|
|
}
|
|
patch->computeInteriors();
|
|
patch->InvalidateGeomCache ();
|
|
}
|