Question pour un portage Win -> OSX

Question pour un portage Win -> OSX - C++ - Programmation

Marsh Posté le 25-07-2011 à 08:38:39    

Bonjour,
 
Je suis en train de déterrer du code que j'avais fait il y a quelques années. Il s'agit d'un petit loader 3DS, je ne pense pas que l'on puisse l'appeler autrement...  
 
Toujours est-il que je suis en train de le porter sous OSX. J'ai donc remplacé tout mes appels à l'API Win32 par du GLUT. Le reste étant en OpenGl et un peu de Cg, il n'y a aucun pb :)
 
J'ai donc réussi à tout porter. Mais mon soucis est que j'ai deux comportement différents entre windows et mac sur la gestion de la fenêtre: sous mac le bouton rouge pour fermer la fenêtre est grisé, mais pas sous windows...  
 
Donc je me demandais si quelqu'un avait une idée de quel était le pb :D
 
Pour ceux qui n'ont pas de boule magique, niveau création de fenêtre je prends juste le code de NeHe:

Code :
  1. glutInit            ( &argc, argv ); // Erm Just Write It =)
  2.   init ();
  3.   glutInitDisplayMode ( GLUT_RGB | GLUT_DOUBLE ); // Display Mode
  4.   glutInitWindowSize  ( 500, 500 ); // If glutFullScreen wasn't called this is the window size
  5.   glutCreateWindow    ( "NeHe's OpenGL Framework" ); // Window Title (argv[0] for current directory as title)
  6.   glutDisplayFunc     ( display );  // Matching Earlier Functions To Their Counterparts
  7.   glutReshapeFunc     ( reshape );
  8.   glutKeyboardFunc    ( keyboard );
  9.   glutSpecialFunc     ( arrow_keys );
  10.   glutMainLoop        ( );


Bon j'ai tout encapsulé dans des classes et tout, mais c'est ça qui se déroule. Je cherche donc s'il n'y a pas une callback a définir spécialement pour OSX ou une option par défaut qui aurai été mise sous windows et pas sous OSX. Je pense que cela soit dût au fait que sous mac le fait de fermer une fenêtre principale n'implique pas nécessairement la fermeture de l'application (contrairement à windows).
 
Merci :)
 
[edit] j'ai renommé le topic, car je vais avoir d'autres questions sur le portage de mon application. Et pas seulement sur GLUT


Message édité par Amonchakai le 26-07-2011 à 07:29:13
Reply

Marsh Posté le 25-07-2011 à 08:38:39   

Reply

Marsh Posté le 25-07-2011 à 19:26:10    

Bon, déjà j'ai vu qu'il fallait utiliser la fonction "atexit( )" qui permet alors d'appeler la fonction pour la fermeture de la fenêtre & cleanup.
 
Cela ne résous pas le pb du bouton grisé, mais au moins cela permet de fermer via pomme+Q sans faire tout planter le système...

Reply

Marsh Posté le 26-07-2011 à 07:54:38    

Bonjour,
 
J'ai nouveau problème de détecté: quand j'écris des données en binaire sous windows, je n'arrive pas a les lire sous OSX...  
 
Exemple: Pour écrire un entier dans un fichier fichier, je faisais:

Code :
  1. // écriture
  2. std::ofstream ofs("toto.dat" );
  3. int i = 50;
  4. ofs.write(reinterpret_cast<const char*>(&i), sizeof(int));
  5. ofs.close
  7. // lecture
  8. std::ifstream ifs("toto.dat" );
  9. int ri = 0;
  10. ofs.read(reinterpret_cast<char *>(&ri), sizeof(int));
  11. ifs.close();


 
Donc tout cela marchait bien sous windows, mais par contre des données écrites sous windows ne sont pas lues correctement sous mac.
Donc j'imagine que c'est un problème dut au fait que un utilise du big endian et l'autre du small endian.  
 
Première question: Il y a-t-il une norme sur l'endianisme (?) quand on écris dans un fichier? Tout dois être en big endian comme pour des données transmises par réseau?  
Deuxième question: Du coup, je fais comment moi ? :o Il y a htons/ntohs, mais je n'écris pas que des entier moi... Et j'imagine que si je planque des float dans des long cela ne va pas marcher... type:

Code :
  1. float f = 3.6f;
  2. long *l = reinterpret_cast<long *>(&f);
  3. long l2network = *l;


