Salut au départ j'avais réalisé ce framework pour développer des jeux voir même d'autres applications. 

J'étais super motivé.

Je crois que le problème c'est comme tu dis ce projet ne me rapporte rien (c'était pas mon but de le vendre) et que je n'ai encore rien fait de concret.

Je pensais que une fois le moteur presque fini ça serait un plaisir de l'utiliser mais non et même avec unity je n'ai plus aucune motivation.

Salut! J'ai un bug d'affichage sous windows avec la classe filedialog.

Je n'ai pas se problème sous linux.

J'ai imprimé les valeurs des positions pour voir ce qui se passe et j'ai une valeur qui change toute seule.

Elle passe de 400 à -2.xxxxxx..... de plus quand je fais -2.xxxxxxx + y ça m'affiche -2.xxxxxx et non pas -2.xxxxxx + y.

Du coup lorsque je sélectionne le dossier les fichiers ne s'affichent pas.

Bref, je pense que je vais arrêter parce que ça commence à me saouler.

-
Edité par OmbreNoire 5 mai 2020 à 15:49:51

Salut!

J'ai installé virtual box pour essayer de faire tourner ubuntu 20.04 malheureusement, ça n'a pas fonctionné, ça plante à l'installation d'ubuntu.

Je ne peux plus tester cela sous linux, mon PC portable est mort (l'écran ne fonctionne plus de tout façon il est trop lent) et je n'ai pas envie de risquer de mettre linux sur mon nouveau PC de peur de perdre windows et tout mes jeux si ça ne fonctionne pas.

Je suis donc bloqué avec ce bug mingw pour le projet ODFAEG Creator qui était sensé être une interface graphique pour mon moteur de jeux.

Je te conseille d'aller chercher VMware player qui est bien mieux:
https://my.vmware.com/en/web/vmware/free#desktop_end_user_computing/vmware_workstation_player/15_0

Ensuite tu vas chercher une image de Linux, par exemple:
https://www.linuxvmimages.com/

Ok avec vmware ça fonctionne!

Le seul soucis c'est que j'ai une erreur d'incompatibilité avec le noyaux apparemment lorsque j'essaye d'installer le driver propriétaire nvidia sous linux du coup je vais devoir travailler avec l'opengl plus ancien puisque mesa ne supporte que le GLSL 1.4 et donc pas l'instanced rendering par contre les extensions d'opengl 4.6 sont supportées c'est ça qui est bizarre.

Purée les développeurs de mesas sont vachement hors tard sur windows je fais déjà de l'instanced rendering pour optimiser parce que j'ai quand même beaucoup de passes à faire bref on va voir à combien de FPS je tourne avec mesa mais sur mon PC portable j'arrivais à 2 FPS mais ici c'est une nouvelle machine donc on va voir...

EDIT : Pfff les extensions vers opengl 4 ne sont même pas supportées, je ne sais pas ce qu'il m'a mit comme driver avec la virtualisation mais il m'en faudrait un plus récent...

EDIT 2 : bon apparemment il faut installer vsphere et esxi mais j'ai un écran mauve : no place on disk to dump data... 

-
Edité par OmbreNoire 13 mai 2020 à 21:09:56

VMware ne supporte que OGL3, mais tu ne trouveras pas mieux en virtualisation.

Le meilleurs moyen de faire du multiboot, c'est d'avoir un deuxième disque et tu choisie ton boot dans le bios. Comme ça, aucun risque de briser ton autre OS.

C'est ce que j'ai essayé de faire mais au démarrage il démarre direct sur windows il ne me propose pas de choisir entre windows et ubuntu pourtant j'ai installé ubuntu sur le deuxième disque dur et windows est installé sur le premier.

Je ne comprends pas sur mon portable j'avais un menu qui me permettait de choisir sur quel os démarrer mais avec mon nouveau PC il n'y est pas.

-
Edité par OmbreNoire 14 mai 2020 à 15:56:58

C'est normal qu'il ne te le demande pas au démarrage (car dans ce cas tu as modifié ta partition et c'est ça qui est dangereux)

Il faut que tu passe par le boot menu du BIOS



La touche dépend du motherboard, tu devrait voir le message en démarrant le PC.
Ensuite tu choisie, ton second disque.
Ou si tu veux vraiment être certain de rien briser, tu débranche l'autre disque.

J'ai essayé mais il ne me trouve pas le boot de ubuntu ça me met error select a proper device to boot. (un message du genre)

Ha oui pour le premier disque il me met UEFI hard disk dans le bios par contre pour le second disque il me met seulement hard disk.

Et lorsque je veux créer la clé usb bootable avec rufus j'ai le choix entre MBR partition scheme for BIOS or UEFI ou GPT je dois choisir quoi ?

Sinon je dois mettre me second disque en UEFI ? Comment on fait ça ?

PS : le vendeur me dit qu'il faut installer linux sur le premier disque dur.

Mais c'est dangereux de faire ça, sur mon ancien PC une fois je l'ai fait et il y avait eu un problème avec grub après l'installation d'ubuntu, j'ai du réinstallé windows.

-
Edité par OmbreNoire 18 mai 2020 à 14:44:05

Le but est de ne pas utiliser grub justement.
UEFI c'est mieux je crois, sinon MBR. Peut-importe, l'installeur linux devrais gérer la création d'une nouvelle partition (et il faut qu'elle soit bootable).

Salut,

Pour faire une dualboot Windows / Linux, installer Windows en premier est le mieux. Donc sur ce point, aucun souci pour toi puisque tu avais déjà Windows.

Maintenant, si tu veux mettre Linux sur un second disque, ça ne pose aucun souci (c'est ce que j'ai fait pour mon ArchLinux). Tu mets ton root (point de montage /) et éventuellement d'autres partitions (/home en particulier) sur ton deuxième disque.

[Sur ma capture d'écran on ne voit que la parition root "/" car les autres partitions sont sur d'autres disques]

Pour le boot par contre, c'est différent. Tu devrais avoir une partition EFI sur ton premier disque (celui avec Windows). Dans le processus d'installation, c'est cette partition que tu dois sélectionner en tant que partition de boot (point de montage /boot/efi). ATTENTION: ne formate surtout pas /boot ou tu perdras la possibilité de booter sur Windows ! Tu dois uniquement définir le point de montage sur /boot/efi.

[Disque où se trouvent les partitions EFI et celle de Windows]

La seule chose que j'ignore, c'est s'il y a des choses à faire spécifiquement dans l'installeur d'Ubuntu. Avec ArchLinux, tout se fait manuellement en ligne de commandes...

-
Edité par Anonyme 21 mai 2020 à 15:41:12

Bah ubuntu il me met tout automatiquement sur le second disque, même pas de partition bootable.

Alors forcément ça ne boot pas 

-
Edité par OmbreNoire 21 mai 2020 à 20:42:23

Tu as essayé une installation automatisée ? Comme installer Ubuntu en dualboot sur un autre disque est un cas particulier (non prévu par l'installation automatisée qui n'est faite que pour installer Ubuntu sur le même disque que Windows), je pense qu'il faut passer en mode "manuel". Ce n'est pas compliqué en soit.

Il faudrait créer les partitions et définir les points de montage correspondants ("/", "/home", "swap", [facultatif: "/tmp"]) sur le disque n°2. A priori tu ne risques rien si ton disque est totalement destiné à Ubuntu.

Sur le disque n°1, tu dois définir le point de montage "/boot/efi" de la partition EFI déjà créée mais sans la formater.

Je comprendrais bien entendu que tu craignes faire cette manipulation.

Une autre piste serait de prendre un disque USB 3.0 et d'y installer Ubuntu dessus. Tu choisirais de lancer le boot de l'ordinateur sur le disque USB, un peu comme avec un LiveUSB (sauf qu'ici le système garde les modifications/fichiers sur le disque). Le souci, c'est que c'est moins confortable puisque c'est nettement moins réactif.

Ouais je dois passer en mode manuel à mon avis, le mode automatique ne fonctionne pas.

EDIT : bon pour la partition EFI du disque 1 là ou il y a window boot manager, j'ai la possibilité de choisir le type de partition, et là je peux choisir bios grub mais je n'ai pas de point montage "/boot/efi" j'ai juste /boot.

Mais même en installant bios grub dans la partition EFI ou il y a window boot manager, ça ne fonctionne pas, il ne me propose pas de démarrer soit sur windows ou ubuntu, il démarre direct sur windows.

-
Edité par OmbreNoire 25 mai 2020 à 14:06:52

Il y a peut-être des différences entre Ubuntu et ArchLinux.

Comme l'avais dit Maeiky, c'est normal que GRUB n'apparaisse pas au démarrage si tu ne fais rien. L'UEFI ne fonctionne pas tout à fait comme le BIOS. Avec l'UEFI, l'ordinateur démarre par défaut sur le premier élément défini dans les paramètres de la carte mère. Si tu veux booter sur autre chose, il faut intervenir. Ça se fait en appuyant sur une touche indiquée pendant le démarrage de l'ordinateur, cette touche est différente selon la marque et le modèle de l'ordinateur/carte-mère.

J'ai pris des photos de mon ordinateur pour expliquer ça un peu mieux.

Lorsque cet écran apparaît, il est indiqué (en bas) d'appuyer sur la touche F11 pour ouvrir le menu de boot (F11 est valable pour une carte-mère MSI) :

Quand j'appuie sur F11, un menu apparaît effectivement et je peux choisir entre Windows (le premier choix, ce sur quoi le PC boote par défaut), ArchLinux, le shell UEFI (un shell directement inclus dans la carte-mère dont on n'a pas à se servir) et la configuration de l'UEFI.

Avec la souris ou le clavier, il faut alors choisir de booter sur Linux. GRUB apparaît si tu l'as installé.

Enfin, dans le setup de l'UEFI on peut aussi changer l'ordre des OS. Si tu places Linux en premier, il bootera dessus par défaut. Si tu n'y vois pas Ubuntu, c'est qu'il n'a pas réussi à installer correctement le bootloader...

C'était ça! Il fallait faire F11! C'est un nouveau PC alors je ne savais pas comment fonctionait le BIOS et puis ça démarre tellement vite que je n'ai pas eu le temps de lire la touche qu'il fallait presser.

Sur mon ancient PC il ne fallait pas presser de touche, j'avais directement le menu qui s'affichait ou je pouvais choisir entre windows et linux.

EDIT : Bon je viens d'essayer avec le driver graphique propriétaire de nvidia sous ubuntu, ça ne fonctionne pas, pourtant sous windows ça fonctionne.

-
Edité par OmbreNoire 25 mai 2020 à 20:02:06

Super !! Oui, des fois c'est trop rapide pour qu'on puisse bien tout lire. La plupart du temps, ça nous arrange que ça aille vite mais d'autres fois on aimerait un peu de lenteur.

Qu'est-ce qu'il se passe avec le driver ? Tu as quelle carte graphique ?

Une nvidia geforce 1660 super. Bah les drivers propriétaires sous ubuntu ça ne fonctionne pas bien sur windows ça marche bien mais sous ubuntu j'ai un écran tout noir, j'ai essayé le driver opensource mais j'ai un message d'erreur "unreconized layout qualifie std430" pourtant les shaders compilaient avec mon ancien PC portable et une carte graphique AMD. Ils sont vachement hors tard les drivers opensources comparé aux driver propriétaires, ils ne supportent même pas l'instanced rendering et le GLSL 330.

-
Edité par OmbreNoire 26 mai 2020 à 16:11:47

J'aurai du mal à t'aider pour ça. La gestion des drivers vidéos sous Debian (et ses dérivées dont Ubuntu) m'a toujours fait peur. C'est une des raisons pour lesquelles j'ai arrêté d'utiliser ces distros. Sans parler des logiciels pas toujours très à jour, soit disant pour plus de stabilité (mais je n'ai jamais rien eu de plus stable qu'une install ArchLinux et d'instable qu'une de Debian !).

Je m'égare un peu...

Sur le site de NVidia, je vois que le driver pour supporter la GTX1660 Super est le 440.82. Est-ce que tu as installé le paquet nvidia-driver-440 du coup ?

Je n'utilise pas non plus les drivers libres. C'est louable de leur part de faire du retro-engineering mais ça ne marche pas toujours bien, surtout sur une carte récente (car ils n'ont pas eu le temps pour bien étudier les spécificités).
C'est pratique par contre pour de vieilles cartes dont les drivers officiels ne sont plus supportés...

Sur le site de NVidia, je vois que le driver pour supporter la GTX1660 Super est le 440.82. Est-ce que tu as installé le paquet nvidia-driver-440 du coup ?

Oui c'est ce paquet là que j'ai installé.

Bon je vois que il y a des différences suivant les plateformes, sur certaines ça fonctionne sur d'autre pas.

Le driver graphique fonctionne bien sous windows mais sous linux j'ai un écran noir avec le même code.

Par contre j'ai une variable qui change de contenu toute seule avec mingw hors que je n'ai pas ce problème sous linux avec g++.

Il n'y a que sous linux avec mon ancien pc que ça allait mais le driver opensource est trop lent et ne supporte pas les cartes graphiques nouvelle.

Je suis donc contraint d'arrêter le projet d'ailleurs ça fait longtemps que je n'ai plus donné de nouvelles.

PS : je pensais que c'était standard les compilateurs c++ et les drivers mais apparemment non.

-
Edité par OmbreNoire 3 octobre 2020 à 17:45:36

Je pense que tu te donne beaucoup de mal pour rien (comme moi d’ailleurs). J'ai réalisé qu'il est pas mal mieux de contribuer à des projets existants, ce qui est beaucoup plus enrichissant, plus valorisant, plus rapide à développer. Sinon on risque de foncer droit dans un mur.

Regarde les projets qui fonctionne bien, souvent ils reposent sur des fondations bien plus solide.

Malgré tout, ceci t'auras donné énormément d’expériences et des plein d'outils. De mon coté j'ai ouvert les yeux, je suis parti sur de trop grandes ambitions, mais je sens que j'ai acquis une certaine expérience et que maintenant toutes les portes sont ouverte.

Bon courage

J'ai sûrement du faire une erreur dans la programmation du moteur pour que cette variable change toute seule de contenu (même si avec mon ancien PC sous linux je n'avais pas de problème) mais bon le moteur est un peu brouillon et difficile à installer, surtout sur windows avec toutes ces dépendances bref, je pense que ce projet est trop ambitieux même pour moi, il me faudrait partir sur autre chose mais pour l'instant je n'ai pas d'idées, partir sur un projet existant peut être j'ai essayé d'installé unity 3D avec un jeux comme exemple mais j'ai une erreur quand je le lance il semble qu'il manque une dll ça me met l'application n'a pas réussi à fonctionné correctement.

EDIT : j'ai un problème avec cwc il lance l'application, au début pas de problème il m'affiche bien les fichiers dans la seconde fenêtre de la file dialog mais après cwc ferme le programme et le relance tout seul et c'est là que ça ne marche plus comme on le voit sur cette vidéo :

https://www.youtube.com/watch?v=o_cP3qxVGjQ

-
Edité par OmbreNoire 8 octobre 2020 à 18:23:58

Salut, je pense que c'est dû à l'antivirus Avast, quand tu créer une nouvelle application il doit l’analyser, ensuite il la redémarre ... pour une raison qui m’échappe...

Il faut que tu ajoute ton dossier dans la liste d'exclusion.

C'est super que tu utilise toujours Cwc, actuellement je travaille pour mettre ce projet au propre

Si tu as d'autre problèmes ou bien pour avoir une réponse plus rapidement je t'invite à joindre le discord:
https://discord.gg/SjPYMP


Si tu veux un projet C++ plutôt solide (sans être trop dépaysé) il y a celui-ci:
https://github.com/floooh/sokol

Et une version Cwc (en cours):
https://github.com/Cwc-Lib/Sokol

-
Edité par Maeiky 9 octobre 2020 à 21:10:29

Ouais c'est l'anti-virus qui fou la merde mais quand je lance l'exécutable (sans le run avec cwc) ça fonctionne là l'anti virus n'analyse plus le fichier.

J'ai réglé quelques bugs comme le redimensionnement des interfaces graphique de ODFAEG creator lorsque je redimensionne la fenêtre. 

J'ai aussi réglé le problème du crash lorsque je lance ODFAEG demo en release.

J'ai essayé d'effacer les fragments d'ombre si il y a un fragment d'objet qui est devant le fragment d'ombre mais ça ne fonctionne pas donc j'ai mit le code en commentaire dans le FS.

R"(#version 460 core
                                                                          in vec4 shadowCoords;
                                                                          in vec4 frontColor;
                                                                          in vec2 fTexCoords;
                                                                          uniform sampler2D texture;
                                                                          uniform sampler2D stencilBuffer;
                                                                          uniform sampler2D depthBuffer;
                                                                          uniform float haveTexture;
                                                                          uniform vec3 resolution;
                                                                          layout (location = 0) out vec4 fColor;
                                                                          void main() {
                                                                            vec2 position = (gl_FragCoord.xy / resolution.xy);
                                                                            vec4 depth = texture2D(depthBuffer, position);
                                                                            vec4 texel = texture2D(texture, fTexCoords);
                                                                            vec4 colors[2];
                                                                            colors[1] = texel * frontColor;
                                                                            colors[0] = frontColor;
                                                                            bool b = (haveTexture >= 0.9f);
                                                                            float color = colors[int(b)].a;
                                                                            vec4 stencil = texture2D (stencilBuffer, shadowCoords.xy);
                                                                            float z = gl_FragCoord.z;
                                                                            colors[1] = vec4 (0, 0, 0, color);
                                                                            colors[0] = vec4 (1, 1, 1, 1);
                                                                            b = (stencil.z < z);
                                                                            /*vec4 visibility;
                                                                            if (stencil.z < z) {
                                                                                if (depth.z >= z) {
                                                                                    visibility = vec4 (1, 1, 1, depth.a);
                                                                                } else {
                                                                                    visibility = vec4 (0, 0, 0, color);
                                                                                }
                                                                            } else {
                                                                                visibility = vec4 (1, 1, 1, 1);
                                                                            }*/
                                                                            vec4 visibility = colors[int(b)];
                                                                            fColor = visibility;
                                                                          }
                                                                          )";

