예제 #1
0
        public void calculateTransformedVertex(int vertexIndex)
        {
            if (!FSkinWeights.ContainsKey(vertexIndex))
            {
                return;
            }
            IDictionaryEnumerator influenceEnum = FSkinWeights[vertexIndex].GetEnumerator();

            Matrix4x4 jointTransform;

            while (influenceEnum.MoveNext())
            {
                FJointTransformsInput.GetMatrix((int)influenceEnum.Key, out jointTransform);
                FVertTransformed[vertexIndex] = (Vector3D)FVertTransformed[vertexIndex] + (double)influenceEnum.Value * (jointTransform * (Vector3D)FVertices[vertexIndex]);
            }
        }
예제 #2
0
        //here we go, thats the method called by vvvv each frame
        //all data handling should be in here
        public void Evaluate(int SpreadMax)
        {
            //if any of the inputs has changed
            //recompute the outputs
            if (FTransformInput.PinIsChanged || FP1Input.PinIsChanged ||
                FP2Input.PinIsChanged || FP3Input.PinIsChanged || FP4Input.PinIsChanged)
            {
                //first set slicecounts for all outputs
                //the incoming int SpreadMax is the maximum slicecount of all input pins, which is a good default
                FTransformOutput.SliceCount = SpreadMax;

                //the variables to fill with the input data
                Matrix4x4 matrixSlice;
                Vector4D  p1Slice;
                Vector4D  p2Slice;
                Vector4D  p3Slice;
                Vector4D  p4Slice;

                //loop for all slices
                for (int i = 0; i < SpreadMax; i++)
                {
                    //read data from inputs
                    FTransformInput.GetMatrix(i, out matrixSlice);
                    FP1Input.GetValue4D(i, out p1Slice.x, out p1Slice.y, out p1Slice.z, out p1Slice.w);
                    FP2Input.GetValue4D(i, out p2Slice.x, out p2Slice.y, out p2Slice.z, out p2Slice.w);
                    FP3Input.GetValue4D(i, out p3Slice.x, out p3Slice.y, out p3Slice.z, out p3Slice.w);
                    FP4Input.GetValue4D(i, out p4Slice.x, out p4Slice.y, out p4Slice.z, out p4Slice.w);

                    //function per slice
                    matrixSlice = VMath.BilerpMatrix(p1Slice, p2Slice, p4Slice, p3Slice) * matrixSlice;

                    //write data to outputs
                    FTransformOutput.SetMatrix(i, matrixSlice);
                }
            }
        }
예제 #3
0
        //here we go, thats the method called by vvvv each frame
        //all data handling should be in here
        public void Evaluate(int SpreadMax)
        {
            //if any of the inputs has changed
            //recompute the outputs
            if (FJointNameInput.PinIsChanged)
            {
                string name;
                FJointNameInput.GetString(0, out name);
                if (!string.IsNullOrEmpty(name))
                {
                    FRootJoint.Name = name;
                    FSkeleton.BuildJointTable();
                    FSkeletonOutput.MarkPinAsChanged();
                }
            }

            if (FChildPins.Any(c => c.PinIsChanged))
            {
                FSkeleton.ClearAll();
                FSkeleton.Root = FRootJoint;
                FSkeleton.BuildJointTable();

                for (int i = 0; i < FChildPins.Count; i++)
                {
                    if (true)             //childPinsList[i].PinIsChanged)
                    {
                        FSkeletonOutput.MarkPinAsChanged();
                        if (FChildPins[i].IsConnected)
                        {
                            object currInterface;
                            FChildPins[i].GetUpstreamInterface(out currInterface);
                            ISkeleton subSkeleton = (ISkeleton)currInterface;
                            IJoint    child       = subSkeleton.Root.DeepCopy();
                            FSkeleton.InsertJoint(FSkeleton.Root.Name, child);
                            FSkeleton.BuildJointTable();
                        }
                    }
                }

                // re-calculate the IDs ...
                int currId = 0;
                foreach (KeyValuePair <string, IJoint> pair in FSkeleton.JointTable)
                {
                    pair.Value.Id = currId;
                    currId++;
                }
            }

            if (FBaseTransformInput.PinIsChanged)
            {
                Matrix4x4 baseTransform;
                FBaseTransformInput.GetMatrix(0, out baseTransform);
                FRootJoint.BaseTransform = baseTransform;
                FSkeletonOutput.MarkPinAsChanged();
            }

            if (FRotationConstraintsInput.PinIsChanged)
            {
                FRootJoint.Constraints.Clear();
                for (int i = 0; i < 3; i++)
                {
                    double from, to;
                    FRotationConstraintsInput.GetValue2D(i, out from, out to);
                    FRootJoint.Constraints.Add(new Vector2D(from, to));
                }
                FSkeletonOutput.MarkPinAsChanged();
            }

            FSkeletonOutput.SetInterface(FSkeleton);
        }
