Jeux Libres
       
           

» Les Forums » Aide à propos de la création de jeux vidéo » [C++] Lo reprend ses tutos!


Aller à la page : 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11.

[C++] Lo reprend ses tutos!
Lo



Grade : Maître
Inscrit le: 26 Dec 2007, 17:33
Ecrit le: 03 Dec 2014, 19:00             Message non corrigé

Salut!

Bon, j'ai un site web sur lequel j'ai rédiger quelques tutoriel je mettrai le lien une fois que toutes les fautes d'orthographes seront corrigée.

Mon moteur est maintenant capable de dessiner des entités en 3D sur les composants, je viens juste d'avoir terminé les shaders pour faire ça, j'ai également corriger mon algorithme pour la lightMap et le normalMapping qui maintenant fonctionne enfin. :)

Bref tout est prêt je pense qu'au niveau graphisme il ne restera plus que le shadow mapping pour la génération d'ombre en 3D à faire.

Mais je me demande si je ne vais pas commencer aussi un FPS, après tout, mon moteur est conçus pour réaliser plusieurs style de jeux.

Donc je vais bientôt réfléchir sur la génération de terrain en 3D. (Bien que j'ai déjà ma petite idée) et le format de modèles 3D.

Je suis plutôt content de mes tests, ça affiche pas mal de polis sans ramer, je peux même afficher des terrains très très grand. :)




________
Parce qu'on ne peut s'exprimer que par nos créations. ^^
  Profil




Visiteur
Ecrit le: 05 Dec 2014, 08:05             Message non corrigé

Cool tout ça!
Je suis impatient de voir quelques images!

Pour l'ombre temps réel, c'est un peu chaud et faut bien lui foutre de limite sinon la chute de fps est considérable.
Pour un terrain, avant même de faire du procédural, pourquoi ne pas tenter de trouver un format en reconstruisant une carte pré-existante, comme celles de CS ou d'autre fps ?

Existe-t-il sur ton moteur des éléments d'UI ? Style des boutons, sélection via souris, etc ...
  Profil
Lo



Grade : Maître
Inscrit le: 26 Dec 2007, 17:33
Ecrit le: 06 Dec 2014, 14:55             Message non corrigé

