Discussion :

[PixelJuice]

Il fait comme il veut !
Tant qu'il s'amuse et répond à ce pourquoi il a commencé le projet ca le regarde

Surtout que c'est intéressant !

1. Il ne s'amuse pas, il l'a dit lui-même à plusieurs reprises, il est en souffrance même je dirais
2. Certains ici même ont aussi fait des moteurs maisons mais n'ont jamais eu la prétention d'égaler Unity & Unreal, tout en ayant trouvé une niche qui permet à leur moteur d'être quand même utile
3. Ca serait intéressant si c'était pas ultra fouillis ou alors si ça ne changeait pas de direction tout le temps. Rien qu'avec la compatibilité avec Vulkan ou il a changé d'avis 5 fois dessus au minimum
4. Le but de son moteur (je le cite toujours lui) c'était de faire son propre jeu et le moteur même après des années ne peut rien faire tourner. C'est bien de respecter la persévérance d'un Don Quichotte mais ça n'enlève rien à l'absurdité de sa quête.

Nous ne sommes pas là à lui dire ça par plaisir et de lui dissuader de faire un moteur (surtout que l'hégémonie d'Unity et d'Unreal est déjà très néfaste pour l'industrie du JV). Mais à un moment, il s'agirait pour lui de tirer des conclusions et surtout, de se mettre au Game Dev.

Donc je conclurai avec une citation apocryphe d'Einstein comme la tienne :

« La folie, c'est de faire toujours la même chose et de s'attendre à un résultat différent »

[Invité]

D'autant plus qu'il y a des solutions bien plus efficaces (et maintenable), si tu galeres sur le moteur 3d, prend une lib qui fait ca bien, Ogre3d par exemple, met une couche d'abstraction au dessus, et tu peux attaquer ton jeu, quand le jeu tourne, si tu veux vraiment revenir sur ton moteur 3d perso, tu changes l'implementation sous l'abstraction par le tien et tu as au moins un resultat.

En prime ca permet de comparer et de tester ton moteur 3d en condition reelle.
Pour l'instant ca ressemble plus a un amalgame de POCs qu'a une solution utilisable.

[Bousk]

Salut l'algorithme est assez complexe (comme tout les algorithmes de mon moteur de jeux)

En tous cas la lecture de ce fichier gridMap.cpp a au moins le mérite de faire rire de bon matin
Entre la const-correctness inexistante, les copies superflues de partout et un amour des boucles, comment s'étonner que ton truc peine à sortir 5fps
11 ans et écrire du code aussi médiocre, tu es libre de continuer mais c'est même plus foncer dans le mur là: tu en as déjà abattu une dizaine et n'as clairement toujours rien appris
un retour à la réalité serait nécessaire

[Laurent7601]

Salut! J'ai 60 FPS en 3D, pas 5FPS. Je n'ai pas encore testé des scènes plus complexes par contre mais pour le moment, je reste sur la 2D. Mais je n'ai plus vraiment de problème de performances. Ici je suis entrain de corriger et finaliser mon système de guizmos, ça va ça marche comme c'était le cas avec la version opengl.

Pour faire taire les mauvaises langue j'ai décidé de m'y mettre sérieusement cette fois, finir l'éditeur et continuer le mmorpg.

Et je ne fais pas de copies avec la grille pendant le rendu...

[UneMouchePasse]

60fps en affichant quoi ? Ça veut rien dire je peux afficher un cube qui tourne à 60fps

[Laurent7601]

Salut j'ai dû annulé la soumission des commandes buffers primaires dans plusieurs threads pour mes textures de rendu car j'avais des problèmes :

-Affichage incohérent ne se remettant pas à jour assez vide et comme je soumettais dans plusieurs thread ça exécutait pas le rendu de manière synchronisée.
-Echec de l'envoi des commandes buffers côté vulkan.

J'ai dû annulé aussi l'enregistrement des commandes buffers secondaire de la frame n+1 pendant la soumission de la frame n car j'avais des dreadlocks.