예제 #4
0
파일: SetJoint.cs 프로젝트: vnmone/vvvv-sdk
        //here we go, thats the method called by vvvv each frame
        //all data handling should be in here
        public void Evaluate(int SpreadMax)
        {
            //if any of the inputs has changed
            //recompute the outputs

            bool recalculate = false;


            if (FJointNameInput.PinIsChanged)
            {
                jointNames = new List <string>();
                string jointName;
                for (int i = 0; i < FJointNameInput.SliceCount; i++)
                {
                    FJointNameInput.GetString(i, out jointName);
                    jointNames.Add(jointName);
                }
                recalculate = true;
            }

            if (FSkeletonInput.PinIsChanged || recalculate)
            {
                if (FSkeletonInput.IsConnected)
                {
                    object currInterface;
                    FSkeletonInput.GetUpstreamInterface(out currInterface);
                    s = (Skeleton)currInterface;
                    if (inputSkeleton == null || !s.Uid.Equals(inputSkeleton.Uid))
                    {
                        inputSkeleton = (Skeleton)s.DeepCopy();
                    }
                    else
                    {
                        foreach (KeyValuePair <string, IJoint> pair in s.JointTable)
                        {
                            if (!jointNames.Exists(delegate(string name) { return(name == pair.Key); }))
                            {
                                inputSkeleton.JointTable[pair.Key].BaseTransform      = pair.Value.BaseTransform;
                                inputSkeleton.JointTable[pair.Key].AnimationTransform = pair.Value.AnimationTransform;
                            }
                            inputSkeleton.JointTable[pair.Key].Constraints = pair.Value.Constraints;
                        }
                    }
                }
                else
                {
                    inputSkeleton = null;
                }
            }

            if (FSkeletonInput.PinIsChanged || FAnimationTransformInput.PinIsChanged || FBaseTransformInput.PinIsChanged || FParentNameInput.PinIsChanged || FConstraintsInput.PinIsChanged || recalculate)
            {
                if (inputSkeleton != null)
                {
                    IJoint currJoint;
                    for (int i = 0; i < jointNames.Count; i++)
                    {
                        currJoint = inputSkeleton.JointTable[jointNames[i]];
                        Matrix4x4 currAnimationT;
                        Matrix4x4 currBaseT;
                        string    currParentName;
                        if (currJoint != null)
                        {
                            if (FAnimationTransformInput.IsConnected)
                            {
                                FAnimationTransformInput.GetMatrix(i, out currAnimationT);
                                currJoint.AnimationTransform = currAnimationT;
                            }
                            else
                            {
                                currJoint.AnimationTransform = s.JointTable[currJoint.Name].AnimationTransform;
                            }

                            if (FBaseTransformInput.IsConnected)
                            {
                                FBaseTransformInput.GetMatrix(i, out currBaseT);
                                currJoint.BaseTransform = currBaseT;
                            }
                            else
                            {
                                currJoint.BaseTransform = s.JointTable[currJoint.Name].BaseTransform;
                            }

                            /*if (FRotationInput.IsConnected)
                             * {
                             *      currRotation = new Vector3D(0);
                             *      FRotationInput.GetValue3D(i, out currRotation.x, out currRotation.y, out currRotation.z);
                             *      //currJoint.Rotation = currRotation;
                             *
                             * }
                             */

                            /*if (FConstraintsInput.IsConnected)
                             * {
                             *      currConstraints = new List<Vector2D>();
                             *      Vector2D currConstraint;
                             *      for (int j=0; j<3; j++)
                             *      {
                             *              currConstraint = new Vector2D(0);
                             *              FConstraintsInput.GetValue2D(i*3, out currConstraint.x, out currConstraint.y);
                             *              currConstraints.Add(currConstraint);
                             *      }
                             *      currJoint.Constraints = currConstraints;
                             * }
                             */

                            FParentNameInput.GetString(i, out currParentName);
                            if (currParentName != null && (FParentNameInput.SliceCount > 1 || !string.IsNullOrEmpty(currParentName)))
                            {
                                IJoint parent = inputSkeleton.JointTable[currParentName];
                                if (parent != null)
                                {
                                    currJoint.Parent = parent;
                                }
                            }
                        }
                    }
                }

                FSkeletonOutput.MarkPinAsChanged();
            }

            FSkeletonOutput.SetInterface(inputSkeleton);
        }
