Ardor3D est mort, vive JogAmp’s Ardor3D Continuation [Ardor3D is dead, long life to JogAmp’s Ardor3D Continuation]

Article en cours de rédaction… Writing of the article in progress…
J’ai publié cet article non terminé car il y a très peu d’informations disponibles sur ce moteur pour le moment et sa rédaction me prendra plusieurs mois alors que plusieurs développeurs en ont besoin dès maintenant. I published this unfinished article because there is very little information available on this engine at the moment and its writing will take me several months whereas several developers need it right now.
Français English
Sommaire :

Summary:


Introduction


Introduction


Vue d’ensemble


Overview

JogAmp’s Ardor3D Continuation est un moteur 3D polyvalent, professionnellement orienté, open source, basé sur les graphes de scène, pour les environnements de bureau (GNU Linux, Mac OS X, OpenIndiana, Windows) et embarqués, écrit en Java et utilisant JOGL pour l’accélération graphique matérielle. JogAmp’s Ardor3D Continuation is a general-purpose, professionally oriented, open source, scenegraph based 3D engine for desktop (GNU Linux, Mac OS X, OpenIndiana, Windows) and embedded environments, written in Java and using JOGL for the hardware graphics acceleration.

Histoire


History

Ardor3D a été créé le 23 septembre 2008 en tant que fork de JMonkeyEngine par Renanse et MrCoder. Il était développé par ArdorLabs et quelques contributeurs jusqu’à sa version 0.9. Renanse a abandonné le projet le 11 mars 2014, il l’a annoncé sur son blog ici. Ardor3D was created September 23rd 2008 as a fork of JMonkeyEngine by Renanse and MrCoder. It was developed by ArdorLabs and some contributors until its version 0.9. Renanse abandoned the project March 11th 2014, he announced it on his blog here.
Sa version 1.0 est la toute première version activement maintenue et développée par la communauté JogAmp et il supporte exclusivement JOGL 2 (et supérieur). Il est désigné en tant que sous-ensemble du moteur original comme il ne garde qu’un seul système de rendu pertinent pour notre communauté. Ce sous-ensemble est appelé de préférence JogAmp’s Ardor3D Continuation pour éviter toute confusion avec le moteur « officiel » abandonné Ardor3D. Its version 1.0 is the very first version actively maintained and developed by JogAmp‘s community and it supports exclusively JOGL 2 (and later). It is designated as a subset of the original engine as it retains the only renderer relevant for our community. This subset is preferably called JogAmp’s Ardor3D Continuation in order to avoid any confusion with the « official » abandoned engine Ardor3D.

Principales caractéristiques


Main characteristics


Open source


Open source

Le code source est sous licence zlib/libpng (assez permissive). En fait, je devrais plutôt parler de logiciel libre puisque les quatre libertés fondamentales sont préservées :

  • exécuter le programme comme vous le souhaitez, pour n’importe quel but
  • étudier comment le programme fonctionne, et le changer de sorte qu’il fasse votre calcul tel que vous le souhaitez
  • redistribuer des copies afin d’aider votre voisin
  • distribuer des copies de vos versions modifiées à d’autres

The source code is under zlib/libpng license (quite permissive). Actually, I should rather talk about free software as the four fundamental freedoms are preserved:

  • run the program as you wish, for any purpose
  • study how the program works, and change it so it does your computing as you wish
  • redistribute copies so you can help your neighbor
  • distribute copies of your modified versions to others

Vous êtes libres de l’utiliser dans n’importe quel logiciel, libre ou non libre, gratuit ou payant. You are free to use it in any software, free or not free, free of charge or paid.
Néanmoins, si vous redistribuez une version divergente de notre moteur (sans reporter vos changements dans la nôtre, en gros si vous faites un fork), veuillez le faire sous un autre nom pour éviter toute confusion (comme nous le faisons déjà en utilisant l’appellation « JogAmp’s Ardor3D Continuation » au lieu de garder le nom « Ardor3D »). Nevertheless, if you distribute a divergent version of our engine (without putting back your changes into ours, basically if you create a fork), please do it under a different name to avoid any confusion (as we already do by using the name « JogAmp’s Ardor3D Continuation » instead of keeping the name « Ardor3D »).

Extensibilité


Extensibility

Ce moteur est conçu de sorte que la grande majorité de ses fonctionnalités puisse être étendue aisément sans devoir en changer le code source bien que cela reste possible évidemment. Par exemple, il est possible d’écrire ses propres importeurs et exporteurs de modèles 3D et d’images, son propre système de rendu 3D, ses propres widgets, … This engine is designed so that the vast majority of its features can be extended easily without having to modify the source code although it is still obviously possible. For example, you can write your own importers and exporters of 3D models and images, your own 3D rendering system, its own widgets, …

Intégration


Integration

Il fournit des fenêtres et des canevas qui s’intègrent dans des applications existantes basées sur AWT, Swing, SWT, OpenJFX/JavaFX (via Swing pour le moment, avec SwingNode et JFXPanel), Netbeans Platform et Eclipse RCP. L’affichage sur plusieurs écrans est supporté uniquement avec le système de rendu par défaut. It provides some windows and some canvases that integrate into existing applications based on AWT, Swing, SWT, OpenJFX/JavaFX (via Swing for the moment, with SwingNode and JFXPanel), Netbeans Platform and Eclipse RCP. The display on multiple screens is supported only with the default rendering system.

Modularité


Modularity

Ce moteur est composé d’une dizaine de sous-projets. Ainsi, vous pouvez tout à fait ne garder que ce dont vos applications et vos jeux ont vraiment besoin. This engine is composed of about ten sub-projects, so you can quite keep only what your applications and your games really need.

Efficacité


Efficiency

Un soin est porté à l’empreinte mémoire et à la vitesse. La gestion de certaines entités est laissée à la charge du développeur mais l’API lui pave la route. Le système de rendu par défaut minimise le nombre d’opérations sur le contexte OpenGL. La bibliothèque mathématique est optimisée pour solliciter aussi peu que possible le ramasse-miettes et pour éviter de créer des objets inutiles. Le rendu utilise le mode différé pour diminuer le nombre d’appels OpenGL pour dessiner un maillage. Quelques types de culling réduisent le nombre de primitives non visibles envoyées au GPU. A care is taken to the memory footprint and the speed. The management of certain entities is left to the developer but the API paves his way. The default rendering system minimizes the number of operations on the OpenGL context. The math library is optimized to solicit as little as possible the garbage collector and to avoid creating some useless objects. The rendering uses the retained mode to decrease the number of OpenGL calls to draw a mesh. Several kinds of culling reduce the number of non visible primitives uselessly sent to the GPU.

Abstraction


Abstraction

Ce moteur fournit une API de haut niveau, le but étant d’abstraire pour simplifier et non pour compliquer, abstraire pour aider et non pour mettre des bâtons dans les roues du développeur. Il est même possible d’utiliser des délégués de rendu pour injecter du code OpenGL dans le système de rendu par défaut. D’ailleurs, le choix de la résolution d’affichage et du moniteur physique ou virtuel se fait directement avec JOGL comme encapsuler ce type de fonctionnalité n’en aurait pas facilité l’usage (je n’ai pas trouvé de moyen de faire plus simple sans brider les fonctionnalités disponibles). This engine provides a high-level API, in order to abstract to simplify, not to complicate, abstract to help and not to put a spoke into the developer’s wheel. It is even possible to use rendering delegates to inject some OpenGL code into the default rendering system. Moreover, the choice of the display resolution and the physical or virtual monitor is directly done with JOGL as encapsulating this kind of feature wouldn’t have eased its use (I haven’t found a way of making something easier without curbing the available features).

Fiabilité


Reliability

JogAmp’s Ardor3D Continuation est le successeur d’un moteur écrit par deux contributeurs majeurs de JMonkeyEngine (1 et 2), ils avaient su en tirer les leçons et j’ai nettement moins de problèmes avec JogAmp’s Ardor3D Continuation qu’avec JMonkeyEngine 2 que j’avais utilisé pendant un an. JogAmp’s Ardor3D Continuation is the successor of an engine written by two major contributors of JMonkeyEngine (1 and 2), they had known to draw the lessons and I have had far fewer problems with JogAmp’s Ardor3D Continuation than with JMonkeyEngine 2 which I had used for one year.

Durabilité


Sustainability

