Creating Unity VR Drawing App

using System.Collections.Generic;

using UnityEngine;

public class BrushStroke : MonoBehaviour {

   [SerializeField]

   private BrushStrokeMesh _mesh = null;

   // Ribbon State

   struct RibbonPoint {

       public Vector3    position;

       public Quaternion rotation;

   }

   private List<RibbonPoint> _ribbonPoints = new List<RibbonPoint>();

   private Vector3    _brushTipPosition;

   private Quaternion _brushTipRotation;

   private bool       _brushStrokeFinalized;

   // Smoothing

   private Vector3    _ribbonEndPosition;

   private Quaternion _ribbonEndRotation = Quaternion.identity;

   // Mesh

   private Vector3    _previousRibbonPointPosition;

   private Quaternion _previousRibbonPointRotation = Quaternion.identity;

   // Unity Events

   private void Update() {

       // Animate the end of the ribbon towards the brush tip

       AnimateLastRibbonPointTowardsBrushTipPosition();

       // Add a ribbon segment if the end of the ribbon has moved far enough

       AddRibbonPointIfNeeded();

   }

   // Interface

   public void BeginBrushStrokeWithBrushTipPoint(Vector3 position, Quaternion rotation) {

       // Update the model

       _brushTipPosition = position;

       _brushTipRotation = rotation;

       // Update last ribbon point to match brush tip position & rotation

       _ribbonEndPosition = position;

       _ribbonEndRotation = rotation;

       _mesh.UpdateLastRibbonPoint(_ribbonEndPosition, _ribbonEndRotation);

   }

   public void MoveBrushTipToPoint(Vector3 position, Quaternion rotation) {

       _brushTipPosition = position;

       _brushTipRotation = rotation;

   }

   public void EndBrushStrokeWithBrushTipPoint(Vector3 position, Quaternion rotation) {

       // Add a final ribbon point and mark the stroke as finalized

       AddRibbonPoint(position, rotation);

       _brushStrokeFinalized = true;

   }

   // Ribbon drawing

   private void AddRibbonPointIfNeeded() {

       // If the brush stroke is finalized, stop trying to add points to it.

       if (_brushStrokeFinalized)

           return;

       if (Vector3.Distance(_ribbonEndPosition, _previousRibbonPointPosition) >= 0.01f ||

           Quaternion.Angle(_ribbonEndRotation, _previousRibbonPointRotation) >= 10.0f) {

           // Add ribbon point model to ribbon points array. This will fire the RibbonPointAdded event to update the mesh.

           AddRibbonPoint(_ribbonEndPosition, _ribbonEndRotation);

           // Store the ribbon point position & rotation for the next time we do this calculation

           _previousRibbonPointPosition = _ribbonEndPosition;

           _previousRibbonPointRotation = _ribbonEndRotation;

       }

   }

   private void AddRibbonPoint(Vector3 position, Quaternion rotation) {

       // Create the ribbon point

       RibbonPoint ribbonPoint = new RibbonPoint();

       ribbonPoint.position = position;

       ribbonPoint.rotation = rotation;

       _ribbonPoints.Add(ribbonPoint);

       // Update the mesh

       _mesh.InsertRibbonPoint(position, rotation);

   }

   // Brush tip + smoothing

   private void AnimateLastRibbonPointTowardsBrushTipPosition() {

       // If the brush stroke is finalized, skip the brush tip mesh, and stop animating the brush tip.

       if (_brushStrokeFinalized) {

           _mesh.skipLastRibbonPoint = true;

           return;

       }

       Vector3    brushTipPosition = _brushTipPosition;

       Quaternion brushTipRotation = _brushTipRotation;

       // If the end of the ribbon has reached the brush tip position, we can bail early.

       if (Vector3.Distance(_ribbonEndPosition, brushTipPosition) <= 0.0001f &&

           Quaternion.Angle(_ribbonEndRotation, brushTipRotation) <= 0.01f) {

           return;

       }

       // Move the end of the ribbon towards the brush tip position

       _ribbonEndPosition =     Vector3.Lerp(_ribbonEndPosition, brushTipPosition, 25.0f * Time.deltaTime);

       _ribbonEndRotation = Quaternion.Slerp(_ribbonEndRotation, brushTipRotation, 25.0f * Time.deltaTime);

       // Update the end of the ribbon mesh

       _mesh.UpdateLastRibbonPoint(_ribbonEndPosition, _ribbonEndRotation);

   }

}

