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.