JogAmp’s Ardor3D Continuation est un moteur conçu pour le développement d’applications amenées à durer. Cela se traduit d’abord par d’un support d’OpenGL très large, sans compromis, reposant à la fois sur le pipeline fixe et sur le pipeline programmable, le but étant à terme (dans la version 1.1) de supporter toutes les puces graphiques, d’OpenGL 1.1 à OpenGL 4.5, d’OpenGL ES 1 à OpenGL ES 3. Bien évidemment, certaines fonctionnalités ne seront pas supportées sur le matériel trop vieux, il s’agit surtout de permettre l’utilisation d’une grande partie des fonctionnalités partout. JogAmp’s Ardor3D Continuation is an engine designed for the development of applications lead to last. This is reflected first by a very wide OpenGL support, without compromise, relying on both the fixed pipeline and the programmable pipeline, the ultimate goal being (in version 1.1) to support all the graphics chips, from OpenGL 1.1 to OpenGL 4.5, from OpenGL ES 1 to OpenGL ES 3. Of course, some features won’t be supported on too old hardware, it is primarily intended to allow the use of most features everywhere.
Cela se traduit également par le choix des formats de modèles 3D supportés, uniquement des formats standards (ou bien définis et connus), ouverts, stables et pérennes dont les fichiers seront encore lisibles dans les prochaines décennies. Ainsi, la priorité est donnée au principal format d’échange entre applications 3D : Collada. Ce format est relativement bien supporté par un grand nombre de modeleurs dont Blender (un bogue subsiste dans son export des animations). JogAmp’s Ardor3D Continuation supporte aussi le format WaveFront OBJ qui est beaucoup moins complet que Collada (uniquement des maillages statiques) mais qui est nettement mieux supporté par les modeleurs. Deux formats similaires, STL et PLY, sont supportés dans la version 1.0.0 depuis août 2016 et le format BVH largement utilisé en capture de mouvement et en animation de personnage sera supporté dans la version 1.1.0. This is reflected by the choice of supported formats of 3D models too, only some standard (or well defined and known), open, stable, perennial formats whose files will be still readable in the next decades. Thus, the priority is given to the main interchange format for the 3D applications: Collada. This format is quite well supported by a big number of modelers including Blender (a bug remains in its export of animations). JogAmp’s Ardor3D Continuation supports the WaveFront OBJ format too, which is a lot less complete than Collada (only static meshes) but whose support in the modelers is clearly better. Two similar formats, STL and PLY, are supported in the version 1.0.0 since August 2016 and the BVH format widely used in motion capture and character animation will be supported in the version 1.1.0.
JogAmp’s Ardor3D Continuation supporte aussi quelques formats de modèles de jeux vidéo, notamment MD2 et MD3. jClassicRPG dispose également d’un chargeur de modèles au format MD5. ardor3d-openctm est un sous-projet d’un contributeur d’Ardor3D (il ne fait pas partie intégrante de JogAmp’s Ardor3D Continuation) qui permet de charger des modèles aux formats 3DS (Autodesk 3D Studio Max), LWO (Lightwave 3D) et OFF. Si cela ne vous suffit pas, vous pourrez utiliser la bibliothèque Assimp pour importer vos modèles (elle supporte une quarantaine de formats à l’import) puis les exporter dans un format géré par JogAmp’s Ardor3D Continuation. Vous pourrez aussi utiliser le très puissant logiciel de traitement de maillage 3D MeshLab qui supporte un plus grand nombre de formats à l’export qu’Assimp, en particulier U3D, un format d’échange concurrent de Collada. JogAmp’s Ardor3D Continuation supports some formats of video games models, noticeably MD2 and MD3. jClassicRPG has a loader for the models in MD5 format. ardor3d-openctm is a sub-project of an Ardor3D contributor (it’s not a part of JogAmp’s Ardor3D Continuation) that allows to load some models in 3DS (Autodesk 3D Studio Max), LWO (Lightwave 3D) and OFF formats. If it’s not enough for you, you will be able to use the library Assimp to import your models (it supports about forty formats in import) and then export them into a format handled by JogAmp’s Ardor3D Continuation. You’ll be able to use the very powerful 3D mesh processing software MeshLab that supports a greater number of formats in export than Assimp, especially U3D, a interchange format competing with Collada.
Les formats d’éditeurs et de moteurs susceptibles d’évoluer ne seront pas supportés. Ils peuvent changer drastiquement au fil du temps, ils demandent un effort de maintenance régulier (en particulier le format de Blender) et c’est à eux de supporter des formats d’échange. Il est bien évidemment hors de question de supporter des formats propriétaires dont le but est de rendre les utilisateurs captifs des fournisseurs afin de les obliger à acheter les nouvelles versions des logiciels propriétaires pour pouvoir continuer d’ouvrir et de modifier leurs documents. En conséquence, le format FBX ne sera jamais supporté par JogAmp’s Ardor3D Continuation. Je ne souhaite pas rendre ce type de format dangereux et non pérenne plus attractif, cela reviendrait à travailler bénévolement pour des organisations à but lucratif qui implémentent mal le support de certains formats standards (dont Collada) pour nuire à leur image. Il est dans l’intérêt des fournisseurs propriétaires de dissuader les utilisateurs finaux d’utiliser des formats ouverts afin qu’ils ne puissent pas travailler avec des logiciels concurrents même quand ils sont plus adaptés pour certaines tâches. « Science sans conscience n’est que ruine de l’âme », ce qui est plus pratique à court terme n’est pas nécessairement plus juste. The formats of the editors and the engines subject to evolutions won’t be supported. They can change drastically over time, they require a regular maintenance effort (especially Blender‘s format) and the support of interchange formats is their job. It is obviously out of question that I’ll support some proprietary formats which aims to make the users captive by some vendors in order to force them to buy the new versions of proprietary softwares to continue to be able to open and edit their documents. As a consequence, the FBX format will never be supported by JogAmp’s Ardor3D Continuation. I don’t wish to drive this kind of dangerous and not perennial format more attractive, this would lead to work voluntarily for profit-making organizations that implement badly the support of certain standard formats (including Collada) to harm their image. Discouraging end users to use open formats is in the interest of the proprietary vendors so that they can’t work with any competing products even when they are better suited for certain tasks. « Science without conscience is nothing but the ruin of the soul », what is more practical in the short term isn’t necessarily fairer.
Au passage, vous pouvez trouver beaucoup de modèles 3D sur OpenGameArt et sur le moteur de recherche de modèles 3D Yobi 3D. By the way, you can find lots of 3D models on OpenGameArt and on the 3D model search engine Yobi 3D.
Il n’est pas recommandé d’utiliser les formats (binaire et XML) du moteur pour le stockage à long terme. Ils permettent seulement de charger les modèles plus rapidement. En conséquence, il est recommandé de conserver les modèles 3D dans leurs formats originaux afin de pouvoir les convertir à nouveau pour les utiliser avec JogAmp’s Ardor3D Continuation. Using the (binary and XML) formats of the engine for the long-term storage isn’t recommended. They only allow to load the models faster. As a consequence, keeping the 3D models in their original formats is recommended in order to be able to convert them again to use them with JogAmp’s Ardor3D Continuation.

Documentation


Documentation

En fait, c’était le point faible de ce moteur et cet article est sensé y remédier. Le code source est documenté et le sous-projet ardor3d-examples contient une quarantaine d’exemples assez simples. L’ancètre de JogAmp’s Ardor3D Continuation a surtout été utilisé dans des jeux propriétaires. A ma connaissance, il n’existe que deux projets de jeux qui utilisent JogAmp’s Ardor3D Continuation et dont le code source est disponible. Deux autres projets (Besiege et jClassicRPG) semblent au point mort depuis des années et utilisent Ardor3D. Actually, it was the weak point of this engine and this article is supposed to fix it. The source code is documented and the sub-project ardor3d-examples contains about forty fairly simple examples. The ancestor of JogAmp’s Ardor3D Continuation was used primarily in proprietary games. To my knowledge, there are only two game projects that use JogAmp’s Ardor3D Continuation and whose source code is available. Two other projects (Besiege and jClassicRPG) seems to be stalled for years and have used Ardor3D.

Immunisation contre le patron de conception « dieu »


Immunization against the « god » design pattern

JogAmp’s Ardor3D Continuation est principalement axé sur la visualisation 3D avec son API de haut niveau. Ce n’est ni une boite à outils légère de niveau intermédiaire ni une suite de développement de jeux. Il n’y a pas de support du son (pour l’instant, mais vous pouvez utiliser Paul Lamb Sound Library avec ça), pas de machine à états (mais vous pouvez utiliser Fettle avec ça), pas de réseau, pas d’intégration avec un moteur physique (mais vous pouvez utiliser JBullet ou Jinngine avec ça), pas d’éditeur WYSIWYG et pas d’environnement intégré de développement de jeux. JogAmp’s Ardor3D Continuation is mainly focused on 3D visualization with its high-level scenegraph API. It’s neither a lightweight middle-level toolkit nor a game development suite. There is no sound support (yet, but you can use Paul Lamb Sound Library with it), no state machine (but you can use Fettle with it), no networking, no integration with a physics engine (but you can use JBullet or Jinngine with it), no WYSIWYG editor and no integrated game development environment.
JogAmp’s Ardor3D Continuation agit en tant que moteur 3D, il n’essaie pas de tout faire, il assume ses responsabilités dans sa couche logicielle : JogAmp’s Ardor3D Continuation acts as a 3D engine, it doesn’t try to do everything, it faces its own responsibility in its software layer:

  • Il n’essaie pas d’être un binding Java de l’API d’un moteur physique natif
  • Il n’essaie pas d’être un système de fenêtrage natif, c’est le rôle de NEWT (JOGL)
  • Il n’essaie pas d’être un binding Java de l’API OpenGL/OpenGL ES, c’est le rôle de JOGL
  • Il n’essaie pas d’être un binding Java de l’API OpenAL/OpenAL-Soft, c’est le rôle de JOAL

  • It doesn’t try to be a Java binding for a native physics engine API
  • It doesn’t try to be a native windowing system, this is the role of NEWT (JOGL)
  • It doesn’t try to be a Java binding for the OpenGL/OpenGL ES API, this is the role of JOGL
  • It doesn’t try to be a Java binding for the OpenAL/OpenAL-Soft API, this is the role of JOAL

Évidemment, quand une fonctionnalité manque dans une API tierce utilisée par ce moteur, il est possible de faire une demande d’amélioration auprès de l’une d’elles. Of course, when a feature is missing in a third party API used by this engine, it is possible to make a request for enhancement against any of them.

Public visé


Intended audience

Avant d’aller plus loin, vérifiez que JogAmp’s Ardor3D Continuation répond vraiment à vos besoins. Bien qu’il puisse être utilisé dans des applications de visualisation généralistes, je vais surtout m’adresser aux personnes intéressés par la création de jeux vidéo. Before going any further, check that JogAmp’s Ardor3D Continuation really meets your needs. Although it can be used in general-purpose visualization applications, I’m going to speak especially to the people interested in creating video games.
Si vous voulez vous concentrer sur la partie artistique d’un projet de jeu vidéo, utilisez plutôt un éditeur WYSIWYG (celui-ci est gratuit, libre et multiplateforme) ou bien créez un mod d’un jeu existant. If you want to focus on the artistic part of a video game project, rather use a WYSIWYG editor (this one is free of charge, free and cross platform) or make a mod of an existing game.
Si vous voulez vraiment programmer, plusieurs choix s’offrent à vous :

  • utilisez d’abord une API de haut niveau et n’essayez pas de comprendre comment elle fonctionne en interne
  • utilisez d’abord une API de haut niveau et essayez de comprendre comment elle fonctionne en interne ultérieurement
  • utilisez d’abord une API de bas niveau et n’utilisez aucune API de haut niveau
  • utilisez d’abord une API de bas niveau et utilisez une API de haut niveau ultérieurement quand vous vous sentez vraiment capable de comprendre comment elle fonctionne en interne

If you really want to program, several choices are available to you:

  • use a high-level API at first and don’t try to understand how it works internally
  • use a high-level API at first and try to understand how it works internally later
  • use a low-level API at first and don’t use any high-level API
  • use a low-level API at first and use any high-level API later when you feel really able to understand how it works internally

