Messages récents

Pages: [1] 2
1
Releases / Résumé de l'évolution du moteur (2013-2014)
« Dernier message par Lynix le janvier 12, 2015, 04:46:17 pm »
Avec un mois (et dix jours) de retard, Nazara fête ses trois ans.
Le moteur n'a pas autant évolué en 2014 qu'en 2013 pour plusieurs raisons:
  • Tout d'abord, la plus grosse partie du travail a été effectuée sur l'architecture du moteur, donnant lieu à une évolution importante mais invisible.
  • Ensuite cette année j'ai cumulé un autre projet (rémunéré) à côté qui a donc réduit mon temps libre.
  • Et pour finir, j'ai terminé l'année 2014 sur trois mois de dépression clinique pour des raisons personnelles, période durant laquelle Nazara était bien évidemment en pause.
Néanmoins le travail continue, et l'année qui vient de se terminer est la dernière année où le moteur était considéré comme inutilisable, je vais consacrer les prochaines semaines à rendre le moteur accessible (documentation, tutoriel) afin d'en faire un outil pratique pour vous. ;)

Résumé de l'évolution du moteur (2013-2014)


Le moteur dispose à ce jour de 8 modules.

  • NazaraAudio (Gestion du son)
  • NazaraCore (le noyau)
  • NazaraLua (Scripting Lua)
  • NazaraGraphics (Graphismes 2D et 3D)
  • NazaraNoise (Module de génération de bruits par OveRdrivR)
  • NazaraPhysics (Module de physique 3D en développement)
  • NazaraRenderer (Module de rendu OpenGL)
  • NazaraUtility (Module utilitaire, extension du noyau et fenêtrage)


