Game-Lab Index du Forum Game-Lab
Création & modification de jeux vidéo
 
 FAQFAQ   RechercherRechercher   Liste des MembresListe des Membres   Groupes d'utilisateursGroupes d'utilisateurs   S'enregistrerS'enregistrer 
 ProfilProfil   Se connecter pour vérifier ses messages privésSe connecter pour vérifier ses messages privés   ConnexionConnexion 

main.cpp quel changement effectuer?

 
Poster un nouveau sujet   Répondre au sujet    Game-Lab Index du Forum -> Programmation graphique (OpenGL / DirectX / SDL / Shaders / ...)
Voir le sujet précédent :: Voir le sujet suivant  
Auteur Message
papagateau
Membre


Inscrit le: 30 Juin 2010
Messages: 16
MessagePosté le: Mercredi 14 Juillet 2010 @ 7:49    Sujet du message: main.cpp quel changement effectuer? Répondre en citant
bonjours!

Code:
void convertMeshToOBJ(const Mesh_t* mesh, const char* dst) {
   fprintf(stderr, "# VertexCount: %d, BytesPerVertex: %d\n", nVertices_, bytesPerVertex_);
   fprintf(stderr, "# IndexCount: %d, BytesPerIndex: %d\n", nIndices_, bytesPerIndex_);

   FILE* file = fopen(dst, "w");
//   fprintf(file, "mtllib master.mtl\n");

   if(vertexComponents_[0].exists) { // does it have position data
      for(int iVertex = 0; iVertex < nVertices_; ++iVertex) {
         uint8_t* vertex = vertices_ + bytesPerVertex_ * iVertex + vertexComponents_[0].offset;
         fprintf(file, "v %f %f %f\n",
         vertexComponents_[0].convert(vertex + 0 * vertexComponents_[0].typeSize),
         vertexComponents_[0].convert(vertex + 1 * vertexComponents_[0].typeSize),
         vertexComponents_[0].convert(vertex + 2 * vertexComponents_[0].typeSize)
         );
      }
   }
   if(vertexComponents_[4].exists) { // does it have texture coordinates
      for(int iVertex = 0; iVertex < nVertices_; ++iVertex) {
         uint8_t* vertex = vertices_ + bytesPerVertex_ * iVertex + vertexComponents_[4].offset;
         fprintf(file, "vt %f %f\n",
         vertexComponents_[4].convert(vertex + 0 * vertexComponents_[4].typeSize),
         vertexComponents_[4].convert(vertex + 1 * vertexComponents_[4].typeSize)
         );
      }
   }
   if(vertexComponents_[1].exists) { // does it have vertex normals
      for(int iVertex = 0; iVertex < nVertices_; ++iVertex) {
         uint8_t* vertex = vertices_ + bytesPerVertex_ * iVertex + vertexComponents_[1].offset;
         fprintf(file, "vn %f %f %f\n",
         vertexComponents_[1].convert(vertex + 0 * vertexComponents_[1].typeSize),
         vertexComponents_[1].convert(vertex + 1 * vertexComponents_[1].typeSize),
         vertexComponents_[1].convert(vertex + 2 * vertexComponents_[1].typeSize)
         );
      }
   }


ici par exemple, pour la partie de la convertion, j'ai ce code.
Or ici l'objet qui a été convertit, lui ne détient pas le nom de l'objet de ma source.

je sais que le format Obj, lui pour les noms des objets, il utilise "g"

tel que dans l'exemple suivant.

Code:
# The units used in this file are centimeters.
g default
v 1.391242 3.009697 1.076735
v -1.398609 3.009697 1.203546
v 1.391242 3.009697 1.203546
v -0.003683 3.009697 1.330359
v -1.398609 3.009697 1.076735
v -1.398609 -3.330873 1.076735
v 1.391242 -3.330873 1.203546


Donc que faut t'il que j'ajoute pour que l'objet convertit, reçois le nom de mon objet sources.

identiquement, ici, après le "#" je voudrait, que mon objet convertit, me donne aussi l'unité de mesure que l'objet source détient.

merci pour m'indiquer les possibilités.
Revenir en haut
Voir le profil de l'utilisateur Envoyer un message privé
RedEyes
Owner


Inscrit le: 25 Juil 2002
Messages: 2345
Localisation: Paris
MessagePosté le: Mercredi 14 Juillet 2010 @ 12:13    Sujet du message: Répondre en citant
ton fichier main.cpp c'est un des fichier source d'un converterde format 3D vers le format obj ?

bref on ne peut rien dire ou meme limite faire un peu de spéculation.
il nous manque trop d'information sur le moteur et le type de format 3D utiliser là , jvois vraiment pas comment t'aider !

désolé

Code:

# The units used in this file are centimeters.
g default
v 1.391242 3.009697 1.076735
v -1.398609 3.009697 1.203546
v 1.391242 3.009697 1.203546
v -0.003683 3.009697 1.330359
v -1.398609 3.009697 1.076735
v -1.398609 -3.330873 1.076735
v 1.391242 -3.330873 1.203546



ici c'est juste l'emplacement de chaque vertex qui composent les polygones de ton model

g default c'est un subgroup

Citation:

g name

The group name command specifies a sub-object grouping. All 'f' face commands that follow are considered to be in the same group.


info sur le format OBJ :
http://www.fileformat.info/format/wavefrontobj/egff.htm
Revenir en haut
Voir le profil de l'utilisateur Envoyer un message privé Envoyer l'e-mail Visiter le site web du posteur
papagateau
Membre


Inscrit le: 30 Juin 2010
Messages: 16
MessagePosté le: Mercredi 14 Juillet 2010 @ 18:55    Sujet du message: Répondre en citant
salut redeyes et merci de m'avoir répondu.

Donc, si cela peut t'aider à voir mieux, voilà tout le code source de mon fichier main.cpp

il doit convertir les objets Granny dans le format obj.
mais le progr fait de léger bug...

donc, si jamais tu as besoin de lire les codes sources du fichier Granny.h, je peut te le mettre.

et une chose après l'autre..
Code:
#include <stdio.h>
#include <stdlib.h>

#include "granny.h"
#include "half.h"

void __cdecl log(int a, int b, char* msg)
{
   fprintf(stderr, "Log (%d %d) %s\n", a, b, msg);
}

GrannyLogger logger = { &log, &log };

int getTypeSize(int type) {
   switch(type) {
      case 10: return 4;  // 32bit float
      case 11:            // granny_int8
      case 12:            // granny_uint8
      case 14: return 1;  // granny_uint8
      case 21: return 2;  // 16bit float
      default: return 0;
   }
}

typedef float (*convertFunc)(uint8_t* value);

float convertDummy(uint8_t* value) {
   return 0.0f;
}

float convert10(uint8_t* value) {
   return *(float*)value;
}

float convert11(uint8_t* value) {
   return *(granny_int8*)value;
}

float convert12or14(uint8_t* value) {
   return *(granny_uint8*)value;
}

float convert21(uint8_t* value) {
   uint32_t result = half_to_float(*(uint16_t*)value);
   return *(float*)&result;
}

convertFunc getConvertFunc(int type) {
   switch (type) {
      case 10: return &convert10;
      case 11: return &convert11;
      case 12:
      case 14: return &convert12or14;
      case 21: return &convert21;
      default: return &convertDummy;
   }
}

struct VertexComponent {
   const char* name;     // name of the component as used in granny files
   int32_t index;        // index of -1 means it doesn't exist
   bool exists;          // does this component exit
   convertFunc convert;  // convertion function to convert from this components type to 32bit float
   uint32_t offset;      // offset relative to the start of the vertex at which this component starts
   uint32_t typeSize;    // size in bytes of the type of this component
};

uint32_t nVertexComponents_ = 6;

VertexComponent vertexComponents_[] = {
   { "Position"           , -1, false, &convertDummy, 0, 0 },
   { "Normal"             , -1, false, &convertDummy, 0, 0 },
   { "Tangent"            , -1, false, &convertDummy, 0, 0 },
   { "Binormal"           , -1, false, &convertDummy, 0, 0 },
   { "TextureCoordinates0", -1, false, &convertDummy, 0, 0 },
   { "TextureCoordinates1", -1, false, &convertDummy, 0, 0 }
};

//int nTriangles_;
int nTriangleGroups_;
Group_t* triangleGroups_;

int bytesPerVertex_;
int nVertices_;
uint8_t* vertices_;

int bytesPerIndex_;
int nIndices_;
uint8_t* indices_;

void getMeshInfo(const Mesh_t* mesh) {
   // get amount of TriangleGroups (Surfaces)
   nTriangleGroups_ = _GrannyGetMeshTriangleGroupCount(mesh);
   triangleGroups_ = _GrannyGetMeshTriangleGroups(mesh);

   StringMember_t* sm = mesh->PrimaryVertexData->Vertices_strings;


   uint32_t currentOffset = 0;

   // get amount of vertex components
   // _GrannyGetVertexComponentCount(sm); doesnt work as TextureCoordinates0
   // and TextureCoordinates1 is counted as one component
   // uint32_t nVertexComponents = _GrannyGetVertexComponentCount(sm);
   uint32_t nVertexComponents = 0;

   for(int i = 0; sm[i].Type; ++i)
      ++nVertexComponents;

   // offset for each component in the vertex structure
   uint32_t* offsets = new uint32_t[nVertexComponents];

   // calculate offset for each component
   for(uint32_t iVertexComponent = 0; iVertexComponent < nVertexComponents; ++iVertexComponent) {
      offsets[iVertexComponent] =  currentOffset;
      currentOffset += getTypeSize(sm[iVertexComponent].Type) * sm[iVertexComponent].Count;
   }

   bytesPerVertex_ = currentOffset;

   // set data for each component
   for(uint32_t i = 0; i < nVertexComponents_; ++i) {
      vertexComponents_[i].index    = _GrannyGetVertexComponentIndex(vertexComponents_[i].name, sm);
      vertexComponents_[i].exists   = vertexComponents_[i].index != -1;
      vertexComponents_[i].convert  = (vertexComponents_[i].exists) ? getConvertFunc(sm[vertexComponents_[i].index].Type) : &convertDummy;
      vertexComponents_[i].offset   = (vertexComponents_[i].exists) ? offsets[vertexComponents_[i].index] : 0;
      vertexComponents_[i].typeSize = (vertexComponents_[i].exists) ? getTypeSize(sm[vertexComponents_[i].index].Type) : 0;
   }

   delete[] offsets;

   nVertices_ = _GrannyGetMeshVertexCount(mesh);
   vertices_ = (uint8_t*)_GrannyGetMeshVertices(mesh);

   bytesPerIndex_ = _GrannyGetMeshBytesPerIndex(mesh);
   nIndices_ = _GrannyGetMeshIndexCount(mesh);
   indices_ = (uint8_t*)_GrannyGetMeshIndices(mesh);

}

void convertMeshToOBJ(const Mesh_t* mesh, const char* dst) {
   fprintf(stderr, "# VertexCount: %d, BytesPerVertex: %d\n", nVertices_, bytesPerVertex_);
   fprintf(stderr, "# IndexCount: %d, BytesPerIndex: %d\n", nIndices_, bytesPerIndex_);

   FILE* file = fopen(dst, "w");
//   fprintf(file, "mtllib master.mtl\n");

   if(vertexComponents_[0].exists) { // does it have position data
      for(int iVertex = 0; iVertex < nVertices_; ++iVertex) {
         uint8_t* vertex = vertices_ + bytesPerVertex_ * iVertex + vertexComponents_[0].offset;
         fprintf(file, "v %f %f %f\n",
         vertexComponents_[0].convert(vertex + 0 * vertexComponents_[0].typeSize),
         vertexComponents_[0].convert(vertex + 1 * vertexComponents_[0].typeSize),
         vertexComponents_[0].convert(vertex + 2 * vertexComponents_[0].typeSize)
         );
      }
   }
   if(vertexComponents_[4].exists) { // does it have texture coordinates
      for(int iVertex = 0; iVertex < nVertices_; ++iVertex) {
         uint8_t* vertex = vertices_ + bytesPerVertex_ * iVertex + vertexComponents_[4].offset;
         fprintf(file, "vt %f %f\n",
         vertexComponents_[4].convert(vertex + 0 * vertexComponents_[4].typeSize),
         vertexComponents_[4].convert(vertex + 1 * vertexComponents_[4].typeSize)
         );
      }
   }
   if(vertexComponents_[1].exists) { // does it have vertex normals
      for(int iVertex = 0; iVertex < nVertices_; ++iVertex) {
         uint8_t* vertex = vertices_ + bytesPerVertex_ * iVertex + vertexComponents_[1].offset;
         fprintf(file, "vn %f %f %f\n",
         vertexComponents_[1].convert(vertex + 0 * vertexComponents_[1].typeSize),
         vertexComponents_[1].convert(vertex + 1 * vertexComponents_[1].typeSize),
         vertexComponents_[1].convert(vertex + 2 * vertexComponents_[1].typeSize)
         );
      }
   }

   granny_uint32 index0;
   granny_uint32 index1;
   granny_uint32 index2;
   granny_uint32 index3;

   if(bytesPerIndex_ == 2) {
      uint16_t* indices = (uint16_t*) indices_;

      for(int iGroup = 0; iGroup < nTriangleGroups_; ++iGroup) { // for each surface
         fprintf(file, "g %s\n", mesh->MaterialBindings[triangleGroups_[iGroup].MaterialIndex].Material->Name);
//         fprintf(file, "usemtl material%d\n", triangleGroups[iGroup].MaterialIndex);
         for(int iTriangle = 0; iTriangle < triangleGroups_[iGroup].TriCount; ++iTriangle) {
            index0 = (triangleGroups_[iGroup].TriFirst + iTriangle) * 3;
            index1 = indices[index0 + 0] + 1;
            index2 = indices[index0 + 1] + 1;
            index3 = indices[index0 + 2] + 1;
            fprintf(file, "f %d/%d/%d %d/%d/%d %d/%d/%d\n",
            index1, index1, index1,
            index2, index2, index2,
            index3, index3, index3);
         }
      }
   }
   else if(bytesPerIndex_ == 4) {
      uint32_t* indices = (uint32_t*) indices_;

      for(int iGroup = 0; iGroup < nTriangleGroups_; ++iGroup) { // for each surface
         fprintf(file, "g %s\n", mesh->MaterialBindings[triangleGroups_[iGroup].MaterialIndex].Material->Name);
//         fprintf(file, "usemtl material%d\n", triangleGroups[iGroup].MaterialIndex);
         for(int iTriangle = 0; iTriangle < triangleGroups_[iGroup].TriCount; ++iTriangle) {
            index0 = (triangleGroups_[iGroup].TriFirst + iTriangle) * 3;
            index1 = indices[index0 + 0] + 1;
            index2 = indices[index0 + 1] + 1;
            index3 = indices[index0 + 2] + 1;
            fprintf(file, "f %d/%d/%d %d/%d/%d %d/%d/%d\n",
            index1, index1, index1,
            index2, index2, index2,
            index3, index3, index3);
         }
      }
   }

   fclose(file);
}


int main(int argc, char** argv) {
   if(argc < 3) {
      fprintf(stdout, "Usage: %s <src> <dst>\n", argv[0]);
      exit(1);
   }

   granny_int32 result;

   fprintf(stderr, "Library Version: %s\n", _GrannyGetVersionString());
   result = _GrannySetLogCallback(&logger);

   GrannyFile_t* grannyFile = _GrannyReadEntireFile(argv[1]);
   if(!grannyFile) {
      printf("Could not load %s\n", argv[1]);
      exit(1);
   }

   FileInfo_t* fileInfo = _GrannyGetFileInfo(grannyFile);
   if(!fileInfo) {
      printf("Could not get fileinfo\n");
      exit(1);
   }

   if(!fileInfo->nModels) {
      printf("Could not find any models in %s\n", argv[1]);
      exit(1);
   }

   Mesh_t* mesh = fileInfo->Meshes[0];
   getMeshInfo(mesh);
   convertMeshToOBJ(mesh, argv[2]);

   _GrannyFreeFile(grannyFile);
   return 0;
}
Revenir en haut
Voir le profil de l'utilisateur Envoyer un message privé
papagateau
Membre


Inscrit le: 30 Juin 2010
Messages: 16
MessagePosté le: Mercredi 14 Juillet 2010 @ 19:00    Sujet du message: Répondre en citant
oui en fait c'est la fonction "g" et "o" que je voulais intégrer dans le code.

le "g" oui c'est pour le nom des groupes
et "o" pour le nom de l'objet.
Revenir en haut
Voir le profil de l'utilisateur Envoyer un message privé
RedEyes
Owner


Inscrit le: 25 Juil 2002
Messages: 2345
Localisation: Paris
MessagePosté le: Mercredi 14 Juillet 2010 @ 22:36    Sujet du message: Répondre en citant
ben je ne connais pas le format obj et encore moins le format granny
donc non j peux rien faire de plus Smile
Revenir en haut
Voir le profil de l'utilisateur Envoyer un message privé Envoyer l'e-mail Visiter le site web du posteur
DukeNukem
l'homme libre


Inscrit le: 25 Juil 2002
Messages: 867
Localisation: Système Wizea Sodoo, planète 4
MessagePosté le: Jeudi 15 Juillet 2010 @ 12:13    Sujet du message: Répondre en citant
Mais, heu... Qu'est ce que tu cherches à faire exactement ?!
Revenir en haut
Voir le profil de l'utilisateur Envoyer un message privé Visiter le site web du posteur
papagateau
Membre


Inscrit le: 30 Juin 2010
Messages: 16
MessagePosté le: Jeudi 15 Juillet 2010 @ 14:33    Sujet du message: Répondre en citant
salut dukenukem!

Ce que je cherche a faire, c'est d'améliorer le programme de base, du fait, que le programme lorsque je l'utilise, il fait quelques bug.

Bon en attendant, j'ai une fois trouver cette portion de code, pour le format obj.

Ainsi si je veux, que le programme me donne la fonction (g) donc nom du groupe pour mon fichier obj convertit, je supose, qu'il faut insérer la fonction (g) tel qu'il a été programmer dans cette syntax.

Code:
bool CObjet3D::_LoadOBJ(const char *filename) // charge un objet Wavefront 3D (.obj)
# {
# FILE *fp = fopen(filename,"rb");
# if(!fp) return false;
# DEBUGLOG1("Chargement du fichier WAVEFRONT %s",filename)
#
# SFace3D face;
# SGroup3D grp;
# vec3 pt3D;
# vec2 pt2D;
# char *buf,buftmp[64];
# long i,v,g; // compteur pour le stockage des données lors de la seconde passe
# unsigned int lenbuf;
#
# grp.Actif2D = true;
# grp.Actif3D = true;
# while (!feof(fp)) {
# buf = ReadLine(fp);
# lenbuf = strlen((const char *)buf);
# if (lenbuf > 0) {
# sscanf(buf,"%s",buftmp);
# if(!strcmp((const char *)buftmp,"#")) { // on a trouvé un commentaire, on passe
# } else if(!strcmp((const char *)buftmp,"mtllib")) { // on a trouvé un matérial à charger ?
# materials->Load(&buf[7]); // on charge le fichier associé
# } else if(!strcmp((const char *)buftmp,"v")) { // on a trouvé une vertice ?
# sscanf(&buf[2],"%f%f%f",&pt3D.x,&pt3D.y,&pt3D.z);
# this->_pVertices.push_back(pt3D);
# } else if(!strcmp((const char *)buftmp,"vt")) { // on a trouvé une coordonnée de texture ?
# sscanf(&buf[2],"%f%f",&pt2D.x,&pt2D.y);
# this->_pTexCoords.push_back(pt2D);
# } else if(!strcmp((const char *)buftmp,"vn")) { // on a trouvé une normale ?
# sscanf(&buf[2],"%f%f%f",&pt3D.x,&pt3D.y,&pt3D.z);
# this->_pNormals.push_back(pt3D);
# } else if(!strcmp((const char *)buftmp,"g")) { // on a trouvé un groupe ?
# grp.Name = &buf[2];
# grp.Material = 0;
# this->_pGroups.push_back(grp);
# } else if(!strcmp((const char *)buftmp,"usemtl")) { // on a trouvé un matérial à utiliser ?
# if(this->_pGroups.size() <= 0) {
# grp.Name = "No Name";
# grp.Material = 0;
# this->_pGroups.push_back(grp);
# g = 0;
# } else {
# g = this->_pGroups.size() - 1;
# }
# this->_pGroups[g].Material = materials->GetId(&buf[7]); // on récupère son id
# } else if(!strcmp((const char *)buftmp,"f")) { // on a trouvé une face ?
# if(this->_pGroups.size() <= 0) {
# grp.Name = "No Name";
# grp.Material = 0;
# this->_pGroups.push_back(grp);
# g = 0;
# } else {
# g = this->_pGroups.size() - 1;
# }
# for(i=0; (buf[i] < '0') || (buf[i] > '9') ;i++); // on se positionne à la première valeur
# for(v=0; v < 3 ;v++) { // triangles donc composés de 3 vertices
# face.Vertices[v] = 0;
# for(; (buf[i] >= '0') && (buf[i] <= '9') ;i++) { // on la récupère
# face.Vertices[v] *= 10; // première vertice
# face.Vertices[v] += buf[i]-0x30; // 0x30 est la valeur ascii du caractère '0'
# }
# face.Vertices[v]--; // indice n'est pas de 1 à nbFaces mais de 0 à nbFaces-1
# NEXT_INDICE; // on se positionne à la valeur suivante
# face.TexCoords[v] = 0;
# for(; (buf[i] >= '0') && (buf[i] <= '9') ;i++) { // on la récupère
# face.TexCoords[v] *= 10; // première coordonnée de texture
# face.TexCoords[v] += buf[i]-0x30;
# }
# face.TexCoords[v]--; // indice n'est pas de 1 à nbFaces mais de 0 à nbFaces-1
# NEXT_INDICE; // ect ... il y a 9 indices à récupérer
# face.Normals[v] = 0;
# for(; (buf[i] >= '0') && (buf[i] <= '9') ;i++) {
# face.Normals[v] *= 10; // première normale
# face.Normals[v] += buf[i]-0x30;
# }
# face.Normals[v]--; // indice n'est pas de 1 à nbFaces mais de 0 à nbFaces-1
# if(v < 2) NEXT_INDICE;
# }
# this->_pGroups[g].pFaces.push_back(face); // on enregistre la face récupérée
# }
# }
# delete[] buf;
# }
# fclose(fp);
# DEBUGLOG2("Composition finale de l'objet : %ul vertices\n %ul groupes",this->_pVertices.size(),this->_pGroups.size())
# DEBUGLOG2(" %ul faces\n %ul materials",this->GetNumFaces(),this->GetNumMaterials())
# return true;
# }
#
# // destruction de l'objet et vidage du nom de fichier 3D
# void CObjet3D::_Destroy(void) {
# this->_pVertices.clear();
# this->_pNormals.clear();
# this->_pTexCoords.clear();
# this->_pGroups.clear();
# if(tvhDlg)
# EndDialog(tvhDlg,0);
# }
#
# // ecrit un réel dans le fichier fp
# void EcritReel(FILE *fp,float f) {
# char tmp[13];
# sprintf(tmp,"%.2f",f);
# int l = strlen(tmp);
# for(int i=0; i < 12-l ;i++) fprintf(fp," ");
# fprintf(fp,"%s",tmp);
# }
#
# // écrit un entier dans le fichier fp
# void EcritEntier(FILE *fp,int n,int espaces) {
# char *tmp = new char[espaces+1];
# sprintf(tmp,"%d",n);
# int l = strlen(tmp);
# for(int i=0; i < espaces-l ;i++) fprintf(fp," ");
# fprintf(fp,"%s",tmp);
# delete[] tmp;
# }


donc a partir de la ligne 34 ont vois bien, la nomination du groupe (g).
Code:

} else if(!strcmp((const char *)buftmp,"g")) { // on a trouvé un groupe ?
# grp.Name = &buf[2];


donc ce code, il provient d'ici.

http://files.codes-sources.com/fichier.aspx?id=29029&f=Win32_3DViewer%5cCObjet3D.cpp
lui le programmeur, a écrit ce code, pour programmer un viewer, et ainsi afficher les différents format 3D à l'écran.

mais moi ici, j'ai uniquement besoin de la partie du format obj.
et là il me faut encore trouver la même chose pour le format GR2 de granny.
mais là ce cera un peut plus délicat.
Revenir en haut
Voir le profil de l'utilisateur Envoyer un message privé
papagateau
Membre


Inscrit le: 30 Juin 2010
Messages: 16
MessagePosté le: Jeudi 15 Juillet 2010 @ 15:03    Sujet du message: Répondre en citant
et voici en clair, ce que j'essaye de faire.


donc, modifier tout ses petits bug.
Revenir en haut
Voir le profil de l'utilisateur Envoyer un message privé
Montrer les messages depuis:   
Poster un nouveau sujet   Répondre au sujet    Game-Lab Index du Forum -> Programmation graphique (OpenGL / DirectX / SDL / Shaders / ...) Toutes les heures sont au format GMT + 2 Heures
Page 1 sur 1

 
Sauter vers:  
Vous ne pouvez pas poster de nouveaux sujets dans ce forum
Vous ne pouvez pas répondre aux sujets dans ce forum
Vous ne pouvez pas éditer vos messages dans ce forum
Vous ne pouvez pas supprimer vos messages dans ce forum
Vous ne pouvez pas voter dans les sondages de ce forum


Powered by phpBB © 2001, 2005 phpBB Group
Traduction par : phpBB-fr.com