chargement d un shader depuis un fichier

Bonjour !

je viens d implementer un code source c++ :

une fonction renvoyant un pointeur sur char, depuis un fichier.
un fichier lui-meme contenant le code source d un shader, afin de fournir le pointeur en question au code opengl afin de le compiler...

Merci de critiquer mon travail (en bien ou en mal, no souci)...
(j apprend de mes erreurs)

Et si ca peut etre utile a quelqu'un, c est coool !
merci.

Code:

---

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

#include <iostream> #include <fstream> #include <string>   char* chargement(std::string nom) { char* adresse = nullptr; int taille;   std::ifstream flux(nom, std::ios::in); if(!flux){std::cout << "fichier " << nom << " introuvable !\n";}   flux.seekg(0, std::ios::end); taille = flux.tellg();   flux.seekg(0, std::ios::beg); for (int i = 0; i<taille; i++) { flux.read(adresse+i, sizeof(char)); } // ajouter \0 adresse[taille] = '\0'; // fermer le fichier flux.close(); // renvoyer adresse return adresse;   }

---

Je suis conscient qu il existe deja beaucoup de fonctions faisant la meme chose...
juste pour le plaisir...

merci.

ton adresse n'est jamais initialisée, et quitte à faire du c++, autant utiliser std::vector.
Et si tu récupères la taille du fichier, lis-le en un seul appel et non un char à la fois.

oups...

ligne 8 : n est-ce pas une initialisation ?

std::vector ou meme std::string.... est-ce que ces conteneurs seront composés comme des char* ?

merci de vos critiques !!

Bien vu !!

j ai modifié la ligne 8 :

char* adresse;

merci : nullptr n est pas une initialisation...

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22

#include <fstream> #include <vector>   std::vector<char> chargement(std::string nom) { std::ifstream flux(nom); if(!flux) { return {}; }   flux.seekg(0, std::ios::end); const int taille = flux.tellg(); flux.seekg(0, std::ios::beg); std::vector<char> data; data.resize(taille + 1); flux.read(&data[0], taille * sizeof(char)); adresse[taille] = '\0'; flux.close(); return data; }

---

bonjour vous savez que vous pouvez également taper

Code:

---

1 2 3 4

wchar_t szNom_fichier[256]; //// std::wstring strNom_Fichier=szNom_fichier;

---

Le compilateur fait le transtypage poour vous.
Ensuite c'est préférable d'utiliser des std::wstring plutôt que des std::string car ces templates permettent l'utilisation de caractères unicode.

Tiens c'est cadeau : si vous voulez mettre toutes les données dans un répertoire \\datas

Code:

---

1 2 3 4 5 6 7 8 9 10

bool CGameCore::SetDatasPath() { std::wstring strPath(L""); wchar_t szPath[256]; ::GetCurrentDirectory(255,szPath); wcscat_s(szPath,L"\\datas\\"); if(::SetCurrentDirectory(szPath)==FALSE)return false; return true; }

---

par contre ce code ne fonctionne que sur Windows/api win32.

Bonjour,

À propos de std::wstring je n'en suis pas du tout convaincu. Du moins, ce n'est pas aussi simple que cela, surtout si on veut que cela fonctionne aussi sous Linux. Je conseillerai de rester avec les std::string et de faire en sorte, pour les rares cas où l'on doit interagir avec les API des systèmes d'exploitations de faire les conversions appropriées (notamment pour les différents pages de code).

Aussi, restez au plus simple. Sinon, vous n'avancerez pas (ou pas vite), car il y aura toujours des choses à redire sur un code (certaines de ces choses dépendent des préférences des lecteurs). Notamment, quelqu'un comme moi pourrait ajouter qu'au lieu d'utiliser un std::string pour le nom/nom du fichier, vous devriez utiliser la nouvelle bibliothèque std::filesystem::path, c'est plus moderne (C++17) et c'est même mieux.

Finalement, par rapport à la FAQ C++ du site, on peut améliorer le code. J'écrirai :

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21

#include <iostream> #include <fstream> #include <sstream> #include <cassert>   int main() { std::ifstream file("./main.cpp"); if (!file) { throw std::runtime_error("Impossible d'ouvrir le fichier"); }   std::stringstream buffer; buffer << file.rdbuf() << '\0';   std::string content = buffer.str(); std::cout << "File content: '" << content << "'" << std::endl; std::cout << "File content(char*): '" << content.c_str() << "'" << std::endl; assert(content.at(content.size()-1) == '\0'); std::cout << "File size: " << content.size() << std::endl; }

---

