Salut !

Je me suis dit qu´il serait sympa de faire une classe qui chargerait a peu pres n´importe quoi comme modele.
Avec des méthodes tres simples : genre :

class Modele
{
...
public
Modele(char* fichier,int type);
~Modele();
void Render();
};

Thats all !

Ce genre de classe pourrait bien sur gérer les modeles inanimés.
Comment verriez vous une gestion (par frames interpollées) de modeles animés ?
Quelles méthodes voudriez vous mettre ?

Autres questions, avez vous des docs sur les formats existants ?
(jusqu´a présent, je travaillais uniquement sur des objets fixes, et je gérais mes propres formats avec des scripts de sortie : cf, mon jeu de canyon)

Voila, le but est de discuter de la façon la plus simple et la plus ergonomique pour charger et appeler les modeles

Bonne idée, j´ai une question :

A quoi te sert la méthode Render() ?

a afficher l´objet.
Une fois que tu l´as chargé en mémoire, tu appelles la méthode render() pour l´afficher

Ben la méthode render servirai justement a effectuer un rendu de la ressource en question, rendu bien sur adapté au type de ressource (je vois mal un logciel jouant une image ou affichant un son, quoi que pour faire de l´art contemporain ca pourrait etre sympa...)

Ca ne serait pas plus efficace en utilisant :

template class<type>

après ton class Modele{}

?

Mais sinon JYY ton idée est tres bonne. Seulement je propose qu´on se serve pour creer cette classe d´un nombre minimal de librairies, et uniquement de librairies standard. (je sais pas si il en était déja question. Mais l´interet de la chose est de proposer une classe simple et universelle, et universelle passe par ´indépendante´).

Ps: arrete moi si je me goure, mais on pourrait pas faire une dll?

clair, le moins de lib possibles dessous !
le but étant d´y programmer moi meme ! c´est + fun ! et ainsi, c´est + afcile a compiler et + universel !
mon but apres est de faire une lib, une dll éventuellement !

Sinon, je ne suis pas bien d´accord pour le template, je ne vois pas pourquoi dans la mesure ou il n´y aura pas de généricité en fonction du type, bref...

Jyy, pour les formats de fichiers, jettes un oeil au format "Collada".

C´est un format qui est en train d´etre mis en place et qui dans le futur sera certainement un standard pour les fichiers 3D (le but est que chaque logiciel de 3D puisse lire et exporter des fichiers au format collada).

Les sources et plugins sont dispo sur le site collada.

ah ben faudra que je parse ce format aussi alors

Quelles méthodes voudriez vous mettre ?

->

La méthode Render devrait avoir quelques arguments, par exemple une fonction avec et une sans un nombre pour la frame (pour les modèles animés)
Et aussi différents types de rendus (filaire, texturé, ombré(...))

Une fonction pour afficher le squelette si il y en a un par exemple...

Moi c´est tout ce dont j´aurai besoin dans une lib de ce genre ^____^

il me semble qu´en effet, il y a plusieurs keyframes dans un modele animé : et que les animations sont des "dégradés progressifs" (=interpolations) entre 2 frames non ?"

et qu´on peut définir, par exemple (qu´on me corrige si j´ai faux)

Render(int frame1,int frame2,double indice);

qui donne la frame1 de départ, la frame2 d´arrivée, et un nombre entre 0 et 1 qui va définir a quel endroit du chemin entre les deux on est :

0.0 = on est sur frame1
1.0 = on est sur frame2
0.5 = on est pile entre les deux
0.7 = on est + proche de frame2.

Est ce comme cela que marchent les frames animées ?
- Comment calculer chaque modele intermédiaire ? (interpollation entre les points (linéaire ?) ou alors il y a une formule ?
- Comment y stocker ?
Recalculer et rebalancer chaque polygones a chaque frame ?

Quelles sont les choses habituellement utilisées ?
J´ajoue ma faiblesse pour les modeles 3D dynamiques (je n´ai fait jusque la que des objets 3D fixes)

dans les choses utiles :
pre-render, post-render, selection de polys de la mesh par attribut ou materiau, interface generique pour passer des parametres aux VS/PS, etc. plein de choses en fait !

(il est aussi important de dissocier l´affichage, de la physique/animation, histoire de garder qqch souple un minimum, qu´on puisse faire evoluer sans se retrouver avec un plat de spaghetti des qu´on touche qqch)

je pense que dans un premier temps, je ne m´occuperai pas des vertex shaders/pixels shaders
peut etre dans une classe qui héritera

pour la gestion des frames, j´ai juste globalement ?
l´interpollation de chaque vertex entre frame se fait de maniere linéaire (ça m´étonnerait)

non pas vraiment, c´est du skinning au sens large ; si tu interpoles lineairement, les mouvements (de rotations surtout) sont ideux.
Le plus pratique etant de laisser les artistes affecter des poidsd adequats, pour les animations, comme ils ont tout controle sur le resultat
cote code, il suffit de ponderer les matrices quand on les blend pour le skinning.

au passage, le Render() devrait deleguer a une partie plus generale de la couche 3D ; sans quoi si chacun fait son petit render dans son coin, il sera impossible de batcher quoi que ce soit, et les performances vont etre grandement degradees.

ok, donc il ne me reste finalement qu´a récupérer les données, appliquer une formule et j´ai mon interpollation. bien bien ça !

maintenant, il me faudrait un fichier a parser, si quelqu´un a quelque chose (de simple pour commencer)

LGV > de façon ergonomique, peux tu m´écrire une classe simple d´utilisation, avec les méthodes et les parametres qui pourraient etre sympas ?
(juste le header de la classe bien sur)

ben la je vais recommencer a bosser (pause dejeuner finie), mais je peux t´aider a affiner plus tard, si tu veux

oui, je veux bien.
Ce serait cool d´avoir son propre parser, et comme je ne suis un expert en modeles 3D dynamiques, j´aurai en effet besoin de conseils !
bon courage pour le boulot !