Le but est de pouvoir dessiner la couche d'ombre après tout les objets car en 3D je ne peux pas dessiner la couche du sol et puis celle des ombres et puis celle des bâtiments il faudrait que je dessine le sol et les bâtiments sur la même couche car une partie du sol si il est en hauteur peut cacher une partie voir tout un bâtiment hors si je fais comme ça les bâtiments vont toujours s'afficher devant le sol. Et aussi une ombre peut aussi s'afficher sur un bâtiment si il y a une ombre d'un autre bâtiment qui est devant. 

Mais bon mon shader ne marche pas, l'ombre vient quand même s'afficher sur le bâtiment même si le bâtiment est devant l'ombre..., pourtant ma texture de profondeur est bonne je l'ai affichée, j'ai mit tout à jour sur git.

Bref là, je sèche!

PS : cwc fonctionne bien mieux que cmake surtout sur windows, donc oui je l'utilise toujours.

-
Edité par OmbreNoire 10 octobre 2020 à 17:04:25

J'ai remarqué deux bugs que je n'avais pas sous linux, d'abord les scrollbars qui ne s'affiche plus lorsque je les descends jusqu'en bas et pas moyen de les remonter et crash lorsque je sélectionne une texture avec la filedialog..., j'essayerai de regarder ça quand j'en aurai le courage...