Il n'y a plus vraiment besoin de regarder la taille du fichier. Par contre, ne retournez pas content.c_str en retour d'une fonction, car le pointeur n'est valide que si la std::string est valide :).

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24

#include <fstream> #include <vector>   std::vector<char> chargement(std::string nom) { std::ifstream flux(nom); if(!flux) { return {}; }   flux.seekg(0, std::ios::end); const int taille = flux.tellg(); flux.seekg(0, std::ios::beg); std::vector<char> data; data.resize(taille + 1); flux.read(&data[0], taille * sizeof(char)); adresse[taille] = '\0'; flux.close(); return data; }

---

Code tres interressant...
mais....

Code:

---

1 2	data.resize(taille + 1);

---

est-ce vraiment utile ?
en effet : de 0 a taille-1 : les donnees.
a (taille) on place '\0'...

Code:

---

1 2	return data;

---

Du coup....
un std::vector<char> est-il structuré, en memoire, comme un char* ?

Citation:

---

Envoyé par LittleWhite

Bonjour,

À propos de std::wstring je n'en suis pas du tout convaincu.

---

même si on veut localiser son jeu en Russe ou en Japonais ?
Je fais un usage intensif de ce conteneur et ça fonctionne très bien.

Citation:

---

Envoyé par GraineDeDev

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24

#include <fstream> #include <vector>   std::vector<char> chargement(std::string nom) { std::ifstream flux(nom); if(!flux) { return {}; }   flux.seekg(0, std::ios::end); const int taille = flux.tellg(); flux.seekg(0, std::ios::beg); std::vector<char> data; data.resize(taille + 1); flux.read(&data[0], taille * sizeof(char)); adresse[taille] = '\0'; flux.close(); return data; }

---

Code tres interressant...
mais....

Code:

---

1 2	data.resize(taille + 1);

---

est-ce vraiment utile ?
en effet : de 0 a taille-1 : les donnees.
a (taille) on place '\0'...

---

Si si... ce n est pas qu'une adresse...
c'est la taille du tableau de char qui doit etre incrementee...
il me semble...

vous vous compliquez la vie pour pas grand chose j'ai l'impression.
L'intérêt de std::string c'est de faire le redimensionnement de la taille du tableau de caractères à votre place automatiquement.
Pas besoin d'utiliser std::vector <char> ; si vous voulez convertir un std::string en char * parce que c'est nécessaire le cas échéant il suffit d'appeler std::string::c_str()

Citation:

---

Envoyé par Mat.M

même si on veut localiser son jeu en Russe ou en Japonais ?
Je fais un usage intensif de ce conteneur et ça fonctionne très bien.

---

Je ne dit pas que cela ne marchera pas. Si vous faites du Windows only, je suppose que cela marchera bien. Sous Windows, cela dépend aussi de comment votre encodage est configuré (multibyte char ou pas). La problématique est d'autant plus présente si vous faites du multi plateforme. Notamment car sous Linux, un std::string peut contenir des caractères de toutes les langues, sans pour autant avoir de problème (car sous Linux, tout est UTF-8, ça tient dans des std::string :)). Bref, on est hors sujet :aie:.

Citation:

---

Envoyé par Mat.M

même si on veut localiser son jeu en Russe ou en Japonais ?
Je fais un usage intensif de ce conteneur et ça fonctionne très bien.

---

Les 2 marchent.
Tu peux voir que UE utilise un TCHAR qui est un wchar_t sous Windows mais un char sur Linux.
Mais sur tous les moteurs maisons avec lesquels j'ai travaillé avant, on utilisait des char* pour toutes les plateformes.
Dans la pratique, devoir utiliser la macro TEXT partout me gonfle :aie: alors char* a ma préférence.

Citation:

---

Envoyé par GraineDeDev

Code:

---

1 2	return data;

---

Du coup....
un std::vector<char> est-il structuré, en memoire, comme un char* ?

---

C'est le principe même d'un vector, d'avoir sa mémoire contigüe. :calim2:

Citation:

---

Envoyé par Bousk

Les 2 marchent.
Tu peux voir que UE utilise un TCHAR qui est un wchar_t sous Windows mais un char sur Linux.
Mais sur tous les moteurs maisons avec lesquels j'ai travaillé avant, on utilisait des char* pour toutes les plateformes.
Dans la pratique, devoir utiliser la macro TEXT partout me gonfle :aie: alors char* a ma préférence.


C'est le principe même d'un vector, d'avoir sa mémoire contigüe. :calim2:

---

trop cool ! Merci !
Savoir que avec tous les avantages d un tableau de vector... on dispose de cette facilité...