Dependencies

.Net SDK 9.0 is required for development.

Currently, it's also required on player machine. That's temporary limitation, self-contained distribution will be supported soon.

Download

Windows
macOS
- Binaries are not signed, so it requires to allow it running on your Mac in macOS settings.
Linux
Install from sources

How to use

Install .NET 9.0 SDK if it's not installed yet.

Select a project directory where you'll keep scripts and other resources.

Run editor:

(All OS) Specify project directory via command line argument C:/dev/fyrox_cs_sdk/fyroxed_cs_netcore.exe <path>
(Windows only) Double-click on C:/dev/fyrox_cs_sdk/fyroxed_cs_netcore.exe icon and choose project directory in opened dialog window.
(Windows only) Drop project directory on the C:/dev/fyrox_cs_sdk/fyroxed_cs_netcore.exe icon in file explorer.

Minimal C# project files will be created automatically and C# project will be automatically compiled.

Game can be launched using Play button in editor. Also, game can be launched using IDE with debug support (run profile for JB Rider generated, for other IDE note that working directory should be the project directory, not the build directory). Also, game can be launched using dotnet run in the game directory.

Scripts

Inherit classes from NodeScript to create scripts that can be attached to scene nodes in editor via dropdown on Inspector panel at the right.

Inherit from GlobalScript to create singleton scripts (no need for [Uuid(...)] attribute).

NodeScript classes should be annotatee using [Uuid(...)] attribute. Consider JB Rider plugin for Fyrox C# - it generates UUID, but also puts attribute if script created via context menu, also it highlight fields. If you use different IDE, UUID value using any online service like this.

Look into guards_cs project as an example.

Scripts Reloading

Editor reloads scripts metadata automatically after their compilation. In-game hot reload is not supported.

Scenes & Assets

Original Fyrox engine is 100% relevant in all non-code things, so Fyrox Book is advised for non-code information.

CLI

The fyroxed_cs_netcore.exe can also be invoked via terminal with project path argument.

Install from sources

That's optional, because prebuilt binaries are available.

Install .NET 9.0 SDK if it's not installed yet.
Install latest Rust toolchain.
(Windows only) Install Git Bash. Other MSYS2 distribution haven't tested.

Checkout sources and install using shell command (use Git Bash on windows)

