Vous êtes nouveau sur Developpez.com ? Créez votre compte ou connectez-vous afin de pouvoir participer !

Vous devez avoir un compte Developpez.com et être connecté pour pouvoir participer aux discussions.

Vous n'avez pas encore de compte Developpez.com ? Créez-en un en quelques instants, c'est entièrement gratuit !

Si vous disposez déjà d'un compte et qu'il est bien activé, connectez-vous à l'aide du formulaire ci-dessous.

Identifiez-vous
Identifiant
Mot de passe
Mot de passe oublié ?
Créer un compte

L'inscription est gratuite et ne vous prendra que quelques instants !

Je m'inscris !

Ion : un ensemble d'outils pour les applications graphiques

Le , par LittleWhite

0PARTAGES

4  1 
Ion est un ensemble d'outils pour la création d'applications et spécifiquement d'applications graphiques. L'ensemble se veut léger, robuste et multiplateforme. Grâce à Ion, vous pouvez produire des applications pour PC (Windows, Linux, Mac), pour mobiles, pour le Web ou encore pour l'embarqué.
Voici une liste de ses caractéristiques :

  • léger : la taille des binaires est généralement inférieure à 500 Ko ;
  • puissant : fournit des outils pour augmenter votre productivité ;
  • efficace : les outils apportent des aides pour la gestion de vie des objets, de la mémoire, le multithreading et permet même l'instrumentation en temps réel ;
  • robuste : les tests couvrent 100 % du code ;
  • avec, vous pouvez analyser des scènes graphiques, tracer les appels OpenGL, éditer les shaders à la volée ;


Ces outils sont utilisés par plusieurs équipes chez Google.

Si vous voulez tester et que vous clonez le projet, n'oubliez pas de cloner les submodules :
git submodule update --init --recursive
Cela permet d'avoir toutes les dépendances, notamment gyp, l'outil pour compiler le projet.

Prévoyez aussi du temps et de l'espace disque (1,2 Go pour le clone du projet) pour compiler l'intégralité du projet. De nombreuses dépendances le composent :
  • away3d_examples_broomstick : exemples d'ActionScript à utiliser avec le moteur Away3D ;
  • FreeGLUT : OpenGL Utility Toolkit (ouverture de fenêtres, gestion des périphériques...) ;
  • freetype2 : affichage de polices de caractères ;
  • googletest : framework de tests ;
  • gyp : système de compilation ;
  • harfbuzz : mise en forme de texte ;
  • icu : support de l'Unicode ;
  • image_compression : support des formats d'images compressés spécifiques aux GPU (DXT, ETC et PVRTC) ;
  • jsoncpp : analyseur de JSON ;
  • lodepng : support du PNG ;
  • noto_cjk : polices de caractères ;
  • noto_fonts : polices de caractères ;
  • omaha : version open source de Google update;
  • stblib : bibliothèques dans le domaine public liées aux jeux vidéo ;
  • tracing_framework : ensemble de bibliothèques pour le rendu Web complexe ;
  • webfonts : polices de caractères de Google ;
  • zlib : bibliothèque pour la compression.


Ion est publié sous licence Apache 2.0

Votre opinion

L'avez-vous testé ? Qu'en pensez-vous ?

Source

GitHub

Une erreur dans cette actualité ? Signalez-le nous !

