void MeshExporter::_dumpAnimation(IGameControl * pGameControl, int boneId) { int start = ExportConfig::Instance()->GetFrameRange().x; int end = ExportConfig::Instance()->GetFrameRange().y; start *= GetTicksPerFrame(); end *= GetTicksPerFrame(); if ((pGameControl->IsAnimated(IGAME_POS)) || pGameControl->IsAnimated(IGAME_ROT) || pGameControl->IsAnimated(IGAME_SCALE)) { IGameKeyTab Key; if(pGameControl->GetFullSampledKeys(Key, 1, IGAME_TM, true) ) { SkeletonAnimation * skelAnim = new SkeletonAnimation(boneId); int count = Key.Count(); for(int i=0;i<count;i++) { if (Key[i].t >= start && Key[i].t <= end) { float time = (float)Key[i].t / (float)GetTicksPerFrame() / (float)GetFrameRate(); SkeletonAnimation::KeyFrame * kf = skelAnim->CreateKeyFrame(time); kf->position = Utility::ToFloat3(Key[i].sampleKey.gval.Translation()); kf->rotation = Utility::ToQuat(Key[i].sampleKey.gval.Rotation()); kf->scale = Utility::ToFloat3(Key[i].sampleKey.gval.Scaling()); } } skelAnim->Optimize(); _getAnimation()->AddSkeletonAnimation(skelAnim); } } }
//called every frame. Here we set up the target paramters so that they //can be used by each node passed into the perform function. void FormationBhvr::InitAtThisTime(TimeValue t) { INode *leaderNode = GetLeader(t); if(leaderNode) { if(prevPosTime==TIME_NegInfinity||prevPosTime != t - GetTicksPerFrame()) { //get the right leaderPrevPos. leaderPrevPos = GetCurrentMatrix(leaderNode,t-GetTicksPerFrame()).GetTrans(); } leaderPos = GetCurrentMatrix(leaderNode,t).GetTrans(); leaderVel = leaderPos - leaderPrevPos;//use the preivous position to get the velocity. leaderSpeed = leaderVel.FLength(); //normalize the velocity. if(leaderSpeed!=0.0f) leaderVel /= leaderSpeed; else { leaderVel.x = leaderVel.y = leaderVel.z = 0.0f; } //set up the previous for the next time. leaderPrevPos = leaderPos; prevPosTime = t; } }
/* ==================== exportAnimation ==================== */ void G3DAExport::exportAnimation(NODE* node) { // get the animation if(node->include) { int first_frame = mStart/GetTicksPerFrame(); int last_frame = mEnd/GetTicksPerFrame(); for(int i = first_frame; i <= last_frame; i++) { // does this node have a max node? TimeValue t = i*GetTicksPerFrame(); Matrix3 m(true); if(node->parent) { m = GetTransform(node, t) * Inverse(GetTransform(node->parent, t)); } else { m = GetTransform(node, t); } // add the transform to the sequence node->sequence.push_back(m); } mNodeCount++; } // process the child node for(int i = 0; i < node->children.size(); i++) { exportAnimation(node->children[i]); } }
bool bgGlobalMax::Initialize(Interface* p3DMax) { m_p3DMax = p3DMax; m_pRootNode = p3DMax->GetRootNode(); if (m_p3DMax == NULL && m_pRootNode == NULL) return false; if (CheckFile(m_p3DMax) == false) return true; m_Interval = m_p3DMax->GetAnimRange(); memset(&m_Scene, 0, sizeof(m_Scene)); m_Scene.iVersion = 100; m_Scene.iFirstFrame = m_Interval.Start() / GetTicksPerFrame(); m_Scene.iLastFrame = m_Interval.End() / GetTicksPerFrame(); m_Scene.iFrameSpeed = GetFrameRate(); m_Scene.iTickPerFrame = GetTicksPerFrame(); PreProcess(m_pRootNode); m_Scene.iNumMesh = m_MatrixMap.Count(); m_Scene.iMaxWeight = 1; return true; }
// Dialog proc static INT_PTR CALLBACK ExportDlgProc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam) { Interval animRange; ISpinnerControl *spin; AscOut *exp = (AscOut*)GetWindowLongPtr(hWnd,GWLP_USERDATA); switch (msg) { case WM_INITDIALOG: exp = (AscOut*)lParam; SetWindowLongPtr(hWnd,GWLP_USERDATA,lParam); CenterWindow(hWnd, GetParent(hWnd)); // Setup the spinner controls for the floating point precision spin = GetISpinner(GetDlgItem(hWnd, IDC_PREC_SPIN)); spin->LinkToEdit(GetDlgItem(hWnd,IDC_PREC), EDITTYPE_INT ); spin->SetLimits(1, 10, TRUE); spin->SetScale(1.0f); spin->SetValue(exp->GetPrecision() ,FALSE); ReleaseISpinner(spin); // Setup the spinner control for the static frame# // We take the frame 0 as the default value animRange = exp->GetInterface()->GetAnimRange(); spin = GetISpinner(GetDlgItem(hWnd, IDC_STATIC_FRAME_SPIN)); spin->LinkToEdit(GetDlgItem(hWnd,IDC_STATIC_FRAME), EDITTYPE_INT ); spin->SetLimits(animRange.Start() / GetTicksPerFrame(), animRange.End() / GetTicksPerFrame(), TRUE); spin->SetScale(1.0f); spin->SetValue(0, FALSE); ReleaseISpinner(spin); break; case CC_SPINNER_CHANGE: spin = (ISpinnerControl*)lParam; break; case WM_COMMAND: switch (LOWORD(wParam)) { case IDOK: spin = GetISpinner(GetDlgItem(hWnd, IDC_PREC_SPIN)); exp->SetPrecision(spin->GetIVal()); ReleaseISpinner(spin); spin = GetISpinner(GetDlgItem(hWnd, IDC_STATIC_FRAME_SPIN)); exp->SetStaticFrame(spin->GetIVal() * GetTicksPerFrame()); ReleaseISpinner(spin); EndDialog(hWnd, 1); break; case IDCANCEL: EndDialog(hWnd, 0); break; } break; default: return FALSE; } return TRUE; }
INT_PTR CALLBACK TrackPropDlgProc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam) { BlockControl *blk = (BlockControl*)GetWindowLongPtr(hWnd,GWLP_USERDATA); ISpinnerControl *spin; static TSTR zero = FormatUniverseValue(0.0f); Rect rect; switch (msg) { case WM_INITDIALOG: { blk = (BlockControl*)lParam; SetWindowLongPtr(hWnd,GWLP_USERDATA,lParam); Interval range = GetCOREInterface()->GetAnimRange(); spin = GetISpinner(GetDlgItem(hWnd,IDC_STARTSPIN)); spin->SetLimits(-999999.0f,9999999.0f, FALSE); spin->SetAutoScale(); spin->LinkToEdit(GetDlgItem(hWnd,IDC_START), EDITTYPE_INT); spin->SetValue(range.Start()/GetTicksPerFrame(),FALSE); ReleaseISpinner(spin); blk->propStart = range.Start()/GetTicksPerFrame(); CenterWindow(hWnd,GetParent(hWnd)); break; } case CC_SPINNER_CHANGE: spin = (ISpinnerControl*)lParam; switch (LOWORD(wParam)) { case IDC_STARTSPIN: blk->propStart = spin->GetIVal(); break; } break; case WM_COMMAND: switch (LOWORD(wParam)) { case IDOK: { EndDialog(hWnd,1); blk->NotifyDependents(FOREVER, PART_ALL, REFMSG_CHANGE); break; } case IDCANCEL: EndDialog(hWnd,0); break; } break; default: return FALSE; } return TRUE; }
// SAMPLENODEMOTION // sample all the motion on a single node // intended for use in the context of a full tree traversal plSampleVec * SampleNodeMotion(INode * node, INode* parent, int sampleRate, TimeValue start, TimeValue end) { plSampleVec *result = new plSampleVec; bool done = false; for(int i = start; ! done; i += sampleRate) { if (i > end) i = end; if (i == end) done = true; // Get key time TimeValue keyTime = i; int frameNum= keyTime / GetTicksPerFrame(); // get localTM nodeTMInfo * nti = new nodeTMInfo; nti->fTime = keyTime; Matrix3 localTM = node->GetNodeTM(keyTime); nti->fMat3 = localTM; result->push_back(nti); } return result; }
//+--------------------------------------------------------------------------+ //| From IPViewItem | //+--------------------------------------------------------------------------+ bool PFTestGoToRotation::HasDynamicName(TSTR& nameSuffix) { int type = pblock()->GetInt(kGoToRotation_syncBy, 0); switch(type) { case kGoToRotation_syncBy_time: nameSuffix = GetString(IDS_TIME); break; case kGoToRotation_syncBy_age: nameSuffix = GetString(IDS_AGE); break; case kGoToRotation_syncBy_event: nameSuffix = GetString(IDS_EVENT); break; } nameSuffix += _T(" "); int tpf = GetTicksPerFrame(); TimeValue time = pblock()->GetTimeValue(kGoToRotation_time, 0)/tpf; TCHAR buf[32]; _stprintf(buf, _T("%d"), time); nameSuffix += buf; TimeValue variation = pblock()->GetTimeValue(kGoToRotation_variation, 0)/tpf; if (variation > 0) { _tcscpy(buf, GetString(IDS_PLUS_OR_MINUS_CHAR)); nameSuffix += buf; _stprintf(buf, _T("%d"), variation); nameSuffix += buf; } return true; }
int Plate::DoThisFrame(TimeValue t, BOOL fieldRender, TimeValue mapTime) { if (!do_nth) return 0; // only do it once. if (nth==1) return 1; // need every one TimeValue del = abs(t - mapTime); if (fieldRender) del*=2; return (del>=nth*GetTicksPerFrame())?1:0; }
void CSkeletonActionExpDlg::OnBnClickedActionAdd() { // TODO: Add your control notification handler code here sActionInfo_t action; UpdateData(); action.m_ActionType = GetActionType(); action.m_iFirstFrame = m_iStartFrame; action.m_iLastFrame = m_EndFrame; action.m_lTime = m_iDurationTime; if(m_iDurationTime == 0) { int tickt_per_frame = GetTicksPerFrame(); int iMaxTime = (m_EndFrame - m_iStartFrame + 1 ) * tickt_per_frame; float vTime = CMaxEnv::singleton().TicksToSeconds(iMaxTime); action.m_lTime = vTime * 1000; m_iDurationTime = action.m_lTime; } WGetWndText(&m_ctrlActionName , action.m_Name,32); if(wcslen(action.m_Name) == 0) { ::MessageBoxA(::GetActiveWindow(),"请填写动作名字","错误",MB_OK); return ; } if(m_iDurationTime <= 0) { ::MessageBoxA(::GetActiveWindow(),"动作时间不能为0","错误",MB_OK); return ; } InsertAction(action, true); }
//+>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>+ //| From PFOperatorMaterialStatic | //+>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>+ PFOperatorMaterialStatic::PFOperatorMaterialStatic() { _dadMgr() = new PFOperatorMaterialStaticDADMgr(this); GetClassDesc()->MakeAutoParamBlocks(this); // set the initial value for sub-mtls rate to the number of frames per second pblock()->SetValue(kMaterialStatic_ratePerSecond, 0, float(TIME_TICKSPERSEC)/GetTicksPerFrame() ); _material() = NULL; }
void ForceObject::SetUpModifier(TimeValue t,INode *node) { mf->force.obj = (ForceObject*)(mf->GetWSMObject(t)); mf->force.node = mf->nodeRef; mf->force.tmValid.SetEmpty(); mf->force.fValid.SetEmpty(); mf->force.dt = GetTicksPerFrame(); mf->force.dtsq = mf->force.dt * mf->force.dt; }
ForceField *PinObject::GetForceField(INode *node) { PinField *pb = new PinField; pb->obj = this; pb->node = node; pb->tmValid.SetEmpty(); pb->fValid.SetEmpty(); pb->dt=GetTicksPerFrame(); pb->dtsq=pb->dt*pb->dt; return pb; }
// SAMPLENODEMOTION // top level function for sampling all the motion on a single node plSampleVec * SampleNodeMotion(INode* node, INode* parent, int sampleRate, Interface *theInterface) { Interval interval = theInterface->GetAnimRange(); TimeValue start = interval.Start(); // in ticks TimeValue end = interval.End(); sampleRate *= GetTicksPerFrame(); // convert sample rate to ticks return SampleNodeMotion(node, parent, sampleRate, start, end); }
void PinMod::ModifyObject(TimeValue t, ModContext &mc, ObjectState *os, INode *node) { ParticleObject *obj = GetParticleInterface(os->obj); if (obj) { force.obj=(PinObject*)GetWSMObject(t); force.node=nodeRef; force.tmValid.SetEmpty(); force.fValid.SetEmpty(); force.dt=GetTicksPerFrame(); force.dtsq=force.dt*force.dt; obj->ApplyForceField(&force); //ok } }
void Import::SetSceneParameters() { Interval range; range.SetStart(0); range.SetEnd(30); SetFrameRate(30); SetTicksPerFrame(160); range.SetStart(range.Start() * GetTicksPerFrame()); range.SetEnd(range.End() * GetTicksPerFrame()); m_ip->SetAnimRange(range); Point3 bkColor (0.0f, 0.0f, 0.0f); m_impip->SetBackGround(0, bkColor); Point3 amColor (0.3f, 0.3f, 0.3f); m_impip->SetAmbient(0, amColor); }
BOOL bgAnimMax::CheckForAnimation(INode* pNode, BOOL& bPos, BOOL& bRot, BOOL& bScl) { AffineParts ap; Point3 firstPos, firstRotAxis, firstScaleFactor; Point3 rotAxis; float firstRotAngle; float rotAngle; GetDecompAffine(m_Interval.Start(), pNode, &ap, &firstRotAxis, &firstRotAngle); firstPos = ap.t; firstScaleFactor = ap.k; TimeValue start = m_Interval.Start() + GetTicksPerFrame(); TimeValue end = m_Interval.End(); bPos = bRot = bScl = FALSE; for (TimeValue t = start; t <= end; t += m_iDeltaTick) { GetDecompAffine(t, pNode, &ap, &rotAxis, &rotAngle); if (!bPos) { if (!EqualPoint3(ap.t, firstPos)) { bPos = TRUE; } } if (!bRot) { if (fabs(rotAngle - firstRotAngle) > ALMOST_ZERO) { bRot = TRUE; } else if (!EqualPoint3(rotAxis, firstRotAxis)) { bRot = TRUE; } } if (!bScl) { if (!EqualPoint3(ap.k, firstScaleFactor)) { bScl = TRUE; } } if (bPos && bRot && bScl) break; } return bPos || bRot || bScl; }
// ########################################################### // ####### EXPORTERs DI SINGOLE ENTITA' DELLA SCENA ####### // ########################################################### void SkeletonExporter::export_general_info(void) { int ff, lf, fs; Interval range = ip->GetAnimRange(); Box3 bbox; fprintf(fTXT, "[AD]Turbo ROX as usual !! \n\n"); INode *root = ip->GetRootNode(); bbox.pmin.x=bbox.pmin.y=bbox.pmin.z=(float)1E10; bbox.pmax.x=bbox.pmax.y=bbox.pmax.z=(float)-1E10; GetSceneBoundingBox(root, 0, &bbox); ff=range.Start() / GetTicksPerFrame(); lf=range.End() / GetTicksPerFrame(); fs=GetFrameRate(); // Start with a file identifier and format version fprintf(fTXT, "First frame : %d\n", ff); fprintf(fTXT, "Last frame : %d\n", lf); fprintf(fTXT, "Frame speed : %d\n", fs); fprintf(fTXT, "Scene Bounding Box at time 0\n"); fprintf(fTXT, "min : %f, %f, %f\n", bbox.pmin.x, bbox.pmin.y, bbox.pmin.z); fprintf(fTXT, "max : %f, %f, %f\n", bbox.pmax.x, bbox.pmax.y, bbox.pmax.z); write_chunk_header(fA3D, SCENE_GENERAL_INFO_ID, "Scene Root", 36); fwrite(&ff, sizeof(int), 1, fA3D); fwrite(&lf, sizeof(int), 1, fA3D); fwrite(&fs, sizeof(int), 1, fA3D); write_bbox(&bbox, fA3D); if (makeRAY) write_chunk_header(fRAY, SCENE_GENERAL_INFO_ID, "Scene Root", 36); if (makeRAY) fwrite(&ff, sizeof(int), 1, fRAY); if (makeRAY) fwrite(&lf, sizeof(int), 1, fRAY); if (makeRAY) fwrite(&fs, sizeof(int), 1, fRAY); if (makeRAY) write_bbox(&bbox, fRAY); }
int plLayerTex::ICalcFrame(TimeValue t) { PBBitmap *pbbm = fBitmapPB->GetBitmap(kBmpBitmap); if (!pbbm || !pbbm->bi) return 0; BitmapInfo *bi = pbbm->bi; TimeValue tm, dur, td; int frameStart = bi->FirstFrame(); int frameEnd = bi->LastFrame(); int tpf = GetTicksPerFrame(); tm = TimeValue(float(t - startTime) * pbRate); dur = (fend-fstart+1)*GetTicksPerFrame(); switch (endCond) { case END_HOLD: if (tm <= 0) return frameStart; if (tm >= dur) return frameEnd; return tm/tpf; case END_PINGPONG: if (((tm >= 0) && ((tm / dur) & 1)) || ((tm < 0) && !(tm / dur))) { td = modt(tm, dur); return frameStart + frameEnd - td / tpf; } // else fall through case END_LOOP: td = modt(tm, dur); return td / tpf; } return 0; }
void PBombMod::ModifyObject( TimeValue t, ModContext &mc, ObjectState *os, INode *node) { ParticleObject *obj = GetParticleInterface(os->obj); if (obj) { /* if (!mc.localdata) { mc.localdata=seed; seed+=5;} */ force.obj = (PBombObject*)GetWSMObject(t); force.node = nodeRef; force.tmValid.SetEmpty(); force.fValid.SetEmpty(); force.dt=GetTicksPerFrame(); force.dtsq=force.dt*force.dt; obj->ApplyForceField(&force); } }
SWrapObject::SWrapObject() { TimeValue tpf=GetTicksPerFrame(); MakeRefByID(FOREVER, 0, CreateParameterBlock(SWrapdescVer0, PBLOCK_LENGTH, CURRENT_VERSION)); assert(pblock); cmValid.SetEmpty(); srand(12345); custname=TSTR(_T(" ")); custnode=NULL; cmesh=NULL; tm.IdentityMatrix(); vnorms.ZeroCount(); fnorms.ZeroCount(); pblock->SetValue(PB_KIDEFAULT,0,0.0f); pblock->SetValue(PB_USESELVERTS,0,0); pblock->SetValue(PB_STANDOFF,0,1.0f); }
void AsciiExp::DumpRotSample(INode* node, int indentLevel) { TSTR indent = GetIndent(indentLevel); _ftprintf(pStream, _T("%s\t\t%s {\n"), indent.data(), ID_ROT_TRACK); TimeValue start = ip->GetAnimRange().Start(); TimeValue end = ip->GetAnimRange().End(); TimeValue t; int delta = GetTicksPerFrame() * GetKeyFrameStep(); Matrix3 tm; AffineParts ap; Quat prevQ; prevQ.Identity(); for (t=start; t<=end; t+=delta) { tm = node->GetNodeTM(t) * Inverse(node->GetParentTM(t)); decomp_affine(tm, &ap); // Rotation keys should be relative, so we need to convert these // absolute samples to relative values. Quat q = ap.q / prevQ; prevQ = ap.q; if (q.IsIdentity()) { // No point in exporting null keys... continue; } // Output the sample _ftprintf(pStream, _T("%s\t\t\t%s %d\t%s\n"), indent.data(), ID_ROT_SAMPLE, t, Format(q)); } _ftprintf(pStream, _T("%s\t\t}\n"), indent.data()); }
BOOL SmdExportClass::DumpRotations(FILE *pFile, ExpInterface *pexpiface) { // Dump bone-rotation info, for each frame // Also dumps root-node translation info (the model's world-position at each frame) DumpFrameRotationsTEP procDumpFrameRotations; procDumpFrameRotations.m_pfile = pFile; procDumpFrameRotations.m_phec = this; TimeValue m_tvTill = (m_fReferenceFrame) ? m_tvStart : m_tvEnd; fprintf(pFile, "skeleton\n" ); for (TimeValue tv = m_tvStart; tv <= m_tvTill; tv += m_tpf) { fprintf(pFile, "time %d\n", tv / GetTicksPerFrame() ); procDumpFrameRotations.m_tvToDump = tv; (void) pexpiface->theScene->EnumTree(&procDumpFrameRotations); } fprintf(pFile, "end\n" ); return TRUE; }
//from IUnReplaceableControl Control * EulerExposeControl::GetReplacementClone() { Control *control = NewDefaultRotationController(); if(control) { // set key per frame Interval range =GetCOREInterface()->GetAnimRange(); TimeValue tpf = GetTicksPerFrame(); SuspendAnimate(); AnimateOn(); Quat v; for(TimeValue t= range.Start(); t<=range.End();t+=tpf) { GetValue(t,&v,Interval(t,t)); control->SetValue(t,&v,1,CTRL_ABSOLUTE); } ResumeAnimate(); } return control; }
/** * This method will check if there is any animation connected to the node. * It will run from start to end of animation range and if the position, * rotation or scale has been changed during this, it will return true. */ BOOL OSGExp::hasAnimation(INode* node){ TimeValue start = _ip->GetAnimRange().Start(); TimeValue end = _ip->GetAnimRange().End(); TimeValue t; int delta = GetTicksPerFrame(); Matrix3 tm; AffineParts ap; Point3 firstPos; float rotAngle, firstRotAngle; Point3 rotAxis, firstRotAxis; Point3 firstScaleFactor; //return TRUE; for (t=start; t<=end; t+=delta) { tm = node->GetNodeTM(t) * Inverse(node->GetParentTM(t)); decomp_affine(tm, &ap); AngAxisFromQ(ap.q, &rotAngle, rotAxis); // If any point, rotation or scale in the t'th frame has // changes from the start frame then we have an animation. if (t != start){ if(!Util::isPoint3Equal(ap.t, firstPos) || !Util::isPoint3Equal(rotAxis, firstRotAxis) || fabs(rotAngle - firstRotAngle) > ALMOST_ZERO || !Util::isPoint3Equal(ap.k, firstScaleFactor)){ return TRUE; } } else { firstPos = ap.t; firstRotAngle = rotAngle; firstRotAxis = rotAxis; firstScaleFactor = ap.k; } } return FALSE; }
/** * This method will sample the node at each frame to get any possible change * of position, rotation and scaling. The posible changes is inserted into an * OSG AnimationPath and returned. */ osg::AnimationPath* OSGExp::sampleNode(INode* node){ // Create the animation path. osg::AnimationPath* animationPath = new osg::AnimationPath(); animationPath->setLoopMode(osg::AnimationPath::LOOP); TimeValue start = _ip->GetAnimRange().Start(); TimeValue end = _ip->GetAnimRange().End(); int val; if (node->GetUserPropInt("startFrame",val)) start= val; if (node->GetUserPropInt("endFrame",val)) end= val; TimeValue t; int delta = GetTicksPerFrame(); Matrix3 tm; AffineParts ap; for (t=start; t<=end; t+=delta) { tm = node->GetNodeTM(t) * Inverse(node->GetParentTM(t)); decomp_affine(tm, &ap); Point3 pos = ap.t; Point3 sca = ap.k; // Note: OSG wants absolute rotations Quat rot = ap.q; // Convert from Max's left-handed rotation to right-handed float ang; Point3 axis; AngAxisFromQ(rot, &ang, axis); ang = -ang; rot = QFromAngAxis(ang, axis); // Insert the sample point into animation path addControlPoint(animationPath, (t/(float)TIME_TICKSPERSEC), pos, rot, sca); } return animationPath; }
void Exporter::ExportCameraObject(INode* node, int indentLevel) { RSCameraObject *pCO=new RSCameraObject; pCO->name=new char[strlen(node->GetName())+1]; strcpy(pCO->name,node->GetName()); INode* target = node->GetTarget(); ExportNodeTM(node, indentLevel,&pCO->tm); CameraState cs; TimeValue t = GetStaticFrame(); Interval valid = FOREVER; // Get animation range Interval animRange = ip->GetAnimRange(); ObjectState os = node->EvalWorldState(t); CameraObject *cam = (CameraObject *)os.obj; cam->EvalCameraState(t,valid,&cs); pCO->fov=cs.fov; #define TARGETFPS 60 TimeValue start = ip->GetAnimRange().Start(); TimeValue end = ip->GetAnimRange().End(); int delta = GetTicksPerFrame() * GetFrameRate() / TARGETFPS; Matrix3 tm; rsm->m_nCameraFrame=(end-start)/delta+1; Matrix3 *m=pCO->am=new Matrix3[rsm->m_nCameraFrame]; for (t=start; t<=end; t+=delta) { tm = node->GetNodeTM(t) * Inverse(node->GetParentTM(t)); *m=tm; m++; } rsm->m_CameraList.Add(pCO); }
void UtilTest::SetWAV() { // Get the current sound object. SoundObj *snd = ip->GetSoundObject(); // See if we can get a wave interface IWaveSound *iWav = GetWaveSoundInterface(snd); if (iWav) { // Set the sound file if (!iWav->SetSoundFileName(_T("test.wav"))) { MessageBox(hPanel, _T("Unable to load TEST.WAV"), _T("Util Test"),MB_OK); return; } // Set the offset to 10 frames. iWav->SetStartTime(GetTicksPerFrame() * 10); } else { MessageBox(hPanel, _T("No IWaveSound interface"), _T("Util Test"),MB_OK); } }
void AsciiExp::DumpPosSample(INode* node, int indentLevel) { TSTR indent = GetIndent(indentLevel); _ftprintf(pStream, _T("%s\t\t%s {\n"), indent.data(), ID_POS_TRACK); TimeValue start = ip->GetAnimRange().Start(); TimeValue end = ip->GetAnimRange().End(); TimeValue t; int delta = GetTicksPerFrame() * GetKeyFrameStep(); Matrix3 tm; AffineParts ap; Point3 prevPos; for (t=start; t<=end; t+=delta) { tm = node->GetNodeTM(t) * Inverse(node->GetParentTM(t)); decomp_affine(tm, &ap); Point3 pos = ap.t; if (t!= start && EqualPoint3(pos, prevPos)) { // Skip identical keys continue; } prevPos = pos; // Output the sample _ftprintf(pStream, _T("%s\t\t\t%s %d\t%s\n"), indent.data(), ID_POS_SAMPLE, t, Format(pos)); } _ftprintf(pStream, _T("%s\t\t}\n"), indent.data()); }
//+--------------------------------------------------------------------------+ //| From IPViewItem | //+--------------------------------------------------------------------------+ bool PFTestDuration::HasDynamicName(TSTR& nameSuffix) { int testType = pblock()->GetInt(kDuration_testType, 0); switch(testType) { case kDuration_testType_time: // nameSuffix = GetString(IDS_ABSOLUTE_ABBR); nameSuffix = GetString(IDS_TIME); break; case kDuration_testType_age: nameSuffix = GetString(IDS_AGE); break; case kDuration_testType_event: nameSuffix = GetString(IDS_EVENT); break; } int condType = pblock()->GetInt(kDuration_conditionType, 0); if (condType == kDuration_conditionType_less) nameSuffix += _T("<"); else nameSuffix += _T(">"); TimeValue testValue = pblock()->GetTimeValue(kDuration_testValue, 0); int tpf = GetTicksPerFrame(); testValue /= tpf; TCHAR buf[32]; _stprintf(buf, _T("%d"), testValue); nameSuffix += buf; TimeValue variation = pblock()->GetTimeValue(kDuration_variation, 0); variation /= tpf; if (variation > 0) { _tcscpy(buf, GetString(IDS_PLUS_OR_MINUS_CHAR)); nameSuffix += buf; _stprintf(buf, _T("%d"), variation); nameSuffix += buf; } return true; }