示例#1
0
    private void _unpack_modeldef(byte[] payload, ref int offset, int[] version, out ModelDefs modeldef)
    {
        int ndatasets;

        _unpack_head <int>(payload, ref offset, out ndatasets);
        ArrayList datasets = new ArrayList();

        for (int i = 0; i < ndatasets; i++)
        {
            int dtype;
            _unpack_head <int>(payload, ref offset, out dtype);
            string       name;
            int          nmarkers;
            ModelDataset dset;
            ArrayList    mrk_names;
            if (dtype == DATASET_MARKERSET)
            {
                _unpack_cstring(payload, ref offset, MAX_NAMELENGTH, out name);
                _unpack_head <int>(payload, ref offset, out nmarkers);
                mrk_names = new ArrayList();
                for (int j = 0; j < nmarkers; j++)
                {
                    string mrk_name;
                    _unpack_cstring(payload, ref offset, MAX_NAMELENGTH, out mrk_name);
                    mrk_names.Add(mrk_name);
                }
                dset      = new ModelDataset();
                dset.type = DATASET_MARKERSET;
                dset.name = name;
                dset.data = mrk_names;
                datasets.Add(dset);
            }
            else if (dtype == DATASET_RIGIDBODY)
            {
                if (_version_is_at_least(version, 2, 0))
                {
                    _unpack_cstring(payload, ref offset, MAX_NAMELENGTH, out name);
                }
                else
                {
                    name = "";
                }
                int     rbid;
                int     parent;
                Vector3 pos_offset;
                _unpack_head <int>(payload, ref offset, out rbid);
                _unpack_head <int>(payload, ref offset, out parent);
                _unpack_head <Vector3>(payload, ref offset, out pos_offset);
                dset      = new ModelDataset();
                dset.type = DATASET_RIGIDBODY;
                dset.name = name;
                dset.data = new ArrayList();
                dset.data.Add(
                    new Dictionary <string, object>()
                {
                    { "id", rbid },
                    { "parent", parent },
                    { "offset", pos_offset }
                }
                    );
                datasets.Add(dset);
            }
            else if (dtype == DATASET_SKELETON)
            {
                _unpack_cstring(payload, ref offset, MAX_NAMELENGTH, out name);
                int    skid, nbodies;
                string bname;
                _unpack_head <int>(payload, ref offset, out skid);
                _unpack_head <int>(payload, ref offset, out nbodies);
                ArrayList bodies = new ArrayList();
                for (int j = 0; j < nbodies; j++)
                {
                    if (_version_is_at_least(version, 2, 0))
                    {
                        _unpack_cstring(payload, ref offset, MAX_NAMELENGTH, out bname);
                    }
                    else
                    {
                        bname = "";
                    }
                    int     rbid;
                    int     parent;
                    Vector3 pos_offset;
                    _unpack_head <int>(payload, ref offset, out rbid);
                    _unpack_head <int>(payload, ref offset, out parent);
                    _unpack_head <Vector3>(payload, ref offset, out pos_offset);
                    Dictionary <string, object> body = new Dictionary <string, object>()
                    {
                        { "id", rbid },
                        { "bname", bname },
                        { "parent", parent },
                        { "offset", pos_offset },
                        { "skid", skid }
                    };
                    bodies.Add(body);
                }
                dset      = new ModelDataset();
                dset.type = DATASET_SKELETON;
                dset.name = name;
                dset.data = bodies;
                datasets.Add(dset);
            }
            else
            {
                Debug.Log("Noo implemented Error-- dataset type" + dtype);
            }
        }
        modeldef          = new ModelDefs();
        modeldef.datasets = datasets;
    }
示例#2
0
 public void commandRead()
 {
     try
     {
         int bytesReceived = mCommandListner.Receive(mCommandReceiveBuffer);
         if (bytesReceived == 0)
         {
             return;
         }
         object msg;
         int    msgtype;
         int    offset = 0;
         unpack(mCommandReceiveBuffer, ref offset, out msg, out msgtype, versionNumbers);
         if (msgtype == NAT_FRAMEOFDATA)
         {
             //Debug.Log("command.. frame of data");
             lock (syncLock){
                 dataBufferHead++;
                 if (dataBufferHead >= dataBufferSize)
                 {
                     dataBufferHead = 0;
                 }
                 dataBuffer[dataBufferHead] = (FrameOfData)msg;
             }
         }
         else if (msgtype == NAT_MODELDEF)
         {
             Debug.Log("command... model def");
             lock (syncLock){
                 ModelDefs modelDef = (ModelDefs)msg;
                 markerSetIDtoName.Clear();
                 rigidBodyIDtoName.Clear();
                 skeletonIDtoName.Clear();
                 boneIDtoName.Clear();
                 foreach (ModelDataset dataset in modelDef.datasets)
                 {
                     if (dataset.type == DATASET_MARKERSET)
                     {
                         Dictionary <int, string> setDict = null;
                         if (!markerSetIDtoName.TryGetValue(dataset.name, out setDict))
                         {
                             setDict = new Dictionary <int, string>();
                             markerSetIDtoName[dataset.name] = setDict;
                         }
                         int i = 0;
                         foreach (string name in dataset.data)
                         {
                             setDict[i] = name;
                             i++;
                         }
                     }
                     else if (dataset.type == DATASET_RIGIDBODY)
                     {
                         foreach (Dictionary <string, object> rb in dataset.data)
                         {
                             rigidBodyIDtoName[(int)rb["id"]] = dataset.name;
                         }
                     }
                     else if (dataset.type == DATASET_SKELETON)
                     {
                         foreach (Dictionary <string, object> sk in dataset.data)
                         {
                             Dictionary <int, string> skDict = null;
                             int skid = (int)sk["skid"];
                             if (!boneIDtoName.TryGetValue(skid, out skDict))
                             {
                                 skDict             = new Dictionary <int, string>();
                                 boneIDtoName[skid] = skDict;
                             }
                             int boneID = (int)sk["id"];
                             skDict[boneID]         = (string)sk["bname"];
                             skeletonIDtoName[skid] = dataset.name;
                         }
                     }
                     else
                     {
                     }
                 }
             }
             modelDefUpdated = true;
         }
         else if (msgtype == NAT_PINGRESPONSE)
         {
             Debug.Log("Received NatNet server ping response.");
         }
         else
         {
             //TODO: parse the other types
         }
     }
     catch (System.Exception ex)
     {
     }
 }