Avatar de LittleWhite
Responsable 2D/3D/Jeux https://www.developpez.com
Le 11/02/2016 à 19:09
Personnellement, hier soir, j'ai voulu compiler le projet. Je n'ai pas réussi (erreur de compilation) et du coup j'ai abandonné (bouuuhh). Je suis trop "un produit publié doit marcher directement, surtout pour la phase compilation". Autrement dit, un TP qui compile pas, c'est 0 à l'école (enfin, pour moi).
J'ai regardé dans le dossier "demos" :
Code : Sélectionner tout
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
/**
Copyright 2016 Google Inc. All Rights Reserved.
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
    http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS-IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/

// This is not a unit test - it uses OpenGL to render an ion scene graph in a
// window.

#include "ion/demos/demobase.h"
#include "ion/gfx/graphicsmanager.h"
#include "ion/gfx/node.h"
#include "ion/gfx/renderer.h"
#include "ion/gfx/shaderinputregistry.h"
#include "ion/gfx/shape.h"
#include "ion/gfx/statetable.h"
#include "ion/gfx/uniform.h"
#include "ion/gfxutils/shapeutils.h"
#include "ion/math/matrix.h"
#include "ion/math/range.h"
#include "ion/math/vector.h"

using ion::math::Point2i;
using ion::math::Point3f;
using ion::math::Range2i;
using ion::math::Vector2i;
using ion::math::Vector4f;
using ion::math::Matrix4f;

namespace {

//-----------------------------------------------------------------------------
//
// Scene graph construction.
//
//-----------------------------------------------------------------------------

static const ion::gfx::NodePtr BuildRectangle(const Point3f& center,
                                              const Vector4f& color) {
  const ion::gfx::ShaderInputRegistryPtr& global_reg =
      ion::gfx::ShaderInputRegistry::GetGlobalRegistry();

  ion::gfx::NodePtr node(new ion::gfx::Node);
  node->AddUniform(global_reg->Create<ion::gfx::Uniform>("uBaseColor", color));

  ion::gfxutils::RectangleSpec rect_spec;
  rect_spec.vertex_type = ion::gfxutils::ShapeSpec::kPosition;
  rect_spec.translation = center;
  node->AddShape(ion::gfxutils::BuildRectangleShape(rect_spec));
  return node;
}

static const ion::gfx::NodePtr BuildGraph(int width, int height) {
  const ion::gfx::ShaderInputRegistryPtr& global_reg =
      ion::gfx::ShaderInputRegistry::GetGlobalRegistry();

  const Matrix4f proj(1.515f, 0.0f, 0.0f, 0.0f,
                      0.0f, 1.732f, 0.0f, 0.0f,
                      0.0f, 0.0f, -1.905f, -13.798f,
                      0.0f, 0.0f, -1.0f, 0.0f);
  const Matrix4f view(1.0f, 0.0f, 0.0f, 0.0f,
                      0.0f, 1.0f, 0.0f, 0.0f,
                      0.0f, 0.0f, 1.0f, -5.0f,
                      0.0f, 0.0f, 0.0f, 1.0f);

  ion::gfx::NodePtr root(new ion::gfx::Node);
  root->AddUniform(global_reg->Create<ion::gfx::Uniform>("uProjectionMatrix",
                                                         proj));
  root->AddUniform(global_reg->Create<ion::gfx::Uniform>("uModelviewMatrix",
                                                         view));
  // Set up global state.
  ion::gfx::StateTablePtr state_table(new ion::gfx::StateTable(width, height));
  state_table->SetViewport(
      Range2i::BuildWithSize(Point2i(0, 0), Vector2i(width, height)));
  state_table->SetClearColor(Vector4f(0.3f, 0.3f, 0.5f, 1.0f));
  state_table->SetClearDepthValue(1.f);
  state_table->Enable(ion::gfx::StateTable::kDepthTest, true);
  state_table->Enable(ion::gfx::StateTable::kCullFace, true);
  root->SetStateTable(state_table);

  // Yellow rect on left.
  root->AddChild(BuildRectangle(Point3f(-0.6f, 0.0f, 0.0f),
                                Vector4f(0.8f, 0.8f, 0.2f, 1.0f)));

  // Red rect on right.
  root->AddChild(BuildRectangle(Point3f(0.6f, 0.0f, 0.0f),
                                Vector4f(0.9f, 0.3f, 0.2f, 1.0f)));

  return root;
}

}  // anonymous namespace

//-----------------------------------------------------------------------------
//
// IonSimpleDraw class.
//
//-----------------------------------------------------------------------------

class IonSimpleDraw : public DemoBase {
 public:
  IonSimpleDraw(int width, int height)
      : width_(width),
        height_(height) {
    graphics_manager_.Reset(new ion::gfx::GraphicsManager);
    renderer_.Reset(new ion::gfx::Renderer(graphics_manager_));
    root_ = BuildGraph(width, height);
  }
  ~IonSimpleDraw() override {}

  void Resize(int width, int height) override {
    DCHECK(root_->GetStateTable().Get());
    root_->GetStateTable()->SetViewport(
        Range2i::BuildWithSize(Point2i(0, 0), Vector2i(width, height)));
    width_ = width;
    height_ = height;
  }
  void Render() override {
    renderer_->DrawScene(root_);
  }
  void Update() override {}
  void Keyboard(int key, int x, int y, bool is_press) override {}
  void ProcessMotion(float x, float y, bool is_press) override {}
  void ProcessScale(float scale) override {}
  std::string GetDemoClassName() const override { return "IonSimpleDraw"; }

 private:
  ion::gfx::GraphicsManagerPtr graphics_manager_;
  ion::gfx::RendererPtr renderer_;
  ion::gfx::NodePtr root_;
  ion::gfx::NodePtr plane_particles_;
  int width_;
  int height_;
};

DemoBase* CreateDemo(int w, int h) {
  return new IonSimpleDraw(w, h);
}
Cela ressemble à un moteur comme un autre, avec un SceneGraph et les classes/structures habituelles. Après, pour les bidouilleurs, j'aurai du mal à leur conseiller, je ne vois pas de documentation.
Voilà mon avis actuel, mais on peut dire que je suis fautif de ne pas m'y plonger plus .

Note : ceci n'est pas un produit officiel Google.
1  0 
Avatar de
https://www.developpez.com
Le 11/02/2016 à 23:39
Citation Envoyé par cuicui78 Voir le message
Sinon, je suis surprit de la taille supposé d'un binaire. 500 ko, avec autant de dépendances ?

ou alors c'est 500 ko pour le binaire sans les 500 mo de dll
C'est une blague ? Le principe des dll, c'est justement de les avoir une seule fois pour tous les programmes et donc d'alléger les binaires. Cela dit, la lib compile aussi en statique (et dans ce cas, les binaires des exemples fournis font entre 700ko et 9mo).

Sinon, la bibliothèque manque effectivement cruellement de finalisation : j'ai dû modifier quelques lignes dans les fichiers de config projet pour que ça compile, certains exemples ont des shaders erronés et je n'ai pas trouvé de doc non plus...
1  0 
Avatar de matthius
Inactif https://www.developpez.com
Le 11/02/2016 à 6:55
Après la version 1.4 de Angular JS, sortie après la version 1.4 de Lazarus, Google sort un concurrent à Zengl.org juste avant la sortie de Lazarus 1.6.

Vive Lazarus et Code Typhon qui peut utiliser les librairies Java !
1  1 
Avatar de Aiekick
Membre extrêmement actif https://www.developpez.com
Le 11/02/2016 à 10:48
Citation Envoyé par matthius Voir le message
Après la version 1.4 de Angular JS, sortie après la version 1.4 de Lazarus, Google sort un concurrent à Zengl.org juste avant la sortie de Lazarus 1.6.
Vive Lazarus et Code Typhon qui peut utiliser les librairies Java !
quel rapport avec la news ?

Sinon, je suis surprit de la taille supposé d'un binaire. 500 ko, avec autant de dépendances ?

ou alors c'est 500 ko pour le binaire sans les 500 mo de dll
0  0 
Avatar de matthius
Inactif https://www.developpez.com
Le 11/02/2016 à 11:28
Le rapport est que vous pouvez aussi utiliser Zeng GL ou toute librairie 3D Pascal en lien.
Les exécutables Lazarus sont effectivement lourds, pour l'instant.
Par contre, il n'est pas dit que cette librairie soit gardée par Google.
0  0 
Avatar de BufferBob
Expert éminent https://www.developpez.com
Le 11/02/2016 à 18:13
Citation Envoyé par LittleWhite Voir le message
L'avez-vous testé ? Qu'en pensez-vous ?
j'ai pas testé mais j'aimerai bien avoir des retours effectivement, notamment j'ai du mal à me représenter ce que je vais pouvoir trouver dans ce package bouffi comme logiciels concrètement, est-ce que c'est résolument des outils pour les professionnels ? est-ce que ce sont des outils qui ne visent que la productivité finalement ? est-ce qu'en tant que codouilleur dans mon coin, éventuellement débutant dans le dev 2D/3D et les jeux ça va m’être utile ?
0  0 
Avatar de Aiekick
Membre extrêmement actif https://www.developpez.com
Le 12/02/2016 à 18:04
je juge la taille d'une application sur l'ensemble de la place qu'elle prend sur disque.
pas juste la taille du binaire principal et de plus dans le cas ou l'app est packagé comme les apk android, je me demande quelle taille on cible.

je doute sérieusement des 500 ko pour un apk utilisant le ndk avec autant de dependances
0  0 
Avatar de born to code
Nouveau membre du Club https://www.developpez.com
Le 11/02/2016 à 14:42
Encore, va-t-on se demander ou l'on va avec tant de nouveautes...
0  1