First Class Pen Support

[Void-Paw]

Is your feature request related to a problem?

No

Describe your preferred solution

Pens should be a first class supported feature of Basis that comes default with a deployment. The system should, at a minimum achieve the following requirements:

Requirements

1. Networked: everyone should see what is being drawn
2. Unlimited: There should not be a cap to how much can be drawn
3. Non-expiring: It should not despawn over time
4. Late Joiners: people can see what has been drawn despite not being connected when the drawing was made
5. Good erasing UX: it should be as easy and precise to remove drawings as it is to write them. Easy to erase small errors or wipe away large sections.

Optional Requirements

There are some additional features that would make the pens better but I wouldn't consider required:

1. Multi-color
2. Movable drawings
3. Attribution for moderation purposes: see who drew something.
4. Consistent grip point on the pens so that it snaps to a consistent angle when equipped.
5. Haptics for when the pen is drawing or erasing.

Feature Creeps

These are ideas that I would consider beyond what is necessary but would make the pens even more powerful. Of course, these border on turning Basis into a creation framework, which may be better suited as part of a module or extension on its own.

1. Save system: maybe a collection of writing can be clustered together and saved as a prop of its own, able to be shared or brought out at a later time.
2. Option for 2D snapping to a plane for good alignment.
3. Exporting as 2D image or 3D object.
4. The entire ribbon of functionality in Microsoft paint: Select, Resize, Pen Styles, Line types (straight, bezier, freehand), shapes, copy-cut-paste, textbox, fill???

Describe any considered alternatives

By Basis's nature, this could be something that just exists as a prop within the prop system. This might be a suitable idea so long as it can be done in a way that satisfies all of the requirements listed. From what I understand, however, some of those requirements would need to come from the deployment itself and can't be done through a prop.

Additional Context

Every platform, whether they support it or not, eventually gets some form of writing solution. Often times players will need to hack together a solution using particle systems or camera render textures; as a result they have limits that the players cannot work around without modifications to the platform.

Given that players go out of their way to hack in pens on platforms, there is a clear need for them to be available and capable. Making them first class objects in the Basis framework ensures that every deployment has strong pen support.

A personal Usecase

I used to tutor math and physics in Rec Room, an activity that was largely only made possible by Rec Room's incredible pen system. None of the pen systems on other platforms were good enough to be able to tutor in the way I needed to, plus it had some features that I listed above as feature creeps. The ability to save "white boards" filled with lessons and bring them out at will. Here is a lesson (timestamped to 49:37) that demonstrates the power of the rec room pens in the context of tutoring. Hopefully from this you can see how other platforms fall short of being practical for this usecase of VR. Now with Rec Room gone, there really isn't a place for me to do this kind of thing.

[cathiecode]

In the author's experience with the networked pen prop, the primary challenges were not related to the pen itself, but rather to the strokes it produced.

For example:

• How should strokes be rendered?
• How should strokes be synchronized while they are still being drawn?
• How should completed strokes be synchronized?
• If the owner of the prop leaves a session, writes something in another session, and then returns, which strokes should exist?
• How should an eraser detect nearby strokes?
• How should an eraser delete strokes and synchronize those deletions?

Given Basis's role as a framework, I believe it is preferable to provide building blocks and examples of how to use them, rather than an all-in-one solution packaged as a single component or prefab. I believe that detailed UX decisions should be left to the platform developers and user programmers building on top of Basis.

As an MVP, my proposal is to provide a networked LineRenderer wrapper. Support for point synchronization, spawn management, collision detection with other colliders, and splitting based on the shapes of other colliders would be sufficient.

[Void-Paw]

One other friction point with pens on some platforms is how the line rendering is captured. With some implementations the line is captured client-side after all the IK has been computed and transmitted over the network. What this means in practice is that the pen-holder has to draw slowly or else the outcome will become illegible with all the lerping and dropped packets that happen over the network.

It would be nice if this could be avoided with the implementation of this feature in the basis framework.