Interval RelaxMod::LocalValidity(TimeValue t) {
// if being edited, return NEVER forces a cache to be built
// after previous modifier.
if (TestAFlag(A_MOD_BEING_EDITED)) return NEVER;
Interval valid = GetValidity(t);
return valid;
}
void SlaveControl::HoldRange()
{
if (theHold.Holding() && !TestAFlag(A_HELD)) {
SetAFlag(A_HELD);
theHold.Put(new SlaveRangeRestore(this));
}
}
// LAM - 4/21/03 - enumerate files for archiving
void CubeMap::EnumAuxFiles(NameEnumCallback& nameEnum, DWORD flags)
{
if ((flags&FILE_ENUM_CHECK_AWORK1)&&TestAFlag(A_WORK1)) return;
if (GetCubeMapFile())
{
TCHAR *cubeMapPath = FindMapFile(GetCubeMapFile());
if (cubeMapPath)
{
if (!(flags&FILE_ENUM_MISSING_ONLY))
nameEnum.RecordName(cubeMapPath);
}
else
{ if (flags&FILE_ENUM_MISSING_ONLY)
nameEnum.RecordName(GetCubeMapFile());
}
}
if (GetVertexShaderFile())
{
TCHAR *vertexShaderPath = FindMapFile(GetVertexShaderFile());
if (vertexShaderPath)
{
if (!(flags&FILE_ENUM_MISSING_ONLY))
nameEnum.RecordName(vertexShaderPath);
}
else
{ if (flags&FILE_ENUM_MISSING_ONLY)
nameEnum.RecordName(GetVertexShaderFile());
}
}
ReferenceTarget::EnumAuxFiles(nameEnum, flags);
}
IOResult TorusObject::Save(ISave *isave)
{
if (TestAFlag(A_PLUGIN1)) {
isave->BeginChunk(NEWMAP_CHUNKID);
isave->EndChunk();
}
return IO_OK;
}
// The validity of the parameters. First a test for editing is performed
// then Start at FOREVER, and intersect with the validity of each item
Interval ProjectionHolderUVW::LocalValidity(TimeValue t)
{
// if being edited, return NEVER forces a cache to be built
// after previous modifier.
if (TestAFlag(A_MOD_BEING_EDITED))
return NEVER;
return NEVER;
}
Interval ApplyVCMod::LocalValidity(TimeValue t)
{
// aszabo|feb.05.02 If we are being edited,
// return NEVER to forces a cache to be built after previous modifier.
if (TestAFlag(A_MOD_BEING_EDITED))
return NEVER;
return GetValidity(t);
}
/*===========================================================================*\
| The validity of the parameters. First a test for editing is performed
| then Start at FOREVER, and intersect with the validity of each item
\*===========================================================================*/
Interval LuxCam::LocalValidity(TimeValue /*t*/)
{
// if being edited, return NEVER forces a cache to be built
// after previous modifier.
if (TestAFlag(A_MOD_BEING_EDITED))
return NEVER;
#pragma message(TODO("Return the validity interval of the modifier"))
return NEVER;
}
void TriObject::RescaleWorldUnits(float f) {
if (TestAFlag(A_WORK1))
return;
SetAFlag(A_WORK1);
for (int i=0; i<mesh.numVerts; i++)
mesh.verts[i] *= f;
mesh.buildBoundingBox();
NotifyDependents(FOREVER,PART_ALL,REFMSG_CHANGE);
}
/*===========================================================================*\
| The validity of the parameters. First a test for editing is performed
| then Start at FOREVER, and intersect with the validity of each item
\*===========================================================================*/
Interval SolidifyPW::LocalValidity(TimeValue t)
{
// if being edited, return NEVER forces a cache to be built
// after previous modifier.
if (TestAFlag(A_MOD_BEING_EDITED))
return NEVER;
//TODO: Return the validity interval of the modifier
return NEVER;
}
void BombObject::RescaleWorldUnits(float f)
{
if (TestAFlag(A_WORK1))
return;
SetAFlag(A_WORK1);
WSMObject::RescaleWorldUnits(f);
pblock->RescaleParam(PB_STRENGTH,f*f);
pblock->RescaleParam(PB_GRAVITY,f);
}
Interval EChamferMod::LocalValidity(TimeValue t) {
// aszabo|feb.05.02 If we are being edited,
// return NEVER to forces a cache to be built after previous modifier.
if (TestAFlag(A_MOD_BEING_EDITED))
return NEVER;
Interval iv = FOREVER;
float v;
m_pblock->GetValue(kEchAmount,t,v,iv);
return iv;
}
void SimpleWSMObject::Snap(TimeValue t, INode* inode, SnapInfo *snap, IPoint2 *p, ViewExp *vpt)
{
if(TestAFlag(A_OBJ_CREATING)) // No snap to ourself while creating!
return;
Matrix3 tm = inode->GetObjectTM(t);
GraphicsWindow *gw = vpt->getGW();
UpdateMesh(t);
gw->setTransform(tm);
mesh.snap(gw, snap, p, tm);
}
Interval SmoothMod::LocalValidity(TimeValue t) {
// aszabo|feb.05.02 If we are being edited, return NEVER
// to forces a cache to be built after previous modifier.
if (TestAFlag(A_MOD_BEING_EDITED))
return NEVER;
float f;
Interval valid = FOREVER;
// Only one animatable parameter:
pblock->GetValue(sm_threshold,t,f,valid);
return valid;
}
void bhkSphereObject::BuildMesh(TimeValue t)
{
float radius; int segs; int smooth;
float startAng = 0.0f;
if (TestAFlag(A_PLUGIN1)) startAng = HALFPI;
// Start the validity interval at forever and whittle it down.
ivalid = FOREVER;
pblock2->GetValue(PB_RADIUS, t, radius, ivalid);
pblock2->GetValue(PB_SEGS, t, segs, ivalid);
pblock2->GetValue(PB_SMOOTH, t, smooth, ivalid);
BuildSphere(mesh, (radius * 7.0f), segs, smooth, startAng);
}
Interval FaceDataToColorMod::LocalValidity(TimeValue t)
{
// if being edited, return NEVER forces a cache to be built
// after previous modifier.
if (TestAFlag(A_MOD_BEING_EDITED)) return NEVER;
Interval ret(FOREVER);
float val;
mpParams->GetValue (pb_red, t, val, ret);
mpParams->GetValue (pb_green, t, val, ret);
mpParams->GetValue (pb_blue, t, val, ret);
return ret;
}
void Texmaps::RescaleWorldUnits(float f) {
if (TestAFlag(A_WORK1))
return;
SetAFlag(A_WORK1);
// This code will be replaced in particular implementations
for (int i=0; i<NumRefs(); i++) {
if ( (i&1) ==0)
continue; // skip the amount controllers
ReferenceMaker *srm = GetReference(i);
if (srm) {
srm->RescaleWorldUnits(f);
}
}
}
Interval FExtrudeMod::LocalValidity(TimeValue t) {
// aszabo|feb.05.02 If we are being edited,
// return NEVER to forces a cache to be built after previous modifier.
if (TestAFlag(A_MOD_BEING_EDITED))
return NEVER;
Interval iv = FOREVER;
float v;
Point3 pt;
int type;
mp_pblock->GetValue(kFexAmount,t,v,iv);
mp_pblock->GetValue(kFexScale,t,v,iv);
mp_pblock->GetValue (kFexType, t, type, iv);
if (type==2) mp_base->GetValue(t,&pt,iv,CTRL_ABSOLUTE);
return iv;
}
Interval FExtrudeMod::LocalValidity(TimeValue t)
{
// aszabo|feb.05.02 If we are being edited, return NEVER
// to forces a cache to be built after previous modifier.
if (TestAFlag(A_MOD_BEING_EDITED))
return NEVER;
Interval iv = FOREVER;
float v;
Point3 pt;
pblock->GetValue(PB_AMOUNT,t,v,iv);
pblock->GetValue(PB_SCALE,t,v,iv);
base->GetValue(t,&pt,iv,CTRL_ABSOLUTE);
return iv;
}
Interval AFRMod::LocalValidity(TimeValue t)
{
// aszabo|feb.05.02 If we are being edited, return NEVER
// to forces a cache to be built after previous modifier.
if (TestAFlag(A_MOD_BEING_EDITED))
return NEVER;
Interval iv = FOREVER;
float v;
Point3 pt;
pblock->GetValue(PB_FALLOFF,t,v,iv);
pblock->GetValue(PB_PINCH,t,v,iv);
pblock->GetValue(PB_BUBBLE,t,v,iv);
p1->GetValue(t,&pt,iv,CTRL_ABSOLUTE);
p2->GetValue(t,&pt,iv,CTRL_ABSOLUTE);
return iv;
}
Interval XModifier::LocalValidity(TimeValue t)
{
// if being edited, return NEVER forces a cache to be built
// after previous modifier.
if (TestAFlag(A_MOD_BEING_EDITED))
return NEVER;
else {
Interval ivalid = FOREVER;
float f;
BOOL suspDisp;
pblock->GetValue(pb_fn_spin,t,f, ivalid);
pblock->GetValue(pb_suspdisp,t,suspDisp, ivalid);
pblock->GetValue(pb_fn_onoff,t,bFN_OnOff, ivalid);
pblock->GetValue(pb_nf_onoff,t,bNF_OnOff, ivalid);
pblock->GetValue(pb_fa_onoff,t,bFA_OnOff, ivalid);
return ivalid;
}
}
Interval SymmetryMod::LocalValidity(TimeValue t) {
// aszabo|feb.05.02 If we are being edited,
// return NEVER to forces a cache to be built after previous modifier.
if (TestAFlag(A_MOD_BEING_EDITED))
return NEVER;
Interval iv = FOREVER;
int foo;
mp_pblock->GetValue(kSymAxis, t, foo, iv);
mp_pblock->GetValue (kSymFlip, t, foo, iv);
mp_pblock->GetValue(kSymWeld, t, foo, iv);
mp_pblock->GetValue(kSymSlice, t, foo, iv);
float thresh;
mp_pblock->GetValue (kSymThreshold, t, thresh, iv);
Matrix3 mat(1);
mp_mirror->GetValue(t,&mat,iv,CTRL_RELATIVE);
return iv;
}
void SimpleWSMObject::Snap(TimeValue t, INode* inode, SnapInfo *snap, IPoint2 *p, ViewExp *vpt)
{
if ( ! vpt || ! vpt->IsAlive() )
{
// why are we here
DbgAssert(!_T("Invalid viewport!"));
return;
}
if(TestAFlag(A_OBJ_CREATING)) // No snap to ourself while creating!
return;
Matrix3 tm = inode->GetObjectTM(t);
GraphicsWindow *gw = vpt->getGW();
UpdateMesh(t);
gw->setTransform(tm);
mesh.snap(gw, snap, p, tm);
}
Interval BombMod::LocalValidity(TimeValue t)
{
BombObject *obj = GetWSMObject(t);
if (obj && nodeRef && !waitPostLoad && (obj->ClassID() == Class_ID(BOMB_OBJECT_CLASS_ID,0))) {
// Force a cache of input if being edited.
if (TestAFlag(A_MOD_BEING_EDITED))
return NEVER;
Interval valid = FOREVER;
Matrix3 tm;
obj->GetStrength(t,valid);
obj->GetGravity(t,valid);
obj->GetDetonation(t,valid);
tm = nodeRef->GetObjectTM(t,&valid);
return valid;
} else {
return FOREVER;
}
}
// 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 AlembicVisibilityController::EnumAuxFiles(AssetEnumCallback &nameEnum,
DWORD flags)
{
if ((flags & FILE_ENUM_CHECK_AWORK1) && TestAFlag(A_WORK1)) {
return; // LAM - 4/11/03
}
if (!(flags & FILE_ENUM_INACTIVE)) {
return; // not needed by renderer
}
if (flags & FILE_ENUM_ACCESSOR_INTERFACE) {
IEnumAuxAssetsCallback *callback =
static_cast<IEnumAuxAssetsCallback *>(&nameEnum);
callback->DeclareAsset(AlembicPathAccessor(this));
}
// else {
// IPathConfigMgr::GetPathConfigMgr()->RecordInputAsset(
// this->GetParamBlockByID( 0 )->GetAssetUser( GetParamIdByName( this, 0,
//"path" ), 0 ), nameEnum, flags);
//}
ReferenceTarget::EnumAuxFiles(nameEnum, flags);
}
void MorphByBone::EndEditParams( IObjParam *ip, ULONG flags,Animatable *next)
{
editMorph = FALSE;
MorphByBoneDesc.EndEditParams(ip, this, flags, next);
TimeValue t = ip->GetTime();
ClearAFlag(A_MOD_BEING_EDITED);
NotifyDependents(Interval(t,t), PART_ALL, REFMSG_END_EDIT);
NotifyDependents(Interval(t,t), PART_ALL, REFMSG_MOD_DISPLAY_OFF);
ip->ClearPickMode();
ip->DeleteMode(moveMode);
if (moveMode) delete moveMode;
moveMode = NULL;
ip->DeleteMode(rotMode);
if (rotMode) delete rotMode;
rotMode = NULL;
ip->DeleteMode(uscaleMode);
ip->DeleteMode(nuscaleMode);
ip->DeleteMode(squashMode);
ip->DeleteMode(selectMode);
if (uscaleMode) delete uscaleMode;
uscaleMode = NULL;
if (nuscaleMode) delete nuscaleMode;
nuscaleMode = NULL;
if (squashMode) delete squashMode;
squashMode = NULL;
if (selectMode) delete selectMode;
selectMode = NULL;
ReleaseICustButton(iEditButton);
iEditButton = NULL;
ReleaseICustButton(iNodeButton);
iNodeButton = NULL;
ReleaseICustButton(iPickBoneButton);
iPickBoneButton = NULL;
ReleaseICustButton(iMultiSelectButton);
iMultiSelectButton = NULL;
ReleaseICustButton(iDeleteMorphButton);
iDeleteMorphButton = NULL;
ReleaseICustButton(iResetMorphButton);
iResetMorphButton = NULL;
ReleaseICustButton(iClearVertsButton);
iClearVertsButton = NULL;
ReleaseICustButton(iRemoveVertsButton);
iRemoveVertsButton = NULL;
ReleaseICustButton(iGraphButton);
iGraphButton = NULL;
ReleaseICustEdit(iNameField);
iNameField = NULL;
ReleaseISpinner(iInfluenceAngleSpinner);
iInfluenceAngleSpinner = NULL;
this->ip = NULL;
//Defect 727409 If the user turn off the skin morph modifier, we need to get the
//localDataList for using the copy/paste mirror option.
if(!TestAFlag(A_MOD_DISABLED))
{
for (int i = 0; i < localDataList.Count(); i++)
{
if (localDataList[i])
localDataList[i]->FreeConnectionList();
}
localDataList.ZeroCount();
}
}
void OptMod::ModifyObject(TimeValue t, ModContext &mc, ObjectState *os, INode *node)
{
float faceThresh, edgeThresh, bias, maxEdge;
int preserveMat, preserveSmooth, which, render=0, autoEdge;
DWORD flags = 0;
Interval valid = FOREVER;
int nv,nf;
int man;
pblock->GetValue(PB_MANUPDATE,t,man,valid);
if (man && !forceUpdate && !TestAFlag(A_RENDER)) return;
forceUpdate = FALSE;
if (TestAFlag(A_RENDER)) {
pblock->GetValue(PB_RENDER,t,which,valid);
} else {
pblock->GetValue(PB_VIEWS,t,which,valid);
}
pblock->GetValue(PB_AUTOEDGE,t,autoEdge,valid);
if (which==0) {
pblock->GetValue(PB_FACETHRESH1,t,faceThresh,valid);
pblock->GetValue(PB_EDGETHRESH1,t,edgeThresh,valid);
pblock->GetValue(PB_BIAS1,t,bias,valid);
pblock->GetValue(PB_PRESERVEMAT1,t,preserveMat,valid);
pblock->GetValue(PB_PRESERVESMOOTH1,t,preserveSmooth,valid);
pblock->GetValue(PB_MAXEDGE1,t,maxEdge,valid);
} else {
pblock->GetValue(PB_FACETHRESH2,t,faceThresh,valid);
pblock->GetValue(PB_EDGETHRESH2,t,edgeThresh,valid);
pblock->GetValue(PB_BIAS2,t,bias,valid);
pblock->GetValue(PB_PRESERVEMAT2,t,preserveMat,valid);
pblock->GetValue(PB_PRESERVESMOOTH2,t,preserveSmooth,valid);
pblock->GetValue(PB_MAXEDGE2,t,maxEdge,valid);
}
assert(os->obj->IsSubClassOf(triObjectClassID));
TriObject *triOb = (TriObject *)os->obj;
nv = triOb->GetMesh().getNumVerts();
nf = triOb->GetMesh().getNumFaces();
if (preserveMat) flags |= OPTIMIZE_SAVEMATBOUNDRIES;
if (preserveSmooth) flags |= OPTIMIZE_SAVESMOOTHBOUNDRIES;
if (autoEdge) flags |= OPTIMIZE_AUTOEDGE;
if (faceThresh!=0.0f) {
GetAsyncKeyState(VK_ESCAPE); // clear the state
HCURSOR hCur;
if (nf > 2000) hCur = SetCursor(LoadCursor(NULL,IDC_WAIT));
triOb->GetMesh().Optimize(
faceThresh,edgeThresh, bias*0.5f, maxEdge, flags,this);
if (nf > 200) SetCursor(hCur);
}
triOb->GetMesh().InvalidateTopologyCache ();
triOb->PointsWereChanged();
triOb->UpdateValidity(GEOM_CHAN_NUM,valid);
triOb->UpdateValidity(TOPO_CHAN_NUM,valid);
triOb->UpdateValidity (TEXMAP_CHAN_NUM, valid);
triOb->UpdateValidity (VERT_COLOR_CHAN_NUM, valid);
if (pmapParam && pmapParam->GetParamBlock()==pblock && !TestAFlag(A_RENDER)) {
TSTR buf;
buf.printf("%d / %d",nv,triOb->GetMesh().getNumVerts());
SetWindowText(GetDlgItem(pmapParam->GetHWnd(),IDC_OPT_VERTCOUNT),buf);
buf.printf("%d / %d",nf,triOb->GetMesh().getNumFaces());
SetWindowText(GetDlgItem(pmapParam->GetHWnd(),IDC_OPT_FACECOUNT),buf);
}
}
void ParticleMesherObject::BuildMesh(TimeValue t)
{
//check if render time
//get node
//mkae ivalid interesect with the
int isRendering = 0;
ivalid = FOREVER;
TimeValue offset;
float foffset;
Interval iv;
pblock2->GetValue(particlemesher_time, 0, foffset, iv);
foffset = -foffset;
pblock2->GetValue(particlemesher_radius, 0, radius, iv);
foffset *= GetTicksPerFrame();
offset = (TimeValue) foffset;
// pblock2->GetValue(particlemesher_time, 0, foffset, iv);
if ((lastTime == t) )
{
ivalid.Set(t,t);
return;
}
pblock2->GetValue(particlemesher_rendertimeonly, 0, isRendering, ivalid);
isRendering = !isRendering;
if ((isRendering) || (TestAFlag(A_RENDER)))
{
INode *node=NULL;
pblock2->GetValue(particlemesher_pick, 0, node, ivalid);
BOOL reevalGroup = FALSE;
if ((node != NULL) && (node->IsGroupHead()) )
{
for (int ch=0;ch<node->NumberOfChildren();ch++)
{
INode *cnode= node->GetChildNode(ch);
Interval iv;
Matrix3 tm=cnode->GetObjectTM(t,&iv);
if (cnode->IsGroupMember())
{
reevalGroup = TRUE;
for (int groupCount = 0; groupCount < pblock2->Count(particlemesher_extranodes); groupCount++)
{
INode *extraNode = pblock2->GetINode(particlemesher_extranodes,t,ch);
if (cnode == extraNode)
{
reevalGroup = FALSE;
groupCount = pblock2->Count(particlemesher_extranodes);
}
}
if (reevalGroup)
ch=node->NumberOfChildren();
}
}
if (reevalGroup)
{
tmList.ZeroCount();
pblock2->ZeroCount(particlemesher_extranodes);
for (int ch=0;ch<node->NumberOfChildren();ch++)
{
INode *cnode= node->GetChildNode(ch);
Interval iv;
Matrix3 tm=cnode->GetObjectTM(t,&iv);
if (cnode->IsGroupMember())
{
pblock2->Append(particlemesher_extranodes,1,&cnode);
tmList.Append(1,&tm);
}
}
}
}
if (node)
{
if ( (node->IsGroupHead()) && (pblock2->Count(particlemesher_extranodes)!=0))
{
int ct = 0;
Matrix3 ident(1), inverseTm(1);
mesh.setNumVerts(0);
mesh.setNumFaces(0);
for (int ch=0;ch<pblock2->Count(particlemesher_extranodes);ch++)
{
INode *cnode = pblock2->GetINode(particlemesher_extranodes,t,ch);
if (cnode)
{
Object *pobj = cnode->EvalWorldState(t+offset).obj;
if ( (pobj->SuperClassID() == GEOMOBJECT_CLASS_ID) ||
(pobj->SuperClassID() == SHAPE_CLASS_ID) )
{
BOOL needDel;
NullView nullView;
Mesh *msh = ((GeomObject*)pobj)->GetRenderMesh(t+offset,cnode,nullView,needDel);
Mesh tmsh = *msh;
ivalid &= pobj->ObjectValidity(t+offset);
Matrix3 tm(1);
if (ch < tmList.Count())
tm = tmList[ch];
for (int v = 0; v < msh->numVerts; v++)
{
tmsh.verts[v] = tmsh.verts[v] * tm;
}
if (tmsh.numVerts != 0)
{
if (ct ==0)
{
mesh = tmsh;
}
else
mesh = mesh + tmsh;
ct++;
}
if (needDel) delete msh;
}
}
}
mesh.InvalidateTopologyCache();
}
else
{
// Object *tobj = node->GetObjectRef();
// macroRecorder->FunctionCall(_T("time"), 1, 0, mr_int, t);
// macroRecorder->EmitScript();
ObjectState os = node->EvalWorldState(t+offset);
IParticleObjectExt* epobj;
epobj = (IParticleObjectExt*) os.obj->GetInterface(PARTICLEOBJECTEXT_INTERFACE);
if (os.obj->IsParticleSystem() && epobj)
{
if (epobj)
{
BOOL useAllPFEvents;
pblock2->GetValue(particlemesher_useallpf,0,useAllPFEvents,FOREVER);
pfNodes.ZeroCount();
INode *basenode=NULL;
pblock2->GetValue(particlemesher_pick, 0, basenode, ivalid);
tmList.ZeroCount();
if (useAllPFEvents)
{
MyEnumProc dep;
os.obj->DoEnumDependents(&dep);
for (int i = 0; i < dep.Nodes.Count(); i++)
{
Interval valid;
INode *node = dep.Nodes[i];
Object *obj = node->GetObjectRef();
if (ParticleGroupInterface(obj) != nullptr)
{
pfNodes.Append(1,&node);
Matrix3 tm = node->GetNodeTM(t+offset);
tmList.Append(1,&tm);
}
}
}
else
{
int ct = pblock2->Count(particlemesher_pfeventlist);
for (int i = 0; i < ct; i++)
{
INode *node;
pblock2->GetValue(particlemesher_pfeventlist,t,node,FOREVER,i);
if (node)
{
Object *obj = node->GetObjectRef();
if (ParticleGroupInterface(obj) != nullptr)
{
pfNodes.Append(1,&node);
Matrix3 tm(1);// = basenode->GetNodeTM(t+offset);
Matrix3 ntm = node->GetObjectTM(t+offset);
tm = ntm;
tmList.Append(1,&ntm);
}
}
}
}
mesh.setNumVerts(0);
mesh.setNumFaces(0);
int ct = 0;
for (int ch=0;ch< pfNodes.Count();ch++)
{
INode *cnode = pfNodes[ch];
if (cnode)
{
Object *pobj = cnode->EvalWorldState(t+offset).obj;
if ( (pobj->SuperClassID() == GEOMOBJECT_CLASS_ID) ||
(pobj->SuperClassID() == SHAPE_CLASS_ID) )
{
BOOL needDel;
NullView nullView;
Mesh *msh = ((GeomObject*)pobj)->GetRenderMesh(t+offset,cnode,nullView,needDel);
Mesh tmsh = *msh;
ivalid &= pobj->ObjectValidity(t+offset);
Matrix3 tm(1);
if (ch < tmList.Count())
tm = tmList[ch];
for (int v = 0; v < msh->numVerts; v++)
{
tmsh.verts[v] = tmsh.verts[v] * tm;
}
if (tmsh.numVerts != 0)
{
if (ct ==0)
{
mesh = tmsh;
}
else
{
Mesh tempMesh = mesh;
CombineMeshes(mesh, tempMesh, tmsh);
}
ct++;
}
if (needDel) delete msh;
}
}
}
mesh.InvalidateTopologyCache();
}
}
else if ( (os.obj->SuperClassID() == GEOMOBJECT_CLASS_ID) ||
(os.obj->SuperClassID() == SHAPE_CLASS_ID) )
{
BOOL needDel;
NullView nullView;
Mesh *msh = ((GeomObject*)os.obj)->GetRenderMesh(t+offset,node,nullView,needDel);
ivalid &= os.obj->ObjectValidity(t);
if (msh)
{
mesh = *msh;
mesh.InvalidateTopologyCache();
if (needDel) delete msh;
}
}
}
lastTime = t;
}
else
{
//build proxy mesh
if (node == NULL)
{
mesh.setNumVerts(5);
mesh.setNumFaces(8);
mesh.setNumMaps(2);
mesh.setNumMapVerts(0, 0);
mesh.setNumMapVerts(1, 0);
mesh.setNumMapFaces(0, 0);
mesh.setNumMapFaces(1, 0);
mesh.setVert(0, Point3(-radius,-radius, 0.0f));
mesh.setVert(1, Point3( radius,-radius, 0.0f));
mesh.setVert(2, Point3( radius, radius, 0.0f));
mesh.setVert(3, Point3(-radius, radius, 0.0f));
// mesh.setVert(4, Point3(0.0f, 0.0f, 0.0f));
mesh.setVert(4, Point3(0.0f, 0.0f, radius));
mesh.faces[0].setEdgeVisFlags(1,0,1);
mesh.faces[0].setSmGroup(1);
mesh.faces[0].setVerts(0,1,3);
mesh.faces[1].setEdgeVisFlags(1,1,0);
mesh.faces[1].setSmGroup(1);
mesh.faces[1].setVerts(1,2,3);
mesh.faces[2].setEdgeVisFlags(1,1,1);
mesh.faces[2].setSmGroup(1);
mesh.faces[2].setVerts(0,4,1);
mesh.faces[3].setEdgeVisFlags(1,1,1);
mesh.faces[3].setSmGroup(1);
mesh.faces[3].setVerts(1,4,0);
mesh.faces[4].setEdgeVisFlags(1,1,1);
mesh.faces[4].setSmGroup(1);
mesh.faces[4].setVerts(2,4,3);
mesh.faces[5].setEdgeVisFlags(1,1,1);
mesh.faces[5].setSmGroup(1);
mesh.faces[5].setVerts(3,4,2);
mesh.faces[6].setEdgeVisFlags(1,0,1);
mesh.faces[6].setSmGroup(1);
mesh.faces[6].setVerts(3,1,0);
mesh.faces[7].setEdgeVisFlags(1,1,0);
mesh.faces[7].setSmGroup(1);
mesh.faces[7].setVerts(3,2,1);
}
}
}
else
{
//build proxy mesh
//build proxy mesh
INode *node=NULL;
pblock2->GetValue(particlemesher_pick, 0, node, ivalid);
// if (node == NULL)
{
mesh.setNumVerts(5);
mesh.setNumFaces(8);
mesh.setNumMaps(2);
mesh.setNumMapVerts(0, 0);
mesh.setNumMapVerts(1, 0);
mesh.setNumMapFaces(0, 0);
mesh.setNumMapFaces(1, 0);
mesh.setVert(0, Point3(-radius,-radius, 0.0f));
mesh.setVert(1, Point3( radius,-radius, 0.0f));
mesh.setVert(2, Point3( radius, radius, 0.0f));
mesh.setVert(3, Point3(-radius, radius, 0.0f));
// mesh.setVert(4, Point3(0.0f, 0.0f, 0.0f));
mesh.setVert(4, Point3(0.0f, 0.0f, radius));
mesh.faces[0].setEdgeVisFlags(1,0,1);
mesh.faces[0].setSmGroup(1);
mesh.faces[0].setVerts(0,1,3);
mesh.faces[1].setEdgeVisFlags(1,1,0);
mesh.faces[1].setSmGroup(1);
mesh.faces[1].setVerts(1,2,3);
mesh.faces[2].setEdgeVisFlags(1,1,1);
mesh.faces[2].setSmGroup(1);
mesh.faces[2].setVerts(0,4,1);
mesh.faces[3].setEdgeVisFlags(1,1,1);
mesh.faces[3].setSmGroup(1);
mesh.faces[3].setVerts(1,4,0);
mesh.faces[4].setEdgeVisFlags(1,1,1);
mesh.faces[4].setSmGroup(1);
mesh.faces[4].setVerts(2,4,3);
mesh.faces[5].setEdgeVisFlags(1,1,1);
mesh.faces[5].setSmGroup(1);
mesh.faces[5].setVerts(3,4,2);
mesh.faces[6].setEdgeVisFlags(1,0,1);
mesh.faces[6].setSmGroup(1);
mesh.faces[6].setVerts(3,1,0);
mesh.faces[7].setEdgeVisFlags(1,1,0);
mesh.faces[7].setSmGroup(1);
mesh.faces[7].setVerts(3,2,1);
}
}
mesh.InvalidateTopologyCache();
}
void TorusObject::BuildMesh(TimeValue t)
{
Point3 p;
int ix,na,nb,nc,nd,jx,kx;
int nf=0,nv=0;
float delta,ang;
float delta2,ang2;
int sides,segs,smooth;
float radius,radius2, rotation;
float sinang,cosang, sinang2,cosang2,rt;
float twist, pie1, pie2, totalPie, startAng = 0.0f;
int doPie = TRUE;
int genUVs = TRUE;
// Start the validity interval at forever and widdle it down.
ivalid = FOREVER;
pblock->GetValue(PB_RADIUS,t,radius,ivalid);
pblock->GetValue(PB_RADIUS2,t,radius2,ivalid);
pblock->GetValue(PB_ROTATION,t,rotation,ivalid);
pblock->GetValue(PB_TWIST,t,twist,ivalid);
pblock->GetValue(PB_SEGMENTS,t,segs,ivalid);
pblock->GetValue(PB_SIDES,t,sides,ivalid);
pblock->GetValue(PB_SMOOTH,t,smooth,ivalid);
pblock->GetValue(PB_PIESLICE1,t,pie1,ivalid);
pblock->GetValue(PB_PIESLICE2,t,pie2,ivalid);
pblock->GetValue(PB_SLICEON,t,doPie,ivalid);
pblock->GetValue(PB_GENUVS,t,genUVs,ivalid);
LimitValue( radius, MIN_RADIUS, MAX_RADIUS );
LimitValue( radius2, MIN_RADIUS, MAX_RADIUS );
LimitValue( segs, MIN_SEGMENTS, MAX_SEGMENTS );
LimitValue( sides, MIN_SIDES, MAX_SIDES );
// Convert doPie to a 0 or 1 value since it is used in arithmetic below
// Controllers can give it non- 0 or 1 values
doPie = doPie ? 1 : 0;
// We do the torus backwards from the cylinder
pie1 = -pie1;
pie2 = -pie2;
// Make pie2 < pie1 and pie1-pie2 < TWOPI
while (pie1 < pie2) pie1 += TWOPI;
while (pie1 > pie2+TWOPI) pie1 -= TWOPI;
if (pie1==pie2) totalPie = TWOPI;
else totalPie = pie1-pie2;
if (doPie) {
segs++; //*** O.Z. fix for bug 240436
delta = totalPie/(float)(segs-1);
startAng = pie2;
} else {
delta = (float)2.0*PI/(float)segs;
}
delta2 = (float)2.0*PI/(float)sides;
if (TestAFlag(A_PLUGIN1)) startAng -= HALFPI;
int nverts;
int nfaces;
if (doPie) {
nverts = sides*segs + 2;
nfaces = 2*sides*segs;
} else {
nverts = sides*segs;
nfaces = 2*sides*segs;
}
mesh.setNumVerts(nverts);
mesh.setNumFaces(nfaces);
mesh.setSmoothFlags(smooth);
if (genUVs) {
if (doPie) {
mesh.setNumTVerts((sides+1)*segs+2);
mesh.setNumTVFaces(2*sides*segs);
} else {
mesh.setNumTVerts((sides+1)*(segs+1));
mesh.setNumTVFaces(2*sides*segs);
}
} else {
mesh.setNumTVerts(0);
mesh.setNumTVFaces(0);
}
ang = startAng;
// make verts
for(ix=0; ix<segs; ix++) {
sinang = (float)sin(ang);
cosang = (float)cos(ang);
ang2 = rotation + twist * float(ix+1)/float(segs);
for (jx = 0; jx<sides; jx++) {
sinang2 = (float)sin(ang2);
cosang2 = (float)cos(ang2);
rt = radius+radius2*cosang2;
p.x = rt*cosang;
p.y = -rt*sinang;
p.z = radius2*sinang2;
mesh.setVert(nv++, p);
ang2 += delta2;
}
ang += delta;
}
if (doPie) {
p.x = radius * (float)cos(startAng);
p.y = -radius * (float)sin(startAng);
p.z = 0.0f;
mesh.setVert(nv++, p);
ang -= delta;
p.x = radius * (float)cos(ang);
p.y = -radius * (float)sin(ang);
p.z = 0.0f;
mesh.setVert(nv++, p);
}
// Make faces
BOOL usePhysUVs = GetUsePhysicalScaleUVs();
BitArray startSliceFaces;
BitArray endSliceFaces;
if (usePhysUVs) {
startSliceFaces.SetSize(mesh.numFaces);
endSliceFaces.SetSize(mesh.numFaces);
}
/* Make midsection */
for(ix=0; ix<segs-doPie; ++ix) {
jx=ix*sides;
for (kx=0; kx<sides; ++kx) {
na = jx+kx;
nb = (ix==(segs-1))?kx:na+sides;
nd = (kx==(sides-1))? jx : na+1;
nc = nb+nd-na;
DWORD grp = 0;
if (smooth==SMOOTH_SIDES) {
if (kx==sides-1 && (sides&1)) {
grp = (1<<2);
} else {
grp = (kx&1) ? (1<<0) : (1<<1);
}
} else
if (smooth==SMOOTH_STRIPES) {
if (ix==segs-1 && (segs&1)) {
grp = (1<<2);
} else {
grp = (ix&1) ? (1<<0) : (1<<1);
}
} else
if (smooth > 0) {
grp = 1;
}
mesh.faces[nf].setEdgeVisFlags(0,1,1);
mesh.faces[nf].setSmGroup(grp);
mesh.faces[nf].setMatID(0);
mesh.faces[nf++].setVerts( na,nc,nb);
mesh.faces[nf].setEdgeVisFlags(1,1,0);
mesh.faces[nf].setSmGroup(grp);
mesh.faces[nf].setMatID(0);
mesh.faces[nf++].setVerts(na,nd,nc);
}
}
if (doPie) {
na = nv -2;
for(ix=0; ix<sides; ++ix) {
nb = ix;
nc = (ix==(sides-1))?0:ix+1;
mesh.faces[nf].setEdgeVisFlags(0,1,0);
mesh.faces[nf].setSmGroup((1<<3));
mesh.faces[nf].setMatID(1);
if (usePhysUVs)
startSliceFaces.Set(nf);
mesh.faces[nf++].setVerts(na,nc,nb);
}
na = nv -1;
jx = sides*(segs-1);
for(ix=0; ix<sides; ++ix) {
nb = jx+ix;
nc = (ix==(sides-1))?jx:nb+1;
mesh.faces[nf].setEdgeVisFlags(0,1,0);
mesh.faces[nf].setSmGroup((1<<3));
mesh.faces[nf].setMatID(2);
if (usePhysUVs)
endSliceFaces.Set(nf);
mesh.faces[nf++].setVerts(na,nb,nc);
}
}
// UVWs -------------------
if (genUVs) {
float uScale = usePhysUVs ? ((float) 2.0f * PI * radius) : 1.0f;
float vScale = usePhysUVs ? ((float) 2.0f * PI * radius2) : 1.0f;
if (doPie) {
float pieScale = float(totalPie/(2.0*PI));
uScale *= float(pieScale);
}
nv=0;
for(ix=0; ix<=segs-doPie; ix++) {
for (jx=0; jx<=sides; jx++) {
if (usePhysUVs)
mesh.setTVert(nv++,uScale*(1.0f - float(ix)/float(segs-doPie)),vScale*float(jx)/float(sides),0.0f);
else
mesh.setTVert(nv++,float(jx)/float(sides),float(ix)/float(segs),0.0f);
}
}
int pie1 = 0;
int pie2 = 0;
if (doPie) {
pie1 = nv;
if (usePhysUVs)
mesh.setTVert(nv++,0.0f,vScale*0.5f,0.0f);
else
mesh.setTVert(nv++,0.5f,1.0f,0.0f);
pie2 = nv;
if (usePhysUVs)
mesh.setTVert(nv++,uScale*0.5f,vScale*0.0f,0.0f);
else
mesh.setTVert(nv++,1.0f,0.5f,0.0f);
}
nf=0;
for(ix=0; ix<segs-doPie; ix++) {
na = ix*(sides+1);
nb = (ix+1)*(sides+1);
for (jx=0; jx<sides; jx++) {
mesh.tvFace[nf++].setTVerts(na,nb+1,nb);
mesh.tvFace[nf++].setTVerts(na,na+1,nb+1);
na++;
nb++;
}
}
if (doPie) {
if (usePhysUVs) {
Matrix3 tm = RotateZMatrix(startAng) * RotateXMatrix(float(-PI/2.0));
tm.Scale(Point3(-1.0f, 1.0f, 1.0f));
MakeMeshCapTexture(mesh, tm, startSliceFaces, usePhysUVs);
tm = RotateZMatrix(ang) * RotateXMatrix(float(-PI/2.0));
MakeMeshCapTexture(mesh, tm, endSliceFaces, usePhysUVs);
} else {
for (jx=0; jx<sides; jx++) {
mesh.tvFace[nf++].setTVerts(pie1,jx+1,jx);
}
nb = (sides+1)*(segs-1);
for (jx=0; jx<sides; jx++) {
mesh.tvFace[nf++].setTVerts(pie2,nb,nb+1);
nb++;
}
}
}
}
mesh.InvalidateTopologyCache();
}