git clone https://github.com/kkolyan/fyrox_lite.git \
  && cd fyrox_lite \
  && chmod +x **/*.sh \
  && ./bash/cs_install_sdk.sh <installation path>

<installation path> now contains ready-to-use binaries.

Scripting API (C#)

Color

package

Signature	Description
( float r, float g, float b, float a )	Constructs a `Color` from RGBA values, typically on the range of 0 to 1.
( Color c, float a )	Constructs a `Color` from an existing color and an alpha value.
( uint rgba )	Constructs a `Color` from an unsigned 32-bit integer in RGBA format (each byte represents a color channel).
( ulong rgba )	Constructs a `Color` from an unsigned 64-bit integer in RGBA format (each word represents a color channel).
( string code )	Constructs a `Color` either from an HTML color code or from a standardized color name. Supported color names are the same as the `Colors` constants.
( string code, float alpha )	Constructs a `Color` either from an HTML color code or from a standardized color name, with `name` on the range of 0 to 1. Supported color names are the same as the `Colors` constants.

Name	Type	Access	Description
`R8`	byte	get / set	Wrapper for `R` that uses the range 0 to 255 instead of 0 to 1. Getting is equivalent to multiplying by 255 and rounding. Setting is equivalent to dividing by 255.
`G8`	byte	get / set	Wrapper for `G` that uses the range 0 to 255 instead of 0 to 1. Getting is equivalent to multiplying by 255 and rounding. Setting is equivalent to dividing by 255.
`B8`	byte	get / set	Wrapper for `B` that uses the range 0 to 255 instead of 0 to 1. Getting is equivalent to multiplying by 255 and rounding. Setting is equivalent to dividing by 255.
`A8`	byte	get / set	Wrapper for `A` that uses the range 0 to 255 instead of 0 to 1. Getting is equivalent to multiplying by 255 and rounding. Setting is equivalent to dividing by 255.
`H`	float	get / set	The HSV hue of this color, on the range 0 to 1. Getting is a long process, refer to the source code for details. Setting uses `FromHsv` .
`S`	float	get / set	The HSV saturation of this color, on the range 0 to 1. Getting is equivalent to the ratio between the min and max RGB value. Setting uses `FromHsv` .
`V`	float	get / set	The HSV value (brightness) of this color, on the range 0 to 1. Getting is equivalent to using `Math.Max(float, float)` on the RGB components. Setting uses `FromHsv` .
`Luminance`	float	get	Returns the light intensity of the color, as a value between 0.0 and 1.0 (inclusive). This is useful when determining light or dark color. Colors with a luminance smaller than 0.5 can be generally considered dark. Note: `Luminance` relies on the color being in the linear color space to return an accurate relative luminance value. If the color is in the sRGB color space use `SrgbToLinear` to convert it to the linear color space first.

Return Type	Signature	Description
Color	`Blend` ( Color over )	Returns a new color resulting from blending this color over another. If the color is opaque, the result is also opaque. The second color may have a range of alpha values.
Color	`Clamp` ( Color? min, Color? max )	Returns a new color with all components clamped between the components of `name` and `name` using `Mathf.Clamp(float, float, float)` .
Color	`Darkened` ( float amount )	Returns a new color resulting from making this color darker by the specified ratio (on the range of 0 to 1).
Color	`Inverted` ( )	Returns the inverted color: `(1 - r, 1 - g, 1 - b, a)` .
Color	`Lightened` ( float amount )	Returns a new color resulting from making this color lighter by the specified ratio (on the range of 0 to 1).
Color	`Lerp` ( Color to, float weight )	Returns the result of the linear interpolation between this color and `name` by amount `name` .
Color	`LinearToSrgb` ( )	Returns the color converted to the sRGB color space. This method assumes the original color is in the linear color space. See also `SrgbToLinear` which performs the opposite operation.
Color	`SrgbToLinear` ( )	Returns the color converted to linear color space. This method assumes the original color already is in sRGB color space. See also `LinearToSrgb` which performs the opposite operation.
uint	`ToAbgr32` ( )	Returns the color converted to an unsigned 32-bit integer in ABGR format (each byte represents a color channel). ABGR is the reversed version of the default format.
ulong	`ToAbgr64` ( )	Returns the color converted to an unsigned 64-bit integer in ABGR format (each word represents a color channel). ABGR is the reversed version of the default format.
uint	`ToArgb32` ( )	Returns the color converted to an unsigned 32-bit integer in ARGB format (each byte represents a color channel). ARGB is more compatible with DirectX, but not used much in Godot.
ulong	`ToArgb64` ( )	Returns the color converted to an unsigned 64-bit integer in ARGB format (each word represents a color channel). ARGB is more compatible with DirectX, but not used much in Godot.
uint	`ToRgba32` ( )	Returns the color converted to an unsigned 32-bit integer in RGBA format (each byte represents a color channel). RGBA is Godot's default and recommended format.
ulong	`ToRgba64` ( )	Returns the color converted to an unsigned 64-bit integer in RGBA format (each word represents a color channel). RGBA is Godot's default and recommended format.
string	`ToHtml` ( bool includeAlpha )	Returns the color's HTML hexadecimal color string in RGBA format.
void	`ToHsv` ( float hue, float saturation, float value )	Converts a color to HSV values. This is equivalent to using each of the `h` / `s` / `v` properties, but much more efficient.
bool	`Equals` ( object? obj )	Returns `true` if this color and `name` are equal.
bool	`Equals` ( Color other )	Returns `true` if the colors are exactly equal. Note: Due to floating-point precision errors, consider using `IsEqualApprox` instead, which is more reliable.
bool	`IsEqualApprox` ( Color other )	Returns `true` if this color and `name` are approximately equal, by running `Mathf.IsEqualApprox(float, float)` on each component.
int	`GetHashCode` ( )	Serves as the hash function for `Color` .
string	`ToString` ( )	Converts this `Color` to a string.
string	`ToString` ( string? format )	Converts this `Color` to a string with the given `name` .

Return Type	Signature	Description
Color	`FromHtml` ( ReadOnlySpan rgba )	Constructs a `Color` from the HTML hexadecimal color string in RGBA format.
Color	`Color8` ( byte r8, byte g8, byte b8, byte a8 )	Returns a color constructed from integer red, green, blue, and alpha channels. Each channel should have 8 bits of information ranging from 0 to 255.
Color	`FromHsv` ( float hue, float saturation, float value, float alpha )	Constructs a color from an HSV profile. The `name` , `name` , and `name` are typically between 0.0 and 1.0.
Color	`FromRgbe9995` ( uint rgbe )	Encodes a `Color` from a RGBE9995 format integer. See `Image.Format.Rgbe9995` .
Color	`FromString` ( string str, Color @default )	Constructs a color from the given string, which can be either an HTML color code or a named color. Returns `name` if the color cannot be inferred from the string. Supported color names are the same as the `Colors` constants.
bool	`HtmlIsValid` ( ReadOnlySpan color )	Returns `true` if `name` is a valid HTML hexadecimal color string. The string must be a hexadecimal value (case-insensitive) of either 3, 4, 6 or 8 digits, and may be prefixed by a hash sign ( `#` ). This method is identical to `StringExtensions.IsValidHtmlColor(string)` .

Keyboard shortcuts

Fyrox Lite / C#