Comme les APIs de haut niveau reposent sur les APIs de bas niveau, comprendre ces dernières rend plus autonome lors de l’utilisation des premières. Quand quelque chose fonctionne de manière inattendu ou est cassé, vous pouvez la réparer si et seulement si vous la comprenez en interne, sinon vous avez besoin de l’aide des gens qui la comprennent. Si vous décidez d’utiliser uniquement des APIs de bas niveau, vous écrirez tôt ou tard vos propres APIs de haut niveau, vous passerez beaucoup de temps à réinventer la roue ce qui est bien pour apprendre mais cela peut vous décourager ou vous pouvez vous planter. Les APIs de haut niveau vous permettent de créer un jeu plus vite si et seulement si vous comprenez comment les utiliser. As the high-level APIs rely on the low-level APIs, understanding the latters drives you more autonomous when using the formers. When something doesn’t work as expected or is broken, you can only fix it if you understand how it works internally, otherwise you need some help of people who do. If you decide to use only low-level APIs, you’ll write your own high-level APIs sooner or later, you’ll spend a lot of time in reinventing the wheel which is nice to learn but it can discourage you and you can fail. The high-level APIs allow you to create a game faster if and only if you understand how to use them.
Si vous cherchez une API de niveau intermédiaire, utilisez plutôt LibGDX. Si vous cherchez un ensemble d’APIs de bas niveau, utilisez plutôt JogAmp. Si vous cherchez une suite de devéloppement de jeux vidéo, utilisez plutôt JMonkeyEngine. Si vous cherchez un framework dans le domaine public, utilisez plutôt Unlicense. Si vous êtes encore là, lisez la suite. If you’re looking for a middle-level API, rather use LibGDX. If you’re looking for a set of low-level APIs, rather use JogAmp. If you’re looking for a game development suite, rather use JMonkeyEngine. If you’re looking for a framework in the public domain, rather use Unlicense. If you’re still here, read further.
Les prérequis pour utiliser JogAmp’s Ardor3D Continuation sont les suivants :

  • Une maîtrise de la programmation orientée objet en Java et de ses APIs standards les plus couramment utilisées (obligatoire)
  • Une maîtrise des principes de base de l’infographie 3D (obligatoire)
  • Des notions de programmation graphique avec OpenGL (facultatif mais recommandé)

The prerequisites for using JogAmp’s Ardor3D Continuation are these furthers:

  • A mastery of object oriented programming with Java and of its standard most commonly used APIs (mandatory)
  • A mastery of the basic principles of 3D computer graphics (mandatory)
  • Some notions of graphics programming with OpenGL (optional but recommended)

Vous aurez besoin de comprendre la géométrie dans l’espace, les coordonnées homogènes, les vecteurs, les matrices, les transformations (translation, rotation, mise à l’échelle), les projections (orthogonales et en perspective) et le frustum de vue. You’ll need to understand the spatial geometry, the homogeneous coordinates, the vectors, the matrices, the transformations (translation, rotation, scale), the (orthogonal and perspective) projections and the viewing frustum.

Installation


Installation


Java


Java

Vous avez besoin du kit de développement Java (JDK). JogAmp’s Ardor3D Continuation est compatible avec OpenJDK (les instructions d’installation pour GNU Linux sont ici et les builds binaires non officiels sont ) et Oracle Java. JogAmp’s Ardor3D Continuation est incompatible avec Apple Java qui est déprécié depuis OS X 10.6. You need the Java development kit (JDK). Java 3D 1.6.0 is compatible with OpenJDK (the installation instructions for GNU Linux are here and the unofficial binary builds are here) and Oracle Java. JogAmp’s Ardor3D Continuation is incompatible with Apple Java which is deprecated since OS X 10.6.
Le code source et les JARs que je fournis nécessitent au moins Java 1.7. The source code and the JARs that I provide require at least Java 1.7.

Téléchargement


Download

L’installation est simple. Vous avez besoin des JARs suivants : The installation is simple. You need the following JARs:
  • ardor3d-animation.jar
  • ardor3d-awt.jar
  • ardor3d-collada.jar
  • ardor3d-core.jar
  • ardor3d-effects.jar
  • ardor3d-examples.jar
  • ardor3d-extras.jar
  • ardor3d-jinput.jar
  • ardor3d-jogl.jar
  • ardor3d-jogl-awt.jar
  • ardor3d-jogl-swt.jar
  • ardor3d-math.jar
  • ardor3d-savable.jar
  • ardor3d-swt.jar
  • ardor3d-terrain.jar
  • ardor3d-ui.jar
  • jogamp-fat.jar
  • guava-19.0.jar
  • swt.jar
Les JARs de JogAmp’s Ardor3D Continuation sont ici. The JARs of JogAmp’s Ardor3D Continuation are here.
Le fat JAR de JogAmp (JOGL, JOAL, JOCL et GlueGen) est ici. The JogAmp (JOGL, JOAL, JOCL and GlueGen) fat JAR is here.
Le JAR de Guava est ici. The JAR of Guava is here.
Les JARs de SWT sont ici. The JARs of SWT are here.
Le code source du moteur est ici. The source code of the engine is here.
Je vous conseille de bien récupérer tous les JARs, y compris ceux qui ne sont pas nécessaires pour l’exécution de votre programme sur votre système d’exploitation car ils vous seront utiles pour le déployer sur Internet sous forme d’applet, d’application Java Web Start ou de paquet applicatif natif autonome. I advise you to get all JARs, including those that are not necessary for the execution of your program on your operating system because they will be useful to deploy it on Internet as an applet, a Java Web Start application or a self-contained native application bundle.
Cependant, évidemment, vous n’avez besoin d’ardor3d-swt.jar, ardor3d-jogl-swt.jar et de swt.jar que si vous utilisez SWT. Si vous utilisez NEWT sans AWT, vous pouvez aussi vous passer d’ardor3d-awt.jar et d’ardor3d-jogl-awt.jar. Une fois que vous comprendrez mieux le rôle de chaque sous-projet, vous pourrez ne garder que les JARs utilisés par votre programme. However, obviously, you need ardor3d-swt.jar, ardor3d-jogl-swt.jar and swt.jar if and only if you use SWT. If you use NEWT without AWT, you can drop ardor3d-awt.jar and ardor3d-jogl-awt.jar too. Once you better understand the role of each sub-project, you will be able to keep only the JARs used by your program.
Il vous suffit de copier tous les JARs ci-dessus dans le même répertoire et de les mettre dans le classpath. Le répertoire choisi ne doit être ni dans la JVM (jre/lib/ext) ni dans les répertoires du mécanisme d’extension (/Library/Java/Extensions/, /System/Library/Java/Extensions/ et /System/Library/Frameworks sous Mac OS X) ni dans un répertoire mentionné dans la variable d’environnement CLASSPATH afin d’éviter tout conflit entre la version que vous utilisez et une version chargée en priorité installée dans un ou plusieurs de ces répertoires. De plus, ce mécanisme a été supprimé de Java 1.9 dans le cadre du projet Jigsaw. You just have to copy all JARs above into the same directory and put them into the classpath. The chosen directory must be neither in the JVM (jre/lib/ext) nor in one of the directories of the extension mechanism (/Library/Java/Extensions/, /System/Library/Java/Extensions/ and /System/Library/Frameworks under Mac OS X) nor in a directory mentioned in the CLASSPATH environment variable in order to avoid any conflict between the version that you use and a version loaded in priority installed in one or several of these directories. Moreover, this mechanism has been removed from Java 1.9 in the frame of the project Jigsaw.

Compilation et exécution


Compilation and execution


Ligne de commande


Command line

Vous pouvez lancer votre programme ainsi en ligne de commande (remplacez « : » par « ; » sous Windows, remplacez [1] par le chemin relatif de votre JAR ou de vos fichiers .class et [2] par le nom complet de la classe principale lequel contient les paquetages et les sous-paquetages) : You can run your program as well in command line (replace « : » by « ; » under Windows, replace [1] by the relative path of your JAR or of your .class files and [2] by the full name of the main class which contains the packages and subpackages):
java -cp ardor3d-animation.jar:ardor3d-awt.jar:ardor3d-collada.jar:ardor3d-core.jar:ardor3d-effects.jar:ardor3d-examples.jar:ardor3d-extras.jar:ardor3d-jinput.jar:ardor3d-jogl-awt.jar:ardor3d-jogl-swt.jar:ardor3d-jogl.jar:ardor3d-math.jar:ardor3d-savable.jar:ardor3d-swt.jar:ardor3d-terrain.jar:ardor3d-ui.jar:jogamp-fat.jar:guava-19.0.jar:swt.jar:[1] [2]
Utilisez l’option « -classpath » ou « -cp » de la même manière pour compiler votre programme avec javac. Use the option « -classpath » ou « -cp » in the same way to compile your program with javac.

Eclipse


Eclipse

Faites un clic droit sur le projet puis allez dans Properties -> Java Build Path -> Libraries. Cliquez sur « Add JARs… » et sélectionnez les JARs ci-dessus. Right clic on the project and go to Properties -> Java Build Path -> Libraries. Click on « Add JARs… » and select all JARs above.

Netbeans


Netbeans

Dans l’onglet « Project », sélectionnez le noeud « Libraries » -> « Add JAR/Folder » et sélectionnez les JARs ci-dessus. In the « Project » tab, select the « Libraries » node -> « Add JAR/Folder » and select all JARs above.

Maven


Maven

Maven est un outil d’automatisation de production de logiciels Java. Vous pouvez très simplement générer les JARs du moteur grâce à la phase « package » en tapant en ligne de commande « mvn package » dans le répertoire racine contenant le fichier pom.xml principal ou avec votre EDI (Netbeans supporte Maven de base et Eclipse le supporte via M2Eclipse). JogAmp’s Ardor3D Continuation sera disponible sur le dépôt Maven de JogAmp et sur Maven Central ultérieurement. Maven is a Java software build automation tool. You can generate the JARs of the engine very easily thanks to the phase « package » by entering « mvn package » in command line in the root directory containing the main pom.xml file or with your IDE (Netbeans has some build-in support of Maven and Eclipse supports it with M2Eclipse). JogAmp’s Ardor3D Continuation will be available on the JogAmp Maven repository and on Maven Central subsequently.
Dans Eclipse, sélectionnez le menu « File » -> « Import… » -> « Existing Maven Projects ». Cliquez sur le bouton « Browse… » dans la rubrique « Root Directory », choisissez le répertoire racine dans lequel vous venez de cloner les projets Git, choisissez les projets Maven du moteur dans la section « Projects » et cliquez sur le bouton « Finish ». In Eclipse, select the menu « File » -> « Import… » -> « Existing Maven Projects ». Click on the button « Browse… » in the section « Root Directory », choose the root directory in which you have just cloned the Git projects, choose the Maven projects of the engine in the section « Projects » and click on the button « Finish ».