Problème avec les scrollsbar corrigé et j'en ai profité pour faire quelques petits changements :

-Désormais un test est fait entre la position en z des ombres et celles des autres entités, ceci permet de savoir si une ombre doit s'afficher sur une entité ou pas.

-J'ai modifié la classe tground pour l'adapter avec l'instanced rendering en 3D mais je n'ai pas encore pu tester. (Je peux pas dessiner n fois la même tile comme en 2D parce que en 3D la position en z des sommets est différente pour chaque sommet pour les sols en pente, alors je me suis dis je vais modifier la classe pour dessiner tout les sommets du sol (utilisant le même matériel) une fois)

Pour des raisons de performance (pour pas combiner les matrices à chaque draw call et éviter de devoir faire des copies de matrices) je ne combine pas les transformations des entités enfants avec celles de leur parent parce que en plus ça ne rend pas bien et je préfère laisser l'utilisateur choisir si il veut le faire ou pas, en effet, l'utilisateur peut le faire si il le veut en redéfinissant les méthodes onMove, onScale et onRotate de la classe Entity.

EDIT : plutôt que de faire une adaptation pour l'instanced rendering j'ai plutôt choisi de laisser l'utilisateur choisir comment il veut dessiner l'entité. (en instanced rendering, en based instanced rendering ou en normal)

