web-dev-qa-db-fra.com

Comment créer Unity à partir des sources?

J'aimerais savoir comment je construirais Unity à partir du code source dans la version de développement actuelle. Veuillez couvrir les sujets suivants:

  • Quels paquets sont nécessaires pour compiler Unity?
  • Où pourrais-je obtenir le code source actuel?
  • Quelles sont les étapes pour réellement configurer et compiler Unity?
  • Est-il possible d'exécuter en toute sécurité la dernière version aux côtés de la version des référentiels?
unityinstall-from-source
64
htorque

Construire l'unité à partir de la source

Dans ce guide, vous construirez une version séparée de la liaison Unity (installée localement dans votre répertoire personnel). Vous n'aurez ainsi plus à craindre de corrompre la version stockée dans les référentiels Ubuntu et vous n'aurez pas non plus besoin d'autorisations d'accès root. processus entier (sauf pour l'installation des dépendances de construction).

0. Installation des dépendances de construction

Vous devrez l'exécuter une fois pour installer toutes les dépendances de construction nécessaires:

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 vous avez activé les référentiels de code source (alias deb-src), vous pouvez utiliser à la place:

Sudo apt-get build-dep unity

1. Préparer l'environnement

Remplacez SOURCEet PREFIXpar les répertoires dans lesquels vous souhaitez que les fichiers source et les fichiers de construction se trouvent. Dans cet exemple, je mets les deux dans mon répertoire personnel:

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

Vous aurez probablement besoin de récupérer la dernière version de Nuxpour que le tronc Unity soit compilé:

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

Astuce : La plupart des ordinateurs de bureau et portables modernes ont plusieurs cœurs. Vous pouvez grandement accélérer la compilation en tirant parti de cela. La commande makedispose d'une prise en charge intégrée que vous pouvez activer à l'aide du commutateur - jN où N est le nombre des travaux à exécuter en parallèle. Une bonne règle consiste à exécuter 2 fois le nombre de cœurs de votre processeur. Ainsi, sur un ordinateur dual core normal, vous devez exécuter make -j4 pour réduire le temps de compilation.

3. Bâtir l'Unité

Maintenant, récupérez le dernier code Unity et construisez-le:

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

Ça y est, déconnectez-vous et reconnectez-vous à nouveau et vous devriez exécuter la dernière version de Unity. Alternativement , vous pouvez exécuter

setsid $PREFIX/bin/unity

4. Mise à jour

Assurez-vous de préparer l'environnement comme décrit à l'étape 1, puis entrez simplement les deux répertoires de niveau supérieur nuxet unityname__, exécutez bzr pull, reconstruisez et réinstallez.

Je suggère de supprimer et de recréer le répertoire builddans le répertoire unityname__, afin de vous assurer qu'aucun ancien fichier ne perturbe votre construction.

5. Supprimer l'Unité

Supprimez les trois répertoires $SOURCE, $PREFIX et ~/.compiz-1.

Lien utile:

65
Stefano Candori

J'ai créé un script basé sur le script de génération Wayland et ces instructions pour automatiser l'installation des conditions préalables, le clonage, la mise à jour, la configuration et la construction de Unity.

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

9
Cam

Construire dans votre répertoire personnel

Parfois, pour des raisons de test, il est utile de créer Unity et nux dans votre répertoire personnel afin que vous puissiez voir si quelque chose est corrigé dans le tronc sans perdre son temps avec les packages et/ou les PPA. J'ai demandé à Jason Smith (Unity Dev) comment il construisait Unity et il m'a expliqué sa méthode:

  1. Assurez-vous que vous avez tous les dépendances de construction de cette réponse.

  2. Créez d’abord dans votre maison un répertoire appelé "staging", c’est là que nous allons construire Unity. Créez un petit script qui préparera l'environnement de construction, remplacez le répertoire de base par votre propre:

    #!/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/"

    J'appelle cela unity.sh et je l'exécute chaque fois que je veux construire Unity. Donc, fondamentalement, chmod +x unity.sh et ensuite ./unity.sh lorsque vous voulez construire.

  3. Construire Nux:

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

  4. Construire l'unité:

    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

NOTE: Ceci construit nux et l'unité dans votre répertoire personnel, il n'y a pas besoin de Sudo ici ou de quelque chose comme ça.

  • La déconnexion et le retour exécuteront automatiquement cette version de Unity/nux depuis sa construction dans ~/.compiz
  • Pour revenir aux packages normaux, déconnectez-vous simplement, supprimez ~/.compiz et reconnectez-vous.
7
Jorge Castro

Le code source de l'environnement par défaut (Unity) est disponible dans le package unityname__. Installez le source avec apt-get source unity, les dépendances pour le construire avec Sudo apt-get build-dep unity et piratez-le.

Cela vous permettra de positionner le lanceur à droite, en bas, en haut, etc.

6
ish

Il existe une excellente documentation officielle ici - Developing Unity .

Voici un extrait de la construction de Unity - installation à partir de la source et compilation

Construire l'unité

Ces instructions vous aideront à créer l’unité à partir de la source. Cependant, il y a quelques points à considérer:

  • Il est recommandé de ne jamais copier quoi que ce soit que vous avez construit localement en dehors de votre répertoire personnel. Cela pose des problèmes, en particulier parce que nous construisons l’ensemble du bureau Shell. Si vous parvenez à ruiner votre ordinateur de bureau sur l’ensemble du système, vous deviendrez un programmeur très triste!
  • Il est supposé que vous utilisez la version précise d’Ubuntu.
  • Il est également supposé que vous souhaitez construire l'unité à partir du tronc (c'est-à-dire, lp: unité).

Obtenir le code source:

Si Bazaar n’est pas déjà installé, installez-le maintenant:

Sudo apt-get install bzr

Vous voudrez vous faire un dossier pour le code d'unité. Faites quelque chose comme ça:

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

Prenons le code dans le tableau de bord:

bzr branch lp:unity trunk

Cela peut prendre un peu de temps.
Installation des dépendances de construction:

Nous devons obtenir les dépendances de construction pour l'unité. Heureusement, apt-get rend ceci trivial:

Sudo apt-get build-dep unity

Unité de compilation:

Utilisez cet ensemble de fonctions bash pour faciliter considérablement cette étape. Pour les utiliser, copiez le code bash suivant dans un fichier de votre répertoire personnel appelé .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
}

Maintenant, lancez ceci dans un terminal:

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

Cela garantit que, lors de la prochaine ouverture d'un shell bash, les fonctions énumérées ci-dessus seront disponibles. Pour ne pas avoir à fermer et à rouvrir un terminal, nous pouvons les lire manuellement une seule fois:

. ~/.bash_functions

Vous devriez maintenant pouvoir exécuter:

remake-unity

depuis le répertoire trunk/ que nous avons créé précédemment. C’est ça, vous construisez l’unité!

4
Nitin Venkatesh

L’installation est devenue plus compliquée récemment: un nouveau module a été ajouté à Compiz nommé GTK Load (ou il va planter dans XInternAtom). Nous devons activer ce module pour utiliser 4.0.1, mais son activation planterait 3.8.

Il devient difficile de garder les deux. La façon dont je l'ai fait était de:

  • allez dans le dossier compiz-1 et renommez tous les fichiers .so par .so1, à l'exception de libgtkloader.so
  • redémarrez Compiz avec Unity 4.0.1
  • activer le module de chargement gtk dans compizconfig-settings-manager
  • renommez les bibliothèques en .so
  • redémarrez Compiz.
2
Yann