NAME

       castle-engine - build and package Castle Game Engine programs

DESCRIPTION

       castle-engine: Build and package Castle Game Engine programs.

   Call with the current directory set to your project, like this:
              castle-engine [OPTIONS]... COMMAND

       Possible commands:

   create-manifest:
              Creates simple CastleEngineManifest.xml with guessed values.

   compile:
              Compile  project.  By default compiles for the current OS / current CPU (linux / x86_64).  You can
              use --os / --cpu options to compile to some other OS / CPU.  You can use --target to compile for a
              collection of OS / CPU combination (like "iOS" or "Android").

   package:
              Package the application into the best archive format for given operating system (OS)  /  processor
              (CPU) / target.  The OS, CPU and "target" can be changed just like at "compile".

   install:
              Install  the  application  created  by  previous  "package" call.  Useful when OS is "android", it
              installs the apk package created by previous "package" call for Android. Useful for quick  testing
              of  your  app  on a device connected through USB.  Useful also for installing compiled web browser
              plugin.

   run:
              Run the application.  On some platforms, it requires installing the  application  first  (e.g.  on
              Android, where we install and run on a device connected through USB). So run the "install" command
              before.   On  other  platforms (e.g. standalone Windows, Linux, macOS...), it simply runs the last
              compiled application.  So just "compile" the application first.

   package-source:
              Package the source code of the application.

   clean:
              Clean leftover files from compilation and packaging.  Does not remove final packaging output.

   simple-compile:
              Compile the Object Pascal file (unit/program/library) given as a parameter. This does  not  handle
              the  Castle Game Engine projects defined by CastleEngineManifest.xml files.  It merely calls "fpc"
              with proper command-line options for units/programs/libraries using our engine.  Use this  instead
              of  "compile"  only  if there's some good reason you don't want to use CastleEngineManifest.xml to
              your project.

   auto-generate-textures:
              Create   GPU-compressed   versions    of    textures,    for    the    textures    mentioned    in
              <auto_compressed_textures> inside the file data/material_properties.xml.

   auto-generate-clean:
              Clear   "auto_compressed"   subdirectories,  that  should  contain  only  the  output  created  by
              "auto-generate-textures" target.

   generate-program:
              Generate lpr and lpi files to edit and run this project in Lazarus.  Depends on  game_units  being
              defined in the CastleEngineManifest.xml.

   editor:
              Run Castle Game Engine Editor within this project, with possible project-specific components.

   Available options are:
       -h / --help
              Print this help message and exit.

       -v / --version
              Print the version number and exit.

       -V / --verbose
              Verbose mode, output contains e.g. list of packaged files.

       --mode=debug|release
              Compilation  mode, used by "compile" and "package" commands. Also packaging mode on some platforms
              (right now, Android). By default "release".

       --assume-compiled
              Do not automatically do "clean" and "compile"  before  "package".  Instead  assume  that  compiled
              executable for given OS/CPU/mode is already present in the package directory.

       --fast Do  not "clean" before "package". Recompile only what changed. This is faster for development, but
              cannot guarantee that everything is recompiled in a release mode.

       --plugin
              Compile/package/install a browser plugin.

       --fpc-version-iphone-simulator VERSION
              When compiling for iPhone Simulator, we pass  -V<VERSION>  to  the  "fpc"  command-line.  This  is
              necessary  if  you  use  the  official  "FPC for iOS" package (see the "Getting Started - iOS.rtf"
              inside the "FPC for iOS" dmg for explanation). You can set this to "auto" (this is the default) to
              auto-detect this based on regular FPC version. Or you can set this to a particular  version,  like
              "3.0.5".  Or  you  can  set  this  to  empty "" to avoid passing any -V<VERSION> (suitable for FPC
              3.1.1).

       --compiler-option=PARAM
              Extra parameter for  "fpc"  command  line.  For  example  --compiler-option=-dUSE_MOUSE  will  add
              -dUSE_MOUSE.  You can use this parameter multiple times.

       --output=DIR
              Where  to  place  the  output executables, packages, and the "castle-engine-output" directory with
              temporary generated files.

       --project=DIR
              Where to search for the project (CastleEngineManifest.xml file).  By  default  we  search  in  the
              current   directory.   The   argument   can   either   be   a   directory,   or   a   filename  of
              CastleEngineManifest.xml file.

       --all  Use by "auto-generate-clean", indicates to clean everything auto-generated.  By  default  we  only
              clean unused files from "auto_generated" directories.

       --manifest-name=AlternativeManifest.xml
              Search     and     use     given    "AlternativeManifest.xml"    file    instead    of    standard
              "CastleEngineManifest.xml".   Useful  if  you  need  to  maintain  completely  different   project
              configurations for any reason.

       --target=<target>
              The target system for which we build/package.  Available <target> values:

       - "custom" (default): Build for a single OS and CPU
              combination, determined by the --os and --cpu options. These options, in turn, by default indicate
              the current (host) OS/CPU.

       - "ios": Build for all the platforms necessary for
              iOS applications. This includes both 32-bit and 64-bit iOS devices and iPhoneSimulator.

       - "android": Build for all the platforms necessary
              for Android applications. This includes both 32-bit and 64-bit Android devices.

       - "nintendo-switch": Build an application for
              Nintendo Switch.

       --os=<os>
              Set  the  target  operating  system  for  which  we  build/package.   This  is ignored if you used
              --target=<target>, with <target> being something else than "custom".  Available <os> values:

       linux  go32v2 win32 os2 freebsd beos netbsd amiga atari solaris qnx netware openbsd  wdosx  palmos  macos
              (classic  MacOS,  that  ended  with  MacOS  9) darwin (modern macOS 10.x, caled also Mac OS X) emx
              watcom morphos netwlibc win64 wince gba nds embedded symbian  haiku  iphonesim  aix  java  android
              nativent msdos wii aros dragonfly win16

       --cpu=<cpu>
              Set   the   target   processor   for  which  we  build/package.   This  is  ignored  if  you  used
              --target=<target>, with <target> being something else than "custom".  Available <cpu> values:

       i386   m68k powerpc sparc x86_64 arm powerpc64 avr armeb mips  mipsel  jvm  i8086  aarch64  (64-bit  ARM)
              sparc64 riscv32 riscv64

       Full documentation on https://github.com/castle-engine/castle-engine/wiki/Build-Tool

       castle-engine    version    7.0-alpha.1    (unstable).     Created    using    Castle   Game   Engine   (
       https://castle-engine.io/ ) version 7.0-alpha.1 (unstable).  Compiled with FPC 3.2.2  (Linux  /  x86_64),
       platform: Desktop.

Castle Game Engine                                February 2022                                 CASTLE-ENGINE(1)