Gradle


Gradle

Gradle est un outil d’automatisation de production de logiciels Java. Vous pouvez très simplement générer les JARs du moteur grâce à la cible « build » en tapant en ligne de commande « gradle build » dans le répertoire racine contenant le fichier build.gradle principal ou avec votre EDI (Netbeans supporte Gradle avec ce greffon et Eclipse le supporte avec ce greffon). Gradle is a Java software build automation tool. You can generate the JARs of the engine very easily thanks to the target « build » by entering « gradle build » in command line in the root directory containing the main build.gradle file or in your IDE (Netbeans supports Gradle with this plugin and Eclipse supports it with this plugin).

Ant


Ant

Ant est un outil d’automatisation de production de logiciels Java plus souple mais de plus bas niveau que Maven. Vous pouvez appeler Maven depuis Ant grâce aux tâches Ant de Maven. Cet exemple élaboré utilise Ant dans toutes les étapes du projet. Ant is a Java software build automation tool, more flexible but lower level than Maven. You can call Maven in Ant thanks to Maven Ant tasks. This elaborated example uses Ant in all steps of the project.

Résolution des problèmes


Troubleshooting

Si vous obtenez une UnsupportedClassVersionError, vérifiez que vous utilisez bien une JVM supportée par le moteur ici. If you get an UnsupportedClassVersionError, check that you really use a JVM supported by the engine here.

Documentation de l’API


API documentation

La documentation de l’API est disponible ici. The API documentation is available here.

Exemples


Examples


Exemples simples


Simple examples

