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;

}

}