Par rapport à l'année passée, aucun nouveau module n'a été rajouté, cependant le module de rendu a subi d'importantes révisions:
  • Le Deferred Shading est maintenant intégralement lié au module Graphique et n'a plus rien à voir avec le module de rendu
  • La gestion des shaders a été entièrement réécrite pour introduire les Über-Shaders (Qui remplacent l'affreux ShaderProgramManager)
Néanmoins de nouvelles fonctionnalités ont fait leur apparition:

Les particules (vidéos plus bas):



Les lancers de rayons (module mathématique):


Le retour de l'animation squelettique (vidéo plus bas):


Les atlas d'images:


Et dernièrement, le rendu de texte (vidéo anniversaire):



Les vidéos de développement publiées cette année-ci (Ordre chronologique):

Animations squelettiques (Intégration d'essai dans la démo House)
Premières particules (Démonstration des premières particules du moteur)
Cercles de feu (Démonstration plus poussée des particules)
Vidéo bonus pour l'anniversaire (Démonstration de l'affichage du texte)

Cette année-ci va être consacrée dans un premier temps au passage en beta (écriture du tutoriel et de la documentation) et à la révision de l'interface du moteur.
Après quoi, le moteur sera utilisé pour écrire de petits jeux d'exemples comme exemples d'utilisation.

J'ai aussi décidé cette année-ci de vous montrer de très nombreux screenshots pris durant le développement pouvant, éventuellement, en intéresser quelques-un.
Accessible sur ce topic.
2
Discussions / Screenshots de développement 2013-2014
« Dernier message par Lynix le janvier 12, 2015, 02:07:47 pm »
À l'occasion des trois ans du moteur, j'ai pensé partager avec vous une grande partie des screenshots de développement que j'envoie assez régulièrement à quelques contacts Skype. Ceux-ci montrent notamment des fonctionnalités en cours d'ajout, ou des bugs en cours de correction.

Les images présentées ici ne sont pas représentatives des capacités du moteur, beaucoup des fonctionnalités présentées sont intégrées et corrigées à l'heure actuelle.
De plus, les performances ont elles aussi été améliorées de façon significative.

Lien vers la galerie.
3
Discussions / Re : Problème sur la vidéo "House"
« Dernier message par Lynix le décembre 13, 2014, 11:30:46 am »
Bonjour,Désolé de la réponse extrêmement tardive.
J'ai déplacé ton sujet dans ce que j'imagine être le forum le plus approprié.


Quant aux feux, ce n'est pas un bug du moteur mais plutôt une mauvaise configuration de la scène, les feux clignotants sont créés grâce à des spots dirigés sur la voiture, ne leur laissant aucune chance d'éclairer la barrière (Cela est visible dans la vidéo, à partir de 1m17).



Merci de l'intérêt que tu portes à Nazara, ça fait toujours plaisir ;)


Bonne journée, si tu lis un jour ce message.
4
Discussions / Problème sur la vidéo "House"
« Dernier message par 666by le août 28, 2014, 08:40:37 pm »
Bonjour a vous,
J'ai entendu parler de votre projet sur progdupeupl et il m'a vraiment séduit, franchement bravo a vous tous.
J'ai remarquer quelque chose sur la vidéo "House": les feux de la voiture clignotent mais ils ne sont pas affichés sur la barrière juste derrière, je ne sais pas si c'est très important mais je tenais a vous le dire.
5
Releases / Résumé de l'évolution du moteur 2012-2013
« Dernier message par Lynix le décembre 02, 2013, 01:17:08 pm »
Résumé de l'évolution du moteur (2012-2013)


Le moteur dispose à ce jour de 8 modules.

  • NazaraAudio (Gestion du son)
  • NazaraCore (le noyau)
  • NazaraLua (Scripting Lua)
  • NazaraGraphics (Graphismes 2D et 3D)
  • NazaraNoise (Module de génération de bruits par OveRdrivR)
  • NazaraPhysics (Module de physique 3D en développement)
  • NazaraRenderer (Module de rendu OpenGL)
  • NazaraUtility (Module utilitaire, extension du noyau et fenêtrage)


Par rapport à l'année passée, le module 2D et le module 3D ont été réunis en un module Graphique.

Le Deferred Shading a été introduit dans le moteur, ainsi que des post-process (Bloom, FXAA, Fog)

Les vidéos de développement publiées cette année-ci (Ordre chronologique):

Terrains dynamiques (Démonstration du module DynaTerrain d'OveRdrivR)
Rendu 16 bits (Utilisation des RenderTexture)
First Scene (Nouvelle version)
House (Dernière démo démontrant le Deferred Shading, regardez-là avec un casque ou des écouteurs pour en profiter au maximum)

Le moteur est en train de passer en bêta, un tutoriel va bientôt être écrit sur progdupeupl (Et pour être honnête, si le site du zéro ne m'avait pas fait de mauvaise surprise, il serait là depuis un moment).

Pour me faire pardonner du retard, voici l'exécutable de la dernière démo pour que vous testiez chez vous.

Attention que cela nécessite une bonne carte graphique, la mauvaise architecture du ShaderManager fait qu'il est incapable d'initialiser le moteur avec OpenGL 2, chose qui sera corrigée je l'espère bien assez vite (Je dois refaire le ShaderManager).

Lien vers la démo:
http://nazara.digitalpulsesoftware.com/files/House.7z

Les contrôles sont calqués sur ceux que j'utilise dans Half-Life 2, à savoir:

ZQSD (ou flèches du clavier) : Déplacement
Maj : Courir
Ctrl: S'accroupir
F : Lampe torche
Souris : Orienter la caméra

Pour les bricoleurs:

F5: Activer/désactiver le FXAA
F6: Activer/désactiver le Bloom
F7: Activer/désactiver le brouillard

Numpad ".": Afficher les primitives d'éclairage
Numpad "0": Afficher les textures de travail
Numpad "1": Mode G-Buffer
Numpad "2": Mode Bloom
Numpad "4": Mode skin de la voiture

Utilisez les touches +/- du numpad pour changer les paramètres, selon le mode en cours

Si la démo ne se lance pas chez vous, ou plante, lancez le HardwareInfo.exe fournit dans l'archive et postez le rapport ici.
6
Tutoriaux / Re : Nazara Terrain - Tutoriel / Fonctionnement
« Dernier message par Overdrivr le mars 19, 2013, 03:52:21 pm »
Ce post sera dédié au fonctionnement interne du module, si vous êtes un simple utilisateur, il n'est pas indispensable de le lire mais ça peut clarifier des choses.

Quadtree

Gérer un maillage dynamique n'est pas spécialement compliqué, mais requiert un peu d'organisation. Comme certaines zones du terrain seront plus denses en triangles que d'autres, il faut un moyen de conserver en mémoire l'état du maillage, et de le modifier correctement lorsque c'est nécessaire.

Ici, la structure de données qui se prête bien au problème est un arbre de données, et plus précisément un arbre dont chaque noeud a systématiquement 4 enfants, c'est à dire un quadtree.

Par rapport à un simple tableau à deux dimensions, le quadtree possède plusieurs avantages :
  • Mieux profiter de la représentation spatiale (un node enfant est spatialement contenu dans son parent)
  • Implémentation très efficace de techniques de culling, et plus généralement d'algorithmes hiérarchiques
  • Représentation facile des données sur plusieurs niveaux différents

La logique derrière le terrain utilise donc un quadtree. Ici, le quadtree est composé d'une classe de centralisation (NzTerrainQuadTree) et d'un ensemble de noeuds (NzTerrainInternalNode).

Les noeuds les plus en bas de l'arbre, ceux qui n'ont pas d'enfants, sont ceux qui doivent communiquer avec le GPU afin que leur maillage soit dessiné.

Maillage atomique
Le maillage atomique représente le plus petit maillage constituant le terrain, un terrain entier peut être constitué de milliers de ce maillage atomique. Mon choix ici a été de choisir le maillage atomique suivant :



C'est un simple maillage carré constitué de 64 triangles. C'est un choix purement arbitraire, je tiens à le souligner. Parce que la gestion de ce maillage n'est pas triviale, la classe NzPatch est en charge de ces opérations

NzPatch
Chaque NzInternalNode possède un pointeur vers un NzPatch. Lorsqu'un NzInternalNode est au plus bas de l'arbre (on l'appelle aussi un node feuille), ce pointeur est initialisé de manière à être valide. Cette action entraîne à son tour l'initialisation d'un NzPatch, qui effectue diverses opérations sur le maillage atomique (récupération de la hauteur de chaque point, calcul des normales, etc.). Ce maillage est transmis à une classe spécialisée, et en bout de chaîne, ce maillage est uploadé sur le GPU, et affiché.

NzInternalNode ne gère donc absolument pas de maillage, il se contente d'initialiser un NzPatch au bon moment.

Logique vs Affichage
Autant que possible, j'ai essayé de découpler la partie logique de l'affichage, ce qui explique ce qui va suivre.

Contrairement à ce que vous pouvez penser, le quadtree dont je viens de vous parler n'est pas celui que l'on va utiliser pour effectuer les appels au rendu, le culling, etc. Pourquoi ?

Rappelez vous que les maillages atomiques, une fois préparés, ont besoin d'être chargés dans un buffer et uploadés sur le GPU. Avec une utilisation directe de ce quadtree, on n'a pas le choix, il faut un buffer par node, ce buffer contenant donc un seul maillage atomique.

Si notre arbre est un minimum profond par endroits, on atteint facilement 50000 nodes au total, donc 50000 buffers, et à chaque frame une boucle de 50000 nodes à parcourir. Sur nos processeurs modernes, c'est une rigolade, mais ce chiffre augmente exponentiellement lorsque la profondeur de l'arbre augmente. De plus, l'allocation et la désallocation de mémoire sur le GPU prend du temps, si il faut allouer quelques centaines de buffers GPU par seconde les performances vont en prendre un coup.

J'ai donc choisi d'utiliser une autre technique. Chaque NzPatch, après effectué ses tâches, transmet par référence constante son maillage à la classe NzTerrainMasterNode. Je ne détaillerais pas son fonctionnement interne dans ce post, mais sachez que cette fois-ci les maillages sont regroupés par lots, dans des buffers dont la taille est choisie manuellement à l'initialisation.

Au lieu de 50000, on passe à 25 buffers, et surtout le fait d'augmenter la précision du terrain ne demandera d'allouer que quelques buffers supplémentaires...

Le prochain post sera dédié à l'interfaçage avec le manager de scène.
7
Tutoriaux / Nazara Terrain - Tutoriel / Fonctionnement
« Dernier message par Overdrivr le mars 15, 2013, 10:15:22 am »
Nazara Terrain

Comme son nom l'indique, ce module permet de mettre en place et d'utiliser un terrain dans vos applications Nazara, de manière simple et haut niveau.

Ce module a un comportement dynamique, c'est à dire que le maillage du terrain généré peut être mis à jour en temps réel, de manière à conserver une précision maximale autour de la caméra, et à réduire cette précision au fur et à mesure que la distance à la caméra augmente.

http://www.youtube.com/watch?v=Mm2pXM0SeWA

En tant qu'utilisateur, vous avez accès à de multiples paramètres afin de configurer finement la qualité visuelle du terrain ainsi que ses performances. Une classe de configuration vous aide dans cette tâche, et possède également une configuration par défaut, permettant aux utilisateurs débutants de sauter entièrement cette étape.

Ce module essaye autant que possible de profiter des techniques de génération procédurales, capables de générer à la volée un terrain entier. Cela consiste tout simplement à utiliser des fonctions mathématiques capables de simuler l'aspect d'un terrain, qui renvoient pour deux coordonnées (x,y) la hauteur du terrain en ce point. De telles fonctions sont implémentées dans le module Nazara Noise.

L'utilisation de techniques procédurales n'étant incompatible avec l'utilisation de données éditées manuellement, a terme le système sera capable d'importer des heightmaps qui remplaceront localement les hauteurs calculées procéduralement.

Hello world !
Pour fonctionner correctement, le module a avant tout besoin de connaitre les hauteurs du terrain en tout point. Si vous débutez avec ce module, vous pouvez utiliser une classe prête à l'emploi à l'adresse NazaraEngine-master/examples/dynaterrain/MyHeightSource2D.hpp et MyHeightSource2D.cpp. Il vous suffit de rajouter ces deux fichiers à votre projet comme n'importe quelle autre classe perso.

Bonne nouvelle, votre projet est prêt à accueillir un terrain !

#include <Nazara/DynaTerrain/DynamicTerrain.hpp>
#include <Nazara/DynaTerrain/TerrainConfiguration.hpp>
#include "MyHeightSource2D.hpp"


On inclue les fichiers nécessaires au terrain.

int main()
{
    NzScene scene;

    // On instancie notre source de hauteur personnalisée (la classe récupérée dans examples/dynaterrain)
    MyHeightSource2D source2;
    //On créé notre configuration, on n'y touche pas pour l'instant, on utilise celle par défaut
    NzTerrainConfiguration myConfig;
    //On créé le terrain, on lui affecte la source de hauteur et sa configuration
    NzDynamicTerrain terrain(myConfig,&source2);
    //Et on l'initialise
    terrain.Initialize();
    //Et on l'attache à la scène
    terrain.SetParent(scene);


Et dans la boucle principale, afin que le terrain soit mis à jour en temps réel :
terrain.Update(camera.GetTranslation());
Le rendu est quand à lui provoqué par la scène, vous n'avez pas à vous en soucier.

Le code complet est donc le suivant :
#include <Nazara/3D.hpp>
#include <Nazara/Renderer/Renderer.hpp>
#include <Nazara/DynaTerrain/DynamicTerrain.hpp>
#include <Nazara/DynaTerrain/TerrainConfiguration.hpp>
#include "MyHeightSource2D.hpp"
#include <iostream>

using namespace std;

int main()
{
NzContextParameters::defaultCompatibilityProfile = true;
NzInitializer<Nz3D> nazara;
if (!nazara)
{
std::cout << "Failed to initialize Nazara, see NazaraLog.log for further informations" << std::endl;
std::getchar();
return EXIT_FAILURE;
}
    NzScene scene

    MyHeightSource2D source2;
    NzTerrainConfiguration myConfig;
    NzDynamicTerrain terrain(myConfig,&source2);
    terrain.Initialize();
    terrain.SetParent(scene);


    ///Code classique pour ouvrir une fenêtre avec Nazara
    NzString windowTitle("DynaTerrain example");
    NzRenderWindow window(NzVideoMode(800,600,32),windowTitle,nzWindowStyle_Default);
    window.SetFramerateLimit(100);
    NzRenderer::SetMatrix(nzMatrixType_Projection, NzMatrix4f::Perspective(NzDegrees(70.f), static_cast<float> (window.GetWidth())/window.GetHeight(), 1.f, 100000.f));

    NzClock secondClock, updateClock; // Des horloges pour gérer le temps
    unsigned int fps = 0; // Compteur de FPS
    NzMatrix4f matrix;
    matrix.MakeIdentity();
    NzRenderer::SetMatrix(nzMatrixType_View, NzMatrix4f::LookAt(NzVector3f(0.f,0.f,0.f), NzVector3f::Forward()));

    // Notre caméra
    NzVector3f camPos(-2000.f, 1800.f, 2000.f);
    NzEulerAnglesf camRot(-30.f, -45.f, 0.f);

    NzNode camera;
    camera.SetTranslation(camPos);
    camera.SetRotation(camRot);

    float camSpeed = 80.f;
    float sensitivity = 0.2f;

    // Quelques variables
    bool camMode = true;
    window.SetCursor(nzWindowCursor_None);
    bool windowOpen = true;
    bool drawWireframe = false;
    bool terrainUpdate = true;

    while (windowOpen)
    {
NzEvent event;
while (window.PollEvent(&event))
        {
switch (event.type)
{
case nzEventType_Quit:
windowOpen = false;
break;

case nzEventType_MouseMoved:
{
// Si nous ne sommes pas en mode free-fly, on ne traite pas l'évènement
if (!camMode)
break;

camRot.yaw = NzNormalizeAngle(camRot.yaw - event.mouseMove.deltaX*sensitivity);
camRot.pitch = NzClamp(camRot.pitch - event.mouseMove.deltaY*sensitivity, -89.f, 89.f);

camera.SetRotation(camRot);
NzMouse::SetPosition(window.GetWidth()/2, window.GetHeight()/2, window);
break;
}

case nzEventType_MouseButtonPressed:
if (event.mouseButton.button == NzMouse::Left)
{
if (camMode)
{
camMode = false;
window.SetCursor(nzWindowCursor_Default);
}
else
{
camMode = true;
window.SetCursor(nzWindowCursor_None);
}
}
                                break;
case nzEventType_Resized:
NzRenderer::SetViewport(NzRectui(0, 0, event.size.width, event.size.height));
NzRenderer::SetMatrix(nzMatrixType_Projection, NzMatrix4f::Perspective(NzDegrees(70.f), static_cast<float>(event.size.width)/event.size.height, 1.f, 10000.f));
break;

        case nzEventType_KeyPressed:
{
switch (event.key.code)
{
case NzKeyboard::Escape:
windowOpen = false;
break;

case NzKeyboard::F1:
if (drawWireframe)
{
drawWireframe = false;
NzRenderer::SetFaceFilling(nzFaceFilling_Fill);
}
else
{
drawWireframe = true;
NzRenderer::SetFaceFilling(nzFaceFilling_Line);
}
break;

                        case NzKeyboard::F2:
                                 terrainUpdate = !terrainUpdate;
                                 break;

default:
        break;
}

break;
}

default:
break;
}
}

// Mise à jour de la partie logique
if (updateClock.GetMilliseconds() >= 1000/60) // 60 fois par seconde
{
float elapsedTime = updateClock.GetSeconds();

static const NzVector3f forward(NzVector3f::Forward());
static const NzVector3f left(NzVector3f::Left());
static const NzVector3f up(NzVector3f::Up());

float speed2 = (NzKeyboard::IsKeyPressed(NzKeyboard::Key::LShift)) ? camSpeed*7: camSpeed;
                NzVector3f speed(speed2,speed2,speed2);

if (NzKeyboard::IsKeyPressed(NzKeyboard::Z))
camera.Translate(forward * speed * elapsedTime);

if (NzKeyboard::IsKeyPressed(NzKeyboard::S))
camera.Translate(-forward * speed * elapsedTime);

if (NzKeyboard::IsKeyPressed(NzKeyboard::Q))
camera.Translate(left * speed * elapsedTime);

if (NzKeyboard::IsKeyPressed(NzKeyboard::D))
camera.Translate(-left * speed * elapsedTime);

// En revanche, ici la hauteur est toujours la même, peu importe notre orientation
if (NzKeyboard::IsKeyPressed(NzKeyboard::Space))
camera.Translate(up * speed * elapsedTime, nzCoordSys_Global);

if (NzKeyboard::IsKeyPressed(NzKeyboard::LControl))
camera.Translate(up * speed * elapsedTime, nzCoordSys_Global);

updateClock.Restart();
}

        camera.Activate();
scene.Update();
scene.Cull();
scene.UpdateVisible();

        //On met à jour le terrain
        if(terrainUpdate)
        {
            terrain.Update(camera.GetTranslation());
        }

        // Nous mettons à jour l'écran
window.Display();

fps++;

// Toutes les secondes
if (secondClock.GetMilliseconds() >= 1000)
{
window.SetTitle(windowTitle + " (FPS: " + NzString::Number(fps) + ')' + "( Camera in : " + camera.GetTranslation() + ")");
fps = 0;
secondClock.Restart();
}
   }

    return 0;
}
8
Projets / Re : Première Démo Nazara
« Dernier message par Lynix le février 06, 2013, 10:05:32 pm »
C'est en effet une bonne idée, une démo combinant tout.

Pour reprendre tes questions, dans l'ordre:
1) Faire une petite application peut montrer quelque chose de sympa de Nazara, sans pour autant devoir pousser le moteur à ses limites (Qui n'ont d'ailleurs pas encore été établies).
2) Il faut voir ça après avoir donné la liste des choses contenues dans la démo
3) Je ne pense pas que cela soit tellement plus parlant, sauf pour certaines fonctionnalités bien spécifiques (Réseau, Culling, Instancing, etc ..)
9
Projets / Première Démo Nazara
« Dernier message par Overdrivr le février 06, 2013, 11:41:28 am »
    Depuis quelque temps, Nazara avance à bon train, et le noyau dur a déjà de nombreuses fonctionnalités même si il reste beaucoup de travail. Je pense néanmoins qu'il serait intéressant de faire une première démo. Alors comme l'indique le titre, que pourrait t'on mettre dedans ?

    De mon côté, je pense avoir suffisamment avancé dans le module de terrain pour avoir un prototype fonctionnel d'ici peu. Je dois aussi essayer, courant de la semaine prochaine, de modifier le code pour qu'il gère aussi des planètes/astéroïdes.

    Avec Noise, je suis parvenu à générer des fonds étoilés assez crédibles, ainsi qu'un sprite animé de soleil.

    Si on combine tout ça, on pense évidemment à un explorateur spatial basique.

    Si à ça on rajoute quelques modèles, avec de l'éclairage, et un peu de scripting lua, ça peut produire quelque chose d'intéressant.

    Les questions que je me pose sont les suivantes :
    • Est-ce que ça fera vraiment la démonstration des capacités de Nazara ?
    • Que peut-on rajouter qui ne demande pas de passer des mois sur la démo ?
    • Ne vaudrait t'il mieux pas faire une démo de chaque fonctionnalité ?
10
Releases / Résumé de l'évolution du moteur 2011-2012
« Dernier message par Lynix le décembre 02, 2012, 07:43:25 pm »

Résumé de l'évolution du moteur (2011-2012)
Étant donné qu'il s'agit de la première année, que dire ? Il est difficile de comparer avec l'année précédente :P .

Alors pour commencer, le moteur dispose aujourd'hui de 6 modules :
  • Nazara3D (Module du moteur 3D, en développement)
  • NazaraAudio (Module de sons, fonctionnel)
  • NazaraCore (Le noyau, la base de tout module, stable)
  • NazaraNoise (Module de génération de bruits par OveRdrivR, stable)
  • NazaraRenderer (Module de rendu OpenGL, stable)
  • NazaraUtility (Module utilitaire, stable)
À ces modules intégrés vont se rajouter prochainement :
  • Nazara2D (Module du moteur 2D, développement en attente)
  • NazaraNetwork (Module réseau par Fraggy, en développement)
À noter qu'OveRdrivR travaille sur un module de terrains exploitant son module de générations de bruits.

Les vidéos de développement publiées (Ordre chronologique) :
Première animation squelettique
Le skinning
Vidéo sur la démo AnimatedMesh

J'en profite pour vous mettre au courant de la suite, qui concerne l'éclairage (À commencer par le forward lighting et ensuite le deferred lighting) :)
Une démo devrait également arriver entre-temps pour montrer les animations squelettiques.

Des discussions en interne se font également pour promouvoir l'arrivée d'un SDK, ainsi que d'un premier jeu basé utilisant Nazara.
Et bien sur, le plus important, Nazara devrait passer en beta (Stabilisation du moteur, tutoriaux pour l'utilisation, documentation) dans les prochains mois :)

Bon anniversaire Nazara :D
Pages: [1] 2