Les exemples simples sont ici, il y en a presque une centaine. Vous avez besoin de tous les sous-projets du moteur pour les faire fonctionner. Lancez ExampleRunner pour les essayer. The simple examples are here, they are almost one hundred. You need all sub-projects of the engine to make them work. Run ExampleRunner to give them a try.
com.ardor3d.example.basic.BoxExample
Un exemple simple montrant une boîte texturé et éclairé qui tourne. A simple example showing a textured and lit box spinning.
com.ardor3d.example.basic.JoglBasicExample
Cet exemple basé sur JOGL est sensé montrer comment utiliser JogAmp’s Ardor3D Continuation à son niveau le plus primitif. Il utilise NEWT. This JOGL-based example is meant to show how to use JogAmp’s Ardor3D Continuation at the most primitive level. It uses NEWT.
com.ardor3d.example.basic.LineExample
Une démonstration d’anti-aliasing sur un objet Line. A demonstration of anti-aliasing on a Line object.
com.ardor3d.example.basic.MatrixLookAtExample
Une démonstration de la fonction MathUtils.matrixLookAt, qui construit une matrice de rotation utilisée pour orienter une position source vers une position cible. A demonstration of the MathUtils.matrixLookAt function, which constructs a rotation matrix used to orient a source position to a given target position.
com.ardor3d.example.basic.MouseManagerExample
Une démonstration de la classe MouseManager, qui est utilisée pour contrôler des propriétés (par exemple le curseur, la position) de la souris native. A demonstration of the MouseManager class, which is used to control properties (e.g. cursor, location) of the native mouse.
com.ardor3d.example.basic.OrbitCamExample
Une démonstration de OrbitCamControl, un contrôleur qui peut positionner une caméra en orbite autour d’un objet donné – dans ce cas, une théière. A demonstration of the OrbitCamControl, a controller that can position a camera in an orbit around a given target – in this case, a teapot.
com.ardor3d.example.basic.RTTShaderExample
Un exemple simple montrant l’utilisation de shaders dans RTT. A simple example showing use of shaders inside of RTT.
com.ardor3d.example.basic.ShapesExample
Un affichage de formes intrinsèques (par exemple boite, cône, tore). A display of intrinsic shapes (e.g. Box, Cone, Torus).
com.ardor3d.example.basic.SwitchNodeExample
Une démonstration de la classe SwitchNode, utilisée pour contrôler quel nœud à afficher activement parmi un ensemble de nœuds. A demonstration of the SwitchNode class, used to control which Node to actively display from a set of Nodes.
com.ardor3d.example.benchmark.ball.BubbleMarkExample
Le célèbre test BubbleMark UI, recréé avec des quads. The famous BubbleMark UI test, recreated using quads.
com.ardor3d.example.benchmark.ball.BubbleMarkUIExample
Le célèbre test BubbleMark UI, recréé en utilisant des composants Ardor3D UI. The famous BubbleMark UI test, recreated using Ardor3D UI components.
com.ardor3d.example.canvas.JoglAwtExample
Cet exemple montre comment faire du rendu OpenGL (via JOGL) sur un canevas AWT. This example demonstrates how to render OpenGL (via JOGL) on a AWT canvas.
com.ardor3d.example.canvas.JoglAwtDesktopExample
Cet exemple montre comment faire du rendu OpenGL (via JOGL) dans des cadres internes JDesktop. This example demonstrates how to render OpenGL (via JOGL) inside JDesktop internal frames.
com.ardor3d.example.canvas.JoglNewtAwtExample
Cet exemple montre comment faire du rendu OpenGL (via JOGL) sur un canevas NEWT AWT. This example demonstrates how to render OpenGL (via JOGL) on a NEWT AWT canvas.
com.ardor3d.example.canvas.JoglNewtSwtExample
Cet exemple montre comment faire du rendu OpenGL (via JOGL) sur un canevas NEWT SWT. This example demonstrates how to render OpenGL (via JOGL) on a NEWT SWT canvas.
com.ardor3d.example.canvas.JoglSwtExample
Cet exemple montre comment faire du rendu OpenGL (via JOGL) sur un canevas SWT. This example demonstrates how to render OpenGL (via JOGL) on a SWT canvas.
com.ardor3d.example.canvas.JoglSwingExample
Cet exemple montre comment faire du rendu OpenGL (via JOGL) sur un panneau Swing. This example demonstrates how to render OpenGL (via JOGL) on a Swing panel.
com.ardor3d.example.collision.CollisionTreeExample
Une démonstration de recherche et de récupération des collisions entre deux noeuds. A demonstration of finding and retrieving collisions between two nodes.
com.ardor3d.example.collision.ManyCollisionsExample
Une démonstration de comment déterminer si des collisions existent entre deux noeuds. A demonstration on how to determine if collisions exist between two nodes.
com.ardor3d.example.effect.BloomExample
Un exemple simple montrant le bloom A simple example showing bloom.
com.ardor3d.example.effect.ExtrusionExample
Une démonstration d’extrusion, montrant comment une ensemble de points peut être converti en une forme 3D. A demonstration of extrusion, showing how a set of point can be converted into a 3d shape.
com.ardor3d.example.effect.NewDynamicSmokerExample
Une autre démonstration de particules, celle-ci montrant une roquette fumante suivant un curseur autour de l’écran. Another particle demonstration, this one showing a smoking rocket following the cursor around the screen.
com.ardor3d.example.effect.ParallelSplitShadowMapExample
Exemple montrant la technique parallel split shadow mapping. Requiert le support de GLSL. Example showing the parallel split shadow mapping technique. Requires GLSL support.
com.ardor3d.example.effect.ParticleRampExample
Une démonstration des classes ParticleSystem et RampEntry, laquelle contrôle comment les propriétés de l’émetteur (par exemple taille, couleur) change au cours du temps. A demonstration of the ParticleSystem and RampEntry classes, which controls how an emitter’s properties (e.g. size, color) change over time.
com.ardor3d.example.effect.ParticleSwarmExample
Exemple montrant le système de particules utilisant la particule SwarmInfluence. Example showing a particle system using the particle SwarmInfluence.
com.ardor3d.example.effect.ParticleSystemExample
Une démonstration des classes ParticleSystem et TextureState, laquelle contrôle le changement des propriétés de l’émetteur (par exemple taille, couleur) au cours du temps. A demonstration of the ParticleSystem and TextureState classes, which controls an emitter’s properties (e.g. size, color) change over time.
com.ardor3d.example.effect.PointSpritesExample
Une démonstration utilisant PointType.PointSprite. Requiert le support de GLSL. A demonstration of using PointType.PointSprite. Requires GLSL support.
com.ardor3d.example.effect.ProjectedGridExample
Une démonstration de la classe ProjectedGrid, utilisée pour déterminer efficacement les points dans le terrain à dessiner. A demonstration of the ProjectedGrid class, used to efficiently determine which vertices’s in a terrain to draw.
com.ardor3d.example.effect.ProjectedGridWaterExample
Une démonstration de la classe WaterNode, laquelle gère le rendu d’un effet d’eau avec une grille projetée. A demonstration of the WaterNode and ProjectedGrid classes, which handles rendering of water effects with a projected grid.
com.ardor3d.example.effect.QuadImposterExample
Une démonstration de la classe QuadImposterNode, laquelle renseigne le niveau de détail de la texture pour un noeud. A demonstration of the QuadImposterNode class, which sets the texture level of detail for a Node.
com.ardor3d.example.effect.TrailExample
Un exemple d’utilisation de TrailMesh. An example of using TrailMesh.
com.ardor3d.example.effect.WaterExample
Une démonstration de la classe WaterNode, laquelle gère le rendu d’un effet d’eau sur tous ses fils. A demonstration of the WaterNode class, which handles rendering of a water effect on all of its children.
com.ardor3d.example.interact.InteractExample
Un exemple illustrant l’utilisation du framework d’interaction An example illustrating the use of the interact framework
com.ardor3d.example.interact.TerrainInteractExample
Exemple montrant les widgets d’interaction avec le système de Geometry Clipmap Terrain. Requiert le support de GLSL. Example showing interact widgets with the Geometry Clipmap Terrain system. Requires GLSL support.
com.ardor3d.example.interpolation.CurveInterpolationControllerExample
Une démonstration de la classe CurveInterpolationController, laquelle déplace/translate un noeud à chaque temps dans un ensemble de coordonnées 3D (par spline). A demonstration of the CurveInterpolationController class, which will move/translate a Node each epoch through a set of 3D coordinates (via spline).
com.ardor3d.example.interpolation.DefaultColorInterpolationControllerExample
Une démonstration de la classe DefaultColorInterpolationController, laquelle met à jour la couleur par défaut à chaque temps en interpolant entre les couleurs données. A demonstration of the DefaultColorInterpolationController class, which updates the default colour each epoch by interpolating between the given colours.
com.ardor3d.example.interpolation.LinearVector3InterpolationControllerExample
Une démonstration de la classe LinearVector3InterpolationController, laquelle déplacera un noeud dans un ensemble de coordonnées 3D (par interpolation linéaire). A demonstration of the LinearVector3InterpolationController class, which will move a Node through a set of 3D coordinates (via linear interpolation).
com.ardor3d.example.interpolation.QuaternionInterpolationControllerExample
Une démonstration de la classe QuaternionInterpolationController, laquelle tournera le noeud de chaque temps en interpolant entre les quaternions donnés. A demonstration of the QuaternionInterpolationController class, which will rotate a Node each epoch by interpolating between the given quaternions.
com.ardor3d.example.pipeline.AnimationBlinnPhongExample
Illustre le gpu skinning avec une carte de normales, une carte spéculaire et une coloration diffuse. Illustrates gpu skinning with normal map, specular map and diffuse coloring.
com.ardor3d.example.pipeline.AnimationCopyExample
Illustre le chargement de plusieurs animations depuis Collada et leur arrangement en une machine à états d’animation. Illustrates loading several animations from Collada and arranging them in an animation state machine.
com.ardor3d.example.pipeline.AnimationDemoExample
Illustre le chargement de plusieurs animations depuis Collada et leur arrangement en un arbre de mélange contrôlable. Illustrates loading several animations from Collada and arranging them in a controllable blend tree.
com.ardor3d.example.pipeline.AnimationStateExample
Ajoute des contrôles jouer/pause/stop à AnimationDemoExample. Adds play/pause/stop controls to AnimationDemoExample.
com.ardor3d.example.pipeline.ColladaExample
Illustre le chargement d’un modèle depuis Collada. Si le modèle contient aussi une animation, l’animation est joué elle aussi. Illustrates loading a model from Collada. If the model also contains an animation, the animation is played as well.
com.ardor3d.example.pipeline.ColladaManualAnimationExample
Illustre le chargement d’un modèle depuis Collada et l’animation procédurale de ses articulations. Illustrates loading a model from Collada and procedurally animating its joints.
com.ardor3d.example.pipeline.ExportImportExample
Une démonstration des classes BinaryImporter et BinaryExporter, lesquelles peuvent exporter/importer un noeud depuis/vers un flux de données. A demonstration of the BinaryImporter and BinaryExporter classes, which can export/import a Node to/from a data stream.
com.ardor3d.example.pipeline.PrimitiveSkeletonExample
Une démonstration combinant les classes d’animation squelettale au langage de shading OpenGL. A demonstration of combining the skeletal animation classes with OpenGL Shading Language.
com.ardor3d.example.pipeline.SimpleColladaExample
Exemple le plus simple de chargement d’un modèle Collada. Simplest example of loading a Collada model.
com.ardor3d.example.pipeline.SimpleMd2Example
Exemple le plus simple de chargement d’un modèle au format MD2. Simplest example of loading a model in MD2 format.
com.ardor3d.example.pipeline.SimpleMd3Example
Exemple le plus simple de chargement d’un modèle au format MD3. Simplest example of loading a model in MD3 format.
com.ardor3d.example.pipeline.SimpleObjExample
Exemple le plus simple de chargement d’un modèle WaveFront OBJ. Simplest example of loading a Wavefront OBJ model.
com.ardor3d.example.renderer.BillboardNodeExample
Illustre la classe BillboardNode, laquelle définit un noeud qui s’oriente toujours face à la caméra. Illustrates the BillboardNode class, which defines a node that always orients towards the camera.
com.ardor3d.example.renderer.ClipStateExample
Illustre la classe ClipState, laquelle spécifie le plan à test pour le clipping d’un noeud. Illustrates the ClipState class, which specifies a plane to test for clipping of a Node.
com.ardor3d.example.renderer.CombinerExample
Un exemple montrant l’utilisation de MeshCombiner pour souder ensemble un tas de boites en un seul maillage. An example showing use of MeshCombiner to weld together a bunch of boxes into a single mesh.
com.ardor3d.example.renderer.DegenerateTrianglesExample
Illustre deux techniques pour créer un triangle strip (c’est-à-dire des séries de triangles connectés). Illustrates two techniques for creating a triangle strip (i.e. series of connected triangles).
com.ardor3d.example.renderer.DisplayListDelegateExample
Illustre la création de display list à partir de deux ensembles (c’est-à-dire l’ensemble d’origine et l’ensemble copié) de noeuds. Illustrates creating a display list from two sets (i.e. original set and copied set) of Nodes.
com.ardor3d.example.renderer.DisplayListExample
Illustre la création de display list de formes intrinsèques (par exemple boite, cône, tore). Illustrates creating a display list of intrinsic shapes (e.g. Box, Cone, Torus).
com.ardor3d.example.renderer.GeneratedTexturesExample
Illustre la classe GeneratedImageFactory et le paquetage math.functions, lesquels permettent la création procédurale de textures. Illustrates the GeneratedImageFactory class and math.functions package, which allow for procedural creation of textures.
com.ardor3d.example.renderer.GeometryInstancingExample
Démontre l’utilisation du geometry instancing et le compare au VBO. Demonstrates the use of geometry instancing and compares it to VBO.
com.ardor3d.example.renderer.GLSLRibbonExample
Démonstration de l’effet GLSL titré ‘To The Road Of Ribbon’ by TX95 (2008). Requiert le support de GLSL. Demonstration of a GLSL effect titled ‘To The Road Of Ribbon’ by TX95 (2008). Requires GLSL support.
com.ardor3d.example.renderer.MandelbrotExplorerExample
Illustre la classe MandelbrotFunction3D, laquelle permet la création procédurale du fameux ensemble de Mandelbrot. Illustrates the MandelbrotFunction3D class, which allows for procedural creation of the famous Mandelbrot set.
com.ardor3d.example.renderer.ManyLightsExample
Une démonstration de sphères placées aléatoirement illuminées par de nombreuses sources PointLight. A demonstration of randomly placed spheres being illuminated by numerous PointLight sources.
com.ardor3d.example.renderer.MaterialFaceExample
Une démonstration utilisant MaterialState pour renseigner les paramètres des équations de lumières. A demonstration using MaterialState to set lighting equation parameters.
com.ardor3d.example.renderer.MeshDataSharingExample
Illustre les classes CopyLogic et SceneCopier, lesquelles permettent la copie efficace et le partage de données de maillage. Illustrates the CopyLogic and SceneCopier classes, which allow for the efficient copying and sharing of mesh data.
com.ardor3d.example.renderer.MultiPassTextureExample
S’appuie sur le BoxExample pour illustrer l’utilisation du PassNode pour faire du simple multi-texturing. Borrows from the BoxExample to illustrate using PassNode to do simple multi-texturing.
com.ardor3d.example.renderer.MultiStripExample
Illustre le maillage avec plusieurs primitives (c’est-à-dire strip, quad, triangle). Illustrates mesh with several primitives (i.e. strip, quad, triangle).
com.ardor3d.example.renderer.PointCubeExample
Un exemple plus complexe d’utilisation de geometry shaders. Nécessite le support des geometry shaders (évidemment). A more complex example of using geometry shaders. Requires support for geometry shaders (obviously).
com.ardor3d.example.renderer.PointsExample
Une démonstration simple d’affichage de nombreux points en trois dimensions. A simple demonstration of displaying numerous Point in three-dimensions.
com.ardor3d.example.renderer.RenderEffectsExample
Un exemple simple illustrant l’utilisation d’effets de rendu. A simple example illustrating use of render effects.
com.ardor3d.example.renderer.RenderQueueExample
Illustre la file de rendu, laquelle contrôle comment des noeuds sont dessinés quand du chevauchement se produit. Illustrates the Render Queue, which controls how Nodes are drawn when overlapping occurs.
com.ardor3d.example.renderer.RenderTextureCubeMapExample
Démontre le rendu vers une texture, où la texture est un cubemap. Demonstrates rendering to texture, where the texture is a cubemap.
com.ardor3d.example.renderer.RenderTextureSideBySideExample
Illustre la classe TextureRenderer, laquelle rend une scène sur un tampon et la copie vers une texture. Illustrates the TextureRenderer class, which renders a scene to a buffer and copying it to a texture.
com.ardor3d.example.renderer.SphereComparisonsExample
Exemple simple montrant les différences entre GeoSphere et Sphere et les diverses associations de textures. Simple example showing differences between GeoSphere and Sphere and their various texture mappings.
com.ardor3d.example.renderer.StereoExample
Illustre la classe StereoCamera, laquelle permet les plaisirs de la vue stéréo. Illustrates the StereoCamera class, which allows for your stereo viewing pleasures.
com.ardor3d.example.renderer.TexCombineExample
Montre des textures interpolées en utilisant la combinaison de textures. Shows interpolated textures using texture combine.
com.ardor3d.example.renderer.Texture3DExample
Exemple très simple montrant l’utulisation d’une texture Texture3D. Very simple example showing use of a Texture3D texture.
com.ardor3d.example.renderer.TextureProjectionExample
Illustre la classe TextureProjector, laquelle projète une texture bidimensionnelle sur une surface tridimensionnelle. Illustrates the TextureProjector class, which projects a two-dimensional texture onto a three-dimensional surface.
com.ardor3d.example.renderer.UpdateTextureExample
Une démonstration de modification procédurale d’une texture. A demonstration of procedurally updating a texture.
com.ardor3d.example.renderer.VBOSpeedExample
Illustre la classe DataMode, laquelle décrit comment on préfère que les données soient envoyées à la carte. Illustrates the DataMode class, which describe how we prefer data to be sent to the card.
com.ardor3d.example.renderer.ViewportExample
Illustre la classe Camera, laquelle représente une vue dans la scène 3D et comment cette vue devrait correspondre à la surface de rendu 2D. Illustrates the Camera class, which represents a view into a 3d scene and how that view should map to a 2D rendering surface.
com.ardor3d.example.renderer.WireframeGeometryShaderExample
Un exemple d’utilisation des geometry shaders. Requiert le support des geometry shaders (évidemment). An example of using geometry shaders. Requires support for geometry shaders (obviously).
com.ardor3d.example.renderer.utils.atlas.AtlasExample
Exemple montrant comment utiliser l’empaqueteur de textures pour créer un atlas de textures. Montre aussi les bénéfices de son utilisation conjointe avec le MeshCombiner. Example showing how to use the TexturePacker to create a texture atlas. Also shows the benefits of using it together with the MeshCombiner.
com.ardor3d.example.renderer.utils.atlas.AtlasExampleMultiTextured
Exemple montrant comment utiliser l’empaqueteur de textures pour créer un atlas de textures. Montre aussi les bénéfices de son utilisation conjointe avec le MeshCombiner. Example showing how to use the TexturePacker to create a texture atlas. Also shows the benefits of using it together with the MeshCombiner.
com.ardor3d.example.renderer.utils.atlas.TestAtlasPacker
Test de l’algorithme de base d’empaquetage d’atlas Test base atlas packer algorithm
com.ardor3d.example.terrain.ArrayTerrainExample
Exemple montrant un système de Geometry Clipmap Terrain avec ‘MegaTextures’ dans lequel les données du terrain sont fournies depuis un tableau de flottants. Requiert le support de GLSL. Example showing the Geometry Clipmap Terrain system with ‘MegaTextures’ where the terrain data is provided from a float array. Requires GLSL support.
com.ardor3d.example.terrain.ImageMapTerrainExample
Exemple montrant un système de Geometry Clipmap Terrain avec ‘MegaTextures’ dans lequel les données du terrain sont fournies depuis un tableau de flottants rempli à partir d’une carte de hauteur généré avec une image. Requiert le support de GLSL. Example showing the Geometry Clipmap Terrain system with ‘MegaTextures’ where the terrain data is provided from a float array populated from a heightmap generated from an Image. Requires GLSL support.
com.ardor3d.example.terrain.InMemoryTerrainExample
Exemple montrant un système de Geometry Clipmap Terrain avec ‘MegaTextures’ en flux depuis une source de données en mémoire. Requiert le support de GLSL. Example showing the Geometry Clipmap Terrain system with ‘MegaTextures’ streaming from an in-memory data source. Requires GLSL support.
com.ardor3d.example.terrain.MountainShadowTerrainExample
Exemple montrant un système de Geometry Clipmap Terrain avec ‘MegaTextures’ dans lequel les données du terrain sont fournies depuis un tableau de flottants rempli à partir d’une carte de hauteur généré avec une image.. Requiert le support de GLSL. Example showing the Geometry Clipmap Terrain system with ‘MegaTextures’ where the terrain data is provided from a float array populated from a heightmap generated from an Image. Requires GLSL support.
com.ardor3d.example.terrain.ProceduralTerrainExample
Exemple montrant un système de Geometry Clipmap Terrain avec ‘MegaTextures’ en utilisant du contenu généré procéduralement à la volée. Requiert le support de GLSL. Example showing the Geometry Clipmap Terrain system with ‘MegaTextures’ using content procedurally generated on-the-fly. Requires GLSL support.
com.ardor3d.example.terrain.ShadowedTerrainExample
Exemple montrant un système de Geometry Clipmap Terrain combiné au PSSM. (un peu expérimental) Requiert le support de GLSL. Example showing the Geometry Clipmap Terrain system combined with PSSM. (a bit experimental) Requires GLSL support.
com.ardor3d.example.terrain.ShapesPlusProceduralTerrainExample
Exemple montrant un système de Geometry Clipmap Terrain avec ‘MegaTextures’. On fusionne le dessin AWT avec la texture du terrain en temps réel. Requiert le support de GLSL. Example showing the Geometry Clipmap Terrain system with ‘MegaTextures’. We merge AWT drawing with the terrain texture in real time. Requires GLSL support.
com.ardor3d.example.terrain.TerrainWaterExample
Exemple montrant comment combiner le système de terrain et celui de l’eau. Requiert le support de GLSL. Example showing how to combine the terrain and water systems. Requires GLSL support.
com.ardor3d.example.terrain.ZupTerrainExample
Exemple montrant un système de Geometry Clipmap Terrain avec ‘MegaTextures’ avec l’axe Z vers le haut. C’est fait en retournant le système de terrain de l’axe Y vers le haut vers l’axe Z vers le haut et en inversant des interactions avec ça à nouveau dans l’espace de coordonnées de terrain avec l’axe Y vers le haut. Requiert le support de GLSL. Example showing the Geometry Clipmap Terrain system with ‘MegaTextures’ using Z-Up. This is done by flipping the terrain system from y-up to z-up and inverting interactions with it back to the y-up terrain coordinate space. Requires GLSL support.
com.ardor3d.example.ui.BMTextExample
Illustre comment modifier des propriétés de texte (par exemple la police, la couleur, l’alignement) et afficher sur un canevas. Illustrates how to modify text properties (e.g. font, color, alignment) and display on a canvas.
com.ardor3d.example.ui.RotatingUIExample
Illustre comment afficher et déplacer des prmitives d’interfaces graphiques (par exemple RadioButton, Label, TabbedPane) sur un canevas. Illustrates how to display and move GUI primitatives (e.g. RadioButton, Label, TabbedPane) on a canvas.
com.ardor3d.example.ui.SimpleUIExample
Illustre comment afficher des prmitives d’interfaces graphiques (par exemple RadioButton, Label, TabbedPane) sur un canevas. Illustrates how to display GUI primitatives (e.g. RadioButton, Label, TabbedPane) on a canvas.

