¿Cómo construyo Unity desde la fuente?

Me gustaría saber cómo construiría Unity a partir del código fuente en la versión de desarrollo actual. Por favor, cubra los siguientes temas:

• ¿Qué paquetes son necesarios para compilar Unity?
• ¿Dónde obtendría el código fuente actual?
• ¿Cuáles son los pasos para configurar y compilar Unity?
• ¿Es posible ejecutar de forma segura la última versión junto con la versión de los repositorios?

Construyendo Unidad desde la Fuente

En esta guía, creará una versión separada del tronco de Unity (instalada localmente en su directorio de inicio), por lo que no necesita preocuparse por corromper la versión de los repositorios de Ubuntu y tampoco necesitará obtener permisos de root en todo el proceso completo (excepto para instalar las dependencias de compilación).

0. Instalar dependencias de compilación

Deberá ejecutar esto una vez para instalar todas las dependencias de compilación necesarias:

sudo apt-get install bzr cmake compiz-dev gnome-common libbamf3-dev libboost-dev \
libboost-serialization-dev libgconf2-dev libgdu-dev libglewmx1.6-dev \
libgnome-desktop-3-dev libibus-1.0-dev libindicator3-dev libjson-glib-dev \
libnotify-dev libnux-2.0-dev libpci-dev libsigc++-2.0-dev libunity-dev \
libunity-misc-dev libutouch-geis-dev libxxf86vm-dev libzeitgeist-dev xsltproc

Si tiene deb-srchabilitados los repositorios de código fuente (aka ), puede usar:

sudo apt-get build-dep unity

1. Preparando el medio ambiente

Reemplace SOURCEy PREFIXcon los directorios a los que le gustaría ir los archivos de origen y compilación. En este ejemplo, pongo ambos en mi directorio de inicio:

export SOURCE=$HOME/source/unity
export PREFIX=$HOME/build/unity

export PKG_CONFIG_PATH="$PREFIX/lib/pkgconfig:$PKG_CONFIG_PATH"
export LD_LIBRARY_PATH="$PREFIX/lib:$LD_LIBRARY_PATH"
export LD_RUN_PATH="$PREFIX/lib:$LD_RUN_PATH"
export XDG_DATA_DIRS="$PREFIX/share:$XDG_DATA_DIRS"

mkdir -p "$PREFIX"
mkdir -p "$SOURCE"
cd "$SOURCE"

2. Construyendo Nux

Probablemente necesitará obtener la última versión de Nuxpara que Unity trunk compile:

bzr branch lp:nux
cd nux
./autogen.sh --disable-examples --disable-gputests --disable-tests --prefix="$PREFIX"
make -j4
make install
cd ..

Consejo : la mayoría de las computadoras de escritorio y portátiles modernos tienen varios núcleos. Puede acelerar enormemente la compilación aprovechando esto. El makecomando tiene soporte incorporado para esto que puede activar utilizando el modificador -jN donde N es el número de trabajos que se ejecutarán en paralelo. Una buena regla general es ejecutar 2 veces la cantidad de núcleos en su procesador. Por lo tanto, en una computadora de doble núcleo normal, debe ejecutar make -j4para minimizar el tiempo de compilación.

3. Construyendo unidad

Ahora tome el último código de Unity y compílelo:

bzr branch lp:unity
cd unity
mkdir build
cd build
cmake .. -DCMAKE_BUILD_TYPE=Debug -DCOMPIZ_PLUGIN_INSTALL_TYPE=local -DGSETTINGS_LOCALINSTALL=ON -DCMAKE_INSTALL_PREFIX="$PREFIX"
make -j4
make install

Eso es todo, cierre la sesión y vuelva a iniciarla y debería estar ejecutando la última Unidad. Alternativamente , puedes correr

setsid $PREFIX/bin/unity

4. Actualización

Asegúrese de preparar el entorno como se describe en el paso 1, luego simplemente ingrese los directorios de nivel superior nuxy unity, ejecute bzr pull, reconstruya y reinstale.

Sugiero eliminar y volver a crear el builddirectorio en el unitydirectorio, para asegurarse de que no haya archivos antiguos que interfieran con su construcción.

5. Eliminar la unidad

Retire los tres directorios $SOURCE, $PREFIXy ~/.compiz-1.

Enlace útil:

• http://unity.ubuntu.com/getinvolved/development/unity/

He creado un script basado en el script de compilación de Wayland y estas instrucciones para automatizar los requisitos previos de instalación, clonación, actualización, configuración y creación de Unity.

https://github.com/bitshifter/Unity-Build/raw/master/build-unity.sh

Construyendo en su directorio de inicio

A veces, por razones de prueba, es útil construir Unity y Nux en su directorio de inicio para que pueda intentar ver si algo está arreglado en el tronco sin tener que buscar entre paquetes y / o PPA. Le pregunté a Jason Smith (Unity Dev) cómo construye Unity y él me explicó su método:

1. Asegúrese de tener todas las dependencias de compilación de esta respuesta.

2. Primero haga un directorio en su hogar llamado "puesta en escena", aquí es donde construiremos Unity. Cree un pequeño script que preparará el entorno de compilación, reemplace el directorio de inicio con el suyo propio:

   #!/bin/bash
   
   PREFIX=/home/jorge/staging
   
   export XDG_DATA_DIRS="$PREFIX/share:$XDG_DATA_DIRS"
   export LD_LIBRARY_PATH="$PREFIX/lib/"
   export PKG_CONFIG_PATH="$PREFIX/lib/pkgconfig/"
   

   Llamo a esto unity.shy lo ejecuto cada vez que quiero construir Unity. Básicamente, chmod +x unity.shy luego ./unity.shcuando quieres construir.

