Interfaces et OpenSceneGraph

J'ai ressorti quelques vieux bouts de code qui combinent OpenSceneGraph et wxWidgets, et je les ai dépoussiérés en utilisant la bonne vieille wxAui pour permettre de docker et de faire flotter les composants d'interface autour de la fenêtre graphique. Tout cela marche plutôt bien, et en voici quelques captures d'écran, avec un arbre docké, puis flottant:




La combinaison des évênements wxWidgets avec ceux d'OpenSceneGraph marche très bien, et permet de gérer efficacement la navigation à la souris et au clavier dans la fenêtre graphique. Le rafraîchissement se fait dans l'événement OnIdle, ce qui fonctionne plutôt bien: le rendu se fait aussi vite que possible, mais les autres composants de l'interface sont fluides.

J'attends également avec impatience le support de de l'anti-crénelage, qui devrait apparaître normalement dans wxWidgets 2.9.

Rails et routes

J'ai passé un peu de temps à chercher à comment modéliser des routes et des rails, et j'ai trouvé un post très intéressant ici. Ça cause courbes de Bézier et arcs de cercle, et j'ai déjà commencé à gribouiller quelques feuilles pour tenter de gérer mes courbes.

A voir également, la manière dont Cities XL gère la chose, s'affranchissant complètement (du moins en apparence) des grilles.

À ruminer!

Enfin, le bump mapping!

C'est avec l'aide de cette page, de nombreuses simplifications, et beaucoup de bidouillages, que j'ai enfin réussi à faire du bump mapping qui ressemble à quelque chose.

L'ensemble de la scène est assez complexe.

• Tout d'abord, il y a l'élévation, générée à partir d'une texture, au niveau du vertex shader


• Ensuite, il y a l'ombrage général de la scène, généré également avec une texture, mais au niveau du fragment


• Ensuite, il y a le calcul de la tangente, au niveau du vertex shader, qui est ensuite passée au fragment pour générer le bump mapping, à la fois en diffus, et en reflets, pour donner les effets "mouillés"

L'ensemble tourne à un très correct 1700 images par secondes en 1280x1024 plein écran.






Dans la dernière image, la couleur diffuse est en rose, afin que les reflets soient encore plus visibles.

La gueulante du jour

Mais pourquoi les commits sur SourceForge sont-ils si lents???

De une à deux secondes par fichier, c'est pas la mer à boire, mais quand on veux commiter souvent, on a l'impression de passer sa vie à attendre que le serveur daigne répondre.

Ça me dépasse.

Mount & Blade - Rebelle

Cette enflure de King Harlaus ayant refusé de me donner un château que je venais de conquérir, je lui ai dit d'aller se mettre son royaume là où le soleil de brille pas, et je suis passé rebelle.

La déception, c'est que sans l'utilisation des mods, la partie devient assez injouable. En effet, il devient impossible d'aller un tout petit peu loin sans se retrouver avec la moitié du monde attaquant nos châteaux. L'on se retrouve donc principalement à crapahuter entre ses différents fiefs, à recruter dans les villages voisins, chasser les armées belliqueuses, et se battre contre les gardes pour entrer dans les villes et y vendre sa camelote.

Avec du temps, j'imagine qu'il est possible de correctement remplir ses châteaux, et donc espérer les voir résister à de plus grands assauts, mais il faut alors payer sa gigantesque armée, ce qui est loin d'être évident.

Peut-être vais-je essayer le mod de "gestion de royaume", alors.

Cellules sélectionnées d'une wxGrid

J'ai bien cru péter un plomb! J'ai une wxGrid, et je veux savoir quelles sont les cellules sélectionnées. Quelque soit la méthode que j'utilise (GetSelectionBlockTopLeft / GetSelectionBlockBottomRight, GetSelectedCells, GetSelectedRows, GetSelectedCols), il m'en manquait toujours.

Tombant finalement sur le rapport de bug de chez wxWidgets, l'explication est arrivée: pour des raisons d'optimisation mémoire, différentes structures seront maintenues en fonction de la manière dont on sélectionne. Par exemple, lorsque l'on sélectionne une colonne entière, la grille gardera juste l'index de la colonne, lorsque l'on sélectionne un bloc, la grille sauvera le coin en haut à gauche et le coin en bas à droite, etc. Ce qui veux dire en fait qu'il faut utiliser les 4 méthodes pour trouver l'ensemble des sélections!

Cela donne quelque chose d'un peu comme ça:

std::set<std::pair<int, int> > getGridSelection(wxGrid & grid)
{
  std::set<std::pair<int, int> > selection;

  wxGridCellCoordsArray topLeft = grid.GetSelectionBlockTopLeft();
  wxGridCellCoordsArray bottomRight = grid.GetSelectionBlockBottomRight();
  for(size_t i = 0; i < std::min(topLeft.GetCount(), bottomRight.GetCount()); i++)
  {
    for(int row = topLeft.Item(i).GetRow(); row <= bottomRight.Item(i).GetRow(); row++)
    {
      for(int col = topLeft.Item(i).GetCol(); col <= bottomRight.Item(i).GetCol(); col++)
      {
        selection.insert(std::make_pair(row, col));
      }
    }
  }

  wxGridCellCoordsArray cellSelection = grid.GetSelectedCells();
  for(size_t i = 0; i < cellSelection.GetCount(); i++)
  {
    selection.insert(std::make_pair(cellSelection.Item(i).GetRow(), cellSelection.Item(i).GetCol()));
  }

  wxArrayInt selectedRows = grid.GetSelectedRows();
  for(size_t i = 0; i < selectedRows.GetCount(); i++)
  {
    for(int col = 0; col < grid.GetNumberCols(); col++)
    {
      selection.insert(std::make_pair(selectedRows.Item(i), col));
    }
  }

  wxArrayInt selectedCols = grid.GetSelectedCols();
  for(size_t i = 0; i < selectedCols.GetCount(); i++)
  {
    for(int row = 0; row < grid.GetNumberRows(); row++)
    {
      selection.insert(std::make_pair(row, selectedCols.Item(i)));
    }
  }  

  return selection;
}

De retour sur le trading

Ma phase corporate étant passée, je laisse Médoc de côté (en tant que développeur, car en tant qu'utilisateur, je continue à faire chauffer le chameau!), et je retourne à mon module de trading. J'espère bientôt pouvoir sortir une démo, même si le problème de l'hébergement va se poser de plus en plus.