Update CMake docs

Author: fwsGonzo

docs/godot_docs/cmake.md

@@ -10,61 +10,92 @@ This method requires a local RISC-V compiler installed on your system. If you do
 
 CMake is completely optional. Normally, you can use Docker which compiles for you in the Godot editor.
 
-## Setup & Installation
+## Build using Zig
 
-There is a [CMake project in the Godot Sandbox](https://github.com/libriscv/godot-sandbox/tree/main/program/cpp/cmake) repository that can be used to create ELFs with the API pre-included.
+In order to build programs you will need to install: CMake, git, Zig
 
-The easiest way to access it is to create a symlink to the cmake folder above in your project so that you can directly reference it in CMake:
+[Download Zig](https://ziglang.org/download/) and add the extracted folder to PATH so that it becomes globally accessible. This means that typing `zig` from anywhere should work.
+
+The easiest way to use CMake is to have a look at what [Godot Sandbox Programs](https://github.com/libriscv/godot-sandbox-programs) is doing. It has build scripts for Linux, macOS and Windows, and builds several projects for you.
+
+Either fork the godot-sandbox-programs repository or copy it into a new one that you just created. Then go into the programs folder and remove everything except hello-world. Also edit `programs/CMakeLists.txt` to remove the other projects that you just deleted. You can rename hello-world, if you want.
+
+Now you have two options:
+1. If you commit changes and push them, Github Actions will build programs for you and upload them to a draft release. These are ready-to-use and will be very small.
+2. You can build programs yourself using any of the root-level scripts. Linux/macOS: `./build.sh` Windows: `./build.cmd`
+
+
+## Manual CMake setup
+
+There is a [CMake project in the Godot Sandbox](https://github.com/libriscv/godot-sandbox/tree/main/program/cpp/cmake) repository that can be used to create ELFs with the API pre-included. This CMake script supports both RISC-V cross-compilers and Zig cross-compilation.
 
 ```cmake
 cmake_minimum_required(VERSION 3.10)
 project(example LANGUAGES CXX)
 
-# Add the Godot Sandbox build functions
-add_subdirectory(cmake)
+# Fetch godot-sandbox repository (add_subdirectory is implicitly called)
+include(FetchContent)
+FetchContent_Declare(
+	godot-sandbox
+	GIT_REPOSITORY https://github.com/libriscv/godot-sandbox.git
+	GIT_TAG        main
+	SOURCE_SUBDIR  "program/cpp/cmake"
+)
+FetchContent_MakeAvailable(godot-sandbox)
 
 add_sandbox_program(example
     example.cpp
 )
 ```
 
-Here `example` is a regular CMake target that you can use like normal. You can have as many programs as you want.
+Here `example` becomes a program that you can load in the sandbox. You can add as many programs as you want.
 
-In order to build this project, we will use a simple build script:
+In order to build this project, we can use one of the scripts from the godot-sandbox-programs repository:
 
-```sh
-#!/bin/bash
+1. [Linux 64-bit RISC-V cross compiler script](https://github.com/libriscv/godot-sandbox-programs/blob/main/build.sh)
 
-# Change this to reflect your RISC-V toolchain
-export CC="riscv64-linux-gnu-gcc-14"
-export CXX="riscv64-linux-gnu-g++-14"
+2. [Linux/macOS Zig cross-compiler script](https://github.com/libriscv/godot-sandbox-programs/blob/main/zig.sh)
 
-# Create build directory, configure and compile
-mkdir -p .build
-pushd .build
-cmake .. -DCMAKE_BUILD_TYPE=Release
-make -j4
-popd
-```
+3. [Windows Zig cross-compiler script](https://github.com/libriscv/godot-sandbox-programs/blob/main/zig.sh)
 
-Remember to make the script executable:
 
-```sh
-chmod +x build.sh
-```
+### macOS
+
+You can use Zig as a cross-compiler. Have a look at the first chapter.
+
+The [macOS github action](https://github.com/libriscv/godot-sandbox-programs/blob/main/.github/workflows/zig-macos.yml) shows you what dependencies to install and how to build on macOS.
+
+The [Linux/macOS Zig cross-compiler script](https://github.com/libriscv/godot-sandbox-programs/blob/main/zig.sh) will also come in handy.
+
+
+### Windows
+
+You can use Zig as a cross-compiler. Have a look at the first chapter.
+
+The [Windows github action](https://github.com/libriscv/godot-sandbox-programs/blob/main/.github/workflows/zig-windows.yml) shows you how to build on Windows.
+
 
 ### Ubuntu and Windows WSL2
 
 On Linux and Windows WSL2 we can install a RISC-V compiler like so:
 
 ```sh
-sudo apt install g++-14-riscv64-linux-gnu cmake ninja-build git
+sudo apt install g++-14-riscv64-linux-gnu cmake git
 ```
 
-On some systems you may only have access to g++ version 12 or 13. Modify the `build.sh` below accordingly.
+This compiler can be referred to by setting CC and CXX:
+```sh
+export CC="riscv64-linux-gnu-gcc-14"
+export CXX="riscv64-linux-gnu-g++-14"
+```
+
+On some systems you may only have access to compiler version 12 or 13. Modify your `build.sh` script accordingly.
+
 
 ### Windows MSYS2
 
+MSYS2 has a RISC-V compiler that is not capable of compiling all kinds of programs. But it's enough to compile most C++.
+
 ```sh
 pacman -Sy mingw-w64-x86_64-riscv64-unknown-elf-gcc ninja cmake git
 mkdir -p build
@@ -76,10 +107,6 @@ cmake --build .
 You can find a working [MSYS2 build example here](https://github.com/libriscv/godot-sandbox-demo/tree/master/json_diff_sample/json_diff). For `unknown-elf`-type toolchains a toolchain file is needed.
 
 
-### macOS
-
-On macOS there are RISC-V toolchains in brew. Let us know which ones worked for you.
-
 ### Arch Linux
 
 ```sh
@@ -90,13 +117,13 @@ CXX=riscv64-linux-gnu-g++ CC=riscv64-linux-gnu-gcc cmake .. -G Ninja -DCMAKE_BUI
 ninja
 ```
 
-## CMake from Godot editor
+## Build with CMake from Godot editor
 
 If there is a `CMakeLists.txt` in the project root or in a `cmake` folder, when saving C++ code in the editor, `cmake --build` will be executed instead as if the CMake build folder was `.build`. Docker is ignored.
 
 If the CMake script is in project root, the build folder is also in project root: `./.build`, and if the CMake script is in `./cmake`, the build folder is in `./cmake/.build`. The CMake invocation is verbose, so pay attention to it in the Godot console.
 
-This feature allows you to use your own CMake project and RISC-V toolchain to build all the programs with.
+This feature allows you to use your own CMake project and RISC-V toolchain to build all the programs with, all from within the Godot editor.
 
 :::note
 
@@ -111,13 +138,14 @@ Docker can be disabled per project.
 
 Go to Project -> Project Settings and enable Advanced settings on the right. Scroll to Editor -> Script and disable Docker Enabled. You should no longer see any attempts at using Docker in this project.
 
-## Auto-completion in editor
 
-Auto-completion should automatically work if you symlink the `cmake` folder from Godot Sandbox to your project. If not, you can always add this path to your editor workspace:
+## Auto-completion in external editor
+
+Auto-completion should automatically work when using the pre-made CMake script from Godot Sandbox. The CMake script gives your editor access to the C++ API and the run-time generated API. Combined this covers 100% of the Godot API.
 
-https://github.com/libriscv/godot-sandbox/tree/main/program/cpp/api
+### Manually accessing the C++ APIs
 
-Adding the API path to your workspace should give you access to the C++ API.
+If it doesn't work, you can add this folder to your workspace: https://github.com/libriscv/godot-sandbox/tree/main/program/cpp/docker/api
 
 The API has a run-time generated portion that is auto-created when saving in the editor. It can also be created manually from GDScript:
 
@@ -167,6 +195,6 @@ If we now run `autobuild.sh` in a terminal window, it will automatically build o
 
 :::note
 
-Let us know if you have an autobuilder script for another platform!
+Let us know if you have made an autobuild script for another platform!
 
 :::

docs/godot_intro/cppprogram.md

@@ -21,7 +21,7 @@ The default C++ template should look something like this:
 ```cpp
 #include "api.hpp"
 
-extern "C" Variant public_function(String arg) {
+PUBLIC Variant public_function(String arg) {
     print("Arguments: ", arg);
     return "Hello from the other side";
 }