[Tutoriel] Introduction à la 3D avec Purebasic

[blendman]

Tutoriel en cours sur la création de jeu 3D avec Purebasic et Ogre.

Non terminé, en cours

Date de création05/05/2012
Mise à jour : 22/05/2012

Version de purebasic : 4.60 et 4.61 béta2

Note (celle-ci sera enlevée lorsque le tutoriel sera complet ) :
- Je vais essayer de regrouper les informations concernant la création basique d'un jeu 3D en purebasic et Ogre.
- De plus, j'essaierai dans ce tutoriel d'aborder de manière assez détaillée la conception de fichier .material à utiliser sur les entity en 3D, avec Purebasic et Ogre.
- j'essaierai aussi d'ajouter si j'y parviens des informations sur la création de fichier pour shader (HLSL ou GLSL)
- enfin, j'ajouterai aussi des exemples de fichiers (lien sur le forum ou autre).


N'hésitez pas à corriger s'il y a des erreurs, à ajouter des remarques, des liens utiles, etc.. .

I.Introduction

La version 4.60 de Purebasic a apporté énormément de nouveautés très intéressantes pour la création de jeu 3D avec Purebasic et l'utilisation du moteur Ogre (en interne).

Purebasic offre la possibilité de concevoir des jeux et applications en 3D (et 2D aussi bien sûr).
Pour les jeux 3D, Purebasic permet d'utiliser le moteur Ogre en interne.
De très nombreuses commandes sont disponibles, dans bien des domaines : graphique, physique, effets...

1. Quel type de jeu 3D est-il possible de concevoir avec Purebasic et Ogre ?

A priorité, je serai tenté de dire que l'on devrait pouvoir concevoir facilement des jeux (ou au minimum des démos) de type :
- Action FPS : un excellent exemple est proposé parmi les exemples purebasic
- jeu d'aventure en point and clic : mixe décor 2D et personnage 3D avec caméra fixe (comme Syberia). C'est tout à fait faisable.
- jeu d'aventure exploration (comme myst en 3D ou en 2D)
- jeu de plateforme simple : la création de ce type de jeu est un peu plus complexe, car il nécessite beaucoup d'interaction physique entre le joueur et le décor (objet déplaçable, objet fixe et physique). Cependant, l'excellent exemple inclus avec Purebasic ThirdPersonn.pb vous permet de voir que c'est tout à fait possible.
- jeu de shoot (spacial ou autre) : il y a un exemple tank.pb, parmi les exemples Purebasic qui permet d'avoir une idée de ce que l'on peut déjà faire.

Il devrait être possible de concevoir des jeux de type, mais sans doute avec plus de travail :
- RTS : avec les nouvelles possibilités offertes par la 4.60 (les mousepick(), pickx(), etc..), la création de ce type de jeu est désormais accessible en purebasic.
- Aventure/RPG : Il s'agit sans doute de l'un des types de jeux les plus complexes car il requiert des connaissances dans de multiples domaines. Cependant, avec les connaissances nécessaires et beaucoup de travail, il est tout à fait envisageable de concevoir une démo de RPG 3D, et même un jeu complet, si vous avez la patience ou quelques années devant vous . Mais cela n'est pas exclusif à purebasic, la création de ce type de jeu est toujours très longue.
- jeu en ligne : Purebasic propose la possibilité de créer un server et client de amnière très simple. Ainsi, la mise en ligne, bien que demandant des connaissances plus pointus (réseau, socket/udp/tcp, gestion des messsages entrant/sortant, etc..) est tout à fait réalisable. Purebasic propose un exemple de server / client simple, afin d'en comprendre les bases.
- jeu de sport/ course : ces jeux demandent des connaissances et possibilités en physique assez poussées. Il devrait être possible de concevoir un jeu (ou une démo) de ce type, mais cela demandera aussi certainement beaucoup de connaissances et de travail.


2. Et Ogre c'est quoi, c'est bien ?

S'il n'est nul besoin de présenter Purebasic sur ce forum, il peut être utile de dire quelques mots sur Ogre.

Ogre est un moteur graphique 3D gratuit et open-source, très puissant et performant, et qui permet de concevoir des jeux 3D modernes (utilisation de shaders, post-filters...) et professionnels.
Il a d'ailleurs été utilisé par des sociétés professionnelles qui ont conçus des jeux fort sympathiques avec.

Un des meilleurs exemples de jeux conçus avec Ogre est le jeu Torchlight.
CE jeu est disponible sur PC et Xbox. Il suffit d'y jouer pour se rendre compte de la qualité et des possibilités offertes par Ogre.

3. Il est possible de créer un jeu comme TorchLight avec Purebasic ? Sans dec ?

Avant de répondre à cette question, il faut analyser la conception d'un jeu 3D.

La création d'un jeu 3D s'étend sur de multiples domaines.

a) Les graphismes
Logiciel 2D (photoshop, Gimp, Mypaint..) ou dessin à la main scanné :
- création des designs 2D du jeu, recherches graphiques (décors, objets..) et model sheets

Ce qui suit s'opère en général dans un modeleur 3D (blender, 3Dsmax, lightwave..).
- création des modèles 3D
- création des textures et des materials (matériaux ou shaders).
- création des animations sur certains de ces modèles :personnages, ennemis, pnj..

Enfin, l'exportation des modèles et données dans le format de Ogre et purebasic :
- les objets 3D seront exportés directement en *.mesh ou en *.mesh.xml ou *.xml et convertis avec un utilitaire fourni sur le site d'Ogre : OgreXMLConverter.exe
- Les shaders/matériaux créés dans le modeleur 3D devront être exportés vers un format lisible par votre "moteur de jeu". Pour Ogre et purebasic : ce sera en *.material. Au bout d'un moment, lorsque vous aurez réalisé plusieurs *.material et si vous prenez le temps de les comprendre, vous parviendrez à concevoir directement en texte vos propres material. Sur le site d'ogre vous trouverez de la documentation sur la création des material http://www.ogre3d.org/docs/manual/manual_14.html
-Les animations devront être exportées dans le format lisible par votre moteur de jeu (ici *.skeleton)

Note :
blender (version 2.49 et 2.6x) dispose de scripts d'export tout à fait opérationnel et fort intéressant. Vous pourrez facilement exporter :
- vos modèles en *.mesh.xml puis les convertir en *.mesh grâce à OgreXMLConverter.exe
- vos animation en *.skeleton
- vos matériaux en *.material. Pour les les *.material, il faudra sans doute les retravailler et les modifier à la main (en txt avec notepadd++ par exemple), afin d'obtenir ce que vous souhaitez précisemment, car la conversion depuis blender n'est pas encore complètement opérationnelle.


Graphiquement, la création d'un jeu 3D professionnel ou non nécessite d'avoir des modèles 3D de qualité et dédiés au jeu vidéo : peu de faces, mise en place de shader, uvmapping et création des textures, placement du pivot( centre de l'objet), mise en place des squelettes et animations, exportation, etc...

Remarque:
Il faut qu'ils soient conçus à la bonne taille.
Par exemple : à l'exportation, il faut agrandir les modèles dans blender avant de les exporter (environ 3 fois), ou accepter un world assez petit.

La réalisation des textures est aussi une tâche importante (réaliste ou pas). Elle se fait soit dans le modeleur 3D directement (Blender) ou dans un logiciel 2D (photoshop, gimp..). Cependant, chaque texture doit être réalisée en adéquation avec l'uvmapping du modèle texturé.

Une charte graphique est en général définie avant de commencer :
- celle-ci contiendra les éléments décrivant le style graphique (cartoon, semi-réaliste, réslite, manga..), le type de rendu souhaité (réaliste, dessin animé, cell-shading..) et le type de traitement pour les textures (dessinées à la main, photo retouché, rendu de texture..)

Voici 2 exemples de jeux (RPG) au rendu à la fois proche et différent :
- SilverFall (non réalisé avec Ogre) : le rendu utilise des technique mixte : cell-shading sur les bords pour donner un coté BD au jeu, shaders réaliste (normal map, réflexion, reflet/lumière spéculaire..)
- Torchlight : texture et modèles sont conforme avec le Style défini par la direction Artistique. Les modèles sont cartoons, et les textures sont peintes à la main et utilisent peu de techniques /shaders (peu ou pas de normal map), mais une technique dite du "rim-light", un retour lumière pour donner un coté comics au rendu global, sur les personnages.


Concernant les graphismes, Purebasic et Ogre offre de très nombreuses possibilités quant à la création et l'utilisation des materials ainsi que l'utilisation de shaders : normal-map, speculaire, réflexion, ..
Cependant, cela nécessite encore quelques connaissances notamment en GLSL ou HLSL (voir plus bas).


b) le développement du jeu