Exemples élaborés


Elaborate examples


ArdorCraftAPI


ArdorCraftAPI

ArdorCraftAPI_JOGL_second_success
ArdorCraftAPI est une API qui permet de créer des jeux similaires à Minecraft. Son code source est assez documenté et ses trois exemples permettent d’apprendre à s’en servir progressivement. Vous n’y trouverez pas toutes les fonctionnalités de Minecraft mais l’exemple le plus complet est un excellent point de départ. Ce projet utilise de nombreuses fonctionnalités du moteur et a été écrit par MrCoder. C’est un bon moyen de savoir comment les créateurs d’Ardor3D se servaient de leur propre moteur. Le code source est sous la même licence que le moteur qui est adapté autant aux logiciels propriétaires qu’aux logiciels libres. Néanmoins, les exemples ne traitent pas du tout certains aspects, il n’y a ni interface graphique ni son ni déploiement. Le projet Eclipse de test qui contient les exemples est ici et le code source de l’API est ici. ArdorCraftAPI is an API that allows to create some games similar to Minecraft. Its source code is quite documented and its three examples allow to learn how to use it progressively. You won’t find all Minecraft’s features in it but the most complete example is an excellent starting point. This project uses numerous features of the engine and was written by MrCoder. It’s a good mean of knowing how the creators of Ardor3D used their own engine. The source code is under the same license than the engine which is suitable both for closed source softwares than for free softwares. Nevertheless, the examples don’t deal with some aspects, there is neither graphical user interface nor sound nor deployment. The test Eclipse project that contains the examples is here and the source code of the API is here.

Truly Unusual Experience of Revolution®


Truly Unusual Experience of Revolution®

Truly Unusual Experience of Revolution® est le jeu activement maintenu et sous licence libre reposant sur JogAmp’s Ardor3D Continuation le plus complet. C’est un jeu de tir en vue subjective. Il n’utilise ni l’animation squelettale ni le module de gestion de terrains mais il utilise quasiment toutes les autres fonctionnalités du moteur. Paul Lamb Sound Library gère le son avec son greffon basé sur JOAL. Le déploiement s’appuie sur JNDT et Java Web Start. Mon jeu a besoin de contrôler le fenêtrage via NEWT (JOGL) et cet aspect n’est pas entièrement traité par le moteur (il est incapable de récupérer les résolutions disponibles de chaque moniteur). Mon jeu utilise plusieurs machines à états grâce à l’API Fettle. Mon usage des arbres a parfois été critiqué par Renanse donc je ne peux pas garantir que je respecte toujours les bonnes pratiques mais mon code source est très bien documenté. Mon projet est simple à compiler et à lancer, les instructions sont ici. Le nettoyage, la compilation, la création des JARs, la création des fichiers JNLP, celle des paquets applicatifs natifs autonomes et de l’archive du code source, les envois sur le serveur SFTP, le lancement de mon jeu et celui de mon éditeur sont entièrement gérés par le script Ant. Mon jeu dispose d’un éditeur encore assez limité, JFPSM. Bien que mon jeu soit disponible sous forme de projet Eclipse, mes instructions expliquent comment s’en servir sous Netbeans et comme j’utilise Ant, n’importe quel EDI décent peut faire l’affaire, vous pouvez même coder avec un simple éditeur de textes et compiler en ligne de commande. Mon projet contient toutes ses dépendances ce qui fait gagner du temps, vous n’en perdrez pas à chercher les bons JARs sur Internet. Mon jeu est également doté d’une bonne gestion de la mémoire grâce à la prise en charge du cycle de vie complet des objets alloués sur le tas natif et grâce au patron de conception « poids mouche ». Vous pouvez trouver beaucoup d’articles au sujet de mon jeu ici. Truly Unusual Experience of Revolution® is the most complete actively maintained game under free license based on JogAmp’s Ardor3D Continuation. This is a first person shooter. It uses neither the skeletal animation nor the module of terrain management but it uses almost all other features of the engine. Paul Lamb Sound Library manages the sound with its plugin based on JOAL. The deployment relies on JNDT and Java Web Start. My game needs to control the windowing with NEWT (JOGL) and this aspect isn’t entirely treated by the engine (it is unable to retrieve the available resolutions of each monitor). My game uses several state machines thanks to the Fettle API. My usage of the trees has been sometimes criticized by Renanse, therefore I can’t guarantee that I always respect the best practices but my source code is very well documented. My project is simple to compile and to launch, the instructions are here. The cleaning, the compiling, the creation of the JARs, the creation of the JNLP files, those of the self-contained native application bundles and of the archives of the source code, the upload to the SFTP server, the launch of my game and the one of my editor are entirely managed by the Ant script. My game has its own editor which is still quite limited, JFPSM. My instructions explain how to use my project with Netbeans although it is an Eclipse project and as I use Ant, any decent IDE can be used, you can even code with a simple text editor and compile in command line. My project contains all its dependencies which helps to save some time, you won’t waste any time in looking for the right JARs on Internet. My game has a nice memory management too thanks to the handling of the whole lifecycle of the objects allocated on the native heap and thanks to the « flyweight » design pattern. You can find lots of articles about my game here.
Attention : Mon projet utilise des licences virales pour son code source et pour ses œuvres artistiques. Veuillez ne vous en servir que si vous en acceptez les conditions d’utilisation. Warning: My project uses some viral licenses for its source code and its artworks. Please use it only if you agree with its terms of use.