Évidement je suis repassé de 60 à 48 FPS comme je m'y attendais mais mieux vaut cela plutôt qu'un mauvais rendu et des crash vulkan dû à l'échec d'envoi de command buffers.

Voici la scène que je rend actuellement :



C'est déjà bien avec tout ce que j'affiche d'avoir ce FPS là. (Heightmap, modèle 3d (non animé) avec outline, modèle 3D animé, cube avec réfraction, ombres et lumières et aussi gestion de la transparence)

Donc mon rendu est assez gourmand même si l'on pourrait pensé que je ne dessine pratiquement rien, mais je vais essayer de voir avec une scène plus complexe plus tard mais pour l'instant la priorité est de finir mon éditeur.

[Laurent7601]

Salut! J'ai vraiment des difficultés pour afficher la scène bistros parce que les textures au format .dds, alors en plus gli n'arrive pas à les lire parce que ce sont des fichiers .dds non conforme généré avec ImageMagic. Donc je dois les convertir tous et il y en a beaucoup...

[wax78]

Salut! J'ai vraiment des difficultés pour afficher la scène bistros parce que les textures au format .dds, alors en plus gli n'arrive pas à les lire parce que ce sont des fichiers .dds non conforme généré avec ImageMagic. Donc je dois les convertir tous et il y en a beaucoup...

Ne t'occupes pas des textures pour le moment, fait un clay render/ambiant occlusion. Donc pas de textures, tu mets tout en blanc diffus et tu verras pour les textures plus tard. Ca sera surement plus motivant que de s'échiner sur les textures pour le moment, ou au pire, tu utilise la même texture pour tout qui est juste un "pixel blanc".

[Laurent7601]

J'ai finalement réussi à charger les textures et j'en ai profité pour optimiser mon chargeur de modèle 3D (une face par mesh d'assimp et non pas une face par assimp face, ça réduit le nombre d'allocations), mais j'ai encore un plantage lors du chargement de la troisième partie de la scène (bistro_intérior_wine) hors que les deux premières parties se chargent sans problème, et c'est très long à charger plus de 2 millions de polys...

Peut être que ça plante car trop de sommets à charger.

Pourtant je n'ai aucun crash avec les modèles plus petits.

[UneMouchePasse]

Non écoute, tout le monde peut afficher un petit cube, une height map c'est pas plus compliqué, deux trois textures, deux trois lumières. Par contre faire du rendu pour des millions de poly le tout avec de la lumière des particules, de la physique et des animations ce n'est pas possible tout seul. La preuve. Et le problème c'est pas vulkan ou ta carte graphique, c'est ton "moteur"

[Laurent7601]

Salut! C'est vrai que mon moteur n'est pas fait pour afficher des millions de polys en même temps, j'ai essayé et ça rame, tout seul je peux pas faire un tel jeux. Déjà parce que je n'ai pas les connaissances requises pour rendre des millions de poly de manière fluide. Pourtant je fais du frustrum culling, du batching et du multithread...

EDIT : En même temps je ne fais pas encore de culling GPU donc..., c'est lent.

[UneMouchePasse]

Après tu t'amuses tu fais ce que tu veux mais viens pas dire je veux faire un moteur AAA et le vendre c'est juste impossible

[Laurent7601]

Salut! En effet je me suis rendu compte que c'est impossible que ODFAEG puisse afficher des millions de poly de manière fluide, ODFAEG n'a pas été conçu pour cela, je voulais que ODFAEG soit un moteur plus flexible à la place. C'est ça qui le différencie des moteurs de jeux actuels comme Unity, Unreal ou encore godot.

Il y a déjà un problème majeur : mon GPU (ma gforce GTX 1660 super) ne supporte pas les mesh shader ce qui cause problème si je veux optimiser avec du driven-rendering comme les moteurs de jeux AAA font parce que :