Après avoir effectué une réflexion sur la pré-production (graphisme, scénario, écriture du cahier des charges et document de gamedesign (GDD), etc.., on peut commencer à réfléchir sur développement du jeu :

- réflexion sur les gameplays du jeu, mis en place et possibilités offertes en Purebasic et Ogre.

- réflexion sur les besoins : physique, moteur graphique (shaders, post-fx..),IA, etc

- mise en place des "moteurs" du jeu : graphique, physique, IA, GUI...

- codage du jeu et des modules


c) le développement des outils

Le développement d'outil dédié à la création d'un jeu est très intéressant, utile et même indispensable.

Il est donc nécessaire de mener une réflexion sur la nécessité de créer des outils ou d'en trouver :
- éditeur de map / scène / level
- éditeur de Shaders
- éditeur ou visualiseur de post-fx
- éditeur de particules : un éditeur de particules vous permet de concevoir et sauvegarder des systèmes de particules que vous avez conçus et que vous souhaitez utiliser dnas votre jeu.
- scène manager : permet de manger, ranger vos "assets", vos objets 3D
- models viewer : ce genre d'outil vous permet de visualiser facilement un modèle, ainsi que ses textures et les animations de ce modèle. Il existe un utilitaire pour ogre qui fait cela : Ogre Meshy (voir un peu plus bas) .


Editeur de level (Level Editor)

Il est tout à fait faisable et envisageable de concevoir un éditeur de level complet en purebasic et Ogre.
- Arkeos Level editor 3D (créé par Blendman) : http://www.purebasic.fr/french/viewtopi ... 13&t=12749
Cet éditeur en cours de création permet de créer vos levels de jeu. Il permet à l'aide de fonctions simples (transformations, position, ajout d'objets, suppression..) de concevoir un niveau de jeu
Lorsque celui-ci sera terminé, il devrait permettre d'ajouter des objets de "gameplay" comme par exemple : des télé-porteurs, des coffres, des portes, des NPC, des monstres, des objets bloquants, etc...


Editeur de Shaders/ material

- Material Editor (créé par Kelebrindae) : http://www.purebasic.fr/french/viewtopi ... 13&t=12819
Cet outil permet de concevoir vos propres material et shader, en mode texte. Il permet surtout de les visualiser rapidement, et d'oserver les modifications en temps réel.

- Il existe un éditeur de material fourni par la communauté d'Ogre. Celui-ci permet de concevoir des material, mais si vous voulez des fonctions avancées (normal map, réflexion, réfraction..), il faudra modifier votre material et connaitre les notions de GLSL et HLSL :
http://www.ogre3d.org/forums/viewtopic.php?f=11&t=48774

- Éditeur de texte avec coloration syntaxique dédié à la création de material :
http://veniogames.com/downloads/Yaose


Editeur de particule, Fx et autre..

Il existe plusieurs outils dédiés à cela. Ils utilisent les scripts de particules (particles scripts) :
- Ogre particule lab (free?) : http://roussel-geoffrey.blogspot.fr/201 ... -0999.html

- Particle Universe (not free) : http://www.fxpression.com/
Utilisé dans le les jeux professionnels comme Torchlight.

- Ogre Particle editor : http://www.game-cat.com/ogre/pe/docs/index.htm
http://www.ogre3d.org/tikiwiki/OGRE+Par ... ture=Tools

Viewer d'objet ou de mesh

- Ogre meshy permet de visulaiser des objets avec leur material et jouer les animations liés à ceux-ci : http://www.ogre3d.org/forums/viewtopic.php?f=11&t=59600


A la lumière de ces réflexions, on constate qu'un jeu ce n'est pas uniquement du développement. Ce sont aussi des graphismes 3D (et textures), du gameplay, de la réflexion sur les concepts et outils, du scénario, etc...


Concernant le code et développement du jeu ou des outils, cela est donc tout à fait faisable.
La conception d'un jeu 3D avec purebasic utilise un certain nombre d'éléments venant d'Ogre que je vais un peu détailler.

[blendman]

II. Les éléments disponibles

1. Les principaux éléments disponibles.

On a à notre disposition plusieurs type d'éléments ou "d'objets" :

- les meshs : ce sont des éléments contenu dans un fichier *.mesh. En général, il s'agit d'un objet 3D créé dans un modeleur 3D (Blender, 3dsmax, lightwave...) et exporté dans ce format, qui est ensuite lisible en purebasic, par Ogre.
On peut simplifier en disant que c'est le contenu d'un objet 3D, c'est la forme qui apparaitra dans le jeu. Par exemple : un robot.
Cependant, pour voir une mesh (on peut dire un ou une mais dans l'aide il est marqué une ), il faut que celle-ci soit utilisée par une entity (voir pus bas).

- les materials : ce sont le/les matières/matériaux visibles sur une entity. On peut aussi parler de shader. Les materials sont composés de 2 types d'informations :
1) le fichier .material, utilisé de base par Ogre, et qui permet d'obtenir certains rendus sur l'entity : affichage de la texture, animation de celle-ci, multiples canaux de textures, la material émet-il de la lumière, projette-t’il des ombres, est-il touché par la lumière, etc...
Un lien d'explication générale sur les paramètres d'un material d'Ogre :
http://www.ogre3d.org/docs/manual/manual_17.html#SEC92
2) les fichiers spécifiques de paramètres pour les shaders : en HLSL (directX) ou GLSL (OpenGL). Ces fichiers permettent par exemple d'utiliser des propriétés de la carte graphique ajoutant des fonctions au rendu des textures, comme : normal mapping, spéculaire, bump, réflexion, réfraction, etc..

