bool NifImporter::ImportSkin(ImpNode *node, NiTriBasedGeomRef triGeom, int v_start/*=0*/)
{
bool ok = true;
NiSkinInstanceRef nifSkin = triGeom->GetSkinInstance();
if (!nifSkin)
return false;
INode *tnode = node->GetINode();
NiSkinDataRef data = nifSkin->GetSkinData();
NiSkinPartitionRef part = nifSkin->GetSkinPartition();
vector<NiNodeRef> nifBones = nifSkin->GetBones();
//create a skin modifier and add it
Modifier *skinMod = GetOrCreateSkin(tnode);
TriObject *triObject = GetTriObject(tnode->GetObjectRef());
Mesh& m = triObject->GetMesh();
//get the skin interface
if (ISkin *skin = (ISkin *) skinMod->GetInterface(I_SKIN)){
ISkinImportData* iskinImport = (ISkinImportData*) skinMod->GetInterface(I_SKINIMPORTDATA);
// Set the num weights to 4. Yes its in the nif but Shon doesn't like to expose those values
// and the value always seems to be 4 anyway. I'd also this be more dynamic than hard coded numbers
// but I cant figure out the correct values to pass the scripting engine from here so I'm giving up.
int numWeightsPerVertex = 4;
#if VERSION_3DSMAX >= ((5000<<16)+(15<<8)+0) // Version 5+
IParamBlock2 *params = skinMod->GetParamBlockByID(2/*advanced*/);
params->SetValue(0x7/*bone_Limit*/, 0, numWeightsPerVertex);
#endif
// Can get some truly bizarre animations without this in MAX with Civ4 Leaderheads
#if VERSION_3DSMAX > ((5000<<16)+(15<<8)+0) // Version 6+
BOOL ignore = TRUE;
params->SetValue(0xE/*ignoreBoneScale*/, 0, ignore);
#endif
//RefTargetHandle advanced = skinMod->GetReference(3);
//setMAXScriptValue(advanced, "bone_Limit", 0, numWeightsPerVertex);
Matrix3 geom = TOMATRIX3(triGeom->GetLocalTransform());
Matrix3 m3 = TOMATRIX3(data->GetOverallTransform());
Matrix3 im3 = Inverse(m3);
Matrix3 nm3 = im3 * geom;
iskinImport->SetSkinTm(tnode, nm3, nm3); // ???
// Create Bone List
Tab<INode*> bones;
for (size_t i=0; i<nifBones.size(); ++i){
NiNodeRef bone = nifBones[i];
if (INode *boneRef = FindNode(bone)) {
bones.Append(1, &boneRef);
iskinImport->AddBoneEx(boneRef, TRUE);
//// Set Bone Transform
Matrix3 b3 = TOMATRIX3(data->GetBoneTransform(i));
Matrix3 ib3 = Inverse(b3);
ib3 *= geom;
iskinImport->SetBoneTm(boneRef, ib3, ib3);
}
}
if (bones.Count() != data->GetBoneCount())
return false;
ObjectState os = tnode->EvalWorldState(0);
// Need to get a list of bones and weights for each vertex.
vector<VertexHolder> vertexHolders;
vertexHolders.resize(m.numVerts);
for (int i=0, n=data->GetBoneCount();i<n; ++i){
if (INode *boneRef = bones[i]){
vector<SkinWeight> weights = data->GetBoneWeights(i);
for (vector<SkinWeight>::iterator itr=weights.begin(), end=weights.end(); itr != end; ++itr){
VertexHolder& h = vertexHolders[itr->index];
h.vertIndex = itr->index;
++h.count;
h.weights.Append(1, &itr->weight);
h.boneNodeList.Append(1, &boneRef);
}
}
}
tnode->EvalWorldState(0);
skinMod->DisableModInViews();
skinMod->EnableModInViews();
#if VERSION_3DSMAX < ((5000<<16)+(15<<8)+0) // Version 4
gi->SetCommandPanelTaskMode(TASK_MODE_MODIFY);
gi->SelectNode(tnode);
#endif
// Assign the weights
for (vector<VertexHolder>::iterator itr=vertexHolders.begin(), end=vertexHolders.end(); itr != end; ++itr){
VertexHolder& h = (*itr);
if (h.count){
float sum = 0.0f;
for (int i = 0; i < h.count; ++i)
sum += h.weights[i];
ASSERT(fabs(sum-1.0f) < 0.001f);
BOOL add = iskinImport->AddWeights(tnode, h.vertIndex, h.boneNodeList, h.weights);
add = add; // What was the purpose of this?
}
}
// This is a kludge to get skin transforms to update and avoid jumping around after modifying the transforms.
// Initially they show up incorrectly but magically fix up if you go to the modifier roll up.
// There is still an outstanding issue with skeleton and GetObjectTMBeforeWSM.
skinMod->DisableModInViews();
skinMod->EnableModInViews();
// If BSDismembermentSkinInstance, ...
if ( BSDismemberSkinInstanceRef bsdsi = DynamicCast<BSDismemberSkinInstance>(nifSkin) )
{
Modifier *dismemberSkinMod = GetOrCreateBSDismemberSkin(tnode);
if (IBSDismemberSkinModifier *disSkin = (IBSDismemberSkinModifier *) dismemberSkinMod->GetInterface(I_BSDISMEMBERSKINMODIFIER)){
// Evaluate node ensure the modifier data is created
// ObjectState os = tnode->EvalWorldState(0);
FaceMap faceMap;
int nfaces = m.getNumFaces();
for ( int i=0; i<nfaces; ++i ){
Face f = m.faces[i];
faceMap[ rotate(f) ] = i;
}
Tab<IBSDismemberSkinModifierData*> modData = disSkin->GetModifierData();
for (int i=0; i<modData.Count(); ++i) {
IBSDismemberSkinModifierData* bsdsmd = modData[i];
Tab<BSDSPartitionData> &flags = bsdsmd->GetPartitionFlags();
vector<BodyPartList> partitions = bsdsi->GetPartitions();
if (partitions.empty())
continue;
//bsdsmd->SetActivePartition( partitions.size() - 1 ); // Old Code
for (unsigned int j = 0; j < (partitions.size() - 1); ++j){
bsdsmd->AddPartition();
}
for (unsigned int j=0; j < partitions.size(); ++j ) {
flags[j].bodyPart = (DismemberBodyPartType)partitions[j].bodyPart;
flags[j].partFlag = partitions[j].partFlag;
}
for (int j=0; j < part->GetNumPartitions(); ++j) {
bsdsmd->SetActivePartition( j );
dismemberSkinMod->SelectAll(3); // ensures bitarrays are properly synced to mesh
dismemberSkinMod->ClearSelection(3);
vector<Triangle> triangles = part->GetTriangles(j);
vector<unsigned short> map = part->GetVertexMap(j);
GenericNamedSelSetList& fselSet = bsdsmd->GetFaceSelList();
if ( BitArray* fsel = fselSet.GetSetByIndex(j) )
{
for (vector<Triangle>::iterator itrtri = triangles.begin(); itrtri != triangles.end(); ++itrtri) {
Face f;
f.setVerts( map[(*itrtri).v1], map[(*itrtri).v2], map[(*itrtri).v3] );
FaceMap::iterator fitr = faceMap.find( rotate(f) );
if (fitr != faceMap.end())
fsel->Set((*fitr).second);
}
}
}
bsdsmd->SetActivePartition( 0 );
disSkin->LocalDataChanged();
}
}
}
}
return ok;
}
IParamBlock2 *GetParamBlockByID (short id) { return (pblock->ID() == id) ? pblock : NULL; }
void PAOperatorObjectDlgProc::UpdateDlg(IParamMap2* map, HWND hWnd)
{
// BOOL bAxes, bDivergence, bRandom;
// bool varAnimated, divAnimated;
if(map && hWnd) {
IParamBlock2* ppb = map->GetParamBlock();
if(ppb) {
bool enableGeometry = true;
bool enableSubMtl = false;
bool enableMapping = false;
bool enableLockClosest = false;
int type = ppb->GetInt(kObject_channelType, 0);
bool isFloatType = (type == kObject_channelType_float);
EnableWindow( GetDlgItem(hWnd, IDC_FLOATTYPE), isFloatType );
int showControl = isFloatType ? SW_SHOW : SW_HIDE;
ShowWindow( GetDlgItem( hWnd, IDC_FLOATTYPE), showControl);
if (isFloatType) {
switch(ppb->GetInt(kObject_propertyFloat, 0)) {
case kObject_propertyFloat_distanceToPivot:
enableGeometry = false;
SetDlgItemText( hWnd, IDC_TEXT_PROPERTY, GetString(IDS_DESCRIPTION_DISTANCETOPIVOT));
break;
case kObject_propertyFloat_distanceToVertex:
enableLockClosest = true;
SetDlgItemText( hWnd, IDC_TEXT_PROPERTY, GetString(IDS_DESCRIPTION_DISTANCETOVERTEX));
break;
case kObject_propertyFloat_distanceToSurface:
enableLockClosest = true;
SetDlgItemText( hWnd, IDC_TEXT_PROPERTY, GetString(IDS_DESCRIPTION_DISTANCETOSURFACE));
break;
case kObject_propertyFloat_objectSpinRate:
enableGeometry = false;
SetDlgItemText( hWnd, IDC_TEXT_PROPERTY, GetString(IDS_DESCRIPTION_OBJECTSPINRATE));
break;
case kObject_propertyFloat_pointLuminance:
enableSubMtl = true;
enableLockClosest = true;
SetDlgItemText( hWnd, IDC_TEXT_PROPERTY, GetString(IDS_DESCRIPTION_POINTLUMINANCE));
break;
case kObject_propertyFloat_pointOpacity:
enableSubMtl = true;
enableLockClosest = true;
SetDlgItemText( hWnd, IDC_TEXT_PROPERTY, GetString(IDS_DESCRIPTION_POINTOPACITY));
break;
case kObject_propertyFloat_faceSquare:
enableLockClosest = true;
SetDlgItemText( hWnd, IDC_TEXT_PROPERTY, GetString(IDS_DESCRIPTION_FACESQUARE));
break;
case kObject_propertyFloat_softSelection:
enableLockClosest = true;
SetDlgItemText( hWnd, IDC_TEXT_PROPERTY, GetString(IDS_DESCRIPTION_SOFTSELECTION));
break;
}
}
bool isIntType = (type == kObject_channelType_integer);
EnableWindow( GetDlgItem(hWnd, IDC_INTTYPE), isIntType );
showControl = isIntType ? SW_SHOW : SW_HIDE;
ShowWindow( GetDlgItem( hWnd, IDC_INTTYPE), showControl);
if (isIntType) {
switch (ppb->GetInt(kObject_propertyInteger, 0)) {
case kObject_propertyInteger_objectIndexByPivot:
enableGeometry = false;
SetDlgItemText( hWnd, IDC_TEXT_PROPERTY, GetString(IDS_DESCRIPTION_OBJECTINDEXBYPIVOT));
break;
case kObject_propertyInteger_objectIndexByVertex:
SetDlgItemText( hWnd, IDC_TEXT_PROPERTY, GetString(IDS_DESCRIPTION_OBJECTINDEXBYVERTEX));
break;
case kObject_propertyInteger_objectIndexBySurface:
SetDlgItemText( hWnd, IDC_TEXT_PROPERTY, GetString(IDS_DESCRIPTION_OBJECTINDEXBYSURFACE));
break;
case kObject_propertyInteger_vertexIndex:
SetDlgItemText( hWnd, IDC_TEXT_PROPERTY, GetString(IDS_DESCRIPTION_VERTEXINDEX));
break;
case kObject_propertyInteger_faceIndex:
SetDlgItemText( hWnd, IDC_TEXT_PROPERTY, GetString(IDS_DESCRIPTION_FACEINDEX));
break;
case kObject_propertyInteger_materialIndex:
SetDlgItemText( hWnd, IDC_TEXT_PROPERTY, GetString(IDS_DESCRIPTION_MATERIALINDEX));
break;
}
}
bool isVectorType = (type == kObject_channelType_vector);
EnableWindow( GetDlgItem(hWnd, IDC_VECTORTYPE2), isVectorType );
showControl = isVectorType ? SW_SHOW : SW_HIDE;
ShowWindow( GetDlgItem( hWnd, IDC_VECTORTYPE2), showControl);
if (isVectorType) {
int vectorType = ppb->GetInt(kObject_propertyVector, 0);
switch(vectorType) {
case kObject_propertyVector_objectPosition:
enableGeometry = false;
SetDlgItemText( hWnd, IDC_TEXT_PROPERTY, GetString(IDS_DESCRIPTION_OBJECTPOSITION));
break;
case kObject_propertyVector_objectSpeed:
enableGeometry = false;
SetDlgItemText( hWnd, IDC_TEXT_PROPERTY, GetString(IDS_DESCRIPTION_OBJECTSPEED));
break;
case kObject_propertyVector_objectScale:
enableGeometry = false;
SetDlgItemText( hWnd, IDC_TEXT_PROPERTY, GetString(IDS_DESCRIPTION_OBJECTSCALE));
break;
case kObject_propertyVector_objectEuclideRotation:
enableGeometry = false;
SetDlgItemText( hWnd, IDC_TEXT_PROPERTY, GetString(IDS_DESCRIPTION_OBJECTEUCLIDEROTATION));
break;
case kObject_propertyVector_objectSpinAxis:
enableGeometry = false;
SetDlgItemText( hWnd, IDC_TEXT_PROPERTY, GetString(IDS_DESCRIPTION_OBJECTSPINAXIS));
break;
case kObject_propertyVector_nearestColor:
enableSubMtl = true;
enableLockClosest = true;
SetDlgItemText( hWnd, IDC_TEXT_PROPERTY, GetString(IDS_DESCRIPTION_NEARESTCOLOR));
break;
case kObject_propertyVector_nearestMapping:
enableMapping = true;
enableLockClosest = true;
SetDlgItemText( hWnd, IDC_TEXT_PROPERTY, GetString(IDS_DESCRIPTION_NEARESTMAPPING));
break;
case kObject_propertyVector_mappingUVector:
enableMapping = true;
enableLockClosest = true;
SetDlgItemText( hWnd, IDC_TEXT_PROPERTY, GetString(IDS_DESCRIPTION_MAPPINGUVECTOR));
break;
case kObject_propertyVector_mappingVVector:
enableMapping = true;
enableLockClosest = true;
SetDlgItemText( hWnd, IDC_TEXT_PROPERTY, GetString(IDS_DESCRIPTION_MAPPINGVVECTOR));
break;
case kObject_propertyVector_mappingWVector:
enableMapping = true;
enableLockClosest = true;
SetDlgItemText( hWnd, IDC_TEXT_PROPERTY, GetString(IDS_DESCRIPTION_MAPPINGWVECTOR));
break;
case kObject_propertyVector_nearestSurfacePoint:
enableLockClosest = true;
SetDlgItemText( hWnd, IDC_TEXT_PROPERTY, GetString(IDS_DESCRIPTION_NEARESTSURFACEPOINT));
break;
case kObject_propertyVector_nearestVertex:
enableLockClosest = true;
SetDlgItemText( hWnd, IDC_TEXT_PROPERTY, GetString(IDS_DESCRIPTION_NEARESTVERTEX));
break;
case kObject_propertyVector_nearestNormal:
enableLockClosest = true;
SetDlgItemText( hWnd, IDC_TEXT_PROPERTY, GetString(IDS_DESCRIPTION_NEARESTNORMAL));
break;
case kObject_propertyVector_localSpeed:
enableLockClosest = true;
SetDlgItemText( hWnd, IDC_TEXT_PROPERTY, GetString(IDS_DESCRIPTION_LOCALSPEED));
break;
}
}
ISpinnerControl* spin = NULL;
bool useSubMtl = (ppb->GetInt(kObject_useSubMtl, 0) != 0);
EnableWindow( GetDlgItem(hWnd, IDC_USESUBMATERIAL), enableSubMtl );
spin = GetISpinner( GetDlgItem( hWnd, IDC_SUBMATERIALSPIN) );
spin->Enable(enableSubMtl && useSubMtl);
ReleaseISpinner(spin);
EnableWindow( GetDlgItem(hWnd, IDC_TEXT_MAPPINGCHANNEL), enableMapping );
spin = GetISpinner( GetDlgItem( hWnd, IDC_MAPPINGCHANNELSPIN) );
spin->Enable(enableMapping);
ReleaseISpinner(spin);
// if (enableLockClosest) // lockClosest is not used at the moment
// if (ppb->GetInt(kObject_assignOnce, 0) != 0) enableLockClosest = false;
// EnableWindow( GetDlgItem(hWnd, IDC_LOCK), enableLockClosest );
int numObjects = ppb->Count(kObject_objects);
EnableWindow( GetDlgItem(hWnd, IDC_REMOVENODE), numObjects > 0 );
bool useDesignate = (ppb->GetInt(kObject_useDesignate, 0) != 0);
EnableWindow( GetDlgItem(hWnd, IDC_TEXT_CUSTOMNAME2), useDesignate);
EnableWindow( GetDlgItem(hWnd, IDC_CHANNELNAME2), useDesignate);
bool useSyncChannel = (ppb->GetInt(kObject_sync, 0) == kObject_sync_channel);
EnableWindow( GetDlgItem(hWnd, IDC_TEXT_CUSTOMNAME3), useSyncChannel);
EnableWindow( GetDlgItem(hWnd, IDC_CHANNELNAME3), useSyncChannel);
EnableWindow( GetDlgItem(hWnd, IDC_ANIMATED), enableGeometry);
bool animatedShape = (ppb->GetInt(kObject_animated, 0) != 0);
EnableWindow( GetDlgItem(hWnd, IDC_GEOMETRY), enableGeometry && animatedShape);
bool useFilter = (ppb->GetInt(kObject_useCondition, 0) != 0);
EnableWindow( GetDlgItem(hWnd, IDC_TEXT_CONDITIONNAME2), useFilter);
EnableWindow( GetDlgItem(hWnd, IDC_CONDITIONNAME2), useFilter);
}
}
}
void Smoke::SetSize(float f, TimeValue t) {
size = f;
// pblock->SetValue(PB_SIZE, t, f);
pblock->SetValue(smoke_size, t, f);
}
void Smoke::SetIter(int i, TimeValue t) {
iter = i;
// pblock->SetValue(PB_ITER, t, i);
pblock->SetValue(smoke_iteration, t, i);
}
void Water::SetAmp(float f, TimeValue t, BOOL init) {
amp = f;
// pblock->SetValue(PB_AMP, t, f);
pblock->SetValue(water_amp, t, f);
if (init) ReInit();
}
IParamBlock2* GetParamBlockByID(BlockID id) { return (m_pblock->ID() == id) ? m_pblock : NULL; }
Interval ConvertToPoly::GetValidity (TimeValue t) {
Interval ret = FOREVER;
pblock->GetValidity (t, ret);
return ret;
}
void ConvertToPoly::ModifyObject (TimeValue t, ModContext &mc, ObjectState *os, INode *node) {
if (!os->obj->CanConvertToType (triObjectClassID)) return;
Interval ivalid=os->obj->ObjectValidity (t);
TriObject *triObj;
PolyObject *polyObj;
PolyObject *pobj = new PolyObject ();
#ifndef NO_PATCHES // orb 02-11-2002
PatchObject *patchObj;
if (os->obj->IsSubClassOf (patchObjectClassID)) {
patchObj = (PatchObject *) os->obj;
Convert (patchObj, t, pobj->mm, ivalid);
} else
#endif // NO_PATCHES
{
if (os->obj->IsSubClassOf (triObjectClassID)) {
triObj = (TriObject *) os->obj;
Convert (triObj, t, pobj->mm, ivalid);
pobj->SetDisplacementDisable (triObj->mDisableDisplacement);
pobj->SetDisplacementSplit (triObj->mSplitMesh);
pobj->SetDisplacementParameters (triObj->mDispApprox);
pobj->SetDisplacement (triObj->mSubDivideDisplacement);
} else {
if (os->obj->IsSubClassOf (polyObjectClassID)) {
polyObj = (PolyObject *) os->obj;
Convert (polyObj, t, pobj->mm, ivalid);
pobj->SetDisplacementDisable (polyObj->GetDisplacementDisable ());
pobj->SetDisplacementSplit (polyObj->GetDisplacementSplit());
pobj->SetDisplacementParameters (polyObj->GetDisplacementParameters());
pobj->SetDisplacement (polyObj->GetDisplacement ());
} else {
if (os->obj->CanConvertToType (polyObjectClassID)) {
polyObj = (PolyObject *) os->obj->ConvertToType (t, polyObjectClassID);
Convert (polyObj, t, pobj->mm, ivalid);
if (polyObj != os->obj) delete polyObj;
} else {
triObj = (TriObject *) os->obj->ConvertToType (t, triObjectClassID);
Convert (triObj, t, pobj->mm, ivalid);
if (triObj != os->obj) delete triObj;
}
}
}
}
// Handle Selection Conversion
int selConv, useSoftSel;
int selLevel;
pblock->GetValue (turn_sel_type, t, selConv, ivalid);
pblock->GetValue (turn_softsel, t, useSoftSel, ivalid);
pblock->GetValue (turn_sel_level, t, selLevel, ivalid);
if (selLevel && (pobj->mm.selLevel != UI2SelLevel(selLevel))) useSoftSel = false;
if (!useSoftSel) pobj->mm.freeVSelectionWeights ();
int i;
float *vsel;
switch (selConv) {
case 1: // Clear selection
pobj->mm.ClearVFlags (MN_SEL);
pobj->mm.ClearEFlags (MN_SEL);
pobj->mm.ClearFFlags (MN_SEL);
pobj->mm.freeVSelectionWeights ();
break;
case 2: // Invert selection
vsel = pobj->mm.getVSelectionWeights ();
for (i=0; i<pobj->mm.numv; i++) {
if (pobj->mm.v[i].GetFlag (MN_SEL)) pobj->mm.v[i].ClearFlag (MN_SEL);
else pobj->mm.v[i].SetFlag (MN_SEL);
if (vsel) {
vsel[i] = 1.0f - vsel[i];
if (vsel[i]<1) pobj->mm.v[i].ClearFlag (MN_SEL);
}
}
for (i=0; i<pobj->mm.nume; i++) {
if (pobj->mm.e[i].GetFlag (MN_SEL)) pobj->mm.e[i].ClearFlag (MN_SEL);
else pobj->mm.e[i].SetFlag (MN_SEL);
}
for (i=0; i<pobj->mm.numf; i++) {
if (pobj->mm.f[i].GetFlag (MN_SEL)) pobj->mm.f[i].ClearFlag (MN_SEL);
else pobj->mm.f[i].SetFlag (MN_SEL);
}
}
// Set Subobject Level if needed
if(selLevel != 0)
pobj->mm.selLevel = UI2SelLevel(selLevel);
// Set display flags:
pobj->mm.dispFlags = 0;
switch (pobj->mm.selLevel) {
case MNM_SL_VERTEX:
pobj->mm.SetDispFlag (MNDISP_VERTTICKS|MNDISP_SELVERTS);
break;
case MNM_SL_EDGE:
pobj->mm.SetDispFlag (MNDISP_SELEDGES);
break;
case MNM_SL_FACE:
pobj->mm.SetDispFlag (MNDISP_SELFACES);
break;
}
pobj->SetPartValidity (OBJ_CHANNELS, ivalid);
if (os->obj != pobj) os->obj = (Object *) pobj;
}
//---------------------------------------------------------------------------
//
void LuminaireObject::SetRGBFilterColor(Point3& value, TimeValue& time)
{
DbgAssert(mpBlock != NULL);
mpBlock->SetValue(kPB_FILTER_COLOR, time, value);
}
IParamBlock2 *ConvertToPoly::GetParamBlockByID (short id) {
return (pblock->ID() == id) ? pblock : NULL;
}
//---------------------------------------------------------------------------
//
void LuminaireObject::SetDimmer(float value, TimeValue time)
{
DbgAssert(mpBlock != NULL);
mpBlock->SetValue(kPB_DIMMER, time, value);
}
void SolidifyPW::EnableUIControls()
{
if ((ip) && hWnd)
{
TimeValue t = 0;
Interval iv;
BOOL ioverrideMatID;
pblock->GetValue(pb_overrideinnermatid,t,ioverrideMatID,iv);
SpinnerOn(hWnd,IDC_MATIDSPIN2,IDC_MATID2, ioverrideMatID);
EnableWindow(GetDlgItem(hWnd,IDC_IMATIDSTATIC),ioverrideMatID);
BOOL ooverrideMatID;
pblock->GetValue(pb_overrideoutermatid,t,ooverrideMatID,iv);
SpinnerOn(hWnd,IDC_MATIDSPIN3,IDC_MATID3, ooverrideMatID);
EnableWindow(GetDlgItem(hWnd,IDC_OMATIDSTATIC),ooverrideMatID);
BOOL overrideMatID;
pblock->GetValue(pb_overridematid,t,overrideMatID,iv);
SpinnerOn(hWnd,IDC_MATIDSPIN,IDC_MATID, overrideMatID);
EnableWindow(GetDlgItem(hWnd,IDC_EMATIDSTATIC),overrideMatID);
BOOL autoSmooth;
pblock->GetValue(pb_autosmooth,t,autoSmooth,iv);
SpinnerOn(hWnd,IDC_AUTOSMOOTHSPIN,IDC_AUTOSMOOTH, autoSmooth);
EnableWindow(GetDlgItem(hWnd,IDC_ANGLESTATIC),autoSmooth);
if (autoSmooth)
{
EnableWindow(GetDlgItem(hWnd,IDC_SMOOTHCHECK),FALSE);
EnableWindow(GetDlgItem(hWnd,IDC_SGSTATIC),FALSE);
SpinnerOn(hWnd,IDC_SMOOTHGROUPSPIN,IDC_SMOOTHGROUP, FALSE);
}
else
{
EnableWindow(GetDlgItem(hWnd,IDC_SMOOTHCHECK),TRUE);
EnableWindow(GetDlgItem(hWnd,IDC_SGSTATIC),TRUE);
BOOL overridesg;
pblock->GetValue(pb_overridesg,t,overridesg,iv);
SpinnerOn(hWnd,IDC_SMOOTHGROUPSPIN,IDC_SMOOTHGROUP, overridesg);
}
int edgeMap;
pblock->GetValue(pb_edgemap,t,edgeMap,iv);
if (edgeMap < 2 )
{
EnableWindow(GetDlgItem(hWnd,IDC_TVSTATIC),FALSE);
SpinnerOn(hWnd,IDC_TVOFFSETSPIN,IDC_TVOFFSET, FALSE);
}
else
{
EnableWindow(GetDlgItem(hWnd,IDC_TVSTATIC),TRUE);
SpinnerOn(hWnd,IDC_TVOFFSETSPIN,IDC_TVOFFSET, TRUE);
}
}
}
void SolidifyPW::ModifyObject(TimeValue t, ModContext &mc, ObjectState * os, INode *node)
{
//TODO: Add the code for actually modifying the object
meshInfo.Free();
if (os->obj->IsSubClassOf(triObjectClassID)) {
TriObject *tobj = (TriObject*)os->obj;
Mesh &mesh = tobj->GetMesh();
Interval iv = FOREVER;
float a,oa;
pblock->GetValue(pb_amount,t,a,iv);
pblock->GetValue(pb_oamount,t,oa,iv);
if (a == oa)
oa += 0.00001f;
BOOL overrideMatID;
int matid;
pblock->GetValue(pb_overridematid,t,overrideMatID,iv);
pblock->GetValue(pb_matid,t,matid,iv);
matid--;
if (!overrideMatID) matid = -1;
BOOL overridesg;
int sg;
pblock->GetValue(pb_overridesg,t,overridesg,iv);
pblock->GetValue(pb_sg,t,sg,iv);
if (!overridesg) sg = -1;
int edgeMap;
pblock->GetValue(pb_edgemap,t,edgeMap,iv);
float tvOffset;
pblock->GetValue(pb_tvoffset,t,tvOffset,iv);
BOOL ioverrideMatID;
int imatid;
pblock->GetValue(pb_overrideinnermatid,t,ioverrideMatID,iv);
pblock->GetValue(pb_innermatid,t,imatid,iv);
imatid--;
if (!ioverrideMatID) imatid = -1;
BOOL ooverrideMatID;
int omatid;
pblock->GetValue(pb_overrideoutermatid,t,ooverrideMatID,iv);
pblock->GetValue(pb_outermatid,t,omatid,iv);
omatid--;
if (!ooverrideMatID) omatid = -1;
BOOL selEdges, selInner,selOuter;
static BOOL selEdgesPrev = FALSE;
static BOOL selInnerPrev = FALSE;
static BOOL selOuterPrev = FALSE;
BOOL updateUI = FALSE;
pblock->GetValue(pb_seledges,t,selEdges,iv);
pblock->GetValue(pb_selinner,t,selInner,iv);
pblock->GetValue(pb_selouter,t,selOuter,iv);
if (selEdges && (!selEdgesPrev))
updateUI = TRUE;
if (selInner && (!selInnerPrev))
updateUI = TRUE;
if (selOuter && (!selOuterPrev))
updateUI = TRUE;
selEdgesPrev = selEdges;
selInnerPrev = selInner;
selOuterPrev = selOuter;
if (selEdges || selInner|| selOuter)
{
mesh.dispFlags = DISP_SELFACES;
mesh.selLevel = MESH_FACE;
}
int segments = 1;
pblock->GetValue(pb_segments,t,segments,iv);
if (segments < 1) segments = 1;
BOOL fixupCorners;
pblock->GetValue(pb_fixupcorners,t,fixupCorners,iv);
BOOL autoSmooth;
float smoothAngle;
pblock->GetValue(pb_autosmooth,t,autoSmooth,iv);
pblock->GetValue(pb_autosmoothangle,t,smoothAngle,iv);
BOOL bevel;
INode *node;
pblock->GetValue(pb_bevel,t,bevel,iv);
pblock->GetValue(pb_bevelshape,t,node,iv);
PolyShape shape;
if ((bevel) && node)
{
ObjectState nos = node->EvalWorldState(t);
if (nos.obj->IsShapeObject())
{
ShapeObject *pathOb = (ShapeObject*)nos.obj;
if (!pathOb->NumberOfCurves())
{
bevel = FALSE;
}
else
{
pathOb->MakePolyShape(t, shape,PSHAPE_BUILTIN_STEPS,TRUE);
if (shape.lines[0].IsClosed())
bevel = FALSE;
;
}
}
}
DWORD selLevel = mesh.selLevel;
mesh.faceSel.ClearAll();
if (bevel)
meshInfo.MakeSolid(&mesh,segments, a,oa,matid, sg,edgeMap,tvOffset,imatid,omatid,selEdges,selInner,selOuter,fixupCorners,autoSmooth,smoothAngle,&shape.lines[0]);
else meshInfo.MakeSolid(&mesh,segments, a,oa,matid, sg,edgeMap,tvOffset,imatid,omatid,selEdges,selInner,selOuter,fixupCorners,autoSmooth,smoothAngle,NULL);
mesh.selLevel = selLevel;
mesh.InvalidateTopologyCache ();
for (int i = 0; i < mesh.numFaces; i++)
{
for (int j = 0; j < 3; j++)
{
int index = mesh.faces[j].v[j];
if ((index < 0) || (index >= mesh.numVerts))
DebugPrint(_T("Invalid face %d(%d) %d\n"),i,j,index);
}
}
int numMaps = mesh.getNumMaps();
for (int mp = -NUM_HIDDENMAPS; mp < numMaps; mp++)
{
if (!mesh.mapSupport(mp)) continue;
Point3 *uvw = mesh.mapVerts(mp);
TVFace *uvwFace = mesh.mapFaces(mp);
if ((uvw) && (uvwFace))
{
int numberTVVerts = mesh.getNumMapVerts(mp);
for (int i = 0; i < mesh.numFaces; i++)
{
for (int j = 0; j < 3; j++)
{
int index = uvwFace[i].t[j];
if ((index < 0) || (index >= numberTVVerts))
DebugPrint(_T("Invalid Map %d tvface %d(%d) %d\n"),mp,i,j,index);
}
}
}
}
os->obj->UpdateValidity(GEOM_CHAN_NUM,iv);
os->obj->UpdateValidity(TOPO_CHAN_NUM,iv);
MeshNormalSpec *pNormSpec = (MeshNormalSpec *) mesh.GetInterface (MESH_NORMAL_SPEC_INTERFACE);
if (pNormSpec && pNormSpec->GetNumFaces() > 0)
{
pNormSpec->SetParent(&mesh);
pNormSpec->BuildNormals();
pNormSpec->ComputeNormals();
}
if ((updateUI) && (ip))
{
ip->PipeSelLevelChanged();
}
}
EnableUIControls();
}
void Water::SetLenMin(float f, TimeValue t, BOOL init) {
minperiod = f;
// pblock->SetValue(PB_LEN_MIN, t, f);
pblock->SetValue(water_len_min, t, f);
if (init) ReInit();
}
//---------------------------------------------------------------
void LightExporter::exportLight( ExportNode* exportNode )
{
if ( !exportNode->getIsInVisualScene() )
return;
String lightId = getLightId(*exportNode);
INode * iNode = exportNode->getINode();
LightObject* lightObject = (LightObject*) (iNode->GetObjectRef());
if ( !lightObject )
return;
if ( mDocumentExporter->isExportedObject(ObjectIdentifier(lightObject)) )
return;
mDocumentExporter->insertExportedObject(ObjectIdentifier(lightObject), exportNode);
// Retrieve the target node, if we are not baking matrices.
// Baked matrices must always sample the transform!
ULONG ClassId = lightObject->ClassID().PartA();
bool isTargeted = !mDocumentExporter->getOptions().getBakeMatrices() && (ClassId == SPOT_LIGHT_CLASS_ID || ClassId == TDIR_LIGHT_CLASS_ID);
INode* targetNode = isTargeted ? iNode->GetTarget() : 0;
// some lights are not supported at all
switch (ClassId)
{
case FSPOT_LIGHT_CLASS_ID:
case SPOT_LIGHT_CLASS_ID:
case DIR_LIGHT_CLASS_ID:
case TDIR_LIGHT_CLASS_ID:
case SKY_LIGHT_CLASS_ID_PART_A:
case OMNI_LIGHT_CLASS_ID:
break;
default:
return;
}
// Determine the light's type
bool isSpot = false;
bool isDirectional = false;
bool isPoint = false;
bool isSky = false;
COLLADASW::Light::LightType lightType;
switch (ClassId)
{
case FSPOT_LIGHT_CLASS_ID:
case SPOT_LIGHT_CLASS_ID:
lightType = COLLADASW::Light::SPOT;
isSpot = true;
break;
case DIR_LIGHT_CLASS_ID:
case TDIR_LIGHT_CLASS_ID:
lightType = COLLADASW::Light::DIRECTIONAL;
isDirectional = true;
break;
case SKY_LIGHT_CLASS_ID_PART_A:
lightType = COLLADASW::Light::POINT;
isSky = true;
break;
case OMNI_LIGHT_CLASS_ID:
lightType = COLLADASW::Light::POINT;
isPoint = true;
break;
}
COLLADASW::Light * colladaLight = 0;
switch ( lightType )
{
case COLLADASW::Light::DIRECTIONAL:
colladaLight = new COLLADASW::DirectionalLight(COLLADASW::LibraryLights::mSW, lightId, COLLADASW::Utils::checkNCName(NativeString(exportNode->getINode()->GetName())));
break;
case COLLADASW::Light::POINT:
colladaLight = new COLLADASW::PointLight(COLLADASW::LibraryLights::mSW, lightId, COLLADASW::Utils::checkNCName(NativeString(exportNode->getINode()->GetName())));
break;
case COLLADASW::Light::SPOT:
colladaLight = new COLLADASW::SpotLight(COLLADASW::LibraryLights::mSW, lightId, COLLADASW::Utils::checkNCName(NativeString(exportNode->getINode()->GetName())));
break;
}
// Retrieve the parameter block
IParamBlock* parameters = 0;
IParamBlock2* parametersSky = 0;
if (isSky)
parametersSky = (IParamBlock2*) lightObject->GetReference(MaxLight::PBLOCK_REF_SKY);
else
parameters = (IParamBlock*) lightObject->GetReference(MaxLight::PBLOCK_REF);
if (!parameters && !parametersSky)
{
delete colladaLight;
return;
}
if (parameters)
{
bool hasAnimatedColor = mAnimationExporter->addAnimatedParameter(parameters, MaxLight::PB_COLOR, lightId, colladaLight->getColorDefaultSid(), 0 );
colladaLight->setColor(EffectExporter::maxColor2Color(parameters->GetColor(MaxLight::PB_COLOR)), hasAnimatedColor);
}
else if (parametersSky )
{
bool hasAnimatedColor = mAnimationExporter->addAnimatedParameter(parametersSky, MaxLight::PB_SKY_COLOR, lightId, colladaLight->getColorDefaultSid(), 0 );
colladaLight->setColor(EffectExporter::maxColor2Color(parametersSky->GetColor(MaxLight::PB_SKY_COLOR)), hasAnimatedColor);
}
if (isSpot || isPoint)
{
int decayFunction = parameters->GetInt(isPoint ? MaxLight::PB_DECAY : MaxLight::PB_OMNIDECAY, mDocumentExporter->getOptions().getAnimationStart());
switch (decayFunction)
{
case 1:
colladaLight->setConstantAttenuation(0.0f);
colladaLight->setLinearAttenuation(1.0f);
break;
case 2:
colladaLight->setConstantAttenuation(0.0f);
colladaLight->setQuadraticAttenuation(1.0f);
break;
case 0:
default:
colladaLight->setConstantAttenuation(1.0f);
break;
}
}
else if (isSky)
{
colladaLight->setConstantAttenuation(1.0f);
}
setExtraTechnique(colladaLight);
if ( parameters )
addParamBlockAnimatedExtraParameters(LIGHT_ELEMENT, LIGHT_PARAMETERS, LIGHT_PARAMETER_COUNT, parameters, lightId);
else
addParamBlockAnimatedExtraParameters(SKYLIGHT_ELEMENT, SKYLIGHT_PARAMETERS, SKYLIGHT_PARAMETER_COUNT, parametersSky, lightId);
// add all the information to extra tag, that are not contained in IParamBlock
if (isSpot || isDirectional || isPoint)
{
GenLight* light = (GenLight*)(lightObject);
if (!light)
{
delete colladaLight;
return;
}
// Export the overshoot flag for directional lights
if (isDirectional || isSpot)
{
addExtraChildParameter(LIGHT_ELEMENT, OVERSHOOT_PARAMETER, light->GetOvershoot() != false);
}
addExtraChildParameter(LIGHT_ELEMENT, DECAY_TYPE_PARAMETER, (int)light->GetDecayType());
addExtraChildParameter(LIGHT_ELEMENT, USE_NEAR_ATTENUATION_PARAMETER, (light->GetUseAttenNear() != false));
addExtraChildParameter(LIGHT_ELEMENT, USE_FAR_ATTENUATION_PARAMETER, (light->GetUseAtten() != false));
exportShadowParameters(light);
if (light->GetProjector())
{
Texmap* projectorMap = light->GetProjMap();
if (projectorMap)
{
String imageId = exportTexMap(projectorMap);
if ( !imageId.empty() )
{
addExtraChildParameter(LIGHT_ELEMENT, LIGHT_MAP_ELEMENT, "#" + imageId);
}
}
}
}
else // isSky
{
Texmap *colorMap = parametersSky->GetTexmap(MaxLight::PB_SKY_COLOR_MAP, mDocumentExporter->getOptions().getAnimationStart());
String imageId = exportTexMap(colorMap);
if ( !imageId.empty())
{
addExtraChildParameter(SKYLIGHT_ELEMENT, SKYLIGHT_COLORMAP_ELEMENT, "#" + imageId);
}
}
addLight(*colladaLight);
delete colladaLight;
}
void Water::SetLenMax(float f, TimeValue t, BOOL init) {
maxperiod = f;
// pblock->SetValue(PB_LEN_MAX, t, f);
pblock->SetValue(water_len_max, t, f);
if (init) ReInit();
}
void EllipseObject::BuildShape(TimeValue t, BezierShape& ashape)
{
// Start the validity interval at forever and whittle it down.
ivalid = FOREVER;
float length;
float width;
float thickness;
BOOL build_outine = FALSE;
myParamBlock->GetValue(PB_LENGTH, t, length, ivalid);
myParamBlock->GetValue(PB_WIDTH, t, width, ivalid);
myParamBlock->GetValue(PB_THICKNESS, t, thickness, ivalid);
myParamBlock->GetValue(PB_OUTLINE, t, build_outine, ivalid);
LimitValue( length, MIN_LENGTH, MAX_LENGTH );
LimitValue( width, MIN_WIDTH, MAX_WIDTH );
LimitValue(thickness, MIN_THICK, MAX_THICK );
// Delete the existing shape and create a new spline in it
ashape.NewShape();
// Get parameters from SimpleSpline and place them in the BezierShape
int steps;
BOOL optimize,adaptive;
ipblock->GetValue(IPB_STEPS, t, steps, ivalid);
ipblock->GetValue(IPB_OPTIMIZE, t, optimize, ivalid);
ipblock->GetValue(IPB_ADAPTIVE, t, adaptive, ivalid);
ashape.steps = adaptive ? -1 : steps;
ashape.optimize = optimize;
float radius, xmult, ymult;
if(length < width)
{
radius = width;
xmult = 1.0f;
ymult = length / width;
}
else
if(width < length)
{
radius = length;
xmult = width / length;
ymult = 1.0f;
}
else
{
radius = length;
xmult = ymult = 1.0f;
}
MakeCircle(ashape, radius / 2.0f, xmult, ymult);
if(build_outine)
{
length += 2*thickness;
width += 2*thickness;
LimitValue( length, MIN_LENGTH, MAX_LENGTH );
LimitValue( width, MIN_WIDTH, MAX_WIDTH );
if(length < width)
{
radius = width;
xmult = 1.0f;
ymult = length / width;
}
else if(width < length)
{
radius = length;
xmult = width / length;
ymult = 1.0f;
}
else
{
radius = length;
xmult = ymult = 1.0f;
}
MakeCircle(ashape, radius / 2.0f, xmult, ymult);
}
ashape.UpdateSels(); // Make sure it readies the selection set info
ashape.InvalidateGeomCache();
}
void Water::SetPhase(float f, TimeValue t, BOOL init) {
phase = f;
// pblock->SetValue(PB_PHASE, t, f);
pblock->SetValue(water_phase, t, f);
if (init) ReInit();
}
void EllipseObject::InvalidateUI()
{
myParamBlock->GetDesc()->InvalidateUI();
}
void Smoke::SetPhase(float f, TimeValue t) {
phase = f;
// pblock->SetValue(PB_PHASE, t, f);
pblock->SetValue(smoke_phase, t, f);
}
// This method is called before rendering begins to allow the plug-in
// to evaluate anything prior to the render so it can store this information.
void Water::Update(TimeValue t, Interval& ivalid) {
if (!texValidity.InInterval(t)) {
texValidity.SetInfinite();
xyzGen->Update(t, texValidity);
// pblock->GetValue(PB_COL1, t, col[0], texValidity);
pblock->GetValue(water_color1, t, col[0], texValidity);
col[0].ClampMinMax();
// pblock->GetValue(PB_COL2, t, col[1], texValidity);
pblock->GetValue(water_color2, t, col[1], texValidity);
col[1].ClampMinMax();
// pblock->GetValue(PB_NUM, t, count, texValidity);
pblock->GetValue(water_num, t, count, texValidity);
ClampInt(count, (int) MIN_NUM, (int) MAX_NUM);
// pblock->GetValue(PB_SIZE, t, size, texValidity);
pblock->GetValue(water_size, t, size, texValidity);
ClampFloat(size, MIN_SIZE, MAX_SIZE);
// pblock->GetValue(PB_LEN_MIN, t, minperiod, texValidity);
pblock->GetValue(water_len_min, t, minperiod, texValidity);
ClampFloat(minperiod, MIN_LEN_MIN, MAX_LEN_MIN); // > 6/11/02 - 2:42pm --MQM-- typo, was MIN_LEN_MIN, MAX_LEN_MAX
// pblock->GetValue(PB_LEN_MAX, t, maxperiod, texValidity);
pblock->GetValue(water_len_max, t, maxperiod, texValidity);
ClampFloat(maxperiod, MIN_LEN_MAX, MAX_LEN_MAX);
// pblock->GetValue(PB_AMP, t, amp, texValidity);
pblock->GetValue(water_amp, t, amp, texValidity);
ClampFloat(amp, MIN_AMP, MAX_AMP);
// pblock->GetValue(PB_PHASE, t, phase, texValidity);
// pblock->GetValue(PB_TYPE, t, type, texValidity);
pblock->GetValue(water_phase, t, phase, texValidity);
pblock->GetValue(water_type, t, type, texValidity);
for (int i = 0; i < NUM_SUB_TEXMAPS; i++) {
if (subTex[i])
subTex[i]->Update(t, texValidity);
// pblock->GetValue(PB_SEED, t, randSeed, texValidity);
pblock->GetValue(water_seed, t, randSeed, texValidity);
pblock->GetValue(water_mapon1, t, mapOn[0], texValidity);
pblock->GetValue(water_mapon2, t, mapOn[1], texValidity);
ReInit();
}
}
ivalid &= texValidity;
}
void Smoke::SetExp(float f, TimeValue t) {
power = f;
// pblock->SetValue(PB_EXP, t, f);
pblock->SetValue(smoke_exponent, t, f);
}
void Water::SetColor(int i, Color c, TimeValue t) {
col[i] = c;
// pblock->SetValue((i == 0) ? PB_COL1 : PB_COL2, t, c);
pblock->SetValue((i == 0) ? water_color1 : water_color2, t, c);
}
IParamBlock2* GetParamBlockByID(BlockID id) { return (pblock->ID() == id) ? pblock : NULL; } // return id'd ParamBlock
void Water::SetRandSeed(int i, BOOL init) {
randSeed = i;
// pblock->SetValue(PB_SEED, 0, i);
pblock->SetValue(water_seed, 0, i);
if (init) ReInit();
}
void SmoothMod::ModifyObject(TimeValue t, ModContext &mc, ObjectState *os, INode *node) {
Interval valid = FOREVER;
int autoSmooth, bits = 0, prevent = 0;
float thresh = 0.0f;
pblock->GetValue(sm_autosmooth, t, autoSmooth, valid);
if (autoSmooth) {
pblock->GetValue(sm_threshold, t, thresh, valid);
pblock->GetValue(sm_prevent_indirect, t, prevent, valid);
} else {
pblock->GetValue(sm_smoothbits, t, bits, valid);
}
// For version 4 and later, we process patch meshes as they are and pass them on. Earlier
// versions converted to TriMeshes (done below). For adding other new types of objects, add
// them here!
bool done = false;
#ifndef NO_PATCHES
if(version >= MATMOD_VER4 && os->obj->IsSubClassOf(patchObjectClassID)) {
PatchObject *patchOb = (PatchObject *)os->obj;
PatchMesh &pmesh = patchOb->GetPatchMesh(t);
BOOL useSel = pmesh.selLevel >= PO_PATCH;
if (autoSmooth) pmesh.AutoSmooth (thresh, useSel, prevent);
else {
for (int i=0; i<pmesh.getNumPatches(); i++) {
if (!useSel || pmesh.patchSel[i]) pmesh.patches[i].smGroup = (DWORD)bits;
}
}
pmesh.InvalidateGeomCache(); // Do this because there isn't a topo cache in PatchMesh
patchOb->UpdateValidity(TOPO_CHAN_NUM,valid);
done = true;
}
#endif // NO_PATCHES
if (!done && os->obj->IsSubClassOf (polyObjectClassID)) {
PolyObject *pPolyOb = (PolyObject *)os->obj;
MNMesh &mesh = pPolyOb->GetMesh();
BOOL useSel = (mesh.selLevel == MNM_SL_FACE);
if (autoSmooth) mesh.AutoSmooth (thresh, useSel, prevent);
else {
for (int faceIndex=0; faceIndex<mesh.FNum(); faceIndex++) {
if (!useSel || mesh.F(faceIndex)->GetFlag(MN_SEL)) {
mesh.F(faceIndex)->smGroup = (DWORD)bits;
}
}
}
// Luna task 747
// We need to rebuild the smoothing-group-based normals in the normalspec, if any:
if (mesh.GetSpecifiedNormals()) {
mesh.GetSpecifiedNormals()->SetParent (&mesh);
mesh.GetSpecifiedNormals()->BuildNormals ();
mesh.GetSpecifiedNormals()->ComputeNormals ();
}
pPolyOb->UpdateValidity(TOPO_CHAN_NUM,valid);
done = true;
}
TriObject *triOb = NULL;
if (!done) {
if (os->obj->IsSubClassOf(triObjectClassID)) triOb = (TriObject *)os->obj;
else {
// Convert to triobject if we can.
if(os->obj->CanConvertToType(triObjectClassID)) {
TriObject *triOb = (TriObject *)os->obj->ConvertToType(t, triObjectClassID);
// We'll need to stuff this back into the pipeline:
os->obj = triOb;
// Convert validities:
Interval objValid = os->obj->ChannelValidity (t, TOPO_CHAN_NUM);
triOb->SetChannelValidity (TOPO_CHAN_NUM, objValid);
triOb->SetChannelValidity (GEOM_CHAN_NUM,
objValid & os->obj->ChannelValidity (t, GEOM_CHAN_NUM));
triOb->SetChannelValidity (TEXMAP_CHAN_NUM,
objValid & os->obj->ChannelValidity (t, TEXMAP_CHAN_NUM));
triOb->SetChannelValidity (VERT_COLOR_CHAN_NUM,
objValid & os->obj->ChannelValidity (t, VERT_COLOR_CHAN_NUM));
triOb->SetChannelValidity (DISP_ATTRIB_CHAN_NUM,
objValid & os->obj->ChannelValidity (t, DISP_ATTRIB_CHAN_NUM));
}
}
}
if (triOb) { // one way or another, there's a triobject to smooth.
Mesh & mesh = triOb->GetMesh();
BOOL useSel = mesh.selLevel == MESH_FACE;
if (autoSmooth) mesh.AutoSmooth (thresh, useSel, prevent);
else {
for (int i=0; i<mesh.getNumFaces(); i++) {
if (!useSel || mesh.faceSel[i]) mesh.faces[i].smGroup = (DWORD)bits;
}
}
triOb->GetMesh().InvalidateTopologyCache();
triOb->UpdateValidity(TOPO_CHAN_NUM,valid);
}
}
void Water::SetSize(float f, TimeValue t, BOOL init) {
size = f;
// pblock->SetValue(PB_SIZE, t, f);
pblock->SetValue(water_size, t, f);
if (init) ReInit();
}
void Speckle::SetColor(int i, Color c, TimeValue t) {
col[i] = c;
// pblock->SetValue((i == 0) ? PB_COL1 : PB_COL2, t, c);
pblock->SetValue((i == 0) ? speckle_color1 : speckle_color2, t, c);
}
IParamBlock2* GetParamBlockByID(BlockID id) { return (mpParams->ID() == id) ? mpParams : NULL; } // return id'd ParamBlock
