コード例 #1
0
    void Awake()
    {
        try
        {
            // ensure the fbx wrapper is available
            bool bNeedRestart = false;
            if (MocapFbxWrapper.EnsureFbxWrapperAvailability(ref bNeedRestart))
            {
                bFbxAvailable = true;

                if (bNeedRestart)
                {
                    //KinectInterop.RestartLevel(gameObject, "MF");
                    return;
                }
            }
            else
            {
                throw new Exception("Fbx-Unity-Wrapper is not available!");
            }
        }
        catch (Exception ex)
        {
            Debug.LogError(ex.Message);
            Debug.LogException(ex);

            if (infoText != null)
            {
                infoText.GetComponent <GUIText>().text = ex.Message;
            }
        }
    }
コード例 #2
0
    // saves the specified fbx file
    private bool SaveFile()
    {
        if (saveFilePath == string.Empty)
        {
            saveFilePath = loadFilePath;
        }

        // delete the old csv file
        if (saveFilePath != string.Empty && File.Exists(saveFilePath))
        {
            File.Delete(saveFilePath);

#if UNITY_EDITOR
            UnityEditor.AssetDatabase.Refresh();             //.ImportAsset(saveFilePath);
#endif
        }

        if (saveFilePath != string.Empty)
        {
            if (MocapFbxWrapper.SaveFbxFile(saveFilePath, outputFileFormat))
            {
#if UNITY_EDITOR
                UnityEditor.AssetDatabase.Refresh();                  //.ImportAsset(saveFilePath);
#endif

                bFbxDirty = false;

                // play the animation
                AnimationPlayer animPlayer = AnimationPlayer.Instance;
                if (animPlayer)
                {
                    animPlayer.PlayAnimationClip(saveFilePath, animationName);
                }

                return(true);
            }
            else
            {
                Debug.LogError("Could not save mo-cap to: " + saveFilePath);
            }
        }

        return(false);
    }
コード例 #3
0
    // returns post-rotation of a joint (fbx node)
    private Quaternion GetJointPostRot(Transform jointTransform)
    {
        if (jointTransform != null)
        {
            string  sJointName = jointTransform.name;
            Vector3 vPostRot   = Vector3.zero;
            MocapFbxWrapper.GetNodePostRot(sJointName, ref vPostRot);

            Quaternion qPostRot = Quaternion.identity;
            MocapFbxWrapper.Rot2Quat(ref vPostRot, ref qPostRot);

            qPostRot.y = -qPostRot.y;
            qPostRot.z = -qPostRot.z;

            return(qPostRot);
        }

        return(Quaternion.identity);
    }
コード例 #4
0
    void OnDestroy()
    {
        // check if fbx-wrapper is available
        if (!bFbxAvailable)
        {
            return;
        }

        // finish recording, if needed
        isRecording = false;

        // save the fbx file, if needed
        if (!SaveFileIfNeeded())
        {
            //Debug.LogError("Could not save the modified fbx to: " + saveFilePath);
        }

        // terminate the fbx wrapper
        if (bFbxInited)
        {
            MocapFbxWrapper.TermFbxFrapper();
            bFbxInited = false;
        }
    }
コード例 #5
0
    void Start()
    {
        // check if fbx-wrapper is available
        if (!bFbxAvailable)
        {
            return;
        }

        try
        {
            // instantiate the avatar object from the fbx file
            if (LoadAvatarObject() && avatarObject)
            {
                avatarCtrl = avatarObject.gameObject.GetComponent <AvatarController>();
            }
            else
            {
                if (loadFilePath == string.Empty)
                {
                    throw new Exception("Please specify fbx-file to load.");
                }
                else
                {
                    throw new Exception("Cannot instantiate avatar from file: " + loadFilePath);
                }
            }

            // check the KinectManager availability
            if (!manager)
            {
                manager = KinectManager.Instance;
            }

            if (!manager)
            {
                throw new Exception("KinectManager not found, probably not initialized. See the log for details");
            }

            // initialize fbx wrapper
            if (!bFbxInited)
            {
                bFbxInited = MocapFbxWrapper.InitFbxWrapper();

                if (!bFbxInited)
                {
                    throw new Exception("Fbx wrapper could not be initialized.");
                }
            }

            if (infoText != null)
            {
                infoText.GetComponent <GUIText>().text = "Say: 'Record' to start the recorder.";
            }

            // play the animation
            AnimationPlayer animPlayer = AnimationPlayer.Instance;
            if (animPlayer)
            {
                animPlayer.PlayAnimationClip(saveFilePath, animationName);
            }

            if (recordAtStart)
            {
                StartRecording();
            }
        }
        catch (Exception ex)
        {
            Debug.LogError(ex.Message);
            Debug.LogException(ex);

            if (infoText != null)
            {
                infoText.GetComponent <GUIText>().text = ex.Message;
            }
        }
    }