Je trouve que c'est mieux.

EDIT 2 : Tiens il ne me dessine pas le terrain en 3D avec la per pixel linked list je n'avais pas se problème sous linux par contre pour la 2D pas de problème.

-
Edité par OmbreNoire 20 octobre 2020 à 17:22:23

Correction d'un bug maintenant le sol en 3D se dessine bien avec les listes chaînées par pixel, il fallait que je mette une vue en 2D et non pas en 3D pour dessiner le quadrilatère plein écran.

EDIT : du coup j'ai du mettre à jour le composant avec une nouvelle variable booléenne draw2D, car en 2D je dois remettre à jour la vue et la position du quad qui se déplace en même temps que la scène ce qui n'est pas le cas en 3D ou là je dessine la scène en 3D et puis le quad dans la fenêtre en 2D mais la vue en 2D ne bouge pas.

EDIT 2 :

-Le projet utilisera désormais cwc qui est bien plus pratique à utiliser que cmake qui sous windows m'engendre pleins d'erreur du style qu'il n'arrive pas à compiler un simple projet ou encore des erreurs qu'il ne me trouve pas certains fichiers. Les fichiers cmake deviennent obsolète.

-Seul la version windows sera maintenue, j'ai remarqué que les drivers graphiques (du moins les récents) fonctionnent mieux sous windows que sous linux et sont plus rapide.