Pour le terrain en fait je fais ceci, je passe des sprites comme modèle, et je génère une heightmap en modifiant la coordonnée z des sprites aléatoirement :
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
void Map::generate_map(std::vector<Tile*> tGround, std::vector<Tile*> walls, Vec2f tileSize, BoundingBox &rect, bool terrain3D) {
 
   int startX = rect.getPosition().x / gridMap->getCellWidth() * gridMap->getCellWidth();
   int startY = rect.getPosition().y / gridMap->getCellHeight() * gridMap->getCellHeight();
   int endX = (rect.getPosition().x + rect.getWidth()) / gridMap->getCellWidth() * gridMap->getCellWidth();
   int endY = (rect.getPosition().y + rect.getHeight()) / gridMap->getCellHeight() * gridMap->getCellHeight();
   BigTile *bt;
   if (!terrain3D)
       bt = new BigTile(Vec3f(startX, startY, startY + endY * 0.5f));
   else
       bt = new BigTile(Vec3f(startX, startY, rect.getPosition().z));
   //Positions de dE9part et d'arrivE9es en fonction de la taille, de la position et de la taille des cellules de la map.
   for (int y = startY; y < endY;  y+=tileSize.y) {
       for (int x = startX; x < endX; x+=tileSize.x) {
 
           //On projete les positions en fonction de la projection du jeux.
           Vec3f projPos = gridMap->getBaseChangementMatrix().changeOfBase(Vec3f (x - startX, y - startY, 0));
           Vec2f pos (projPos.x + startX, projPos.y + startY);
           //Mur du coin en haut E0 gauche.
           if (x == startX && y == startY && walls.size() >= 4) {
               Wall *w = new Wall(3, 80, new Tile(*walls[3]),&AmbientLight::getAmbientLight(), Shadow::SHADOW_TYPE::SHADOW_WALL);
               w->setPosition(Vec3f(pos.x, pos.y, pos.y + walls[3]->getSize().y * 0.5f));
               addEntity(w);
               gridMap->getGridCellAt(Vec3f(w->getPosition().x, w->getPosition().y, 0))->setPassable(false);
 
               //Mur du coin en haut E0 droite.
           } else if (x == endX - tileSize.x && y == startY && walls.size() >= 5) {
               Wall *w = new Wall(4, 80, new Tile(*walls[4]),&AmbientLight::getAmbientLight(), Shadow::SHADOW_TYPE::SHADOW_WALL);
               w->setPosition(Vec3f(pos.x, pos.y, pos.y + walls[4]->getSize().y * 0.5f));
               addEntity(w);
               gridMap->getGridCellAt(Vec3f(w->getPosition().x, w->getPosition().y, w->getPosition().z))->setPassable(false);
               //Mur du coin en bas E0 droite.
           } else if (x == endX - tileSize.x && y == endY - tileSize.y && walls.size() >= 3) {
               Wall *w = new Wall(2, 80, new Tile(*walls[2]),&AmbientLight::getAmbientLight(), Shadow::SHADOW_TYPE::SHADOW_WALL);
               w->setPosition(Vec3f(pos.x, pos.y, pos.y + walls[2]->getSize().y * 0.5f));
               addEntity(w);
               gridMap->getGridCellAt(Vec3f(w->getPosition().x, w->getPosition().y, 0))->setPassable(false);
           } else if (x == startX && y == endY - tileSize.y && walls.size() >= 6) {
               Wall *w = new Wall(5, 80, new Tile(*walls[5]),&AmbientLight::getAmbientLight(), Shadow::SHADOW_TYPE::SHADOW_WALL);
               w->setPosition(Vec3f(pos.x, pos.y, pos.y + walls[5]->getSize().y * 0.5f));
               addEntity(w);
               gridMap->getGridCellAt(Vec3f(w->getPosition().x, w->getPosition().y, 0))->setPassable(false);
           } else if ((y == startY || y == endY - tileSize.y) && walls.size() >= 1) {
               Wall *w = new Wall(0, 80, new Tile(*walls[0]),&AmbientLight::getAmbientLight(), Shadow::SHADOW_TYPE::SHADOW_WALL);
               w->setPosition(Vec3f(pos.x, pos.y, pos.y + walls[0]->getSize().y * 0.5f));
               addEntity(w);
               if (y == endY) {
                   int i = Math::random(tGround.size());
                   Tile *tile = new Tile(*tGround[i]);
                   tile->setPosition(Vec3f(pos.x, pos.y, pos.y + tile->getSize().y * 0.5f));
                   bt->addTile(tile);
               }
               gridMap->getGridCellAt(Vec3f(w->getPosition().x, w->getPosition().y, 0))->setPassable(false);
           } else if ((x == startX || x == endX - tileSize.x) && walls.size() >= 2) {
               Wall *w = new Wall(1, 80, new Tile(*walls[1]),&AmbientLight::getAmbientLight(), Shadow::SHADOW_TYPE::SHADOW_WALL);
               w->setPosition(Vec3f(pos.x, pos.y, pos.y + walls[1]->getSize().y * 0.5f));
               addEntity(w);
               if (x == endX) {
                   int i = Math::random(tGround.size());
                   Tile *tile = new Tile(*tGround[i]);
                   tile->setPosition(Vec3f(pos.x, pos.y, pos.y + tile->getSize().y * 0.5f));
                   bt->addTile(tile);
               }
               gridMap->getGridCellAt(Vec3f(w->getPosition().x, w->getPosition().y, 0))->setPassable(false);
           } else {
               int i = Math::random(tGround.size());
               Tile *tile = new Tile(*tGround[i]);
               tile->setPosition(Vec3f(pos.x, pos.y, pos.y + tile->getSize().y * 0.5f));
               if (terrain3D) {
                   float heights[4];
                   for (int j = 0; j < sizeof(heights) / sizeof(float); j++) {
                       heights[j] = Math::random(rect.getPosition().z, rect.getPosition().z + rect.getDepth());
                   }
                   bt->addTile(tile, Vec2f(pos.x, pos.y), Vec2f(tile->getSize().x, tile->getSize().y),rect.getWidth() / tile->getSize().x, Vec2f(rect.getPosition().x, rect.getPosition().y), heights);
               } else {
                   bt->addTile(tile);
               }
           }
       }
   }
   addEntity(bt);
}

