Using the Photon library, it should be possible to share the connection lines a user created with the other users in the room, such that they can be used for demonstration and visualization purposes.

Go through the implemented classes for the connection lines and think about the "read-write" permissions of each variable.

• Is the variable only public because it should be visible in the inspector? => make it private and add the [SerializeField] tag in front of it.

• Is the variable public because another script needs to read it but never changes its value (and is not supposed to change its value)? => use a getter

• Is the variable public because another script changes its value and something should happen if the value is changed => use a getter and setter; call the code that should happen if the variable is changed from the setter

• Is the variable public because another script needs to read and write it? => you could use a public variable but I would still prefer a getter and a setter

C# has special getter and setter Keywords which can be used:
https://docs.microsoft.com/de-de/dotnet/csharp/language-reference/keywords/get
https://docs.microsoft.com/de-de/dotnet/csharp/language-reference/keywords/set

Instead of the current buttons that are floating along the cube, one button called "Connection Lines" should be added to the Main Menu cube that opens a new menu where the current buttons and future features should be added, such that they are not just floating in the air.

The DrawMode can both be entered by the EnterDrawMode and the EnterSingleDelete button (same for exiting the mode). As pressing these buttons in a random sequence might end up with unwanted results, it should be changed. This could be done by introducing a new mode for deleting.

This feature is supposed to enable a drawing mode in the application. The mode can be enabled via a button saying "Enter Line Draw Mode" in the main menu. After clicking on that button it should be replaced with the text "Draw Line". Clicking "Draw Line" results in reverting the button to its original text.

The test scene should allow for fast room creation for the sake of testing the collaborative mode. Besides, it should provide objects of relevant shapes for testing the pointer object's form and its behavior with movement.

There is an existing color chooser which is e.g. used for the Kanban boards. Maybe we can integrate this into the UI of the connection lines?

The color chooser has a dependency on a visualization. It is probably necessary to remove this dependency, e.g. by introducing a color chosen event to which a second script reacts. This second script can set the color of an assigned object, in this case the visualization or the line.

A button should be added, that allows users to delete all lines. To do this use for example tags and delete all instances of the LineRenderer Prefab that are labeled with that tag.

When multiple users are in the same room, only the users own arrow rotation sticks out of game objects it is placed on as it should, but the other arrows not.
The rotation variable of the arrow is not shared.

In the Draw Mode, the selected objects should be highlighted, such that the user is aware of which objects he/she selected. This highlighting should be removed once the mode is exited by clicking "Draw Line".

Each feature should get its own dedicated Wiki page to keep things organized.

When selecting more than two issues while in DrawMode every issue that has been selected is highlighted even though the selection has been overwritten by another object. This is confusing, as not only the currently selected objects are highlighted. This can be fixed by reseting the color of an issue when another object becomes the new start or destination object.

Implement the enable/disable button that is already in the scene to toggle between showing and not showing the overlay text

The user should be able to select whether his/her lines are visible for other participants in the room. This can be done via a button in the Connection Lines Menu that activates or deactivates the sharing of lines.

UI with button to activate/deactivate sharing gaze feature
UI with options to configure one's own gaze object color

In the Connection Lines Menu, it should be possible to choose from two different line width settings. This could for example be implemented with two buttons that show the option of a narrower and wider line and they should be selected when in the Line Draw Mode.

Currently working on main menu cube
To implement to work on test cubes and on all object created with the ViaProMa Application ( Issue cards, buildings, progress bars etc. )

Choose a pointer object for which rotation is not going to play a major role, so that it does not have to be rotated to individual users in the game.

When an Issue card connected with Line(s) to other Objects is deleted, the Program crashes.

Since the connection lines are almost ready to be merged with the master branch of the project, the documentation for them should be checked and updated to account for the new menu structure.

It would also be good to collect the documentation at a central place instead of separate readme files. I created a Wiki for this repository where you can document the results.

Implement a movement functionality for all windows which allows the user to place them somewhere else.

One solution would be to introduce a top bar, e.g. behind the title of the window, which the user can grab to drag the window around. A good idea would be to rotate the window towards the user while dragging. The HoloLens 2 introduces an "Adjust" button on such a top bar which allows the user to rotate and scale the entire window with a bounding box.

For performance reasons, the usage of GetComponent in the script for the connection line menu should be reduced.
There are two ways to do this:

1. Reference the component itself in the inspector instead of the GameObject. If you drag-and-drop a GameObject onto a field in the inspector, it will automatically choose the fitting component on the GameObject.
2. Execute GetComponent in the initialization methods which are only executed once, e.g. in Awake or Start, and cache the result in a new private variable.

Example for 1: instead of
`
[SerializeField] private GameObject button;

private void SomeMethod()
{
button.GetComponent().Enabled = false; // accessing the Interactable component
button.name = "My Button" // accessing the GameObject itself
}
`

you can write:
`
[SerializeField] private Interactable interactable;

private void SomeMethod()
{
interactable.Enabled = false; // accessing the Interactable component
interactable.gameObject.Name = "My Button" // accessing the GameObject itself
}
`

When two users enter the same room in VIAProMa, the new gaze object should be made shareable so that both users can see where the other user is looking

UI showing who is looking at what object
Shows if head is looking or the controllers are pointing to the object

Via utilizing a bounding box the user should be able to choose a specific edge or corner of an object when creating a new line. This helps avoiding the lines covering the content of issue cards and blocking the view of visualizations.

How to recreate

Pull a task card into the scene and rotate it in a way that the top edge is closer to the user than the bottom edge. This means that the front of the task card points towards the floor. The app bar will rotate by 180 degrees and point away from the user, making it impossible to reach its buttons.

Help for fixing the bug

The app bar has a positioning script. It calculates the nearest face and its normal vector based on the box collider of the bounding box. This is used to place the app bar in front of the bounding box's face and with a rotation that the app bar snaps to the bounding box's face. You can probably add a check to invert the rotation if the calculated normal vector points away from the user.
This can be checked with the dot product between the calculated normal vector and the vector from the camera's position to the object.

Share/unshare my gaze button is outside of the main menu cube when it is closed.
When the main menu cube is opened the button aligns correctly on the settings panel of the open cube.
The position/rotation/scale of the share/unshare my gaze button should also be correct when the main menu cube is moved or scaled with the bounding box option.

The currently selected line color and width should be highlighted in the corresponding UI.

https://docs.microsoft.com/en-us/dotnet/csharp/codedoc

In the Connection Lines Menu, it should be possible to choose from several (for example 9) different colors, that the next line to be created should have. This could for example be one button in the color of the currently selected line color, that when clicked displays all possible colors to choose from. After selecting a color it should collapse back into one button displaying the new line color.

Object should be visible when looking at game objects from the main scene
Use different colors for the object to distinguish head and controllers gaze

When objects are moved in the scene, the connecting line should be moved accordingly as well. To do this the coordinates of the Line Renderer should be set to the new coordinates of the object.

The project has accumulated a lot of branches. We should identify the purpose of each branch and identify those that have already been merged. Please create an overview, e.g. in the Wiki which shows which branches carry valuable additions that should be added to the master.

Implement the rotation of the arrow to not be partially inside of game objects when looking/pointing at them

The connection lines should be accessible in an own window which can be placed somewhere in the scene.

• Remove the additional side from the main menu cube
• Create a button on the main menu which opens a separate window
• Create the separate window and move the controls of the connection line menu to this window

You can take a look at existing windows to find out how they work and how they are created.

Overlay canvas showing the users nickname, color of arrow and device he is using, works with two users in room, when third user enters room canvas only shows one of the two users information

A script enables a mode in which two objects can be selected. Once the "Enter Line Draw Mode" button is clicked, a method enters this mode. Then the two objects can be selected and once the "Draw Line" button is clicked the following happens: With the coordinates of these objects a line is drawn with the Line Renderer component. Therefore a prefab is instantiated that contains the LineRenderer component and the coordinate of the two objects is entered into it.

Not all objects should be selectable in the DrawMode. Only issue cards and visualizations should be selectable.

Using the same loading/saving system as ViaProMa, drawn lines should be saved and loaded alongside the project.

The method is marked as async but there is no await call, so we can just remote the async keyword.

Overlay canvas text should show a list of all users, the device they are using and the name of the object currently being gazed/pointed at, for all users in the room
Currently, the name of the user is being displayed correctly, the correct device and name of the object are missing

In addition to deleting all lines, specific lines should be selected and deleted. For this, an additional button should be added. When it is clicked it turns to the color red (this is an example, it should be possible to distinguish the states of the button), the user is able to select a specific line and with another click on the same button (caption saying "Delete Line") the corresponding gameobject containing the LineRenderer is destroyed.

We changed it at some point, but there should be a duplicate with the necessary properties.

This way, the pointer object will not get caught up inside the objects in the scene.