-J'ai des entités dont le nombre de sommets peut changer ainsi que les positions des sommets, coordonnées de textures et couleurs, comme mon système de particule par exemple : il peut avoir plusieurs émetteurs et affecteurs et même des émitteurs et affectors personnalisés pour les particules, c'est donc impossible d'avoir un grand vertex buffer que je peux mettre à jour sans devoir mettre à jour le grand vertex buffer et index buffer de toute la scène ce qui serait lent. (Car pas de mesh shader)

-Un autre point noir : pas de batching donc je dois faire une draw indirect command par mesh au lieu d'en faire un par matériel et topologie.

Donc c'est en effet impossible que ODFAEG devienne un moteur de jeux AAA. Je me contenterai du moteur pour créer des jeux avec des scènes en low poly en 3D. Si je veux faire du high-poly la flexibilité du moteur m'obligerais à racheter un nouveau GPU RTX et sûrement un nouveau PC pour le support des mesh shaders, mais c'est pas le but pour le moment, je veux d'abord faire un jeux tout simple, non complexe, avec juste un éditeur et un système de scripts. J'optimiserai ODFAEG avec des meshs shader lorsque mon PC actuel sera foutu et que je devrais en racheter un nouveau et donc, pas tout de suite.

[Mat.M]

ODFAEG n'a pas été conçu pour cela, je voulais que ODFAEG soit un moteur plus flexible à la place. C'est ça qui le différencie des moteurs de jeux actuels comme Unity, Unreal ou encore godot.

pour avoir un moteur plus flexible il faut un moteur de script interne.Est-ce le cas ?
Ensuite comment faites-vous pour activer la technique du frustum culling avec les shaders ?
C'est possible ceci ?
Sinon on attend toujours votre projet de jeu

[Laurent7601]

pour avoir un moteur plus flexible il faut un moteur de script interne.Est-ce le cas ?

Je suis entrain d'en faire un.

Ensuite comment faites-vous pour activer la technique du frustum culling avec les shaders ?