Sur le grand sprite, je fais juste un mappage de la hauteur là ou les coins des sprites se supperpose :
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
void BigTile::addTile (Tile *tile, Vec2f tilePos, Vec2f tileSize, int nbTilesPerRow, Vec2f minPos, float* heights) {
  tile->setParent(this);
  addChild(tile);
  if (heights != nullptr) {
       int xPosition = Math::abs(minPos.x) / tileSize.x + tilePos.x / tileSize.x;
       int yPosition = Math::abs(minPos.y) / tileSize.y + tilePos.y / tileSize.y;
       int position = yPosition * nbTilesPerRow + xPosition;
       int belowPos = (yPosition - 1) * nbTilesPerRow  + xPosition;
       if (xPosition > 0) {
           heights[0] = getChildren()[position-1]->getFaces()[0]->getVertexArray()[1].position.z;
           heights[3] = getChildren()[position-1]->getFaces()[0]->getVertexArray()[2].position.z;
       }
       if (belowPos  > 0) {
           heights[0] = getChildren()[belowPos]->getFaces()[0]->getVertexArray()[3].position.z;
           heights[1] = getChildren()[belowPos]->getFaces()[0]->getVertexArray()[2].position.z;
       }
       tile->changeVerticesHeights(
                   heights[0],
                   heights[1],
                   heights[2],
                   heights[3]);
   }
}

Et ensuite je fais un sprite batching pour afficher le terrain, en regroupant tout les vertex des sprites du big sprite qui sont dans le champ de vision de la caméra.

Pour les shaders ne t'inquiète pas j'ai plusieurs composants qui contiennent chacun une caméra, par exemple, la fenêtre à une caméra en 2D, le composant à une caméra en 3D, je récupère la texture du composant donc le framebuffer de la scene en 3D sur lequel j'applique mes shaders. (Normal mapping, heightmapping, etc...)

J'utilise un worker pour update les composants et endormir le CPU pour des raisons d'optimisation ce qui fait que les shaders ne sont pas appliqué à chaque frame..., mais, tout les 0.5 secondes par exemple.

PS : avance que je mette des images il me faudrait quelque textures, je vais en chercher...

________
Parce qu'on ne peut s'exprimer que par nos créations. ^^
  Profil
Lo



Grade : Maître
Inscrit le: 26 Dec 2007, 17:33
Ecrit le: 07 Dec 2014, 13:12             Message non corrigé

Voilà un premier jet sur la heightmap :



Bien sûr ce n'est qu'un premier jet il y a sûrement moyen de faire mieux au niveau de la texture.

Donc un prochain tutoriel à venir sur la génération de terrain en 3D et la collision en hauteur.

PS : Loubitek, pour les exécutables se sont des .out donc sur window tu ne pourra pas les exécuter, il te faut donc une plateforme linux. :/



________
Parce qu'on ne peut s'exprimer que par nos créations. ^^
  Profil
David



Grade : Maître
Inscrit le: 11 Mai 2005, 20:30
Ecrit le: 07 Dec 2014, 14:40             Message non corrigé

J'aimerais bien l'essayer, tu peux me l'envoyer ?
Je vais l'essayer avec un live CD.

________
Apprenez à créer votre propre FPS en C++ avec OpenGL. C'est pas dur ! :-)
  Profil