コード例 #6
0
    // saves needed animation frames at the current save-time
    private bool SaveAnimFrame(int jointIndex, Transform jointTransform, StringBuilder sbDebug)
    {
        if (jointTransform == null)
        {
            return(false);
        }

        string sJointName = jointTransform.name;
        bool   bSuccess   = true;

        float fSaveTime = (float)iSavedFrame / fGlobalFps;

        if (jointIndex == 0 && !dontSaveRootPos)
        {
            // save avatar position
            Vector3 currentPos = jointTransform.position - initialPos;
            currentPos.x  = -currentPos.x;
            currentPos.y += initialPos.y;

            float distToLast = (currentPos - lastSavedPos[jointIndex]).magnitude;
            if (distToLast >= jointDistanceThreshold)
            {
                lastSavedPos[jointIndex] = currentPos;

                if (sbDebug != null)
                {
                    sbDebug.AppendFormat("{0}:{1:F2} ", jointIndex, distToLast);
                }

                Vector3 vJointPos = currentPos * fUnityScale * fFbxScale;
                bSuccess &= MocapFbxWrapper.SetAnimCurveTrans(sJointName, fSaveTime, ref vJointPos);
            }
        }

        // save joint orientation
        Quaternion qJointRot   = jointTransform.localRotation;
        float      angleToLast = Quaternion.Angle(lastSavedRot[jointIndex], qJointRot);

        if (angleToLast >= jointAngleThreshold)
        {
            lastSavedRot[jointIndex] = qJointRot;

            if (sbDebug != null)
            {
                sbDebug.AppendFormat("{0}:{1:F0} ", jointIndex, angleToLast);
            }

            if (alJointPreRots != null && alJointPostRots != null)
            {
                Quaternion qJointPreRot  = alJointPreRots[jointIndex];
                Quaternion qJointPostRot = alJointPostRots[jointIndex];

                qJointRot = Quaternion.Inverse(qJointPreRot) * qJointRot * Quaternion.Inverse(qJointPostRot);
            }

            qJointRot.x = -qJointRot.x;
            qJointRot.w = -qJointRot.w;

            Vector3 vJointRot = Vector3.zero;
            MocapFbxWrapper.Quat2Rot(ref qJointRot, ref vJointRot);

            bSuccess &= MocapFbxWrapper.SetAnimCurveRot(sJointName, fSaveTime, ref vJointRot);
        }

        if (iSavedFrame == 0)
        {
            // save the node scale in the first frame only
            Vector3 vJointScale = jointTransform.localScale;
            MocapFbxWrapper.SetAnimCurveScale(sJointName, 0f, ref vJointScale);
        }

        return(bSuccess);
    }
