public BasicRefinedVertexInfo[] GetVertexInfos(ChannelOutputs outputs, Vector3[] controlPositions)
    {
        Vector3 center = bone.GetChainedTransform(outputs).Transform(bone.CenterPoint.GetValue(outputs));

        double totalDist = 0;

        foreach (int vertexIdx in attachedVertices)
        {
            totalDist += Vector3.Distance(controlPositions[vertexIdx], center);
        }
        double radius = totalDist / attachedVertices.Count;

        Quaternion rotation = bone.Parent.GetChainedTransform(outputs).RotationStage.Rotation;

        var transform = Matrix.AffineTransformation((float)radius, rotation, center);

        var transformedSurrogateMesh = OcclusionSurrogateCommon.Mesh.Transform(transform);

        return(Enumerable.Range(0, transformedSurrogateMesh.VertexCount)
               .Select(idx => new BasicRefinedVertexInfo {
            position = transformedSurrogateMesh.VertexPositions[idx],
            normal = Vector3.Normalize(transformedSurrogateMesh.VertexNormals[idx])
        })
               .ToArray());
    }
コード例 #2
0
    public void Update(FrameUpdateParameters updateParameters, ChannelInputs inputs)
    {
        var outputs            = channelSystem.Evaluate(null, inputs);
        var chestBoneTransform = chestBone.GetChainedTransform(outputs);
        var chestBoneRotation  = chestBoneTransform.RotationStage.Rotation;

        chestBoneRotation.Invert();
        var gravity = Vector3.Transform(Vector3.Down, chestBoneRotation);

        float xRotation = -5 - gravity.Y * 5;

        lPectoralBone.Rotation.X.SetValue(inputs, xRotation);
        rPectoralBone.Rotation.X.SetValue(inputs, xRotation);

        float yRotationInput = gravity.X;

        //Console.WriteLine(yRotation);
        lPectoralBone.Rotation.Y.SetValue(inputs, 5 * ExpandNegative(yRotationInput));
        rPectoralBone.Rotation.Y.SetValue(inputs, 5 * ExpandPositive(yRotationInput));

        float flatten     = Max(-gravity.Z, 0);
        float hangForward = Max(+gravity.Z, 0);

        flattenChannel.SetValue(inputs, flatten);
        hangForwardChannel.SetValue(inputs, hangForward);
    }
コード例 #3
0
    public void Update(FrameUpdateParameters updateParameters, ChannelInputs inputs)
    {
        headPositionForecaster.Update(updateParameters.Time, updateParameters.HeadPosition);

        var forecastHeadPosition = headPositionForecaster.Forecast;

        if (!behaviorModel.LookAtPlayer)
        {
            return;
        }

        var outputs = channelSystem.Evaluate(null, inputs);
        var eyeParentTotalTransform = eyeParentBone.GetChainedTransform(outputs);

        UpdateEye(outputs, eyeParentTotalTransform, inputs, leftEyeBone, forecastHeadPosition);
        UpdateEye(outputs, eyeParentTotalTransform, inputs, rightEyeBone, forecastHeadPosition);
    }
コード例 #4
0
    private void Update3dAudioPosition(FrameUpdateParameters updateParameters, ChannelInputs inputs)
    {
        TrackedDevicePose_t gamePose = updateParameters.GamePoses[OpenVR.k_unTrackedDeviceIndex_Hmd];
        Matrix hmdToWorldTransform   = gamePose.mDeviceToAbsoluteTracking.Convert();

        hmdToWorldTransform.Invert();

        var outputs            = channelSystem.Evaluate(null, inputs);
        var headTotalTransform = headBone.GetChainedTransform(outputs);

        var     headBindPoseCenter = headBone.CenterPoint.GetValue(outputs);
        Vector3 headWorldPosition  = headTotalTransform.Transform(headBindPoseCenter) / 100;

        Vector3 headHmdPosition = Vector3.TransformCoordinate(headWorldPosition, hmdToWorldTransform);

        phononStream.HeadRelativePosition = headHmdPosition;
    }
コード例 #5
0
    public StagedSkinningTransform[] GetBoneTransforms(ChannelOutputs outputs)
    {
        while (outputs.Parent != null)
        {
            outputs = outputs.Parent;
        }

        StagedSkinningTransform[] boneTransforms = new StagedSkinningTransform[bones.Count];

        for (int boneIdx = 0; boneIdx < bones.Count; ++boneIdx)
        {
            Bone bone   = bones[boneIdx];
            Bone parent = bone.Parent;
            StagedSkinningTransform parentTransform = parent != null ? boneTransforms[parent.Index] : StagedSkinningTransform.Identity;
            boneTransforms[boneIdx] = bone.GetChainedTransform(outputs, parentTransform);
        }

        return(boneTransforms);
    }