Polycode uses a CMake build generator for automatically downloading and building required 3rd party packages and Polycode itself. Polycode is setup for preferring custom static libraries over system ones, so please use the dependency build system even if you have all of the dependencies installed on your computer.
The first dependency is CMake. It can be downloaded from http://cmake.org/cmake/resources/software.html or installed using apt or rpm on most Linux distributions. CMake 2.8.8 or greater is now required.
When Polycode and its Dependencies are built, they will be available in the Release/YourArchitecture folder under the main source tree in a structure that should mimic the main binary release.
If you wish to build a 32-bit version on a 64-bit machine in OS X, pass -DCMAKE_OSX_ARCHITECTURES=i386 as an argument to cmake
Polycode depends on a number of third party packages that are not included in the Polycode source tree:
The CMake dependency build system will download and install static version of these libraries into the Polycode source tree. It will NOT attempt to install any of these packages into your system.
All dependenices will be installed into the Polycode source tree under Release//Framework/
Instructions describe using CMake on the command line, you may prefer to use the CMake GUI if unfamiliar with CMake.
NOTE: If you are using the new Xcode that is downloaded from the AppStore and cmake complains about not finding Xcode in /Developer, you have to run this command to update the Xcode path: sudo /usr/bin/xcode-select -switch /Applications/Xcode.app/Contents/Developer
To generate an Xcode project for building Polycode dependencies, perform the following steps in the Polycode directory from a terminal:
cd Dependencies
mkdir Build
cd Build
cmake -G Xcode ..
This generates a PolycodeDependencies Xcode project in the Build directory. Building this project in Xcode will download, build and install the dependencies (make sure you build the ALL_BUILD target). Note that you need to build both Debug and Release in Xcode
Note: Release is "Build for Archiving" in Xcode4.
To generate a Microsoft Visual Studio (any version) project for building Polycode dependencies, perform the following steps in the Polycode directory from a command prompt (for VS2010):
cd Dependencies
mkdir Build
cd Build
cmake -G "Visual Studio 10" ..
This generates a PolycodeDependencies.sln in the Build directory. Building the ALL_BUILD project in the solution in Visual Studio will download, build and install the dependencies. Note that you need to build both Debug and Release.
You will also need to manually build the "glext" and "wglext" projects.
To generate and build Debug and Release builds with Unix Makefiles perform the following steps in the Polycode directory from a terminal:
cd Dependencies
mkdir Build
cd Build
mkdir Debug
cd Debug
cmake -G "Unix Makefiles" -DCMAKE_BUILD_TYPE=Debug ../..
make
cd ..
mkdir Release
cd Release
cmake -G "Unix Makefiles" -DCMAKE_BUILD_TYPE=Release ../..
make
The Polycode CMake build will look for dependencies installed as static libraries in the Release folder by the above dependency build step. It will not use system level versions of these libraries, even if you have them installed. The only exception to this is SDL for the Linux build, which you must manually install on the system level.
If you want to build documentation, you must have Doxygen installed and in your run path. You can get Doxygen from http://www.doxygen.org or install it using a package manager.
To generate an Xcode project for building Polycode, perform the following steps in the Polycode directory from a terminal:
mkdir Build
cd Build
cmake -G Xcode ..
This generates a Polycode Xcode project in the Build directory.
Build the "ALL_BUILD" target in this project in both Debug and Release and then build the "install" target, also in Debug and Release. This will install Polycode into the Release/Darwin/Framework directory, which should mirror the binary download from the website and contain templates and examples that will build out of the box.
To generate a Microsoft Visual Studio project for building Polycode, perform the following steps in the Polycode directory from a command prompt:
mkdir Build
cd Build
cmake -G "Visual Studio 10" ..
Build the "ALL_BUILD" target in this project in both Debug and Release and then build the "install" target, also in Debug and Release. This will install Polycode into the Release/Windows/Framework directory, which should mirror the binary download from the website and contain templates and examples that will build out of the box.
To generate and build Debug and Release builds with Unix Makefiles perform the following steps in the Polycode directory from a terminal:
NOTE: You need to install SDL development libraries on your system before doing this as they are not automatically installed by the Dependencies project above. You can get SDL from http://www.libsdl.org or using the package manager of your distribution.
mkdir Build
cd Build
mkdir Debug
cd Debug
cmake -G "Unix Makefiles" -DCMAKE_BUILD_TYPE=Debug ../..
make
make install
cd ..
mkdir Release
cd Release
cmake -G "Unix Makefiles" -DCMAKE_BUILD_TYPE=Release ../..
make
make install
This will install Polycode into the Release/Linux/Framework directory, which should mirror the binary download from the website and contain templates and examples that will build out of the box.
Note: To build a complete distribution of the standalone Lua tools as it appears in the binary release, you will need to build it on all supported platforms and copy the module libraries and deployment templates from all three into the folder. If you do not have access to all the supported platforms, you will not be able to build a complete distribution!
To build Polycode Lua, you need to build the bindings and the player, which are disabled by default. To do this, you need to add a couple of variables to the cmake commands above. To build the bindings, you need a python installation with the PLY python module. You can get the PLY module at http://www.dabeaz.com/ply/
Note: You will need python 2 for this step. If you have python 3 installed, pass -DPYTHON_EXECUTABLE=/usr/bin/python2 or whatever the full path to the python2 executable is on your system.
To enable the bindings and the player, add the following options to the cmake command. Otherwise, the steps are exactly the same as the regular Polycode build for your system.
-DPOLYCODE_BUILD_BINDINGS=ON -DPOLYCODE_BUILD_PLAYER=ON
Note: You need to build the "PolycodeLua" target before you build the "install" target.
After building the install build or running 'make install', perform the following commands in the Polycode source root:
cd Standalone
mkdir Build
cd Build
cmake -G "Unix Makefiles" ..
make install
This will create a Release/YourArchitecture/Standalone folder with the same structure as the binary Polycode Lua release.
cd Standalone
mkdir Build
cd Build
cmake -G "Visual Studio 10" ..
This will create a Standalone.sln solution in the Build directory. Build the "install" target of this solution.
This will create a Release/Windows/Standalone folder with the same structure as the binary Polycode Lua release.
Since the standalone Lua distribution is supposed to compile packages for all platforms, you need to do this build step on all of the platforms and merge the Standalone/Modules and Standalone/Publish folders with the one you just built.
It would be good to create a CMake build template for people to create new Polycode applications with.