Premier cas d’utilisation


First use case


Concepts de base


Basic Concepts

Le moteur est composé de 17 sous-projets :

The engine is composed of 17 sub-projects:


Explication de code


Explanation of code


Déploiement


Deployment


Applet


Applet

Le support des applets dans JogAmp’s Ardor3D Continuation a été abandonné en février 2016 comme cette technologie risque de disparaitre des principaux navigateurs web d’ici quelques années à la suite de l’abandon de l’architecture de greffon NPAPI sur laquelle le greffon Java s’appuie. Elle est dépréciée dans Java 1.9 depuis janvier 2016 et disparaitra de Java dans sa version 1.10. The support of applets in JogAmp’s Ardor3D Continuation was dropped in February 2016 as this technology risks to disappear from the major web browsers in a few years in the wake of the abandon of the plugin architecture NPAPI on which the Java plugin is based. It’s deprecated in Java 1.9 since January 2016 and will disappear from Java in its version 1.10.

Java Web Start


Java Web Start

L’obligation de signer les JARs avec un certificat dit « de confiance » payant, les nombreux changements de sécurité et les problèmes récurrents de fiabilité de Java Web Start l’ont rendu particulièrement pénible à utiliser, à la fois pour les développeurs et pour les utilisateurs finaux. Je ne fournis que des JARs non signés, à vous de les signer. Cette méthode de déploiement n’est pas recommandée. The obligation of signing up the JARs with a « trusted » paid certificate, the numerous security changes and the recurring reliability problems of Java Web Start have driven it particularly painful to use, both for the developers and for the end users. I provide only some unsigned JARs, it’s up to you to sign them up. This deployment method isn’t recommended.
Chaque JAR du même fichier JNLP doit être signé avec le même certificat. Les attributs de manifeste « Application-Name », « Permissions » et « Codebase » doivent être renseignés, c’est expliqué ici. Mettre l’attribut de manifeste « Trusted-Only » à « true » est recommandé, c’est ce qui vous posera le moins de problèmes, vous trouverez de plus amples explications ici. Malheureusement, pour éviter de tomber sur des bogues et pour simplifier le déploiement, vous devez faire ces modifications sur tous les JARs que vous hébergez, les vôtres et ceux des bibliothèques que vous utilisez. Vous devez également supprimer l’attribut « Trusted-Library » des manifestes des JARs. Each JAR of the same JNLP file must be signed with the same certificate. The manifest attributes « Application-Name », « Permissions » and « Codebase » must be set, it’s explained here. Setting the manifest attribute « Trusted-Only » to « true » is recommended, this is what will cause you the fewest problems, you will find more explanations here. Unfortunately, you must make some modifications on all JARs that you host, yours and those of the libraries that you use in order to avoid suffering because of some bugs and to simplify the deployment. You must remove the attribute « Trusted-Library » from the manifests of the JARs.
Ce tutoriel officiel d’Oracle explique comment déployer une application avec Java Web Start et celui-ci explique la syntaxe du fichier JNLP. Je vous recommande de renseigner au moins -XX:MaxDirectMemorySize (taille du tas « natif », utile pour les NIO buffers directs), initial-heap-size et max-heap-size (taille du tas Java). Renseignez aussi l’attribut « main-class » de l’élément « application-desc ». Enfin, utilisez l’élément « jar » pour chaque JAR, renseignez l’attribut « main » à « true » pour le JAR qui contient la classe qui contient la méthode principale du programme. This official Oracle tutorial explains how to deploy an application with Java Web Start and this one explains the JNLP file syntax. I recommend you to set at least -XX:MaxDirectMemorySize (size of the « native » heap, useful for the direct NIO buffers), initial-heap-size and max-heap-size (size of the Java heap). Set the attribute « main-class » of the element « application-desc ». Finally, use the element « jar » for each JAR, set the attribute « main » to « true » for the JAR that contains the class that contains the main method of the program.

JAR exécutable


Executable JAR

Un JAR exécutable est un JAR qui contient le point d’entrée du programme et qui peut donc être lancé d’un double-clic si Java est installé et reconnu comme programme à utiliser par défaut pour ouvrir les JARs. L’attribut du manifeste « Main-Class » pointe vers la classe qui contient la méthode main. Bien qu’il soit possible de déployer une application avec plusieurs JARs dont un seul JAR exécutable, on parle souvent de JAR exécutable pour un fat JAR qui contient tous les fichiers de l’application. An executable JAR is a JAR that contains the program entry point and that can therefore be run with a double-click if Java is installed and recognized as the program to use by default to open the JARs. The manifest attribute « Main-Class » points to the class that contains the main method. We often talk about executable JAR for a fat JAR that contains all files of the application although it is possible to deploy an application with several JARs only one of which is an executable JAR.
Cette solution comporte pas mal d’inconvénients :

  • Une version suffisamment récente de Java doit être installé sur la machine
  • Beaucoup d’utilisateurs finaux ne sont toujours pas familiers aux JARs malgré le succès de Minecraft
  • Certains navigateurs web sur certains systèmes d’exploitation cassent les JARs téléchargés ce qui rend les programmes impossibles à lancer d’un double-clic
  • Un double-clic sur le JAR peut l’ouvrir avec l’archiveur au lieu de démarrer son programme
  • La fusion des manifestes ne permet pas de conserver certains attributs et peut faire planter certains outils en cas d’entrées dupliquées dont Ant (rapport de bogue ici)
  • Il est impossible de modifier les options de la JVM
  • Il n’y a aucune intégration native dans le bureau

This solution has a lot of disadvantages:

  • A sufficiently recent version of Java must be installed on the machine
  • Many end-users are still not familiar with JARs despite the success of Minecraft
  • Some web browsers on some operating systems break the downloaded JARs which makes their programs impossible to run with a double-click
  • A double-click on a JAR can open it with the archiver instead of running its program
  • The merge of the manifests doesn’t allow to keep some attributes and can crash some tools in case of duplicate entries including Ant (bug report here)
  • Modifying the JVM options is impossible
  • There is no native integration in the desktop

Il est préférable de voir le JAR exécutable comme une solution temporaire pendant une période d’expérimentation et comme une entrée à fournir à des méthodes de déploiement plus élaborées comme tous les fichiers nécessaires au bon fonctionnement du programme sont dans le JAR. It is better to see the executable JAR as a temporary solution for a period of experimentation and as an input to provide to some more sophisticated methods of deployment as all necessary files for the proper functioning of the program are in the JAR.
Il faut respecter cette disposition pour permettre à GlueGen de trouver les bibliothèques natives. L’outil de build Ant permet très facilement de créer un seul JAR à partir de plusieurs JARs comme dans cet exemple, vous devez également renseigner l’attribut « Main-Class » du manifeste. Vous pouvez aussi utiliser JarMatey, One-Jar et JarSplice à cet effet. You must respect this layout to allow GlueGen to find the native libraries. The build tool Ant allows to create a single JAR from several JARs very easily like in this example, you must set the manifest attribute « Main-Class » too. You can also use JarMatey, One-Jar and JarSplice for this purpose.

Paquet applicatif natif autonome


Self-contained native application bundle

Cette méthode de déploiement lève quasiment toutes les limitations des JARs exécutables. En signant votre code (ce que je ne fais pas pour des raisons politiques), vous pourrez même vous débarrasser des messages d’alerte effrayant de certains systèmes d’exploitation propriétaires mais pas de ceux des logiciels antivirus stupides. This method of deployment lifts almost all the limitations of executable JARs. By signing your code (which I don’t do for political reasons), you will even be able to get rid of the scary warning messages of some proprietary operating systems but not those of the stupid virus scanners.

IzPack


IzPack

IzPack est un installeur open source (sous une licence permissive) très mature, fiable et activement maintenu depuis 2001. C’est la solution à privilégier pour une installation nécessitant pas mal d’interactions avec l’utilisateur, par exemple pour accepter la licence, choisir la langue, choisir les modules à installer et le répertoire d’installation. Il dispose de ses propres lanceurs natifs pour Windows. Il est compatible avec Launch4j et JSmooth. Il est probablement utilisable avec PackR et JNDT avec un petit effort. Sa principale limitation est l’absence de mécanisme de mise à jour automatique. L’utilisateur final n’a pas besoin d’une JVM pré-installée quand IzPack utilise un lanceur natif sur chaque plateforme supporté, ce qui est faisable grâce à PackR et JNDT. IzPack couplé à Launch4j, PackR ou JNDT fournit à peu près les mêmes fonctionnalités que ses principaux concurrents propriétaires, install4j + exe4j et jwrapper. IzPack is an open source (under a permissive lincense) very mature and reliable installer maintained since 2001. It’s the solution to favour for an installation requiring numerous interactions with the user, for example to accept the license, choose the language, choose the modules to install and the directory of installation. It has its own native launchers for Windows. It is compatible with Launch4j and JSmooth. It is probably usable with PackR and JNDT with a small effort. Its main limitation is the absence of automatic update mechanism. The end user doesn’t need a pre-installed JVM when IzPack use a native launcher on each supported platform, which is doable thanks to PackR and JNDT. IzPack coupled with Launch4j, PackR or JNDT provides just about the same features than its main closed source competitors, install4j + exe4j and jwrapper.

PackR


PackR