예제 #5
0
        //here we go, thats the method called by vvvv each frame
        //all data handling should be in here
        public void Evaluate(int SpreadMax)
        {
            //if any of the inputs has changed
            //recompute the outputs

            bool recalculate = false;

            if (FJointNameInput.PinIsChanged || FBaseTransformInput.PinIsChanged || FOffsetModeInput.PinIsChanged || FParentNameInput.PinIsChanged || FConstraintsInput.PinIsChanged || recalculate)
            {
                skeleton = new Skeleton();

                int currId = 0;
                for (int i = 0; i < FJointNameInput.SliceCount; i++)
                {
                    string jointName;
                    string parentName;
                    FJointNameInput.GetString(i % FJointNameInput.SliceCount, out jointName);
                    FParentNameInput.GetString(i % FParentNameInput.SliceCount, out parentName);
                    IJoint    currJoint = new JointInfo(jointName);
                    Matrix4x4 baseTransform;
                    FBaseTransformInput.GetMatrix(i % FBaseTransformInput.SliceCount, out baseTransform);
                    currJoint.BaseTransform = baseTransform;             //VMath.Translate(basePositionX, basePositionY, basePositionZ);
                    currJoint.Constraints.Clear();
                    for (int j = i * 3; j < i * 3 + 3; j++)
                    {
                        double constraintMin, constraintMax;
                        FConstraintsInput.GetValue2D(j % FConstraintsInput.SliceCount, out constraintMin, out constraintMax);
                        currJoint.Constraints.Add(new Vector2D(constraintMin, constraintMax));
                    }
                    if (string.IsNullOrEmpty(parentName))
                    {
                        if (skeleton.Root == null)
                        {
                            skeleton.Root = currJoint;
                            currJoint.Id  = currId;
                            currId++;
                            skeleton.BuildJointTable();
                        }
                    }
                    else
                    {
                        if (skeleton.JointTable.ContainsKey(parentName))
                        {
                            currJoint.Parent = skeleton.JointTable[parentName];
                            currJoint.Id     = currId;
                            currId++;
                        }
                        skeleton.BuildJointTable();
                    }
                }

                int positionInWorldSpace = 0;
                FOffsetModeInput.GetOrd(0, out positionInWorldSpace);
                if (positionInWorldSpace > 0)
                {
                    List <Vector3D> offsetList = new List <Vector3D>();
                    foreach (KeyValuePair <string, IJoint> pair in skeleton.JointTable)
                    {
                        Vector3D worldPos = pair.Value.BaseTransform * (new Vector3D(0));
                        Vector3D parentWorldPos;
                        if (pair.Value.Parent != null)
                        {
                            parentWorldPos = pair.Value.Parent.BaseTransform * (new Vector3D(0));
                        }
                        else
                        {
                            parentWorldPos = new Vector3D(0);
                        }
                        Vector3D offset = worldPos - parentWorldPos;
                        offsetList.Add(offset);
                    }
                    int i = 0;
                    foreach (KeyValuePair <string, IJoint> pair in skeleton.JointTable)
                    {
                        pair.Value.BaseTransform = VMath.Translate(offsetList[i]);
                        i++;
                    }
                }


                FSkeletonOutput.MarkPinAsChanged();
            }

            FSkeletonOutput.SetInterface(skeleton);
        }