コード例 #7
0
    // ----- end of public functions -----


    // loads the specified fbx file
    private bool LoadFile()
    {
        if (!bFbxInited)
        {
            return(false);
        }

        if (!SaveFileIfNeeded())
        {
            throw new Exception("Could not save the modified file to: " + saveFilePath);
        }

        string sLoadFbxFile = loadFilePath;

        if (loadSaveFileIfExists && saveFilePath != string.Empty && File.Exists(saveFilePath))
        {
            sLoadFbxFile = saveFilePath;
        }

        if (sLoadFbxFile != string.Empty)
        {
            bFbxLoaded = MocapFbxWrapper.LoadFbxFile(sLoadFbxFile, false);
        }
        else
        {
            bFbxLoaded = false;
        }

        if (avatarCtrl && manager && manager.IsInitialized())
        {
            // get the pre- and post-rotations
            int jointCount = manager.GetJointCount();

            lastSavedPos = new Vector3[jointCount + 2];
            lastSavedRot = new Quaternion[jointCount + 2];

            for (int j = 0; j < (jointCount + 2); j++)
            {
                lastSavedPos [j] = Vector3.zero;
                lastSavedRot [j] = Quaternion.identity;
            }

            alJointPreRots  = new Quaternion[jointCount + 2];
            alJointPostRots = new Quaternion[jointCount + 2];

            for (int j = 0; j < jointCount; j++)
            {
                int       boneIndex      = avatarCtrl.GetBoneIndexByJoint((KinectInterop.JointType)j, false);
                Transform jointTransform = avatarCtrl.GetBoneTransform(boneIndex);

                alJointPreRots [j]  = GetJointPreRot(jointTransform);
                alJointPostRots [j] = GetJointPostRot(jointTransform);
            }

            // get special transforms
            int       specIndex     = avatarCtrl.GetSpecIndexByJoint(KinectInterop.JointType.ShoulderLeft, KinectInterop.JointType.SpineShoulder, false);
            Transform specTransform = avatarCtrl.GetBoneTransform(specIndex);
            alJointPreRots [jointCount]  = GetJointPreRot(specTransform);
            alJointPostRots [jointCount] = GetJointPostRot(specTransform);

            specIndex     = avatarCtrl.GetSpecIndexByJoint(KinectInterop.JointType.ShoulderRight, KinectInterop.JointType.SpineShoulder, false);
            specTransform = avatarCtrl.GetBoneTransform(specIndex);
            alJointPreRots [jointCount + 1]  = GetJointPreRot(specTransform);
            alJointPostRots [jointCount + 1] = GetJointPostRot(specTransform);
        }
        else
        {
            bFbxLoaded = false;
        }

        bFbxDirty = false;

        return(bFbxLoaded);
    }
コード例 #8
0
    // starts recording
    public bool StartRecording()
    {
        if (avatarObject == null)
        {
            return(false);
        }

        if (isRecording)
        {
            return(false);
        }

        isRecording = true;

        // load the fbx file
        if (!LoadFile())
        {
            isRecording = false;

            Debug.LogError("File could not be loaded: " + loadFilePath);
            if (infoText != null)
            {
                infoText.GetComponent <GUIText>().text = "File could not be loaded: " + loadFilePath;
            }
        }

        // check for save file name
        if (saveFilePath == string.Empty)
        {
            isRecording = false;

            Debug.LogError("No file to save.");
            if (infoText != null)
            {
                infoText.GetComponent <GUIText>().text = "No file to save.";
            }
        }

        // create the animation stack, if animation name is specified
        if (animationName != string.Empty && !MocapFbxWrapper.CreateAnimStack(animationName))
        {
            isRecording = false;

            //throw new Exception("Could not create animation: " + animationName);
            Debug.LogError("Could not create animation: " + animationName);
            if (infoText != null)
            {
                infoText.GetComponent <GUIText>().text = "Could not create animation: " + animationName;
            }
        }

        if (isRecording && animationName != string.Empty)
        {
            MocapFbxWrapper.SetCurrentAnimStack(animationName);
        }

        if (isRecording)
        {
            Debug.Log("Recording started.");
            if (infoText != null)
            {
                infoText.GetComponent <GUIText>().text = "Recording... Say 'Stop' to stop the recorder.";
            }

            // get initial avatar position
            if (avatarCtrl != null)
            {
                int       hipsIndex     = avatarCtrl.GetBoneIndexByJoint(KinectInterop.JointType.SpineBase, false);
                Transform hipsTransform = avatarCtrl.GetBoneTransform(hipsIndex);
                initialPos = hipsTransform != null ? hipsTransform.position : Vector3.zero;
            }

            // initialize times
            fStartTime    = fCurrentTime = Time.time;
            fMinFrameTime = maxFramesPerSecond > 0f ? 1f / maxFramesPerSecond : 0f;
            iSavedFrame   = 0;

            // get global time mode as fps
            fGlobalFps = MocapFbxWrapper.GetGlobalFps();

            // get global scale factor
            fFbxScale = 100f / MocapFbxWrapper.GetGlobalScaleFactor();

            // Unity scale factor
            fUnityScale = importScaleFactor != 0f ? 1f / importScaleFactor : 1f;
        }

        return(isRecording);
    }