Car je suis pas sur que le mac et win vont représenter les float de la même façon :/
 
[edit] Et puis j'imagine que ça va aussi être le drame à cause de mes sizeof(int) qui peuvent retourner tout et n'importe quoi en fonction de la plateforme :/
 
C'est quoi la méthode "propre" pour ce problème?
 
merci :)


Message édité par Amonchakai le 26-07-2011 à 08:29:46
Reply

Marsh Posté le 26-07-2011 à 08:43:20    

utilise une lib de serialization genre boost.serialization.

Reply

Marsh Posté le 26-07-2011 à 11:16:20    

Ok, merci.  
 
J'ai fait un petit test vite fait:  

Code :
  1. #include <boost/serialization/vector.hpp>
  2. #include <boost/serialization/string.hpp>
  3. #include <boost/serialization/version.hpp>
  5. #include <boost/archive/binary_iarchive.hpp>
  6. #include <boost/archive/binary_oarchive.hpp>
  9. #include <vector>
  10. #include <string>
  12. #include <iostream>
  13. #include <fstream>
  16. class SomeOtherClass {
  18. private:
  19.     friend class boost::serialization::access;
  20.     float f;
  22.     template<class Archive>
  23.     void serialize(Archive & ar, const unsigned int version) {
  24.         ar & f;
  25.     }
  27. public:
  28.     SomeOtherClass(float i) : f(i)         {};
  29.     SomeOtherClass() {};
  31.     inline float getF() const             {return f; }
  32.    
  33. };
  34. BOOST_CLASS_VERSION(SomeOtherClass, 1)
  36. class SomeClass {
  38. private:
  39.     friend class boost::serialization::access;
  41.     std::vector< SomeOtherClass >    otherClass;
  42.     std::string                        str;
  44.     template<class Archive>
  45.     void serialize(Archive & ar, const unsigned int version) {
  46.         ar & otherClass;
  47.         ar & str;
  48.     }
  50. public:
  51.     SomeClass() {};
  53.     inline void                  setStr(const std::string &s)    { str = s; }
  54.     inline const std::string &getStr() const                { return str; }
  56.     inline void                     add(const SomeOtherClass &s)        { otherClass.push_back(s); }
  57.     inline const SomeOtherClass &get(size_t i) const                { return otherClass.at(i); }
  58.     inline size_t                 size()    const                        { return otherClass.size(); }
  61. };
  62. BOOST_CLASS_VERSION(SomeClass, 1)
  65. int main(int argc, char **argv) {
  67.     SomeClass sC;
  69.     sC.setStr("toto" );
  70.     for(size_t k = 0 ; k < 10 ; ++k)
  71.         sC.add(SomeOtherClass(sqrtf(static_cast<float>(k))));
  73.     {
  74.         std::ofstream ofs("binaryfile.dat" );
  75.         boost::archive::binary_oarchive oa(ofs);
  76.         oa << sC;
  77.         ofs.close();
  78.     }
  80.     SomeClass sC2;
  81.     {
  82.         std::ifstream ifs("binaryfile.dat" );
  83.         boost::archive::binary_iarchive ia(ifs);
  84.         ia >> sC2;
  85.         ifs.close();
  86.     }
  89.     std::cout << sC2.getStr() << "\n";
  90.     for(size_t k = 0 ; k < 10 && k < sC2.size() ; ++k)
  91.         std::cout << sC2.get(k).getF() << "\n";
  94.     return 0;
  95. }


 
Ca marche bien sous windows. J'ai ensuite essayé de lire le fichier binaire sous linux. Mais a la lecture, je me tape une exception:

Citation :

terminate called after throwing an instance of 'boost::archive::archive_exception'
  what():  input stream error
Aborted


 
Tu aurai une idée du pb?  :??:

Reply

Marsh Posté le 26-07-2011 à 21:31:59    

Bon, je viens de tester sur mon mac. Cela ne marche pas... Mais j'ai une autre erreur...

Citation :

terminate called after throwing an instance of 'boost::archive::archive_exception'
  what():  invalid signature
Abort trap

 

Du coup, pas trop chaud pour le gros refactoring... Vu que cela ne marche pas mieux entre OS :/


Message édité par Amonchakai le 26-07-2011 à 21:38:10
Reply

Sujets relatifs:

Leave a Replay

Make sure you enter the(*)required information where indicate.HTML code is not allowed