-Seul l'opengl moderne sera maintenu, en effet les per-pixel-linked-list sont bien plus pratiques et offrent un meilleur rendu que le weighted blended OIT, seule les composants de rendu PerPixelLinkedListRenderComponent, ShadowRenderComponent et LightRenderComponent seront maintenu, les autres composants tel que DepthPeelingRenderComponent, OITRenderWomponent et ZSortingRenderComponent deviennent obsolète.

Au départ j'avais une idée de mettre tout dans un seul et même VBO et d'envoyé les indices des sommets visible pour les dessiner mais ça m'a posé quelques problèmes :

-Pour des entités qui disparaissent comme les particules ça faisait un trou dans mes VBO et donc je devais décaler tout les éléments se trouvant après l'élément supprimé pour bouché le trou et c'est lent.

-Je devais remettre à jour le VBO à chaque modification de la matrice de transformation d'une entité, j'avais passé un tableau de matrices de transformation en uniform aux shaders mais si la taille du tableau de matrice change il faut recompiler le shader ce qui est lent.

J'ai donc laissé tombé cette idée.

Maintenant je récupère ce qui est visible, je prétransfome et puis je dessine, c'est plus simple et rapide.

Il se peut donc que il y ai encore de l'ancien code dans le framework que j'ai mit en commentaire.