3. Construir nux:

   bzr branch lp:nux
   cd nux
   ./autogen.sh --prefix=/home/jorge/staging
   make -j4
   make install
   cd ..
   

4. Construir unidad:

   bzr branch lp:unity
   cd unity
   mkdir build
   cd build
   cmake .. -DCMAKE_INSTALL_PREFIX=/home/jorge/staging/ -DCMAKE_BUILD_TYPE=Debug -DCOMPIZ_PLUGIN_INSTALL_TYPE=local -DGSETTINGS_LOCALINSTALL=ON
   make -j4
   make install
   

NOTA: Esto crea nux y unidad en su directorio de inicio, no hay necesidad de sudo aquí ni nada de eso.

• Cerrar sesión y volver a iniciarla ejecutará esta versión de Unity / nux automáticamente desde que fue incorporada ~/.compiz
• Para volver a los paquetes normales, simplemente cierre sesión, elimine ~/.compizy vuelva a iniciar sesión.

El código fuente para el entorno predeterminado (Unity) se puede encontrar en el paquete unity. Instale la fuente con apt-get source unitylas dependencias para construirla sudo apt-get build-dep unityy hackearla.

Esto le permitirá colocar el lanzador a la derecha, abajo, arriba, etc.

Aquí hay una excelente documentación oficial: Unity en desarrollo .

Aquí hay un extracto de él sobre la construcción de Unity: instalación desde la fuente y compilación

Construyendo Unidad

Estas instrucciones te ayudarán a construir la unidad desde la fuente. Sin embargo, hay algunas cosas a considerar:

• Se recomienda que nunca copie nada que haya creado localmente fuera de su directorio de inicio. Hacerlo es pedir problemas, especialmente porque estamos construyendo todo el shell del escritorio. ¡Si logras arruinar la consola de tu escritorio en todo el sistema, serás un programador muy triste!
• Se supone que está ejecutando la versión precisa de Ubuntu.
• También se supone que desea construir la unidad desde el tronco (es decir, lp: unidad).

Obteniendo el código fuente:

Si aún no tiene instalado Bazaar, instálelo ahora:

sudo apt-get install bzr

Deberá crear una carpeta para el código de la unidad. Haz algo como esto:

mkdir -p ~/code/unity
cd ~/code/unity

Tomemos el código del launchpad:

bzr branch lp:unity trunk

Esto puede tardar un rato.
Instalación de dependencias de compilación:

Necesitamos obtener las dependencias de construcción para la unidad. Afortunadamente, apt-get hace que esto sea trivial:

sudo apt-get build-dep unity

Unidad de compilación:

Use este conjunto de funciones bash para hacer este paso significativamente más fácil. Para usarlos, copie el siguiente código bash en un archivo en su directorio de inicio llamado .bash_functions:

function recreate-build-dir()
{
   rm -r build
   mkdir build
   cd build
}

function remake-autogen-project()
{
    ./autogen.sh --prefix=$HOME/staging --enable-debug
    make clean && make && make install
}

function remake-unity()
{
    recreate-build-dir
    cmake .. -DCMAKE_BUILD_TYPE=Debug -DCOMPIZ_PLUGIN_INSTALL_TYPE=local -DCMAKE_INSTALL_PREFIX=$HOME/staging/ -DGSETTINGS_LOCALINSTALL=ON
    make  && make install
}

function unity-env
{
 export PATH=~/staging/bin:$PATH
 export XDG_DATA_DIRS=~/.config/compiz-1/gsettings/schemas:~/staging/share:/usr/share:/usr/local/share
 export LD_LIBRARY_PATH=~/staging/lib:${LD_LIBRARY_PATH}
 export LD_RUN_PATH=~/staging/lib:${LD_RUN_PATH}
 export PKG_CONFIG_PATH=~/staging/lib/pkgconfig:${PKG_CONFIG_PATH}
 export PYTHONPATH=~/staging/lib/python2.7/site-packages:$PYTHONPATH
}

Ahora ejecute esto en una terminal:

echo ". ~/.bash_functions" >> ~/.bashrc

Esto garantiza que la próxima vez que abra un bash shell, las funciones enumeradas anteriormente estarán disponibles para usted. Para evitar tener que cerrar y volver a abrir una terminal, podemos leerlos manualmente solo esta vez:

. ~/.bash_functions

Ahora debería poder ejecutar:

remake-unity

del trunk/directorio que creamos anteriormente. Eso es todo, ¡estás construyendo la unidad!

La instalación se volvió más complicada recientemente: se ha agregado un nuevo módulo a compiz llamado GTK Load (o se bloqueará en XInternAtom). Necesitamos activar este módulo para usar 4.0.1, pero al activarlo se bloqueará la unidad 3.8.

Se está haciendo difícil mantenerlos a ambos. La forma en que lo hice fue:

• vaya a la carpeta compiz-1 y cambie el nombre de todos .so por .so1, excepto libgtkloader.so
• reiniciar compiz con unity 4.0.1
• active el módulo de carga gtk en compizconfig-settings-manager
• cambiar el nombre de las bibliotecas a .so
• reiniciar compiz.