J'envoie mes AABB dans un compute shader et je rempli le draw indirect command buffer avec ce même compute shader, il parait que l'on peut aussi faire du z occlusion et ce genre de choses pour optimiser. (Mais je ne pourrais vraiment le faire de manière optimisée que lorsque j'aurais une nouvelle carte qui supporte les mesh shaders)

Mais je pense que j'optimiserai plus tard la priorité maintenant :

-Résoudre les derniers crashs (apparemment j'ai encore quelques accès concurrents par moment), finir l'éditeur pour enfin faire mon premier jeux avec le moteur!!! Je pense que je pourrais débuter le premier jeu, l'année prochaine si tout va bien car ça avance bien. Aujourd'hui j'ai du m'arracher le crâne pour résoudre des erreurs vulkan (device lost) mais ici ça va j'ai plus de device lost.

[dragonjoker59]

Affichage incohérent ne se remettant pas à jour assez vide et comme je soumettais dans plusieurs thread ça exécutait pas le rendu de manière synchronisée.

On génère les command buffers de manière asynchrone, puis on les envoie à une queue via un seul thread...
L'async GPU c'est pas toi qui le gères, c'est le driver, et si tu essaies de faire du multi-queue, il te faut mettre les barrières qui vont bien, avec transfert de responsabilité d'une queue à une autre, répartir correctement la charge sur les différentes queues, ne pas mélanger compute/graphics, ...
Tu ne veux pas faire ça...

Il y a déjà un problème majeur : mon GPU (ma gforce GTX 1660 super) ne supporte pas les mesh shader ce qui cause problème si je veux optimiser avec du driven-rendering comme les moteurs de jeux AAA (...) ce qui serait lent. (Car pas de mesh shader)

Ce n'est certainement pas le bottleneck sur ton moteur... tu peux faire du GPU driven rendering directement en compute (pour te donner une idée, je ne génère plus que mon visibility buffer, avec le rasterizer, le reste je le fais en compute)

Un autre point noir : pas de batching

A toi de le faire, c'est pas la mer à boire, de regrouper tes objets par pipeline (type de matériau + topologie)

Si je veux faire du high-poly la flexibilité du moteur m'obligerais à racheter un nouveau GPU RTX et sûrement un nouveau PC

C'est pas la flexbilité de ton moteur, le problème, c'est la poutre dans ton oeil qui t'empêche de regarder les problèmes de conception en face...

En même temps je ne fais pas encore de culling GPU donc..., c'est lent.

Pas besoin de culling GPU pour avoir plus de 60 FPS dans la scène que tu montres en screenshot...

C'est déjà bien avec tout ce que j'affiche d'avoir ce FPS là. (Heightmap, modèle 3d (non animé) avec outline, modèle 3D animé, cube avec réfraction, ombres et lumières et aussi gestion de la transparence)

Non, c'est ridiculement lent, 16ms pour afficher si peu.

Castor3D, pas particulièrement rapide, affiche ça en 4ms

Et la scène Bistro, avec juste une source lumineuse directionnelle prend 18ms (quand je disais qu'il n'est pas particulièrement rapide)

[Laurent7601]

Oui peut être que, je devrais repartir sur un culling et un batching GPU, je crois que c'est le batching/culling CPU qui ralenti tout..., surtout quand je veux afficher une scène avec des millions de poly comme la scène bistro, je pense que le goulot d'étranglement vient de là.
J'ai justement plusieurs idées pour faire cela côté GPU avec un compute shader, sans devoir modifier le grand vertex buffer pendant le rendu. (Juste modifier une partie d'un buffer quand je fais une transformation ou que je change le matériel)
Mais ça va juste me prendre un temps fou, pour optimiser le moteur...

[dragonjoker59]

Le culling CPU... Tu ne vas pas jusqu'au triangle, tout de même ? Il faut s'arrêter aux AABB...

[Laurent7601]

Salut non je ne vais pas jusqu'au triangle je fais juste un test d'AABB.

C'est mon algorithme de batching qui est lent car depuis que j'ai remplacé le if par une condition variable pour attendre après le culling+batching mon FPS a baissé de beaucoup!
Donc j'ai un goulot d'étranglement au niveau du CPU...

Donc soit ici pour le culling :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
void Scene::checkVisibleEntities(EntityFactory& factory, View& view) {
 
                    physic::BoundingBox viewVolume;
                    {
                       std::lock_guard<std::recursive_mutex> lock(rec_mutex);
                       viewVolume = view.getViewVolume();
                    }                   
 
                    visibleEntities.clear();                   
                    visibleEntities.resize(factory.getNbEntitiesTypes());
                    for (unsigned int i = 0; i < visibleEntities.size(); i++) {                        
                        visibleEntities[i].resize(factory.getNbEntities(), nullptr);
                    }
                    int x = viewVolume.getPosition().x();
                    int y = viewVolume.getPosition().y();
                    int z = viewVolume.getPosition().z();
                    int endX = viewVolume.getPosition().x() + viewVolume.getWidth();
                    int endY = viewVolume.getPosition().y() + viewVolume.getHeight()+100;
                    int endZ = (gridMap->getCellDepth() > 0) ? viewVolume.getPosition().z() + viewVolume.getDepth()+100 : z;
 
 
                    for (int i = x; i <= endX; i+=gridMap->getOffsetX()) {
                        for (int j = y; j <= endY; j+=gridMap->getOffsetY()) {
                            for (int k = z; k <= endZ; k+=gridMap->getOffsetZ()) {
                                math::Vec3f point(i, j, k);
                                CellMap* cell = getGridCellAt(point);
                                if (cell != nullptr) {
 
                                    for (unsigned int n = 0; n < cell->getNbEntitiesInside(); n++) {
                                       std::lock_guard<std::recursive_mutex> lock(rec_mutex);
                                       Entity* entity = cell->getEntityInside(n);
                                       math::Vec3f toEntity = (entity->getCenter() - view.getPosition()).normalize();
                                       if (visibleEntities[entity->getRootTypeInt()][entity->getId()] == nullptr) {
 
                                            if (toEntity.dot(view.getForward()) <= 0.0f
                                                && viewVolume.intersects(entity->getGlobalBounds())) {
                                                visibleEntities[entity->getRootTypeInt()][entity->getId()] = entity;
                                            }
                                       }
 
                                    }
                                }
                            }
                        }
                    }               
 
                    for (unsigned int c = 0; c < frcm->getNbComponents(); c++) {
                        if (frcm->getRenderComponent(c) != nullptr) {
                            std::lock_guard<std::recursive_mutex> lock(rec_mutex);
                            std::vector<Entity*> entities = getVisibleEntities(frcm->getRenderComponent(c)->getExpression(), factory);
                            frcm->getRenderComponent(c)->loadEntitiesOnComponent(entities);
                        }
                    }                
        }

Ou bien ici pour le batching à mon avis c'est plutôt ici le goulot.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
Instance::Instance () {
                numInstances = 0;
 
            }
            Instance::Instance (Material& material, PrimitiveType pType) {
                primType = pType;
                numInstances = 0;
                vertices = VertexArray(pType);
                this->material = &material;
            }
            void Instance::setPrimitiveType (PrimitiveType pType) {
                primType = pType;
                vertices.setPrimitiveType(pType);
            }
            void Instance::setMaterial (Material& mat) {
                material = &mat;
            }
            void Instance::addVertexArray(VertexArray& va, TransformMatrix& tm) {
                std::lock_guard<std::recursive_mutex> lock(rec_mutex);              ////////std::cout<<"push transform"<<std::endl;
                va.computeNormals();
                if (va.getEntity() != nullptr && !containsEntity(va.getEntity())) {
 
                    m_transforms.push_back(&tm);
 
                    m_entities.push_back(va.getEntity());
 
                }
 
 
 
                unsigned int baseVertex = vertices.getVertexCount();
                for (unsigned int i = 0; i < va.getVertexCount(); i++) {
 
 
                    math::Vec3f t;
                    if (va.getEntity() != nullptr && va.getEntity()->getDrawMode() == Entity::NORMAL
                        && (va.getEntity()->getRootType() == "E_BONE_ANIMATION" || va.getEntity()->getRootType() == "E_PARTICLES")) {
                        //std::cout<<"don't transform"<<std::endl;
                        t = va[i].position;
                    } else {
                        t = tm.transform(va[i].position);
                    }                   
                    Vertex v (t, va[i].color, va[i].texCoords);
                    v.normal = va[i].normal;
                    for (unsigned int b = 0; b < MAX_BONE_INFLUENCE; b++) {
                        v.m_BoneIDs[b] = va[i].m_BoneIDs[b];
                        v.m_Weights[b] = va[i].m_Weights[b];
                    }
                    v.entityId = va[i].entityId;
                    v.particleId = va[i].particleId;
                    vertices.append(v);
                }
                for (unsigned int i = 0; i < va.getIndexes().size(); i++) {
                    vertices.addIndex(baseVertex + va.getIndexes()[i]);
                }
 
            }
            void Instance::addVertexShadowArray (VertexArray& va, TransformMatrix& tm, ViewMatrix& viewMatrix, TransformMatrix shadowProjMatrix) {
                std::lock_guard<std::recursive_mutex> lock(rec_mutex);
                va.computeNormals();
                if (!containsEntity(va.getEntity())) {
                    m_transforms.push_back(&tm);
                    m_shadowProjMatrix.push_back(shadowProjMatrix);
                    if (va.getEntity() != nullptr)
                        m_entities.push_back(va.getEntity());
                }
                m_vertexArrays.push_back(&va);               
                unsigned int baseVertex = vertices.getVertexCount();
                for (unsigned int i = 0; i < va.getVertexCount(); i++) {
                    math::Vec3f t = tm.transform(va[i].position);
                    Vertex v (t, va[i].color, va[i].texCoords);
                    v.normal = va[i].normal;
                    for (unsigned int b = 0; b < MAX_BONE_INFLUENCE; b++) {
                        v.m_BoneIDs[b] = va[i].m_BoneIDs[b];
                        v.m_Weights[b] = va[i].m_Weights[b];
                    }
                    v.entityId = va[i].entityId;
                    v.particleId = va[i].particleId;
                    vertices.append(v);
                }
                for (unsigned int i = 0; i < va.getIndexes().size(); i++) {
                    vertices.addIndex(baseVertex + va.getIndexes()[i]);
                }
            }
            bool Instance::containsEntity(Entity* entity) {
                for (unsigned int i = 0; i < m_entities.size(); i++) {
                    if (m_entities[i] == entity)
                        return true;
                }
                return false;
            }
            std::vector<Entity*> Instance::getEntities() {
                return m_entities;
            }
 
            VertexArray& Instance::getAllVertices() {
                return vertices;
            }
            std::vector<VertexArray*> Instance::getVertexArrays() {
                return m_vertexArrays;
            }
            std::vector<unsigned int> Instance::getAllIndexes() {
                return allIndexes;
            }
            std::vector<std::vector<unsigned int>> Instance::getIndexes() {
                return m_indexes;
            }
            void Instance::clear() {
                m_transforms.clear();
                m_vertexArrays.clear();
                m_shadowProjMatrix.clear();
                vertices.clear();
            }
            std::vector<TransformMatrix*> Instance::getTransforms() {
                 std::lock_guard<std::recursive_mutex> lock(rec_mutex);
                 return m_transforms;
            }
            std::vector<TransformMatrix> Instance::getShadowProjMatrix() {
                return m_shadowProjMatrix;
            }
            Material& Instance::getMaterial() {
                return *material;
            }
            PrimitiveType Instance::getPrimitiveType() {
                return primType;
            }
            unsigned int Instance::getNumInstances() {
                return numInstances;
            }
            Instance::~Instance() {
                m_transforms.clear();
                m_vertexArrays.clear();
                m_shadowProjMatrix.clear();
                vertices.clear();
            }
 
            Batcher::Batcher() {
                numVertices = 0;
                numIndexes = 0;
                nbLayers = 0;
            }
            void Batcher::addFace(Face* face) {
 
 
                std::lock_guard<std::recursive_mutex> lock(rec_mutex);
                Instance& instance = instances[face->getMaterial().getId() * nbPrimitiveTypes + face->getVertexArray().getPrimitiveType()];
 
                instance.setPrimitiveType(face->getVertexArray().getPrimitiveType());
                instance.setMaterial(face->getMaterial());
 
                instance.addVertexArray(face->getVertexArray(),face->getTransformMatrix());                
 
 
            }
            void Batcher::addShadowFace(Face* face, ViewMatrix viewMatrix, TransformMatrix shadowProjMatrix) {
                std::lock_guard<std::recursive_mutex> lock(rec_mutex);
                Instance& instance = instances[face->getMaterial().getId() * nbPrimitiveTypes + face->getVertexArray().getPrimitiveType()];
                instance.setPrimitiveType(face->getVertexArray().getPrimitiveType());
                instance.setMaterial(face->getMaterial());
                instance.addVertexShadowArray(face->getVertexArray(),face->getTransformMatrix(), viewMatrix, shadowProjMatrix);
 
            }
            std::vector<Instance> Batcher::getInstances() {
 
                return instances;
            }
            unsigned int Batcher::getNumIndexes() {
                return numIndexes;
            }
            unsigned int Batcher::getNumVertices() {
                return numVertices;
            }
            unsigned int Batcher::getNbLayers() {
                return nbLayers;
            }
            void Batcher::resize() {
                std::lock_guard<std::recursive_mutex> lock(rec_mutex);
                instances.resize(nbPrimitiveTypes * Material::getNbMaterials());
            }
            void Batcher::clear() {
                std::lock_guard<std::recursive_mutex> lock(rec_mutex);
                instances.clear();               
 
                instances.resize(nbPrimitiveTypes * Material::getNbMaterials());
                nbLayers = 0;                
            }
    }
}

[dragonjoker59]

Beaucoup... Beaucoup... Beaucoup trop de mutex dans ces trucs...
Me dis pas que tu batch par face ?