En général, Ogre utilise un fichier .cg, il faut donc convertir ce fichier .cg, en fichier utilisable par Purebasic : vertex program et vertex shader (.vp et .vs).
Pour cela un outil est proposé par exemple par nvidia sur leur site (Merci Comtois pour l'information).


- les textures : ce sont les images utilisées par les material.
En général, des jpg, des png ou des tga. Celles-ci peuvent boucler ou pas (il faut les faire boucler soi-même dans un logiciel 2D).
Il existe plusieurs types de textures, en fonction des paramètres du material/shader que l'on souhaite modifier : texture diffuse (pour les couleurs et l'aspect général du rendu), texture normal map (pour le relief), texture spéculaire (pour les lumière dites spéculaire (la brillance en quelques sorte), etc..
Il est possible de mixer des textures dans un material, d'utiliser plusieurs textures avec des mode de rendu différents, etc.


- les entitys : ce sont les "objets 3D" vides.
C'est un peu le contenant d'un objet 3D. On doit utiliser une mesh pour visualiser une entité, sinon, elle est vide et on ne voit rien. Mais c'est sur l'entité que l'on fait les transformations (position, rotation, scale) ou que l'on applique le material et non sur les meshs. Les entités sont donc uniques, tout comme les meshs. Cependant, plusieurs entités peuvent utiliser la même mesh. On peut aussi utiliser la même mesh sur plusieurs entités, avec des materials différents.

Note sur le scale de certaines entités :
Il arrive que certains modèles (ou mesh) trop petits doivent être agrandis. Je vous conseille fortement de tous les exportés à la même taille et d'éviter les scales trop grands sur les objets, car cela peut créés des artfacts très désagréables avec certaines ombres (modulative).


- les camera : ce sont les caméras de la scène ou du jeu, elles permettent de visualiser la scène.
Il faut au minimum une caméra dans la scène. On peut régler divers paramètres : position, rotation, focal.
Attention : le nombre de caméra augmente le nombre de polygon affichés, même si la caméra n'est pas visible.
Celle-ci peut être mode perspective ou en mode orthogonal.


- les lights : ce sont des éléments émettant de la lumière et des ombres sur les objets et la scène. On peut régler divers paramètres, comme le type (point, directionnal, spot), les couleurs (diffuses et spéculaires), les ombres, la position.
Pour certaines, on peut régler l'atténuation ou le range (spot).
Pour changer l'intensité de la lumière(diffuse ou spéculaire d'une light, pour le moment il faut que la couleur comporte plus de noir.
Attention : une light de lumière noir n'émet aucune lumière. Elle n'émet pas de lumière "noire", comme dans Blender.

On ne peut pas encore régler l'atténuation des lights de type Point ou Directionnel.

Remarque :
- Toutes les lights qui émettent des ombres émettent le même type d'ombre. Cela est défini dans le WorldShadows() (voir plus bas)
- chaque entité qui projette des ombres ajoute des triangles (ou faces) dans votre scène. Il convient donc de désactiver les entités qui n'ont pas la nécessité de projeter des ombres, ou de proposer une option de projection d'ombre dans votre jeu.



Format d'exportation à utiliser (rappel) :
.mesh pour les mesh,
.material pour les material
.jpg/png/tga pour les textures.
.skeleton pour les animation


2. Autres éléments

Il existe d'autres éléments disponibles en purebasic qui peuvent s'avérer très intéressants :

- CreateWater() : créé une surface d'eau, avec quelques paramètres à régler (voir l'aide pour plus de détails).

- CreateTerrain() : permet de concevoir un terrain (voir l'aide pour plus de détails).. G-rom et Kelebrindae ont proposé des codes fort sympathiques qui peuvent vous aider dans la conception de terrain, en plus de cette fonction.

- CreateCube(), CreateSphere(), createPlane(), CreateCylinder() : permet de créer des meshs de forme de base : sphere, cube, plan, cylindre.
Cela peut être pratique pour concevoir des level rapidement par exemple et les tester, ou pour concevoir des boites de collisions, etc..

- Createline3D() : permet de concevoir des ligne 3D. Cela est très pratique pour le débuggage (vérifier la collision entre 2 meshs) ou pour d'autres choses comme un éditeur de Level (Axe visuel, boite englobante..)

- CreateMesh() : il est possible de créer des vertex et des faces en purebasic, puis de créer le mesh. Cela peut s'avérer pratique si vous souhaitez coder un modeleur par exemple, ou créer des meshs directement dans votre jeu (voir plus createTerrain de G-rom ou de Kelebrindae).

- saveMesh() : il est possible de sauvegarder un mesh (créé ou importé).

- Submesh : Purebasic gère aussi les "sub-mesh". On peut ajouter à une mesh créée avec CreateMesh() une autre mesh ou sous-mesh les mesh



3. Le World

Il s'agit du monde entourant votre scène, et des paramètres qui y sont liés.
Purebasic nous permet de modifier certains éléments liés à ce World :

- Sun() : il s'agit d'un soleil artificiel (cela change la couleur et la position) et cela affecte surtout l'eau.

- Fog() : permet d'ajouter un brouillard sur la scène, avec quelques paramètres (intensité, couleur, distance start et end ).
On peut faire évoluer ce fog(), pour cela, il suffit de le recréer, par exemple en diminuant la distance end, le brouillard se ra de plus en plus denses en temps réel.

- Ambientcolor() : permet de modifier la couleur Ambient de la scène.
Une couleur noire n'aura aucune incidence sur les materials, alors qu'une couleur blanche les rendra plus "lumineux".
Ainis, si vous supprimez les lights de votre scène, tous les entités seront visibles et pas complètement noire.
Il est aussi possible de paramétrer un material pour que celui-ci émette un peut de lumière, en modifiant le paramètre emissive :

Code : Tout sélectionner

material Emit
{
    receive_shadows on
    technique
    {
        pass Emit
        {
            ambient 0.8 0.8 0.8 0.5
            diffuse 0.65 0.65 0.65 0.5
            emissive 0.8 0.8 0.8 0.5
        }
     }
}  

- Skybox : permet de créer une boite englobant le monde, sur laquelle on peut dessiner un ciel.
La texture du ciel doit être d'une forme particulière pour cela (voir l'exemple skybox du dossier des exemples 3D de purebasic)


- Skydom : permet de créer une sorte de sphere englobant le monde, avec une texture dessus.
Cette sphère tourne sur elle-même donnant une impression de déplacement des nuages. On peut régler la courbe de cette sphère, ainsi que la texture, mais pas encore la vitesse de déplacement.


4. Autres paramètres

- réglage du type d'ombre : WorldShadows(), avec 3 types d'ombres disponibles.

- Worlddebug : permet d'avoir un mode débug, pour visualiser les boites englobantes des entités.

[blendman]

III.Fonctions avancées

1. Static geometry

(d'après l'aide) une static geometry est une forme géométrique (pouvant utiliser une mesh) prédéfinie et pré-rendue ne pouvant plus être modifé ensuite. Elle est donc très rapide à affichée.
grâce à cela, on peut afficher de très nombreux polygons (jusque 1 millions), en utilisant seulement quelques meshs par exemple.

2.Joint

les joints permettent de lier 2 entités entre elles, afin d'avoir des possibilités d'interaction entre les 2.
Cela peut être utile pour plusieurs choses, avec de la physique par exemple : des objets attachés les uns aux autres qui inter-agissent.

3. Physic

Purebasic dispose de fonctions permettant de gérer les collisions, et la physique (objet ayant une masse, friction...).

Informations importante sur la physique et les collisions (Source Comtois et G-rom) :
- lorsque vous concevez vos modèles 3D, il est important de définir le pivot de votre objet au centre, car il n'est pas encore possible de le modifier en purebasic. Cependant, la bouding box (boite de collision) créé à partir du mesh se dimensionne en son centre. Ainsi pour la boite colle parfaitement au mesh, il faut que son pivot soit au centre de celui-ci.


4.Ribbon

Le Ribbon est un effet spécial, pouvant être rapproché d'un motion blur (dans l'idée).
Cela permet de créer une sorte de trainée avec les objets qui se déplace.

C'est très utile pour ajouter des effets visuels de dynamique et de vitesse.

5. Compositor

Ce sont des post-filters ou effets spéciaux appliqués après le rendu de l'image 3D pour lui donner un certain aspect (flou, teinte, saturation, sépia, noir et blanc, bloom, etc..)

6. Billboard

Les billboards sont des plans (2 triangles) toujours tournés vers la caméra. On peut concevoir des groupes de billboards, cela est utile notamment pour la création d'éléments nombreux : herbes, pluie, neige, particules, effets de magie...