using System.Collections.Generic;

using UnityEngine;

using UnityEngine.XR;

using UnityEngine.UI;

public class Brush : MonoBehaviour

{

   // Prefab to instantiate when we draw a new brush stroke

   [SerializeField] private GameObject _brushStrokePrefab = null;

   // Which hand should this brush instance track?

   private enum Hand { LeftHand, RightHand };

   [SerializeField] private Hand _hand = Hand.RightHand;

   // Used to keep track of the current brush tip position and the actively drawing brush stroke

   private Vector3 _handPosition;

   private Quaternion _handRotation;

   private BrushStroke _activeBrushStroke;

   public InputDeviceCharacteristics controllerCharacteristics;

   public GameObject test;

   private InputDevice targetDevice;

   void Start()

   {

       controllerCharacteristics = InputDeviceCharacteristics.Right | InputDeviceCharacteristics.Controller;

       var devices = new List<InputDevice>();

       InputDevices.GetDevicesWithCharacteristics(controllerCharacteristics, devices);

       if (devices.Count > 0){

           targetDevice = devices[0];

       }

   }

   private void Update()

   {

       // Start by figuring out which hand we're tracking

       XRNode node = _hand == Hand.LeftHand ? XRNode.LeftHand : XRNode.RightHand;

       string trigger = _hand == Hand.LeftHand ? "Left Trigger" : "Right Trigger";

       // Get the position & rotation of the hand

       bool handIsTracking = UpdatePose(node, ref _handPosition, ref _handRotation);

       // Figure out if the trigger is pressed or not

       bool triggerPressed = targetDevice.TryGetFeatureValue(CommonUsages.trigger, out float triggerValue) && triggerValue > 0.1f;

       // If we lose tracking, stop drawing

       if (!handIsTracking)

           triggerPressed = false;

       // If the trigger is pressed and we haven't created a new brush stroke to draw, create one!

       if (triggerPressed && _activeBrushStroke == null)

       {

           // Instantiate a copy of the Brush Stroke prefab.

           GameObject brushStrokeGameObject = Instantiate(_brushStrokePrefab);

           // Grab the BrushStroke component from it

           _activeBrushStroke = brushStrokeGameObject.GetComponent<BrushStroke>();

           // Tell the BrushStroke to begin drawing at the current brush position

           _activeBrushStroke.BeginBrushStrokeWithBrushTipPoint(_handPosition, _handRotation);

       }

       // If the trigger is pressed, and we have a brush stroke, move the brush stroke to the new brush tip position

       if (triggerPressed)

           _activeBrushStroke.MoveBrushTipToPoint(_handPosition, _handRotation);

       // If the trigger is no longer pressed, and we still have an active brush stroke, mark it as finished and clear it.

       if (!triggerPressed && _activeBrushStroke != null)

       {

           _activeBrushStroke.EndBrushStrokeWithBrushTipPoint(_handPosition, _handRotation);

           _activeBrushStroke = null;

       }

   }

   //// Utility

   // Given an XRNode, get the current position & rotation. If it's not tracking, don't modify the position & rotation.

   private static bool UpdatePose(XRNode node, ref Vector3 position, ref Quaternion rotation)

   {

       List<XRNodeState> nodeStates = new List<XRNodeState>();

       InputTracking.GetNodeStates(nodeStates);

       foreach (XRNodeState nodeState in nodeStates)

       {

           if (nodeState.nodeType == XRNode.RightHand)

           {

               Vector3 nodePosition;

               Quaternion nodeRotation;

               bool gotPosition = nodeState.TryGetPosition(out nodePosition);

               bool gotRotation = nodeState.TryGetRotation(out nodeRotation);

               if (gotPosition)

                   position = nodePosition;

               if (gotRotation)

                   rotation = nodeRotation;

               return gotPosition;

           }

       }

       return false;

   }

}