Windmill : moteur graphique 3D - PARTAGE DES SOURCES
Posté le 30/09/2016 00:44
Windmill
Bonjour, bonsoir !
Windmill est un moteur graphique 3D pour calculatrices CASIO monochromes.
Ce topic est le journal de bord du projet, il décrit l'avancée étape par étape, jour par jour, depuis la création du projet à aujourd'hui.
Début du projet : juillet 2016
Dernière mise à jour : mars 2019
Dernière démo : jour 22
Un petit brief d'abord :
Windmill est un moteur graphique 3D, il est capable d'afficher des objets définis en trois dimensions.
Le principe de base du moteur graphique est de décomposer en triangles un modèle 3D puis d'appliquer des textures sur ces triangles en gérant l'occlusion.
Sur calculatrice, il n'existe aucune libairie dédiée à le 3D, donc Windmill a été écrit à partir d'une feuille blanche, tout à été réalisé de A à Z.
Jour 1
Cliquez pour recouvrir
Dans la vidéo, j'ai optimisé le moteur graphique pour les murs verticaux. c'est à dire qu'il ne dessine plus des triangles mais des trapèzes, j'ai commencé l'optimisation pour les murs horizontaux récemment.
La bonne nouvelle c'est qu'il reste une grosse marge de progression pour optimiser ces cas particuliers : éviter les flottants, gérer un peu mieux le clipping, le back face culling et éviter un calcul redondant dans la boucle principale.
Jour 2
Cliquez pour recouvrir
Principalement un gros travail sur l'optimisation des murs : la plupart des calculs flottants sont désormais avec des entiers, le clipping est géré (on affiche pas les pixels en dehors de l'écran), des calculs sont simplifiés, et même pour gagner encore quelques fps les textures doivent être tournées de 90°.
Désormais les murs horizontaux peuvent être affichés, et même le plafond noir (avant c'était de la triche juste pour la vidéo...), des textures peuvent être appliquées sur le sol, et on peux construire des objets telle que la caisse ici présente.
Les textures peuvent être changées pendant le jeu, ainsi cela permettra d'afficher des textures animées comme de l'eau par exemple !
Il y a trois types d'objets affichable :
- les murs. De face ou de coté.
- les étages. Il s'agit d'objets plats, par exemple le sol, le paillasson, le haut de la caisse.
- le plafond. C'est un étage optimisé pour le noir.
Tous les objets sont paramètrables, de la taille, la hauteur, la texture que l'on veut.
Jour 3
Cliquez pour recouvrir
Simplement un aperçu de la vue de coté, en fil de fer cette fois parce que je n'ai pas terminé l'algo pour afficher les textures sur les murs.
J'ai déjà la structure de l'algo pour appliquer mes textures, il me reste plus qu'a l'implémenter. Il ressemble à celui que j'ai déjà mais avec une variante. Cependant je vais le reprendre de zéro pour être certain d'optimiser au mieux.
Parce que avec cette vue il y a beaucoup de chose qui changent :
- les textures appliquées sur le sol, au plafond ne sont plus des sprites classiques, elles sont maintenant déformées ce qui implique d'utiliser l'algo "lourd" et pas un simple affichage de sprite zoomé (cf la lib ML_zoom)
- les murs orientés vers le "sud" ne sont plus visible car toujours vu par "derrière" donc plus besoin d'être géré. Ça c'est une bonne nouvelle, mais je ne pense pas que ça puisse compenser le point du dessus.
Donc en conclusion, j'ai peur quand aux performances de l'ensemble fini. Il va arriver un moment où ça risque de coincer.
Jour 4
Cliquez pour recouvrir
GROSSE GROSSE nouveauté ! Comme promis le moteur gère la vue de coté !!
Pour cela j'ai totalement repris mon algo de base pour appliquer les textures sur des triangles avec un bon passage à la moulinette de l'optimisation, et j'ai ainsi multiplié par 11 les performances ! C'est énorme !
La prochaine étape est d'implémenter le Z-buffer pour ne pas voir à travers les murs, et encore un tas d'optimisations...
Et maintenant il n'y a pas de cas particuliers dans l'algo, c'est à dire que je peux tourner la caméra dans tous les sens, afficher des formes dans n'importe quelle position (mais ça ce sera pour une prochaine vidéo )
Jour 5
Cliquez pour recouvrir
Et voilà encore du nouveau ! (Oui ça avance vite )
Maintenant j'ai rajouté le z_buffer qui permet de ne pas afficher les murs sensé ne pas être visible.
Et j'ai rajouté un degré de liberté pour la caméra, ce qui permet de tourner sur soi-même.
Il reste encore un tas de choses à améliorer (meilleur rendu des textures, déplacement de la caméra selon différents repères) et d'optimisations (accès à la vram plus intelligent pour éviter de dessiner du banc si c'était déjà blanc, passage des calculs pour les rotations, les projections et les produits vectoriels en nombres entiers).
Je vais mixer un peu le rendu avec le mode fil de fer pour les murs vu par derrière (qui sont transparents actuellement). J'ai déjà fait quelques test et on se rend mieux compte des volumes !
Jour 6
Cliquez pour recouvrir
J'ai amélioré la qualité du rendu général en jouant sur les décalages de bits de façon plus astucieuse, en simplifiant des opérations et en arrondissant les nombres flottants. Résultat moins de perte à cause d'arrondi et de troncature, les textures sont moins déformées et plus précises. J'ai encore optimisé mon algorithme pour appliquer les textures, j'étais passé à côté de quelque chose d'énorme, résultat j'ai pu simplifier encore mes calculs pour gagner 35% de performances. Je suis passé de 10 décalages de bit, 17 mults, 9 additions à 7 décalages, 12 mults et 10 additions.
J'ai apporté quelques modifications au z-buffer (qui permet de ne pas afficher les objets caché par d'autres), l'initialisation est plus rapide et il est plus stable car il ne risque pas de d'overflow. Et je ne dessine plus de pixel blanc si c'est la première fois que je dessine sur un pixel puisqu'il était forcement blanc avant.
J'ai rajouté la gestion des viewport, c'est à dire que le rendu peu être dans une fenêtre définie par le programmeur et plus forcement sur l'écran entier. C'est utile si on utilise un ATH qui prend une partie de l'écran ou dans un menu pour afficher un objet 3D dans un coin facilement. Je n'ai pas testé, mais il est théoriquement possible d'afficher deux rendus différents en même temps, un écran splitté pour le multijoueur par exemple
Jour 7
Cliquez pour recouvrir
Il n'y a pas grand chose de nouveau visuellement donc je sors pas de vidéo, mais maintenant que j'ai fini d'opimisé le rendu des textures, j'ai optimisé la transformation des points dans l'espace 3D. J'ai gagné 71% de rapidité depuis le jour 6 ! Entre autres, j'ai précalculé les cos et sin, les coefficients de la matrice de rotation, le tout avec des nombre entiers.
Ce qui me prend du temps en ce moment c'est la structure de mes données, comment faire quelque chose d'efficace et qui permette d'écrire les modèle 3D rapidement à la main. Donc je gère des mini structures toutes faites, des triangles, des rectangles, et peut être d'autres plus tard comme des cylindres.
De plus, j'ai ajouté une fonctionalité qui permet d'appliquer une texture des deux cotés d'un triangles. Mais un problème est apparu, quand deux textures sont trop prochent l'une de l'autre, elle on tendance à se chevaucher, c'est à dire que la texture qui est derrière est affichée par dessus celle de devant...Ici on voit la texture blanche qui passe par dessus le mur de brique (frame 2 à 7)
Ça fait une journée que je cherche le problème. Il vient evidemment du z-buffer, mais la raison du problème est assez floue
Jour 8
Cliquez pour recouvrir
J'ai réussi à repérer l'origine de mon problème après plusieurs longues séances de documentation et de débeugage.
L'utilisation des matrices de projection perspective m'a permis de remapper la coordonnée z de mes points dans l'espace caméra, c'est à dire que maintenant leur coordonnée z à une valeur logique : elle est définie à 0 quand le point est sur le near clipping plane et à 1 sur le far clipping plane. Deux plans que je définie moi même.
Ceci m'a permis de mettre au jour une relation très vicieuse entre mes triangles que je n'avais pas remarqué jusqu'à présent. Je m'explique : dans ma phase de simplification, j'ai remarqué qu'une division était inutile puisque qu'elle se simplifiait dans une multiplication un peu plus loin. Dans le même genre que (A / B) x (C x B) = A x C
Cela n'a pas posé de problème de simplifier, j'ai obtenu exactement le même rendu.
Cependant, et c'est là que c'est vicieux, c'est que, plus tard, en rajoutant mon z-buffer (qui permet de connaître la distance entre mon point et la caméra afin d'afficher uniquement le plus proche), j'ai fabriqué une relation cachée entre mes triangles. En effet ils ne sont plus dessinés independamment puisqu'ils partagent le même z-buffer.
Et comme j'ai utilisé uniquement A et pas A / B et que B varie d'un triangle à l'autre, les données que je rentrais dans mon z-buffer étaient faussent.
Mais comme B varie peu, le problème ne s'est pas montré au premier abort, mais il était bien là !
Maintenant que je comprends l'origine du problème, je vais pouvoir le résoudre. En tout cas, c'était bien tordu et ça m'a bien pris la tête.
Désolé pour ce passage assez technique, mais expliquer l'origine du problème ne peut pas se faire sans
Jour 9
Cliquez pour recouvrir
Et voilà problème réglé ! Enfin, ça m'a pris une journée complète. (j'ai bien perdu 1h sur un copier coller raté et 3h parce que j'avais pas mon café...)
Maintenant le z-buffer est ultra propre ! je maitrise vraiment tout se qui passe. Un bon point pour la stabilité et éviter l'apparition d'artéfactes visuels
Jour 10
Cliquez pour recouvrir
J'ai commencé à modéliser des vrais objets pour voir ce que mon moteur a dans le ventre, et le résultat est renversant !
En définissant toutes les faces du moulin à vent, j'ai pu créer avec une relative simplicité un résultat plus que correct.
D'un point de vue technique, j'ai de nouveau optimisé depuis le jour précédent, en effet j'avais tout "désoptimisé" pour résoudre mon problème. Les fps en temps réel sont affichés dans le coin de l'écran, on voit que pour un modèle aussi riche (30 triangles) la vitesse du rendu est plus que convenable ce qui démontre que ce projet est viable. De plus il me reste quelques points à optimiser, sur le calcul des coordonnées de textures je peux grater pas mal, j'ai deux divisions que je peux transformer en une seule, et quelques autres idées. Donc j'ai encore de la marge, l'objectif étant qu'a terme le rendu soit le plus véloce possible
Sinon on peut remarquer que j'applique des textures sur des triangles dans des positions quelconques (le toit et les pales) et que j'ai ajouté l'option pour afficher une texture différentes de chaque côté d'un triangle (le toit vu par en dessous est noir) et j'ai rajouté un paramètre pour une bonne utilisation des textures sur les triangles (en effet le sprite est un carré à la base).
La prochaine étape est une réorganisation du code, j'ai deux fichiers que je vais réunir en un seul et je vais revoir comment le moteur recoit les objets à afficher. Dans la prochaine vidéo, les pales du moulin tourneront (enfin je l'espère bien )
Jour 11
Cliquer pour enrouler
Jour 11
Maintenant le moteur peut afficher plusieurs objets différents et les objets dynamiques ! J'ai revu totalement la façon de fournir les objets à afficher au moteur. Maintenant on peut afficher plusieurs objets simultanément, et on peut définir des mouvements pour les objets.
Jour 12
Cliquer pour enrouler
Jour 12
Après une grande pause, le projet reprend, en fonction de ma disponibilté, plus faible qu'avant, mais toujours présente
Comme je l'avais annoncé, la reprise de mes travaux portent sur l'optimisation, la résolution de bugs, et des changements internes pour les nouveautés à venir.
- nettoyage du fov, la valeur qui correspond à l'angle de vision, c'était un peu au pif avant.
- mise en const des variables de la map : les textures, les objets, les triangles et les rectangles.
- j'ai clarifié la précision des fixed (des nombres entiers utilisés comme des nombres à virgules) pour éviter les débordements, c'est surtout problématique pour les objets lointains, ou très proches car des variables s'approchent des limites d'un int.
Maintenant je suis certain qu'afficher un objet à la taille minimale (de taille 1) ne pose aucuns problèmes.
un cube de côté 1 :
un cube de coté 10, avec à sa droite le cube de coté 1.
(On voit le sol à partir de cette échelle, la distance entre les points est de 10)
L'histoire d'échelle est d'ailleurs très subjective, à combien correspond une taille de 10 si on veut la comparer au monde réel ? J'ai fait la proposition suivante : 1 = 10cm
- j'ai ajouté un repère 3D dans un coin de l'écran, c'est utile pour le debug.
- j'ai sorti la camera de la scène, c'est à dire que j'ai crée une classe juste pour la caméra.
- correction d'un problème dans le z-buffer (un tableau de la taille de l'écran enregistrant la distance des pixels par rapport à l'écran), j'avais un overflow, maintenant c'est tout propre !
- nettoyage divers dans le code
Jour 13
Cliquer pour enrouler
Jour 13
J'avance lentement, j'ai assez peu de disponibilité depuis 2 semaines...
MAIS ! Windmill avec encore et toujours
J'ai ajouté une fonctionnalité qui manquait depuis un long moment mais qui est pourtant essentielle : l'affichage des triangles devant le plan de clipping...
Explication :
Je parlais plus haut des plans de clipping, le proche et le lointain. Ces deux plans parralèles forment une pyramide avec à son sommet la caméra. Tout ce qui est entre ces plans est affiché. Le problème c'est si un point du triangle est avant le plan proche, jusqu'à présent si un des points avaient une coordonnée en z négative je n'affichais tout simplement pas le triangle.
Pour résoudre celà je tronque ou divise, en fonction des cas (1 ou 2 points devant le plan)
Desormais il n'y a presque plus de cas où des triangles disparaissent
Jour 14
Cliquer pour enrouler
Jour 14
Le problème de clipping que j'exposais en jour 13 est résolu !
Voici un petit rendu que comment c'était avant et comment c'est maintenant, le triangle (qui est la brique essentielle de tout le reste) est maintenant affichable avec beaucoup plus d'angle. Même quand on est presque dans le mur, il s'affiche correctement.
La texture se déforme légèrement quand on est vraiment proche, c'est dû aux erreurs d'arrondi.
Bonne vidéo
Jour 15
Cliquer pour enrouler
Jour 15
Une grosse surprise se prépare. Encore quelques soucis en train d'être corrigés et vous allez en prendre plein les yeux promis
En attendant cette semaine j'ai corrigé quelques bêtes erreurs comme un 1204 au lieu d'un 1024.
Changé un tas de chose en interne pour homogénéiser mon code
Les ajouts depuis le jour 13 :
Ajouté une ligne d'horizon (c'est tout bête mais ça rend bien mieux)
Changé les coordonnées des textures, maintenant on définit la taille en pixel en la texture, et la taille dans le monde.
Par exemple un texture de 32x32 peut correspondre à un carré de taille 20x20 (soit 2m carré), ou plus, ou moins c'est au choix.
- En affichant cette texture sur un rectangle de taille 40x40, la texture va automatiquement boucler.
- En renseignant 0x0 en taille réelle, la texture va s'étirer sur son support au lieu de boucler.
C'est très pratique pour répéter des motifs sans avoir à créer un autre rectangle, ou alors pour appliquer une texture sur n'importe quelle surface.
Actuellement j'ai un problème de serpent qui se mort la queue, clipping() doit être executé avant afficher() et afficher() doit être executé avant clipping() sinon j'ai des triangles qui s'effacent à certains moment. Je suis en train de corriger ça, mais c'est un peu casse tête
j'ai une grosse piste d'optimisation, si ça fonctionne j'estime à +30% de fps !
Jour 16
Cliquer pour enrouler
Jour 16
Désolé si tu es venu sur ce topic en pensant que j'ai enfin lancé LA démo ultime que j'ai vendu au jour 15.
Aujourd'hui c'est résolution de bugs.
J'ai résolu le problème du serpent qui se mort la queue en créant une fonction dédié plus rapide. Le problème était de savoir quelle face du triangle afficher, pour rentrer les dimensions de la textures dans les points.
Le problème que j'ai maintenant est une erreur d'overflow, lorsque la surface du triangle à afficher est trop importante, les nombres prennent des valeurs qui dépassent les limites d'un int (+- 2 milliards) et provoquent des bugs terribles sur l'affichage des textures.
J'ai bien ciblé le problème, je sais exactement quand, comment et pourquoi il se produit, je ne sais juste pas comment le résoudre simplement.
Après 3 soirées gachées à essayer de bricoler un truc, j'ai décidé de faire une autre fonction de clipping.
Cette fois l'objectif n'est pas découpe en plusieurs triangles ceux qui passent derrière la caméra (comme au jour14), mais découper pour n'avoir que les pixel qui sont à l'écran.
Le petit triangle s'affiche sans procblème, le grand à une aire qui overflow et bug visuellement
Jour 17
Cliquer pour enrouler
Jour 17
Le problème de clipping est résolu !
Pour récapituler, j'ai intégré du clipping sur l'axe devant-derrière pour couper les triangles passant derrière la caméra. Puis j'ai créé une nouvelle fonction pour découper les triangles sur l'axe haut-bas/droite-gauche, c'est à dire les bord de l'écran pour régler des problèmes d'overflow (cf jour 16). Le résultat est que le moteur est capable d'afficher des triangles dans n'importe quelle position, même la plus tordue sans bug, ou déformation du triangle.
A cette occasion j'ai revu toute la structure interne pour gérer l'affichage des objets. Je commence avec 1 triangle, et le clipping peux me renvoyer 1 à 10 triangles. Au lieu de gérer chaque point individuellement et avec des conditions à n'en plus finir, j'ai tout inséré dans un tableau que j'envoie à mes fonctions, et tout roule tout seul. c'est beaucoup plus léger et propre.
J'ai rajouté une synchronisation de la caméra avec le rendu. Le déplacement de la caméra (gestion du clavier) est appelé par un timer à interval régulier, ce qui peut tomber pendant le rendu d'une frame. Du coup je commence à dessiner un objet en regardant sous un angle X, la caméra se mets à jour et je termine de dessiner l'objet sous un angle Y. Ça provoquait des secousses et bugs visuels.
Résolution d'un bug sur le z-buffer.
Correction des quelques soucis avec le rendu du sol.
Un peu d'optimisation sur quelques variables.
Le moteur est super stable et il n'y a plus d'artéfactes visuels majeurs !!
C'est un vrai plaisir à regarder Pour ça rien de mieux qu'une vidéo !
Je teste ici sur émulateur et sur la machine, c'est quand même suffisament fluide, environ 10 fps, sachant que cette valeur est doublée avec de l'overcloacking
Jour 18
Cliquer pour enrouler
Jour 18
Windmill avance toujours, bien que la dernière vidéo soit impressionnante, il reste beaucoup de choses à faire.
Voici les nouveautés de la semaine :
- Réorganisation du code. J'ai ajouté une class Player et une class Engine avec un tas de petites modifications. Maintenant on peut créer son propre moteur physique et de gestion du jeu totalement indépendant du rendu 3D.
On peut même créer des moteurs physiques différents. Je suis en train d'en coder 2 :
>> Moteur de déplacement d'un personnage. En vue classique style FPS, on peut courrir, sauter, regarder dans toutes les direction (@Lephé : tout est fluide), interagir avec les objets (porte, trappe, ...)
>> Moteur de création de map. En vue de haut uniquement, on peut selectionner un objet, le déplacer, le tourner et observer ses coordonnées en temps réel. Une fois au bon endroit, il suffit d'écrire les coordonnées en dur dans le code. Très pratique pour créer une map.
- Ajout des billboard. Ce sont des sprites qui font toujours face au joueur. Il tournent sur l'axe vertical pour toujours faire face à la caméra. J'ai crée des arbres avec et des personnages avec.
- Ajout des masques alpha. Chaque texture doit avoir un sprite, et peut avoir un masque. La texture est dessinée que si le pixel du masque est noir.
- Ajout des sphere englobantes. Au chargement d'une nouvelle map, Windmill calcule automatiquement une sphere englobante pour chaque objet. Ceci permet de faire un test rapide. Si la sphere n'est pas à l'écran, aucune utilisté de vérifier si tous les triangles à l'intérieur sont à l'écran. Pour l'instant j'ai fais l'algo pour créer le spheres, il me reste l'algo pour savoir si elles sont à l'écran. J'ai mesuré les fps avant pour faire la comparaison.
- Ajout d'un tas de petites modifications.
- J'ai commencé à rédiger un manuel complet pour utiliser Windmill
Donc voilà, pas mal de nouveautés, c'est à chaque fois de plus en plus impressionnant
Jour 19
Le jour 19 arrive rapidement après le jour 18 car il y a une bonne nouveauté qui fera sans aucun doute plaisir à entendre !
J'ai terminé l'algo des sphères englobantes pour ne pas "chercher" à afficher les objets qui ne sont pas à l'écran.
Une petite explication plus détaillée
Lors du chargement de la map, un premier algorithme génère pour chaque objet une sphère qui englobe tous ses points. Lors du rendu, un second algorithme test pour chaque objet, si sa sphère est intersecte ou est incluse dans le champ de vision de la caméra. Si c'est le cas, on dessine l'objet, dans le cas contraire l'objet est ignoré.
Soit N le nombre de point d'un objet composant un objet, au lieu de calculer à chaque fois N points, on calcule au pire N+1 (N+centre de la sphère) ou au mieux 1 point. C'est très rentable !
Voici une animation représentant 2 sphères. La rouge est hors du champs de vision, la verte est dans le champs de vision.
Le gain en fps est d'autant plus important que le nombre d'objet hors du champs de vision est important. Donc impossible d'exprimer un gain fixe en fps.
Voici un comparatif :
Cas n°1, la map est peu chargée (celle en exterieur)
avant après
Tous les objets hors du champs de vision : 67 85
La moitié des objets dans le champs : 28 32
Cas n°1, la map est fort chargée (j'ai ajouté 15 moulins sur la map)
avant après
Tous les objets hors du champs de vision : 35 83
La moitié des objets dans le champs : 22 32
On remarque qu'avec cette méthode, les objets hors ne baisse pas (ou très peu) les performances.
En plus de cela, ça m'ouvre des opportunités pour de nouvelles foncionnalités
Jour 20
Une petite nouveauté dont je parlais précédemment : le trie des objets en fonction de la distance à la caméra.
Windmill trie en continue les objets pour afficher ceux qui sont les plus près en premier. En vérité Il trie les sphères englobantes.
Par exemple, j'ai placé 7 "murs" les uns derrière les autres.
Quand les objets sont dessinés du plus loin au plus proche : 10 fps
Quand les objets sont dessinés du plus proche au plus loin : 17 fps
Le trie permet garantir le second cas.
Cette fonctionnalité permet d'ajouter encore des objets sans perte majeure de performances
Jour 21
Bon... Ça fait un bon moment que je vous promets une démo pour le fameux et si attendu "jour 21".
Depuis le jour 20 il y a eu de gros changements, en interne comme en externe, visibles ou non visibles.
Je vais vous présenter l'ensemble de nouveautés en attendant la prochaine démo, qui sera pour le jour 22 du coup.
D'abord... Windmill gère les collisions avec le décors !!!
J'ai intégré un algorithme qui génèrement automatiquement au chargement de la carte des boites de collision à partir du modèle 3D. Donc le personnage bute sur les murs d'une maison, mais peut aussi monter sur une caisse. En effet le moteur de collision fonctionne dans les 3 dimensions.
Ensuite... Windmill intègre un algorithme de post traitement de l'image.
Cet algorithme détecte les contours des objets et les dessine en noir. Ceci permet de mieux apprecier les volumes.
Et surtout, il simplifie la création des modèle 3D (je développerai pourquoi plus tard)
Après... Windmill gère les "décorations".
Il s'agit d'objets que l'on peut poser en superposition sur les murs pour ajouter du détail. L'objectif est encore une fois de simplifier (énormément) la création des modèles 3D. Avant, pour ajouter une porte sur un mur, il fallait découper le mur en plusieurs parties pour éviter les bugs d'affichage. Maintenant, il suffit de placer la porte où on veut par dessus un unique mur. Il reste néanmoins quelques petits bugs d'affichage avec cette méthode, mais elle fonctionne 90% du temps.
Enfin... beaucoup de remaniement en interne
J'ai nettoyé l'ensemble du code. Il y a maintenant une gestion par scene facilitant la gestion des différentes parties du jeu : l'écran titre est une scene, la map est une autre scene, le menu de sauvegarde sera une scene...
Modification de l'étalement des textures sur les objets
Ajout d'un moteur de création rapide de map, il permet de sélectionner, déplacer et tourner un objet en affichant en direct ces coordonnées. C'est une scene de debug extremment utile pour agencer les objets sur la carte.
Réunion de toutes les variables à sauvegarder dans une même classe, en prévision de la sauvegarde/chargement de partie.
Diverses améliorations
Le jeu tourne forcement moins vite avec l'ajout de ces nouvelles fonctionnalités. Le moteur physique n'influe presque pas, par contre le post traitement diminue entre 5 et 15% les fps. Je dispose cependant toujours de pistes d'optimisation, mais elle ne seront pas fabuleuses non plus. Quoi qu'il en soit, Windmill est toujours parfaitement jouable !
Jour 22 : 22 mars 2019
Bon, je suis malheureux de plus trop bosser dessus, du coup je vous donne le dernier g1a que j'ai compilé !!!
Je souhaitais faire un effet encore plus Wahou en ajoutant encore quelques trucs mais je me rends compte qu'il ne sortira jamais sinon.
Et vu le nombre de fois que je vois passer le Windmill je ressens l'impatience des gens
Je vous laisse vous balader dans ce village virtuel
La grosse nouveauté est, je le rappelle, le moteur physique, essayez de monter sur les bottes de foin ou de sauter par dessus les barrières
Jour 23 : 01 mai 2019
Je commence à en voir de le bout de cette documentation !
J'y ai consacré de nombreuses heures. C'est pour moi un point essentiel pour comprendre comment créer un environnement en 3D à travers Windmill.
De plus, elle n'arrive que tardivement car il fallait s'assurer que les bases du moteurs soit stables et qu'il n'y ait pas de revirement majeur dans la façon de créer une carte. Sinon cela aurait été du travail pour presque rien.
Maintenant c'est assez modulaire pour que l'ajout de nouvelles fonctionnalités se fasse de façon transparente pour vous, au même titre qu'une mise à jour de logiciel.
Vous trouverez ci-joint la documentation dans sa version 3.0. A priori elle devrait suffire pour couvrir les bases de la création d'une carte sous Windmill.
Je posterai les sources par la suite, je vais prendre un peu de temps pour clarifier quelques point au niveau du code
Jour 24 : 02 septembre 2021
Après une longue période sans nouvelles officielles je vous annonce officiellement que Windmill tourne avec les derniers (et même un peu plus) standards de compilation : Gint & C++
Il m'aura fallu bien plus de temps que je ne l'imaginais pour installer Gint, comprendre son fonctionnement, comprendre le fonctionnement du terminal, adapter le code du jeu... J'avais un peu avancé sur l'adaptation en y allant cran par cran jusqu'à ce le C++ soit un obstacle pour continuer.
Lephénixnoir ce sera bien démené mais nous y sommes arrivé !
Que du texte, pas grand chose à montrer, hormis un rendu pas très joli.
Il faut que je refasse une passe sur le code pour voir ce qui cloche car les textures ne sont pas sur bien rendu, il doit y avoir quelques erreur de calculs de ci de là.
Et il faut aussi que je regarde pourquoi le jeu crach dès que je regarde trop à droite ou à gauche.
J'ai a nouveau la main pour avancer comme il se doit. Des nouvelles prochainement sans doute !
Jour 25 : 12 novembre 2021
Bonjour à tous !
La dernière vidéo de Sebastian Lague (I Tried Creating a Game Using Real-world Geographic Data) détaille à 24min moment comment générer des ombres pour un rendu 3D. Je pensais que c'était hyper complexe comme sujet mais en fait c'est assez simple. En fouillant un peu je suis tombé sur une méthode encore plus simple, qui parait trivial une fois dites mais il fallait penser Planar Shadow. J'ai bien l'intention d'implémenter ça
J'ai encore du mal avec le passage sous Gint, avec des bugs dont j'ai du mal à me dépatouiller.
Autre chose, je vais désormais avoir une 90E, donc un truc bien plus récent que ma calto SH3, et avec la couleur, je pourrai faire des tests sur le portage pour cette plateforme ! On verra ce que donnent les performances.
J'ai encore un autre projet, c'est de créer un importeur de fichier obj. L'obj est un format 3D simple à générer, et aussi simple à parser. Le but est de simplifier la création des modèles 3D en passant par un logiciel 3D plutôt que créer à la fin la liste des triangle, c'est fastidieux. Ici une maison crée sous Fusion 360 en 1 minute. On voit le maillage avec les 16 triangles.
Jour 26 : 5 janvier 2022
Bonne année à tous, me revoici avec des nouveautés concernant Windmill.
Les nouvelles fonctions que je vous décrivais dans le "jour 25" et surtout les ombres et le passage en obj nécessitent une refonte du système de clipping décrit dans le jour 14.
Ce qui change ? Je passe d'un clipping 2D à un clipping 3D.
En somme, je tronque les triangles du modèle en étant encore dans l'espace 3D et plus dans l'espace 2D, c'est à dire un cran avant.
C'était un peu de boulot mais ça me permet désormais d'avancer.
Je vous présente une petite vidéo qui illustre le clipping d'un triangle par rapport au frustrum (la pyramide de vision de la caméra). Le chiffre indique le nombre de trinagle résultant du découpage
Jour 27 : 26 octobre 2022
Bonjour à tous,
La programmation sur calculatrice est chronophage et je n'ai plus de temps perso à y accorder.
J'ai des envies pour ce projet, et pas des petites : passer à la couleur, mettre en place les ombres, terminer l'import au format stl. Ça me motive à fond. Dans le même temps côté boulot, j'utilise le C# et dès que je replonge dans le C ou C++ c'est un retour en arrière qui me frustre. Je passe plus de temps à débugger Windmill qu'à faire ce qui me plait. Je n'avance pas.
J'ai finalement vendu ma 90E avant qu'elle ne prenne la poussière, que les touches se mettent à gripper et que les araignées y fassent leur nid.
Pour être honnête, je ne pense pas remettre un pied dans le projet.
Windmill a souvent été pris en exemple pour l'exploit technique et son potentiel, et je n'en suis pas peu fière. Je ne pense pas qu'une autre personne de la communauté (fr ou non) soit allé aussi loin dans la création d'un vrai moteur 3D pour calculatrice.
C'est pourquoi ce projet doit continuer à vivre et ne doit pas tomber dans l'oubli.
Ainsi je partage à la communauté les sources du projet aujourd'hui.
C'est brut, tout n'est pas commenté, si vous souhaitez reprendre le projet, bon courage, mais merci si vous vous lancez !
Exactement Darks. Je me demandais si rustc produisait pas du C à un moment mais visiblement non (j'ai dû confondre avec Haskell). En tous cas côté LLVM y'a zéro progrès depuis des années, pour l'instant personne a l'expertise pour aller faire un back-end même décent.
(D'un autre côté je suis susceptible de jouer beaucoup avec le code LLVM dans mes stages et ma recherche, c'est pas impossible qu'un jour je puisse tenter. Mais c'est pas prévu pour l'instant.)
Ok Ninestars, merci pour la réponse merci Lephé aussi, (j'ai attendu pour pas double-poster )
Pour la compil sous Gint, content que ça avance !
Au niveau d'une "scène chargée" j'ai pas trop de référence, faut que je regarde la démo, mais il me semble qu'une map avec la même densité de maison, d'objet que la démo, mais 10 fois plus grande ? En fait, c'est pas tant la densité que la taille en elle-même… ?
Au niveau de la création des maps, j'ai survolé la doc, ça à l'air assez laborieux… ^^' Peut-être une idée de feature, mais est-ce possible (même au niveau du dev du projet derrière) d'avoir une sorte de type windmill_map qui transpose la map en 2D en 3D en plaçant sur la map des objets en 3D définis ailleurs ?
Ajouté le 16/06/2021 à 19:01 :
J'ai voulu tester la version démo, mais presser la touche Shift (au tout début), ne fait rien…
"Ce n'est pas parce que les chose sont dures que nous ne les faisons pas, c'est parce que nous ne les faisons pas qu'elles sont dures." Sénèque
Typiquement, le compilation sous Gint évite ce genre de soucis. Là de souvenir, c'est un problème de SH3/SH4 pour la détection des touches. Il doit y avoir une version compatible SH4 en pièce d'un des posts je crois
Pour tes questions sur la densité et la taille de la map, la taille n'a pas d'influence sur les performances, ni le nombre d'objets.
Le truc qui prend toutes les performance c'est l'affichage. En fait les fps sont presque proportionnels au nombre de pixels qui changent de couleur entre le moment ou j'efface l'écran, et la fin du dessin
J'ai fais un tas d'optimisation, notamment une qui trie en temps réel les objets en fonction de leur distance à la caméra pour limiter la double, triple, qua... écriture d'un même pixel !
Il y a le mode debug que j'ai crée pour simplifier ça justement C'est assez simple avec ce mode : Tu charges une map avec tous les objets que tu veux mettre dessus, tu passe en mode debug, puis tu peux déplacer des objets, les faire tourner et tout, afin d'avoir leurs bonnes coordonnées, que tu viens écrire en brut dans le code. Tu recomplies, et tout est à la bonne place désormais. Assez simple dans les faits
Juste pour dire que j'ai touché aux sources que Ninestars m'a gentiment passé ces derniers jours, et j'ai pu finir de rendre Windmill compatible avec gint (en tous cas assez pour me balader dans la démo).
Il y a encore des progrès à faire côté compatibilité C++dans gint, mais ça devrait aller essentiellement tout seul.
Pedrobzh a écrit : pour faire du c++ avec gint il faut remplacer tout les gcc par g++ dans le makefile et mettre en extern C les include de gint
Plus maintenant (enfin bientôt) ! D'abord CMake détecte les fichiers C++ et génère les bonnes commandes tout seul donc il n'y a pas de modifications à faire dans le système de build. Et ensuite les en-têtes de gint ajoutent automatiquement le extern "C" (enfin) depuis un commit récent sur dev.
Il y a deux difficultés, en réalité. Le problème principal c'est que le C++ repose beaucoup sur sa bibliothèque standard, et donc il faut la compiler pour pouvoir écrire des choses simples comme new/delete ou des destructeurs globaux. Jusqu'ici je n'y étais pas arrivé, mais c'est maintenant chose faite (avec un bémol).
Le bémol en question est la deuxième raison, c'est que la partie fournie de la lib standard (<vector>, <string>, etc.) est assez lourde et demande pas mal de fonctionnalités pour compiler, et donc on ne l'a pas. Je n'ai compilé de la lib standard qu'une partie minimaliste (dite « free-standing »), qui fournit assez d'outils pour écrire des programmes C++, mais qui ne donne pas les fonctionnalités dont on a l'habitude. Du coup il faut coder sans.
Tu n'étais pas si loin donc.
Ninestars a écrit : En effet, et Lephé m'a répondu de façon très détaillé, merci à toi
Je continue ça quand j'ai un moment.
Du coup, peux-tu nous expliquer quelles sont les étapes pour compiler en C++ ?
Notes préliminaires :
Je vais publier rapidement une version de gint appropriée avec toutes les modifs, je te conseille de l'attendre avant de faire cette procédure, ce sera plus simple.
Il y a un résumé des commandes dans les grandes lignes à la fin.
J'ai documenté la majorité des étapes sur le dépôt sh-elf-gcc (utilisé par GiteaPC pour compiler GCC). Pour l'instant, ce n'est pas intégré au système automatique, il faudra attendre encore un peu pour ça.
D'abord il faut recompiler GCC. Tu peux clôner le dépôt sh-elf-gcc même sans utiliser GiteaPC, et suivre les instructions. Ça commence par télécharger et extraire l'archive, ce qui donne à peu près ça :
% cd le/dépôt/sh-elf-gcc
% wget -q --show-progress https://ftp.gnu.org/gnu/gcc/gcc-11.1.0/gcc-11.1.0.tar.xz -O gcc-11.1.0.tar.xz
% unxz -c < gcc-11.1.0.tar.xz | tar -xf -
Ensuite il faut créer un dossier de compilation et configurer GCC, et là les commandes sont données dans le README que j'ai lié. La raison pour laquelle il faut faire ça c'est que des options en plus sont nécessaires pour avoir la lib C++ et donc l'installation existante de GCC ne convient pas.
Note que quand tu configures tu donne un dossier d'installation (le PREFIX). Celui-là, il faut que tu le choisisses. Tu peux donner le même que ton GCC existant, mais par pitié prends un dossier où ton utilisateur non-root peut écrire. Si tu installes dans un dossier root tu te condamnes à devoir mettre sudo partout tout le temps et ce sera un calvaire. Si tu ne sais pas où le mettre, je suggère $HOME/.local qui est safe.
Il y a quelques explications, et ensuite les commandes de compilation de GCC (le plus long) qui sont comme d'habitude.
À ce stade, tu as le compilateur C et c'est tout. Si tu n'as pas installé le nouveau compilateur au même endroit que le précédent, alors il est important de supprimer le précédent et potentiellement de modifier ton PATH pour inclure le nouveau. Tu sauras que tu as réussi si command -v sh-elf-gcc indique le chemin où tu as installé le nouveau compilateur.
C'est maintenant qu'il faut mettre à jour tes bibliothèques :
D'abord il te faut OpenLibm. Je crois que tu l'as déjà installée, mais j'ai trouvé pas mal de problèmes/améliorations récemment donc tu auras besoin de la mettre à jour. Les instructions sont les mêmes mais la commande est légèrement différente, prends bien les deux commandes ici en vérifiant que PREFIX a une valeur correcte, et tu seras bon.
Ensuite il te faut fxlibc, notre lib standard qui fait proprement ce que gint faisait un peu sous le tapis jusqu'ici. Là aussi ça va aller tout seul, les instructions sont directes. Utilise la première méthode pour choisir PREFIX (celle qui utilise GCC), pas la seconde (la seconde est indiquée recommandée mais pas pour toi).
Et ensuite tu peux compiler la lib C++ en suivant les instructions données dans le premier README.
Voilà un résumé/aperçu des commandes, que je tape là sans tester mais pour te guider. Ce n'est pas absolu, mais si je suis très chanceux tu peux clôner les dépôts, naviguer et lancer les commandes et ça marchera. Remplace bien le marquer par ton dossier d'installation choisi pour GCC.
## Compilation de GCC (étape 1)
# Clôner le dépôt sh-elf-gcc, naviguer dans la copie du dépôt
# Configurer GCC avec les options C++ :
% export PREFIX="/TON/DOSSIER/INSTALLATION/GCC"
# Par exemple: export PREFIX="$HOME/.local"
% mkdir build-libstdc++
% cd build-libstdc++
% ../gcc-11.1.0/configure --prefix="$PREFIX" --target=sh3eb-elf --with-multilib-list=m3,m4-nofpu --enable-languages=c,c++ --without-headers --with-newlib --program-prefix=sh-elf- --enable-libssp --enable-lto --enable-clocale=generic --enable-libstdcxx-allocator --disable-threads --disable-hosted-libstdcxx --disable-libstdcxx-verbose --enable-cxx-flags="-ffreestanding -fno-exceptions"
# Compiler et installer GCC (sans la lib C ni la lib C++) :
% make -j$(nproc) all-gcc all-target-libgcc
% make -j$(nproc) install-strip-gcc install-strip-target-libgcc
## Compilation/mise à jour de OpenLibm
# Clôner OpenLibm, naviguer dans la copie du dépôt.
% PREFIX=$(sh-elf-gcc -print-file-name=.)
# ↑ Cette commande est pareille que la version du README avec grep install etc.
# Vérifie que PREFIX commence bien par le dossier d'installation de GCC :
% echo "$PREFIX"
# Exemple : /home/ton_utilisateur/.local/lib/gcc/sh3eb-elf/11.1.0/.
# Si c'est pas bon → pause et commente sur ce topic
% make USEGCC=1 TOOLPREFIX=sh-elf- AR=sh-elf-ar CC=sh-elf-gcc libdir="$PREFIX" includedir="$PREFIX/include" install-static install-headers
## Compilation de fxlibc
# Clôner fxlibc, naviguer dans la copie du dépôt
% PREFIX=$(sh-elf-gcc -print-file-name=.)
% cmake -B build-gint -DFXLIBC_TARGET=gint -DCMAKE_TOOLCHAIN_FILE=cmake/toolchain-sh.cmake -DCMAKE_INSTALL_PREFIX="$PREFIX"
% make -C build
% make -C build install
## Mise à jour du fxSDK
# Naviguer dans ta copie du fxSDK
# Si tu as une version vraiment vieille qui utilise un Makefile, supprimer le dossier build :
% [[ -f Makefile ]] && rm -rf build
# Mettre à jour, recompiler et installer
% git pull
# Si erreur de pull → pause et commente le topic
% cmake -B build
# Si tu as une erreur disant que UDisks2 n'est pas trouvé, utilise à la place :
% cmake -B build -DFXLINK_DISABLE_UDISKS2=1
# Et ensuite :
% make -C build
% make -C build install
# Naviguer dans le dépôt sh-elf-gcc
% cd build-libstdc++
# Petite manip pour que OpenLibm soit trouvé
% SRC="$(sh-elf-gcc -print-file-name=include/openlibm)"
% DST="../sh3eb-elf/sys-include"
% mkdir -p "$DST"
% for x in "$SRC"/*.h; do ln -s "$x" "$DST/${x#$SRC/}"; done
# Petite manip pour que <stdint.h> soit trouvé
% echo '#include "stdint-gcc.h"' > ../sh3eb-elf/sys-include/stdint.h
# Compilation de la lib C++
% make all-target-libstdc++-v3
% make install-strip-target-libstdc++-v3
Si tu en arrives là, ton GCC sera prêt et le projet tel que je te l'ai passé devrait fonctionner. Je réexpliquerai dans tous les cas les options et outils nécessaires pour compiler en C++ (principalement, pour les curieux : -lsupc++ -lc -lopenlibm -lgcc, accompagnés de -fno-use-cxa-atexit et je suggère -fno-exceptions -fno-rtti si acceptable).
Puisque j'étais sur le sujet de Windmill (avec les Casio Awards, bravo d'ailleurs !), je reviens rapidement dessus.
Depuis le dernier message, gint a été mis à jour et supporte maintenant plein de petits détails qui allaient pas avant, du style les extern "C" {}. Plus besoin de ça maintenant. qsort() est aussi dans la lib standard maintenant, #include <stdlib.h> et hop. Par contre, la lib C++ n'est toujours pas compilée automatiquement par le script d'installation de GCC.
J'en profite pour lancer une idée que j'avais eu par rapport au rendu de certaines textures. Je remarque que quand les textures sont petites les détails sont souvent très difficiles à voir, parce que l'épaisseur des traits se perd dans la distance. Est-ce que ce serait techniquement faisable d'avoir (1) plusieurs versions de la même texture pour différentes tailles, ou (2) texturer un triangle avec une fonction qui dessine les pixels à la main ?
Excellent, je vais mettre à jour Gint et m'appuyer sur ce que tu m'avais dit dans ton message précédent (si tout est toujours valable)
Parfait, qsort était presque indispensable, c'est lui qui sert au trie en profondeur des éléments pour optimiser l'ordre d'affichage.
Alors, en effet, comme je calcule l'aire en pixel du triangle avant son affichage, il est possible en fonction de son l'aire d'effectuer des actions différentes. pour le 1, c'est bien possible ! J'imagine rapidement que cela nécessiterait quelques modif mineures, un switch fonction de la valeur de l'aire mais aussi d'ajouter dans Windmill la notion que une texture peut avoir plusieurs bitmap en fonction d'une valeur seuil (l'aire affichée). Rien d'impossible 🙂
Pour le point 2, j'avais pensé un moment de dessiner 3 traits qui forment les contours du triangle si son aire est faible. Mais je n'ai pas donné suite à ça. Sinon, en dehors de ce hack simple, je ne vois pas comment faire de "dessin à la main" même si je comprends l'idée.
Sinon j'avais pensé aussi, que si l'aire est faible (2x2 pixels ou 3x3 par exemple) dessiner full black. Ça limite l'effet de scintillement. Pas testé non plus
Hum, pour le 1., je ne crois pas dire de bêtise si je dit que Deadly World 3D utilise cette technique là aussi (des textures différentes en fonction de la distance)
"Ce n'est pas parce que les chose sont dures que nous ne les faisons pas, c'est parce que nous ne les faisons pas qu'elles sont dures." Sénèque
Après une longue période sans nouvelles officielles je vous annonce officiellement que Windmill tourne avec les derniers (et même un peu plus) standards de compilation : Gint & C++
Il m'aura fallu bien plus de temps que je ne l'imaginais pour installer Gint, comprendre son fonctionnement, comprendre le fonctionnement du terminal, adapter le code du jeu... J'avais un peu avancé sur l'adaptation en y allant cran par cran jusqu'à ce le C++ soit un obstacle pour continuer.
Lephénixnoir ce sera bien démené mais nous y sommes arrivé !
Que du texte, pas grand chose à montrer, hormis un rendu pas très joli.
Il faut que je refasse une passe sur le code pour voir ce qui cloche car les textures ne sont pas sur bien rendu, il doit y avoir quelques erreur de calculs de ci de là.
Et il faut aussi que je regarde pourquoi le jeu crach dès que je regarde trop à droite ou à gauche.
J'ai a nouveau la main pour avancer comme il se doit. Des nouvelles prochainement sans doute !
Je ne peux apporter aucune conclusion pour l'instant car le jeu est rythmé différemment par rapport à l'ancienne version :
Le moteur graphique tournait en boucle
Le moteur physique était timé avec des timers.
Là pour simplifier la migration les deux sont dans une boucle while(1)
Donc je ne peux pas trop comparer. Il faut que je reprenne comme c'était fait avant puis que je compare avec en faisant une mesure des fps pour en avoir le coeur net.
Bien joué !
Hâte d'avoir des premières images du rendu, bonne chance pour la suite de l'adaptation
Ça signifie que Windmill sera portable vers 90+E dans le futur ?
Hey, excellent ! Ce sujet rappelle des bons souvenirs
Il n'est pas très probable qu'il y ait des grosses différences de performances parce que c'est beaucoup de calcul. Mais il y a quelques opportunités d'optimisation fournies par gint, qui peuvent être saisies si le code est programmé pour.
Massena a écrit : Ça signifie que Windmill sera portable vers 90+E dans le futur ?
Il n'y avait rien dans le code original de Windmill qui soit fondamentalement incompatible avec la Graph 90. gint aide, mais il n'y a pas besoin de beaucoup de support. Le vrai problème ce sera plutôt comment maintenir les performances avec un écran aussi grand, et ça je pense que Ninestars sera d'accord que ce serait une grosse inconnue. Donc portable oui, utilisable la question reste ouverte jusqu'à ce que ce soit testé.
Merci de vos retours !
En effet il n'y a rien d'incompatible. Mais il y a deux choses qui vont prendre plus de ressources :
- pour chaque pixel dessiné aller chercher les trois canaux R + G + B au lieu de un actuellement.
- plus de pixels à dessiner. La c'est strictement proportionnel, si on ajoute 4x plus de pixel ça sera 4x plus lent
Mais de toute façon je n'ai pas de Graph couleur pour essayer A l'occasion j'en achèterai une pour essayer pourquoi pas
Planète Casio est un site communautaire non affilié à Casio. Toute reproduction de Planète Casio, même partielle, est interdite.
Les programmes et autres publications présentes sur Planète Casio restent la propriété de leurs auteurs et peuvent être soumis à des licences ou copyrights.
CASIO est une marque déposée par CASIO Computer Co., Ltd
)
)
J'ai encore optimisé mon algorithme pour appliquer les textures, j'étais passé à côté de quelque chose d'énorme, résultat j'ai pu simplifier encore mes calculs pour gagner 35% de performances. Je suis passé de 10 décalages de bit, 17 mults, 9 additions à 7 décalages, 12 mults et 10 additions.
Ici on voit la texture blanche qui passe par dessus le mur de brique (frame 2 à 7)
Ajouté une ligne d'horizon (c'est tout bête mais ça rend bien mieux)
Il reste néanmoins quelques petits bugs d'affichage avec cette méthode, mais elle fonctionne 90% du temps.
Citer : Posté le 15/06/2021 08:53 | #
Exactement Darks. Je me demandais si rustc produisait pas du C à un moment mais visiblement non (j'ai dû confondre avec Haskell). En tous cas côté LLVM y'a zéro progrès depuis des années, pour l'instant personne a l'expertise pour aller faire un back-end même décent.
(D'un autre côté je suis susceptible de jouer beaucoup avec le code LLVM dans mes stages et ma recherche, c'est pas impossible qu'un jour je puisse tenter. Mais c'est pas prévu pour l'instant.)
Citer : Posté le 16/06/2021 16:42 | #
Ok Ninestars, merci pour la réponse merci Lephé aussi, (j'ai attendu pour pas double-poster
Pour la compil sous Gint, content que ça avance !
Au niveau d'une "scène chargée" j'ai pas trop de référence, faut que je regarde la démo, mais il me semble qu'une map avec la même densité de maison, d'objet que la démo, mais 10 fois plus grande ? En fait, c'est pas tant la densité que la taille en elle-même… ?
Au niveau de la création des maps, j'ai survolé la doc, ça à l'air assez laborieux… ^^' Peut-être une idée de feature, mais est-ce possible (même au niveau du dev du projet derrière) d'avoir une sorte de type windmill_map qui transpose la map en 2D en 3D en plaçant sur la map des objets en 3D définis ailleurs ?
Ajouté le 16/06/2021 à 19:01 :
J'ai voulu tester la version démo, mais presser la touche Shift (au tout début), ne fait rien…
Citer : Posté le 16/06/2021 19:27 | #
Typiquement, le compilation sous Gint évite ce genre de soucis. Là de souvenir, c'est un problème de SH3/SH4 pour la détection des touches. Il doit y avoir une version compatible SH4 en pièce d'un des posts je crois
Pour tes questions sur la densité et la taille de la map, la taille n'a pas d'influence sur les performances, ni le nombre d'objets.
Le truc qui prend toutes les performance c'est l'affichage. En fait les fps sont presque proportionnels au nombre de pixels qui changent de couleur entre le moment ou j'efface l'écran, et la fin du dessin
J'ai fais un tas d'optimisation, notamment une qui trie en temps réel les objets en fonction de leur distance à la caméra pour limiter la double, triple, qua... écriture d'un même pixel !
Il y a le mode debug que j'ai crée pour simplifier ça justement
Citer : Posté le 16/06/2021 20:14 | #
Aow parfait ! Merci beaucoup !
Bien vu, j'avais perdu de vue ces problèmes SH3/SH4, avec Gint, j'ai plus l'habitude xD
jmnz Invité
Citer : Posté le 16/06/2021 20:16 | #
Merci
Citer : Posté le 16/06/2021 21:58 | #
il est ou le code source?
Citer : Posté le 18/06/2021 17:17 | #
Juste pour dire que j'ai touché aux sources que Ninestars m'a gentiment passé ces derniers jours, et j'ai pu finir de rendre Windmill compatible avec gint (en tous cas assez pour me balader dans la démo).
Il y a encore des progrès à faire côté compatibilité C++dans gint, mais ça devrait aller essentiellement tout seul.
Bon courage quand tu auras le temps 9*
Citer : Posté le 18/06/2021 18:30 | #
En effet, et Lephé m'a répondu de façon très détaillé, merci à toi
Je continue ça quand j'ai un moment.
Du coup, peux-tu nous expliquer quelles sont les étapes pour compiler en C++ ?
@Pedrobzh : le code source est en train d'être adapté pour être compilé sous Gint, la norme désormais, une fois compilable, il sera publié
Citer : Posté le 19/06/2021 08:14 | #
pour faire du c++ avec gint il faut remplacer tout les gcc par g++ dans le makefile et mettre en extern C les include de gint
Citer : Posté le 19/06/2021 13:44 | #
Je pense que tu te doutes que si c'était aussi simple, ça ferait longtemps qu'on aurait Windmill avec Gint…
Citer : Posté le 19/06/2021 13:50 | #
c'est quoi le problème? la std?
Citer : Posté le 19/06/2021 15:00 | #
pour faire du c++ avec gint il faut remplacer tout les gcc par g++ dans le makefile et mettre en extern C les include de gint
Plus maintenant (enfin bientôt) ! D'abord CMake détecte les fichiers C++ et génère les bonnes commandes tout seul donc il n'y a pas de modifications à faire dans le système de build. Et ensuite les en-têtes de gint ajoutent automatiquement le extern "C" (enfin) depuis un commit récent sur dev.
Il y a deux difficultés, en réalité. Le problème principal c'est que le C++ repose beaucoup sur sa bibliothèque standard, et donc il faut la compiler pour pouvoir écrire des choses simples comme new/delete ou des destructeurs globaux. Jusqu'ici je n'y étais pas arrivé, mais c'est maintenant chose faite (avec un bémol).
Le bémol en question est la deuxième raison, c'est que la partie fournie de la lib standard (<vector>, <string>, etc.) est assez lourde et demande pas mal de fonctionnalités pour compiler, et donc on ne l'a pas. Je n'ai compilé de la lib standard qu'une partie minimaliste (dite « free-standing »), qui fournit assez d'outils pour écrire des programmes C++, mais qui ne donne pas les fonctionnalités dont on a l'habitude. Du coup il faut coder sans.
Tu n'étais pas si loin donc.
En effet, et Lephé m'a répondu de façon très détaillé, merci à toi
Je continue ça quand j'ai un moment.
Du coup, peux-tu nous expliquer quelles sont les étapes pour compiler en C++ ?
Notes préliminaires :
J'ai documenté la majorité des étapes sur le dépôt sh-elf-gcc (utilisé par GiteaPC pour compiler GCC). Pour l'instant, ce n'est pas intégré au système automatique, il faudra attendre encore un peu pour ça.
D'abord il faut recompiler GCC. Tu peux clôner le dépôt sh-elf-gcc même sans utiliser GiteaPC, et suivre les instructions. Ça commence par télécharger et extraire l'archive, ce qui donne à peu près ça :
% wget -q --show-progress https://ftp.gnu.org/gnu/gcc/gcc-11.1.0/gcc-11.1.0.tar.xz -O gcc-11.1.0.tar.xz
% unxz -c < gcc-11.1.0.tar.xz | tar -xf -
Ensuite il faut créer un dossier de compilation et configurer GCC, et là les commandes sont données dans le README que j'ai lié. La raison pour laquelle il faut faire ça c'est que des options en plus sont nécessaires pour avoir la lib C++ et donc l'installation existante de GCC ne convient pas.
Note que quand tu configures tu donne un dossier d'installation (le PREFIX). Celui-là, il faut que tu le choisisses. Tu peux donner le même que ton GCC existant, mais par pitié prends un dossier où ton utilisateur non-root peut écrire. Si tu installes dans un dossier root tu te condamnes à devoir mettre sudo partout tout le temps et ce sera un calvaire. Si tu ne sais pas où le mettre, je suggère $HOME/.local qui est safe.
Il y a quelques explications, et ensuite les commandes de compilation de GCC (le plus long) qui sont comme d'habitude.
À ce stade, tu as le compilateur C et c'est tout. Si tu n'as pas installé le nouveau compilateur au même endroit que le précédent, alors il est important de supprimer le précédent et potentiellement de modifier ton PATH pour inclure le nouveau. Tu sauras que tu as réussi si command -v sh-elf-gcc indique le chemin où tu as installé le nouveau compilateur.
C'est maintenant qu'il faut mettre à jour tes bibliothèques :
Et ensuite tu peux compiler la lib C++ en suivant les instructions données dans le premier README.
Voilà un résumé/aperçu des commandes, que je tape là sans tester mais pour te guider. Ce n'est pas absolu, mais si je suis très chanceux tu peux clôner les dépôts, naviguer et lancer les commandes et ça marchera. Remplace bien le marquer par ton dossier d'installation choisi pour GCC.
# Clôner le dépôt sh-elf-gcc, naviguer dans la copie du dépôt
# Télécharger et décompresser GCC :
% wget -q --show-progress https://ftp.gnu.org/gnu/gcc/gcc-11.1.0/gcc-11.1.0.tar.xz -O gcc-11.1.0.tar.xz
% unxz -c < gcc-11.1.0.tar.xz | tar -xf -
# Configurer GCC avec les options C++ :
% export PREFIX="/TON/DOSSIER/INSTALLATION/GCC"
# Par exemple: export PREFIX="$HOME/.local"
% mkdir build-libstdc++
% cd build-libstdc++
% ../gcc-11.1.0/configure --prefix="$PREFIX" --target=sh3eb-elf --with-multilib-list=m3,m4-nofpu --enable-languages=c,c++ --without-headers --with-newlib --program-prefix=sh-elf- --enable-libssp --enable-lto --enable-clocale=generic --enable-libstdcxx-allocator --disable-threads --disable-hosted-libstdcxx --disable-libstdcxx-verbose --enable-cxx-flags="-ffreestanding -fno-exceptions"
# Compiler et installer GCC (sans la lib C ni la lib C++) :
% make -j$(nproc) all-gcc all-target-libgcc
% make -j$(nproc) install-strip-gcc install-strip-target-libgcc
## Compilation/mise à jour de OpenLibm
# Clôner OpenLibm, naviguer dans la copie du dépôt.
% PREFIX=$(sh-elf-gcc -print-file-name=.)
# ↑ Cette commande est pareille que la version du README avec grep install etc.
# Vérifie que PREFIX commence bien par le dossier d'installation de GCC :
% echo "$PREFIX"
# Exemple : /home/ton_utilisateur/.local/lib/gcc/sh3eb-elf/11.1.0/.
# Si c'est pas bon → pause et commente sur ce topic
% make USEGCC=1 TOOLPREFIX=sh-elf- AR=sh-elf-ar CC=sh-elf-gcc libdir="$PREFIX" includedir="$PREFIX/include" install-static install-headers
## Compilation de fxlibc
# Clôner fxlibc, naviguer dans la copie du dépôt
% PREFIX=$(sh-elf-gcc -print-file-name=.)
% cmake -B build-gint -DFXLIBC_TARGET=gint -DCMAKE_TOOLCHAIN_FILE=cmake/toolchain-sh.cmake -DCMAKE_INSTALL_PREFIX="$PREFIX"
% make -C build
% make -C build install
## Mise à jour du fxSDK
# Naviguer dans ta copie du fxSDK
# Si tu as une version vraiment vieille qui utilise un Makefile, supprimer le dossier build :
% [[ -f Makefile ]] && rm -rf build
# Mettre à jour, recompiler et installer
% git pull
# Si erreur de pull → pause et commente le topic
% cmake -B build
# Si tu as une erreur disant que UDisks2 n'est pas trouvé, utilise à la place :
% cmake -B build -DFXLINK_DISABLE_UDISKS2=1
# Et ensuite :
% make -C build
% make -C build install
## Mise à jour de gint
# Naviguer dans ta copie de gint
% git pull
% fxsdk build-fx install
% fxsdk build-cg install
## Compilation de GCC (étape 2)
# Naviguer dans le dépôt sh-elf-gcc
% cd build-libstdc++
# Petite manip pour que OpenLibm soit trouvé
% SRC="$(sh-elf-gcc -print-file-name=include/openlibm)"
% DST="../sh3eb-elf/sys-include"
% mkdir -p "$DST"
% for x in "$SRC"/*.h; do ln -s "$x" "$DST/${x#$SRC/}"; done
# Petite manip pour que <stdint.h> soit trouvé
% echo '#include "stdint-gcc.h"' > ../sh3eb-elf/sys-include/stdint.h
# Compilation de la lib C++
% make all-target-libstdc++-v3
% make install-strip-target-libstdc++-v3
Si tu en arrives là, ton GCC sera prêt et le projet tel que je te l'ai passé devrait fonctionner. Je réexpliquerai dans tous les cas les options et outils nécessaires pour compiler en C++ (principalement, pour les curieux : -lsupc++ -lc -lopenlibm -lgcc, accompagnés de -fno-use-cxa-atexit et je suggère -fno-exceptions -fno-rtti si acceptable).
Voilà voilà... xD
Citer : Posté le 23/08/2021 20:25 | # |
Fichier joint
Puisque j'étais sur le sujet de Windmill (avec les Casio Awards, bravo d'ailleurs !), je reviens rapidement dessus.
Depuis le dernier message, gint a été mis à jour et supporte maintenant plein de petits détails qui allaient pas avant, du style les extern "C" {}. Plus besoin de ça maintenant. qsort() est aussi dans la lib standard maintenant, #include <stdlib.h> et hop. Par contre, la lib C++ n'est toujours pas compilée automatiquement par le script d'installation de GCC.
J'en profite pour lancer une idée que j'avais eu par rapport au rendu de certaines textures. Je remarque que quand les textures sont petites les détails sont souvent très difficiles à voir, parce que l'épaisseur des traits se perd dans la distance. Est-ce que ce serait techniquement faisable d'avoir (1) plusieurs versions de la même texture pour différentes tailles, ou (2) texturer un triangle avec une fonction qui dessine les pixels à la main ?
Citer : Posté le 23/08/2021 22:44 | #
Excellent, je vais mettre à jour Gint et m'appuyer sur ce que tu m'avais dit dans ton message précédent (si tout est toujours valable)
Parfait, qsort était presque indispensable, c'est lui qui sert au trie en profondeur des éléments pour optimiser l'ordre d'affichage.
Alors, en effet, comme je calcule l'aire en pixel du triangle avant son affichage, il est possible en fonction de son l'aire d'effectuer des actions différentes. pour le 1, c'est bien possible ! J'imagine rapidement que cela nécessiterait quelques modif mineures, un switch fonction de la valeur de l'aire mais aussi d'ajouter dans Windmill la notion que une texture peut avoir plusieurs bitmap en fonction d'une valeur seuil (l'aire affichée). Rien d'impossible 🙂
Pour le point 2, j'avais pensé un moment de dessiner 3 traits qui forment les contours du triangle si son aire est faible. Mais je n'ai pas donné suite à ça. Sinon, en dehors de ce hack simple, je ne vois pas comment faire de "dessin à la main" même si je comprends l'idée.
Sinon j'avais pensé aussi, que si l'aire est faible (2x2 pixels ou 3x3 par exemple) dessiner full black. Ça limite l'effet de scintillement. Pas testé non plus
Citer : Posté le 23/08/2021 22:45 | #
Hum, pour le 1., je ne crois pas dire de bêtise si je dit que Deadly World 3D utilise cette technique là aussi
Citer : Posté le 29/08/2021 11:23 | #
Ok intéressant Shadow ! Merci pour l'info
Ajouté le 02/09/2021 à 23:12 :
Après une longue période sans nouvelles officielles je vous annonce officiellement que Windmill tourne avec les derniers (et même un peu plus) standards de compilation : Gint & C++
Il m'aura fallu bien plus de temps que je ne l'imaginais pour installer Gint, comprendre son fonctionnement, comprendre le fonctionnement du terminal, adapter le code du jeu... J'avais un peu avancé sur l'adaptation en y allant cran par cran jusqu'à ce le C++ soit un obstacle pour continuer.
Lephénixnoir ce sera bien démené mais nous y sommes arrivé !
Que du texte, pas grand chose à montrer, hormis un rendu pas très joli.
Il faut que je refasse une passe sur le code pour voir ce qui cloche car les textures ne sont pas sur bien rendu, il doit y avoir quelques erreur de calculs de ci de là.
Et il faut aussi que je regarde pourquoi le jeu crach dès que je regarde trop à droite ou à gauche.
J'ai a nouveau la main pour avancer comme il se doit. Des nouvelles prochainement sans doute !
Citer : Posté le 02/09/2021 23:20 | #
Par curiosité, est-ce que tu as vu une différence en termes de performances ?
Citer : Posté le 02/09/2021 23:33 | #
Je ne peux apporter aucune conclusion pour l'instant car le jeu est rythmé différemment par rapport à l'ancienne version :
Le moteur graphique tournait en boucle
Le moteur physique était timé avec des timers.
Là pour simplifier la migration les deux sont dans une boucle while(1)
Donc je ne peux pas trop comparer. Il faut que je reprenne comme c'était fait avant puis que je compare avec en faisant une mesure des fps pour en avoir le coeur net.
En tout cas là, c'est déjà jouable
Citer : Posté le 03/09/2021 07:04 | #
Bien joué !
Hâte d'avoir des premières images du rendu, bonne chance pour la suite de l'adaptation
Ça signifie que Windmill sera portable vers 90+E dans le futur ?
@RDP btw
Citer : Posté le 04/09/2021 15:26 | #
Hey, excellent ! Ce sujet rappelle des bons souvenirs
Il n'est pas très probable qu'il y ait des grosses différences de performances parce que c'est beaucoup de calcul. Mais il y a quelques opportunités d'optimisation fournies par gint, qui peuvent être saisies si le code est programmé pour.
Ça signifie que Windmill sera portable vers 90+E dans le futur ?
Il n'y avait rien dans le code original de Windmill qui soit fondamentalement incompatible avec la Graph 90. gint aide, mais il n'y a pas besoin de beaucoup de support. Le vrai problème ce sera plutôt comment maintenir les performances avec un écran aussi grand, et ça je pense que Ninestars sera d'accord que ce serait une grosse inconnue. Donc portable oui, utilisable la question reste ouverte jusqu'à ce que ce soit testé.
Citer : Posté le 05/09/2021 12:43 | #
Merci de vos retours !
En effet il n'y a rien d'incompatible. Mais il y a deux choses qui vont prendre plus de ressources :
- pour chaque pixel dessiné aller chercher les trois canaux R + G + B au lieu de un actuellement.
- plus de pixels à dessiner. La c'est strictement proportionnel, si on ajoute 4x plus de pixel ça sera 4x plus lent
Mais de toute façon je n'ai pas de Graph couleur pour essayer