Lo



Grade : Maître
Inscrit le: 26 Dec 2007, 17:33
Ecrit le: 07 Dec 2014, 15:03             Message non corrigé

Ok je t'envoie ça ce soir dès que je reviens.

________
Parce qu'on ne peut s'exprimer que par nos créations. ^^
  Profil
Lo



Grade : Maître
Inscrit le: 26 Dec 2007, 17:33
Ecrit le: 07 Dec 2014, 16:31             Message non corrigé

Voila je t'ai envoyé.

________
Parce qu'on ne peut s'exprimer que par nos créations. ^^
  Profil
David



Grade : Maître
Inscrit le: 11 Mai 2005, 20:30
Ecrit le: 10 Dec 2014, 02:59             Message non corrigé

Merci.

________
Apprenez à créer votre propre FPS en C++ avec OpenGL. C'est pas dur ! :-)
  Profil
Lo



Grade : Maître
Inscrit le: 26 Dec 2007, 17:33
Ecrit le: 10 Dec 2014, 18:40             Message non corrigé

J'ai essayer de faire une vidéo pour le normal mapping cependant je n'arrive pas à réduire la vitesse de la vidéo. :/ J'ai essayer d'ajouter un effet avec kdenlive mais ça ne marche pas, ça n'affiche plus rien du tout dans ce cas.



Ca fait plus joli et on voit bien la lumière qui se reflète sur le bord des textures (enfin pas tellement le temps de le voir ici car la vidéo est trop rapide. :/), cependant, comme Loubitek me l'as dis hier, avec des shaders c'est beaucoup plus lent. :/
Mon FPS est réduit de 2 (je passe de 60 FPS sans shaders à 30 FPS avec shader. :( )

________
Parce qu'on ne peut s'exprimer que par nos créations. ^^
  Profil
Lo



Grade : Maître
Inscrit le: 26 Dec 2007, 17:33
Ecrit le: 27 Dec 2014, 08:25             Message non corrigé

Salut!

J'ai terminé le système de particule, enfin, j'ai repris celui d'une bibliothèque que j'ai modifié et j'ai aussi rajouté un billboard pour orienté les particules vers la caméra en 3D.

La version 1 du moteur sort bientôt, mais comme le site à pour but d'apprendre à créer un jeux de A à Z, je pense que je vais, en plus des tutoriels sur le moteur : Ici

Rajouter quelque tutoriel sur ce site, le but sera de créer un jeux avec le moteur, il y aura deux petit jeux, le premier sera en hack and slash en 3D iso, similaire au projet de Grégoire, le second sera un FPS tout simple similaire à celui de ce site, mais, avec en plus de l'affichage de particule, ainsi que des lumières et des ombres (Qui seront générée par le moteur) et bien sûr, le son.

Pour 2016 les choses sérieuses vont enfin pouvoir arriver!


________
Parce qu'on ne peut s'exprimer que par nos créations. ^^
  Profil
 


Aller à la page : 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11.


Hébergeur du site : David
Version PHP : 5.4.45-0+deb7u2
Uptime : 206 jours 17 heures 19 minutes
Espace libre : 1561 Mo
Dernière sauvegarde : 18/06/2019
Taille de la sauvegarde : 1113 Mo


5294707 pages ont été consultées sur le site !
Dont 2147 pages pendant les 24 dernières heures.

Page générée en 2.367 secondes


Nos sites préférés
- Création d'un jeu de plateforme de A à Z avec SDL
- Zelda ROTH : Jeux amateurs sur le thème de Zelda
- Zeste de Savoir : la connaissance pour tous et sans pépins
- YunoHost : s'héberger soi-même en toute simplicité
- Site de Fvirtman : recueil de projets et de codes en C et C++
- Par ici la sortie : le site des idées de sorties


  © 2005-2019 linor.fr - Toute reproduction totale ou partielle du contenu de ce site est strictement interdite.