-
Edité par OmbreNoire 21 octobre 2020 à 22:16:26

Mise à jour à venir : optimisation des shaders et ajout d'un nouveau composant. (ReflecRefractRendercomponent pour la réflection et la réfraction) 

Pour le rendu des ombres j'ai fais une depthTexture et j'ai testé si un objet venait caché l'ombre ou pas et en fonction de la transparence de cet objet j'ai calculé la couleur du fragment.

Le problème est le suivant : plusieurs objets semi-transparent peuvent venir devant l'ombre, dans ce cas je dois faire une linked list pour calculer la composante alpha finale de tout ses objets et enfin calculer la couleur finale de l'ombre.

Et même chose pour la réflexion/réfraction si j'ai plusieurs objets semi-transparents devant l'objet qui reflète.

Pour gérer la réflexion, réfraction j'ai décidé d'essayé ce procéder :

Je dessines toutes les entités visibles avec comme vue, la vue de l'objet qui reflète (par exemple de l'eau) qui regarde en direction du rayon de réfraction.

Ensuite  je dessine l'objet qui reflète en récupérant la couleur de l'objet reflété sur la texture suivant l'indice de réflexion et je vais ajouter un textureOffset suivant l'indice de réfraction ce qui va donner quelque chose de ce genre :

const std::string buildFramebufferShader = R"(#version 460 core
                                                                in vec4 reflectRefractCoords;
                                                                in vec4 frontColor;
                                                                in vec2 fTexCoords;
                                                                uniform float haveTexture;
                                                                uniform float maxRefraction;
                                                                uniform vec3 resolution;
                                                                uniform sampler2D texture;
                                                                uniform sampler2D depthTexture;
                                                                uniform sampler2D reflectRefractFactorTexture;
                                                                uniform sampler2D reflectRefractTexture;
                                                                layout (location = 0) out vec4 fColor;
                                                                void main () {
                                                                    vec2 position = (gl_FragCoord.xy / resolution.xy);
                                                                    vec4 depth = texture2D(depthBuffer, position);
                                                                    vec4 reflectRefractInd = texture2D (reflectRefractFactorTexture, position);
                                                                    float offsetX = reflectRefractInd.y * maxRefraction;
                                                                    vec2 offs = vec2 (offsetX, 0);
                                                                    vec4 colorToReflect = textureOffset (reflectRefractTexture, position, offs);
                                                                    vec4 texel = texture2D(texture, fTexCoords);
                                                                    vec4 colors[2];
                                                                    colors[1] = texel * frontColor;
                                                                    colors[0] = frontColor;
                                                                    bool b = (haveTexture > 0.9);
                                                                    float color = colors[int(b)];
                                                                    if (depth.z >= z) {
                                                                        fColor = vec4 (color.rgb,1-depth.a) * (1 - reflectRefractInd.x) + vec4(colorToReflect.rgb,1-depth.a) * relfectRefractInd.x;
                                                                    } else {
                                                                        fColor = color * (1 - reflectRefractInd.x) + colorToReflect * relectRefractInd.x;
                                                                    }
                                                                }
                                                              )";