예제 #6
0
        //here we go, thats the method called by vvvv each frame
        //all data handling should be in here
        public void Evaluate(int SpreadMax)
        {
            //if any of the inputs has changed
            //recompute the outputs

            bool recalculate = false;

            if (FJointNameInput.PinIsChanged)
            {
                jointNames = new List <string>();
                string jointName;
                for (int i = 0; i < FJointNameInput.SliceCount; i++)
                {
                    FJointNameInput.GetString(i, out jointName);
                    jointNames.Add(jointName);
                }
                recalculate = true;
                if (jointNames.Count == 1 && string.IsNullOrEmpty(jointNames[0]))
                {
                    jointsSelected = false;
                }
                else
                {
                    jointsSelected = true;
                }
            }

            if (FSkeletonInput.PinIsChanged)
            {
                if (FSkeletonInput.IsConnected)
                {
                    object currInterface;
                    FSkeletonInput.GetUpstreamInterface(out currInterface);
                    inputSkeleton = (Skeleton)currInterface;

                    // if there are no specific joints selected via input pin, collect them all
                    if (jointNames == null || !jointsSelected)
                    {
                        jointNames = new List <string>();
                        foreach (KeyValuePair <string, IJoint> pair in inputSkeleton.JointTable)
                        {
                            // Only add those with a valid array index.
                            // It's not a must that all bones are used as skinning matrices.
                            if (pair.Value.Id >= 0)
                            {
                                jointNames.Add(pair.Key);
                            }
                        }
                    }
                }
                else
                {
                    inputSkeleton = null;
                }
                recalculate = true;
            }

            if (FInverseBindPoseInput.PinIsChanged)
            {
                recalculate = true;
            }

            if (FOutputModeInput.PinIsChanged)
            {
                FOutputModeInput.GetOrd(0, out outputMode);
                recalculate = true;
            }

            if (recalculate && inputSkeleton != null)
            {
                inputSkeleton.CalculateCombinedTransforms();
                int jointCount;
                if (outputMode == OUTPUT_MODE_DYNAMIC)
                {
                    jointCount = jointNames.Count;
                }
                else
                {
                    jointCount = 60;
                }
                FTransformOutput.SliceCount = jointCount;
                IJoint    currJoint;
                Matrix4x4 currIBPMatrix;
                int       i = 0;
                for (i = 0; i < jointNames.Count; i++)
                {
                    currJoint = inputSkeleton.JointTable[jointNames[i]];
                    if (currJoint != null)
                    {
                        int sliceIndex;
                        if (outputMode == OUTPUT_MODE_STATIC)
                        {
                            sliceIndex = currJoint.Id;
                        }
                        else
                        {
                            sliceIndex = i;
                        }
                        FInverseBindPoseInput.GetMatrix(sliceIndex, out currIBPMatrix);
                        FTransformOutput.SetMatrix(sliceIndex, currIBPMatrix * currJoint.CombinedTransform);
                    }
                }

                // Pad remaining slices with Identity Matrices
                for (int j = i; j < jointCount; j++)
                {
                    FTransformOutput.SetMatrix(j, VMath.IdentityMatrix);
                }
            }
        }