doc: Add scala support to documentation

Author: piiertho

docs/src/doc/index.md

@@ -48,7 +48,7 @@ If you don't have Discord or you don't want to use it, please file an issue on G
 
 ## Supported languages
 
-The main language supported is Kotlin. We do however support Java experimentally. It should be possible to support other JVM-based languages as well but this is not the focus of this project. If you want to have support for other languages, have a look at [support for other JVM-based languages](contribution/support-for-other-jvm-based-languages.md).
+The main language supported is Kotlin. We do however support Java and Scala experimentally. It should be possible to support other JVM-based languages as well but this is not the focus of this project. If you want to have support for other languages, have a look at [support for other JVM-based languages](contribution/support-for-other-jvm-based-languages.md).
 
 ## Supported platforms
 
@@ -85,7 +85,7 @@ Contrary to the official binaries, there are two builds of the editor per Platfo
 `release` editors are the editors you use normally. `debug` editors provide debug symbols and are intended to provide better stacktraces in case of crashes of the editor. Please use those when submitting bugreports. 
 
 !!! warning
-    This module will NOT work with the official Godot Editor and Export Templates! To be able to use Kotlin and Java scripts in Godot, you need our Editor and Export Templates builds.
+    This module will NOT work with the official Godot Editor and Export Templates! To be able to use Kotlin, Java and Scala scripts in Godot, you need our Editor and Export Templates builds.
 
 ## Developer discussion
 

docs/src/doc/user-guide/advanced/cleanup-operations.md

@@ -1,4 +1,4 @@
-When running Kotlin/Java code, the JVM is embedded and managed directly by Godot, which offer little control when the game is closing. 
+When running Kotlin/Java/Scala code, the JVM is embedded and managed directly by Godot, which offer little control when the game is closing. 
 If you use third-party library that needs resources to be freed/saved or threads to be closed. 
 To that end, we provide a simple method that allows you to register callbacks that will be called when the JVM is shutdown.
 

docs/src/doc/user-guide/api-differences.md

@@ -5,9 +5,9 @@ Godot Kotlin/JVM offers two different ways to attach scripts:
 - Source files
 - Registration files.
 
-## Source files .kt and .java
+## Source files .kt, .java and .scala
 
-Just like you would do with GDScript, you can directly attach your Kotlin/Java files to Nodes as scripts.
+Just like you would do with GDScript, you can directly attach your Kotlin/Java/Scala files to Nodes as scripts.
 This is the most straightforward method to use Kotlin scripts but not the most flexible.
 
 The limitations are the following:
@@ -20,7 +20,7 @@ The limitations are the following:
     var test_script: MyScript = load("res://pathToScript/MyScript.kt").new() // Wrong
     var test_script: Node = load("res://pathToScript/MyScript.kt").new() // Correct
     ```
-    The same applies if you use a Godot object with a .kt/.java attached to it
+    The same applies if you use a Godot object with a .kt/.java/.scala attached to it
 
 If those limitations don't apply to you, feel free to use Kotlin source files directly.
 
@@ -32,7 +32,7 @@ They have several benefits over source files:
 - .gdj can be placed wherever you want in your Godot project, you are not limited to the source set.
 - Each script get its own .gdj. This includes scripts in different modules and libraries.
 - If a source file contains several scripts. A different .gdj will be generated for each.
-- Registration files are language agnostic, they are generated for Kotlin and Java files with no difference.
+- Registration files are language agnostic, they are generated for Kotlin, Java and Scala files with no difference.
 - When creating a script from code using its registered name. The module is going to use the registration file as the script. Therefore, registration files are treated as the default way to use scripts inside the module.
 
 By default, these files are generated into a folder called `gdj` in the root of your project.
@@ -182,6 +182,14 @@ This kind of operation can be costly so we provide extension functions which cac
 ```
 ///
 
+/// tab | Scala
+```scala
+    val stringName = StringNames.asCachedStringName("myString")
+    val nodePath = NodePaths.asCachedNodePath("myNode/myChildNode")
+    val snakeCaseStringName = StringNames.toGodotName("myString")
+```
+///
+
 You can also use the non-cached version of them if you simply want ease of conversion:
 
 /// tab | Kotlin
@@ -198,6 +206,13 @@ You can also use the non-cached version of them if you simply want ease of conve
 ```
 ///
 
+/// tab | Scala
+```scala
+    val stringName = StringNames.asStringName("myString")
+    val nodePath = NodePaths.asNodePath("myNode/myChildNode")
+```
+///
+
 
 ## Logging
 

docs/src/doc/user-guide/signals_and_callables.md

@@ -35,6 +35,16 @@ public MyScript extends Node {
 ```
 ///
 
+/// tab | Scala
+```scala
+@RegisterClass
+class MyScript extends Node {
+    @RegisterSignal("reverse")
+    val mySignal: Signal1[Boolean] = Signal1.create(this, "mySignal") // Only one way to do it in Java.
+}
+```
+///
+
 !!! warning Signal parameter count
     In GDScript, signals can have any number of arguments, this is not possible in Kotlin as it is a statically typed language. 
     At the moment, you can create signals and expose them to Godot up to 16 parameters.
@@ -55,6 +65,12 @@ reverseChanged.emit(false);
 ```
 ///
 
+/// tab | Scala
+```scala
+reverseChanged.emit(false)
+```
+///
+
 ## Callables
 
 You can use a classic Callable referencing a Godot Object and one of its method or conveniently use to avoid to creating a separate function.
@@ -80,6 +96,19 @@ You can use a classic Callable referencing a Godot Object and one of its method
 ```
 ///
 
+/// tab | Scala
+```scala
+    val regularCallable = Callable.create(this, "myMethod".toGodotName())
+    val customCallable = LambdaCallable1.create(
+      classOf[Void],
+      classOf[String],
+      (string: String) => {
+        println(string);
+      }
+    )
+```
+///
+
 ### Signals and Callables together
 
 Kotlin and Java already have ways to pass functions around as References. 
@@ -143,6 +172,33 @@ public class AnotherObject extends Object {
 ```
 ///
 
+/// tab | Scala
+```scala
+@RegisterClass
+class SomeObject extends Object {
+    @RegisterFunction
+    def onReverseChanged(boolean reverse): Unit = {
+        println(s"Value of reverse has changed: $reverse")
+    }
+}
+
+@RegisterClass
+class AnotherObject extends Object {
+    @RegisterSignal("reverse")
+    val mySignal: Signal1[Boolean] = Signal1.create(this, "mySignal")
+
+    private val targetObject = new SomeObject()
+
+    public AnotherObject() {
+        // Here are 3 different ways to connect a signal to a registered method. The method reference syntax is not implemented for Java.
+        mySignal.connect(Callable.create(targetObject, StringNames.toGodotName("onReverseChanged"))) // The recommanded way.
+        mySignal.connect(Callable.create(targetObject, "on_reverse_changed")) // Unsafe, try to use snake_case in your code as least as possible.
+        connect("my_signal", Callable.create(targetObject, "on_reverse_changed")) // Really, don't do that.
+    }
+}
+```
+///
+
 You can also use Kotlin lambdas directly to subscribe to signals
 
 ```kt