Build Instructions/fr

From OpenSimulator

(Difference between revisions)
Jump to: navigation, search
(Debian)
(Compiler avec msbuild)
 
(18 intermediate revisions by one user not shown)
Line 1: Line 1:
{{Quicklinks}}
+
 
 +
{{Languages|Build_Instructions}}
  
 
__TOC__
 
__TOC__
Line 8: Line 9:
 
= Compiler =
 
= Compiler =
 
Autant cette page est longue, autant la compilation d'OpenSimulator est rapide. Reportez-vous au fichier BUILDING.txt inclus dans la distribution elle-même pour trouver des instructions simplifiées.
 
Autant cette page est longue, autant la compilation d'OpenSimulator est rapide. Reportez-vous au fichier BUILDING.txt inclus dans la distribution elle-même pour trouver des instructions simplifiées.
 +
 +
== Conditions ==
 +
OpenSimulator 0.9.0.x nécessite soit
 +
* [http://msdn.microsoft.com/en-us/netframework/cc378097 .NET Framework 4.0] sur Windows
 +
* [https://www.mono-project.com/download/stable/ Mono] sur Linux ou Mac.  Mono 2.10.8 est la version minimale.
 +
Vous pouvez également avoir besoin de l'outil nant.
 +
 +
OpenSimulator >= 0.9.1 (y compris le master actuel) nécessite
 +
* [http://msdn.microsoft.com/en-us/netframework/cc378097 .NET Framework 4.6] sur Windows
 +
* [https://www.mono-project.com/download/stable/ Mono] sur Linux ou Mac. Mono 5.12 est la version minimum recommandée. <br>
 +
'''Note:''' plutôt que d'utiliser les paquets Mono de votre distribution Linux, qui peuvent manquer de composants requis, veuillez installer à partir du  [https://www.mono-project.com/download/stable/ dépôt officiel de Mono pour votre distribution]. Il est recommandé de compiler avec msbuild.
 +
 +
D'autres plateformes peuvent avoir leurs propres distributions mono, ou peuvent avoir besoin de compiler mono.
 +
 +
D'autres bibliothèques utilisées par OpenSimulator peuvent être trouvées dans notre dépôt git opensim-libs :
 +
 +
git clone git://opensimulator.org/git/opensim-libs
 +
 +
La bibliothèque libOpenMetaVerse utilisée peut être trouvé sur https://bitbucket.org/opensimulator/
 +
 +
Vous devrez peut-être les compiler pour votre plate-forme, en particulier les bibliothèques non gérées comme les bibliothèques de code natif Bullet ou ODE.
 +
 
== Microsoft Windows ==
 
== Microsoft Windows ==
Les versions OpenSimulator 0,8 et postérieure nécessitent soit :
 
* [http://msdn.microsoft.com/en-us/netframework/cc378097 .NET Framework 4.0] pour Windows ou
 
* [http://www.go-mono.com/mono-downloads/download.html Mono] pour Linux ou Mac.  Mono 2.10.8 est la version minimum.
 
  
 
===Compilateurs supportés===
 
===Compilateurs supportés===
* Visual Studio 2010
+
* [https://visualstudio.microsoft.com/downloads/ Visual Studio Community 2017]
* Visual Studio 2008 peut être utilisé jusqu'à OpenSimulator 0.7.6 - le code développé actuellement requiert Visual Studio 2010 ou un compilateur qui peut compiler le code .NET 4.0.
+
* Ou toute autre version qui supporte la version .Net. Au moins VS2010 pour les versions antérieures à 0.91, VS2015 pour les versions 0.91 et ultérieures.
Toutes les éditions de Visual Studio devraient fonctionner parfaitement, y compris l'édition libre [http://www.microsoft.com/express/downloads/ Microsoft Visual C# Express].
+
* OpenSimulator >=0.9.2.0 peut compiler pour .Net Framework 4.8 en utilisant runprebuild48.bat au lieu de runprebuild.bat ci-dessous et avec VS2017/19/22
 
+
Notez que les versions Visual Studio 2005 et antérieures ne sont plus supportées ([http://www.mail-archive.com/opensim-dev@lists.berlios.de/msg02674.html opensim-dev proposal], [http://www.mail-archive.com/opensim-dev@lists.berlios.de/msg02673.html opensim-dev approved]).
+
  
 
===Compiler dans un IDE===
 
===Compiler dans un IDE===
# Lancez "runprebuild.bat" ou "runprebuild2010.bat" (si vous utilisez Visual Studio 2010 avec le code source de OpenSimulator 0.7.6 ou de versions antérieures).
+
# Lancez "runprebuild.bat".
# Ouvrez le fichier "OpenSim.sln" résultant dans un IDE Visual Studio.
+
# Ouvrez le fichier "OpenSim.sln" résultant dans L'IDE Visual Studio.
# Compilez (ou déboguez) -> Build Solution.
+
# Sélectionnez la configuration Debug ou Release
 
+
# Menu Build -> Build Solution.                                    
 +
 
 
===Compiler en ligne de commande===
 
===Compiler en ligne de commande===
 
# Lancez "runprebuild.bat".
 
# Lancez "runprebuild.bat".
# Lancez le fichier "compile.bat" résultant ou lancez "nant". L'exécutable OpenSim.exe va être construit avec MSBuild (l'ancien) ou nant (le dernier).
+
# Lancez le fichier "compile.bat" résultant.
  
===Notes complémentaires===
+
== Linux et autres plates-formes mono ==
* Vous pouvez lancer OpenSimulator sur Windows 64-bit (Vista, Windows 7 ...),  mais si vous voulez le déboguer dans Visual Studio, vous devrez ajouter OpenSim.32BitLaunch à la solution et le définir comme début de projet. Voir [http://blog.tedd.no/2008/12/05/opensim-in-visual-studio-on-win64/ OpenSimulator in Visual Studio on Win64@Tedds blog] pour plus de details.
+
  
*Pour ceux qui utilisent Cygwin shell, il faudra peut-être corriger les permissions des DLLs en tapant "<tt>chmod 755 *.dll *.exe</tt>" dans le répertoire <tt>bin</tt>.
+
=== Préparer la compilation ===
  
== Mac OS X ==
+
Pour créer les différents fichiers du projet, exécuter dans le dossier opensim :
=== Mac OS X 10.5 et postérieur, Intel ===
+
La seule chose que vous ayez à faire est de télécharger :  
+
* Mono SDK depuis [http://www.go-mono.com/mono-downloads/download.html Page de téléchargement de Mono]
+
* Le paquet MonoDevelop depuis [http://monodevelop.com/Download la page de téléchargement de MonoDevelop] 
+
** MonoDevelop est redirigé vers  Xamarin Studio pour les téléchargement de  Mc OS X (ndlr: je ne sais pas si j'ai bien traduit cette phrase)
+
et ensuite les installe. Il n'est pas nécessaire d'installer XCode et MacPort (bien que vous puissiez installer les bibliothèques mono dev  et nant avec MacPort).
+
  
Quand vous lancez nano pour compiler OpenSimulator, l'erreur suivante peut s'afficher : "Unable to locate 'mono' module using pkg-config. Download the Mono development packages" (Impossible de localiser le module 'mono' avec pkg-config. Téléchargez les paquets de développement de Mono). Le rédacteur de l'article anglais suspecte  XCode ou MacPort d'être à l'origine de cette erreur (depuis qu'il les a supprimés cela fonctionne mieux), mais il n'en est pas sur.  
+
  ./runprebuild.sh
  
De toute façon, pour gérer le problème, inserrez une ligne dans le fichier du script '''/usr/bin/nant'''  :
+
==== Compiler avec Nant ====
<pre>
+
#!/bin/sh
+
export PKG_CONFIG_PATH=/Library/Frameworks/Mono.framework/Libraries/pkgconfig    # ajoutez ceci!
+
exec /Library/Frameworks/Mono.framework/Versions/2.10.2/bin/mono \
+
    /Library/Frameworks/Mono.framework/Versions/2.10.2/share/NAnt/bin/NAnt.exe "$@"
+
</pre>
+
  
Vous pouvez compiler et déboguer OpenSimulator avec l'IDE MonoDevelop après avoir lancé "runprebuild.sh". Ouvrez le fichier de la solution (*.sln) avec l'IDE MonoDevelop et sélectionnez Build -> Build All à partir du menu.
+
Sur certaines versions de mono, en particulier les anciennes versions peuvent nécessiter d'utiliser l'utilisation de nant pour compiler correctement OpenSimulator, dans ce cas il suffit d'exécuter :
 +
 +
  nant
  
===Compilation en ligne de commande (Mono 3.x)===
+
==== Compiler avec xbuild ====
* Téléchargez Mono MDK depuis [http://www.mono-project.com/download/ la page de téléchargement de Mono].
+
  
Utilisez xbuild à la place de nant:
+
Sur les versions mono, vous pouvez simplement utiliser xbuild. (msbuild est recommandé pour la version 0.9.1.0.0+)
<pre>
+
./runprebuild.sh
+
xbuild
+
</pre>
+
  
===Mac OS X 10.4/10.5 sur PowerPC ===
+
  xbuild
OpenSimulator peut être lancé sur  PowerPC Macs (comme G4, G5). Les instructions qui suivent on été testées sur 10.5.8. Notez que les deux bibliothèques doivent aussi être compilées depuis la source.
+
  
Avertissement: l'application d'OpenSimulator n'a été que brièvement testée en mode autonome. Des problèmes peuvent survenir pour cette version. N' hésitez pas à noter toutes les questions que vous vous posez ici (ou dans une nouvelle page wiki? discussion?).
+
xbuild n'est plus recommandé sur mono 5.x, mais fonctionne toujours actuellement (5.12)
  
Malheureusement, la version d'OpenSimulator utilisée ici doit être compilée avec une version de Mono (2.6.7) et lancée avec une autre version (2.8.2). Cela signifie qu'il faut mettre à niveau Mono après l'avoir compilé, ou avoir deux versions installées en pouvant accéder à l'ancienne version pour la compilation. Les instructions qui suivent proposent d'avoir les deux versions installées.
+
>>>> L'outil xbuild est obsolète et sera supprimé dans les prochaines mises à jour, utilisez plutôt msbuild <<<<
  
* Installez Xcode 3.1.4 Developer Tools depuis http://developer.apple.com/. Vous devez avoir un compte développeur Apple libre pour accéder au téléchargement. 3.1.4 est le dernier PowerPC Xcode.
+
Sur les versions mono plus récentes, la configuration de la version peut donner un certain gain de performance, mais vous perdez certaines capacités de débogage.  
 +
<br>Compiler avec la configuration Release :
  
* (10.4 only) Installez X11 depuis  les installations Optionelles (ou voir si c'est une option personnalisée quand vous installez Xcode). 10.5 installe X11 par défaut (''depuis OS X ou dev tools?'').
+
    xbuild /p:Configuration=Release
* Installez Mono 2.6.7 PowerPC Framework depuis : http://www.go-mono.com/mono-downloads/download.html (OS X Framework binaire, ce n'est pas nécessaire de le compiler).
+
* Ensuite, installez Mono 2.8.2 PowerPC framework. Pour que cela fonctionne vous devez installer 2.6.7, PUIS 2.8.2. (l'ancien framework n'est pas supprimé, mais les liens symboliques "Courants" sont mis à jour).
+
* Téléchargez l'archive du code source OpenSimulator 0.7.0.2 : http://dist.opensimulator.org/opensim-0.7.0.2-source.tar.gz.
+
** Vous pouvez utiliser une version plus récente d'OpenSimulator (le référentiel est sur git maintenant).
+
** Si vous utilisez une nouvelle version d'OpenSimulator, vérifiez dans BUILDING.txt qu'il n'y a pas eu de changement dans les instructions de compilation (voir sous "Linux").
+
* Editez ou créez  .profile ou .bash_profile dans votre dossier home OS X, avec les lignes suivantes :
+
# rapel de real PATH
+
export OSIM_HACK_ORIG_PATH=$PATH
+
+
# chemin normal pour lancer OpenSimulator
+
export PATH=$PATH:/Library/Frameworks/Mono.framework/Versions/Current/bin:/usr/local/mysql/bin
+
+
# Seulement pour nant:
+
export PKG_CONFIG_PATH=/Library/Frameworks/Mono.framework/Versions/2.6.7/lib/pkgconfig
+
alias oldpath="export PATH=$OSIM_HACK_ORIG_PATH:/Library/Frameworks/Mono.framework/Versions/2.6.7/bin"
+
+
* Ouvrez un nouveau terminal, et cd vers votre dossier décompressé d'OpenSimulator source (raccourci: tapez "cd " ensuite glissez le dossier dans le terminal). Ensuite entrez ces commandes:
+
oldpath
+
./runprebuild.sh
+
nant
+
*nant doit mettre environ 10 minutes pour compiler votre OpenSimulator. Si vous y parvenez sans erreur, vous aurez fait la moitié du travail ! (L'auteur avait 234 warnings).
+
*Important : Avant d'oublier, ouvrez un nouveau terminal (nécessaire pour éviter les effets de "oldpath").
+
*Maintenant, nous avons besoin des versions PowerPC de deux bibliothèques. Compilez chacune d'elle et remplacez les fichiers compilés .dylib  dans le dossier opensim/bin.
+
** libode.dylib http://cdnetworks-us-1.dl.sourceforge.net/project/opende/ODE/0.11.1/ode-0.11.1.zip
+
** libopenjpeg-dotnet-2.1.3.0-dotnet-1.dylib (vérifier avec svn :)
+
svn co http://libopenmetaverse.googlecode.com/svn/libopenmetaverse/trunk/openjpeg-dotnet libopenmetaverse-read-only
+
cd libopenmetaverse-read-only
+
** Pour compiler, supprimez le fichier  Makefile, qui concerne Linux, et renommez Makefile.osx simplement Makefile, ensuite lancez la commande : make )
+
** Supprimez les autres versions des deux bibliothèques (mêmes noms et extensions différentes, par exemple "libode-x86_64.so". Deux libode et trois libopenjpeg).
+
* Configurez votre sim: copiez OpenSim.ini.example vers OpenSim.ini et personnalisez-le.
+
* De la même façon copiez et personnalisez StandaloneCommon.ini dans bin/config-include.
+
* Notez que les commentaires disent que le plugin SQLite courant ne fonctionne pas pour OS X. Aussi vous pouvez corriger cela, ou installez MySQL, qui ne demande pas de compilation et qui est relativement simple à configurer :
+
** Depuis http://downloads.mysql.com/archives.php?p=mysql-5.1&v=5.1.40, télécharger MySQL 5.1.40 pour 10.5 PowerPC (installateur, pas 64-bit)
+
** Lancer  l'installateur. (Qui installe vers /usr/local)
+
** Installez MySQL.prefPane dans System Preferences en double cliquant dessus.
+
** Ouvrez le panneau des préférences et lancez le serveur  MySQL.
+
** (Optionel: ) Pour un démarrage sans surveillance, installez MySQLStartupItem ( pour l'auteur ça ne fonctionne pas toujours).
+
** (Recommandé : ) Dans un terminal, utiliser l'installation en une fois de MySQL avec cette commande : mysql_secure_installation
+
** Dans MySQL, créez l'utilisateur  opensim . Donnez-lui tous les privilèges de création.
+
*** Puisque nous sommes sous Mac, vous pouvez utiliser Sequel Pro (donationware) pour faire cela dans une jolie interface graphique. Pour une connexion standard, host: 127.0.0.1 (si vous êtes sur le même Mac).
+
* Vous êtes prêt pour lancer  OpenSimulator. Dans un nouveau terminal, cd vers votre dossier OpenSim-source/bin.
+
mono OpenSim.exe
+
* Si tout se passe bien, vous serez invité à entrer le nom de votre région :"New region name []: "
+
* Reportez-vous à "lancer OpenSimulator pour la première fois" sur la page [[Configuration/fr]] du wiki.
+
* Lorsque votre simulateur sera opérationnel vous aurez l'invite "Region (<nom-de-la-region>) #"
+
  
== Linux ==
+
==== Compiler avec msbuild ====
===Ubuntu===
+
Pour les utilisateur des anciennes distributions d'Ubuntu (7.10, 8.04, 9.10 etc.) '''vous aurez besoin''' de mettre à niveau votre version de mono à au moins 2.4.3 pour OpenSimulator 0.7.6 et 2.10.8 les versions plus récentes d'OpenSimulator. Nous vous recommandons d'installer au moins  Mono 2.10.8 dans tous les cas pour des raisons de performance. Pour ceux qui veulent mettre à niveau leur  Mono, voir [[Update Mono on Ubuntu]].
+
  
Ubuntu Karmic (9.10) comprend les paquets mono 2.4.2.3.
+
Pour Opensim 0.9.1 vous pouver encore utiliser xbuild mais Mono recommande l'utilisation de msbuild. Pour cela, vous devrez peut-être installer le paquet msbuild en plus de mono-complete. (Actuellement, msbuild est inclus si vous installez mono-complete, sur Ubuntu, à partir des dépôts mono officiels. https://www.mono-project.com/download/stable/#download-lin ).
  
Ubuntu Lucid (10.04) comprend les paquets mono 2.4.4.
+
Utilisez xbuild sur les autres cas en dernier recours.
  
Ubuntu Maverick (10.10)comprend les paquets mono 2.6.7.
+
Des améliorations récentes, en particulier sur le runtime JIT, justifient la compilation en configuration Release, mais vous perdez certaines capacités de débogage.  
  
Ubuntu Natty (11.04) comprend les paquets mono 2.6.7.
+
Compiler avec la configuration de débogage :
  
Ubuntu Oneirc (11.10) à Salamander (13.10) comprennent les paquets mono 2.10.8.1.
+
  msbuild
  
Ubuntu Trusty (14.04) à Ubuntu Vivid (15.04) comprennent les paquets mono 3.2.8.
+
Compiler avec la configuration Release :
====Ubuntu 10.04 et plus récents====
+
Dans ces versions, il suffit d'installer mono-complète - toutes les dépêndances nécessaires seront installées. Ainsi, pour compiler tapez les commandes suivantes dans un terminal :
+
  
sudo apt-get install mono-complete
+
  msbuild /p:Configuration=Release
# [[Download/fr|télécharger]] opensim
+
cd opensim
+
./runprebuild.sh
+
xbuild
+
À partir des versions mono 2.6, xbuild a fonctionné relativement bien pour réaliser une compilation complète d'OpenSimulator. Depuis, xbuild est inclus dans le package Ubuntu '''mono-complete''', vous n'avez pas besoin d'installer de paquets supplémentaire si vous n'avez pas de raison particulière d'utiliser nant à la place de xbuild. Il y a simplement deux systèmes de compilation différents qui invoque le même compilateur C# sur la base de deux formats de scripts de build différents.
+
  
Si vous voulez compiler OpenSimulator avec nant, alors vous devez installer le paquet apt-get '''nant''' et l'exécuter :
+
Compiler avec la configuration debug et afin que le fichier détaillé OpenSim.log puisse être lu avec un éditeur de texte :
 +
 
 +
  msbuild /p:Configuration=Debug /fileLogger /flp:logfile=opensim.log /v:d
  
sudo apt-get install nant
+
Vous pouvez spécifier les valeurs suivantes pour définir le niveau de détail du fichier OpenSim.log :
nant
+
   
 +
  q [quiet], m [minimal], n [normal], d [detailed] and diag [diagnostic].
  
à la place de
+
Pour compiler pour .Net Framework 4.8 avec mono >=6.12. vous pouvez exécuter runprebuild48.sh au lieu de runprebuild.sh ci-dessus. Toutefois, il n'y a pas beaucoup d'intérêt à faire cela, si ce n'est aucun.
  
xbuild
+
== Compilation anticipée (Ahead of Time compilation) (AOT) ==
  
ensuite ./runprebuild.sh
+
Comme vous le savez tous, les fichiers *.exe et .dll créés par le processus de compilation ci-dessus ne contiennent pas de code natif pour la machine.<br>
 +
Avec ces fichiers, le code natif requis par l'ordinateur est créé au moment de l'exécution, selon les besoins, dans un processus appelé Just in Time (JIT)(compilation à la volée). <br>
 +
Il est possible de faire une autre niveau de compilation sur ces fichiers pour créer un code natif, qui sera prêt au démarrage du programme. C'est le processus AOT (Ahead of time process).<br>
 +
Comme le JIT se fait à l'exécution, il dispose d'un temps limité pour effectuer des optimisations de code étendues, AOT, en revanche, peut tout faire.<br>
 +
AOT devrait ainsi être plus rapide à charger, économiser la mémoire nécessaire au travail du JIT et réduire la latence due à la génération de code lorsqu'une nouvelle section de code est nécessaire.<br>
 +
De cette façon, AOT contribue à réduire l'énorme écart de performance entre le C# et un langage plus approprié comme le C++, même si le JIT peut effectuer une certaine optimisation en fonction de l'état d'exécution du code, ce que AOT ne peut pas faire. (si vous pensez que c# est aussi rapide qu'un code C++ efficace, mieux vaut fumez autre chose...)<br>
 +
En fait, aussi bien .net que mono utilisent AOT sur leurs composants lors de l'installation<br>
 +
Le JIT sera toujours actif et compilera un autre code au moment de l'exécution. OpenSim et les parties utilisées du framework .net/mono en dépendent.
  
====Optionnel(pour les développeurs)====
+
Pour Linux, la version 0.9.2.0 inclut désormais les scripts makeaot.sh et cleanaot.sh pour aider à tester AOT.<br>
Pour exécuter la suite de tests de régression, vous devez aussi installer nunit-console, comme ceci :
+
Lancez makeaot.sh après l'étape de compilation ci-dessus, pour générer les fichiers de code natif. L'option -O=all doit être ajoutée à mono lors de l'exécution de opensim.exe, ex:<br>
 +
 
 +
  mono --desktop -O=all OpenSim.exe
  
sudo apt-get install nunit-console
+
Le script cleanaot.sh supprime les fichiers binaires utilisés par AOT. Vous devez l'exécuter si vous recompilez le code (pour être protégé même si vous exécutez makeaot).<br>
nant test
+
<b>N'OUBLIEZ PAS de lancer makeaot.sh ou cleanaot.sh après la recompilation!</b><br>
 +
Les fichiers générés sont spécifiques à cette machine. <b>Ne pas copier les fichiers de code natif sur une autre machine, sauf si elle est absolument identique</b><br>
 +
Les .exe et .dll originaux sont toujours nécessaires<br>
  
{{anchor|CentOS}}{{anchor|RedHat}}{{anchor|RHEL}}{{anchor|Fedora}}
+
AOT est également possible dans Windows, mais en utilisant différents outils, et ceux-ci ajoutent des choses au dépôt central sur la machine, plus difficile à isoler et à maintenir. voir [https://docs.microsoft.com/en-us/dotnet/framework/tools/ngen-exe-native-image-generator ngen]<br>
  
===Debian===
+
Les Macs sont.. Les Macs.. Les futurs modèles pourraient totalement interdire le JIT, comme le font les produits mobiles d'Apple. Le Mono AOT sur les Macs actuels pourrait fonctionner comme sur Linux<br>
Debian 4 (Etch) n'est plus supporté par debian.org. Mettez votre système à jour au moins à la version 5 (Lenny) avant de lancer OpenSimulator. Pour plus d'informations , voir  [http://www.debian.org/releases/lenny/i386/release-notes/ch-upgrading.html Upgrades from previous release@debian.org] ou pour une mise à niveau depuis Debian 6 ver Debian 7 la documentation en français [http://www.debian.org/releases/stable/i386/release-notes/index.fr.html Mises à niveau depuis Debian 6.0]
+
  
Pour Debian 5 (Lenny) ou pour une version plus récente, tapez simplement :
+
En pratique, ne vous attendez pas à un chargement plus rapide.
<pre>
+
De plus, comme la compilation est différente, elle peut ajouter de nouveaux problèmes. Donc, testez avec soin.<br>
sudo aptitude install nant
+
Les problèmes de performance d'Opensim concernent principalement son propre code, les terribles mauvais protocoles de communication, l'utilisation d'un mauvais code .net/mono framework (qualité de la démo dans les mêmes cas), etc.<br>
</pre>
+
Et bien sûr, GC éternellement cassé. <br>
Avant de lancer  runprebuild.sh et nant. Vous pouvez utiliser  apt-get à la place d'aptitude. Les deux vont installer les dépendances.
+
''But... well every ns counts..''<br>
  
Testé sur Debian 5 "Lenny" ''oldstable'', Debian 6 "Squeeze" ''stable'' et Debian 7 "Wheezy" ''testing''.
+
= Configuration =
  
===Fedora===
+
Voir [[Configuration/fr|Configuration]].
===CentOS, Redhat ===
+
===openSUSE===
+
===FreeBSD ===
+
  
= Configuration =
+
[[Category:French Translations]]

Latest revision as of 03:13, 5 March 2022


Contents


Cette page couvre la compilation d'OpenSimulator à partir du code source pour plusieurs plateformes. S'il vous plaît, aidez-nous à garder cette page à jour pour au fur et à mesure que le projet progresse. Si vous voulez simplement lancer une instance d'OpenSimulator, téléchargez et lancez la version binaire à la place. Dans la plupart des cas, cette version fonctionne très bien.

[edit] Obtenir le code source

Allez à la page de téléchargement pour trouver des instructions et la dernière version du code source. Si vous voulez le code de développement courant,( comme par exemple la branche maître Git) allez à la page Developer_Documentation#Source_Code_Repository_Access.

[edit] Compiler

Autant cette page est longue, autant la compilation d'OpenSimulator est rapide. Reportez-vous au fichier BUILDING.txt inclus dans la distribution elle-même pour trouver des instructions simplifiées.

[edit] Conditions

OpenSimulator 0.9.0.x nécessite soit

Vous pouvez également avoir besoin de l'outil nant.

OpenSimulator >= 0.9.1 (y compris le master actuel) nécessite

Note: plutôt que d'utiliser les paquets Mono de votre distribution Linux, qui peuvent manquer de composants requis, veuillez installer à partir du dépôt officiel de Mono pour votre distribution. Il est recommandé de compiler avec msbuild.

D'autres plateformes peuvent avoir leurs propres distributions mono, ou peuvent avoir besoin de compiler mono.

D'autres bibliothèques utilisées par OpenSimulator peuvent être trouvées dans notre dépôt git opensim-libs :

git clone git://opensimulator.org/git/opensim-libs

La bibliothèque libOpenMetaVerse utilisée peut être trouvé sur https://bitbucket.org/opensimulator/

Vous devrez peut-être les compiler pour votre plate-forme, en particulier les bibliothèques non gérées comme les bibliothèques de code natif Bullet ou ODE.

[edit] Microsoft Windows

[edit] Compilateurs supportés

  • Visual Studio Community 2017
  • Ou toute autre version qui supporte la version .Net. Au moins VS2010 pour les versions antérieures à 0.91, VS2015 pour les versions 0.91 et ultérieures.
  • OpenSimulator >=0.9.2.0 peut compiler pour .Net Framework 4.8 en utilisant runprebuild48.bat au lieu de runprebuild.bat ci-dessous et avec VS2017/19/22

[edit] Compiler dans un IDE

  1. Lancez "runprebuild.bat".
  2. Ouvrez le fichier "OpenSim.sln" résultant dans L'IDE Visual Studio.
  3. Sélectionnez la configuration Debug ou Release
  4. Menu Build -> Build Solution.

[edit] Compiler en ligne de commande

  1. Lancez "runprebuild.bat".
  2. Lancez le fichier "compile.bat" résultant.

[edit] Linux et autres plates-formes mono

[edit] Préparer la compilation

Pour créer les différents fichiers du projet, exécuter dans le dossier opensim :

 ./runprebuild.sh

[edit] Compiler avec Nant

Sur certaines versions de mono, en particulier les anciennes versions peuvent nécessiter d'utiliser l'utilisation de nant pour compiler correctement OpenSimulator, dans ce cas il suffit d'exécuter :

nant

[edit] Compiler avec xbuild

Sur les versions mono, vous pouvez simplement utiliser xbuild. (msbuild est recommandé pour la version 0.9.1.0.0+)

 xbuild

xbuild n'est plus recommandé sur mono 5.x, mais fonctionne toujours actuellement (5.12)

>>>> L'outil xbuild est obsolète et sera supprimé dans les prochaines mises à jour, utilisez plutôt msbuild <<<<

Sur les versions mono plus récentes, la configuration de la version peut donner un certain gain de performance, mais vous perdez certaines capacités de débogage.
Compiler avec la configuration Release :

   xbuild /p:Configuration=Release

[edit] Compiler avec msbuild

Pour Opensim 0.9.1 vous pouver encore utiliser xbuild mais Mono recommande l'utilisation de msbuild. Pour cela, vous devrez peut-être installer le paquet msbuild en plus de mono-complete. (Actuellement, msbuild est inclus si vous installez mono-complete, sur Ubuntu, à partir des dépôts mono officiels. https://www.mono-project.com/download/stable/#download-lin ).

Utilisez xbuild sur les autres cas en dernier recours.

Des améliorations récentes, en particulier sur le runtime JIT, justifient la compilation en configuration Release, mais vous perdez certaines capacités de débogage.

Compiler avec la configuration de débogage :

  msbuild

Compiler avec la configuration Release :

  msbuild /p:Configuration=Release

Compiler avec la configuration debug et afin que le fichier détaillé OpenSim.log puisse être lu avec un éditeur de texte :

  msbuild /p:Configuration=Debug /fileLogger /flp:logfile=opensim.log /v:d

Vous pouvez spécifier les valeurs suivantes pour définir le niveau de détail du fichier OpenSim.log :

  q [quiet], m [minimal], n [normal], d [detailed] and diag [diagnostic].

Pour compiler pour .Net Framework 4.8 avec mono >=6.12. vous pouvez exécuter runprebuild48.sh au lieu de runprebuild.sh ci-dessus. Toutefois, il n'y a pas beaucoup d'intérêt à faire cela, si ce n'est aucun.

[edit] Compilation anticipée (Ahead of Time compilation) (AOT)

Comme vous le savez tous, les fichiers *.exe et .dll créés par le processus de compilation ci-dessus ne contiennent pas de code natif pour la machine.
Avec ces fichiers, le code natif requis par l'ordinateur est créé au moment de l'exécution, selon les besoins, dans un processus appelé Just in Time (JIT)(compilation à la volée).
Il est possible de faire une autre niveau de compilation sur ces fichiers pour créer un code natif, qui sera prêt au démarrage du programme. C'est le processus AOT (Ahead of time process).
Comme le JIT se fait à l'exécution, il dispose d'un temps limité pour effectuer des optimisations de code étendues, AOT, en revanche, peut tout faire.
AOT devrait ainsi être plus rapide à charger, économiser la mémoire nécessaire au travail du JIT et réduire la latence due à la génération de code lorsqu'une nouvelle section de code est nécessaire.
De cette façon, AOT contribue à réduire l'énorme écart de performance entre le C# et un langage plus approprié comme le C++, même si le JIT peut effectuer une certaine optimisation en fonction de l'état d'exécution du code, ce que AOT ne peut pas faire. (si vous pensez que c# est aussi rapide qu'un code C++ efficace, mieux vaut fumez autre chose...)
En fait, aussi bien .net que mono utilisent AOT sur leurs composants lors de l'installation
Le JIT sera toujours actif et compilera un autre code au moment de l'exécution. OpenSim et les parties utilisées du framework .net/mono en dépendent.

Pour Linux, la version 0.9.2.0 inclut désormais les scripts makeaot.sh et cleanaot.sh pour aider à tester AOT.
Lancez makeaot.sh après l'étape de compilation ci-dessus, pour générer les fichiers de code natif. L'option -O=all doit être ajoutée à mono lors de l'exécution de opensim.exe, ex:

 mono --desktop -O=all OpenSim.exe

Le script cleanaot.sh supprime les fichiers binaires utilisés par AOT. Vous devez l'exécuter si vous recompilez le code (pour être protégé même si vous exécutez makeaot).
N'OUBLIEZ PAS de lancer makeaot.sh ou cleanaot.sh après la recompilation!
Les fichiers générés sont spécifiques à cette machine. Ne pas copier les fichiers de code natif sur une autre machine, sauf si elle est absolument identique
Les .exe et .dll originaux sont toujours nécessaires

AOT est également possible dans Windows, mais en utilisant différents outils, et ceux-ci ajoutent des choses au dépôt central sur la machine, plus difficile à isoler et à maintenir. voir ngen

Les Macs sont.. Les Macs.. Les futurs modèles pourraient totalement interdire le JIT, comme le font les produits mobiles d'Apple. Le Mono AOT sur les Macs actuels pourrait fonctionner comme sur Linux

En pratique, ne vous attendez pas à un chargement plus rapide. De plus, comme la compilation est différente, elle peut ajouter de nouveaux problèmes. Donc, testez avec soin.
Les problèmes de performance d'Opensim concernent principalement son propre code, les terribles mauvais protocoles de communication, l'utilisation d'un mauvais code .net/mono framework (qualité de la démo dans les mêmes cas), etc.
Et bien sûr, GC éternellement cassé.
But... well every ns counts..

[edit] Configuration

Voir Configuration.

Personal tools
General
About This Wiki