Le if (depth.z >= z) va disparaitre, au profit d'une texture qui contiendra la valeur alpha finale de tout les fragments se trouvant devant l'objet reflété.

EDIT : ou alors non je vais faire plus simple dessiner tout dans le même composant ainsi je n'aurai plus de problème avec la position z et le calcul de la transparence si un objet vient devant ou derrière une lumière, une ombre ou un objet reflété, maintenant qu'il y a imageLoadStore c'est facile je peux récupérer la couleur en temps réel, tout trier en fonction de la position z de tout mes objets (lumières, ombres, etc...) et appliquer le blending correspondant si c'est une lumière, une ombre ou un objet.

-
Edité par OmbreNoire 23 octobre 2020 à 16:36:25

Le dernier défi à réaliser pour mon moteur de jeux pour qu'il réalise au moins la même chose qu'un autre moteur de jeux : la réflexion et la refraction ainsi que le rendu de l'eau.

J'ai ajouté un nouveau composant de rendu (ReflectRefractRendercomponent) mais je ne l'ai pas encore testé le but est de dessiner une surface d'eau et essayer de la rendre en reflétant par exemple une lumière ou un objet, bref, je testerai plus tard.

Je compte aussi mettre un vertex shader spécial dans la classe PerPixelLinkedListRenderComponent pour déplacer les sommets de la texture d'eau et changer la couleur pour ainsi faire des vagues.

EDIT : voilà j'ai testé j'ai bien une texture qui se reflète sur l'eau mais le problème c'est que il y a une limite avec textureOffset ça ne marche pas si bien je vais utiliser une matrice de réfraction à la place.

-
Edité par OmbreNoire 25 octobre 2020 à 4:46:56