PackR prend en entrée un JAR exécutable (obligatoire), un JDK (obligatoire) et d’autres fichiers (optionnels). Il en fait un répertoire prêt à compresser contenant tous les fichiers nécessaires au bon fonctionnement du programme dont un lanceur natif prêt à l’emploi qu’il n’est pas nécessaire de recompiler s’il n’est pas modifié. Il lit ses options dans un fichier JSON. Ainsi, il est possible de faire une grande partie de la création d’un paquet applicatif natif autonome sans être sous le système d’exploitation cible. Le lanceur natif de PackR n’utilise que la JVM empaquetée avec l’application, il n’utilise pas la JVM du système, le programme est vu comme une application native par le système d’exploitation. PackR est un projet Java assez simple (sa documentation est ici), il ne supporte pas d’outil de build ou de système de build mais c’est très facile à implémenter en appelant sa classe principale. Ses principales limitations sont l’absence de conversion des icônes et l’absence d’intégration native dans le bureau sauf sous Mac OS X. En d’autres termes, c’est à la charge du développeur de fournir un fichier image dans le bon format pour chaque plateforme et c’est à l’utilisateur final de décompresser l’archive et de lancer l’exécutable. PackR laisse à la charge du développeur de faire le nécessaire pour fignoler le paquet de sorte qu’il devienne intuitif et dans un format familier pour l’utilisateur final. Je vous conseille de faire très attention aux droits d’exécution des executables et des bibliothèques natives en compressant le répertoire pour éviter un plantage du lanceur natif. Il n’affiche pas les traces d’exception, donc lancez directement le JAR en cas de problème avec le programme Java. PackR est open source (sous licence permissive). PackR takes in input a executable JAR (mandatory), a JDK (mandatory) and some other files (optional). It makes from those things a directory ready to get compressed containing all necessary files for the proper functioning of the program including a native launcher ready to be used which it isn’t necessary to recompile if it isn’t modified. It reads its options in a JSON file. Thus, it is possible to do a great part of the creation of a self-contained native application bundle without being under the target operating system. The native launcher of PackR uses only the JVM packaged with the application, it doesn’t use the JVM of the system, the program is seen as a native application by the operating system. PackR is a quite simple Java project (its documentation is here), it doesn’t support any build tool or build system but it’s very easy to implement by calling its main class. Its main limitations are the absence of icons conversion and its absence of native integration in the desktop except under Mac OS X. In other words, it’s up to the developer to provide an image file in the right format for each platform and it’s up to the end user to decompress the archive and run the executable. PackR makes the developer responsible for doing the necessary things to tweak the bunble so that it becomes intuitive and in a familiar format for the end user. I advise you to be very careful with the executable bit of the executables and the native libraries while compressing the directory to avoid a crash of the native launcher. It doesn’t display the exception traces, therefore run the JAR directly in case of a problem with the Java program. PackR is open source (under a permissive license).

JNDT


JNDT

JNDT prend pratiquement les mêmes entrées que PackR mais il va beaucoup plus loin. Tout d’abord, il se charge de convertir l’icône dans le bon format pour le système d’exploitation cible et il prend soin de préserver les droits d’exécution des fichiers qui en ont besoin. Ensuite, il peut utiliser le lanceur natif de PackR ou bien un script. Il dispose de très nombreuses options, il peut utiliser la JVM installée sur le système. JNDT est fourni sous forme d’un ensemble de cibles Ant. L’une d’elles a le même rôle que PackR. Les autres cibles Ant génèrent à la fois des paquets applicatifs natifs autonomes dans les formats courants pour les utilisateurs qui ont suffisament de droits sur leurs machines et des archives plus simples qui servent de solutions de repli pour chaque système d’exploitation et pour chaque architecture. JNDT takes almost the same inputs than PackR but it goes a lot further. At first, it deals with the conversion of the icon in the right format for the target operating system and it takes care to preserve the executable bit of the files that need it. Then, it can use the native launcher of PackR or a script. It has many options, it can use the JVM installed on the system. JNDT is provided as a set of Ant targets. One of them has the same role as PackR. The other Ant targets generate both the self-contained native application bundles in the popular formats for the users who have enough rights on their machines and some simpler archives that serve as fallbacks for each operating system and for each architecture.
Contrairement à JavaFX Ensemble, il n’utilise aucun outil dépendant de la plateforme. Par exemple, JNDT permet de créer un paquetage Debian sous Mac OS X, un paquet applicatif Mac OS X sous Windows voire un installeur Windows sous GNU Linux là où JavaFX Ensemble a absolument besoin d’un Mac pour créer un paquet applicatif Mac OS X. JNDT, tout comme PackR, contrairement à IzPack, est adapté à des installations très simples avec très très peu d’interactions avec l’utilisateur final dans le même esprit que Java Web Start mais malheureusement sans mécanisme de mise à jour automatique. JNDT respecte la philosophie de Java tout en offrant les avantages des paquets dépendants des plateformes : le développeur utilise le système d’exploitation de son choix pour travailler et l’utilisateur final dispose d’une application native dans un format familier qui ne lui demande pas de changer ses habitudes. JNDT est un logiciel libre faisant partie de Truly Unusual Experience of Revolution® sous GPL. Unlike JavaFX Ensemble, it doesn’t use any platform-dependent tool. For example, JNDT allows to create a Debian package under Mac OS X, a Mac OS X application package under Windows and even a Windows installer under GNU Linux whereas JavaFX Ensemble absolutely needs a Mac to create a Mac OS X application packet. JNDT, like PackR, unlike IzPack, is suitable for the very simple installations with a very little interactions with the end user in the same spirit as Java Web Start but unfortunately without a mechanism of automatic updates. JNDT respects the philosophy of Java while providing the benefits of platform-dependent packages: the developer uses the operating system of choice to work and the end user has a native application in a familiar format that doesn’t require him to change his ways. JNDT is a free software part of Truly Unusual Experience of Revolution® under the GPL.
JNDT prend un seul JAR en entrée, le JAR principal, grâce à l’attribut « appjar » mais il est possible de passer d’autres JARs grâce à l’attribut « resources ». Dans ce cas, vous devez renseigner l’attribut de manifeste « Class-Path » du JAR principal. Ainsi, JNDT supporte à la fois les JARs executables « tout en un » (aussi appelés « fat JARs« ) et les applications composées de plusieurs JARs. JNDT takes a single JAR in input, the main JAR, thanks to the attribute « appjar » but it is possible to pass some other JARs thanks to the attribute « resources ». In this case, you must set the manifest attribute « Class-Path » of the main JAR. Thus, JNDT supports both the « all in one » executable JARs (called « fat JARs » too) and the applications composed of several JARs.
JOGL utilise le chargement automatisé des bibliothèques natives par défaut, il ne repose pas sur le Java library path ou toute variable d’environnement dépendante de la plateforme pour trouver quelles bibliothèques natives à extraire et à charger. Vous pouvez désactiver ce mécanisme en utilisant l’argument de la VM suivant mais alors vous devez renseigner la propriété de la VM « java.library.path ». JOGL uses the automated native library loading by default, it doesn’t rely on the Java library path or on any platform-dependent environment variable to find which native libraries to extract from the JARs and to load. You can disable this mechanism by using the following VM argument but then you must set the VM property « java.library.path ».
-Djogamp.gluegen.UseTempJarCache=false
JNDT est composé de 4 cibles Ant :

  • create-app-dir : crée le répertoire de l’application, c’est-à-dire le répertoire contenant les fichiers nécessaires pour lancer l’application, son JAR, ses resources (optionnelles), le JRE (optionnel), le lanceur natif ou le script de lancement et les fichiers pour l’intégration native dans le bureau (l’icône, …)
  • create-linux-app-bundles : crée un paquetage RPM, un paquetage DEB et une archive tar.gz pour GNU Linux
  • create-os-x-app-bundle : crée un fichier APP compressé pour Mac OS X
  • create-windows-app-bundles : crée un installeur et une archive compressée de l’application pour Microsoft Windows
JNDT is composed of 4 Ant targets:

  • create-app-dir: creates the directory of the application, i.e the directory containing the necessary files to run the application, its JAR, its resources (optional), the JRE (optional), the native launcher or the launch script and the files for the native integration in the desktop (the icon, …)
  • create-linux-app-bundles: creates a RPM package, a DEB package and a tar.gz archive for GNU Linux
  • create-os-x-app-bundle: creates a compressed APP file for Mac OS X
  • create-windows-app-bundles: creates an installer and a compressed application archive for Microsoft Windows
Son code source est ici, ses dépendances sont ici, il y a un exemple d’utilisation ici et vous pouvez télécharger les paquets applicatifs natifs autonomes de mon jeu ici. Its source code is here, its dependencies are here, there is an example of use here and you can download the self-contained native application bundle of my game here.
Le fonctionnement de chaque cible Ant est documenté ici. The functioning of each Ant target is documented here.

Aide


Help

Vous pouvez obtenir de l’aide sur ce moteur sur le canal IRC de JogAmp, l’ancien canal IRC d’Ardor3D et sur le forum officiel de JogAmp. L’outil de suivi de bogues est ici. Vous pouvez me contacter en privé, mon adresse email est ici. Veuillez utiliser le forum officiel de JogAmp en priorité. Si vous demandez de l’aide sur StackOverflow, je vous demanderai systématiquement d’utiliser exclusivement les moyens précédemment cités à cet effet et il en sera de même pour les autres forums et salons de discussion hors de contrôle de la communauté JogAmp afin d’éviter certains débordements (diffamation, injures, dénigrement) et de permettre à toute la communauté de vous venir en aide sans avoir à s’inscrire partout. You can get some help on this engine on the JogAmp IRC channel, the previous Ardor3D IRC channel and on the official JogAmp forum. You can contact me in private, my email address is here. Please use the official JogAmp forum in priority. If you ask for help on StackOverflow, I will systematically ask you to use exclusively the previously cited means for this purpose and it will be the same for the other forums and chat rooms out of the control of the JogAmp community in order to avoid certain excesses (defamation, insults, disparagement) and to allow the community to help you without having to register everywhere.

Conclusion


Conclusion

Licence Creative Commons
La photo de cet article est mise à disposition selon les termes de la Licence Creative Commons Attribution – Pas d’Utilisation Commerciale – Pas de Modification 3.0 non transposé
Creative Commons License
The photo of this article is licensed under a Creative Commons Attribution-NonCommercial-NoDerivs 3.0 Unported License
Licence Creative Commons
Cet article est mis à disposition selon les termes de la Licence Creative Commons Attribution – Pas d’Utilisation Commerciale – Partage à l’Identique 3.0 non transposé
Creative Commons License
This article is licensed under a Creative Commons Attribution-NonCommercial-ShareAlike 3.0 Unported License
Auteur : Julien Gouesse Author: Julien Gouesse

A propos gouessej

Ingénieur en informatique, militant politique d'extrême-gauche, développeur de logiciels libres multi-plateformes. Engineer in computer science, far left-wing political activist, developer of free open source cross-platform softwares.
Cet article, publié dans Jeux vidéo, est tagué , , , , . Ajoutez ce permalien à vos favoris.

2 commentaires pour Ardor3D est mort, vive JogAmp’s Ardor3D Continuation [Ardor3D is dead, long life to JogAmp’s Ardor3D Continuation]

  1. Ping : Java 3D est de retour [Java 3D is back] | Blog de Julien Gouesse

  2. Ping : Truly Unusual Experience of Revolution®! 8 ans déjà! [Truly Unusual Experience of Revolution®! Already 8 years!] | Blog de Julien Gouesse

Les commentaires sont fermés.