Provided by: fp-units-castle-game-engine_6.4+dfsg1-2_amd64 bug


       castle-engine - build and package Castle Game Engine programs


       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:

              Creates simple CastleEngineManifest.xml with guessed values.

              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 special collection of OS/CPU platforms (like

              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 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  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 the source code of the application.

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

              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

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

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

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

   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.

              Compilation mode, used by "compile" command. Also packaging mode for some platforms
              (right now, Android). By default "release".

              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

       --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.

              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).

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


              The target system for which we build/package.  - "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.

       --os   Set the target operating system for which we build/package.  Available values:

              linux go32v2 win32 os2 freebsd beos netbsd amiga atari solaris qnx netware  openbsd
              wdosx  palmos macos darwin emx watcom morphos netwlibc win64 wince gba nds embedded
              symbian haiku iphonesim aix java android nativent msdos wii

       --cpu  Set the target processor for which we build/package.  Available values:

              i386 m68k powerpc sparc x86_64 arm  powerpc64  avr  armeb  mips  mipsel  jvm  i8086

       Full documentation on

       castle-engine version 6.4.  Created using Castle Game Engine ( )
       version 6.4.  Compiled with FPC 3.0.4 (Linux / x86_64).