En général, on utilise des textures en transparence dessus (brin d'herbe, forme de nuage...).

7.Particules

Purebasic offre la possibilité de créer et modifier des systèmes de particules. Les particules sont pratiques pour les effets de feu, fumée, magie, effets météo (pluie, neige..), particules flottantes, etc...

Information importante (Merci Comtois) : si on souhaite utiliser le fog et les particules avec Alpha, il faudra utiliser un .material spécial pour ces particules (ou billboards).

En ajoutant notamment :

fog_override true

Code complet du material (merci Comtois)

Code : Tout sélectionner

material Examples/Particles
{
   technique
   {
      pass
      {
         lighting off
         depth_write on
         scene_blend add
         fog_override true
         texture_unit
         {
            texture flare.png
         }
      }
   }
} 

Pour utiliser ce code dans le jeu (dans l'exemple particule.pb):

Code : Tout sélectionner

;     LoadTexture(0, "flare.png")
;     
;     CreateMaterial(0, TextureID(0))
;     DisableMaterialLighting(0, 1)
;     MaterialBlendingMode   (0, #PB_Material_Add)
      GetScriptMaterial(0, "Examples/Particles") 

8.Node

Informations tirées de l'aide:
les nodes sont des conteneurs permettant de grouper des entités, caméras, billboard, sons 3D, systèmes de particules, autres noeuds. Les mouvements et position d'un objet attachés à un noeud sont relatifs à ce noeud. C'est un autre lien de parenté que celui de la librairie Joint.

9.Sound 3D

On ajouter dans une scène des sons 3D.
ce sont des sons qui s'atténuent en fonction de la distance avec la caméra.

[blendman]

IV. C'est parti pour le Show, on va faire une petite scène avec Ogre et Purebasic

Nous allons découvrir dans cette partie un code pour créer une scène 3D en purebasic et Ogre.

Si vous avez ouvert les exemples fournis avec l'installation de Purebasic, cela ne vous sera sans doute pas très utile, mais un petit rappel ne peut pas faire de mal ^^.


Généralité

Comme tout code Purebasic, vous pouvez l'organiser comme vous le voulez.
Néanmoins certaines choses doivent être réalisées dans un ordre précis.

Vous pouvez par exemple organiser votre code de la manière suivante, si vous le souhaitez :
- énumération, constante, définition des variables
- déclaration, création des structures
- initialisation (initsprite()...)
- ouverture de la fenêtre et de l'écran
- boucle

Concernant vos procédures, faites comme bon vous semble : au début de votre fichier, à la fin avec la déclaration des procédures au début, etc..

Quelques astuces qui peuvent être utile :
- essayer d'organiser votre code par parties distinctes.
- si celui-ci commence à être trop long, n'hésitez pas à le segmenter en plusieurs fichiers. Utilisez xincludefile , includefile pour inclure tous vos fichiers.


Plutôt que de réinventer la roue, je me suis permis de reprendre l'excellent exemple ThirdPerson.pb (Comtois et G-rom) et je l'ai commenté (un peu )


Vous devez enregistrer ce code dans le répertoire : \Examples\3D\Demos de purebasic

Code : Tout sélectionner

;
; ------------------------------------------------------------
;
;   PureBasic - Third Person
;
;    (c) 2011 - Fantaisie Software
;
; ------------------------------------------------------------

IncludeFile "Screen3DRequester.pb" ; The file "Screen3DRequester.pb" is include
;This file show a preference window, to define our resolution, fullscreen mode, ...
; ouvre une fenêtre de préférence, pour définir notre choix sur la résolution, le fullscreen, etc..

;{ les constantes / The constantes
#PlayerSpeed = 60
#CameraSpeed = 10
;}

;{ les structures / the structures
Structure Vector3 ; simple structure pour 3 coordonnées (on est en 3D)
  x.f
  y.f
  z.f
EndStructure

Structure s_Key ; structure nécessaire pour connaitre certains évènement avec le player (touche et déplacement)
; structure needed to know some event with the player (keyboard, motion/position of the player)
  Up.i
  Down.i
  Left.i
  Right.i
  StrafeLeft.i
  StrafeRight.i
  Jump.i
EndStructure

Structure s_Entity ; Structure nécessaire pour définir les propriétés de certaines entités
; structure needed to deifne the properties of some entities
  Entity.i
  EntityBody.i
  BodyOffsetY.f
  elapsedTime.f
  Key.s_Key
  MainNode.i 
  SightNode.i
  CameraNode.i 
  ForwardNode.i
  StrafeNode.i
EndStructure

Structure s_Camera ; notre camera / our camera
  Camera.i
  Tightness.f
  CameraNode.i
  TargetNode.i
EndStructure   
;}

;{ les macros
Macro GetNodePosition(Position, Node); permet de connaitre la position des noeuds (nodes)
; to know the position of the nodes
  Position\x = NodeX(Node) 
  Position\y = NodeY(Node) 
  Position\z = NodeZ(Node) 
EndMacro

Macro SubVector3(V, V1, V2) ; permet de connaitre la position de certains vecteurs 3D
; to know the position of some vector 3D
  V\x = V1\x - V2\x
  V\y = V1\y - V2\y
  V\z = V1\z - V2\z
EndMacro
;}

;{ Declare
; déclaration des procédures / declaration of procedures
Declare HandleEntity(*Entity.s_Entity)
Declare CameraTrack(*Camera.s_Camera, *Entity.s_Entity)
Declare OnGround(*Entity.s_Entity)
Declare MakeColimacon(PX.f, PY.f, PZ.f, Length.i, Height.i, Width.i, Stair.i)
Declare MakeStair(PX.f, PY.f, PZ.f, Length.i, Height.i, Width.i, Stair.i)
Declare AddObjects()
;}

;{ define
Define Robot.s_Entity
Define Camera.s_Camera
;}

If InitEngine3D(); on doit tout d'abord initialiser l'engine 3D avant tout le reste / First, we have to initialise the engine3D
  
  ; puis on initialise les autres libs qu'on utilise/ and we initiliase the others libs
  InitSprite() ; les sprites
  InitKeyboard() ; le clavier
  InitMouse() ; la souris
 
  If Screen3DRequester() ; on vérifie qu'on a choisit une résolution, un mode fullscreen, etc.. / verification of the resolution, fullscreen mode..
    KeyboardMode(#PB_Keyboard_International) ; on change le mode du clavier/ we change the mode of the keyboard
    
    ;{ 3D archives
    ; ici, on ajoute les "archives", les chemins vers les données
    ; here, we had the path for the "archives" (the datas)
    Add3DArchive("../Data/Textures"        , #PB_3DArchive_FileSystem)
    Add3DArchive("../Data/Models"          , #PB_3DArchive_FileSystem)
    Add3DArchive("../Data/Scripts"         , #PB_3DArchive_FileSystem)
    Add3DArchive("../Data/GUI"             , #PB_3DArchive_FileSystem)
    Add3DArchive("../Data/Packs/desert.zip", #PB_3DArchive_Zip)
    Parse3DScripts() ; on lit les fichiers scripts d'ogre / to "read" the scripts (material)
    ;}
    
    WorldShadows(#PB_Shadow_Additive, 50) ; on définit le type d'ombre du monde. Ici, j'ai mis en additif, mais c'est plus gourmand.
   ; here, we chosse the shadows mode of the world. I have set it in additive, but it's more consuming CPU.
   
    ;{ Texture
    ; on créé une texture / creation of a texture
    CreateTexture(1, 256, 256)
    StartDrawing(TextureOutput(1))
    Box(0, 0, 256, 256, $002255)
    DrawingMode(#PB_2DDrawing_Outlined)
    Box(0, 0, 256, 256, $FFFFFF)
    Box(10, 10, 236, 236, $FFFF)
    StopDrawing()
    ;}
   
    ;{ Material
    ; on créé les material qu'on va utiliser / we create the material we will use after
    CreateMaterial(0, LoadTexture(0, "r2skin.jpg"))
    CreateMaterial(1, TextureID(1))
    CreateMaterial(2, LoadTexture(2, "Dirt.jpg"))
    CreateMaterial(3, LoadTexture(3, "Wood.jpg"))
    GetScriptMaterial(4, "Scene/GroundBlend")
    ;}
    
    ;{ Les mesh
    ; on charge ou on créé les mesh qu'on va utiliser
    ; creation or loading of the meshs used in our scene
    ; Robot
    LoadMesh   (0, "robot.mesh")
    CreateEntity (0, MeshID(0), #PB_Material_None);
    AnimateEntity(0, "Stop")    ;AnimateEntity(0, "Idle")
   
    ;Robot Body
    CreateEntity(1, MeshID(0), #PB_Material_None, 0, 26, 0)
    HideEntity(1, 1)
   
    ;Ground
    CreatePlane(2, 5000, 5000, 100, 100, 100, 100)
    CreateEntity(2, MeshID(2), MaterialID(1), 0, 0, 0)
   
    ;Body
    EntityPhysicBody(1, #PB_Entity_CapsuleBody, 1, 0, 0)
    EntityPhysicBody(2, #PB_Entity_StaticBody)
   
    ;Add some statics and dynamics objects
    CreateCube(3, 1)
    AddObjects() 
   
    ;Add some stairs
    MakeColimacon(120, 0, 120, 130, 7, 48, 15)
    MakeStair(360, 0, 220, 130, 11, 48, 15)
    ;}
    
    ;{ Light
    ; on ajoute les light dans notre scène et on définit la couleur d'ambiance
    ;  we add the lights in our scene, and we define the ambient color
    CreateLight(0,RGB(155,155,155),700,500,0)
    CreateLight(1,RGB(235, 175, 123),100,50,500)
    DisableLightShadows(1, 1) ; to disable the shadow on the light 1
    AmbientColor(RGB(85,85,85))
    ;}
    
    ;{ Skybox
    ; on ajoute une skybox pour le ciel/ we add a skybox for the sky
    SkyBox("desert07.jpg")
    ;}
    
    ;{ on va initialiser certains paramètres pour certains "objet" (ou entité)
   ; initilisation of somes parameters for some objects (or entity)
    ; le robot : le personnage joueur / the robot is the character for the player
    With Robot
     ;{ propriétés générales/ general properties
      \Entity = 0
      \EntityBody = 1
      \BodyOffsetY = 43
      ;}
     ;{ définition en fonction des touches clavier
     ; for the keyboard
      \Key\Down        = #PB_Key_Down
      \Key\Left        = #PB_Key_Left
      \Key\Right       = #PB_Key_Right
      \Key\Up          = #PB_Key_Up
      \Key\StrafeLeft  = #PB_Key_X
      \Key\StrafeRight = #PB_Key_C
      \Key\Jump        = #PB_Key_Space
     ;}
     ;{ on ajoute des Nodes (Les noeuds sont des conteneurs qui peuvent être utilisés pour grouper des objets )
     ; we add the nodes, the nodes are container which can be used to group some objects
     \MainNode    = CreateNode(#PB_Any) ; Entity position
      \SightNode   = CreateNode(#PB_Any,  120,  20,  0) ; For cameraLookAt
      \CameraNode  = CreateNode(#PB_Any, -140, 100,  0) ; Camera position
      \ForwardNode = CreateNode(#PB_Any,    1,   0,  0) ; Direction normalized
      \StrafeNode  = CreateNode(#PB_Any,    0,   0, -1) ; Direction normalized
     
      AttachNodeObject(\MainNode, NodeID(\SightNode)  , #PB_Node_Node)
      AttachNodeObject(\MainNode, NodeID(\CameraNode) , #PB_Node_Node)   
      AttachNodeObject(\MainNode, NodeID(\ForwardNode), #PB_Node_Node)     
      AttachNodeObject(\MainNode, NodeID(\StrafeNode) , #PB_Node_Node)   
      AttachNodeObject(\MainNode, EntityID(\Entity)   , #PB_Node_Entity)
      ;}      
    EndWith
   
    ;{ Camera
    CreateCamera(0, 0, 0, 100, 100)
    With Camera 
      \Camera = 0
      \Tightness = 0.035
      ; Camera use 2 nodes
      \CameraNode = CreateNode(#PB_Any, -3000, 700, 0) ; Camera position
      \TargetNode = CreateNode(#PB_Any) ; For cameraLookAt
      AttachNodeObject(\CameraNode, CameraID(\Camera), #PB_Node_Camera)
    EndWith 
   ;}
   ;}
   
    ;{ pour éviter que la caméra ne bouge au lancement du jeu
    ; to avoid the camera move at the start of the game
    If ExamineMouse()
      MouseDeltaX()
      MouseDeltaY()
    EndIf
    ;}
    
    ;{ Main loop  
    Repeat
      Screen3DEvents()
     
      If Engine3DFrameRate(#PB_Engine3D_Current) ; on vérifie le FPS / verification of the fps
        Robot\elapsedTime = 40/Engine3DFrameRate(#PB_Engine3D_Current)
      EndIf       
     
      HandleEntity(@Robot) ; procedure d'event lié au robot (clavier, déplacement, collision..) / procedure of event for the robot (keyboard, position, collision..)    
      CameraTrack(@Camera, @Robot)
     
      RenderWorld(50); on fait le rendu du monde 3D / rendering of the world
      FlipBuffers() ; 
    Until KeyboardPushed(#PB_Key_Escape) Or Quit = 1
    
    
  EndIf
 
Else
  MessageRequester("Error", "The 3D Engine can't be initialized",0)
EndIf

End
;}


;{ les procedures  / the procedures
Procedure OnGround(*Entity.s_Entity)
  With *Entity
    ProcedureReturn RayCollide(NodeX(\MainNode),  NodeY(\MainNode)+3, NodeZ(\MainNode), NodeX(\MainNode), NodeY(\MainNode),  NodeZ(\MainNode))
  EndWith 
EndProcedure

Procedure IsStair(*Entity.s_Entity)
  Protected.f x, y, z
  With *Entity
    x = (NodeX(\ForwardNode) - NodeX(\MainNode))*30
    y = (NodeY(\ForwardNode) - NodeY(\MainNode))*30
    z = (NodeZ(\ForwardNode) - NodeZ(\MainNode))*30
    ;CreateLine3D(20, NodeX(\MainNode), NodeY(\MainNode)+20, NodeZ(\MainNode), $FFFF, NodeX(\MainNode)+V\x, NodeY(\MainNode)+V\y+20,  NodeZ(\MainNode)+V\z, $FFFF)
    Ray1 = RayCollide(NodeX(\MainNode), NodeY(\MainNode)+10, NodeZ(\MainNode),  NodeX(\MainNode)+x, NodeY(\MainNode)+y+10,  NodeZ(\MainNode)+z)
    Ray2 = RayCollide(NodeX(\MainNode), NodeY(\MainNode)+20, NodeZ(\MainNode),  NodeX(\MainNode)+x, NodeY(\MainNode)+y+20,  NodeZ(\MainNode)+z)
    If Ray1 And Ray2=0
      ProcedureReturn 1
    EndIf
    ProcedureReturn 0
  EndWith 
EndProcedure

Procedure HandleEntity(*Entity.s_Entity)
  Protected.Vector3 Forward, Strafe, PosMain, PosDir, PosStrafe
  Protected.f Speed, Speed2, x, y, MouseX, MouseY, Action.s
  Static Jump.f, MemJump.i, Rot.Vector3, Trans.Vector3, Clic, LastAction.s
 
  With *Entity
    GetNodePosition(PosMain, \MainNode)
    GetNodePosition(PosDir, \ForwardNode)
    GetNodePosition(PosStrafe, \StrafeNode)
    SubVector3(Forward, PosDir, PosMain)
    SubVector3(Strafe, PosStrafe, PosMain)
   
    Speed = #PlayerSpeed * \elapsedTime
    Speed2 = Speed / 2
   
    If ExamineKeyboard()
     
      If KeyboardReleased(#PB_Key_F5)
        ;WorldDebug(#PB_World_DebugBody) : bug pour le moment avec la 4.61b2
      ElseIf KeyboardReleased(#PB_Key_F6)
        WorldDebug(#PB_World_DebugEntity)
      ElseIf KeyboardReleased(#PB_Key_F7)
        WorldDebug(#PB_World_DebugNone)
      EndIf
     
      If KeyboardPushed(\Key\Jump) And OnGround(*Entity)
        Jump = 4
        MemJump = 1
      EndIf 
      
      Rot\x * 0.30
      Rot\y * 0.30
      Rot\z * 0.30
      Trans\x * 0.20
      Trans\y = Jump
      Trans\z * 0.20
     
      Action = "Stop"      ;Action = "Idle"
     
      If KeyboardPushed(\Key\Up)
        Trans\x + Forward\x * Speed
        Trans\z + Forward\z * Speed
        Action = "Walk"
      ElseIf KeyboardPushed(\Key\Down)
        Trans\x + Forward\x * -Speed2
        Trans\z + Forward\z * -Speed2
        Action = "Walk"
      EndIf
     
      If KeyboardPushed(\Key\Left)
        Rot\y + 2 * \elapsedTime
        If Action <> "Walk"
          action="Idle"
        EndIf        
      ElseIf KeyboardPushed(\Key\Right)
        Rot\y - 2 * \elapsedTime
        If Action <> "Walk"
          action="Idle"
        EndIf 
      EndIf
     
      If KeyboardPushed(\Key\StrafeLeft)
        Trans\x + Strafe\x * Speed2
        Trans\z + Strafe\z * Speed2
        Action = "Walk"
      ElseIf KeyboardPushed(\Key\StrafeRight)
        Trans\x + Strafe\x * -Speed2
        Trans\z + Strafe\z * -Speed2
        Action = "Walk"
      EndIf
     
      If Action <> LastAction
        LastAction = Action
        AnimateEntity(0, Action)
      EndIf
      
      If OnGround(*Entity)
        Jump = 0
      ElseIf MemJump
        Jump + 20
        If Jump > 80
          MemJump = 0
        EndIf
      Else
        Jump - 9 * \elapsedTime
      EndIf 
      
      
      If IsStair(*Entity) And Jump = 0 And ( Abs(Trans\x)>=Speed / 2 Or Abs(Trans\z)>=Speed / 2)
        Jump = 22 ; Or more
      EndIf
     
    EndIf
   
    MoveEntity  (\EntityBody, Trans\x, Trans\y, Trans\z)
    RotateEntity(\EntityBody, 0, Rot\y, 0, #PB_Relative)   
   
    NodeLocate(\MainNode, EntityX(\EntityBody), EntityY(\EntityBody)-\BodyOffsetY, EntityZ(\EntityBody))
    RotateNode(\MainNode, 0, EntityYaw(\EntityBody), 0)
  EndWith   
EndProcedure


Procedure CameraTrack(*Camera.s_Camera, *Entity.s_Entity)
  Protected CameraPosition.Vector3, TargetPosition.Vector3, Temp.Vector3
  Protected V1.Vector3, V2.Vector3, x.f, y.f, z.f
 
  GetNodePosition(CameraPosition, *Entity\CameraNode)
  GetNodePosition(TargetPosition, *Entity\SightNode)
  x = NodeX(*Camera\CameraNode)
  y = NodeY(*Camera\CameraNode)
  z = NodeZ(*Camera\CameraNode)
  x = (CameraPosition\x - x) *  *Camera\Tightness
  y = (CameraPosition\y - y) *  *Camera\Tightness
  z = (CameraPosition\z - z) *  *Camera\Tightness
  MoveNode(*Camera\CameraNode, x, y, z)
 
  x = NodeX(*Camera\TargetNode)
  y = NodeY(*Camera\TargetNode)
  z = NodeZ(*Camera\TargetNode)
  x = (TargetPosition\x - x) *  *Camera\Tightness
  y = (TargetPosition\y - y) *  *Camera\Tightness
  z = (TargetPosition\z - z) *  *Camera\Tightness
  MoveNode(*Camera\TargetNode, x, y, z)
 
  CameraLookAt(*Camera\Camera, NodeX(*Camera\TargetNode), NodeY(*Camera\TargetNode), NodeZ(*Camera\TargetNode))
 
EndProcedure


Procedure MakeColimacon(PX.f, PY.f, PZ.f, Length.i, Height.i, Width.i, Stair.i)
  Protected.f Angle
  Protected.i a, Ent
 
  For a = 1 To Stair
    Ent = CreateEntity(#PB_Any, MeshID(3), MaterialID(2))
    ScaleEntity(Ent, Length, Height, Width)
    EntityLocate(Ent, PX + Cos(Radian(Angle)) * Width * 5, PY + (a-1) * Height * 4, PZ -Sin(Radian(Angle)) * Width * 5)
    RotateEntity(Ent, 0, Angle, 0)
    EntityPhysicBody(Ent, #PB_Entity_StaticBody)
    Angle = Mod(Angle + 30, 360)
  Next
EndProcedure

Procedure MakeStair(PX.f, PY.f, PZ.f, Length.i, Height.i, Width.i, Stair.i)
  Protected.i a, Ent, Nb
  Protected.f Size, Delta, H 
 
  For a = 1 To Stair
    Ent = CreateEntity(#PB_Any, MeshID(3), MaterialID(2))
    ScaleEntity(Ent, Length, Height, Width)
    EntityLocate(Ent, PX, PY + (a-1) * Height, PZ + (a-1) * Width * 0.8)
    EntityPhysicBody(Ent, #PB_Entity_StaticBody)
  Next a
 
  ;Add a plateform
  Ent = CreateEntity(#PB_Any, MeshID(3), MaterialID(2))
  ScaleEntity(Ent, Length*5, Height, Width*5)
  EntityLocate(Ent, PX, PY + (a-1) * Height, PZ + (a-1) * Width)
  EntityPhysicBody(Ent, #PB_Entity_StaticBody)
 
  ;Add Pyramid
  Nb = 7
  Delta = 0.01
  Size = 20
  H = EntityY(Ent) + Height/2
  For j = 0 To Nb
    For i= 0 To Nb-j
      Ent = CreateEntity(#PB_Any, MeshID(3), MaterialID(4))
      ScaleEntity(Ent, Size, Size, Size)
      EntityPhysicBody(Ent, #PB_Entity_BoxBody, 0.5)
      EntityLocate(Ent, 340 +  j * ((Size) / 2) + i * Size, H + ((Size) / 2) + (j * (Size)), 890)
    Next
  Next
EndProcedure

Procedure AddObjects()
  Protected Size.Vector3
  Protected.f x, z
  Protected.i Ent, i 
 
  For i = 0 To 100
    If Random(1)
      Size\x = Random(60) + 30
      Size\y = Random(60) + 30
      Size\z = Random(60) + 30     
      Volume.f = Size\x * Size\y * Size\z
      Ent=CreateEntity(#PB_Any, MeshID(3), MaterialID(3), Random(5000)-2600, 100, Random(5000)-2500)
      RotateEntity(Ent, 0, Random(360), 0)
      ScaleEntity(ent, Size\x, Size\y, Size\z)       
      EntityPhysicBody(Ent, #PB_Entity_BoxBody, (Volume / 7000), 0, 2)
    Else
      Size\x = Random( 60) + 30
      Size\y = Random(160) + 30
      Size\z = Random( 60) + 30     
     
      Repeat
        x = Random(5000)-2500
      Until x < -400 Or x > 400 
     
      Repeat
        z = Random(5000)-2500
      Until z < -400 Or z > 400 
     
      Ent=CreateEntity(#PB_Any, MeshID(3), MaterialID(2), x, Size\y/2 + Random(90) , z)
      RotateEntity(Ent, 0, Random(360), 0)
      ScaleEntity(Ent, Size\x, Size\y, Size\z)
      EntityPhysicBody(Ent, #PB_Entity_StaticBody)   
    EndIf
   
  Next
EndProcedure 

;}

[blendman]

V. Exportation d'un modèle 3D depuis Blender (2.6x)

Informations sur Blender

Blender est un Logiciel de modélisation, animation et rendu 3D. Il est gratuit et Open-source.

La dernière Version est la 2.63 (main 2012).

Il permet de créer des modèles 3D de qualité, pour le pré-calculé ou le temps réel.

Il dispose d'un moteur de jeu Interne( le BGE), qui est plutôt performant pour concevoir des petits jeux amateurs.
D'un point de vue graphique, en temps réel, on dispose d'une preview des shaders avec la plupart des paramètres disponibles (spculaire, normal map..).
On a le même rendu ou presque dans le moteur de jeu.

Mais ce qui nous intéresse, c'est la possibilité d'exporter un modèle 3D que l'on a créé nous-même pour du temps en .mesh pour l'ouvrir dans ogre ( et purebasic bien entendu).

Je ne parlerai pas de la création d'un modèle 3D sous blender. Pour cela, vous trouverez énormément de tutoriaux sur internet. J'ai même participé à l'écriture d'un livre là-dessus .

Installation du script d'export de blender (2.63) vers ogre

Il existe des scripts d'export de blender vers ogre, pour la plupart des versions (2.49b, 2.5x, 2.6x).
Nous utiliserons le dernier pour al 2.63.

Installation (blender et script d'export blender -> ogre
- si ce n'est pas encore fait, téléchargez blender 2.63 et installez-le (http://www.blender.org/)
- téléchargez le script d'export blender vers ogre (version 2.63) : http://www.ogre3d.org/forums/viewtopic.php?f=8&t=61485
- installez-le /copiez-le dans le répertoire script\addons de votre blender 2.63, logiquement, ça doit être : 2.63\scripts\addons
- ensuite, dans blender, activez cet addon depuis le panneau de préférence (ctrl+alt+U), panneau Addons / sous menu à gauche Import-Export
- cochez la case Import-Export:Ogre Exporter (.scene, .mesh,.skeleton)
- cliquez sur "save as default" (bouton en bas)
- et voilà, normalement, votre addons est installé.

Remarque :
- blender 2.5x script d'export (au cas où) : http://www.ogre3d.org/tikiwiki/Blender+2.5+Exporter


Créer les shaders (material) depuis blender 2.63

Dans blender, vous pouvez créer vos propres materiaux (ou shaders), et les appliquer à vos objets.
Vous avez normalement installé l'addons d'export blender->ogre. Si ce n'est pas encore le cas, voir un peu plus haut.

S'il est activé, vous avez normalement un tout petit panneau en haut, à droite (àcoté du bouton pour mettre blender en fullscreen) , indiquant "Ogre toggle UI".
Si vous l'activez,(je le conseille), des nouveaux panneaux et menus apparaitront et notamment pour les matériaux.
Cela vous permettra de mieux voir ce que vous pouvez exporter comme paramètres de vos matériaux et textures.

La création d'un shader utilisable par Ogre n'est pas encore complet avec cet Addons :
- on a accès surtout aux textures diffuse, mais pas encore aux canaux de type normal map, spec, etc..

Concevez cependant vos matériaux comme d'habitude, car ce script sera sans doute mis à jour régulièrement .
De toute manière, vous pouvez retravaillez vos .material exporté (je vous le conseille)

Il existe de nombreux tutoriaux sur la création de matériaux avec blender, je vous laisse le soin de trouver ces tutoriaux sur le net .

Une fois que vous avez créé un matérial dans blender, l'exportation de celui-ci s'effectue en même temps que l'export du modèle 3D.


exporter un mesh depuis blender 2.63

Vous avez normalement installé l'addons d'export vers ogre. Si ce n'est pas fait, voir plus haut.

Utilisation
- sélectionnez votre objet 3D
- allez dans le menu file\export et choisissez Ogre 3D
- ensuite, définissez les paramètres que vous souhaitez prendre en compte (à gauche) : comme l'export du modèle sélectionné uniquement, des animations, de la scène, des materials, etc..

Résultat de l'exportation
Une fois que vous avez exportez, vous devez avoir obtenu :
- un .mesh.xml que vous devrez convertir ensuite avec l'utilitaire d'ogre.
- un .skeleton si vous avez créée des animations
- un .material (ou plusieurs) : ce sont vos material
- un .scene si vous l'avez activé, c'est votre scène.


Note :
Quelques informations sur le script : http://code.google.com/p/blender2ogre/w/list


Conversion du mesh avec l'utilitaire de Ogre

Téléchargement de l'utilitaire de conversion

- Télécharger sur le site d'ogre l'utilitaire : OgreXMLConverter.exe
- pour cela : rendez-vous sur la page : http://www.ogre3d.org/download/tools
- tout en bas, dans "Miscellaneous", téléchargez la version qui vous convient (mac, windows, pour linux, je ne sais pas oùcela se trouve) : Ogre Command-line Tools (1.7.2)
Remarque : sur cette page, vous trouverez divers liens, notamment vers des exporters. Il y en a pour Blender, mais je ne sais pas ce qu'ils donnent,.


Conversion

- lorsque vous avez converti un de modèle depuis blender, vous avez obtenu un *.mesh.xml
- copier ce fichier dans le répertoire où vous avez mis OgreXMLConverter.exe
- ensuite glissez-déposez ce fichier (*.mesh.xml) sur OgreXMLConverter.exe
- si tout s'est bien passé, vous obtenez un fichier *.mesh, un peu plus léger.
- sinon, c'est que votre modèle a des problèmes, il faudra le retravailler dans blender et retenter une exportation.

- si cela s'est passé correctement, vous pouvez utiliser votre mesh dans purebasic/ogre .


Astuce : Conversion multiple

si vous avez beaucoup de fichiers *.mesh.xml à convertir, voici une technique plutôt pratique :
- créez un dossier à la racine de votre disque dur et mettez-y votre ogreXmlConverter.exe (par exemple : c:/Ogre/ et vous y placez tout ce qui est nécessaire (ogrexmlconverter.exe + les dll associées)
- créez un autre dossier à la racine de votre disque dur et mettez-y vos fichiers à convertir (par exemple c:/convert).
- ouvrez une invite de command (cmd.exe)
- allez dans votre dossier c:/ convert, normalement, vous devez faire : cd .. , puis cd .. , puis cd convert
- tapez la ligne suivante : for %1 in ( *.xml.mesh) DO c:\Ogre\OgreXmlConverter %1 (si vous avez mis votre converter dans c:/ogre)
- ensuite patientez le temps que cela soit converti et voilà tous vos meshs sont convertis en 1 seule fois, c'est pratique


Remarques et Astuces importantes

Optimisation
- veillez à concevoir des modèles ayant le moins de faces possibles pour du temps réel.
- si possible n'utilisez qu'un seul material par modèle, ce sera plus simple ensuite. Vous pouvez si besoin en utiliser plusieurs, mais ce sera plus délicat à gérer si vous souhaitez les modifier dans Purebasic/Ogre
- veillez à créer des textures les plus petites possibles et si possible en puissance de 2 : 64*64, 128*128, 256*256, etc..
- de plus, évitez de mettre des normal map, spec map ou autre sur tous vos modèles. Cela risque d'alourdir le temps de calcul du rendu dans Ogre et de baisser vos FPS.
- il faut savoir que le calcul des ombres dans rajoute énormément de faces : veillez à n'utiliser des ombres projetés que si c'est nécessaire, et faites le uniquement sur les modèles souhaités.

Règle de lighting
- En général, on choisit d'utiliser 3 sources de lumière principale : une qui donne la teinte et projette des ombres. Une deuxième en contre -lumière dans les tons complémentaire. Une troisième beaucoup moins intense en opposition (de l'autre cote), pour faire un très léger back light). Vous pouvez ensuite ajouter des lumières ponctuelles là où vous avez mis des sources lumineuses (feu, objets magique, lampe..)
- il faut si possible qu'il y ait le moins de light possible qui projettent des ombres (une seule peut suffire).

Réutilisation
- essayez de réutiliser, dans la mesure du possible, vos textures ou material

Echelle
- il est important de faire un premier d'exportation et d'importation de votre modèle dans purebasic/ogre. Les échelles peuvent être très différentes entre blender (ou d'autres modeleurs) et purebasic/ogre. Il vous faudra alors faire un scale de votre modèle dans purebasic, mais autant qu'il soit tout de suite à la bonne taille dans blender. Ainsi, il est intéressant de créer une scène vide avec une échelle de référence (un personnage low-poly par exemple). Cela vous permet d'éviter de créer des modèles avec nécessité de les agrandir si ce n'est pas nécessaire.

[blendman]

VI. Les materials un peu en détail

Voici déjà quelques liens qui seront utiles :

- des exemples de materials :
http://www.ogre3d.org/tikiwiki/Materials

- Les passes de material :
http://www.ogre3d.org/docs/manual/manual_16.html

- pass et fragment /vertex shaders
http://www.ogre3d.org/docs/manual/manual_23.html#SEC121

- shaders (généralité) :
http://www.ogre3d.org/tikiwiki/Shaders& ... e=Cookbook

- HLSL : http://www.ogre3d.org/tikiwiki/HLSL&structure=Cookbook

Des codes GLSL :
http://code.google.com/p/glslang-library/

Shaders (GLSL) :
Reflect : http://code.google.com/p/glslang-librar ... g.glsl?r=8

VII.informations complémentaires

Fichiers et Exemples utiles

Exemples généraux ou complets - Jeux (2d et 3D)
- liste de fichiers d'exemples : http://www.purebasic.fr/french/viewtopi ... =2&t=12360

Shoot
- MadFire(Cool Dji) : http://www.purebasic.fr/french/viewtopi ... =2&t=11828

Jeux de course
- proto de jeux de course (Kelebrindae) : http://www.purebasic.fr/french/viewtopi ... 13&t=12531
- générateur de circuit (Kelebrindae) : http://www.purebasic.fr/french/viewtopi ... 13&t=12421

Ribbon Effect
- KeleBrindae (encore lui ) : http://www.purebasic.fr/french/viewtopi ... 13&t=11748

Physique
- code de comtois au milieu de la page : http://www.purebasic.fr/french/viewtopi ... =2&t=12335
- aéroglisseur (Kelebrindae) : http://www.purebasic.fr/french/viewtopi ... 13&t=12395
- pendule harmonique (Kelebrindae) : http://www.purebasic.fr/french/viewtopi ... 13&t=11889

Utilitaires ou fonctions pratiques

- create terrain (Kelebrindae) : http://www.purebasic.fr/french/viewtopi ... 13&t=12370
- create terrain (G-rom & Huitbit) : http://www.purebasic.fr/french/viewtopi ... 13&t=11797


Shaders
- quelques shaders et test (un peu tout le monde) : http://www.purebasic.fr/french/viewtopi ... 13&t=11740
- shader lave (Kelebrindae) : http://www.purebasic.fr/french/viewtopi ... 13&t=11418
- shader soleil (Kelebrindae) : http://www.purebasic.fr/french/viewtopi ... 13&t=11400


Remerciements

Évidemment un grand Merci à Fred pour le purebasic, mais aussi à G-rom pour avoir participer très grandement à l'ajout de superbes fonctions 3D (static geometry, cube mapping/reflexion, paramètres de material, ribbon, , ajout de paramètres liés aux rotations, compositor, etc..).

Remerciements supplémentaires :
- G-rom pour les nombreux conseils en matière de 3D et les exemples qu'il a fourni (create terrain, static geometry, fps...).
- Comtois pour les exemples en 3D.
- Kelebrindae : pour les exemples sur les shaders, ou les scènes (physiques, create terrain)
- et tout ceux qui ont posté des exemples en 3D, permettant de comprendre d'avantage comment fonctionne Purebasic et la 3D.

[bombseb]

Et un merci à toi pour ce super tuto !

[omega]

Bonjour à tous

Que pourriez-vous conseiller à un vrai débutant pour apprendre à développer des jeux 3D?
Quel est l'outil le plus indiqué ? Est ce que je peux commencer directement en Pb ??

Merci

[Cool Dji]

Hello,

Qui que c’est t’y qu’a un lien pour choper OgreXMLConverter.exe ?
Google ne donne rien...
Je vais en avoir besoin, je viens d'installer la 2.63

Merci

[blendman]

Qui que c’est t’y qu’a un lien pour choper OgreXMLConverter.exe ?
Google ne donne rien...
Je vais en avoir besoin, je viens d'installer la 2.63

salut

j'ai ajouté ça dans la partie sur la conversion blender> ogre :

- rendez-vous sur la page : http://www.ogre3d.org/download/tools
- tout en bas, dans "Miscellaneous", téléchargez la version qui vous convient (mac ou windows, pour linux, je ne sais pas où cela se trouve) : Ogre Command-line Tools (1.7.2)

Il y a aussi à cette page un lien d'exporter depuis blender, mais je ne sais pas ce que cela donne.

Voiloutch, en espérant que cela t'aide .

[Ar-S]

il n'existe pas d’éditeur de particule (...)

Sur topic blendman, merci pour ce boulot.

Pour ce qui est de l'editeur de particule, il en existe. J'ai par exemple utilisé Particle illusion qui est vraiment bien. Petit test sur video que j'ai fait il y a qques années : https://rapidshare.com/files/3620612567 ... inasse.avi

[blendman]

il n'existe pas d’éditeur de particule (...)

Pour ce qui est de l'editeur de particule, il en existe. J'ai par exemple utilisé Particle illusion qui est vraiment bien.

je parlais d'un éditeur de particule permettant d'utiliser les particules/systèmes de particules créés dans un jeu Vidéo en 3D, donc compatible avec purebasic /ogre
Le résultat de ParcileIllusion ce n'est que pour la 2D ou la vidéo, pas la 3D en temps réel.

De plus, il n'est mis nulle part que Particle Illusion a été codé en purebasic .

[Cool Dji]

Oki, Merci Blendman pour le lien

[comtois]

il y a Ogre particule lab fait par un français
Et Particle universe qui est payant

Fut un temps j'avais utilisé Ogre Particle editor qui était disponible sur le site d'ogre, mais je n'arrive plus à mettre la main dessus
malgré ce lien

[blendman]

Merci Comtois.
Visiblement, ça utilise les particles scripts, mais on n'a pas encore ça dans purebasic ^^.

Particle Universe a l'air top, je l'avais repéré car il est utilisé dans Torchlight .