hyperdramatik - Benutzerbeiträge [de]

XY Plotter

2023-02-14T16:58:36Z

Fkirschner: /* using the mDraw Firmware (Recommended) */

== XY Plotter ==

Spiel und Objekt besitzt drei [https://www.makeblock.com/project/xy-plotter-robot-kit| Makeblock XY Plotter].

[[File:xyPlotter_example.jpg|500px|An image of an xyPlotter during the 2023 GameJam at the FFT Düsseldorf]]
 
Given the age of the hardware, a lot of the documentation is out of date. This article will help you getting the device to work with your WINDOWS computer.

== Assembly Instructions ==
If, for some reason, a device broke or you need to reassemble it, here is a link to the [http://download.makeblock.com/XY/pdf/XY%20Plotter%20V2.0%20Assembly%20instructions%EF%BC%882016.6%EF%BC%89.pdf| official assembly guide]

== General Hardware Specifications ==
* They are controlled by a custom Arduino UNO compatible board with Custom Firmware.
* The two stepper motors are driven by a 12V external Power supply
* Some of them might have an additional Servo motor to control a Pen or a Magnet Holder.

== Getting it to work ==
* Connect the XY Plotter using a Micro-USB Cable.
* Make sure the XY Plotter's 12V power supply is plugged in and that power is turned on (in addition to the USB Connection).
* Download the software "mDraw" either from the official [https://www.makeblock.com/project/xy-plotter-robot-kit|XY Plotter website] or from [https://nx16523.your-storageshare.de/s/CCW7oLcRdMbC7oS| the Spiel und Objekt Buschcloud].

=== using the mDraw Firmware (Recommended) ===
* open mDraw
* In the drop-down Menu on the top right, select ''XY-Plotter''
* Make sure the Plotter is connected, the COM port should be connected in the lower right hand side of the software.
* Click '''Connect'''
* If the firmware has changed recently, or you read the word "init" in the lower right hand Console Window and the Plotter seems to move super slow, you might want to reapply the mDraw Firmware.
* To apply the mDraw firmware, click '''Update Firmware'''
* Wait for the Firmware to Download onto the board
* Profit!
** Double-Clicking in the middle of the drawing area should move the Plotter to that point.
** Clicking on the house Icon should move the Plotter back to its initial 0,0 Position
** Feel free to explore the software. The plotters should work Out-Of-The-Box with the default settings of the Software. Please document if you Settings changed setting for other groups potentially using the Plotter. Here's an image of the setting as of 14.02.23: [[File:mDraw_settings.jpg|300px|mDraw setting page]]

=== using the official gitHub Firmware (Not Recommended) ===
* download the XY Plotter firmware from the [https://github.com/Makeblock-official/XY-Plotter-2.0|Makeblock GitHub page] or use the one that comes in the Spiel und Objekt Buschcloud folder.
* Open the Arduino file: XY-Plotter-2.0-master\software\GCodeParser.ino
* Make sure the Plotter is connected, then select the COM port as usual in the Arduino software.
* Contrary to the instructions on the official Firmware GitHub website, we selected ''"Arduino Uno"'' as our board type for success.
* Upload the code to the controller board
* The code is very, very slow, but it works. You can possibly adjust the values in the code itself to speed it up.
* we really recommend using the mDraw Firmware, it is much much faster.

== Using GCode ==

Once you have chosen a firmware (we really really suggest you use mDraw version of the firmware), you can use GCode Commands over Serial Communication to control the XY Plotter from Processing (or any other Serial compatible Code Environment).
 
GCode is a Command Set for CNC machines and 3D Printers that is often used to control and set up moving machines. The Makeblock XY Plotter uses GCode commands to move the stepper motors and the Servo into position, change its speed and other fun things.
 
GCode are submitted as Strings. For example:

G0 X100 Y100

moves the Plotter to the position 10cm to the right and 10cm forward from its initial home position (if the home position is on the bottom left).

If you want to test out GCode Commands, you can apply them directly in the Input field of the mDraw software (this works for both Firmware versions) or use an Arduino Serial Monitor. Just type the command and watch what happens.

=== Common GCode Commands for mDraw Firmware===
* G0 Xxxx Yyyy - moves the Plotter to xxx and yyy position in Millimeters from the Home Position
* G1 Xxxx Yyyy - - moves the Plotter to xxx and yyy position in Millimeters from the Home Position
* G28 - moves the Plotter to its 0,0 position
* M1 xxx - rotates the Servo (from 0 to 255, like any Arduino Servo). Note that the Servo setup of the XY Plotter usually assumes that you have a Pen or Magnet attached to the Plotter, and so a value of 80 is usually considered '''Pen Down''' and a value of 160 is usually considered '''Pen Up'''

Note: We reverse engineered some of this information from the mDraw Source Code, that you can see on the [https://github.com/Makeblock-official/mDrawBot/blob/master/mDrawGui/XYRobot.py| Makeblock official GitHub page] (Open Source for the win!), but you can also find really good info on this (thanks Clemens!) on [https://gist.github.com/heavysixer/511a7019a3c009027b83| this Github page!]

=== Common GCode Commands for official Firmware ===
* You can derive the GCode commands from the Source Code file in XY-Plotter-2.0-master\software\GCodeParser\process_string.io
* Maybe there is more stuff you can do with that firmware?
* What's nice about it though is that you can change the firmware yourself! It's just a .ino file!
* We really recommend you use the mDraw Version

== Project related Code ==

=== Be:B.E.R.N.D. ===
The following code connects a xy-plotter to unity and also simulates the movement of the plotter in the game view. A simple white plane represents the scale of the plotter and a white cube its movement.
The movement is controlled by the arrow keys.

GitHub [https://github.com/HfSDigital/XY-Plotter-Unity]

XY Plotter

2023-02-14T16:57:22Z

Fkirschner: /* Getting it to work */

== XY Plotter ==

Spiel und Objekt besitzt drei [https://www.makeblock.com/project/xy-plotter-robot-kit| Makeblock XY Plotter].

[[File:xyPlotter_example.jpg|500px|An image of an xyPlotter during the 2023 GameJam at the FFT Düsseldorf]]
 
Given the age of the hardware, a lot of the documentation is out of date. This article will help you getting the device to work with your WINDOWS computer.

== Assembly Instructions ==
If, for some reason, a device broke or you need to reassemble it, here is a link to the [http://download.makeblock.com/XY/pdf/XY%20Plotter%20V2.0%20Assembly%20instructions%EF%BC%882016.6%EF%BC%89.pdf| official assembly guide]

== General Hardware Specifications ==
* They are controlled by a custom Arduino UNO compatible board with Custom Firmware.
* The two stepper motors are driven by a 12V external Power supply
* Some of them might have an additional Servo motor to control a Pen or a Magnet Holder.

== Getting it to work ==
* Connect the XY Plotter using a Micro-USB Cable.
* Make sure the XY Plotter's 12V power supply is plugged in and that power is turned on (in addition to the USB Connection).
* Download the software "mDraw" either from the official [https://www.makeblock.com/project/xy-plotter-robot-kit|XY Plotter website] or from [https://nx16523.your-storageshare.de/s/CCW7oLcRdMbC7oS| the Spiel und Objekt Buschcloud].

=== using the mDraw Firmware (Recommended) ===
* open mDraw
* In the drop-down Menu on the top right, select ''XY-Plotter''
* Make sure the Plotter is connected, the COM port should be connected in the lower right hand side of the software.
* Click '''Connect'''
* To apply the mDraw firmware, click '''Update Firmware'''
* Wait for the Firmware to Download onto the board
* Profit!
** Double-Clicking in the middle of the drawing area should move the Plotter to that point.
** Clicking on the house Icon should move the Plotter back to its initial 0,0 Position
** Feel free to explore the software. The plotters should work Out-Of-The-Box with the default settings of the Software. Please document if you Settings changed setting for other groups potentially using the Plotter. Here's an image of the setting as of 14.02.23: [[File:mDraw_settings.jpg|300px|mDraw setting page]]

=== using the official gitHub Firmware (Not Recommended) ===
* download the XY Plotter firmware from the [https://github.com/Makeblock-official/XY-Plotter-2.0|Makeblock GitHub page] or use the one that comes in the Spiel und Objekt Buschcloud folder.
* Open the Arduino file: XY-Plotter-2.0-master\software\GCodeParser.ino
* Make sure the Plotter is connected, then select the COM port as usual in the Arduino software.
* Contrary to the instructions on the official Firmware GitHub website, we selected ''"Arduino Uno"'' as our board type for success.
* Upload the code to the controller board
* The code is very, very slow, but it works. You can possibly adjust the values in the code itself to speed it up.
* we really recommend using the mDraw Firmware, it is much much faster.

== Using GCode ==

Once you have chosen a firmware (we really really suggest you use mDraw version of the firmware), you can use GCode Commands over Serial Communication to control the XY Plotter from Processing (or any other Serial compatible Code Environment).
 
GCode is a Command Set for CNC machines and 3D Printers that is often used to control and set up moving machines. The Makeblock XY Plotter uses GCode commands to move the stepper motors and the Servo into position, change its speed and other fun things.
 
GCode are submitted as Strings. For example:

G0 X100 Y100

moves the Plotter to the position 10cm to the right and 10cm forward from its initial home position (if the home position is on the bottom left).

If you want to test out GCode Commands, you can apply them directly in the Input field of the mDraw software (this works for both Firmware versions) or use an Arduino Serial Monitor. Just type the command and watch what happens.

=== Common GCode Commands for mDraw Firmware===
* G0 Xxxx Yyyy - moves the Plotter to xxx and yyy position in Millimeters from the Home Position
* G1 Xxxx Yyyy - - moves the Plotter to xxx and yyy position in Millimeters from the Home Position
* G28 - moves the Plotter to its 0,0 position
* M1 xxx - rotates the Servo (from 0 to 255, like any Arduino Servo). Note that the Servo setup of the XY Plotter usually assumes that you have a Pen or Magnet attached to the Plotter, and so a value of 80 is usually considered '''Pen Down''' and a value of 160 is usually considered '''Pen Up'''

Note: We reverse engineered some of this information from the mDraw Source Code, that you can see on the [https://github.com/Makeblock-official/mDrawBot/blob/master/mDrawGui/XYRobot.py| Makeblock official GitHub page] (Open Source for the win!), but you can also find really good info on this (thanks Clemens!) on [https://gist.github.com/heavysixer/511a7019a3c009027b83| this Github page!]

=== Common GCode Commands for official Firmware ===
* You can derive the GCode commands from the Source Code file in XY-Plotter-2.0-master\software\GCodeParser\process_string.io
* Maybe there is more stuff you can do with that firmware?
* What's nice about it though is that you can change the firmware yourself! It's just a .ino file!
* We really recommend you use the mDraw Version

== Project related Code ==

=== Be:B.E.R.N.D. ===
The following code connects a xy-plotter to unity and also simulates the movement of the plotter in the game view. A simple white plane represents the scale of the plotter and a white cube its movement.
The movement is controlled by the arrow keys.

GitHub [https://github.com/HfSDigital/XY-Plotter-Unity]

XY Plotter

2023-02-14T16:56:59Z

Fkirschner: /* Assembly Instructions */

== XY Plotter ==

Spiel und Objekt besitzt drei [https://www.makeblock.com/project/xy-plotter-robot-kit| Makeblock XY Plotter].

[[File:xyPlotter_example.jpg|500px|An image of an xyPlotter during the 2023 GameJam at the FFT Düsseldorf]]
 
Given the age of the hardware, a lot of the documentation is out of date. This article will help you getting the device to work with your WINDOWS computer.

== Assembly Instructions ==
If, for some reason, a device broke or you need to reassemble it, here is a link to the [http://download.makeblock.com/XY/pdf/XY%20Plotter%20V2.0%20Assembly%20instructions%EF%BC%882016.6%EF%BC%89.pdf| official assembly guide]

== General Hardware Specifications ==
* They are controlled by a custom Arduino UNO compatible board with Custom Firmware.
* The two stepper motors are driven by a 12V external Power supply
* Some of them might have an additional Servo motor to control a Pen or a Magnet Holder.

== Getting it to work ==
* Connect the XY Plotter using a Micro-USB Cable.
* Make sure the XY Plotter's 12V power supply is plugged in and that power is turned on (in addition to the USB Connection).
* Download the software "mDraw" either from the official [https://www.makeblock.com/project/xy-plotter-robot-kit|XY Plotter website] or from the Spiel und Objekt Buschcloud [https://nx16523.your-storageshare.de/s/CCW7oLcRdMbC7oS|here].

=== using the mDraw Firmware (Recommended) ===
* open mDraw
* In the drop-down Menu on the top right, select ''XY-Plotter''
* Make sure the Plotter is connected, the COM port should be connected in the lower right hand side of the software.
* Click '''Connect'''
* To apply the mDraw firmware, click '''Update Firmware'''
* Wait for the Firmware to Download onto the board
* Profit!
** Double-Clicking in the middle of the drawing area should move the Plotter to that point.
** Clicking on the house Icon should move the Plotter back to its initial 0,0 Position
** Feel free to explore the software. The plotters should work Out-Of-The-Box with the default settings of the Software. Please document if you Settings changed setting for other groups potentially using the Plotter. Here's an image of the setting as of 14.02.23: [[File:mDraw_settings.jpg|300px|mDraw setting page]]

=== using the official gitHub Firmware (Not Recommended) ===
* download the XY Plotter firmware from the [https://github.com/Makeblock-official/XY-Plotter-2.0|Makeblock GitHub page] or use the one that comes in the Spiel und Objekt Buschcloud folder.
* Open the Arduino file: XY-Plotter-2.0-master\software\GCodeParser.ino
* Make sure the Plotter is connected, then select the COM port as usual in the Arduino software.
* Contrary to the instructions on the official Firmware GitHub website, we selected ''"Arduino Uno"'' as our board type for success.
* Upload the code to the controller board
* The code is very, very slow, but it works. You can possibly adjust the values in the code itself to speed it up.
* we really recommend using the mDraw Firmware, it is much much faster.

== Using GCode ==

Once you have chosen a firmware (we really really suggest you use mDraw version of the firmware), you can use GCode Commands over Serial Communication to control the XY Plotter from Processing (or any other Serial compatible Code Environment).
 
GCode is a Command Set for CNC machines and 3D Printers that is often used to control and set up moving machines. The Makeblock XY Plotter uses GCode commands to move the stepper motors and the Servo into position, change its speed and other fun things.
 
GCode are submitted as Strings. For example:

G0 X100 Y100

moves the Plotter to the position 10cm to the right and 10cm forward from its initial home position (if the home position is on the bottom left).

If you want to test out GCode Commands, you can apply them directly in the Input field of the mDraw software (this works for both Firmware versions) or use an Arduino Serial Monitor. Just type the command and watch what happens.

=== Common GCode Commands for mDraw Firmware===
* G0 Xxxx Yyyy - moves the Plotter to xxx and yyy position in Millimeters from the Home Position
* G1 Xxxx Yyyy - - moves the Plotter to xxx and yyy position in Millimeters from the Home Position
* G28 - moves the Plotter to its 0,0 position
* M1 xxx - rotates the Servo (from 0 to 255, like any Arduino Servo). Note that the Servo setup of the XY Plotter usually assumes that you have a Pen or Magnet attached to the Plotter, and so a value of 80 is usually considered '''Pen Down''' and a value of 160 is usually considered '''Pen Up'''

Note: We reverse engineered some of this information from the mDraw Source Code, that you can see on the [https://github.com/Makeblock-official/mDrawBot/blob/master/mDrawGui/XYRobot.py| Makeblock official GitHub page] (Open Source for the win!), but you can also find really good info on this (thanks Clemens!) on [https://gist.github.com/heavysixer/511a7019a3c009027b83| this Github page!]

=== Common GCode Commands for official Firmware ===
* You can derive the GCode commands from the Source Code file in XY-Plotter-2.0-master\software\GCodeParser\process_string.io
* Maybe there is more stuff you can do with that firmware?
* What's nice about it though is that you can change the firmware yourself! It's just a .ino file!
* We really recommend you use the mDraw Version

== Project related Code ==

=== Be:B.E.R.N.D. ===
The following code connects a xy-plotter to unity and also simulates the movement of the plotter in the game view. A simple white plane represents the scale of the plotter and a white cube its movement.
The movement is controlled by the arrow keys.

GitHub [https://github.com/HfSDigital/XY-Plotter-Unity]

XY Plotter

2023-02-14T16:56:46Z

Fkirschner: /* XY Plotter */

== XY Plotter ==

Spiel und Objekt besitzt drei [https://www.makeblock.com/project/xy-plotter-robot-kit| Makeblock XY Plotter].

[[File:xyPlotter_example.jpg|500px|An image of an xyPlotter during the 2023 GameJam at the FFT Düsseldorf]]
 
Given the age of the hardware, a lot of the documentation is out of date. This article will help you getting the device to work with your WINDOWS computer.

== Assembly Instructions ==
If, for some reason, a device broke or you need to reassemble it, here is a link to the [http://download.makeblock.com/XY/pdf/XY%20Plotter%20V2.0%20Assembly%20instructions%EF%BC%882016.6%EF%BC%89.pdf | official assembly guide]

== General Hardware Specifications ==
* They are controlled by a custom Arduino UNO compatible board with Custom Firmware.
* The two stepper motors are driven by a 12V external Power supply
* Some of them might have an additional Servo motor to control a Pen or a Magnet Holder.

== Getting it to work ==
* Connect the XY Plotter using a Micro-USB Cable.
* Make sure the XY Plotter's 12V power supply is plugged in and that power is turned on (in addition to the USB Connection).
* Download the software "mDraw" either from the official [https://www.makeblock.com/project/xy-plotter-robot-kit|XY Plotter website] or from the Spiel und Objekt Buschcloud [https://nx16523.your-storageshare.de/s/CCW7oLcRdMbC7oS|here].

=== using the mDraw Firmware (Recommended) ===
* open mDraw
* In the drop-down Menu on the top right, select ''XY-Plotter''
* Make sure the Plotter is connected, the COM port should be connected in the lower right hand side of the software.
* Click '''Connect'''
* To apply the mDraw firmware, click '''Update Firmware'''
* Wait for the Firmware to Download onto the board
* Profit!
** Double-Clicking in the middle of the drawing area should move the Plotter to that point.
** Clicking on the house Icon should move the Plotter back to its initial 0,0 Position
** Feel free to explore the software. The plotters should work Out-Of-The-Box with the default settings of the Software. Please document if you Settings changed setting for other groups potentially using the Plotter. Here's an image of the setting as of 14.02.23: [[File:mDraw_settings.jpg|300px|mDraw setting page]]

=== using the official gitHub Firmware (Not Recommended) ===
* download the XY Plotter firmware from the [https://github.com/Makeblock-official/XY-Plotter-2.0|Makeblock GitHub page] or use the one that comes in the Spiel und Objekt Buschcloud folder.
* Open the Arduino file: XY-Plotter-2.0-master\software\GCodeParser.ino
* Make sure the Plotter is connected, then select the COM port as usual in the Arduino software.
* Contrary to the instructions on the official Firmware GitHub website, we selected ''"Arduino Uno"'' as our board type for success.
* Upload the code to the controller board
* The code is very, very slow, but it works. You can possibly adjust the values in the code itself to speed it up.
* we really recommend using the mDraw Firmware, it is much much faster.

== Using GCode ==

Once you have chosen a firmware (we really really suggest you use mDraw version of the firmware), you can use GCode Commands over Serial Communication to control the XY Plotter from Processing (or any other Serial compatible Code Environment).
 
GCode is a Command Set for CNC machines and 3D Printers that is often used to control and set up moving machines. The Makeblock XY Plotter uses GCode commands to move the stepper motors and the Servo into position, change its speed and other fun things.
 
GCode are submitted as Strings. For example:

G0 X100 Y100

moves the Plotter to the position 10cm to the right and 10cm forward from its initial home position (if the home position is on the bottom left).

If you want to test out GCode Commands, you can apply them directly in the Input field of the mDraw software (this works for both Firmware versions) or use an Arduino Serial Monitor. Just type the command and watch what happens.

=== Common GCode Commands for mDraw Firmware===
* G0 Xxxx Yyyy - moves the Plotter to xxx and yyy position in Millimeters from the Home Position
* G1 Xxxx Yyyy - - moves the Plotter to xxx and yyy position in Millimeters from the Home Position
* G28 - moves the Plotter to its 0,0 position
* M1 xxx - rotates the Servo (from 0 to 255, like any Arduino Servo). Note that the Servo setup of the XY Plotter usually assumes that you have a Pen or Magnet attached to the Plotter, and so a value of 80 is usually considered '''Pen Down''' and a value of 160 is usually considered '''Pen Up'''

Note: We reverse engineered some of this information from the mDraw Source Code, that you can see on the [https://github.com/Makeblock-official/mDrawBot/blob/master/mDrawGui/XYRobot.py| Makeblock official GitHub page] (Open Source for the win!), but you can also find really good info on this (thanks Clemens!) on [https://gist.github.com/heavysixer/511a7019a3c009027b83| this Github page!]

=== Common GCode Commands for official Firmware ===
* You can derive the GCode commands from the Source Code file in XY-Plotter-2.0-master\software\GCodeParser\process_string.io
* Maybe there is more stuff you can do with that firmware?
* What's nice about it though is that you can change the firmware yourself! It's just a .ino file!
* We really recommend you use the mDraw Version

== Project related Code ==

=== Be:B.E.R.N.D. ===
The following code connects a xy-plotter to unity and also simulates the movement of the plotter in the game view. A simple white plane represents the scale of the plotter and a white cube its movement.
The movement is controlled by the arrow keys.

GitHub [https://github.com/HfSDigital/XY-Plotter-Unity]

XY Plotter

2023-02-14T16:55:34Z

Fkirschner: /* Common GCode Commands for mDraw Firmware */

== XY Plotter ==

Spiel und Objekt besitzt drei [https://www.makeblock.com/project/xy-plotter-robot-kit|Makeblock XY Plotter].

[[File:xyPlotter_example.jpg|500px|An image of an xyPlotter during the 2023 GameJam at the FFT Düsseldorf]]
 
Given the age of the hardware, a lot of the documentation is out of date. This article will help you getting the device to work with your WINDOWS computer.

== Assembly Instructions ==
If, for some reason, a device broke or you need to reassemble it, here is a link to the [http://download.makeblock.com/XY/pdf/XY%20Plotter%20V2.0%20Assembly%20instructions%EF%BC%882016.6%EF%BC%89.pdf | official assembly guide]

== General Hardware Specifications ==
* They are controlled by a custom Arduino UNO compatible board with Custom Firmware.
* The two stepper motors are driven by a 12V external Power supply
* Some of them might have an additional Servo motor to control a Pen or a Magnet Holder.

== Getting it to work ==
* Connect the XY Plotter using a Micro-USB Cable.
* Make sure the XY Plotter's 12V power supply is plugged in and that power is turned on (in addition to the USB Connection).
* Download the software "mDraw" either from the official [https://www.makeblock.com/project/xy-plotter-robot-kit|XY Plotter website] or from the Spiel und Objekt Buschcloud [https://nx16523.your-storageshare.de/s/CCW7oLcRdMbC7oS|here].

=== using the mDraw Firmware (Recommended) ===
* open mDraw
* In the drop-down Menu on the top right, select ''XY-Plotter''
* Make sure the Plotter is connected, the COM port should be connected in the lower right hand side of the software.
* Click '''Connect'''
* To apply the mDraw firmware, click '''Update Firmware'''
* Wait for the Firmware to Download onto the board
* Profit!
** Double-Clicking in the middle of the drawing area should move the Plotter to that point.
** Clicking on the house Icon should move the Plotter back to its initial 0,0 Position
** Feel free to explore the software. The plotters should work Out-Of-The-Box with the default settings of the Software. Please document if you Settings changed setting for other groups potentially using the Plotter. Here's an image of the setting as of 14.02.23: [[File:mDraw_settings.jpg|300px|mDraw setting page]]

=== using the official gitHub Firmware (Not Recommended) ===
* download the XY Plotter firmware from the [https://github.com/Makeblock-official/XY-Plotter-2.0|Makeblock GitHub page] or use the one that comes in the Spiel und Objekt Buschcloud folder.
* Open the Arduino file: XY-Plotter-2.0-master\software\GCodeParser.ino
* Make sure the Plotter is connected, then select the COM port as usual in the Arduino software.
* Contrary to the instructions on the official Firmware GitHub website, we selected ''"Arduino Uno"'' as our board type for success.
* Upload the code to the controller board
* The code is very, very slow, but it works. You can possibly adjust the values in the code itself to speed it up.
* we really recommend using the mDraw Firmware, it is much much faster.

== Using GCode ==

Once you have chosen a firmware (we really really suggest you use mDraw version of the firmware), you can use GCode Commands over Serial Communication to control the XY Plotter from Processing (or any other Serial compatible Code Environment).
 
GCode is a Command Set for CNC machines and 3D Printers that is often used to control and set up moving machines. The Makeblock XY Plotter uses GCode commands to move the stepper motors and the Servo into position, change its speed and other fun things.
 
GCode are submitted as Strings. For example:

G0 X100 Y100

moves the Plotter to the position 10cm to the right and 10cm forward from its initial home position (if the home position is on the bottom left).

If you want to test out GCode Commands, you can apply them directly in the Input field of the mDraw software (this works for both Firmware versions) or use an Arduino Serial Monitor. Just type the command and watch what happens.

=== Common GCode Commands for mDraw Firmware===
* G0 Xxxx Yyyy - moves the Plotter to xxx and yyy position in Millimeters from the Home Position
* G1 Xxxx Yyyy - - moves the Plotter to xxx and yyy position in Millimeters from the Home Position
* G28 - moves the Plotter to its 0,0 position
* M1 xxx - rotates the Servo (from 0 to 255, like any Arduino Servo). Note that the Servo setup of the XY Plotter usually assumes that you have a Pen or Magnet attached to the Plotter, and so a value of 80 is usually considered '''Pen Down''' and a value of 160 is usually considered '''Pen Up'''

Note: We reverse engineered some of this information from the mDraw Source Code, that you can see on the [https://github.com/Makeblock-official/mDrawBot/blob/master/mDrawGui/XYRobot.py| Makeblock official GitHub page] (Open Source for the win!), but you can also find really good info on this (thanks Clemens!) on [https://gist.github.com/heavysixer/511a7019a3c009027b83| this Github page!]

=== Common GCode Commands for official Firmware ===
* You can derive the GCode commands from the Source Code file in XY-Plotter-2.0-master\software\GCodeParser\process_string.io
* Maybe there is more stuff you can do with that firmware?
* What's nice about it though is that you can change the firmware yourself! It's just a .ino file!
* We really recommend you use the mDraw Version

== Project related Code ==

=== Be:B.E.R.N.D. ===
The following code connects a xy-plotter to unity and also simulates the movement of the plotter in the game view. A simple white plane represents the scale of the plotter and a white cube its movement.
The movement is controlled by the arrow keys.

GitHub [https://github.com/HfSDigital/XY-Plotter-Unity]

XY Plotter

2023-02-14T16:55:18Z

Fkirschner: /* Common GCode Commands for mDraw Firmware */

== XY Plotter ==

Spiel und Objekt besitzt drei [https://www.makeblock.com/project/xy-plotter-robot-kit|Makeblock XY Plotter].

[[File:xyPlotter_example.jpg|500px|An image of an xyPlotter during the 2023 GameJam at the FFT Düsseldorf]]
 
Given the age of the hardware, a lot of the documentation is out of date. This article will help you getting the device to work with your WINDOWS computer.

== Assembly Instructions ==
If, for some reason, a device broke or you need to reassemble it, here is a link to the [http://download.makeblock.com/XY/pdf/XY%20Plotter%20V2.0%20Assembly%20instructions%EF%BC%882016.6%EF%BC%89.pdf | official assembly guide]

== General Hardware Specifications ==
* They are controlled by a custom Arduino UNO compatible board with Custom Firmware.
* The two stepper motors are driven by a 12V external Power supply
* Some of them might have an additional Servo motor to control a Pen or a Magnet Holder.

== Getting it to work ==
* Connect the XY Plotter using a Micro-USB Cable.
* Make sure the XY Plotter's 12V power supply is plugged in and that power is turned on (in addition to the USB Connection).
* Download the software "mDraw" either from the official [https://www.makeblock.com/project/xy-plotter-robot-kit|XY Plotter website] or from the Spiel und Objekt Buschcloud [https://nx16523.your-storageshare.de/s/CCW7oLcRdMbC7oS|here].

=== using the mDraw Firmware (Recommended) ===
* open mDraw
* In the drop-down Menu on the top right, select ''XY-Plotter''
* Make sure the Plotter is connected, the COM port should be connected in the lower right hand side of the software.
* Click '''Connect'''
* To apply the mDraw firmware, click '''Update Firmware'''
* Wait for the Firmware to Download onto the board
* Profit!
** Double-Clicking in the middle of the drawing area should move the Plotter to that point.
** Clicking on the house Icon should move the Plotter back to its initial 0,0 Position
** Feel free to explore the software. The plotters should work Out-Of-The-Box with the default settings of the Software. Please document if you Settings changed setting for other groups potentially using the Plotter. Here's an image of the setting as of 14.02.23: [[File:mDraw_settings.jpg|300px|mDraw setting page]]

=== using the official gitHub Firmware (Not Recommended) ===
* download the XY Plotter firmware from the [https://github.com/Makeblock-official/XY-Plotter-2.0|Makeblock GitHub page] or use the one that comes in the Spiel und Objekt Buschcloud folder.
* Open the Arduino file: XY-Plotter-2.0-master\software\GCodeParser.ino
* Make sure the Plotter is connected, then select the COM port as usual in the Arduino software.
* Contrary to the instructions on the official Firmware GitHub website, we selected ''"Arduino Uno"'' as our board type for success.
* Upload the code to the controller board
* The code is very, very slow, but it works. You can possibly adjust the values in the code itself to speed it up.
* we really recommend using the mDraw Firmware, it is much much faster.

== Using GCode ==

Once you have chosen a firmware (we really really suggest you use mDraw version of the firmware), you can use GCode Commands over Serial Communication to control the XY Plotter from Processing (or any other Serial compatible Code Environment).
 
GCode is a Command Set for CNC machines and 3D Printers that is often used to control and set up moving machines. The Makeblock XY Plotter uses GCode commands to move the stepper motors and the Servo into position, change its speed and other fun things.
 
GCode are submitted as Strings. For example:

G0 X100 Y100

moves the Plotter to the position 10cm to the right and 10cm forward from its initial home position (if the home position is on the bottom left).

If you want to test out GCode Commands, you can apply them directly in the Input field of the mDraw software (this works for both Firmware versions) or use an Arduino Serial Monitor. Just type the command and watch what happens.

=== Common GCode Commands for mDraw Firmware===
* G0 Xxxx Yyyy - moves the Plotter to xxx and yyy position in Millimeters from the Home Position
* G1 Xxxx Yyyy - - moves the Plotter to xxx and yyy position in Millimeters from the Home Position
* G28 - moves the Plotter to its 0,0 position
* M1 xxx - rotates the Servo (from 0 to 255, like any Arduino Servo). Note that the Servo setup of the XY Plotter usually assumes that you have a Pen or Magnet attached to the Plotter, and so a value of 80 is usually considered '''Pen Down''' and a value of 160 is usually considered '''Pen Up'''

Note: We reverse engineered some of this information from the mDraw Source Code, that you can see on the [https://github.com/Makeblock-official/mDrawBot/blob/master/mDrawGui/XYRobot.py|Makeblock official GitHub page] (Open Source for the win!), but you can also find really good info on this (thanks Clemens!) on [https://gist.github.com/heavysixer/511a7019a3c009027b83|this Github page!]

=== Common GCode Commands for official Firmware ===
* You can derive the GCode commands from the Source Code file in XY-Plotter-2.0-master\software\GCodeParser\process_string.io
* Maybe there is more stuff you can do with that firmware?
* What's nice about it though is that you can change the firmware yourself! It's just a .ino file!
* We really recommend you use the mDraw Version

== Project related Code ==

=== Be:B.E.R.N.D. ===
The following code connects a xy-plotter to unity and also simulates the movement of the plotter in the game view. A simple white plane represents the scale of the plotter and a white cube its movement.
The movement is controlled by the arrow keys.

GitHub [https://github.com/HfSDigital/XY-Plotter-Unity]

XY Plotter

2023-02-14T16:55:00Z

Fkirschner: /* Common GCode Commands for mDraw Firmware */

== XY Plotter ==

Spiel und Objekt besitzt drei [https://www.makeblock.com/project/xy-plotter-robot-kit|Makeblock XY Plotter].

[[File:xyPlotter_example.jpg|500px|An image of an xyPlotter during the 2023 GameJam at the FFT Düsseldorf]]
 
Given the age of the hardware, a lot of the documentation is out of date. This article will help you getting the device to work with your WINDOWS computer.

== Assembly Instructions ==
If, for some reason, a device broke or you need to reassemble it, here is a link to the [http://download.makeblock.com/XY/pdf/XY%20Plotter%20V2.0%20Assembly%20instructions%EF%BC%882016.6%EF%BC%89.pdf | official assembly guide]

== General Hardware Specifications ==
* They are controlled by a custom Arduino UNO compatible board with Custom Firmware.
* The two stepper motors are driven by a 12V external Power supply
* Some of them might have an additional Servo motor to control a Pen or a Magnet Holder.

== Getting it to work ==
* Connect the XY Plotter using a Micro-USB Cable.
* Make sure the XY Plotter's 12V power supply is plugged in and that power is turned on (in addition to the USB Connection).
* Download the software "mDraw" either from the official [https://www.makeblock.com/project/xy-plotter-robot-kit|XY Plotter website] or from the Spiel und Objekt Buschcloud [https://nx16523.your-storageshare.de/s/CCW7oLcRdMbC7oS|here].

=== using the mDraw Firmware (Recommended) ===
* open mDraw
* In the drop-down Menu on the top right, select ''XY-Plotter''
* Make sure the Plotter is connected, the COM port should be connected in the lower right hand side of the software.
* Click '''Connect'''
* To apply the mDraw firmware, click '''Update Firmware'''
* Wait for the Firmware to Download onto the board
* Profit!
** Double-Clicking in the middle of the drawing area should move the Plotter to that point.
** Clicking on the house Icon should move the Plotter back to its initial 0,0 Position
** Feel free to explore the software. The plotters should work Out-Of-The-Box with the default settings of the Software. Please document if you Settings changed setting for other groups potentially using the Plotter. Here's an image of the setting as of 14.02.23: [[File:mDraw_settings.jpg|300px|mDraw setting page]]

=== using the official gitHub Firmware (Not Recommended) ===
* download the XY Plotter firmware from the [https://github.com/Makeblock-official/XY-Plotter-2.0|Makeblock GitHub page] or use the one that comes in the Spiel und Objekt Buschcloud folder.
* Open the Arduino file: XY-Plotter-2.0-master\software\GCodeParser.ino
* Make sure the Plotter is connected, then select the COM port as usual in the Arduino software.
* Contrary to the instructions on the official Firmware GitHub website, we selected ''"Arduino Uno"'' as our board type for success.
* Upload the code to the controller board
* The code is very, very slow, but it works. You can possibly adjust the values in the code itself to speed it up.
* we really recommend using the mDraw Firmware, it is much much faster.

== Using GCode ==

Once you have chosen a firmware (we really really suggest you use mDraw version of the firmware), you can use GCode Commands over Serial Communication to control the XY Plotter from Processing (or any other Serial compatible Code Environment).
 
GCode is a Command Set for CNC machines and 3D Printers that is often used to control and set up moving machines. The Makeblock XY Plotter uses GCode commands to move the stepper motors and the Servo into position, change its speed and other fun things.
 
GCode are submitted as Strings. For example:

G0 X100 Y100

moves the Plotter to the position 10cm to the right and 10cm forward from its initial home position (if the home position is on the bottom left).

If you want to test out GCode Commands, you can apply them directly in the Input field of the mDraw software (this works for both Firmware versions) or use an Arduino Serial Monitor. Just type the command and watch what happens.

=== Common GCode Commands for mDraw Firmware===
* G0 Xxxx Yyyy - moves the Plotter to xxx and yyy position in Millimeters from the Home Position
* G1 Xxxx Yyyy - - moves the Plotter to xxx and yyy position in Millimeters from the Home Position
* G28 - moves the Plotter to its 0,0 position
* M1 xxx - rotates the Servo (from 0 to 255, like any Arduino Servo). Note that the Servo setup of the XY Plotter usually assumes that you have a Pen or Magnet attached to the Plotter, and so a value of 80 is usually considered '''Pen Down''' and a value of 160 is usually considered '''Pen Up'''

Note: We reverse engineered some of this information from the mDraw Source Code, that you can see on the [https://github.com/Makeblock-official/mDrawBot/blob/master/mDrawGui/XYRobot.py|Makeblock official GitHub page] (Open Source for the win!), but you can also find really good info on this (thanks Clemens!) on [https://gist.github.com/heavysixer/511a7019a3c009027b83
| this Github page!]

=== Common GCode Commands for official Firmware ===
* You can derive the GCode commands from the Source Code file in XY-Plotter-2.0-master\software\GCodeParser\process_string.io
* Maybe there is more stuff you can do with that firmware?
* What's nice about it though is that you can change the firmware yourself! It's just a .ino file!
* We really recommend you use the mDraw Version

== Project related Code ==

=== Be:B.E.R.N.D. ===
The following code connects a xy-plotter to unity and also simulates the movement of the plotter in the game view. A simple white plane represents the scale of the plotter and a white cube its movement.
The movement is controlled by the arrow keys.

GitHub [https://github.com/HfSDigital/XY-Plotter-Unity]

XY Plotter

2023-02-14T16:54:44Z

Fkirschner: /* Common GCode Commands for mDraw Firmware */

== XY Plotter ==

Spiel und Objekt besitzt drei [https://www.makeblock.com/project/xy-plotter-robot-kit|Makeblock XY Plotter].

[[File:xyPlotter_example.jpg|500px|An image of an xyPlotter during the 2023 GameJam at the FFT Düsseldorf]]
 
Given the age of the hardware, a lot of the documentation is out of date. This article will help you getting the device to work with your WINDOWS computer.

== Assembly Instructions ==
If, for some reason, a device broke or you need to reassemble it, here is a link to the [http://download.makeblock.com/XY/pdf/XY%20Plotter%20V2.0%20Assembly%20instructions%EF%BC%882016.6%EF%BC%89.pdf | official assembly guide]

== General Hardware Specifications ==
* They are controlled by a custom Arduino UNO compatible board with Custom Firmware.
* The two stepper motors are driven by a 12V external Power supply
* Some of them might have an additional Servo motor to control a Pen or a Magnet Holder.

== Getting it to work ==
* Connect the XY Plotter using a Micro-USB Cable.
* Make sure the XY Plotter's 12V power supply is plugged in and that power is turned on (in addition to the USB Connection).
* Download the software "mDraw" either from the official [https://www.makeblock.com/project/xy-plotter-robot-kit|XY Plotter website] or from the Spiel und Objekt Buschcloud [https://nx16523.your-storageshare.de/s/CCW7oLcRdMbC7oS|here].

=== using the mDraw Firmware (Recommended) ===
* open mDraw
* In the drop-down Menu on the top right, select ''XY-Plotter''
* Make sure the Plotter is connected, the COM port should be connected in the lower right hand side of the software.
* Click '''Connect'''
* To apply the mDraw firmware, click '''Update Firmware'''
* Wait for the Firmware to Download onto the board
* Profit!
** Double-Clicking in the middle of the drawing area should move the Plotter to that point.
** Clicking on the house Icon should move the Plotter back to its initial 0,0 Position
** Feel free to explore the software. The plotters should work Out-Of-The-Box with the default settings of the Software. Please document if you Settings changed setting for other groups potentially using the Plotter. Here's an image of the setting as of 14.02.23: [[File:mDraw_settings.jpg|300px|mDraw setting page]]

=== using the official gitHub Firmware (Not Recommended) ===
* download the XY Plotter firmware from the [https://github.com/Makeblock-official/XY-Plotter-2.0|Makeblock GitHub page] or use the one that comes in the Spiel und Objekt Buschcloud folder.
* Open the Arduino file: XY-Plotter-2.0-master\software\GCodeParser.ino
* Make sure the Plotter is connected, then select the COM port as usual in the Arduino software.
* Contrary to the instructions on the official Firmware GitHub website, we selected ''"Arduino Uno"'' as our board type for success.
* Upload the code to the controller board
* The code is very, very slow, but it works. You can possibly adjust the values in the code itself to speed it up.
* we really recommend using the mDraw Firmware, it is much much faster.

== Using GCode ==

Once you have chosen a firmware (we really really suggest you use mDraw version of the firmware), you can use GCode Commands over Serial Communication to control the XY Plotter from Processing (or any other Serial compatible Code Environment).
 
GCode is a Command Set for CNC machines and 3D Printers that is often used to control and set up moving machines. The Makeblock XY Plotter uses GCode commands to move the stepper motors and the Servo into position, change its speed and other fun things.
 
GCode are submitted as Strings. For example:

G0 X100 Y100

moves the Plotter to the position 10cm to the right and 10cm forward from its initial home position (if the home position is on the bottom left).

If you want to test out GCode Commands, you can apply them directly in the Input field of the mDraw software (this works for both Firmware versions) or use an Arduino Serial Monitor. Just type the command and watch what happens.

=== Common GCode Commands for mDraw Firmware===
* G0 Xxxx Yyyy - moves the Plotter to xxx and yyy position in Millimeters from the Home Position
* G1 Xxxx Yyyy - - moves the Plotter to xxx and yyy position in Millimeters from the Home Position
* G28 - moves the Plotter to its 0,0 position
* M1 xxx - rotates the Servo (from 0 to 255, like any Arduino Servo). Note that the Servo setup of the XY Plotter usually assumes that you have a Pen or Magnet attached to the Plotter, and so a value of 80 is usually considered '''Pen Down''' and a value of 160 is usually considered '''Pen Up'''

Note: We reverse engineered some of this information from the mDraw Source Code, that you can see on the [https://github.com/Makeblock-official/mDrawBot/blob/master/mDrawGui/XYRobot.py|Makeblock official GitHub page] (Open Source for the win!), but you can also find really good info on this (thanks Clemens!) on [https://gist.github.com/heavysixer/511a7019a3c009027b83
|this Github page!]

=== Common GCode Commands for official Firmware ===
* You can derive the GCode commands from the Source Code file in XY-Plotter-2.0-master\software\GCodeParser\process_string.io
* Maybe there is more stuff you can do with that firmware?
* What's nice about it though is that you can change the firmware yourself! It's just a .ino file!
* We really recommend you use the mDraw Version

== Project related Code ==

=== Be:B.E.R.N.D. ===
The following code connects a xy-plotter to unity and also simulates the movement of the plotter in the game view. A simple white plane represents the scale of the plotter and a white cube its movement.
The movement is controlled by the arrow keys.

GitHub [https://github.com/HfSDigital/XY-Plotter-Unity]

XY Plotter

2023-02-14T16:45:29Z

Fkirschner: /* Common GCode Commands for mDraw Firmware */

== XY Plotter ==

Spiel und Objekt besitzt drei [https://www.makeblock.com/project/xy-plotter-robot-kit|Makeblock XY Plotter].

[[File:xyPlotter_example.jpg|500px|An image of an xyPlotter during the 2023 GameJam at the FFT Düsseldorf]]
 
Given the age of the hardware, a lot of the documentation is out of date. This article will help you getting the device to work with your WINDOWS computer.

== Assembly Instructions ==
If, for some reason, a device broke or you need to reassemble it, here is a link to the [http://download.makeblock.com/XY/pdf/XY%20Plotter%20V2.0%20Assembly%20instructions%EF%BC%882016.6%EF%BC%89.pdf | official assembly guide]

== General Hardware Specifications ==
* They are controlled by a custom Arduino UNO compatible board with Custom Firmware.
* The two stepper motors are driven by a 12V external Power supply
* Some of them might have an additional Servo motor to control a Pen or a Magnet Holder.

== Getting it to work ==
* Connect the XY Plotter using a Micro-USB Cable.
* Make sure the XY Plotter's 12V power supply is plugged in and that power is turned on (in addition to the USB Connection).
* Download the software "mDraw" either from the official [https://www.makeblock.com/project/xy-plotter-robot-kit|XY Plotter website] or from the Spiel und Objekt Buschcloud [https://nx16523.your-storageshare.de/s/CCW7oLcRdMbC7oS|here].

=== using the mDraw Firmware (Recommended) ===
* open mDraw
* In the drop-down Menu on the top right, select ''XY-Plotter''
* Make sure the Plotter is connected, the COM port should be connected in the lower right hand side of the software.
* Click '''Connect'''
* To apply the mDraw firmware, click '''Update Firmware'''
* Wait for the Firmware to Download onto the board
* Profit!
** Double-Clicking in the middle of the drawing area should move the Plotter to that point.
** Clicking on the house Icon should move the Plotter back to its initial 0,0 Position
** Feel free to explore the software. The plotters should work Out-Of-The-Box with the default settings of the Software. Please document if you Settings changed setting for other groups potentially using the Plotter. Here's an image of the setting as of 14.02.23: [[File:mDraw_settings.jpg|300px|mDraw setting page]]

=== using the official gitHub Firmware (Not Recommended) ===
* download the XY Plotter firmware from the [https://github.com/Makeblock-official/XY-Plotter-2.0|Makeblock GitHub page] or use the one that comes in the Spiel und Objekt Buschcloud folder.
* Open the Arduino file: XY-Plotter-2.0-master\software\GCodeParser.ino
* Make sure the Plotter is connected, then select the COM port as usual in the Arduino software.
* Contrary to the instructions on the official Firmware GitHub website, we selected ''"Arduino Uno"'' as our board type for success.
* Upload the code to the controller board
* The code is very, very slow, but it works. You can possibly adjust the values in the code itself to speed it up.
* we really recommend using the mDraw Firmware, it is much much faster.

== Using GCode ==

Once you have chosen a firmware (we really really suggest you use mDraw version of the firmware), you can use GCode Commands over Serial Communication to control the XY Plotter from Processing (or any other Serial compatible Code Environment).
 
GCode is a Command Set for CNC machines and 3D Printers that is often used to control and set up moving machines. The Makeblock XY Plotter uses GCode commands to move the stepper motors and the Servo into position, change its speed and other fun things.
 
GCode are submitted as Strings. For example:

G0 X100 Y100

moves the Plotter to the position 10cm to the right and 10cm forward from its initial home position (if the home position is on the bottom left).

If you want to test out GCode Commands, you can apply them directly in the Input field of the mDraw software (this works for both Firmware versions) or use an Arduino Serial Monitor. Just type the command and watch what happens.

=== Common GCode Commands for mDraw Firmware===
* G0 Xxxx Yyyy - moves the Plotter to xxx and yyy position in Millimeters from the Home Position
* G1 Xxxx Yyyy - - moves the Plotter to xxx and yyy position in Millimeters from the Home Position
* G28 - moves the Plotter to its 0,0 position
* M1 xxx - rotates the Servo (from 0 to 255, like any Arduino Servo). Note that the Servo setup of the XY Plotter usually assumes that you have a Pen or Magnet attached to the Plotter, and so a value of 80 is usually considered '''Pen Down''' and a value of 160 is usually considered '''Pen Up'''

=== Common GCode Commands for official Firmware ===
* You can derive the GCode commands from the Source Code file in XY-Plotter-2.0-master\software\GCodeParser\process_string.io
* Maybe there is more stuff you can do with that firmware?
* What's nice about it though is that you can change the firmware yourself! It's just a .ino file!
* We really recommend you use the mDraw Version

== Project related Code ==

=== Be:B.E.R.N.D. ===
The following code connects a xy-plotter to unity and also simulates the movement of the plotter in the game view. A simple white plane represents the scale of the plotter and a white cube its movement.
The movement is controlled by the arrow keys.

GitHub [https://github.com/HfSDigital/XY-Plotter-Unity]

XY Plotter

2023-02-14T16:39:16Z

Fkirschner: /* Using GCode */

== XY Plotter ==

Spiel und Objekt besitzt drei [https://www.makeblock.com/project/xy-plotter-robot-kit|Makeblock XY Plotter].

[[File:xyPlotter_example.jpg|500px|An image of an xyPlotter during the 2023 GameJam at the FFT Düsseldorf]]
 
Given the age of the hardware, a lot of the documentation is out of date. This article will help you getting the device to work with your WINDOWS computer.

== Assembly Instructions ==
If, for some reason, a device broke or you need to reassemble it, here is a link to the [http://download.makeblock.com/XY/pdf/XY%20Plotter%20V2.0%20Assembly%20instructions%EF%BC%882016.6%EF%BC%89.pdf | official assembly guide]

== General Hardware Specifications ==
* They are controlled by a custom Arduino UNO compatible board with Custom Firmware.
* The two stepper motors are driven by a 12V external Power supply
* Some of them might have an additional Servo motor to control a Pen or a Magnet Holder.

== Getting it to work ==
* Connect the XY Plotter using a Micro-USB Cable.
* Make sure the XY Plotter's 12V power supply is plugged in and that power is turned on (in addition to the USB Connection).
* Download the software "mDraw" either from the official [https://www.makeblock.com/project/xy-plotter-robot-kit|XY Plotter website] or from the Spiel und Objekt Buschcloud [https://nx16523.your-storageshare.de/s/CCW7oLcRdMbC7oS|here].

=== using the mDraw Firmware (Recommended) ===
* open mDraw
* In the drop-down Menu on the top right, select ''XY-Plotter''
* Make sure the Plotter is connected, the COM port should be connected in the lower right hand side of the software.
* Click '''Connect'''
* To apply the mDraw firmware, click '''Update Firmware'''
* Wait for the Firmware to Download onto the board
* Profit!
** Double-Clicking in the middle of the drawing area should move the Plotter to that point.
** Clicking on the house Icon should move the Plotter back to its initial 0,0 Position
** Feel free to explore the software. The plotters should work Out-Of-The-Box with the default settings of the Software. Please document if you Settings changed setting for other groups potentially using the Plotter. Here's an image of the setting as of 14.02.23: [[File:mDraw_settings.jpg|300px|mDraw setting page]]

=== using the official gitHub Firmware (Not Recommended) ===
* download the XY Plotter firmware from the [https://github.com/Makeblock-official/XY-Plotter-2.0|Makeblock GitHub page] or use the one that comes in the Spiel und Objekt Buschcloud folder.
* Open the Arduino file: XY-Plotter-2.0-master\software\GCodeParser.ino
* Make sure the Plotter is connected, then select the COM port as usual in the Arduino software.
* Contrary to the instructions on the official Firmware GitHub website, we selected ''"Arduino Uno"'' as our board type for success.
* Upload the code to the controller board
* The code is very, very slow, but it works. You can possibly adjust the values in the code itself to speed it up.
* we really recommend using the mDraw Firmware, it is much much faster.

== Using GCode ==

Once you have chosen a firmware (we really really suggest you use mDraw version of the firmware), you can use GCode Commands over Serial Communication to control the XY Plotter from Processing (or any other Serial compatible Code Environment).
 
GCode is a Command Set for CNC machines and 3D Printers that is often used to control and set up moving machines. The Makeblock XY Plotter uses GCode commands to move the stepper motors and the Servo into position, change its speed and other fun things.
 
GCode are submitted as Strings. For example:

G0 X100 Y100

moves the Plotter to the position 10cm to the right and 10cm forward from its initial home position (if the home position is on the bottom left).

If you want to test out GCode Commands, you can apply them directly in the Input field of the mDraw software (this works for both Firmware versions) or use an Arduino Serial Monitor. Just type the command and watch what happens.

=== Common GCode Commands for mDraw Firmware===
* G0 Xxxx Yyyy - moves the Plotter to xxx and yyy position in Millimeters from the Home Position
* G1 Xxxx Yyyy - - moves the Plotter to xxx and yyy position in Millimeters from the Home Position
* G28 - moves the Plotter to its 0,0 position
* M1 xxx - rotates the Servo (from 0 to 255, like any Arduino Servo). Note that the Servo setup of the XY Plotter usually assumes that you have a Pen or Magnet attached to the Plotter, and so a value of 80 is usually considered '''Pen Down''' and a value of 160 is usually considered '''Pen Up'''

== Project related Code ==

=== Be:B.E.R.N.D. ===
The following code connects a xy-plotter to unity and also simulates the movement of the plotter in the game view. A simple white plane represents the scale of the plotter and a white cube its movement.
The movement is controlled by the arrow keys.

GitHub [https://github.com/HfSDigital/XY-Plotter-Unity]

XY Plotter

2023-02-14T15:58:30Z

Fkirschner: /* using the mDraw Firmware (Recommended) */

Datei:MDraw settings.jpg

2023-02-14T15:57:56Z

Fkirschner:

XY Plotter

2023-02-14T15:56:55Z

Fkirschner: /* Getting it to work */

XY Plotter

2023-02-14T15:31:25Z

Fkirschner: /* General Hardware specifications */

XY Plotter

2023-02-14T15:30:50Z

Fkirschner:

XY Plotter

2023-02-14T15:21:26Z

Fkirschner:

Hauptseite

2023-02-14T15:20:38Z

Fkirschner: /* XY Plotter */

Willkommen auf dem Spiel und Objekt Wiki! 

Auf diesen Seiten legen wir Referenzen, Projektdokumentationen, Literaturhinweise, Kursmitschriften und Best Practices ab. 

=P R A X I S=

== Kurse ==

=== Spiel && Objekt ===

====WS2018/19====
*[[SpieleDesign|Spiel und Theater]]
*[[PartizipationÜbungen|Übungen Partizipation]]
*[[NeueMedienGesellschaft|Neue Medien und Gesellschaft]]

====SS2020====
*[[Vernetzte Räume]]
*[[From Space to Space]]

====WS2020/21====
*[[Least Likely]]
*[[Soft Soft]]
*[[Cyber+Technofeminism]]

====SS2021====
*[[Everything is Talkative]]

====WS2021/22====
*[[Communicating Bodies]]
*[[Soziale Architektur 2]]
*[[Spekulative Objekte]]
*[[Künstlerische Forschung]]

====SS2022====
*[[Wireless Workshop]]

=== Zeitgenössische Puppenspielkunst HfS ===
*[https://www.kobakant.at/DIY/?p=8139 #e-textile-adventures] (SS2020)
*[https://www.kobakant.at/DIY/?p=9038 #paper-adventures] (SS2021)
*[https://www.kobakant.at/DIY/?p=9545 Sensitive Puppets] (SS2022)

=== Kooperation Uni Bremen ===
*[[OeffentlichkeitTheorie| Öffentlichkeit bei Habermas und Luhmann]]

==Projekte==

===1. Jahrgang (2018-2020)===
*[[Be Bernd]]
*[[Wir Alle Spielen Theater]]
*[[Altruistic Modification]]
*[[Archäologischer Park- Die Villa]]
*[[Futopolis]]
*[[Kalte Ecken im Koffer]]

===2. Jahrgang (2020-2022)===
*[[Random Acts of Vulnerability]]
*[[Wir Haben Fragen]]

== Recherchen ==

=== Künstlerische ===
*[[BioArt]]
*[[Feminismus]]
*[[VideoAsSculpture]]
*[[SpieleDesign]]
*[[NoScreens]]
*[[DesignFiction]]
*[[NetworkedArt|Networked Theatre, Performance, Art, Culture...]]
*[[Donna Haraway]]

=== Technische ===
*[[Schreiben]]
*[[Capturing Process]]
*[[Websites]]
*[[Ticketing]]

= T E C H N I K =
== Inventar ==
*[[Spiel&&Objekt Gadgets]]

=== KITS ===
*[[S&&O KIT]] (brought to you by the [[Labor für Digitalität]])
*[[world meets computer KIT]] (from the course [[Least Likely]] Scenario)
*[[softsoft KIT]] (from the course [[Soft Soft]])
*[[spaghetti monster KIT]] (from the course [[Communicating Bodies]])
*[[Dome Pod KIT]]s
*[[mini Dome Pod Staw KIT]]

== Fabrication ==
*[[How to: 3D Drucken]]
*[[How to: build a mini Dome Pod from Drinking Straws]]
*Circuits
**[[How to: make PCBs]] (coming soon...)
**[[Wire]]

== Physical Computing ==

*[[Arduino| Arduino Übersicht]]

*[[Sensors]]
*[[Actuators]]
**[[Audio Amplification]]
*[[Motors | Motors Overview]]
**[[Stepper Motor and Driver]]
**[[Servo Motor Control]]
*[[Transistors]]
*[[Widerstände]] (Resistors)
*[[Voltage Divider]] (Spannungs-Teiler)
*[[Voltage Divider what?]]

=== Physical Computing Examples ===
*[[Making Sound with Sensors]]
*[[Bewässerungsanlage mit Arduino Uno und DIY-Feuchtigkeitssensor]]

== Programming ==

=== Unity ===
*[[Unity]]
*[[Online_Multiplayer]]
*[[BasicMultiplayerFramework|Virtuelle Multiuser Räume]]

=== p5.js (Javascript) ===
*[[p5 Overview]]

===Arduino===
*[[smoothing analog sensor values]]

====ESP mit Arduino====
*[[ESP32 mit Arduino | ESP32 Dev Module mit Arduino programmieren]]
*[[ESP8266 Lolin mit Arduino]] programmieren

====ESP32,ESP8266 mit micropython====
*[[arduino vs. micropython]]
*[[micropython install]]
*[[Empfehlungen micropython]]
*[[uPyCraft]]
*[[DMX_MQTT_CONTROLLER]]

===Miscellaneous===
*[[Multiple_Keyboards_with_RaspberryPi_and_OSC|Mehrere Keyboards/RFID Reader an ein RaspberryPi, mit OSC ins Netzwerk]]
*[[Raspberry Pi - Helfende Befehle]]

== Kommunikation / Netzwerkommunikation ==

=== Wireless Kommunikation ===
*see: [[Wireless Workshop]]

=== WIFI ===
*[[Wifi what?]]
*[[Ubiquiti WiFi|Stabiles WiFi auf der Bühne]]
*[[AsusRP-N53|Access Point mit dem Asus RP-N53]]
*[[Asus RT-AC68U|WLan mit dem Asus RT-AC68U]]

=== OSC Protocol ===
*[[OSC what?]]
*[[OSC in Arduino]]
*[[OSC in Processing]]
*[[OSC between Arduino and Processing]]
*[[OSC in vvvv]]
*[[OSC in Unity]]

=== MQTT Protocol ===
*[[MQTT what?]]
MQTT Brokers:
*[[MQTT Brokers]] (online server, localhost)
*[[Build your own MQTT Broker]]
MQTT Clients:
*[[MQTT in Arduino]] (Shiftr library)
*[[MQTT in Arduino 2]] (different library)
*[[MQTT in Processing]] (Shiftr library)
*[[MQTT between Arduino and Processing]]
*[[MQTT in vvvv]]
*[[MQTT in pure data]] (vom [[Communicating Bodies]] Kurs)
*[[MQTT in Unity]]

*[[Mqtt to Unity via shiftr.io | How to send Data from ESP to Unity with Mqtt protocol]]
*[[MQTT implementation in Basic Multiplayer via webGL Client | Shiftr.io/MQTT implementation in Basic Multiplayer via webGL Client]]

==== MQTT Examples ====
*[[PubSub_3sensors_onChange_asSeperateTopics]] (ESP & Arduino)
*[[PubSub_3sensors_continuous_asStringList]] (ESP & Arduino)
*[[Pub_3sensors_continuous_asStringList and Sub_3sensors_control3Servos]] (ESP & Arduino)

=== RFID ===
*[[User Login|Einloggen an einer Station mit einem Avatar]]

=== XY Plotter ===
Please refer to this page if you want to use the [[XY Plotter | XyPlotter]].

== Video Technik ==
''Alles, was dir deine Eltern nicht zum Thema '''Videoübertragung''' erzählt haben.''
Oft ist ein PC als Schnittstelle zwischer Kamera und Bildschirm/Projektor sinnvoll oder nötig. Doch es gibt auch Fälle, in denen eine unkomplizierte, direkte Verbindung einfacher und besser ist.

=== Verbindung Kamera<->Ausgabegerät ===
*[[NX500|NX500 ⇒ Bildschirm oder Projektor]]

=== PC als Schnittstelle ===
*[[Der Videomischer]]
*[[Blackmagic Intensity|Blackmagic Intensity ⇒ PC]]

= T H E O R I E =

== Glossare, Begriffe und Konzepte ==
* [[GlossarCG|Begriffe der Computergrafik]]
* [[GlossarSensorActuator|Sensoren und Aktuatoren]]
* [[Algorithms|Common Algorithms]]
* [[Glossar Code|Code Glossar]]
* [[Glossar Elektronik|Elektronik Glossar]]
* [[Netzwerk]]
* [[Interaktionstaxonomie AR]]
* [[Bibliothek|Literatur Bibliothek]]

=P R A K T I S C H E S=

==Stuff==
** [[Shopping]]
** [[Events]]

==Hack your "Theater" - How To==
*[[for Theaterleitung]]
*[[for Künstler*innen]]

==Wiki Help==
*[[how to structure documentation well]]
*[[cheatsheet]]
*[https://www.mediawiki.org/wiki/Help:Formatting Hilfe: Formatierung]
*[https://www.mediawiki.org/wiki/Help:Links Hilfe: Links]
*[[ignore wiki syntax]]
*[[code syntax highlighting]]
*[[text scroll box]

=In Arbeit=
*[[OSC Kommunikation in Processing]]
*[[software architecture in theatre]]
*[[Verbindung Arduino / Unity - Research Diary]]
*[[TFT LCD Shield|2.6"/2.8" TFT LCD Shield mit Touch]]
*[[Trying out Wikistuff]]

Datei:XyPlotter example.jpg

2023-02-14T15:19:16Z

Fkirschner:

XY Plotter

2023-02-14T15:15:20Z

Fkirschner: Die Seite wurde neu angelegt: „== XY Plotter == Spiel und Objekt besitzt drei [https://www.makeblock.com/project/xy-plotter-robot-kit|Makeblock XY Plotter]. An image of an xyPlotter during the 2023 GameJam at the FFT Düsseldorf Given the age of the hardware, a lot of the documentation is out of date. This article will help you getting the device to work with your WINDOWS computer. == General Hardware specifications == * They are controlle…“

Hauptseite

2023-02-14T15:07:16Z

Fkirschner: /* XY Plotter */

Willkommen auf dem Spiel und Objekt Wiki! 

Auf diesen Seiten legen wir Referenzen, Projektdokumentationen, Literaturhinweise, Kursmitschriften und Best Practices ab. 

=P R A X I S=

== Kurse ==

=== Spiel && Objekt ===

====WS2018/19====
*[[SpieleDesign|Spiel und Theater]]
*[[PartizipationÜbungen|Übungen Partizipation]]
*[[NeueMedienGesellschaft|Neue Medien und Gesellschaft]]

====SS2020====
*[[Vernetzte Räume]]
*[[From Space to Space]]

====WS2020/21====
*[[Least Likely]]
*[[Soft Soft]]
*[[Cyber+Technofeminism]]

====SS2021====
*[[Everything is Talkative]]

====WS2021/22====
*[[Communicating Bodies]]
*[[Soziale Architektur 2]]
*[[Spekulative Objekte]]
*[[Künstlerische Forschung]]

====SS2022====
*[[Wireless Workshop]]

=== Zeitgenössische Puppenspielkunst HfS ===
*[https://www.kobakant.at/DIY/?p=8139 #e-textile-adventures] (SS2020)
*[https://www.kobakant.at/DIY/?p=9038 #paper-adventures] (SS2021)
*[https://www.kobakant.at/DIY/?p=9545 Sensitive Puppets] (SS2022)

=== Kooperation Uni Bremen ===
*[[OeffentlichkeitTheorie| Öffentlichkeit bei Habermas und Luhmann]]

==Projekte==

===1. Jahrgang (2018-2020)===
*[[Be Bernd]]
*[[Wir Alle Spielen Theater]]
*[[Altruistic Modification]]
*[[Archäologischer Park- Die Villa]]
*[[Futopolis]]
*[[Kalte Ecken im Koffer]]

===2. Jahrgang (2020-2022)===
*[[Random Acts of Vulnerability]]
*[[Wir Haben Fragen]]

== Recherchen ==

=== Künstlerische ===
*[[BioArt]]
*[[Feminismus]]
*[[VideoAsSculpture]]
*[[SpieleDesign]]
*[[NoScreens]]
*[[DesignFiction]]
*[[NetworkedArt|Networked Theatre, Performance, Art, Culture...]]
*[[Donna Haraway]]

=== Technische ===
*[[Schreiben]]
*[[Capturing Process]]
*[[Websites]]
*[[Ticketing]]

= T E C H N I K =
== Inventar ==
*[[Spiel&&Objekt Gadgets]]

=== KITS ===
*[[S&&O KIT]] (brought to you by the [[Labor für Digitalität]])
*[[world meets computer KIT]] (from the course [[Least Likely]] Scenario)
*[[softsoft KIT]] (from the course [[Soft Soft]])
*[[spaghetti monster KIT]] (from the course [[Communicating Bodies]])
*[[Dome Pod KIT]]s
*[[mini Dome Pod Staw KIT]]

== Fabrication ==
*[[How to: 3D Drucken]]
*[[How to: build a mini Dome Pod from Drinking Straws]]
*Circuits
**[[How to: make PCBs]] (coming soon...)
**[[Wire]]

== Physical Computing ==

*[[Arduino| Arduino Übersicht]]

*[[Sensors]]
*[[Actuators]]
**[[Audio Amplification]]
*[[Motors | Motors Overview]]
**[[Stepper Motor and Driver]]
**[[Servo Motor Control]]
*[[Transistors]]
*[[Widerstände]] (Resistors)
*[[Voltage Divider]] (Spannungs-Teiler)
*[[Voltage Divider what?]]

=== Physical Computing Examples ===
*[[Making Sound with Sensors]]
*[[Bewässerungsanlage mit Arduino Uno und DIY-Feuchtigkeitssensor]]

== Programming ==

=== Unity ===
*[[Unity]]
*[[Online_Multiplayer]]
*[[BasicMultiplayerFramework|Virtuelle Multiuser Räume]]

=== p5.js (Javascript) ===
*[[p5 Overview]]

===Arduino===
*[[smoothing analog sensor values]]

====ESP mit Arduino====
*[[ESP32 mit Arduino | ESP32 Dev Module mit Arduino programmieren]]
*[[ESP8266 Lolin mit Arduino]] programmieren

====ESP32,ESP8266 mit micropython====
*[[arduino vs. micropython]]
*[[micropython install]]
*[[Empfehlungen micropython]]
*[[uPyCraft]]
*[[DMX_MQTT_CONTROLLER]]

===Miscellaneous===
*[[Multiple_Keyboards_with_RaspberryPi_and_OSC|Mehrere Keyboards/RFID Reader an ein RaspberryPi, mit OSC ins Netzwerk]]
*[[Raspberry Pi - Helfende Befehle]]

== Kommunikation / Netzwerkommunikation ==

=== Wireless Kommunikation ===
*see: [[Wireless Workshop]]

=== WIFI ===
*[[Wifi what?]]
*[[Ubiquiti WiFi|Stabiles WiFi auf der Bühne]]
*[[AsusRP-N53|Access Point mit dem Asus RP-N53]]
*[[Asus RT-AC68U|WLan mit dem Asus RT-AC68U]]

=== OSC Protocol ===
*[[OSC what?]]
*[[OSC in Arduino]]
*[[OSC in Processing]]
*[[OSC between Arduino and Processing]]
*[[OSC in vvvv]]
*[[OSC in Unity]]

=== MQTT Protocol ===
*[[MQTT what?]]
MQTT Brokers:
*[[MQTT Brokers]] (online server, localhost)
*[[Build your own MQTT Broker]]
MQTT Clients:
*[[MQTT in Arduino]] (Shiftr library)
*[[MQTT in Arduino 2]] (different library)
*[[MQTT in Processing]] (Shiftr library)
*[[MQTT between Arduino and Processing]]
*[[MQTT in vvvv]]
*[[MQTT in pure data]] (vom [[Communicating Bodies]] Kurs)
*[[MQTT in Unity]]

*[[Mqtt to Unity via shiftr.io | How to send Data from ESP to Unity with Mqtt protocol]]
*[[MQTT implementation in Basic Multiplayer via webGL Client | Shiftr.io/MQTT implementation in Basic Multiplayer via webGL Client]]

==== MQTT Examples ====
*[[PubSub_3sensors_onChange_asSeperateTopics]] (ESP & Arduino)
*[[PubSub_3sensors_continuous_asStringList]] (ESP & Arduino)
*[[Pub_3sensors_continuous_asStringList and Sub_3sensors_control3Servos]] (ESP & Arduino)

=== RFID ===
*[[User Login|Einloggen an einer Station mit einem Avatar]]

=== XY Plotter ===
[[XY Plotter | XyPlotter]]

The following code connects a xy-plotter to unity and also simulates the movement of the plotter in the game view. A simple white plane represents the scale of the plotter and a white cube its movement.
The movement is controlled by the arrow keys.

GitHub [https://github.com/HfSDigital/XY-Plotter-Unity]

== Video Technik ==
''Alles, was dir deine Eltern nicht zum Thema '''Videoübertragung''' erzählt haben.''
Oft ist ein PC als Schnittstelle zwischer Kamera und Bildschirm/Projektor sinnvoll oder nötig. Doch es gibt auch Fälle, in denen eine unkomplizierte, direkte Verbindung einfacher und besser ist.

=== Verbindung Kamera<->Ausgabegerät ===
*[[NX500|NX500 ⇒ Bildschirm oder Projektor]]

=== PC als Schnittstelle ===
*[[Der Videomischer]]
*[[Blackmagic Intensity|Blackmagic Intensity ⇒ PC]]

= T H E O R I E =

== Glossare, Begriffe und Konzepte ==
* [[GlossarCG|Begriffe der Computergrafik]]
* [[GlossarSensorActuator|Sensoren und Aktuatoren]]
* [[Algorithms|Common Algorithms]]
* [[Glossar Code|Code Glossar]]
* [[Glossar Elektronik|Elektronik Glossar]]
* [[Netzwerk]]
* [[Interaktionstaxonomie AR]]
* [[Bibliothek|Literatur Bibliothek]]

=P R A K T I S C H E S=

==Stuff==
** [[Shopping]]
** [[Events]]

==Hack your "Theater" - How To==
*[[for Theaterleitung]]
*[[for Künstler*innen]]

==Wiki Help==
*[[how to structure documentation well]]
*[[cheatsheet]]
*[https://www.mediawiki.org/wiki/Help:Formatting Hilfe: Formatierung]
*[https://www.mediawiki.org/wiki/Help:Links Hilfe: Links]
*[[ignore wiki syntax]]
*[[code syntax highlighting]]
*[[text scroll box]

=In Arbeit=
*[[OSC Kommunikation in Processing]]
*[[software architecture in theatre]]
*[[Verbindung Arduino / Unity - Research Diary]]
*[[TFT LCD Shield|2.6"/2.8" TFT LCD Shield mit Touch]]
*[[Trying out Wikistuff]]

OSC in Unity

2022-02-03T18:48:33Z

Fkirschner: /* Herunterladen des externen OSC Codes */

= OSC in Unity =
Um von anderen Programmen (z.B. Processing) Daten an Unity zu senden, verwenden wir das IP Protokoll und eine OSC Library. Das heisst, das Device auf dem das Unity Programm laufen soll (Computer oder Tablet) muss mit einem [[Netzwerk]] verbunden sein und eine '''IP-Adresse''' besitzen. OSC basiert wiederum auf dem UDP Protokoll, das vor allem in lokalen Netzwerken gut funktioniert. Mehr Infos zu Protokollen und Netzwerken gibt es auf der [[Netzwerk]] Seite.

== externen OSC Code in unser Projekt einfügen ==

=== Herunterladen des externen OSC Codes ===
Code für die Implementierung von OSC in Unity gibt es auf [https://github.com/thomasfredericks/UnityOSC/releases | der github Seite von Thomas Fredericks unter ''Releases''], eine kurze Erklärung und ein Beispiel auf [https://thomasfredericks.github.io/UnityOSC/| seiner Webseite]. Für uns ist der Release '''For Unity 2018''' relevant (funktioniert auch bis Unity 2020.3).

Nachdem wir den SourceCode als .zip heruntergeladen haben, erstellen wir am Besten ein neues Unity Projekt mit dem Standard Template (3D). Wenn ihr bereits ein Unity Projekt habt, in dem ihr OSC verwenden möchtet, dann könnt ihr diesen Schritt gerne überspringen. :-) 

Die von uns hier verwendete OSC-Implementierung funktioniert nachgewiesen auf Unity 2019.4 und Unity 2020.3. Gerne könnt ihr 2020.3 nutzen. 
[[Datei:new-osc-test-project.jpg|600px]] 

=== Einfügen des externen OSC Codes in unser Projekt ===

Nachdem wir das Projekt erstellt haben, und der Unity Editor das Projekt geöffnet hat, kopieren wir den Inhalt der heruntergeladenen .zip Datei in den Projektordner unseres neu erstellten Projekts, wie hier angezeigt: 
[[Datei:copy_osc_to_new_unity_project.jpg|800px]] 

Windows fragt, ob wir einige der zu kopierenden Dateien überschreiben oder überspringen wollen. In diesem Fall würden wir sie '''überspringen'''. Beides ist aber okay.

Wenn wir zurück zu Unity wechseln, werden nach einem kurzen Moment des Importierens im Project Tab einige neue Dateien angezeigt: 
[[Datei:imported-Osc-unity.jpg|800px]] 

=== Aufräumen ===
Für die Anleitung hier im Wiki werden wir nicht vom mitgelieferten beispiel ausgehen, deswegen würde ich die 5 Dateien die von OSC direkt in den Assets Folder kopiert worden sind direkt in den Extras-Ordner verschieben, um die Übersicht im Projekt zu behalten: 
[[Datei:move-unnecessary-example-osc-unity.jpg|600px]] 
Ebenso lohnt es sich, direkt im Assets Folder einen Ordner zu erstellen, den wir '''Scripts''' nennen, und in dem wir unsere eigenen Scripte speichern werden: 
[[Datei:Unity-scripts-folder-osc-example.jpeg|400px]] 

== OSC in unserer Szene benutzen ==
Nachdem wir den OSC Code erfolgreich ins Projekt importiert haben, können wir nur beispielhaft damit arbeiten. Hierfür müssen wir das externe OSC.cs Script auf ein GameObject in unserer Szene legen.
Wir wollen im weiteren Verlauf Scripte schreiben, die auf die Funktionen des OSC.cs Scripts zugreifen können. Dafür müssen wir das OSC.cs Script in ein GameObject in der Szene einfügen.

=== Einfügen des OSC Scripts in die Szene ===
Dafür erstellen wir am Besten ein neues, leeres Gameobject in unserer Hierarchy und nennen es "OSC"(wir könnten es auch anders nennen) : 
[[Datei:create-osc-gameobject.jpg|600px]] 
Dann wählen wir das eben erstellte Gameobject in unserer Hierarchy an und ziehen das OSC.cs Script aus dem Ordner OSC in unserem Project Tab in den Inspector: 
[[Datei:place-osc-script-on-gameobject.jpg|600px]] 

=== Einstellungen im OSC Script ===
Wenn wir das Script eingefügt haben, können wir einige Variablen ändern, die mit unserer Nutzung von OSC im weiteren Verlauf zu tun haben: 
[[Datei:osc-script-explained.jpg|500px]] 

* '''inPort''' - steht für den Port, auf dem das OSC Script nach ankommenden OSC-Messages sucht. Im Processing OSC Beispiel ist der Port auf 12000 gesetzt, hier ist er Standardmässig auf 6969 gesetzt. Es lohnt sich, das direkt zu ändern, damit Processing und Unity direkt miteinander kommunizieren können.
* '''outIP''' - steht für die IP Adresse, an die unser OSC-Script im weiteren Verlauf OSC-Messages ''schicken'' kann.
* '''outPort''' - steht für den Port, an dem geschickte OSC-Messages ankommen werden.

'''Wichtig:''' der inPort wird von Unity für das Betriebssystem reserviert, wenn wir auf Play drücken. Das heisst, kein anderes Programm kann dann auf diesen Port zugreifen, bzw. es gibt eine Fehlermeldung, wenn ein Anderes Programm schon diesen Port reserviert hat. Wenn ihr das Processing Beispiel gleichzeitig laufen habt können nicht beide Programme den Port 12000 reservieren.

== OSC Nachrichten empfangen ==

Nun möchten wir über ein eigenes Script auf die OSC-Funktionalität des OSC Scripts zugreifen. ''Es gibt sehr viele verschiedene Wege das zu tun. Der hier angeführte Weg macht viele Dinge, die im weiteren Verlauf eleganter gelöst werden können. Es wird Kekse für elegantere Lösungen geben.'' 
* Hierzu erstellen wir ein neues, leeres GameObject in der Hierarchy und geben ihm den Namen "OSCempfangen": 
* Daraufhin erstellen wir in unserem Scripts-Ordner im Project Tab ein neues C# Script und nennen es OscReceive.cs (Gross-Kleinschreibung beachten! Scripte immer mit Grossbuchstaben beginnen!). ''Der Unterschied in der Namensgebung zwischen dem Gameobject und dem Script soll andeuten, dass diese Namen frei gewählt sind und nicht etwa eine versteckte Unity Funktionalität andeuten. Es lohnt sich, Scripte und Gameobjects nach dem zu benennen, was sie tun.''
* Schliesslich legen wir unser neu erstelltes Script auf das neu erstellte Gameobject, so dass es sich in unsere Szene befindet und ausgeführt wird. Daraufhin können wir mit der eigentlichen Programmierung beginnen. 
[[Datei:osc-oscreceive-setup.jpg|700px]]

=== In Code auf das externe OSC Script zugreifen ===
Wir haben nun in unserer Szene zwei Scripte als Components auf jeweils einem GameObject:
* Das OSC-Script, dass wir von extern haben. 
und: 
* Unser OscReceive Script, das wir jetzt schreiben wollen.

Wir möchten von unserem eigenen OscReceive-Script aus auf die Funktionen und Variablen des OSC Scripts zugreifen. Hierzu müssen wir in unserem Code eine Verbindung über eine Variable schaffen, durch die wir auf die Funktionen und Variablen des anderen Scripts zugreifen können: 
[[Datei:osc-connect-to-osc-cSharp.jpg|500px]] 

Ihr erinnert euch sicherlich, dass Scripte in Unity immer auch als Typ genutzt werden können, um von "aussen" auf alle Variablen und Funktionen dieses Scripts zugreifen zu können. Wir wollen also durch eine Variable vom Typ '''OSC''', die wir "myOSC" nennen (könnte auch anders heissen), auf die Funktionen und Variablen des OSC-Scripts zugreifen. 
Wir definieren diese Variable als public, damit wir sie im Unity Editor mit dem bereits in der Szene befindlichen OSC-Script verbinden können: 
[[Datei:connect-osc-script-in-editor.jpg|700px]] 

Nachdem wir diese Verbindung im Unity Editor geschaffen haben, können wir nun mit Hilfe von "myOSC" auf die Funktionalität des OSC Scripts zugreifen.

=== OSC Messages im eigenen Script empfangen ===
Um im eigenen Script OSC Messages zu empfangen, müssen wir selbst eine Funktion festlegen, die aufgerufen wird, wenn eine neue OSC-Message an unserem inPort ankommt. Das tun wir, indem wir folgende Funktion im OSC Script über unsere myOSC Variable ausführen: 

SetMessageHandler(''funktionsname'');

Dabei können wir uns den Funktionsnamen aussuchen. Er beschreibt eine Funktion, die in unserem Script stehen muss, und die ausgeführt wird, wenn messages ankommen. Ich schlage vor, wir nutzen den selben Namen wie bei Processing: ''OscEvent''. 

Da wir diese Funktion nur einmal ausführen müssen, um die Verbindung von "Message kommt an" zu "Funktion wird ausgeführt" einzustellen, macht es Sinn, diesen Funktionsaufruf in die "Start" Funktion unseres Scripts zu schreiben: 

public OSC myOSC;

// Start is called before the first frame update
void Start()
{
myOSC.SetAllMessageHandler(OscEvent);
}

Als nächstes müssen wir die Funktion selbst schreiben und festlegen, was passieren soll, wenn eine OscMessage ankommt. Wir fügen also eine neue Funktion in unser Script ein, die ''OscEvent'' heisst (weil wir sie so genannt haben), und die als Parameter eine Variable vom Typ OscMessage hat, die wir z.B. ''receivedMessage'' nennen können (weil wir es wollen, nicht müssen).
Diese Funktion muss einen Parameter vom Typ OscMessage haben, damit die verbindung von "Message kommt an" und "Funktion wird aufgerufen" funktioniert. Wie wir die Variable im Parameter nennen ist allerdings uns überlassen. 
Die Funktion würde dann so aussehen: 

void OscEvent(OscMessage receivedMessage)
{

}

Durch den Parameter bekommen wir automatisch die neueste, angekommene OscMessage zugespielt und können in dieser Funktion anfangen, mit ihr umzugehen. Unser Script sieht also inzwischen so aus: 
[[Datei:basic-osc-receive-script.JPG|500px]] 

=== OSC Message "auspacken" ===

Da wir jetzt davon ausgehen können, dass wir eine Funktion haben, die ausgeführt wird, wenn eine OscMessage am inPort ankommt, und eine Variable durch die wir Zugang zu dieser OscMessage haben (die wir ''receivedMessage'' genannt haben), können wir uns mit dem Inhalt der Message befassen. Ähnlich wie in Processing stehen uns mehrere Funktionen zur Verfügung, um auf die Inhalte der Message zuzugreifen: 

receivedMessage.address; //gibt uns die osc-Adresse der OSC-Message
receivedMessage.GetInt(index); //gibt uns eine ganze Zahl als Wert an der Stelle "index" zurück
receivedMessage.GetFloat(index); //gibt uns eine Kommazahl als Wert an der Stelle "index" zurück

receivedMessage.values[index]; //lässt uns direkt auf den Wert in der Liste an der Stelle "index" zugreifen

receivedMessage.values[index].ToString(); //gibt uns einen String als Wert an der Stelle "index" zurück

Ausgehend von unserem Processing-Code, den wir hier als Test-Sendeprogramm nutzen können, können wir unsere Funktion also folgendermassen schreiben: 
[[Datei:debug-osc-receive-script.jpg|600px]]

=== Wenn alles funktioniert ===
Hier ist ein Screenshot von Unity und Processing nebeneinander, mit einigen rot eingefärbten Bereichen. Könnt ihr euch erklären, wieso die rot eingefärbten Werte so gewählt wurden, wie sie gewählt wurden? 
[[Datei:osc-unity-processing-test-setup.JPG|1000px]] 

=== Where To From Here ===
In diesem Beispiel haben wir ein eigenes Script geschrieben, das nur dafür da ist, den Inhalt der OscMessage in die Konsole zu schreiben. In euren projekten wollt ihr sicherlich kompliziertere Dinge machen, wenn ihr OscMessages empfangt, und werdet vielleicht schon ein Script haben, das etwas bestimmtes macht (Ton abspielen, Dinge bewegen, etc.) wenn eine OscMessage empfangen wird. 
Wenn ihr aufmerksam mitgelesen habt, könnt ihr feststellen, dass ihr in jede eurer Scripte eine Funktion einbauen könnt, die aufgerufen wird, wenn eine OscMessage ankommt. Ihr müsst in eurem Script dafür dann folgendes tun:
* eine Verbindung zum OSC Script über eine public OSC ''myOSC'' Variable anlegen (wobei ihr myOSC auch anders nennen könnt).
* diese Verbindung im Editor verknüpfen, indem ihr das GameObject, auf dem das OSC Script liegt in diese Variable auf eurem Script zieht
* in eurer Start() Funktion die Funktion '''myOSC.SetAllMessageHandler(OscEvent);''' aufrufen (wobei eure Funktion auch anders heissen darf
* in eurem Script die Funktion ''void OscEvent(OscMessage myMessage){}'' schreiben. (wenn ihr eure Funktion anders genannt habt, dann hier den anderen Namen nutzen.)

Hier ein Beispiel eines Scripts, das jedes mal kleine Würfel aus einem Prefab generiert, wenn eine OscMessage ankommt: 
 
[[InstantiatePrefabOnOscMessage]]
 

Ihr könnt euch auch den Beispielcode anschauen, der bei der OSC-Implementierung dabei ist, [http://thomasfredericks.github.io/UnityOSC/| oder die Erklärungen auf der Webseite lesen]. Vielleicht entdeckt ihr ja noch ein paar weitere Funktionen, die man im OSC-Script nutzen kann.

== OSC Nachrichten verschicken ==
tbd.

== Beispielprojekte ==
Ein Projekt des ersten Jahrgangs Spiel und Objekt, das sehr viel OSC in Processing und Unity implementiert hat, ist [[Be Bernd]].

Saving in Unity

2021-11-16T11:59:25Z

Fkirschner: /* Daten als JSON speichern und lesen */

=Allgemeines zum Speichern=
Um Daten in Unity speichern und wieder laden zu können, schreiben wir für gewöhnlich eben diese Daten auf das Speichermedium unseres Devices (meistens eine Festplatte oder equivalent). Die Art und Weise, wie wir diese Daten ablegen ist dabe uns selbst überlassen. 
Tatsächlich gibt es mehrere standardisierte Verfahren,die dafür sorgen, dass sich Daten, die wir auf eine Festplatte geschrieben haben, wieder so lesen lassen, dass wir verstehen was gemeint war. Schlussendlich sind sämtliche Daten auf einer Festplatte als Bytes gespeichert, die durch von uns angesetzte Interpretation dann als Text, Zahl, Bild oder Ton wieder gelesen werden können.

=Wohin speichert Unity?=
=Daten als ASCII Text speichern und lesen=
=Daten als JSON speichern und lesen=
Unity stellt Funktionen bereit, die alle Variablen eines von uns selbst definierten Objects in eine Textdatei ausgeben, und aus dieser auch wieder herauslesen kann.
Hierzu generieren wir eine neue Klasse, die nicht von Monobehaviour abgeleitet ist, ungefähr so:

public class SaveData
{
int eineAnzahl=0;
string einText="hallowelt";
}

=Daten als WaveForm speichern und lesen=

Saving in Unity

2021-11-16T11:58:23Z

Fkirschner: Die Seite wurde neu angelegt: „=Allgemeines zum Speichern= Um Daten in Unity speichern und wieder laden zu können, schreiben wir für gewöhnlich eben diese Daten auf das Speichermedium uns…“

=Allgemeines zum Speichern=
Um Daten in Unity speichern und wieder laden zu können, schreiben wir für gewöhnlich eben diese Daten auf das Speichermedium unseres Devices (meistens eine Festplatte oder equivalent). Die Art und Weise, wie wir diese Daten ablegen ist dabe uns selbst überlassen. 
Tatsächlich gibt es mehrere standardisierte Verfahren,die dafür sorgen, dass sich Daten, die wir auf eine Festplatte geschrieben haben, wieder so lesen lassen, dass wir verstehen was gemeint war. Schlussendlich sind sämtliche Daten auf einer Festplatte als Bytes gespeichert, die durch von uns angesetzte Interpretation dann als Text, Zahl, Bild oder Ton wieder gelesen werden können.

=Wohin speichert Unity?=
=Daten als ASCII Text speichern und lesen=
=Daten als JSON speichern und lesen=
Unity stellt Funktionen bereit, die alle Variablen eines von uns selbst definierten Objects in eine Textdatei ausgeben, und aus dieser auch wieder herauslesen kann.
Hierzu generieren wir eine neue Klasse, die nicht von Monobehaviour abgeleitet ist, ungefähr so:

public class SaveData
{

int eineAnzahl=0;
string einText="hallowelt";
}

=Daten als WaveForm speichern und lesen=

Unity

2021-11-16T11:43:07Z

Fkirschner: /* Konzepte und Tutorials */

== Was ist Unity?==
Unity ist ein Programm, mit dessen Hilfe man eigene interaktive Applikationen und Visualisierungen herstellen kann. In Unity können wir eigene virtuelle Räume mit Hilfe des Unity Editors gestalten und mit eigenen Scripten, die in der Programmiersprache C# geschrieben werden, eigene Interaktionen in diesen Räumen festlegen. 

Unity wird oft auch als Game-Engine beschrieben.

== Für welche Geräte kann ich Unity nutzen?==
Wir benutzen den Unity Editor unter Windows 10, er läuft aber auch unter Mac OS. 
Im Unterricht nutzen wir den Unity Editor um Programme zu gestalten, die auf Windows, Mac OS, Android und WebGL laufen können. Man kann Unity zwar dafür verwenden, Programme für iOS zu gestalten, unser Studiengang deckt diese prozesse allerdings nicht ab.

==Welche Version von Unity nutzen wir?==
Wir verwenden für die Verwaltung unserer Projekte und Unity Versionen das programm '''Unity Hub'''. Damit ist es möglich, mehrere Versionen von Unity gleichzeitig installiert zu haben und jedes Projekt mit unterschiedlichen Versionen des Unity Editors zu bearbeiten.
Die momentan im Unterricht genutzten Versionen von Unity sind '''2020.3.x''' und '''2019.4.x'''.
Innerhalb der Stelle hinter dem zweiten Punkt in der Versionsnummer von Unity sollten Updates des Unity Editors für gewöhnlich kein Problem sein. Projekte die in 2019.4.12 angefangen wurden sollten problemlos unter 2019.4.18 laufen. Es empfiehlt sich nicht, alte Projekte mit grösseren Versionsunterschieden in neueren Versionen von Unity zu öffnen.

==Terminologie im Unity Editor==
[[Datei:Unity_Interface.jpg|1024px]]

==Begriffe==
* '''Projekt''' - ein Ordner auf dem Computer in dem sich eine ganze Reihe weiterer Ordner befinden. Es gibt nicht eine einzelne Projektdatei, sondern eine ganze Struktur an Dateien und Ordnern aus denen der Unity Editor das Projekt erstellt und manipulierbar macht. Deswegen lohnt es sich, Unity Projekte über den Unity Hub zu verwalten. Der Ablageort eines Projektes auf der Festplatte kann sich verschieben, solange die in ihm enthaltene Verzeichnisstruktur gewahrt bleibt.
* '''Szene''' - eine Datei im Asset Folder von Unity, in der eine bestimmte Konfiguration von GameObjects und Verknüpfungen zwischen ihnen gespeichert ist.
* '''GameObject''' - ein GameObject ist eine Datenstruktur innerhalb einer Szene in Unity. Alle GameObjects, unabhängig davon ob sie eine visuelle Repräsentation haben, sind in der Hierarchy ausgeführt. Scripte können für gewöhnlich nur ausgeführt werden, wenn sie als Component eines gameObjects in der Szene vorhanden sind.
* '''Script''' - unter einem Script verstehen wir eine mit Visual Studio in C# geschriebene Datei, die wir im Editor als Component auf GameObjects legen können, damit das Script ausgeführt wird. Scripts können auf mehrere GameObjects gleichzeitig gelegt werden, oder auch mehrmals auf dasselbe GameObject und laufen als eigenständige Instanzen jeweils so oft, wie sie in der Szene vorkommen.
* '''Component''' - ein Script als Teil eines GameObjects, dessen Variablen ich sowohl über den Inspector im Unity Editor, als auch über ein eigenes Script verändern kann.
* '''Asset Folder''' - ein Ordner in der Unity Projektstruktur, in dem alle für das Projekt benötigten Scripte, Audio-, Bild-, Video-, 3D und Textdateien abgelegt werden. Diese Dateien werden oft auch Assets genannt. Unity scannt diesen Ordner jedesmal, wenn der Unity-Editor in Windows in den Focus tritt und importiert sämtliche im Ordner befindlichen Dateien automatisch in das Projekt.
* '''Build''' - ein unabhängig vom Editor ausführbares programm erstellen nennt man auch einen Build machen. Da Unity sämtliche Dateien im Asset-Folder direkt ins Projekt importieren möchte, empfiehlt es sich, diese von Unity erstellten Dateien in einem eigenen Ordner ausserhalb des Asset-Folders aber innerhalb des Projektordners zu speichern.

==Eingabe und Ausgabe in Unity==
Interaktion in Unity Projekten entsteht erst, wenn die Eingabe von Nutzer*innen mit Veränderungen in der Gestaltung der Unity Szene verknüpft wird.
*[[Input in Unity]]
* [[Output in Unity]]

==Mein Build funktioniert nicht!==

* Android builds auf externen Festplatten gehen oft nicht. In dem Fall das Projekt auf die Festplatte des Computers kopieren, auf dem der build ist
* keine umlaute und leerzeichen in dateinamen und ordnern verwenden
* Zu lange Ordnerstrukturen vermeiden (z.B. C:\Users\Ein Name mit Zuname\Dokumente\Unity Test\2021\Oktober\Nur rumprobieren\MeinProjekt Version 12)
* Manche Plugins und Add-ons sind Hardwarespezifisch (z.B. Kinect Addon und NVidia Grafikkarten)

== Konzepte und Tutorials ==
* [[Algorithms#Unity|Basic Algorithms]]
* [[Moving_Objects_in_Unity|Moving Objects in Unity]]
* [[UI in Unity]]
* [[OSC_in_Unity| OSC in Unity]]
* [[Raycasts]] in Unity
* [[Saving_in_Unity | Speichern in Unity]]

== Pages related to Unity that need Context and/or Love ==
* [[Mqtt_to_Unity_via_shiftr.io| MQTT, Unity and shiftr.io]]

Hauptseite

2021-11-16T11:28:03Z

Fkirschner: /* Programming */

Willkommen auf dem Spiel und Objekt Wiki! 

Auf diesen Seiten legen wir Referenzen, Projektdokumentationen, Literaturhinweise, Kursmitschriften und Best Practices ab. 

=P R A X I S=

== Kurse ==

=== Spiel && Objekt ===

====WS2018/19====
*[[SpieleDesign|Spiel und Theater]]
*[[PartizipationÜbungen|Übungen Partizipation]]
*[[NeueMedienGesellschaft|Neue Medien und Gesellschaft]]

====SS2020====
*[[Vernetzte Räume]]
*[[From Space to Space]]

====WS2020/21====
*[[Least Likely]]
*[[Soft Soft]]
*[[Cyber+Technofeminism]]

====SS2021====
*[[Everything is Talkative]]

====WS2021/22====
*[[Communicating Bodies]]
*[[Soziale Architektur 2]]

=== Zeitgenössische Puppenspielkunst HfS ===
*[[Material Adventures]] (SS2020)
*[[Paper Adventures]] (SS2021)

=== Kooperation Uni Bremen ===
*[[OeffentlichkeitTheorie| Öffentlichkeit bei Habermas und Luhmann]]

==Projekte==

===1. Jahrgang (2018-2020)===
*[[Be Bernd]]
*[[Wir Alle Spielen Theater]]
*[[Altruistic Modification]]
*[[Archäologischer Park- Die Villa]]
*[[Futopolis]]
*[[Kalte Ecken im Koffer]]

===2. Jahrgang (2020-2022)===
*[[Random Acts of Vulnerability]]
*[[Wir Haben Fragen]]

== Recherchen ==
*[[BioArt]]
*[[Feminismus]]
*[[VideoAsSculpture]]
*[[SpieleDesign]]
*[[NoScreens]]
*[[DesignFiction]]
*[[NetworkedArt|Networked Theatre, Performance, Art, Culture...]]
*[[Donna Haraway]]
*[[Schreiben]]
*[[Capturing Process]]
*[[Websites]]

= T E C H N I K =
== Inventar ==
*[[Spiel&&Objekt Gadgets]]

=== KITS ===
*[[S&&O KIT]] (brought to you by the [[Labor für Digitalität]])
*[[world meets computer KIT]] (from the course [[Least Likely]] Scenario)
*[[softsoft KIT]] (from the course [[Soft Soft]])
*[[spaghetti monster KIT]] (from the course [[Communicating Bodies]])
*[[Dome Pod KIT]]s

== Fabrication ==
*[[How to: 3D Drucken]]
*[[How to: build geodesic domes]] (coming soon...)
*[[How to: make PCBs]] (coming soon...)

== Physical Computing ==

*[[Arduino| Arduino Übersicht]]

*[[Sensors]]
*[[Actuators]]
*[[Widerstände]]
*[[Voltage Divider]]

=== Physical Computing Examples ===
*[[Making Sound with Sensors]]
*[[Bewässerungsanlage mit Arduino Uno und DIY-Feuchtigkeitssensor]]

== Programming ==

=== Unity ===
*[[Unity]]
*[[Online_Multiplayer]]
*[[BasicMultiplayerFramework|Virtuelle Multiuser Räume]]

=== p5.js (Javascript) ===
*[[p5 Overview]]

===ESP32 mit Arduino===
*[[ESP32 mit Arduino]] programmieren

===ESP32,ESP8266 mit micropython===
*[[arduino vs. micropython]]
*[[micropython install]]
*[[Empfehlungen micropython]]
*[[uPyCraft]]
*[[DMX_MQTT_CONTROLLER]]

===Miscellaneous===
*[[Multiple_Keyboards_with_RaspberryPi_and_OSC|Mehrere Keyboards/RFID Reader an ein RaspberryPi, mit OSC ins Netzwerk]]
*[[Raspberry Pi - Helfende Befehle]]

== Netzwerkommunikation ==

=== WIFI ===
*[[Ubiquiti WiFi|Stabiles WiFi auf der Bühne]]
*[[AsusRP-N53|Access Point mit dem Asus RP-N53]]
*[[Asus RT-AC68U|WLan mit dem Asus RT-AC68U]]
*[[Mqtt to Unity via shiftr.io | How to send Data from ESP to Unity with Mqtt protocol]]
*[[MQTT implementation in Basic Multiplayer via webGL Client | Shiftr.io/MQTT implementation in Basic Multiplayer via webGL Client]]

==== MQTT ====
*[[What is MQTT?]]
*[[MQTT Brokers]] (online server, localhost)
*[[MQTT Clients]] (Arduino, Processing)

===== MQTT Examples =====
*[[PubSub_3sensors_onChange_asSeperateTopics]] (ESP & Arduino)
*[[PubSub_3sensors_continuous_asStringList]] (ESP & Arduino)

=== RFID ===
*[[User Login|Einloggen an einer Station mit einem Avatar]]

=== XY Plotter ===
The following code connects a xy-plotter to unity and also simulates the movement of the plotter in the game view. A simple white plane represents the scale of the plotter and a white cube its movement.
The movement is controlled by the arrow keys.

GitHub [https://github.com/HfSDigital/XY-Plotter-Unity]

== Kommunikation ==

===OSC===
*[[OSC what?]]
*[[OSC in Unity]]

=== MQTT ===
*[[MQTT what?]]
*[[MQTT in Unity]]
*[[Build your own MQTT Broker]]

== Video Technik ==
''Alles, was dir deine Eltern nicht zum Thema '''Videoübertragung''' erzählt haben.''
Oft ist ein PC als Schnittstelle zwischer Kamera und Bildschirm/Projektor sinnvoll oder nötig. Doch es gibt auch Fälle, in denen eine unkomplizierte, direkte Verbindung einfacher und besser ist.

=== Verbindung Kamera<->Ausgabegerät ===
*[[NX500|NX500 ⇒ Bildschirm oder Projektor]]

=== PC als Schnittstelle ===
*[[Der Videomischer]]
*[[Blackmagic Intensity|Blackmagic Intensity ⇒ PC]]

= T H E O R I E =

== Glossare, Begriffe und Konzepte ==
* [[GlossarCG|Begriffe der Computergrafik]]
* [[GlossarSensorActuator|Sensoren und Aktuatoren]]
* [[Algorithms|Common Algorithms]]
* [[Glossar Code|Code Glossar]]
* [[Glossar Elektronik|Elektronik Glossar]]
* [[Netzwerk]]
* [[Interaktionstaxonomie AR]]
* [[Bibliothek|Literatur Bibliothek]]

=P R A K T I S C H E S=

** [[Shopping]]
** [[Events]]

==Hack your "Theater" - How To==
*[[for Theaterleitung]]
*[[for Künstler*innen]]

= Wiki Help =
*[[how to structure documentation well]]
*[[cheatsheet]]
*[https://www.mediawiki.org/wiki/Help:Formatting Hilfe: Formatierung]
*[https://www.mediawiki.org/wiki/Help:Links Hilfe: Links]
*[[ignore wiki syntax]]
*[[code syntax highlighting]]
*[[text scroll box]

=In Arbeit=
*[[OSC Kommunikation in Processing]]
*[[software architecture in theatre]]
*[[Verbindung Arduino / Unity - Research Diary]]
*[[TFT LCD Shield|2.6"/2.8" TFT LCD Shield mit Touch]]
*[[Trying out Wikistuff]]

NeueMedienGesellschaft

2021-07-20T10:23:53Z

Fkirschner: /* Leseliste */

== Leseliste ==

* Erving Goffmann: Behaviour in Public Places
* John Stuart Hall: Cultural Studies
* Karin Knorr-Cetina: Postsozialität
* Anne Hohner und Ronald Hitzler: Technik und Vergemeinschaftung
* Hans georg Soeffner: Vergesst eure Leitkultur [https://www.faz.net/aktuell/feuilleton/debatten/hans-georg-soeffner-vergesst-eure-leitkultur-14007001.html]
* Jay Bolter, David Grusin: Remediation
* Paolo Freire: Pedagogy of the Oppressed
* Franz Fanon: Black Skin, White Mask

=== weiterführende Literatur ===
* Marshal McLuhan: Understanding Media
* Michel DeCerteau: The Practice of Everyday Life
* Friedrich Kittler: Aufschreibesysteme
* Bruno Latour: Pandora's Hope
* Ronald Hitzler: Bastelexistenz
* Janet Murray: Hamlet on the Holodeck
* Karin Knorr-Cetina: Sozialität mit Objekten
* Max Weber: Die protestanthische Ethik und der Geist des Kapitalismus
* Elisabeth Beck-Gernsheim, Ulrich Beck: Riskante Freiheiten
* Schütz: Der sinnhafte Aufbau der sozialen Welt
* Huizinga: Homo Ludens

== Schaubilder und Aufschriebe ==

=== Sinnhafter Aufbau einer spielerischen/theatralen Situation: ===
[[Datei:Situation.jpg|600px]]

=== Wirkung und Gestaltung bei partizipativen Anlagen: ===

[[Datei:UrsacheWirkung.jpg|600px]]

== Aufgaben ==
Im WiSe 2018/19 fand das Seminar "Neue Medien und Gesellschaft" statt. Im Zuge dieses Seminars entstanden die folgenden Texte in Auseinandersetzung mit dem Spiel Stories untold und dem Text "Remediation. Understanding New Media." von J.D. Bolter und R. Grusin statt.

*[[Eine Beschäftigung mit dem Text "Remediation. Understanding New Media." von Jay David Bolter und Richard Grusin, MIT 1999.]]
*[[Knowledge/Wissen]]
*[[Hypermediaty in "Stories Untold"]]
*[[Immediacy durch Hypermediacy und Remediation in "Stories Untold"?]]
*[[Textadventure "Stories Untold" - Woher kommt die reale Spannung im virtuellen Spiel?]]
*[[Stories Untold: Ich zocke also bin ich?]]
*[[The House Unbanded- eine Spielerfahrung untersucht an den Thesen von Jay David Bolter and Richard Grusin‘s: Remediation Von Leonie Adam]]
*[[HyperBewildered]]
*[[Mise en abandon]]
*[[Warum heißt unser Betriebssystem eigentlich Windows? How to become a penguin.]]
*[[Strg + Klicken Sie auf einen Hyperlink, um ihn zu öffnen]]

Input in Unity

2021-05-05T11:37:51Z

Fkirschner: /* Abfrage der Mausezeigerposition */

= Interagieren in Unity =
Um den Nutzer*innen in den von uns gestalteten Unity Programmen die Möglichkeit zu geben zu interagieren, sollen hier einige generelle Interaktionsmodi aufgelistet und erklärt werden.

== Keyboard Input ==
Um in einem Unity Script abzufragen, ob eine bestimmte Taste auf dem Keyboard gedrückt wurde, nutzen wir die Input Klasse. Unity Dokumentation [https://docs.unity3d.com/ScriptReference/Input.html| hier].
In Code verwenden wir folgende Abfrage meist in unserer Update() Funktion, da diese Funktion in jedem Frame aufgerufen wird, und wir den Zustand des Keyboards nicht versehentlich verpassen wollen:

if (Input.GetKeyUp(KeyCode.Y)){

//do something when the key y has been released

}

== Mouse Input ==
=== Abfrage der Mausezeigerposition ===
Unity gibt uns mehrere Möglichkeiten, die Position des Mauszeigers sowie seine relative Veränderung abzufragen. 
Einerseits kann direkt die Position des Mauszeigers als Bildschirmkoordinaten durch abgefragt werden (ähnlich mouseX und mouseY in Processing):

Input.mouseposition

Mehr Infos dazu in der Dokumentation zu [https://docs.unity3d.com/ScriptReference/Input.html| Input in Unity]. 

Andererseits können wir auch auf die Veränderung der Mausposition über Zeit zugreifen:

Input.GetAxis("Mouse X")

Mehr Infos und Beispielcode dazu in der Dokumentation von [https://docs.unity3d.com/ScriptReference/Input.GetAxis.html| Input.GetAxis()]. 

Letzteres können wir nutzen, um die Rotation der Kamera per Mausbewegung zu steuern, ähnlich wie wir es aus Videospielen kennen:

* dazu müssen wir ein Script schreiben, das auf dem GameObject mit Camera-Component liegt (oder auf das GameObject mit Camera Component zugreift)
* in diesem GameObject müssen wir den Transform Component so verändern, dass er anhand der Mausbewegung seine Rotation ändert.
* das müssen wir in jedem Frame machen (also in der Update Funktion)

Der Code dazu könnte in etwa wie folgt aussehen:

void

=== Klicken auf ein Objekt ===

== Touch Input ==

== Netzwerk Input ==
Auch durch Interaktionen von anderen Computern aus können in einem Unity Programm Dinge passieren. Eine genauere Beschreibung möglicher Netzwerkinteraktion steht auf der [[OSC in Unity]] Seite.

== Position und Rotation des Devices ==
=== Position via GPS ===
=== Rotation via Gyroskop ===
=== Position und Rotation via ARCore ===

== UI Interaktion ==
Die Interaktion durch sogenannte UI Elemente in Unity ist stärker strukturiert als die oben angegebenen Beispiele und bedarf einer längeren Kontextualisierung. Mehr Informationen zu UI Elementen gibt es auf der [[UI in Unity]] Seite.

Input in Unity

2021-05-05T11:10:12Z

Fkirschner: /* Abfrage der Mausezeigerposition */

= Interagieren in Unity =
Um den Nutzer*innen in den von uns gestalteten Unity Programmen die Möglichkeit zu geben zu interagieren, sollen hier einige generelle Interaktionsmodi aufgelistet und erklärt werden.

== Keyboard Input ==
Um in einem Unity Script abzufragen, ob eine bestimmte Taste auf dem Keyboard gedrückt wurde, nutzen wir die Input Klasse. Unity Dokumentation [https://docs.unity3d.com/ScriptReference/Input.html| hier].
In Code verwenden wir folgende Abfrage meist in unserer Update() Funktion, da diese Funktion in jedem Frame aufgerufen wird, und wir den Zustand des Keyboards nicht versehentlich verpassen wollen:

if (Input.GetKeyUp(KeyCode.Y)){

//do something when the key y has been released

}

== Mouse Input ==
=== Abfrage der Mausezeigerposition ===
Unity gibt uns mehrere Möglichkeiten, die Position des Mauszeigers sowie seine relative Veränderung abzufragen. 
Einerseits kann direkt die Position des Mauszeigers als Bildschirmkoordinaten durch abgefragt werden (ähnlich mouseX und mouseY in Processing):

Input.mouseposition

Mehr Infos dazu in der Dokumentation zu [https://docs.unity3d.com/ScriptReference/Input.html| Input in Unity]. 

Andererseits können wir auch auf die Veränderung der Mausposition über Zeit zugreifen:

Input.GetAxis("Mouse X")

Mehr Infos und Beispielcode dazu in der Dokumentation von [https://docs.unity3d.com/ScriptReference/Input.GetAxis.html| Input.GetAxis()].

=== Klicken auf ein Objekt ===

== Touch Input ==

== Netzwerk Input ==
Auch durch Interaktionen von anderen Computern aus können in einem Unity Programm Dinge passieren. Eine genauere Beschreibung möglicher Netzwerkinteraktion steht auf der [[OSC in Unity]] Seite.

== Position und Rotation des Devices ==
=== Position via GPS ===
=== Rotation via Gyroskop ===
=== Position und Rotation via ARCore ===

== UI Interaktion ==
Die Interaktion durch sogenannte UI Elemente in Unity ist stärker strukturiert als die oben angegebenen Beispiele und bedarf einer längeren Kontextualisierung. Mehr Informationen zu UI Elementen gibt es auf der [[UI in Unity]] Seite.

Unity

2021-05-05T10:51:46Z

Fkirschner: /* Eingabe und Ausgabe in Unity */

== Was ist Unity?==
Unity ist ein Programm, mit dessen Hilfe man eigene interaktive Applikationen und Visualisierungen herstellen kann. In Unity können wir eigene virtuelle Räume mit Hilfe des Unity Editors gestalten und mit eigenen Scripten, die in der Programmiersprache C# geschrieben werden, eigene Interaktionen in diesen Räumen festlegen. 

Unity wird oft auch als Game-Engine beschrieben.

== Für welche Geräte kann ich Unity nutzen?==
Wir benutzen den Unity Editor unter Windows 10, er läuft aber auch unter Mac OS. 
Im Unterricht nutzen wir den Unity Editor um Programme zu gestalten, die auf Windows, Mac OS, Android und WebGL laufen können. Man kann Unity zwar dafür verwenden, Programme für iOS zu gestalten, unser Studiengang deckt diese prozesse allerdings nicht ab.

==Welche Version von Unity nutzen wir?==
Wir verwenden für die Verwaltung unserer Projekte und Unity Versionen das programm '''Unity Hub'''. Damit ist es möglich, mehrere Versionen von Unity gleichzeitig installiert zu haben und jedes Projekt mit unterschiedlichen Versionen des Unity Editors zu bearbeiten.
Die momentan im Unterricht genutzten Versionen von Unity sind '''2020.3.x''' und '''2019.4.x'''.
Innerhalb der Stelle hinter dem zweiten Punkt in der Versionsnummer von Unity sollten Updates des Unity Editors für gewöhnlich kein Problem sein. Projekte die in 2019.4.12 angefangen wurden sollten problemlos unter 2019.4.18 laufen. Es empfiehlt sich nicht, alte Projekte mit grösseren Versionsunterschieden in neueren Versionen von Unity zu öffnen.

==Terminologie im Unity Editor==
[[Datei:Unity_Interface.jpg|1024px]]

==Begriffe==
* '''Projekt''' - ein Ordner auf dem Computer in dem sich eine ganze Reihe weiterer Ordner befinden. Es gibt nicht eine einzelne Projektdatei, sondern eine ganze Struktur an Dateien und Ordnern aus denen der Unity Editor das Projekt erstellt und manipulierbar macht. Deswegen lohnt es sich, Unity Projekte über den Unity Hub zu verwalten. Der Ablageort eines Projektes auf der Festplatte kann sich verschieben, solange die in ihm enthaltene Verzeichnisstruktur gewahrt bleibt.
* '''Szene''' - eine Datei im Asset Folder von Unity, in der eine bestimmte Konfiguration von GameObjects und Verknüpfungen zwischen ihnen gespeichert ist.
* '''GameObject''' - ein GameObject ist eine Datenstruktur innerhalb einer Szene in Unity. Alle GameObjects, unabhängig davon ob sie eine visuelle Repräsentation haben, sind in der Hierarchy ausgeführt. Scripte können für gewöhnlich nur ausgeführt werden, wenn sie als Component eines gameObjects in der Szene vorhanden sind.
* '''Script''' - unter einem Script verstehen wir eine mit Visual Studio in C# geschriebene Datei, die wir im Editor als Component auf GameObjects legen können, damit das Script ausgeführt wird. Scripts können auf mehrere GameObjects gleichzeitig gelegt werden, oder auch mehrmals auf dasselbe GameObject und laufen als eigenständige Instanzen jeweils so oft, wie sie in der Szene vorkommen.
* '''Component''' - ein Script als Teil eines GameObjects, dessen Variablen ich sowohl über den Inspector im Unity Editor, als auch über ein eigenes Script verändern kann.
* '''Asset Folder''' - ein Ordner in der Unity Projektstruktur, in dem alle für das Projekt benötigten Scripte, Audio-, Bild-, Video-, 3D und Textdateien abgelegt werden. Diese Dateien werden oft auch Assets genannt. Unity scannt diesen Ordner jedesmal, wenn der Unity-Editor in Windows in den Focus tritt und importiert sämtliche im Ordner befindlichen Dateien automatisch in das Projekt.
* '''Build''' - ein unabhängig vom Editor ausführbares programm erstellen nennt man auch einen Build machen. Da Unity sämtliche Dateien im Asset-Folder direkt ins Projekt importieren möchte, empfiehlt es sich, diese von Unity erstellten Dateien in einem eigenen Ordner ausserhalb des Asset-Folders aber innerhalb des Projektordners zu speichern.

==Eingabe und Ausgabe in Unity==
Interaktion in Unity Projekten entsteht erst, wenn die Eingabe von Nutzer*innen mit Veränderungen in der Gestaltung der Unity Szene verknüpft wird.
*[[Input in Unity]]
* [[Output in Unity]]

==Mein Build funktioniert nicht!==

* Android builds auf externen Festplatten gehen oft nicht. In dem Fall das Projekt auf die Festplatte des Computers kopieren, auf dem der build ist
* keine umlaute und leerzeichen in dateinamen und ordnern verwenden
* Zu lange Ordnerstrukturen vermeiden (z.B. C:\Users\Ein Name mit Zuname\Dokumente\Unity Test\2021\Oktober\Nur rumprobieren\MeinProjekt Version 12)
* Manche Plugins und Add-ons sind Hardwarespezifisch (z.B. Kinect Addon und NVidia Grafikkarten)

== Konzepte und Tutorials ==
* [[Algorithms#Unity|Basic Algorithms]]
* [[Moving_Objects_in_Unity|Moving Objects in Unity]]
* [[UI in Unity]]
* [[OSC_in_Unity| OSC in Unity]]
* [[Raycasts]] in Unity

== Pages related to Unity that need Context and/or Love ==
* [[Mqtt_to_Unity_via_shiftr.io| MQTT, Unity and shiftr.io]]

Hauptseite

2021-04-21T17:26:28Z

Fkirschner:

Willkommen auf dem Spiel und Objekt Wiki! 

Auf diesen Seiten legen wir Referenzen, Projektdokumentationen, Literaturhinweise, Kursmitschriften und Best Practices ab. 

= Theorie =

== Glossare, Begriffe und Konzepte ==
* [[GlossarCG|Begriffe der Computergrafik]]
* [[GlossarSensorActuator|Sensoren und Aktuatoren]]
* [[Algorithms|Common Algorithms]]
* [[Glossar Code|Code Glossar]]
* [[Glossar Elektronik|Elektronik Glossar]]
* [[Netzwerk]]
* [[Interaktionstaxonomie AR]]
* [[Bibliothek|Literatur Bibliothek]]
** obiges sollte in die anderen Bereiche eingepflegt werden...
* [[Shopping]]

== Recherchen ==
*[[BioArt]]
*[[Feminismus]]
*[[VideoAsSculpture]]
*[[SpieleDesign]]
*[[NoScreens]]
*[[DesignFiction]]
*[[NetworkedArt|Networked Theatre, Performance, Art, Culture...]]
*[[Donna Haraway]]

== Kurse ==

=== Spiel && Objekt ===
*[[SpieleDesign|Spiel und Theater]]
*[[PartizipationÜbungen|Übungen Partizipation]]
*[[NeueMedienGesellschaft|Neue Medien und Gesellschaft]]
*[[Vernetzte Räume]] (SS2020)
*[[From Space to Space]] (SS2020)
*[[Least Likely]] (WS20/21)
*[[Soft Soft]] (WS20/21)
*[[Cyber+Technofeminism]] (WS20/21)
*[[Everything is Talkative]] (SS2021)

=== Zeitgenössische Puppenspielkunst HfS ===
*[[Material Adventures]]

=== Kooperation Uni Bremen ===
*[[OeffentlichkeitTheorie| Öffentlichkeit bei Habermas und Luhmann]]

== Prozess und Dokumentation ==
*[[Schreiben]]
*[[Capturing Process]]
*[[Websites]]

= Praxis =

== Technik und Werkzeuge ==
*[[Spiel&&Objekt Gadgets]]

=== Arduino ===
*[[Arduino| Übersicht Arduino]] - diese Seite ist nur eine Kopie von Inhalten anderer Seiten, hauptsächlich [[Common Algorithms]]
*[[Bewässerungsanlage mit Arduino Uno und DIY-Feuchtigkeitssensor]]
*[[Sensors]]
*[[Actuators]]
*[[Voltage Divider]]

=== p5.js (Javascript) ===
*[[p5 Overview]]

=== Unity ===
*[[Unity]]
*[[Online_Multiplayer]]
*[[BasicMultiplayerFramework|Virtuelle Multiuser Räume]]

=== KITS ===
*[[S&&O KIT]] (brought to you by the [[Labor für Digitalität]])
*[[world meets computer KIT]] (from the course [[Least Likely]] Scenario)
*[[softsoft KIT]] (from the course [[Soft Soft]])

===ESP32,ESP8266 mit micropython===
*[[arduino vs. micropython]]
*[[micropython install]]
*[[Empfehlungen micropython]]
*[[uPyCraft]]
*[[DMX_MQTT_CONTROLLER]]

===Miscellaneous===
*[[Multiple_Keyboards_with_RaspberryPi_and_OSC|Mehrere Keyboards/RFID Reader an ein RaspberryPi, mit OSC ins Netzwerk]]
*[[Raspberry Pi - Helfende Befehle]]

== Video Technik ==
''Alles, was dir deine Eltern nicht zum Thema '''Videoübertragung''' erzählt haben.''
Oft ist ein PC als Schnittstelle zwischer Kamera und Bildschirm/Projektor sinnvoll oder nötig. Doch es gibt auch Fälle, in denen eine unkomplizierte, direkte Verbindung einfacher und besser ist.

=== Verbindung Kamera<->Ausgabegerät ===
*[[NX500|NX500 ⇒ Bildschirm oder Projektor]]

=== PC als Schnittstelle ===
*[[Der Videomischer]]
*[[Blackmagic Intensity|Blackmagic Intensity ⇒ PC]]

== Netzwerkommunikation ==
*[[Ubiquiti WiFi|Stabiles WiFi auf der Bühne]]
*[[AsusRP-N53|Access Point mit dem Asus RP-N53]]
*[[Asus RT-AC68U|WLan mit dem Asus RT-AC68U]]
*[[Mqtt to Unity via shiftr.io | How to send Data from ESP to Unity with Mqtt protocol]]
*[[MQTT implementation in Basic Multiplayer via webGL Client | Shiftr.io/MQTT implementation in Basic Multiplayer via webGL Client]]

== RFID ==
*[[User Login|Einloggen an einer Station mit einem Avatar]]

== XY Plotter ==
The following code connects a xy-plotter to unity and also simulates the movement of the plotter in the game view. A simple white plane represents the scale of the plotter and a white cube its movement.
The movement is controlled by the arrow keys.

GitHub [https://github.com/HfSDigital/XY-Plotter-Unity]

==Kommunikation==

===OSC===
*[[OSC what?]]
*[[OSC in Unity]]

===MQTT===
*[[MQTT what?]]
*[[MQTT in Unity]]
*[[Build your own MQTT Broker]]

=Projekte=
== Projekte Spiel und Objekt ==
*[[Be Bernd]]
*[[Wir Alle Spielen Theater]]
*[[Altruistic Modification]]
*[[Archäologischer Park- Die Villa]]
*[[Futopolis]]
*[[See Not]]
*[[Kalte Ecken im Koffer]]

==Hack your "Theater" - How To==

*[[for Theaterleitung]]
*[[for Künstler*innen]]

= Chancen Unmöglichkeiten =
FK: ich würde vorschlagen, so eine Liste nicht im Wiki zu machen. Dafür ist Discord besser geeignet.
*[[Residencies & Camps]]
*[[Festivals & Konferenzen mit CfPs]]

=In Arbeit=
*[[OSC Kommunikation in Processing]]
*[[software architecture in theatre]]
*[[Verbindung Arduino / Unity - Research Diary]]
*[[TFT LCD Shield|2.6"/2.8" TFT LCD Shield mit Touch]]

= Wiki Help =
*[[how to structure documentation well]]
*[[cheatsheet]]
*[https://www.mediawiki.org/wiki/Help:Formatting Hilfe: Formatierung]
*[https://www.mediawiki.org/wiki/Help:Links Hilfe: Links]
*[[ignore wiki syntax]]
*[[code syntax highlighting]]
*[[text scroll box]

Unity

2021-04-21T17:24:09Z

Fkirschner: /* Begriffe */

== Was ist Unity?==
Unity ist ein Programm, mit dessen Hilfe man eigene interaktive Applikationen und Visualisierungen herstellen kann. In Unity können wir eigene virtuelle Räume mit Hilfe des Unity Editors gestalten und mit eigenen Scripten, die in der Programmiersprache C# geschrieben werden, eigene Interaktionen in diesen Räumen festlegen. 

Unity wird oft auch als Game-Engine beschrieben.

== Für welche Geräte kann ich Unity nutzen?==
Wir benutzen den Unity Editor unter Windows 10, er läuft aber auch unter Mac OS. 
Im Unterricht nutzen wir den Unity Editor um Programme zu gestalten, die auf Windows, Mac OS, Android und WebGL laufen können. Man kann Unity zwar dafür verwenden, Programme für iOS zu gestalten, unser Studiengang deckt diese prozesse allerdings nicht ab.

==Welche Version von Unity nutzen wir?==
Wir verwenden für die Verwaltung unserer Projekte und Unity Versionen das programm '''Unity Hub'''. Damit ist es möglich, mehrere Versionen von Unity gleichzeitig installiert zu haben und jedes Projekt mit unterschiedlichen Versionen des Unity Editors zu bearbeiten.
Die momentan im Unterricht genutzten Versionen von Unity sind '''2020.3.x''' und '''2019.4.x'''.
Innerhalb der Stelle hinter dem zweiten Punkt in der Versionsnummer von Unity sollten Updates des Unity Editors für gewöhnlich kein Problem sein. Projekte die in 2019.4.12 angefangen wurden sollten problemlos unter 2019.4.18 laufen. Es empfiehlt sich nicht, alte Projekte mit grösseren Versionsunterschieden in neueren Versionen von Unity zu öffnen.

==Terminologie im Unity Editor==
[[Datei:Unity_Interface.jpg|1024px]]

==Begriffe==
* '''Projekt''' - ein Ordner auf dem Computer in dem sich eine ganze Reihe weiterer Ordner befinden. Es gibt nicht eine einzelne Projektdatei, sondern eine ganze Struktur an Dateien und Ordnern aus denen der Unity Editor das Projekt erstellt und manipulierbar macht. Deswegen lohnt es sich, Unity Projekte über den Unity Hub zu verwalten. Der Ablageort eines Projektes auf der Festplatte kann sich verschieben, solange die in ihm enthaltene Verzeichnisstruktur gewahrt bleibt.
* '''Szene''' - eine Datei im Asset Folder von Unity, in der eine bestimmte Konfiguration von GameObjects und Verknüpfungen zwischen ihnen gespeichert ist.
* '''GameObject''' - ein GameObject ist eine Datenstruktur innerhalb einer Szene in Unity. Alle GameObjects, unabhängig davon ob sie eine visuelle Repräsentation haben, sind in der Hierarchy ausgeführt. Scripte können für gewöhnlich nur ausgeführt werden, wenn sie als Component eines gameObjects in der Szene vorhanden sind.
* '''Script''' - unter einem Script verstehen wir eine mit Visual Studio in C# geschriebene Datei, die wir im Editor als Component auf GameObjects legen können, damit das Script ausgeführt wird. Scripts können auf mehrere GameObjects gleichzeitig gelegt werden, oder auch mehrmals auf dasselbe GameObject und laufen als eigenständige Instanzen jeweils so oft, wie sie in der Szene vorkommen.
* '''Component''' - ein Script als Teil eines GameObjects, dessen Variablen ich sowohl über den Inspector im Unity Editor, als auch über ein eigenes Script verändern kann.
* '''Asset Folder''' - ein Ordner in der Unity Projektstruktur, in dem alle für das Projekt benötigten Scripte, Audio-, Bild-, Video-, 3D und Textdateien abgelegt werden. Diese Dateien werden oft auch Assets genannt. Unity scannt diesen Ordner jedesmal, wenn der Unity-Editor in Windows in den Focus tritt und importiert sämtliche im Ordner befindlichen Dateien automatisch in das Projekt.
* '''Build''' - ein unabhängig vom Editor ausführbares programm erstellen nennt man auch einen Build machen. Da Unity sämtliche Dateien im Asset-Folder direkt ins Projekt importieren möchte, empfiehlt es sich, diese von Unity erstellten Dateien in einem eigenen Ordner ausserhalb des Asset-Folders aber innerhalb des Projektordners zu speichern.

==Eingabe und Ausgabe in Unity==
Interaktion in Unity Projekten entsteht erst, wenn die Eingabe von Nutzer*innen mit Veränderungen in der Gestaltung der Unity Szene verknüpft wird.
*[[Input in Unity]]
* [[Output in Unity]]

== Konzepte und Tutorials ==
* [[Algorithms#Unity|Basic Algorithms]]
* [[Moving_Objects_in_Unity|Moving Objects in Unity]]
* [[UI in Unity]]
* [[OSC_in_Unity| OSC in Unity]]
* [[Raycasts]] in Unity

== Pages related to Unity that need Context and/or Love ==
* [[Mqtt_to_Unity_via_shiftr.io| MQTT, Unity and shiftr.io]]

Unity

2021-04-21T17:23:41Z

Fkirschner: /* Begriffe */

== Was ist Unity?==
Unity ist ein Programm, mit dessen Hilfe man eigene interaktive Applikationen und Visualisierungen herstellen kann. In Unity können wir eigene virtuelle Räume mit Hilfe des Unity Editors gestalten und mit eigenen Scripten, die in der Programmiersprache C# geschrieben werden, eigene Interaktionen in diesen Räumen festlegen. 

Unity wird oft auch als Game-Engine beschrieben.

== Für welche Geräte kann ich Unity nutzen?==
Wir benutzen den Unity Editor unter Windows 10, er läuft aber auch unter Mac OS. 
Im Unterricht nutzen wir den Unity Editor um Programme zu gestalten, die auf Windows, Mac OS, Android und WebGL laufen können. Man kann Unity zwar dafür verwenden, Programme für iOS zu gestalten, unser Studiengang deckt diese prozesse allerdings nicht ab.

==Welche Version von Unity nutzen wir?==
Wir verwenden für die Verwaltung unserer Projekte und Unity Versionen das programm '''Unity Hub'''. Damit ist es möglich, mehrere Versionen von Unity gleichzeitig installiert zu haben und jedes Projekt mit unterschiedlichen Versionen des Unity Editors zu bearbeiten.
Die momentan im Unterricht genutzten Versionen von Unity sind '''2020.3.x''' und '''2019.4.x'''.
Innerhalb der Stelle hinter dem zweiten Punkt in der Versionsnummer von Unity sollten Updates des Unity Editors für gewöhnlich kein Problem sein. Projekte die in 2019.4.12 angefangen wurden sollten problemlos unter 2019.4.18 laufen. Es empfiehlt sich nicht, alte Projekte mit grösseren Versionsunterschieden in neueren Versionen von Unity zu öffnen.

==Terminologie im Unity Editor==
[[Datei:Unity_Interface.jpg|1024px]]

==Begriffe==
* '''Projekt''' - ein Ordner auf dem Computer in dem sich eine ganze Reihe weiterer Ordner befinden. Es gibt nicht eine einzelne Projektdatei, sondern eine ganze Struktur an Dateien und Ordnern aus denen der Unity Editor das Projekt erstellt und manipulierbar macht. Deswegen lohnt es sich, Unity Projekte über den Unity Hub zu verwalten. Der Ablageort eines Projektes auf der Festplatte kann sich verschieben, solange die in ihm enthaltene Verzeichnisstruktur gewahrt bleibt.
* '''Szene''' - eine Datei im Asset Folder von Unity, in der eine bestimmte Konfiguration von GameObjects und Verknüpfungen zwischen ihnen gespeichert ist.
* '''GameObject''' - ein GameObject ist eine Datenstruktur innerhalb einer Szene in Unity. Alle GameObjects, unabhängig davon ob sie eine visuelle Repräsentation haben, sind in der Hierarchy ausgeführt. Scripte können für gewöhnlich nur ausgeführt werden, wenn sie als Component eines gameObjects in der Szene vorhanden sind.
* '''Script''' - unter einem Script verstehen wir eine mit Visual Studio in C# geschriebene Datei, die wir im Editor als Component auf GameObjects legen können, damit das Script ausgeführt wird. Scripts können auf mehrere GameObjects gleichzeitig gelegt werden, oder auch mehrmals auf dasselbe GameObject und laufen als eigenständige Instanzen jeweils so oft, wie sie in der Szene vorkommen.
* '''Component''' - ein Script als Teil eines GameObjects, dessen Variablen ich sowohl über den Inspector im Unity Editor, als auch über ein eigenes Script verändern kann.
* '''Asset Folder''' - ein Ordner in der Unity Projektstruktur, in dem alle für das Projekt benötigten Scripte, Audio-, Bild-, Video-, 3D und Textdateien abgelegt werden. Unity scannt diesen Ordner jedesmal, wenn der Unity-Editor in Windows in den Focus tritt und importiert sämtliche im Ordner befindlichen Dateien automatisch in das Projekt.
* '''Build''' - ein unabhängig vom Editor ausführbares programm erstellen nennt man auch einen Build machen. Da Unity sämtliche Dateien im Asset-Folder direkt ins Projekt importieren möchte, empfiehlt es sich, diese von Unity erstellten Dateien in einem eigenen Ordner ausserhalb des Asset-Folders aber innerhalb des Projektordners zu speichern.

==Eingabe und Ausgabe in Unity==
Interaktion in Unity Projekten entsteht erst, wenn die Eingabe von Nutzer*innen mit Veränderungen in der Gestaltung der Unity Szene verknüpft wird.
*[[Input in Unity]]
* [[Output in Unity]]

== Konzepte und Tutorials ==
* [[Algorithms#Unity|Basic Algorithms]]
* [[Moving_Objects_in_Unity|Moving Objects in Unity]]
* [[UI in Unity]]
* [[OSC_in_Unity| OSC in Unity]]
* [[Raycasts]] in Unity

== Pages related to Unity that need Context and/or Love ==
* [[Mqtt_to_Unity_via_shiftr.io| MQTT, Unity and shiftr.io]]

Unity

2021-04-21T17:23:08Z

Fkirschner: /* Begriffe */

== Was ist Unity?==
Unity ist ein Programm, mit dessen Hilfe man eigene interaktive Applikationen und Visualisierungen herstellen kann. In Unity können wir eigene virtuelle Räume mit Hilfe des Unity Editors gestalten und mit eigenen Scripten, die in der Programmiersprache C# geschrieben werden, eigene Interaktionen in diesen Räumen festlegen. 

Unity wird oft auch als Game-Engine beschrieben.

== Für welche Geräte kann ich Unity nutzen?==
Wir benutzen den Unity Editor unter Windows 10, er läuft aber auch unter Mac OS. 
Im Unterricht nutzen wir den Unity Editor um Programme zu gestalten, die auf Windows, Mac OS, Android und WebGL laufen können. Man kann Unity zwar dafür verwenden, Programme für iOS zu gestalten, unser Studiengang deckt diese prozesse allerdings nicht ab.

==Welche Version von Unity nutzen wir?==
Wir verwenden für die Verwaltung unserer Projekte und Unity Versionen das programm '''Unity Hub'''. Damit ist es möglich, mehrere Versionen von Unity gleichzeitig installiert zu haben und jedes Projekt mit unterschiedlichen Versionen des Unity Editors zu bearbeiten.
Die momentan im Unterricht genutzten Versionen von Unity sind '''2020.3.x''' und '''2019.4.x'''.
Innerhalb der Stelle hinter dem zweiten Punkt in der Versionsnummer von Unity sollten Updates des Unity Editors für gewöhnlich kein Problem sein. Projekte die in 2019.4.12 angefangen wurden sollten problemlos unter 2019.4.18 laufen. Es empfiehlt sich nicht, alte Projekte mit grösseren Versionsunterschieden in neueren Versionen von Unity zu öffnen.

==Terminologie im Unity Editor==
[[Datei:Unity_Interface.jpg|1024px]]

==Begriffe==
* '''Projekt''' - ein Ordner auf dem Computer in dem sich eine ganze Reihe weiterer Ordner befinden. Es gibt nicht eine einzelne Projektdatei, sondern eine ganze Struktur an Dateien und Ordnern aus denen der Unity Editor das Projekt erstellt und manipulierbar macht. Deswegen lohnt es sich, Unity Projekte über den Unity Hub zu verwalten. Der Ablageort eines Projektes auf der Festplatte kann sich verschieben, solange die in ihm enthaltene Verzeichnisstruktur gewahrt bleibt.
* '''Szene''' - eine Datei im Asset Folder von Unity, in der eine bestimmte Konfiguration von GameObjects und Verknüpfungen zwischen ihnen gespeichert ist.
* '''GameObject''' - ein GameObject ist eine Datenstruktur innerhalb einer Szene in Unity. Alle GameObjects, unabhängig davon ob sie eine visuelle Repräsentation haben, sind in der Hierarchy ausgeführt. Scripte können für gewöhnlich nur ausgeführt werden, wenn sie als Component eines gameObjects in der Szene vorhanden sind.
* '''Script''' - unter einem Script verstehen wir eine mit Visual Studio in C# geschriebene Datei, die wir im Editor als Component auf GameObjects legen können, damit das Script ausgeführt wird. Scripts können auf mehrere GameObjects gleichzeitig gelegt werden, oder auch mehrmals auf dasselbe GameObject und laufen als eigenständige Instanzen jeweils so oft, wie sie in der Szene vorkommen.
* '''Component''' - ein Script als Teil eines GameObjects, dessen Variablen ich sowohl über den Inspector im Unity Editor, als auch über ein eigenes Script verändern kann.
* '''Asset Folder''' - ein Ordner in der Unity Projektstruktur, in dem alle für das Projekt benötigten Scripte, Audio-, Video-, 3D und Textdateien abgelegt werden. Unity scannt diesen Ordner jedesmal, wenn der Unity-Editor in Windows in den Focus tritt und importiert sämtliche im Ordner befindlichen Dateien automatisch in das Projekt.
* '''Build''' - ein unabhängig vom Editor ausführbares programm erstellen nennt man auch einen Build machen. Da Unity sämtliche Dateien im Asset-Folder direkt ins Projekt importieren möchte, empfiehlt es sich, diese von Unity erstellten Dateien in einem eigenen Ordner ausserhalb des Asset-Folders aber innerhalb des Projektordners zu speichern.

==Eingabe und Ausgabe in Unity==
Interaktion in Unity Projekten entsteht erst, wenn die Eingabe von Nutzer*innen mit Veränderungen in der Gestaltung der Unity Szene verknüpft wird.
*[[Input in Unity]]
* [[Output in Unity]]

== Konzepte und Tutorials ==
* [[Algorithms#Unity|Basic Algorithms]]
* [[Moving_Objects_in_Unity|Moving Objects in Unity]]
* [[UI in Unity]]
* [[OSC_in_Unity| OSC in Unity]]
* [[Raycasts]] in Unity

== Pages related to Unity that need Context and/or Love ==
* [[Mqtt_to_Unity_via_shiftr.io| MQTT, Unity and shiftr.io]]

Unity

2021-04-21T17:22:47Z

Fkirschner: /* Begriffe */

== Was ist Unity?==
Unity ist ein Programm, mit dessen Hilfe man eigene interaktive Applikationen und Visualisierungen herstellen kann. In Unity können wir eigene virtuelle Räume mit Hilfe des Unity Editors gestalten und mit eigenen Scripten, die in der Programmiersprache C# geschrieben werden, eigene Interaktionen in diesen Räumen festlegen. 

Unity wird oft auch als Game-Engine beschrieben.

== Für welche Geräte kann ich Unity nutzen?==
Wir benutzen den Unity Editor unter Windows 10, er läuft aber auch unter Mac OS. 
Im Unterricht nutzen wir den Unity Editor um Programme zu gestalten, die auf Windows, Mac OS, Android und WebGL laufen können. Man kann Unity zwar dafür verwenden, Programme für iOS zu gestalten, unser Studiengang deckt diese prozesse allerdings nicht ab.

==Welche Version von Unity nutzen wir?==
Wir verwenden für die Verwaltung unserer Projekte und Unity Versionen das programm '''Unity Hub'''. Damit ist es möglich, mehrere Versionen von Unity gleichzeitig installiert zu haben und jedes Projekt mit unterschiedlichen Versionen des Unity Editors zu bearbeiten.
Die momentan im Unterricht genutzten Versionen von Unity sind '''2020.3.x''' und '''2019.4.x'''.
Innerhalb der Stelle hinter dem zweiten Punkt in der Versionsnummer von Unity sollten Updates des Unity Editors für gewöhnlich kein Problem sein. Projekte die in 2019.4.12 angefangen wurden sollten problemlos unter 2019.4.18 laufen. Es empfiehlt sich nicht, alte Projekte mit grösseren Versionsunterschieden in neueren Versionen von Unity zu öffnen.

==Terminologie im Unity Editor==
[[Datei:Unity_Interface.jpg|1024px]]

==Begriffe==
* '''Projekt''' - ein Ordner auf dem Computer in dem sich eine ganze Reihe weiterer Ordner befinden. Es gibt nicht eine einzelne Projektdatei, sondern eine ganze Struktur an Dateien und Ordnern aus denen der Unity Editor das Projekt erstellt und manipulierbar macht. Deswegen lohnt es sich, Unity Projekte über den Unity Hub zu verwalten. Der Ablageort eines Projektes auf der Festplatte kann sich verschieben, solange die in ihm enthaltene Verzeichnisstruktur gewahrt bleibt.
* '''Szene''' - eine Datei im Asset Folder von Unity, in der eine bestimmte Konfiguration von GameObjects und Verknüpfungen zwischen ihnen gespeichert ist.
* '''GameObject''' - ein GameObject ist eine Datenstruktur innerhalb einer Szene in Unity. Alle GameObjects, unabhängig davon ob sie eine visuelle Repräsentation haben, sind in der Hierarchy ausgeführt. Scripte können für gewöhnlich nur ausgeführt werden, wenn sie als Component eines gameObjects in der Szene vorhanden sind.
* '''Script''' - unter einem Script verstehen wir eine mit Visual Studio in C# geschriebene Datei, die wir im Editor als Component auf GameObjects legen können, damit das Script ausgeführt wird. Scripts können auf mehrere GameObjects gleichzeitig gelegt werden, oder auch mehrmals auf dasselbe GameObject und laufen als eigenständige Instanzen jeweils so oft, wie sie in der Szene vorkommen.
* '''Component''' - ein Script als Teil eines GameObjects, dessen Variablen ich sowohl über den Inspector im Unity Editor, als auch über ein eigenes Script verändern kann.
* '''Asset Folder''' - ein Ordner in der Unity Projektstruktur, in dem alle für das Projekt benötigten Scripte, Audio-, Video- und Textdateien abgelegt werden. Unity scannt diesen Ordner jedesmal, wenn der Unity-Editor in Windows in den Focus tritt und importiert sämtliche im Ordner befindlichen Dateien automatisch in das Projekt.
* '''Build''' - ein unabhängig vom Editor ausführbares programm erstellen nennt man auch einen Build machen. Da Unity sämtliche Dateien im Asset-Folder direkt ins Projekt importieren möchte, empfiehlt es sich, diese von Unity erstellten Dateien in einem eigenen Ordner ausserhalb des Asset-Folders aber innerhalb des Projektordners zu speichern.

==Eingabe und Ausgabe in Unity==
Interaktion in Unity Projekten entsteht erst, wenn die Eingabe von Nutzer*innen mit Veränderungen in der Gestaltung der Unity Szene verknüpft wird.
*[[Input in Unity]]
* [[Output in Unity]]

== Konzepte und Tutorials ==
* [[Algorithms#Unity|Basic Algorithms]]
* [[Moving_Objects_in_Unity|Moving Objects in Unity]]
* [[UI in Unity]]
* [[OSC_in_Unity| OSC in Unity]]
* [[Raycasts]] in Unity

== Pages related to Unity that need Context and/or Love ==
* [[Mqtt_to_Unity_via_shiftr.io| MQTT, Unity and shiftr.io]]

UI in Unity

2021-04-21T17:06:06Z

Fkirschner: /* UI */

= UI =
'''UI''' steht generell als Kurzform von '''User Interface'''. Im Kontext von Unity bezeichnet der Begriff '''UI''' allerdings eine von Unity spezifisch vorgegebene Interaktionsstruktur, die mit Buttons, Textfeldern und ähnlichem arbeitet, und sich im Code von den [[Input in Unity| meisten anderen Eingabemöglichkeiten unterscheidet]].
Der Hauptunterschied besteht im von Unity vorgegebenen Interaktionsmodus durch UI Elemente und die Unterschiede in der Art der Darstellung auf dem Bildschirm.

== UI Elemente hinzufügen ==
Unity UI Elemente sind GameObjects die man in der Hierarchy über den Unterpunkt UI erstellen kann. 
[[Datei:create-ui-menu-unity.png | 400px]] 
Es stehen eine Reihe von Elementen zur Auswahl. Wir werden uns auf dieser Seite hauptsächlich mit den Elementen Button (TextMeshPro) und Text (TextMeshpro) beschäftigen.
=== Kurze Erklärung zu TextMeshPro ===
Unity ist in den letzten zehn Jahren enorm schnell gewachsen und hat oft Code-Elemente, die von Menschen ausserhalb der Firma erstellt wurden über Zeit in den eigenen Code übernommen. TextMeshPro ist so ein Fall, in dem besserer Code zur Darstellung von texten in unity eingeflossen ist. Unity muss allerdings nun den von ihnen selbst erstellten sowie den zugekauften Code weiter anbieten, was dazu führt, dass man als Nutzer*in die Auswahl aht, für welche dier beiden zur Verfügung gestellten Varianten man sich entscheiden möchte. 
 
'''Wir wollen uns im Zweifel immer für TextMeshPro entscheiden''', da der Text schöner dargestellt wird.
 
Wenn ihr das erste Mal aus der Hierarchy ein GameObject mit dem Zusatz (TextMeshPro) erstellt, ploppt folgender Dialog auf, bei dem ihr auf beide Knöpfe klicken könnt: 
[[Datei:tmp-import.png|600px]] 

=== Das Canvas Konzept ===
Alle in Unity genutzten UI Elemente werden einem sogenannten '''Canvas''' Objekt zugeordnet, einer Art Leinwand, die über der Szenen auf den Bildschirm gespannt ist. Wenn wir in der Hierarchy einen neuen Button erstellen, erstellt Unity auch gleich ein '''Canvas''' Object sowie ein '''EventSystem''' (über letzteres werde wir uns im Rahmen des Studiengangs nur peripher unterhalten). 
[[Datei:unity-canvas-eventsystem-ui.png |400px]] 
UI Elemente werden relativ zu diesem Canvas positioniert und dargestellt (gerendert) und unterliegen dem Koordinatensystem, das durch den Canvas vorgegeben ist. Für gewöhnlich sind sie daher '''unabhängig von der Position und Rotation der Kamera in der Szene''' immer am selben Ort auf dem Bildschirm. '''Deswegen müssen UI Elemente in der Hierarchy in Unity auch immer unter einem Canvas Objekt auftauchen.''' 
Das Koordinatensystem des Canvas Objekts wiederum orientiert sich an der [[Screen Resolution| Auflösung des Bildschirms]], wie in der Game View eingestellt. 
[[Datei:unity-gameview-resolution.png| 600px]] 
Da man sich der Auflösung der Endgeräte zu Beginn eines Projektes nicht immer sicher sein kann, und Unity von sich aus vorsieht, dass die Nutzer*innen ihre Auflösung auch selbst einstellen können (kommt bei uns seltener vor), bietet uns Unity durch die Nutzung des Canvas Konzeptes an, dass wir verschiedene UI Elemente '''relativ zu den Ecken des Bildschirms''' positionieren können. Hierfür ändert Unity den uns bekannten [https://docs.unity3d.com/ScriptReference/Transform.html| '''Transform'''] Component in ein [https://docs.unity3d.com/ScriptReference/RectTransform.html| '''RectTransform'''] Component (der allerdings von Transform abgeleitet ist, so dass wir per Script weiterhin wie gewohnt auf transform.position zugreifen können): 
[[Datei:recttransform.png|400px]] 
=== Unterschiede in Koordinaten ===
Wie ihr gut erkennen könnt, sind die Zahlen, die in diesem Component die Position des GameObjects beschreiben deutlich anders, als die von uns bisher genutzten. Während wir bei unseren bisherigen Übungen für gewöhnlich Koordinaten zwischen 1 und 10 oder -1 und -10 für die x, y und z Werte genutzt haben, stehen hier plötzlich zahlen in der Grösse von 100 und 1000. Das hat damit zu tun, dass die Koordinaten bei Rect Transform als Bildschirmkoordinaten interpretiert werden, wobei eine Koordinate von 1 genau einen Pixel beschreibt. Zum Vergleich: in unserer Unity Szene beschreibt eine Koordinate von 1 für gewöhnlich die Distanz von einem Meter. 
=== Darstellung in Scene View und Game View ===
Wenn wir zwischen der Unity Scene View und der Game View hin und her schalten, stellen wir fest, dass unser Button in der Game View zwar an einem sinnvollen Punkt dargestellt wird, in unserer Scene View Allerdings nichts von ihm zu sehen ist. Stattdessen sehen wir eine seltsame Linie mit Ecke: 
[[Datei:ui-scene-vs-gameview.png|800px]] 
Der Grund dafür ist, dass die Unity Scene View immer alle Dinge in Unity Koordinaten darstellt (1 Unity Koordinate interpretieren wir für gewöhnlich als 1 Meter), wohingegen in der Game View die Besonderheiten des Canvas-Konzeptes bereits in Betracht gezogen werden, und die UI Elemente unabhängig von der Kamera auf dem Bildschirm platziert werden. 
'''UI Elemente sind also am Einfachsten in der Game View sichtbar und es empfiehlt sich, ihre positionierung auch dort zu überprüfen.''' 
 
Trotzdem können UI Elemente auch in der Scene View angeschaut und manipuliert werden. Die oben angesprochene weisse Linie beschreibt den Umfang des Canvas Objektes in Unity 3D-Koordinaten. Im Canvas Objekt selbst könnt ihr unter ''width'' und ''height'' nachschauen, wie gross dieser Umfang ist. Wenn ihr gaaaaaaaanz weit herauszoomt, könnt ihr dann auch euren Button sehen. Eine einfachere Version, um eine übersicht über die UI Elemente in der Scene View zu bekommen ist, '''das Canvas GameObjekt doppelklicken'''. 
[[Datei:unity-doubleclick-canvas.png|600px]]

Ihr könnt selbstverständlich wie gewohnt, auch UI Elemente in der Scene View anklicken und verschieben. Wichtig hierbei ist nur zu wissen, dass der Canvas diese Elemente nicht perspektivisch darstellt und sich an der Darstellung der UI Elemente somit auch bei Verschiebung in der Z-Achse nichts ändert.

=== Relatives Ausrichten der UI Elemente ===
Durch klicken auf das Piktogramm links bei RectTransform können wir bestimmen, wie Unity die relative Position unseres UI Elements bestimmen soll: 
[[Datei:unity-ui-anchors.png|400px]] 
Gerade bewegt Unity unseren Button von der Mitte des Screens aus gesehen 687 Pixel nach links und 369.5 Pixel nach unten.
Mehr informationen hierzu findet ihr in der [https://docs.unity3d.com/Packages/com.unity.ugui@1.0/manual/UIBasicLayout.html| Unity Gebrauchsanweisung für UI Elemente].

Nachdem wir einen '''Button (TextMeshPro)''' in Unity hinzugefügt haben, sollte unsere Szene ungefähr so aussehen: 

[[Datei:unity-scene-with-button.png|800px]] 

== Textfelder ==
Nicht immer werden UI Elemente dafür genutzt, dass sie manipuliert werden können. Oft sollen sie auch einfach nur etwas darstellen oder anzeigen. Ein Beispiel dafür ist '''Text (TextMeshPro)''': 
[[Datei:unity-ui-create-text-tmp.png|600px]] 

Ein Textfeld generiert genauso einen Canvas (falls noch keiner da ist) oder ordnet sich automatisch einem bestehenden Canvas unter (falls schon ein anderes UI Element in der Szene ist).

=== Text in einem Textfeld per Script definieren ===
Der Unity Editor erlaubt euch, den Text den ihr im Textfeld seht direkt im Editor einzugeben. Für Nutzer*innen eures Programms ist der Text allerdings nicht editierbar. Jedoch könnt ihr den Text selbstverständlich per Script jederzeit ändern. 
Dafür erstellen wir hier als Beispiel ein neues Script, dass den Text in unserem neu generierten Textfeld verändert. Wir wollen es TextChange.cs nennen: 
[[Datei:unity-new-script-textChange.png|400px]] 

Um von unserem Script aus auf das '''Text (TextMeshPro)''' GameObject zugreifen zu können und dort den angezeigten Text zu verändern, müssen wir eine Verbindung zu unserem Script in Form einer Variable schaffen. Dazu brauchen wir, [[Algorithms#Auf_eine_Variable_in_einem_anderen_Script_zugreifen| wie immer]], den Typ des Scripts auf das wir zugreifen wollen. Im Falle eines '''Text (TextMeshPro)''' stellt sich der Typ allerdings als etwas komplizierter dar, weil es Text in Unity in unterschiedlichen Formen gibt: einmal für UI und einmal für die 3D Repräsentation in unserer Szene! Indiesem Fall wollen wir auf die UI-Version des Typs Text (TextMeshPro) zugreifen. Der Typ unseres Textfeldes ist in diesem Fall TextMeshProUGUI (UGUI steht kurz für Unity Graphical User Interface). Damit wir direkt Zugriff auf diesen Typ bekommen, sollten wir die Library TMPro in unserem Script mit laden. Das sieht dann so aus: 
[[Datei:visual-studio-using-tmpro.png|600px]] 

Wir können nun im Unity Editor unser Script in ein neues, leeres GameObject ziehen, das wir TextManipulation nennen können: 
[[Datei:unity-ui-textmanipulation-gameobject.png|600px]] 
Und dort dann die Verbindung mit unserem Text(TMP) GameObject und dem zugehörigen TextMeshProUGUI Component herstellen: 
[[Datei:unity-ui-connect Text-tmp-to-textmanipulation.png|600px]] 
 
Nun können wir in unserem TextChange.cs Script auf die Variable '''text'''in der verbundenen TextMeshProUGUI-Komponente zugreifen und sie verändern, in dem wir beispielsweise unsere Start Funktion folgendermassen umschreiben: 

void Start()
{

meinTextFeld.text="Hallo Welt!";

}

oder in unserer Update Funktion folgendes Schreiben:

void Update()
{

meinTextFeld.text+="mi";

}

== Einen Button abfragen ==
Prinzipiell erstellen wir in unseren Szenen Buttons als UI-Elemente, weil wir im Code darauf reagieren wollen, dass jemensch den Button geklickt hat. Hier hilft uns Unity durch bereits vorprogrammierte Strukturen, die es uns sehr einfach ermöglichen, eine Funktion aufzurufen, wenn ein bestimmter Button geklickt wurde.

=== Beispielscript ===
Wir können also ein Beispielscript erstellen, nennen wir es KnopfGeklickt.cs (Grossschreibung bei neuen Scripten beachten!). Und diesem Script können wir eine einfache Funktion hinzufügen - in diesem Beispiel die Funktion ButtonWurdeGeklickt(), die uns in der Konsole etwas ausgibt:

public void ButtonWurdeGeklickt(){

Debug.Log("Yay!");

}

Das '''public''' bei public void ist in diesem Fall sehr wichtig, da wir diese Funktion ausserhalb des eigenen GameObjects aufrufen wollen!

=== Button mit Beispielscript verbinden ===
Nachdem wir unser Script als Component auf ein leeres Gameobject hinzugefügt haben, können wir daraufhin im Inspector den Button mit unserer Funktion direkt verbinden. Dazu fügen wir beim Button im Feld OnClick eine neue Verbindung zu unserer Funktion hinzu: 
Ausgangspunkt ist unsere Hierarchy mit unserem GameObject (ich habe es KlickKonsequenz genannt) und unserem neuen Script als Component: 
[[Datei:unity-klickkonsequenz-setup.png|600px]] 
In Folgenden Schritten können wir die oben genannte Funktion in unserem Script ausführen lassen, wenn der Button gedrückt wurde:
* Neue Verbindung bei Button herstellen: [[Datei:unity-btn-add-connection.png|600px]] 
* Unser GameObject zuweisen: [[Datei:unity-btn-drag-gameobject-to-connect.png|600px]] 
* Unsere neu geschriebene Funktion auswählen: [[Datei:unity-btn-select-function.png|600px]] 

Wenn alles funktioniert hat ist das Resultat in der Console ablesbar: 
[[Datei:unity-btn-yay.png]]

== Mehrere Buttons mit einem Script verbinden ==
Im Folgenden Beispiel wollen wir mit zwei Buttons arbeiten, und unser KnopfGeklickt.cs Script so erweitern, dass wir im Script unterscheiden können, welcher der beiden Knöpfe gedrückt wurde. Hierzu benutzen wir ein Kozpet, dass in Unity in diesem Kontext mit '''static paramaters''' bezeichnet wird.

=== Hinzufügen eines Parameters in unsere Scriptfunktion ===
Wir ändern die Funktion in unserem Script, so dass wir einen Parameter unserer Wahl hinzufügen, und dadurch eine Entscheidung über unsere Ausgabe treffen können. Dieser Parameter wird später bei der Verbindung zu den Buttons mit einem Wert gefüllt, den wir im Inspector bei den jeweiligen Buttons einstellen können. Als Beispiel wähle ich hier einen '''int''' Parameter und nenne ihn "welcherButton": 

public void ButtonWurdeGeklickt(int welcherButton)
{

if (welcherButton==1){
Debug.Log("Button 1 gedrückt!");
}

if (welcherButton==2){
Debug.Log("Button 2 gedrückt!");
}

}

Damit ich zwischen zwei Buttons unterscheiden kann, brauche ich ja auch zwei Buttons. Ich habe dafür meinen ersten Button kopiert und leicht verschoben, dann beiden einen Namen gegeben, damit ich sie für mich besser unterscheiden kann. Meine Hierarchy sieht dementsprechend so aus: 
[[Datei:unity-btn-two-btns.png|600px]] 
Ich habe nun zwei Buttons, beide in der Hierarchy unter demselben Canvas GameObject, allerdings der Übersicht halber unterschiedlich benannt. Das sich mein Script geändert hat, muss ich die Funktion bei OnCLick wieder neu Verbinden.Beim Verbinden mit meiner abgeänderten Funktion entsteht nun ein neues Feld, in den ich manuell den Wert des Parameters eingeben kann, der an meine Funktion übergeben wird, wenn der Button gedrückt wird: 
[[Datei:unity-btn-static-parameter.png|600px]] 

Diese statischen Parameter müssen nun '''für jeden Button einzeln''' auf eine Zahl gesetzt werden, die ich dann im oben genannten Script abfragen kann. Für ''Button Eins'' setze ich die Zahl auf 1, für ''Button Zwei'' setze ich sie auf zwei. So kann ich mit einem einzelnen Script unterscheiden, welcher Knopf im User Interface gedrückt wurde.

== Textfelder ==
Nachdem wir die Verbindung von UI Elementen mit unseren Scripten und den Umgang mit statischen parametern angeschaut haben, stellt sich nun die Frage: Was tun, wenn wir die Eingabe von Nutzer*innen in textfelder direkt in Code weiterverarbeiten wollen? 
Hierzu erstellen wir zunächst ein neues InputField (TextMeshPro) in unserer Hierarchy. Wir ihr sehen könnt wird es direkt dem bereits bestehenden Canvas GameObject in der Hierarchy untergeordnet: 
[[Datei:unity-new-inputfield.png|400px]] 
Dieses Inputfield hat nun mehrere Möglichkeiten, die Texteingabe von Nutzer*innen an den von uns geschriebenen Code weiterzuleiten: 
[[Datei:unity-textinput-functionlist.png|400px]] 
Die Funktionszuschreibungen funktionieren hier genauso wie bei den Buttons weiter oben, jedoch können wir zu verschiedenen Zuständen, die es beim InputField geben kann auch verschiedene Funktionen zuordnen. 

=== Durch Textfelder Funktionen rufen ===
Um das auszuprobieren, können wir ein neues Script erstellen, dass ich beispielhalber TextEingabeLesen.cs nennen möchte. In diesem Script können wir eine Funktion hinzufügen, von der wir wollen, dass sie aufgerufen wird, wenn jemand etwas in unser InputField geschrieben und die Eingabe bestätigt hat. Die Funktion könnte ungefähr so aussehen:

public void TextEingegeben(){

Debug.Log("Yay!");

}

Da ich mich zunächst vergewissern möchte, dass ich alles richtig verbunden habe, macht diese Funktion zunächst nicht besonders viel. Sie ist aber ein erster Schritt, mit dem ich überprüfen kann, ob die Funktion tatsächlich im richtigen Moment gerufen wird. 
Folgende Schritte stehen also nun an:
* Ein neues, leeres GameObject muss der Hierarchy hinzugefügt werden, vielleicht nennen wir es "TextVerarbeitung"
* Unser neu geschriebenes Script mit dem Namen TextEingabeLesen.cs muss als Component zum neuen GameObject TextVerarbeitung hinzugefügt werden.
* In unserem InputField GameObject, muss ich eine neue Verbindung bei '''OnEndEdit''' zu TextVerarbeitung hinzufügen: 
[[Datei:unity-connect-script-to-inputfield.png|600px]]
* Als Funktion soll die Funktion TextEingeben ausgeführt werden.

Wenn alles verbunden ist, könnt ihr die Eingabe testen: In der Game View und im Play Modus könnt ihr auf das Textfeld klicken, einen Text eingeben und dann die Enter-Taste drücken. In der Konsole sollte dann "Yay!"erscheinen. 
[[Datei:Unity-btn-yay.png]]

=== Übungen ===
* Könnt ihr die Szene so verändern, dass "Yay!" jedesmal erscheint wenn ein Buchstabe ins Textfeld eingegeben wird?
* Könnt ihr euer Script so umschreiben, dass in der Console "..." ausgegeben wird, wenn jemand etwas tippt, und "Yay!" wenn die Eingabe beendet wurde?

=== Dynamische Parameter ===
Ein einfaches Beispiel könnte den eingegebenen Text in der Console ausgeben. Wie aber stellt mir das InputField diesen eingegebenen text zur Verfügung? Die Antwort ist: über einen '''dynamic parameter'''. Wir können für unsere Funktion, ähnlich wie bei ''static parameter'' bei den Buttons, nun einen neuen Parameter vom Typ string definieren:

public void TextEingegeben(string derText){

Debug.Log(derText);

}

Damit das InputFIeld GameObject weiss, dass es den eingegebenen Text an diese Funktion übergeben soll, müssen wir die Funktion folgendermassen verbinden: 
[[Datei:unity-inputfield-dynamic-string.png|600px]] 
Wie ihr sehen könnt, gibt es unsere Funktion TextEingegeben in der Liste gleich zweimal: einmal unter der Kategorie '''Dynamic string''' und einmal unter der Kategorie '''Static Parameters'''. In diesem Fall wollen wir unsere Funktion aus der oberen Liste auswählen, damit Unity den eingegebenen Text direkt an den Parameter unserer Funktion weitergeben kann!

===Übungen===
* Kannst du eine Unity Szene machen, in der sich ein Würfel immer einen Meter vorwärts bewegt, wenn jemand das Wort "liebe" in ein Textfeld eingibt?
* Kannst du eine Unity Szene machen, in der derselbe Würfel einen Namen bekommt, der durch ein zweites Textfeld festgelegt wird?
* Kannst du eine Eingabe aus einem textfeld in einem 3D-Text (TextMeshPro) erscheinen lassen?

==Übungen zu UI und Unity==
* Kannst du ein Quiz-Programm schreiben, dass die 10 Fragen hintereinander stellt, und am Ende eine Auswertung auf dem Screen ausgibt?
* Kannst du einige der Fragen über ein UI Element Slider von 1-10 beantworten lassen?
* Kannst du über [[OSC in Unity]] die Antworten dieser Fragen auf einem anderen Computer visualisieren?

Output in Unity

2021-04-21T17:05:37Z

Fkirschner:

Playing Audio, etc...

Output in Unity

2021-04-21T17:04:28Z

Fkirschner: Die Seite wurde neu angelegt: „tbd“

tbd

Unity

2021-04-21T17:04:18Z

Fkirschner: /* Eingabe und Ausgabe in Unity */

== Was ist Unity?==
Unity ist ein Programm, mit dessen Hilfe man eigene interaktive Applikationen und Visualisierungen herstellen kann. In Unity können wir eigene virtuelle Räume mit Hilfe des Unity Editors gestalten und mit eigenen Scripten, die in der Programmiersprache C# geschrieben werden, eigene Interaktionen in diesen Räumen festlegen. 

Unity wird oft auch als Game-Engine beschrieben.

== Für welche Geräte kann ich Unity nutzen?==
Wir benutzen den Unity Editor unter Windows 10, er läuft aber auch unter Mac OS. 
Im Unterricht nutzen wir den Unity Editor um Programme zu gestalten, die auf Windows, Mac OS, Android und WebGL laufen können. Man kann Unity zwar dafür verwenden, Programme für iOS zu gestalten, unser Studiengang deckt diese prozesse allerdings nicht ab.

==Welche Version von Unity nutzen wir?==
Wir verwenden für die Verwaltung unserer Projekte und Unity Versionen das programm '''Unity Hub'''. Damit ist es möglich, mehrere Versionen von Unity gleichzeitig installiert zu haben und jedes Projekt mit unterschiedlichen Versionen des Unity Editors zu bearbeiten.
Die momentan im Unterricht genutzten Versionen von Unity sind '''2020.3.x''' und '''2019.4.x'''.
Innerhalb der Stelle hinter dem zweiten Punkt in der Versionsnummer von Unity sollten Updates des Unity Editors für gewöhnlich kein Problem sein. Projekte die in 2019.4.12 angefangen wurden sollten problemlos unter 2019.4.18 laufen. Es empfiehlt sich nicht, alte Projekte mit grösseren Versionsunterschieden in neueren Versionen von Unity zu öffnen.

==Terminologie im Unity Editor==
[[Datei:Unity_Interface.jpg|1024px]]

==Begriffe==
* '''Projekt''' - ein Ordner auf dem Computer in dem sich eine ganze Reihe weiterer Ordner befinden. Es gibt nicht eine einzelne Projektdatei, sondern eine ganze Struktur an Dateien und Ordnern aus denen der Unity Editor das Projekt erstellt und manipulierbar macht. Deswegen lohnt es sich, Unity Projekte über den Unity Hub zu verwalten. Der Ablageort eines Projektes auf der Festplatte kann sich verschieben, solange die in ihm enthaltene Verzeichnisstruktur gewahrt bleibt.
* '''Szene''' - eine Datei im Asset Folder von Unity, in der eine bestimmte Konfiguration von GameObjects und Verknüpfungen zwischen ihnen gespeichert ist.
* '''GameObject''' - ein GameObject ist eine Datenstruktur innerhalb einer Szene in Unity. Alle GameObjects, unabhängig davon ob sie eine visuelle Repräsentation haben, sind in der Hierarchy ausgeführt. Scripte können für gewöhnlich nur ausgeführt werden, wenn sie als Component eines gameObjects in der Szene vorhanden sind.
* '''Script''' - unter einem Script verstehen wir eine mit Visual Studio in C# geschriebene Datei, die wir im Editor als Component auf GameObjects legen können, damit das Script ausgeführt wird. Scripts können auf mehrere GameObjects gleichzeitig gelegt werden, oder auch mehrmals auf dasselbe GameObject und laufen als eigenständige Instanzen jeweils so oft, wie sie in der Szene vorkommen.
* '''Component''' - ein Script als Teil eines GameObjects, dessen Variablen ich sowohl über den Inspector im Unity Editor, als auch über ein eigenes Script verändern kann.
* '''Asset Folder''' - ein Ordner in der Unity Projektstruktur, in dem alle für das Projekt benötigten Dateien abgelegt werden. Unity scannt diesen Ordner jedesmal, wenn der Unity-Editor in Windows in den Focus tritt und importiert sämtliche im Ordner befindlichen Dateien automatisch in das Projekt.
* '''Build''' - ein unabhängig vom Editor ausführbares programm erstellen nennt man auch einen Build machen. Da Unity sämtliche Dateien im Asset-Folder direkt ins Projekt importieren möchte, empfiehlt es sich, diese von Unity erstellten Dateien in einem eigenen Ordner ausserhalb des Asset-Folders aber innerhalb des Projektordners zu speichern.

==Eingabe und Ausgabe in Unity==
Interaktion in Unity Projekten entsteht erst, wenn die Eingabe von Nutzer*innen mit Veränderungen in der Gestaltung der Unity Szene verknüpft wird.
*[[Input in Unity]]
* [[Output in Unity]]

== Konzepte und Tutorials ==
* [[Algorithms#Unity|Basic Algorithms]]
* [[Moving_Objects_in_Unity|Moving Objects in Unity]]
* [[UI in Unity]]
* [[OSC_in_Unity| OSC in Unity]]
* [[Raycasts]] in Unity

== Pages related to Unity that need Context and/or Love ==
* [[Mqtt_to_Unity_via_shiftr.io| MQTT, Unity and shiftr.io]]

Interaction in Unity

2021-04-21T17:03:25Z

Fkirschner: Fkirschner verschob die Seite Interaction in Unity nach Input in Unity

#WEITERLEITUNG [[Input in Unity]]

Input in Unity

2021-04-21T17:03:25Z

Fkirschner: Fkirschner verschob die Seite Interaction in Unity nach Input in Unity

Unity

2021-04-21T17:02:06Z

Fkirschner: /* Begriffe */

== Was ist Unity?==
Unity ist ein Programm, mit dessen Hilfe man eigene interaktive Applikationen und Visualisierungen herstellen kann. In Unity können wir eigene virtuelle Räume mit Hilfe des Unity Editors gestalten und mit eigenen Scripten, die in der Programmiersprache C# geschrieben werden, eigene Interaktionen in diesen Räumen festlegen. 

Unity wird oft auch als Game-Engine beschrieben.

== Für welche Geräte kann ich Unity nutzen?==
Wir benutzen den Unity Editor unter Windows 10, er läuft aber auch unter Mac OS. 
Im Unterricht nutzen wir den Unity Editor um Programme zu gestalten, die auf Windows, Mac OS, Android und WebGL laufen können. Man kann Unity zwar dafür verwenden, Programme für iOS zu gestalten, unser Studiengang deckt diese prozesse allerdings nicht ab.

==Welche Version von Unity nutzen wir?==
Wir verwenden für die Verwaltung unserer Projekte und Unity Versionen das programm '''Unity Hub'''. Damit ist es möglich, mehrere Versionen von Unity gleichzeitig installiert zu haben und jedes Projekt mit unterschiedlichen Versionen des Unity Editors zu bearbeiten.
Die momentan im Unterricht genutzten Versionen von Unity sind '''2020.3.x''' und '''2019.4.x'''.
Innerhalb der Stelle hinter dem zweiten Punkt in der Versionsnummer von Unity sollten Updates des Unity Editors für gewöhnlich kein Problem sein. Projekte die in 2019.4.12 angefangen wurden sollten problemlos unter 2019.4.18 laufen. Es empfiehlt sich nicht, alte Projekte mit grösseren Versionsunterschieden in neueren Versionen von Unity zu öffnen.

==Terminologie im Unity Editor==
[[Datei:Unity_Interface.jpg|1024px]]

==Begriffe==
* '''Projekt''' - ein Ordner auf dem Computer in dem sich eine ganze Reihe weiterer Ordner befinden. Es gibt nicht eine einzelne Projektdatei, sondern eine ganze Struktur an Dateien und Ordnern aus denen der Unity Editor das Projekt erstellt und manipulierbar macht. Deswegen lohnt es sich, Unity Projekte über den Unity Hub zu verwalten. Der Ablageort eines Projektes auf der Festplatte kann sich verschieben, solange die in ihm enthaltene Verzeichnisstruktur gewahrt bleibt.
* '''Szene''' - eine Datei im Asset Folder von Unity, in der eine bestimmte Konfiguration von GameObjects und Verknüpfungen zwischen ihnen gespeichert ist.
* '''GameObject''' - ein GameObject ist eine Datenstruktur innerhalb einer Szene in Unity. Alle GameObjects, unabhängig davon ob sie eine visuelle Repräsentation haben, sind in der Hierarchy ausgeführt. Scripte können für gewöhnlich nur ausgeführt werden, wenn sie als Component eines gameObjects in der Szene vorhanden sind.
* '''Script''' - unter einem Script verstehen wir eine mit Visual Studio in C# geschriebene Datei, die wir im Editor als Component auf GameObjects legen können, damit das Script ausgeführt wird. Scripts können auf mehrere GameObjects gleichzeitig gelegt werden, oder auch mehrmals auf dasselbe GameObject und laufen als eigenständige Instanzen jeweils so oft, wie sie in der Szene vorkommen.
* '''Component''' - ein Script als Teil eines GameObjects, dessen Variablen ich sowohl über den Inspector im Unity Editor, als auch über ein eigenes Script verändern kann.
* '''Asset Folder''' - ein Ordner in der Unity Projektstruktur, in dem alle für das Projekt benötigten Dateien abgelegt werden. Unity scannt diesen Ordner jedesmal, wenn der Unity-Editor in Windows in den Focus tritt und importiert sämtliche im Ordner befindlichen Dateien automatisch in das Projekt.
* '''Build''' - ein unabhängig vom Editor ausführbares programm erstellen nennt man auch einen Build machen. Da Unity sämtliche Dateien im Asset-Folder direkt ins Projekt importieren möchte, empfiehlt es sich, diese von Unity erstellten Dateien in einem eigenen Ordner ausserhalb des Asset-Folders aber innerhalb des Projektordners zu speichern.

==Eingabe und Ausgabe in Unity==
Interaktion in Unity Projekten entsteht erst, wenn die Eingabe von Nutzer*innen mit Veränderungen in der Gestaltung der Unity Szene verknüpft wird.

== Konzepte und Tutorials ==
* [[Algorithms#Unity|Basic Algorithms]]
* [[Moving_Objects_in_Unity|Moving Objects in Unity]]
* [[UI in Unity]]
* [[OSC_in_Unity| OSC in Unity]]
* [[Raycasts]] in Unity

== Pages related to Unity that need Context and/or Love ==
* [[Mqtt_to_Unity_via_shiftr.io| MQTT, Unity and shiftr.io]]

Unity

2021-04-21T17:01:56Z

Fkirschner: /* Begriffe */

== Was ist Unity?==
Unity ist ein Programm, mit dessen Hilfe man eigene interaktive Applikationen und Visualisierungen herstellen kann. In Unity können wir eigene virtuelle Räume mit Hilfe des Unity Editors gestalten und mit eigenen Scripten, die in der Programmiersprache C# geschrieben werden, eigene Interaktionen in diesen Räumen festlegen. 

Unity wird oft auch als Game-Engine beschrieben.

== Für welche Geräte kann ich Unity nutzen?==
Wir benutzen den Unity Editor unter Windows 10, er läuft aber auch unter Mac OS. 
Im Unterricht nutzen wir den Unity Editor um Programme zu gestalten, die auf Windows, Mac OS, Android und WebGL laufen können. Man kann Unity zwar dafür verwenden, Programme für iOS zu gestalten, unser Studiengang deckt diese prozesse allerdings nicht ab.

==Welche Version von Unity nutzen wir?==
Wir verwenden für die Verwaltung unserer Projekte und Unity Versionen das programm '''Unity Hub'''. Damit ist es möglich, mehrere Versionen von Unity gleichzeitig installiert zu haben und jedes Projekt mit unterschiedlichen Versionen des Unity Editors zu bearbeiten.
Die momentan im Unterricht genutzten Versionen von Unity sind '''2020.3.x''' und '''2019.4.x'''.
Innerhalb der Stelle hinter dem zweiten Punkt in der Versionsnummer von Unity sollten Updates des Unity Editors für gewöhnlich kein Problem sein. Projekte die in 2019.4.12 angefangen wurden sollten problemlos unter 2019.4.18 laufen. Es empfiehlt sich nicht, alte Projekte mit grösseren Versionsunterschieden in neueren Versionen von Unity zu öffnen.

==Terminologie im Unity Editor==
[[Datei:Unity_Interface.jpg|1024px]]

==Begriffe==
* '''Projekt''' - ein Ordner auf dem Computer in dem sich eine ganze Reihe weiterer Ordner befinden. Es gibt nicht eine einzelne Projektdatei, sondern eine ganze Struktur an Dateien und Ordnern aus denen der Unity Editor das Projekt erstellt und manipulierbar macht. Deswegen lohnt es sich, Unity Projekte über den Unity Hub zu verwalten. Der Ablageort eines Projektes auf der Festplatte kann sich verschieben, solange die in ihm enthaltene Verzeichnisstruktur gewahrt bleibt.
* '''Szene''' - eine Datei im Asset Folder von Unity, in der eine bestimmte Konfiguration von GameObjects und Verknüpfungen zwischen ihnen gespeichert ist.
* '''GameObject''' - ein GameObject ist eine Datenstruktur innerhalb einer Szene in Unity. Alle GameObjects, unabhängig davon ob sie eine visuelle Repräsentation haben, sind in der Hierarchy ausgeführt. Scripte können für gewöhnlich nur ausgeführt werden, wenn sie als Component eines gameObjects in der Szene vorhanden sind.
* '''Script''' - unter einem Script verstehen wir eine mit Visual Studio in C# geschriebene Datei, die wir im Editor als Component auf GameObjects legen können, damit das Script ausgeführt wird. Scripts können auf mehrere GameObjects gleichzeitig gelegt werden, oder auch mehrmals auf dasselbe GameObject und laufen als eigenständige Instanzen jeweils so oft, wie sie in der Szene vorkommen.
* '''Component''' - ein Script als Teil eines GameObjects, dessen Variablen ich sowohl über den Inspector im Unity Editor, als auch über ein eigenes Script verändern kann.
* '''Asset Folder''' - ein Ordner in der Unity Projektstruktur, in dem alle für das Projekt benötigten Dateien abgelegt werden. Unity scannt diesen Ordner jedesmal, wenn der Unity-Editor in Windows in den Focus tritt und importiert sämtliche im Ordner befindlichen Dateien automatisch in das Projekt.
* Build - ein unabhängig vom Editor ausführbares programm erstellen nennt man auch einen Build machen. Da Unity sämtliche Dateien im Asset-Folder direkt ins Projekt importieren möchte, empfiehlt es sich, diese von Unity erstellten Dateien in einem eigenen Ordner ausserhalb des Asset-Folders aber innerhalb des Projektordners zu speichern.

==Eingabe und Ausgabe in Unity==
Interaktion in Unity Projekten entsteht erst, wenn die Eingabe von Nutzer*innen mit Veränderungen in der Gestaltung der Unity Szene verknüpft wird.

== Konzepte und Tutorials ==
* [[Algorithms#Unity|Basic Algorithms]]
* [[Moving_Objects_in_Unity|Moving Objects in Unity]]
* [[UI in Unity]]
* [[OSC_in_Unity| OSC in Unity]]
* [[Raycasts]] in Unity

== Pages related to Unity that need Context and/or Love ==
* [[Mqtt_to_Unity_via_shiftr.io| MQTT, Unity and shiftr.io]]

Unity

2021-04-21T17:01:47Z

Fkirschner: /* Begriffe */

== Was ist Unity?==
Unity ist ein Programm, mit dessen Hilfe man eigene interaktive Applikationen und Visualisierungen herstellen kann. In Unity können wir eigene virtuelle Räume mit Hilfe des Unity Editors gestalten und mit eigenen Scripten, die in der Programmiersprache C# geschrieben werden, eigene Interaktionen in diesen Räumen festlegen. 

Unity wird oft auch als Game-Engine beschrieben.

== Für welche Geräte kann ich Unity nutzen?==
Wir benutzen den Unity Editor unter Windows 10, er läuft aber auch unter Mac OS. 
Im Unterricht nutzen wir den Unity Editor um Programme zu gestalten, die auf Windows, Mac OS, Android und WebGL laufen können. Man kann Unity zwar dafür verwenden, Programme für iOS zu gestalten, unser Studiengang deckt diese prozesse allerdings nicht ab.

==Welche Version von Unity nutzen wir?==
Wir verwenden für die Verwaltung unserer Projekte und Unity Versionen das programm '''Unity Hub'''. Damit ist es möglich, mehrere Versionen von Unity gleichzeitig installiert zu haben und jedes Projekt mit unterschiedlichen Versionen des Unity Editors zu bearbeiten.
Die momentan im Unterricht genutzten Versionen von Unity sind '''2020.3.x''' und '''2019.4.x'''.
Innerhalb der Stelle hinter dem zweiten Punkt in der Versionsnummer von Unity sollten Updates des Unity Editors für gewöhnlich kein Problem sein. Projekte die in 2019.4.12 angefangen wurden sollten problemlos unter 2019.4.18 laufen. Es empfiehlt sich nicht, alte Projekte mit grösseren Versionsunterschieden in neueren Versionen von Unity zu öffnen.

==Terminologie im Unity Editor==
[[Datei:Unity_Interface.jpg|1024px]]

==Begriffe==
* '''Projekt''' - ein Ordner auf dem Computer in dem sich eine ganze Reihe weiterer Ordner befinden. Es gibt nicht eine einzelne Projektdatei, sondern eine ganze Struktur an Dateien und Ordnern aus denen der Unity Editor das Projekt erstellt und manipulierbar macht. Deswegen lohnt es sich, Unity Projekte über den Unity Hub zu verwalten. Der Ablageort eines Projektes auf der Festplatte kann sich verschieben, solange die in ihm enthaltene Verzeichnisstruktur gewahrt bleibt.
* '''Szene''' - eine Datei im Asset Folder von Unity, in der eine bestimmte Konfiguration von GameObjects und Verknüpfungen zwischen ihnen gespeichert ist.
* '''GameObject''' - ein GameObject ist eine Datenstruktur innerhalb einer Szene in Unity. Alle GameObjects, unabhängig davon ob sie eine visuelle Repräsentation haben, sind in der Hierarchy ausgeführt. Scripte können für gewöhnlich nur ausgeführt werden, wenn sie als Component eines gameObjects in der Szene vorhanden sind.
* Script - unter einem Script verstehen wir eine mit Visual Studio in C# geschriebene Datei, die wir im Editor als Component auf GameObjects legen können, damit das Script ausgeführt wird. Scripts können auf mehrere GameObjects gleichzeitig gelegt werden, oder auch mehrmals auf dasselbe GameObject und laufen als eigenständige Instanzen jeweils so oft, wie sie in der Szene vorkommen.
* '''Component''' - ein Script als Teil eines GameObjects, dessen Variablen ich sowohl über den Inspector im Unity Editor, als auch über ein eigenes Script verändern kann.
* '''Asset Folder''' - ein Ordner in der Unity Projektstruktur, in dem alle für das Projekt benötigten Dateien abgelegt werden. Unity scannt diesen Ordner jedesmal, wenn der Unity-Editor in Windows in den Focus tritt und importiert sämtliche im Ordner befindlichen Dateien automatisch in das Projekt.
* Build - ein unabhängig vom Editor ausführbares programm erstellen nennt man auch einen Build machen. Da Unity sämtliche Dateien im Asset-Folder direkt ins Projekt importieren möchte, empfiehlt es sich, diese von Unity erstellten Dateien in einem eigenen Ordner ausserhalb des Asset-Folders aber innerhalb des Projektordners zu speichern.

==Eingabe und Ausgabe in Unity==
Interaktion in Unity Projekten entsteht erst, wenn die Eingabe von Nutzer*innen mit Veränderungen in der Gestaltung der Unity Szene verknüpft wird.

== Konzepte und Tutorials ==
* [[Algorithms#Unity|Basic Algorithms]]
* [[Moving_Objects_in_Unity|Moving Objects in Unity]]
* [[UI in Unity]]
* [[OSC_in_Unity| OSC in Unity]]
* [[Raycasts]] in Unity

== Pages related to Unity that need Context and/or Love ==
* [[Mqtt_to_Unity_via_shiftr.io| MQTT, Unity and shiftr.io]]

Unity

2021-04-21T16:59:06Z

Fkirschner: /* Terminologie im Unity Editor */

== Was ist Unity?==
Unity ist ein Programm, mit dessen Hilfe man eigene interaktive Applikationen und Visualisierungen herstellen kann. In Unity können wir eigene virtuelle Räume mit Hilfe des Unity Editors gestalten und mit eigenen Scripten, die in der Programmiersprache C# geschrieben werden, eigene Interaktionen in diesen Räumen festlegen. 

Unity wird oft auch als Game-Engine beschrieben.

== Für welche Geräte kann ich Unity nutzen?==
Wir benutzen den Unity Editor unter Windows 10, er läuft aber auch unter Mac OS. 
Im Unterricht nutzen wir den Unity Editor um Programme zu gestalten, die auf Windows, Mac OS, Android und WebGL laufen können. Man kann Unity zwar dafür verwenden, Programme für iOS zu gestalten, unser Studiengang deckt diese prozesse allerdings nicht ab.

==Welche Version von Unity nutzen wir?==
Wir verwenden für die Verwaltung unserer Projekte und Unity Versionen das programm '''Unity Hub'''. Damit ist es möglich, mehrere Versionen von Unity gleichzeitig installiert zu haben und jedes Projekt mit unterschiedlichen Versionen des Unity Editors zu bearbeiten.
Die momentan im Unterricht genutzten Versionen von Unity sind '''2020.3.x''' und '''2019.4.x'''.
Innerhalb der Stelle hinter dem zweiten Punkt in der Versionsnummer von Unity sollten Updates des Unity Editors für gewöhnlich kein Problem sein. Projekte die in 2019.4.12 angefangen wurden sollten problemlos unter 2019.4.18 laufen. Es empfiehlt sich nicht, alte Projekte mit grösseren Versionsunterschieden in neueren Versionen von Unity zu öffnen.

==Terminologie im Unity Editor==
[[Datei:Unity_Interface.jpg|1024px]]

==Begriffe==
* Projekt - ein Ordner auf dem Computer in dem sich eine ganze Reihe weiterer Ordner befinden. Es gibt nicht eine einzelne Projektdatei, sondern eine ganze Struktur an Dateien und Ordnern aus denen der Unity Editor das Projekt erstellt und manipulierbar macht. Deswegen lohnt es sich, Unity Projekte über den Unity Hub zu verwalten. Der Ablageort eines Projektes auf der Festplatte kann sich verschieben, solange die in ihm enthaltene Verzeichnisstruktur gewahrt bleibt.
* Szene - eine Datei im Asset Folder von Unity, in der eine bestimmte Konfiguration von GameObjects und Verknüpfungen zwischen ihnen gespeichert ist.
* GameObject - ein GameObject ist eine Datenstruktur innerhalb einer Szene in Unity. Alle GameObjects, unabhängig davon ob sie eine visuelle Repräsentation haben, sind in der Hierarchy ausgeführt. Scripte können für gewöhnlich nur ausgeführt werden, wenn sie als Component eines gameObjects in der Szene vorhanden sind.
* Component - ein Script als Teil eines GameObjects, dessen Variablen ich sowohl über den Inspector im Unity Editor, als auch über ein eigenes Script verändern kann.
* Asset Folder - ein Ordner in der Unity Projektstruktur, in dem alle für das Projekt benötigten Dateien abgelegt werden. Unity scannt diesen Ordner jedesmal, wenn der Unity-Editor in Windows in den Focus tritt und importiert sämtliche im Ordner befindlichen Dateien automatisch in das Projekt.
* Build - ein unabhängig vom Editor ausführbares programm erstellen nennt man auch einen Build machen. Da Unity sämtliche Dateien im Asset-Folder direkt ins Projekt importieren möchte, empfiehlt es sich, diese von Unity erstellten Dateien in einem eigenen Ordner ausserhalb des Asset-Folders aber innerhalb des Projektordners zu speichern.

==Eingabe und Ausgabe in Unity==
Interaktion in Unity Projekten entsteht erst, wenn die Eingabe von Nutzer*innen mit Veränderungen in der Gestaltung der Unity Szene verknüpft wird.

== Konzepte und Tutorials ==
* [[Algorithms#Unity|Basic Algorithms]]
* [[Moving_Objects_in_Unity|Moving Objects in Unity]]
* [[UI in Unity]]
* [[OSC_in_Unity| OSC in Unity]]
* [[Raycasts]] in Unity

== Pages related to Unity that need Context and/or Love ==
* [[Mqtt_to_Unity_via_shiftr.io| MQTT, Unity and shiftr.io]]

Input in Unity

2021-04-21T16:42:03Z

Fkirschner: /* Keyboard Input */

Raycasts

2021-04-21T16:37:29Z

Fkirschner:

Raycasts dienen dazu, eine unsichtbare Linie(ray) von einem bestimmten Punkt auf dem Bildschirm in die virtuelle Welt zu projezieren (cast). Sie sind notwendig um in Code herauszufinden, ob jemand auf ein Objekt in der 3D Welt geklickt hat. In VR sind sie nützlich, um den Kopfbewegungen der Benutzerin zu folgen.

== Anwendungsbeispiele & Tutorials ==
Anwendung und Tutorial von Raycasts zum Auswählen von Objekten[https://www.youtube.com/watch?v=_yf5vzZ2sYE]

Anwendung und Tutorial von Raycasts für Shooter[https://www.youtube.com/watch?v=THnivyG0Mvo]

Für das Spiel [[Be Bernd]] wurden Raycasts benutzt, um in der VR Objekte auszuwählen und interagierbar zu machen.

== Code ==
<source lang="csharp" line start="2" highlight="4-6">
// Dies ist der Code, um einen Raycast in die AR zu bringen und zu testen, ob er ein Game Object trifft
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using UnityEngine.UI;
//Bis hierhin werden die libraries, auf die Unity zurückgreift, benannt
public class hit : MonoBehaviour
//Der Name des Scripts ist hit, daher das hit hinter public class.
public Text textDebug ;
public Gameobject rayTest;

// Weil Testing in AR schwierig ist und jedes Mal einen neuen Build erfordert, wird hier ein Debug Textfeld angelegt, das im Editor noch verknüpft werden muss
// Update is called once per frame
void Update()
{ if (Input.touchCount >0)
// .touchCount ist die genaueste Methode, um die folgende Funktionen abzurufen, da es auf jede zusätzliche Berührung reagiert.
{ textDebug.text = "TOUCHED";
// Debugging in
PerformRaycast();
}
else
{
textDebug.text = "NO TOUCH";
}
if (Input.touchCount >0 && Input.GetTouch(0).phase==TouchPhase.Began)
//Input.GetTouch(0).phase==TouchPhase.Began veranlasst einen einen neuen Raycast bei jeder neuen Berührung.
{
textDebug.text = "RAYCAST";
PerformRaycast();
}

void PerformRaycast()
{
Vector3 ray = playerCamera.ScreenToWorldPoint(Input.GetTouch(0).position);
// Hiermit wird ein Vektor3 Variable erstellt, welche den berührten Punkt auf dem Tablet in die physische Welt überträgt.
Ray myRay = playerCamera.ScreenPointToRay(Input.GetTouch(0).position);
//Erstellt einen Rayast vom berühreten Screenpunkt aus
RaycastHit hit;
// Wird ein Objekt vom Raycast berührt, wird ein RaycastHit Object hit erstellt

touchedObjectText.text = ray.ToString();
// Der Name des gehitteten Objects wird in einen String verwandelt

rayTest.transform.position = myRay.origin;
rayTest.transform.LookAt(myRay.direction);
//Hier wird ein Testobjekt erstellt, dass dem gesetzten Raycast entspricht- also eine Krücke, um zu sehen, wo der nicht sichtbare Raycast ist

if (Physics.Raycast(myRay.origin, myRay.direction, out hit, Mathf.Infinity))
// Hier handelt es sich um einen boolean, der true ist, wenn er ein Game Object hittet. Weitere Details: [https://docs.unity3d.com/ScriptReference/Physics.Raycast.html]
{
touchedObjectText.text = "HIT!";
Debug.DrawRay(ray, transform.TransformDirection(Vector3.forward) * hit.distance, Color.yellow);
hitGameObject = hit.collider.gameObject;
touchedObjectText.text =hitGameObject.name.ToString();
}
}

}

</source>

UI in Unity

2021-04-21T16:33:41Z

Fkirschner: /* Übungen zu UI und Unity */

= UI =
'''UI''' steht generell als Kurzform von '''User Interface'''. Im Kontext von Unity bezeichnet der Begriff '''UI''' allerdings eine von Unity spezifisch vorgegebene Interaktionsstruktur, die mit Buttons, Textfeldern und ähnlichem arbeitet, und sich im Code von den [[Interaction in Unity| meisten anderen Interaktionen unterscheidet]].
Der Hauptunterschied besteht im von Unity vorgegebenen Interaktionsmodus durch UI Elemente und die Unterschiede in der Art der Darstellung auf dem Bildschirm.

== UI Elemente hinzufügen ==
Unity UI Elemente sind GameObjects die man in der Hierarchy über den Unterpunkt UI erstellen kann. 
[[Datei:create-ui-menu-unity.png | 400px]] 
Es stehen eine Reihe von Elementen zur Auswahl. Wir werden uns auf dieser Seite hauptsächlich mit den Elementen Button (TextMeshPro) und Text (TextMeshpro) beschäftigen.
=== Kurze Erklärung zu TextMeshPro ===
Unity ist in den letzten zehn Jahren enorm schnell gewachsen und hat oft Code-Elemente, die von Menschen ausserhalb der Firma erstellt wurden über Zeit in den eigenen Code übernommen. TextMeshPro ist so ein Fall, in dem besserer Code zur Darstellung von texten in unity eingeflossen ist. Unity muss allerdings nun den von ihnen selbst erstellten sowie den zugekauften Code weiter anbieten, was dazu führt, dass man als Nutzer*in die Auswahl aht, für welche dier beiden zur Verfügung gestellten Varianten man sich entscheiden möchte. 
 
'''Wir wollen uns im Zweifel immer für TextMeshPro entscheiden''', da der Text schöner dargestellt wird.
 
Wenn ihr das erste Mal aus der Hierarchy ein GameObject mit dem Zusatz (TextMeshPro) erstellt, ploppt folgender Dialog auf, bei dem ihr auf beide Knöpfe klicken könnt: 
[[Datei:tmp-import.png|600px]] 

=== Das Canvas Konzept ===
Alle in Unity genutzten UI Elemente werden einem sogenannten '''Canvas''' Objekt zugeordnet, einer Art Leinwand, die über der Szenen auf den Bildschirm gespannt ist. Wenn wir in der Hierarchy einen neuen Button erstellen, erstellt Unity auch gleich ein '''Canvas''' Object sowie ein '''EventSystem''' (über letzteres werde wir uns im Rahmen des Studiengangs nur peripher unterhalten). 
[[Datei:unity-canvas-eventsystem-ui.png |400px]] 
UI Elemente werden relativ zu diesem Canvas positioniert und dargestellt (gerendert) und unterliegen dem Koordinatensystem, das durch den Canvas vorgegeben ist. Für gewöhnlich sind sie daher '''unabhängig von der Position und Rotation der Kamera in der Szene''' immer am selben Ort auf dem Bildschirm. '''Deswegen müssen UI Elemente in der Hierarchy in Unity auch immer unter einem Canvas Objekt auftauchen.''' 
Das Koordinatensystem des Canvas Objekts wiederum orientiert sich an der [[Screen Resolution| Auflösung des Bildschirms]], wie in der Game View eingestellt. 
[[Datei:unity-gameview-resolution.png| 600px]] 
Da man sich der Auflösung der Endgeräte zu Beginn eines Projektes nicht immer sicher sein kann, und Unity von sich aus vorsieht, dass die Nutzer*innen ihre Auflösung auch selbst einstellen können (kommt bei uns seltener vor), bietet uns Unity durch die Nutzung des Canvas Konzeptes an, dass wir verschiedene UI Elemente '''relativ zu den Ecken des Bildschirms''' positionieren können. Hierfür ändert Unity den uns bekannten [https://docs.unity3d.com/ScriptReference/Transform.html| '''Transform'''] Component in ein [https://docs.unity3d.com/ScriptReference/RectTransform.html| '''RectTransform'''] Component (der allerdings von Transform abgeleitet ist, so dass wir per Script weiterhin wie gewohnt auf transform.position zugreifen können): 
[[Datei:recttransform.png|400px]] 
=== Unterschiede in Koordinaten ===
Wie ihr gut erkennen könnt, sind die Zahlen, die in diesem Component die Position des GameObjects beschreiben deutlich anders, als die von uns bisher genutzten. Während wir bei unseren bisherigen Übungen für gewöhnlich Koordinaten zwischen 1 und 10 oder -1 und -10 für die x, y und z Werte genutzt haben, stehen hier plötzlich zahlen in der Grösse von 100 und 1000. Das hat damit zu tun, dass die Koordinaten bei Rect Transform als Bildschirmkoordinaten interpretiert werden, wobei eine Koordinate von 1 genau einen Pixel beschreibt. Zum Vergleich: in unserer Unity Szene beschreibt eine Koordinate von 1 für gewöhnlich die Distanz von einem Meter. 
=== Darstellung in Scene View und Game View ===
Wenn wir zwischen der Unity Scene View und der Game View hin und her schalten, stellen wir fest, dass unser Button in der Game View zwar an einem sinnvollen Punkt dargestellt wird, in unserer Scene View Allerdings nichts von ihm zu sehen ist. Stattdessen sehen wir eine seltsame Linie mit Ecke: 
[[Datei:ui-scene-vs-gameview.png|800px]] 
Der Grund dafür ist, dass die Unity Scene View immer alle Dinge in Unity Koordinaten darstellt (1 Unity Koordinate interpretieren wir für gewöhnlich als 1 Meter), wohingegen in der Game View die Besonderheiten des Canvas-Konzeptes bereits in Betracht gezogen werden, und die UI Elemente unabhängig von der Kamera auf dem Bildschirm platziert werden. 
'''UI Elemente sind also am Einfachsten in der Game View sichtbar und es empfiehlt sich, ihre positionierung auch dort zu überprüfen.''' 
 
Trotzdem können UI Elemente auch in der Scene View angeschaut und manipuliert werden. Die oben angesprochene weisse Linie beschreibt den Umfang des Canvas Objektes in Unity 3D-Koordinaten. Im Canvas Objekt selbst könnt ihr unter ''width'' und ''height'' nachschauen, wie gross dieser Umfang ist. Wenn ihr gaaaaaaaanz weit herauszoomt, könnt ihr dann auch euren Button sehen. Eine einfachere Version, um eine übersicht über die UI Elemente in der Scene View zu bekommen ist, '''das Canvas GameObjekt doppelklicken'''. 
[[Datei:unity-doubleclick-canvas.png|600px]]

Ihr könnt selbstverständlich wie gewohnt, auch UI Elemente in der Scene View anklicken und verschieben. Wichtig hierbei ist nur zu wissen, dass der Canvas diese Elemente nicht perspektivisch darstellt und sich an der Darstellung der UI Elemente somit auch bei Verschiebung in der Z-Achse nichts ändert.

=== Relatives Ausrichten der UI Elemente ===
Durch klicken auf das Piktogramm links bei RectTransform können wir bestimmen, wie Unity die relative Position unseres UI Elements bestimmen soll: 
[[Datei:unity-ui-anchors.png|400px]] 
Gerade bewegt Unity unseren Button von der Mitte des Screens aus gesehen 687 Pixel nach links und 369.5 Pixel nach unten.
Mehr informationen hierzu findet ihr in der [https://docs.unity3d.com/Packages/com.unity.ugui@1.0/manual/UIBasicLayout.html| Unity Gebrauchsanweisung für UI Elemente].

Nachdem wir einen '''Button (TextMeshPro)''' in Unity hinzugefügt haben, sollte unsere Szene ungefähr so aussehen: 

[[Datei:unity-scene-with-button.png|800px]] 

== Textfelder ==
Nicht immer werden UI Elemente dafür genutzt, dass sie manipuliert werden können. Oft sollen sie auch einfach nur etwas darstellen oder anzeigen. Ein Beispiel dafür ist '''Text (TextMeshPro)''': 
[[Datei:unity-ui-create-text-tmp.png|600px]] 

Ein Textfeld generiert genauso einen Canvas (falls noch keiner da ist) oder ordnet sich automatisch einem bestehenden Canvas unter (falls schon ein anderes UI Element in der Szene ist).

=== Text in einem Textfeld per Script definieren ===
Der Unity Editor erlaubt euch, den Text den ihr im Textfeld seht direkt im Editor einzugeben. Für Nutzer*innen eures Programms ist der Text allerdings nicht editierbar. Jedoch könnt ihr den Text selbstverständlich per Script jederzeit ändern. 
Dafür erstellen wir hier als Beispiel ein neues Script, dass den Text in unserem neu generierten Textfeld verändert. Wir wollen es TextChange.cs nennen: 
[[Datei:unity-new-script-textChange.png|400px]] 

Um von unserem Script aus auf das '''Text (TextMeshPro)''' GameObject zugreifen zu können und dort den angezeigten Text zu verändern, müssen wir eine Verbindung zu unserem Script in Form einer Variable schaffen. Dazu brauchen wir, [[Algorithms#Auf_eine_Variable_in_einem_anderen_Script_zugreifen| wie immer]], den Typ des Scripts auf das wir zugreifen wollen. Im Falle eines '''Text (TextMeshPro)''' stellt sich der Typ allerdings als etwas komplizierter dar, weil es Text in Unity in unterschiedlichen Formen gibt: einmal für UI und einmal für die 3D Repräsentation in unserer Szene! Indiesem Fall wollen wir auf die UI-Version des Typs Text (TextMeshPro) zugreifen. Der Typ unseres Textfeldes ist in diesem Fall TextMeshProUGUI (UGUI steht kurz für Unity Graphical User Interface). Damit wir direkt Zugriff auf diesen Typ bekommen, sollten wir die Library TMPro in unserem Script mit laden. Das sieht dann so aus: 
[[Datei:visual-studio-using-tmpro.png|600px]] 

Wir können nun im Unity Editor unser Script in ein neues, leeres GameObject ziehen, das wir TextManipulation nennen können: 
[[Datei:unity-ui-textmanipulation-gameobject.png|600px]] 
Und dort dann die Verbindung mit unserem Text(TMP) GameObject und dem zugehörigen TextMeshProUGUI Component herstellen: 
[[Datei:unity-ui-connect Text-tmp-to-textmanipulation.png|600px]] 
 
Nun können wir in unserem TextChange.cs Script auf die Variable '''text'''in der verbundenen TextMeshProUGUI-Komponente zugreifen und sie verändern, in dem wir beispielsweise unsere Start Funktion folgendermassen umschreiben: 

void Start()
{

meinTextFeld.text="Hallo Welt!";

}

oder in unserer Update Funktion folgendes Schreiben:

void Update()
{

meinTextFeld.text+="mi";

}

== Einen Button abfragen ==
Prinzipiell erstellen wir in unseren Szenen Buttons als UI-Elemente, weil wir im Code darauf reagieren wollen, dass jemensch den Button geklickt hat. Hier hilft uns Unity durch bereits vorprogrammierte Strukturen, die es uns sehr einfach ermöglichen, eine Funktion aufzurufen, wenn ein bestimmter Button geklickt wurde.

=== Beispielscript ===
Wir können also ein Beispielscript erstellen, nennen wir es KnopfGeklickt.cs (Grossschreibung bei neuen Scripten beachten!). Und diesem Script können wir eine einfache Funktion hinzufügen - in diesem Beispiel die Funktion ButtonWurdeGeklickt(), die uns in der Konsole etwas ausgibt:

public void ButtonWurdeGeklickt(){

Debug.Log("Yay!");

}

Das '''public''' bei public void ist in diesem Fall sehr wichtig, da wir diese Funktion ausserhalb des eigenen GameObjects aufrufen wollen!

=== Button mit Beispielscript verbinden ===
Nachdem wir unser Script als Component auf ein leeres Gameobject hinzugefügt haben, können wir daraufhin im Inspector den Button mit unserer Funktion direkt verbinden. Dazu fügen wir beim Button im Feld OnClick eine neue Verbindung zu unserer Funktion hinzu: 
Ausgangspunkt ist unsere Hierarchy mit unserem GameObject (ich habe es KlickKonsequenz genannt) und unserem neuen Script als Component: 
[[Datei:unity-klickkonsequenz-setup.png|600px]] 
In Folgenden Schritten können wir die oben genannte Funktion in unserem Script ausführen lassen, wenn der Button gedrückt wurde:
* Neue Verbindung bei Button herstellen: [[Datei:unity-btn-add-connection.png|600px]] 
* Unser GameObject zuweisen: [[Datei:unity-btn-drag-gameobject-to-connect.png|600px]] 
* Unsere neu geschriebene Funktion auswählen: [[Datei:unity-btn-select-function.png|600px]] 

Wenn alles funktioniert hat ist das Resultat in der Console ablesbar: 
[[Datei:unity-btn-yay.png]]

== Mehrere Buttons mit einem Script verbinden ==
Im Folgenden Beispiel wollen wir mit zwei Buttons arbeiten, und unser KnopfGeklickt.cs Script so erweitern, dass wir im Script unterscheiden können, welcher der beiden Knöpfe gedrückt wurde. Hierzu benutzen wir ein Kozpet, dass in Unity in diesem Kontext mit '''static paramaters''' bezeichnet wird.

=== Hinzufügen eines Parameters in unsere Scriptfunktion ===
Wir ändern die Funktion in unserem Script, so dass wir einen Parameter unserer Wahl hinzufügen, und dadurch eine Entscheidung über unsere Ausgabe treffen können. Dieser Parameter wird später bei der Verbindung zu den Buttons mit einem Wert gefüllt, den wir im Inspector bei den jeweiligen Buttons einstellen können. Als Beispiel wähle ich hier einen '''int''' Parameter und nenne ihn "welcherButton": 

public void ButtonWurdeGeklickt(int welcherButton)
{

if (welcherButton==1){
Debug.Log("Button 1 gedrückt!");
}

if (welcherButton==2){
Debug.Log("Button 2 gedrückt!");
}

}

Damit ich zwischen zwei Buttons unterscheiden kann, brauche ich ja auch zwei Buttons. Ich habe dafür meinen ersten Button kopiert und leicht verschoben, dann beiden einen Namen gegeben, damit ich sie für mich besser unterscheiden kann. Meine Hierarchy sieht dementsprechend so aus: 
[[Datei:unity-btn-two-btns.png|600px]] 
Ich habe nun zwei Buttons, beide in der Hierarchy unter demselben Canvas GameObject, allerdings der Übersicht halber unterschiedlich benannt. Das sich mein Script geändert hat, muss ich die Funktion bei OnCLick wieder neu Verbinden.Beim Verbinden mit meiner abgeänderten Funktion entsteht nun ein neues Feld, in den ich manuell den Wert des Parameters eingeben kann, der an meine Funktion übergeben wird, wenn der Button gedrückt wird: 
[[Datei:unity-btn-static-parameter.png|600px]] 

Diese statischen Parameter müssen nun '''für jeden Button einzeln''' auf eine Zahl gesetzt werden, die ich dann im oben genannten Script abfragen kann. Für ''Button Eins'' setze ich die Zahl auf 1, für ''Button Zwei'' setze ich sie auf zwei. So kann ich mit einem einzelnen Script unterscheiden, welcher Knopf im User Interface gedrückt wurde.

== Textfelder ==
Nachdem wir die Verbindung von UI Elementen mit unseren Scripten und den Umgang mit statischen parametern angeschaut haben, stellt sich nun die Frage: Was tun, wenn wir die Eingabe von Nutzer*innen in textfelder direkt in Code weiterverarbeiten wollen? 
Hierzu erstellen wir zunächst ein neues InputField (TextMeshPro) in unserer Hierarchy. Wir ihr sehen könnt wird es direkt dem bereits bestehenden Canvas GameObject in der Hierarchy untergeordnet: 
[[Datei:unity-new-inputfield.png|400px]] 
Dieses Inputfield hat nun mehrere Möglichkeiten, die Texteingabe von Nutzer*innen an den von uns geschriebenen Code weiterzuleiten: 
[[Datei:unity-textinput-functionlist.png|400px]] 
Die Funktionszuschreibungen funktionieren hier genauso wie bei den Buttons weiter oben, jedoch können wir zu verschiedenen Zuständen, die es beim InputField geben kann auch verschiedene Funktionen zuordnen. 

=== Durch Textfelder Funktionen rufen ===
Um das auszuprobieren, können wir ein neues Script erstellen, dass ich beispielhalber TextEingabeLesen.cs nennen möchte. In diesem Script können wir eine Funktion hinzufügen, von der wir wollen, dass sie aufgerufen wird, wenn jemand etwas in unser InputField geschrieben und die Eingabe bestätigt hat. Die Funktion könnte ungefähr so aussehen:

public void TextEingegeben(){

Debug.Log("Yay!");

}

Da ich mich zunächst vergewissern möchte, dass ich alles richtig verbunden habe, macht diese Funktion zunächst nicht besonders viel. Sie ist aber ein erster Schritt, mit dem ich überprüfen kann, ob die Funktion tatsächlich im richtigen Moment gerufen wird. 
Folgende Schritte stehen also nun an:
* Ein neues, leeres GameObject muss der Hierarchy hinzugefügt werden, vielleicht nennen wir es "TextVerarbeitung"
* Unser neu geschriebenes Script mit dem Namen TextEingabeLesen.cs muss als Component zum neuen GameObject TextVerarbeitung hinzugefügt werden.
* In unserem InputField GameObject, muss ich eine neue Verbindung bei '''OnEndEdit''' zu TextVerarbeitung hinzufügen: 
[[Datei:unity-connect-script-to-inputfield.png|600px]]
* Als Funktion soll die Funktion TextEingeben ausgeführt werden.

Wenn alles verbunden ist, könnt ihr die Eingabe testen: In der Game View und im Play Modus könnt ihr auf das Textfeld klicken, einen Text eingeben und dann die Enter-Taste drücken. In der Konsole sollte dann "Yay!"erscheinen. 
[[Datei:Unity-btn-yay.png]]

=== Übungen ===
* Könnt ihr die Szene so verändern, dass "Yay!" jedesmal erscheint wenn ein Buchstabe ins Textfeld eingegeben wird?
* Könnt ihr euer Script so umschreiben, dass in der Console "..." ausgegeben wird, wenn jemand etwas tippt, und "Yay!" wenn die Eingabe beendet wurde?

=== Dynamische Parameter ===
Ein einfaches Beispiel könnte den eingegebenen Text in der Console ausgeben. Wie aber stellt mir das InputField diesen eingegebenen text zur Verfügung? Die Antwort ist: über einen '''dynamic parameter'''. Wir können für unsere Funktion, ähnlich wie bei ''static parameter'' bei den Buttons, nun einen neuen Parameter vom Typ string definieren:

public void TextEingegeben(string derText){

Debug.Log(derText);

}

Damit das InputFIeld GameObject weiss, dass es den eingegebenen Text an diese Funktion übergeben soll, müssen wir die Funktion folgendermassen verbinden: 
[[Datei:unity-inputfield-dynamic-string.png|600px]] 
Wie ihr sehen könnt, gibt es unsere Funktion TextEingegeben in der Liste gleich zweimal: einmal unter der Kategorie '''Dynamic string''' und einmal unter der Kategorie '''Static Parameters'''. In diesem Fall wollen wir unsere Funktion aus der oberen Liste auswählen, damit Unity den eingegebenen Text direkt an den Parameter unserer Funktion weitergeben kann!

===Übungen===
* Kannst du eine Unity Szene machen, in der sich ein Würfel immer einen Meter vorwärts bewegt, wenn jemand das Wort "liebe" in ein Textfeld eingibt?
* Kannst du eine Unity Szene machen, in der derselbe Würfel einen Namen bekommt, der durch ein zweites Textfeld festgelegt wird?
* Kannst du eine Eingabe aus einem textfeld in einem 3D-Text (TextMeshPro) erscheinen lassen?

==Übungen zu UI und Unity==
* Kannst du ein Quiz-Programm schreiben, dass die 10 Fragen hintereinander stellt, und am Ende eine Auswertung auf dem Screen ausgibt?
* Kannst du einige der Fragen über ein UI Element Slider von 1-10 beantworten lassen?
* Kannst du über [[OSC in Unity]] die Antworten dieser Fragen auf einem anderen Computer visualisieren?

UI in Unity

2021-04-21T16:32:57Z

Fkirschner: /* Dynamische Parameter */

= UI =
'''UI''' steht generell als Kurzform von '''User Interface'''. Im Kontext von Unity bezeichnet der Begriff '''UI''' allerdings eine von Unity spezifisch vorgegebene Interaktionsstruktur, die mit Buttons, Textfeldern und ähnlichem arbeitet, und sich im Code von den [[Interaction in Unity| meisten anderen Interaktionen unterscheidet]].
Der Hauptunterschied besteht im von Unity vorgegebenen Interaktionsmodus durch UI Elemente und die Unterschiede in der Art der Darstellung auf dem Bildschirm.

== UI Elemente hinzufügen ==
Unity UI Elemente sind GameObjects die man in der Hierarchy über den Unterpunkt UI erstellen kann. 
[[Datei:create-ui-menu-unity.png | 400px]] 
Es stehen eine Reihe von Elementen zur Auswahl. Wir werden uns auf dieser Seite hauptsächlich mit den Elementen Button (TextMeshPro) und Text (TextMeshpro) beschäftigen.
=== Kurze Erklärung zu TextMeshPro ===
Unity ist in den letzten zehn Jahren enorm schnell gewachsen und hat oft Code-Elemente, die von Menschen ausserhalb der Firma erstellt wurden über Zeit in den eigenen Code übernommen. TextMeshPro ist so ein Fall, in dem besserer Code zur Darstellung von texten in unity eingeflossen ist. Unity muss allerdings nun den von ihnen selbst erstellten sowie den zugekauften Code weiter anbieten, was dazu führt, dass man als Nutzer*in die Auswahl aht, für welche dier beiden zur Verfügung gestellten Varianten man sich entscheiden möchte. 
 
'''Wir wollen uns im Zweifel immer für TextMeshPro entscheiden''', da der Text schöner dargestellt wird.
 
Wenn ihr das erste Mal aus der Hierarchy ein GameObject mit dem Zusatz (TextMeshPro) erstellt, ploppt folgender Dialog auf, bei dem ihr auf beide Knöpfe klicken könnt: 
[[Datei:tmp-import.png|600px]] 

=== Das Canvas Konzept ===
Alle in Unity genutzten UI Elemente werden einem sogenannten '''Canvas''' Objekt zugeordnet, einer Art Leinwand, die über der Szenen auf den Bildschirm gespannt ist. Wenn wir in der Hierarchy einen neuen Button erstellen, erstellt Unity auch gleich ein '''Canvas''' Object sowie ein '''EventSystem''' (über letzteres werde wir uns im Rahmen des Studiengangs nur peripher unterhalten). 
[[Datei:unity-canvas-eventsystem-ui.png |400px]] 
UI Elemente werden relativ zu diesem Canvas positioniert und dargestellt (gerendert) und unterliegen dem Koordinatensystem, das durch den Canvas vorgegeben ist. Für gewöhnlich sind sie daher '''unabhängig von der Position und Rotation der Kamera in der Szene''' immer am selben Ort auf dem Bildschirm. '''Deswegen müssen UI Elemente in der Hierarchy in Unity auch immer unter einem Canvas Objekt auftauchen.''' 
Das Koordinatensystem des Canvas Objekts wiederum orientiert sich an der [[Screen Resolution| Auflösung des Bildschirms]], wie in der Game View eingestellt. 
[[Datei:unity-gameview-resolution.png| 600px]] 
Da man sich der Auflösung der Endgeräte zu Beginn eines Projektes nicht immer sicher sein kann, und Unity von sich aus vorsieht, dass die Nutzer*innen ihre Auflösung auch selbst einstellen können (kommt bei uns seltener vor), bietet uns Unity durch die Nutzung des Canvas Konzeptes an, dass wir verschiedene UI Elemente '''relativ zu den Ecken des Bildschirms''' positionieren können. Hierfür ändert Unity den uns bekannten [https://docs.unity3d.com/ScriptReference/Transform.html| '''Transform'''] Component in ein [https://docs.unity3d.com/ScriptReference/RectTransform.html| '''RectTransform'''] Component (der allerdings von Transform abgeleitet ist, so dass wir per Script weiterhin wie gewohnt auf transform.position zugreifen können): 
[[Datei:recttransform.png|400px]] 
=== Unterschiede in Koordinaten ===
Wie ihr gut erkennen könnt, sind die Zahlen, die in diesem Component die Position des GameObjects beschreiben deutlich anders, als die von uns bisher genutzten. Während wir bei unseren bisherigen Übungen für gewöhnlich Koordinaten zwischen 1 und 10 oder -1 und -10 für die x, y und z Werte genutzt haben, stehen hier plötzlich zahlen in der Grösse von 100 und 1000. Das hat damit zu tun, dass die Koordinaten bei Rect Transform als Bildschirmkoordinaten interpretiert werden, wobei eine Koordinate von 1 genau einen Pixel beschreibt. Zum Vergleich: in unserer Unity Szene beschreibt eine Koordinate von 1 für gewöhnlich die Distanz von einem Meter. 
=== Darstellung in Scene View und Game View ===
Wenn wir zwischen der Unity Scene View und der Game View hin und her schalten, stellen wir fest, dass unser Button in der Game View zwar an einem sinnvollen Punkt dargestellt wird, in unserer Scene View Allerdings nichts von ihm zu sehen ist. Stattdessen sehen wir eine seltsame Linie mit Ecke: 
[[Datei:ui-scene-vs-gameview.png|800px]] 
Der Grund dafür ist, dass die Unity Scene View immer alle Dinge in Unity Koordinaten darstellt (1 Unity Koordinate interpretieren wir für gewöhnlich als 1 Meter), wohingegen in der Game View die Besonderheiten des Canvas-Konzeptes bereits in Betracht gezogen werden, und die UI Elemente unabhängig von der Kamera auf dem Bildschirm platziert werden. 
'''UI Elemente sind also am Einfachsten in der Game View sichtbar und es empfiehlt sich, ihre positionierung auch dort zu überprüfen.''' 
 
Trotzdem können UI Elemente auch in der Scene View angeschaut und manipuliert werden. Die oben angesprochene weisse Linie beschreibt den Umfang des Canvas Objektes in Unity 3D-Koordinaten. Im Canvas Objekt selbst könnt ihr unter ''width'' und ''height'' nachschauen, wie gross dieser Umfang ist. Wenn ihr gaaaaaaaanz weit herauszoomt, könnt ihr dann auch euren Button sehen. Eine einfachere Version, um eine übersicht über die UI Elemente in der Scene View zu bekommen ist, '''das Canvas GameObjekt doppelklicken'''. 
[[Datei:unity-doubleclick-canvas.png|600px]]

Ihr könnt selbstverständlich wie gewohnt, auch UI Elemente in der Scene View anklicken und verschieben. Wichtig hierbei ist nur zu wissen, dass der Canvas diese Elemente nicht perspektivisch darstellt und sich an der Darstellung der UI Elemente somit auch bei Verschiebung in der Z-Achse nichts ändert.

=== Relatives Ausrichten der UI Elemente ===
Durch klicken auf das Piktogramm links bei RectTransform können wir bestimmen, wie Unity die relative Position unseres UI Elements bestimmen soll: 
[[Datei:unity-ui-anchors.png|400px]] 
Gerade bewegt Unity unseren Button von der Mitte des Screens aus gesehen 687 Pixel nach links und 369.5 Pixel nach unten.
Mehr informationen hierzu findet ihr in der [https://docs.unity3d.com/Packages/com.unity.ugui@1.0/manual/UIBasicLayout.html| Unity Gebrauchsanweisung für UI Elemente].

Nachdem wir einen '''Button (TextMeshPro)''' in Unity hinzugefügt haben, sollte unsere Szene ungefähr so aussehen: 

[[Datei:unity-scene-with-button.png|800px]] 

== Textfelder ==
Nicht immer werden UI Elemente dafür genutzt, dass sie manipuliert werden können. Oft sollen sie auch einfach nur etwas darstellen oder anzeigen. Ein Beispiel dafür ist '''Text (TextMeshPro)''': 
[[Datei:unity-ui-create-text-tmp.png|600px]] 

Ein Textfeld generiert genauso einen Canvas (falls noch keiner da ist) oder ordnet sich automatisch einem bestehenden Canvas unter (falls schon ein anderes UI Element in der Szene ist).

=== Text in einem Textfeld per Script definieren ===
Der Unity Editor erlaubt euch, den Text den ihr im Textfeld seht direkt im Editor einzugeben. Für Nutzer*innen eures Programms ist der Text allerdings nicht editierbar. Jedoch könnt ihr den Text selbstverständlich per Script jederzeit ändern. 
Dafür erstellen wir hier als Beispiel ein neues Script, dass den Text in unserem neu generierten Textfeld verändert. Wir wollen es TextChange.cs nennen: 
[[Datei:unity-new-script-textChange.png|400px]] 

Um von unserem Script aus auf das '''Text (TextMeshPro)''' GameObject zugreifen zu können und dort den angezeigten Text zu verändern, müssen wir eine Verbindung zu unserem Script in Form einer Variable schaffen. Dazu brauchen wir, [[Algorithms#Auf_eine_Variable_in_einem_anderen_Script_zugreifen| wie immer]], den Typ des Scripts auf das wir zugreifen wollen. Im Falle eines '''Text (TextMeshPro)''' stellt sich der Typ allerdings als etwas komplizierter dar, weil es Text in Unity in unterschiedlichen Formen gibt: einmal für UI und einmal für die 3D Repräsentation in unserer Szene! Indiesem Fall wollen wir auf die UI-Version des Typs Text (TextMeshPro) zugreifen. Der Typ unseres Textfeldes ist in diesem Fall TextMeshProUGUI (UGUI steht kurz für Unity Graphical User Interface). Damit wir direkt Zugriff auf diesen Typ bekommen, sollten wir die Library TMPro in unserem Script mit laden. Das sieht dann so aus: 
[[Datei:visual-studio-using-tmpro.png|600px]] 

Wir können nun im Unity Editor unser Script in ein neues, leeres GameObject ziehen, das wir TextManipulation nennen können: 
[[Datei:unity-ui-textmanipulation-gameobject.png|600px]] 
Und dort dann die Verbindung mit unserem Text(TMP) GameObject und dem zugehörigen TextMeshProUGUI Component herstellen: 
[[Datei:unity-ui-connect Text-tmp-to-textmanipulation.png|600px]] 
 
Nun können wir in unserem TextChange.cs Script auf die Variable '''text'''in der verbundenen TextMeshProUGUI-Komponente zugreifen und sie verändern, in dem wir beispielsweise unsere Start Funktion folgendermassen umschreiben: 

void Start()
{

meinTextFeld.text="Hallo Welt!";

}

oder in unserer Update Funktion folgendes Schreiben:

void Update()
{

meinTextFeld.text+="mi";

}

== Einen Button abfragen ==
Prinzipiell erstellen wir in unseren Szenen Buttons als UI-Elemente, weil wir im Code darauf reagieren wollen, dass jemensch den Button geklickt hat. Hier hilft uns Unity durch bereits vorprogrammierte Strukturen, die es uns sehr einfach ermöglichen, eine Funktion aufzurufen, wenn ein bestimmter Button geklickt wurde.

=== Beispielscript ===
Wir können also ein Beispielscript erstellen, nennen wir es KnopfGeklickt.cs (Grossschreibung bei neuen Scripten beachten!). Und diesem Script können wir eine einfache Funktion hinzufügen - in diesem Beispiel die Funktion ButtonWurdeGeklickt(), die uns in der Konsole etwas ausgibt:

public void ButtonWurdeGeklickt(){

Debug.Log("Yay!");

}

Das '''public''' bei public void ist in diesem Fall sehr wichtig, da wir diese Funktion ausserhalb des eigenen GameObjects aufrufen wollen!

=== Button mit Beispielscript verbinden ===
Nachdem wir unser Script als Component auf ein leeres Gameobject hinzugefügt haben, können wir daraufhin im Inspector den Button mit unserer Funktion direkt verbinden. Dazu fügen wir beim Button im Feld OnClick eine neue Verbindung zu unserer Funktion hinzu: 
Ausgangspunkt ist unsere Hierarchy mit unserem GameObject (ich habe es KlickKonsequenz genannt) und unserem neuen Script als Component: 
[[Datei:unity-klickkonsequenz-setup.png|600px]] 
In Folgenden Schritten können wir die oben genannte Funktion in unserem Script ausführen lassen, wenn der Button gedrückt wurde:
* Neue Verbindung bei Button herstellen: [[Datei:unity-btn-add-connection.png|600px]] 
* Unser GameObject zuweisen: [[Datei:unity-btn-drag-gameobject-to-connect.png|600px]] 
* Unsere neu geschriebene Funktion auswählen: [[Datei:unity-btn-select-function.png|600px]] 

Wenn alles funktioniert hat ist das Resultat in der Console ablesbar: 
[[Datei:unity-btn-yay.png]]

== Mehrere Buttons mit einem Script verbinden ==
Im Folgenden Beispiel wollen wir mit zwei Buttons arbeiten, und unser KnopfGeklickt.cs Script so erweitern, dass wir im Script unterscheiden können, welcher der beiden Knöpfe gedrückt wurde. Hierzu benutzen wir ein Kozpet, dass in Unity in diesem Kontext mit '''static paramaters''' bezeichnet wird.

=== Hinzufügen eines Parameters in unsere Scriptfunktion ===
Wir ändern die Funktion in unserem Script, so dass wir einen Parameter unserer Wahl hinzufügen, und dadurch eine Entscheidung über unsere Ausgabe treffen können. Dieser Parameter wird später bei der Verbindung zu den Buttons mit einem Wert gefüllt, den wir im Inspector bei den jeweiligen Buttons einstellen können. Als Beispiel wähle ich hier einen '''int''' Parameter und nenne ihn "welcherButton": 

public void ButtonWurdeGeklickt(int welcherButton)
{

if (welcherButton==1){
Debug.Log("Button 1 gedrückt!");
}

if (welcherButton==2){
Debug.Log("Button 2 gedrückt!");
}

}

Damit ich zwischen zwei Buttons unterscheiden kann, brauche ich ja auch zwei Buttons. Ich habe dafür meinen ersten Button kopiert und leicht verschoben, dann beiden einen Namen gegeben, damit ich sie für mich besser unterscheiden kann. Meine Hierarchy sieht dementsprechend so aus: 
[[Datei:unity-btn-two-btns.png|600px]] 
Ich habe nun zwei Buttons, beide in der Hierarchy unter demselben Canvas GameObject, allerdings der Übersicht halber unterschiedlich benannt. Das sich mein Script geändert hat, muss ich die Funktion bei OnCLick wieder neu Verbinden.Beim Verbinden mit meiner abgeänderten Funktion entsteht nun ein neues Feld, in den ich manuell den Wert des Parameters eingeben kann, der an meine Funktion übergeben wird, wenn der Button gedrückt wird: 
[[Datei:unity-btn-static-parameter.png|600px]] 

Diese statischen Parameter müssen nun '''für jeden Button einzeln''' auf eine Zahl gesetzt werden, die ich dann im oben genannten Script abfragen kann. Für ''Button Eins'' setze ich die Zahl auf 1, für ''Button Zwei'' setze ich sie auf zwei. So kann ich mit einem einzelnen Script unterscheiden, welcher Knopf im User Interface gedrückt wurde.

== Textfelder ==
Nachdem wir die Verbindung von UI Elementen mit unseren Scripten und den Umgang mit statischen parametern angeschaut haben, stellt sich nun die Frage: Was tun, wenn wir die Eingabe von Nutzer*innen in textfelder direkt in Code weiterverarbeiten wollen? 
Hierzu erstellen wir zunächst ein neues InputField (TextMeshPro) in unserer Hierarchy. Wir ihr sehen könnt wird es direkt dem bereits bestehenden Canvas GameObject in der Hierarchy untergeordnet: 
[[Datei:unity-new-inputfield.png|400px]] 
Dieses Inputfield hat nun mehrere Möglichkeiten, die Texteingabe von Nutzer*innen an den von uns geschriebenen Code weiterzuleiten: 
[[Datei:unity-textinput-functionlist.png|400px]] 
Die Funktionszuschreibungen funktionieren hier genauso wie bei den Buttons weiter oben, jedoch können wir zu verschiedenen Zuständen, die es beim InputField geben kann auch verschiedene Funktionen zuordnen. 

=== Durch Textfelder Funktionen rufen ===
Um das auszuprobieren, können wir ein neues Script erstellen, dass ich beispielhalber TextEingabeLesen.cs nennen möchte. In diesem Script können wir eine Funktion hinzufügen, von der wir wollen, dass sie aufgerufen wird, wenn jemand etwas in unser InputField geschrieben und die Eingabe bestätigt hat. Die Funktion könnte ungefähr so aussehen:

public void TextEingegeben(){

Debug.Log("Yay!");

}

Da ich mich zunächst vergewissern möchte, dass ich alles richtig verbunden habe, macht diese Funktion zunächst nicht besonders viel. Sie ist aber ein erster Schritt, mit dem ich überprüfen kann, ob die Funktion tatsächlich im richtigen Moment gerufen wird. 
Folgende Schritte stehen also nun an:
* Ein neues, leeres GameObject muss der Hierarchy hinzugefügt werden, vielleicht nennen wir es "TextVerarbeitung"
* Unser neu geschriebenes Script mit dem Namen TextEingabeLesen.cs muss als Component zum neuen GameObject TextVerarbeitung hinzugefügt werden.
* In unserem InputField GameObject, muss ich eine neue Verbindung bei '''OnEndEdit''' zu TextVerarbeitung hinzufügen: 
[[Datei:unity-connect-script-to-inputfield.png|600px]]
* Als Funktion soll die Funktion TextEingeben ausgeführt werden.

Wenn alles verbunden ist, könnt ihr die Eingabe testen: In der Game View und im Play Modus könnt ihr auf das Textfeld klicken, einen Text eingeben und dann die Enter-Taste drücken. In der Konsole sollte dann "Yay!"erscheinen. 
[[Datei:Unity-btn-yay.png]]

=== Übungen ===
* Könnt ihr die Szene so verändern, dass "Yay!" jedesmal erscheint wenn ein Buchstabe ins Textfeld eingegeben wird?
* Könnt ihr euer Script so umschreiben, dass in der Console "..." ausgegeben wird, wenn jemand etwas tippt, und "Yay!" wenn die Eingabe beendet wurde?

=== Dynamische Parameter ===
Ein einfaches Beispiel könnte den eingegebenen Text in der Console ausgeben. Wie aber stellt mir das InputField diesen eingegebenen text zur Verfügung? Die Antwort ist: über einen '''dynamic parameter'''. Wir können für unsere Funktion, ähnlich wie bei ''static parameter'' bei den Buttons, nun einen neuen Parameter vom Typ string definieren:

public void TextEingegeben(string derText){

Debug.Log(derText);

}

Damit das InputFIeld GameObject weiss, dass es den eingegebenen Text an diese Funktion übergeben soll, müssen wir die Funktion folgendermassen verbinden: 
[[Datei:unity-inputfield-dynamic-string.png|600px]] 
Wie ihr sehen könnt, gibt es unsere Funktion TextEingegeben in der Liste gleich zweimal: einmal unter der Kategorie '''Dynamic string''' und einmal unter der Kategorie '''Static Parameters'''. In diesem Fall wollen wir unsere Funktion aus der oberen Liste auswählen, damit Unity den eingegebenen Text direkt an den Parameter unserer Funktion weitergeben kann!

===Übungen===
* Kannst du eine Unity Szene machen, in der sich ein Würfel immer einen Meter vorwärts bewegt, wenn jemand das Wort "liebe" in ein Textfeld eingibt?
* Kannst du eine Unity Szene machen, in der derselbe Würfel einen Namen bekommt, der durch ein zweites Textfeld festgelegt wird?
* Kannst du eine Eingabe aus einem textfeld in einem 3D-Text (TextMeshPro) erscheinen lassen?

==Übungen zu UI und Unity==
* Kannst du ein Quiz-Programm schreiben, dass die 10 Fragen hintereinander stellt, und am Ende eine Auswertung auf dem Screen ausgibt?
* Kannst du über [[OSC in Unity]] die Antworten dieser Fragen auf einem anderen Computer visualisieren?
* Kannst du einige der Fragen über ein UI Element Slider von 1-10 beantworten lassen?

UI in Unity

2021-04-21T16:26:33Z

Fkirschner: /* Text in einem Textfeld per Script definieren */

= UI =
'''UI''' steht generell als Kurzform von '''User Interface'''. Im Kontext von Unity bezeichnet der Begriff '''UI''' allerdings eine von Unity spezifisch vorgegebene Interaktionsstruktur, die mit Buttons, Textfeldern und ähnlichem arbeitet, und sich im Code von den [[Interaction in Unity| meisten anderen Interaktionen unterscheidet]].
Der Hauptunterschied besteht im von Unity vorgegebenen Interaktionsmodus durch UI Elemente und die Unterschiede in der Art der Darstellung auf dem Bildschirm.

== UI Elemente hinzufügen ==
Unity UI Elemente sind GameObjects die man in der Hierarchy über den Unterpunkt UI erstellen kann. 
[[Datei:create-ui-menu-unity.png | 400px]] 
Es stehen eine Reihe von Elementen zur Auswahl. Wir werden uns auf dieser Seite hauptsächlich mit den Elementen Button (TextMeshPro) und Text (TextMeshpro) beschäftigen.
=== Kurze Erklärung zu TextMeshPro ===
Unity ist in den letzten zehn Jahren enorm schnell gewachsen und hat oft Code-Elemente, die von Menschen ausserhalb der Firma erstellt wurden über Zeit in den eigenen Code übernommen. TextMeshPro ist so ein Fall, in dem besserer Code zur Darstellung von texten in unity eingeflossen ist. Unity muss allerdings nun den von ihnen selbst erstellten sowie den zugekauften Code weiter anbieten, was dazu führt, dass man als Nutzer*in die Auswahl aht, für welche dier beiden zur Verfügung gestellten Varianten man sich entscheiden möchte. 
 
'''Wir wollen uns im Zweifel immer für TextMeshPro entscheiden''', da der Text schöner dargestellt wird.
 
Wenn ihr das erste Mal aus der Hierarchy ein GameObject mit dem Zusatz (TextMeshPro) erstellt, ploppt folgender Dialog auf, bei dem ihr auf beide Knöpfe klicken könnt: 
[[Datei:tmp-import.png|600px]] 

=== Das Canvas Konzept ===
Alle in Unity genutzten UI Elemente werden einem sogenannten '''Canvas''' Objekt zugeordnet, einer Art Leinwand, die über der Szenen auf den Bildschirm gespannt ist. Wenn wir in der Hierarchy einen neuen Button erstellen, erstellt Unity auch gleich ein '''Canvas''' Object sowie ein '''EventSystem''' (über letzteres werde wir uns im Rahmen des Studiengangs nur peripher unterhalten). 
[[Datei:unity-canvas-eventsystem-ui.png |400px]] 
UI Elemente werden relativ zu diesem Canvas positioniert und dargestellt (gerendert) und unterliegen dem Koordinatensystem, das durch den Canvas vorgegeben ist. Für gewöhnlich sind sie daher '''unabhängig von der Position und Rotation der Kamera in der Szene''' immer am selben Ort auf dem Bildschirm. '''Deswegen müssen UI Elemente in der Hierarchy in Unity auch immer unter einem Canvas Objekt auftauchen.''' 
Das Koordinatensystem des Canvas Objekts wiederum orientiert sich an der [[Screen Resolution| Auflösung des Bildschirms]], wie in der Game View eingestellt. 
[[Datei:unity-gameview-resolution.png| 600px]] 
Da man sich der Auflösung der Endgeräte zu Beginn eines Projektes nicht immer sicher sein kann, und Unity von sich aus vorsieht, dass die Nutzer*innen ihre Auflösung auch selbst einstellen können (kommt bei uns seltener vor), bietet uns Unity durch die Nutzung des Canvas Konzeptes an, dass wir verschiedene UI Elemente '''relativ zu den Ecken des Bildschirms''' positionieren können. Hierfür ändert Unity den uns bekannten [https://docs.unity3d.com/ScriptReference/Transform.html| '''Transform'''] Component in ein [https://docs.unity3d.com/ScriptReference/RectTransform.html| '''RectTransform'''] Component (der allerdings von Transform abgeleitet ist, so dass wir per Script weiterhin wie gewohnt auf transform.position zugreifen können): 
[[Datei:recttransform.png|400px]] 
=== Unterschiede in Koordinaten ===
Wie ihr gut erkennen könnt, sind die Zahlen, die in diesem Component die Position des GameObjects beschreiben deutlich anders, als die von uns bisher genutzten. Während wir bei unseren bisherigen Übungen für gewöhnlich Koordinaten zwischen 1 und 10 oder -1 und -10 für die x, y und z Werte genutzt haben, stehen hier plötzlich zahlen in der Grösse von 100 und 1000. Das hat damit zu tun, dass die Koordinaten bei Rect Transform als Bildschirmkoordinaten interpretiert werden, wobei eine Koordinate von 1 genau einen Pixel beschreibt. Zum Vergleich: in unserer Unity Szene beschreibt eine Koordinate von 1 für gewöhnlich die Distanz von einem Meter. 
=== Darstellung in Scene View und Game View ===
Wenn wir zwischen der Unity Scene View und der Game View hin und her schalten, stellen wir fest, dass unser Button in der Game View zwar an einem sinnvollen Punkt dargestellt wird, in unserer Scene View Allerdings nichts von ihm zu sehen ist. Stattdessen sehen wir eine seltsame Linie mit Ecke: 
[[Datei:ui-scene-vs-gameview.png|800px]] 
Der Grund dafür ist, dass die Unity Scene View immer alle Dinge in Unity Koordinaten darstellt (1 Unity Koordinate interpretieren wir für gewöhnlich als 1 Meter), wohingegen in der Game View die Besonderheiten des Canvas-Konzeptes bereits in Betracht gezogen werden, und die UI Elemente unabhängig von der Kamera auf dem Bildschirm platziert werden. 
'''UI Elemente sind also am Einfachsten in der Game View sichtbar und es empfiehlt sich, ihre positionierung auch dort zu überprüfen.''' 
 
Trotzdem können UI Elemente auch in der Scene View angeschaut und manipuliert werden. Die oben angesprochene weisse Linie beschreibt den Umfang des Canvas Objektes in Unity 3D-Koordinaten. Im Canvas Objekt selbst könnt ihr unter ''width'' und ''height'' nachschauen, wie gross dieser Umfang ist. Wenn ihr gaaaaaaaanz weit herauszoomt, könnt ihr dann auch euren Button sehen. Eine einfachere Version, um eine übersicht über die UI Elemente in der Scene View zu bekommen ist, '''das Canvas GameObjekt doppelklicken'''. 
[[Datei:unity-doubleclick-canvas.png|600px]]

Ihr könnt selbstverständlich wie gewohnt, auch UI Elemente in der Scene View anklicken und verschieben. Wichtig hierbei ist nur zu wissen, dass der Canvas diese Elemente nicht perspektivisch darstellt und sich an der Darstellung der UI Elemente somit auch bei Verschiebung in der Z-Achse nichts ändert.

=== Relatives Ausrichten der UI Elemente ===
Durch klicken auf das Piktogramm links bei RectTransform können wir bestimmen, wie Unity die relative Position unseres UI Elements bestimmen soll: 
[[Datei:unity-ui-anchors.png|400px]] 
Gerade bewegt Unity unseren Button von der Mitte des Screens aus gesehen 687 Pixel nach links und 369.5 Pixel nach unten.
Mehr informationen hierzu findet ihr in der [https://docs.unity3d.com/Packages/com.unity.ugui@1.0/manual/UIBasicLayout.html| Unity Gebrauchsanweisung für UI Elemente].

Nachdem wir einen '''Button (TextMeshPro)''' in Unity hinzugefügt haben, sollte unsere Szene ungefähr so aussehen: 

[[Datei:unity-scene-with-button.png|800px]] 

== Textfelder ==
Nicht immer werden UI Elemente dafür genutzt, dass sie manipuliert werden können. Oft sollen sie auch einfach nur etwas darstellen oder anzeigen. Ein Beispiel dafür ist '''Text (TextMeshPro)''': 
[[Datei:unity-ui-create-text-tmp.png|600px]] 

Ein Textfeld generiert genauso einen Canvas (falls noch keiner da ist) oder ordnet sich automatisch einem bestehenden Canvas unter (falls schon ein anderes UI Element in der Szene ist).

=== Text in einem Textfeld per Script definieren ===
Der Unity Editor erlaubt euch, den Text den ihr im Textfeld seht direkt im Editor einzugeben. Für Nutzer*innen eures Programms ist der Text allerdings nicht editierbar. Jedoch könnt ihr den Text selbstverständlich per Script jederzeit ändern. 
Dafür erstellen wir hier als Beispiel ein neues Script, dass den Text in unserem neu generierten Textfeld verändert. Wir wollen es TextChange.cs nennen: 
[[Datei:unity-new-script-textChange.png|400px]] 

Um von unserem Script aus auf das '''Text (TextMeshPro)''' GameObject zugreifen zu können und dort den angezeigten Text zu verändern, müssen wir eine Verbindung zu unserem Script in Form einer Variable schaffen. Dazu brauchen wir, [[Algorithms#Auf_eine_Variable_in_einem_anderen_Script_zugreifen| wie immer]], den Typ des Scripts auf das wir zugreifen wollen. Im Falle eines '''Text (TextMeshPro)''' stellt sich der Typ allerdings als etwas komplizierter dar, weil es Text in Unity in unterschiedlichen Formen gibt: einmal für UI und einmal für die 3D Repräsentation in unserer Szene! Indiesem Fall wollen wir auf die UI-Version des Typs Text (TextMeshPro) zugreifen. Der Typ unseres Textfeldes ist in diesem Fall TextMeshProUGUI (UGUI steht kurz für Unity Graphical User Interface). Damit wir direkt Zugriff auf diesen Typ bekommen, sollten wir die Library TMPro in unserem Script mit laden. Das sieht dann so aus: 
[[Datei:visual-studio-using-tmpro.png|600px]] 

Wir können nun im Unity Editor unser Script in ein neues, leeres GameObject ziehen, das wir TextManipulation nennen können: 
[[Datei:unity-ui-textmanipulation-gameobject.png|600px]] 
Und dort dann die Verbindung mit unserem Text(TMP) GameObject und dem zugehörigen TextMeshProUGUI Component herstellen: 
[[Datei:unity-ui-connect Text-tmp-to-textmanipulation.png|600px]] 
 
Nun können wir in unserem TextChange.cs Script auf die Variable '''text'''in der verbundenen TextMeshProUGUI-Komponente zugreifen und sie verändern, in dem wir beispielsweise unsere Start Funktion folgendermassen umschreiben: 

void Start()
{

meinTextFeld.text="Hallo Welt!";

}

oder in unserer Update Funktion folgendes Schreiben:

void Update()
{

meinTextFeld.text+="mi";

}

== Einen Button abfragen ==
Prinzipiell erstellen wir in unseren Szenen Buttons als UI-Elemente, weil wir im Code darauf reagieren wollen, dass jemensch den Button geklickt hat. Hier hilft uns Unity durch bereits vorprogrammierte Strukturen, die es uns sehr einfach ermöglichen, eine Funktion aufzurufen, wenn ein bestimmter Button geklickt wurde.

=== Beispielscript ===
Wir können also ein Beispielscript erstellen, nennen wir es KnopfGeklickt.cs (Grossschreibung bei neuen Scripten beachten!). Und diesem Script können wir eine einfache Funktion hinzufügen - in diesem Beispiel die Funktion ButtonWurdeGeklickt(), die uns in der Konsole etwas ausgibt:

public void ButtonWurdeGeklickt(){

Debug.Log("Yay!");

}

Das '''public''' bei public void ist in diesem Fall sehr wichtig, da wir diese Funktion ausserhalb des eigenen GameObjects aufrufen wollen!

=== Button mit Beispielscript verbinden ===
Nachdem wir unser Script als Component auf ein leeres Gameobject hinzugefügt haben, können wir daraufhin im Inspector den Button mit unserer Funktion direkt verbinden. Dazu fügen wir beim Button im Feld OnClick eine neue Verbindung zu unserer Funktion hinzu: 
Ausgangspunkt ist unsere Hierarchy mit unserem GameObject (ich habe es KlickKonsequenz genannt) und unserem neuen Script als Component: 
[[Datei:unity-klickkonsequenz-setup.png|600px]] 
In Folgenden Schritten können wir die oben genannte Funktion in unserem Script ausführen lassen, wenn der Button gedrückt wurde:
* Neue Verbindung bei Button herstellen: [[Datei:unity-btn-add-connection.png|600px]] 
* Unser GameObject zuweisen: [[Datei:unity-btn-drag-gameobject-to-connect.png|600px]] 
* Unsere neu geschriebene Funktion auswählen: [[Datei:unity-btn-select-function.png|600px]] 

Wenn alles funktioniert hat ist das Resultat in der Console ablesbar: 
[[Datei:unity-btn-yay.png]]

== Mehrere Buttons mit einem Script verbinden ==
Im Folgenden Beispiel wollen wir mit zwei Buttons arbeiten, und unser KnopfGeklickt.cs Script so erweitern, dass wir im Script unterscheiden können, welcher der beiden Knöpfe gedrückt wurde. Hierzu benutzen wir ein Kozpet, dass in Unity in diesem Kontext mit '''static paramaters''' bezeichnet wird.

=== Hinzufügen eines Parameters in unsere Scriptfunktion ===
Wir ändern die Funktion in unserem Script, so dass wir einen Parameter unserer Wahl hinzufügen, und dadurch eine Entscheidung über unsere Ausgabe treffen können. Dieser Parameter wird später bei der Verbindung zu den Buttons mit einem Wert gefüllt, den wir im Inspector bei den jeweiligen Buttons einstellen können. Als Beispiel wähle ich hier einen '''int''' Parameter und nenne ihn "welcherButton": 

public void ButtonWurdeGeklickt(int welcherButton)
{

if (welcherButton==1){
Debug.Log("Button 1 gedrückt!");
}

if (welcherButton==2){
Debug.Log("Button 2 gedrückt!");
}

}

Damit ich zwischen zwei Buttons unterscheiden kann, brauche ich ja auch zwei Buttons. Ich habe dafür meinen ersten Button kopiert und leicht verschoben, dann beiden einen Namen gegeben, damit ich sie für mich besser unterscheiden kann. Meine Hierarchy sieht dementsprechend so aus: 
[[Datei:unity-btn-two-btns.png|600px]] 
Ich habe nun zwei Buttons, beide in der Hierarchy unter demselben Canvas GameObject, allerdings der Übersicht halber unterschiedlich benannt. Das sich mein Script geändert hat, muss ich die Funktion bei OnCLick wieder neu Verbinden.Beim Verbinden mit meiner abgeänderten Funktion entsteht nun ein neues Feld, in den ich manuell den Wert des Parameters eingeben kann, der an meine Funktion übergeben wird, wenn der Button gedrückt wird: 
[[Datei:unity-btn-static-parameter.png|600px]] 

Diese statischen Parameter müssen nun '''für jeden Button einzeln''' auf eine Zahl gesetzt werden, die ich dann im oben genannten Script abfragen kann. Für ''Button Eins'' setze ich die Zahl auf 1, für ''Button Zwei'' setze ich sie auf zwei. So kann ich mit einem einzelnen Script unterscheiden, welcher Knopf im User Interface gedrückt wurde.

== Textfelder ==
Nachdem wir die Verbindung von UI Elementen mit unseren Scripten und den Umgang mit statischen parametern angeschaut haben, stellt sich nun die Frage: Was tun, wenn wir die Eingabe von Nutzer*innen in textfelder direkt in Code weiterverarbeiten wollen? 
Hierzu erstellen wir zunächst ein neues InputField (TextMeshPro) in unserer Hierarchy. Wir ihr sehen könnt wird es direkt dem bereits bestehenden Canvas GameObject in der Hierarchy untergeordnet: 
[[Datei:unity-new-inputfield.png|400px]] 
Dieses Inputfield hat nun mehrere Möglichkeiten, die Texteingabe von Nutzer*innen an den von uns geschriebenen Code weiterzuleiten: 
[[Datei:unity-textinput-functionlist.png|400px]] 
Die Funktionszuschreibungen funktionieren hier genauso wie bei den Buttons weiter oben, jedoch können wir zu verschiedenen Zuständen, die es beim InputField geben kann auch verschiedene Funktionen zuordnen. 

=== Durch Textfelder Funktionen rufen ===
Um das auszuprobieren, können wir ein neues Script erstellen, dass ich beispielhalber TextEingabeLesen.cs nennen möchte. In diesem Script können wir eine Funktion hinzufügen, von der wir wollen, dass sie aufgerufen wird, wenn jemand etwas in unser InputField geschrieben und die Eingabe bestätigt hat. Die Funktion könnte ungefähr so aussehen:

public void TextEingegeben(){

Debug.Log("Yay!");

}

Da ich mich zunächst vergewissern möchte, dass ich alles richtig verbunden habe, macht diese Funktion zunächst nicht besonders viel. Sie ist aber ein erster Schritt, mit dem ich überprüfen kann, ob die Funktion tatsächlich im richtigen Moment gerufen wird. 
Folgende Schritte stehen also nun an:
* Ein neues, leeres GameObject muss der Hierarchy hinzugefügt werden, vielleicht nennen wir es "TextVerarbeitung"
* Unser neu geschriebenes Script mit dem Namen TextEingabeLesen.cs muss als Component zum neuen GameObject TextVerarbeitung hinzugefügt werden.
* In unserem InputField GameObject, muss ich eine neue Verbindung bei '''OnEndEdit''' zu TextVerarbeitung hinzufügen: 
[[Datei:unity-connect-script-to-inputfield.png|600px]]
* Als Funktion soll die Funktion TextEingeben ausgeführt werden.

Wenn alles verbunden ist, könnt ihr die Eingabe testen: In der Game View und im Play Modus könnt ihr auf das Textfeld klicken, einen Text eingeben und dann die Enter-Taste drücken. In der Konsole sollte dann "Yay!"erscheinen. 
[[Datei:Unity-btn-yay.png]]

=== Übungen ===
* Könnt ihr die Szene so verändern, dass "Yay!" jedesmal erscheint wenn ein Buchstabe ins Textfeld eingegeben wird?
* Könnt ihr euer Script so umschreiben, dass in der Console "..." ausgegeben wird, wenn jemand etwas tippt, und "Yay!" wenn die Eingabe beendet wurde?

=== Dynamische Parameter ===
Ein einfaches Beispiel könnte den eingegebenen Text in der Console ausgeben. Wie aber stellt mir das InputField diesen eingegebenen text zur Verfügung? Die Antwort ist: über einen '''dynamic parameter'''. Wir können für unsere Funktion, ähnlich wie bei ''static parameter'' bei den Buttons, nun einen neuen Parameter vom Typ string definieren:

public void TextEingegeben(string derText){

Debug.Log(derText);

}

Damit das InputFIeld GameObject weiss, dass es den eingegebenen Text an diese Funktion übergeben soll, müssen wir die Funktion folgendermassen verbinden: 
[[Datei:unity-inputfield-dynamic-string.png|600px]] 
Wie ihr sehen könnt, gibt es unsere Funktion TextEingegeben in der Liste gleich zweimal: einmal unter der Kategorie '''Dynamic string''' und einmal unter der Kategorie '''Static Parameters'''. In diesem Fall wollen wir unsere Funktion aus der oberen Liste auswählen, damit Unity den eingegebenen Text direkt an den Parameter unserer Funktion weitergeben kann!

Datei:Unity-ui-connect Text-tmp-to-textmanipulation.png

2021-04-21T16:22:15Z

Fkirschner: