Cet article vous guidera dans vos débuts en programmation de jeux vidéo et vous aidera à choisir les bons outils, langages, API et bibliothèques

Sommaire des tutoriels sur OpenGL : une spécification portable de rendu graphique 2D et 3D.

Sommaire des tutoriels sur OpenGL ES : une spécification portable de rendu graphique 2D et 3D pour les mobiles et systèmes embarqués.

Apprenez à programmer avec DirectX 11 et créer des applications 3D ainsi que des jeux avec cette série complète de tutoriels.

Grégory Massal nous présente ici l'historique des versions de DirectX et détaille les fonctionnalités accompagnant la onzième version de l'API de Microsoft.

Jesse Natalie est développeur chez Microsoft dans l'équipe Direct 3D. Ce guide est destiné aux développeurs connaissant et ayant déjà utilisé DirectX 11.

Ce tutoriel présentera comment bien débuter avec cette API qui peut être utilisée de façon complètement indépendante des autres modules de DirectX.

DirectShow est à la base un composant de DirectX. Depuis avril 2005, il est devenu un composant à part entière. Ce tutoriel présentera la préparation de l'environnement pour l'utilisation de DirectShow.

Cette série de tutoriels vous apprendra à faire vos débuts avec l'API multimédia DirectX en C#.

Tutoriel sur l'utilisation du composant DelphiX à travers la programmation d'un jeu.

Déçus par DelphiX ? Voici un tour d'horizon des composants Asphyre, qui proposent une encapsulation complète et facile d'utilisation de DirectX 9

Quand on parle développement de jeux, la grande majorité de personnes pensent que C++ est le seul langage adapté à ce type de programmation. Toutefois, nous allons voir que vous pouvez tout à fait créer un jeu ou du moins, utiliser DirectX avec Delphi.

XNA n'est plus développé par Microsoft, ce qui veut dire que les nouveaux systèmes d'exploitation ne sont pas officiellement supportés et que le framework ne recevra pas de mise à jour. Heureusement, tout n'est pas perdu. MonoGame est une implémentation libre du framework et propose même d'étendre ses fonctionnalités.

Dans cette seconde partie, nous allons voir comment gérer la détection de collisions entre notre personnage et son environnement. La technique utilisée ici sera celle du « Pixel Perfect » donc une détection de collision au pixel près.

Ce tutoriel introduit et détaille de manière très complète la plateforme de développement de jeux pour C# XNA.

Introduction à la programmation pour XBox en utilisant le framework XNA de Microsoft

Actuellement il n'existe aucune API pour faire de la 3D dans le JDK officiel. Cependant il existe plusieurs projets qui comblent ce manque. Certains projets sont développés par Sun eux-mêmes.

Cette série d'articles a pour but d'apprendre OpenGL étape par étape en utilisant Java, avec JOGL.

Intégrez et réalisez votre première application JOGL avec Eclipse. Ce tutoriel vous guidera dans le processus d'installation de la bibliothèque dans votre IDE.

Trois tutoriels sur l'utilisation du moteur Plegat Graphic Engine :
-> introduction ;
-> bases et gestion de la caméra ;
-> définition et affichage d'objets.

Dans cet article, nous verrons dans un premier temps l'historique de Qt et de son support d'OpenGL puis nous découvrirons l'ensemble des nouvelles fonctionnalités de Qt 5.1 qui améliorent le support d'OpenGL.

Qt propose la classe QOpenGLBuffer (anciennement nommée QGLBuffer) pour faciliter la manipulation des différents types de tampons tels que les attributs de sommets ou les tampons d'indices. OpenGL possède aussi un conteneur appelé Vertex Array Object (VAO) pour faciliter la manipulation de ce type de données.

OpenGL propose sur les plates-formes de bureau un outil très pratique nommé requêtes temporelles. Ces derniers permettent de mesurer le temps passé par le processeur graphique à traiter un certain nombre de commandes. En couplant ces outils aux traditionnelles techniques de profilage du processeur, il devient aisé de mettre en évidence les zones d'engorgement du code de rendu.

Ce tutoriel présente l'utilisation du processeur graphique (GPU) pour créer des applications de rendu 3D et de calculs parallèles multiplateformes sous Qt. Deux API libres et multiplateformes seront utilisées afin de communiquer avec le processeur graphique : OpenGL pour la partie rendu 3D et OpenCL pour le calcul. Un des points-clés de ce tutoriel est la recherche d'optimisation des performances. Différentes méthodes de programmation seront proposées : partant de versions qu'on pourrait qualifier de « naïves » c'est-à-dire simples, mais non optimisées, le souci de performances nous poussera à l'utilisation de techniques d'optimisation permettant souvent d'améliorer considérablement les performances. Un exemple récurrent est utilisé tout au long du tutoriel : la génération de terrain.

La première chose à faire lors de la conception d'un modèle est de penser à l'intérêt de ce que l'on fait. Dans ce cas, on veut un modèle qui stocke des informations concernant une scène 3D qui peut alors être rendue avec OpenGL et QGLWidget. La scène sera constituée de quelques objets, qui peuvent être définis de différentes manières offertes par la spécification OpenGL.
Ce genre de modèle est souvent basé sur des items, la première chose à faire est donc de définir ce que représente un item. Pour des scènes 3D, cela peut être un seul objet (modèle 3D). Au début, un set d'attributs (représentés comme des rôles dans l'implémentation MVC de Qt 4) devrait être défini et ensuite seulement la hiérarchie du modèle.

Ici, on expliquera quelles étapes doivent être effectuées pour obtenir un modèle OpenGL qui fonctionne et est prêt à fournir des données aux vues. Cet article est divisé en deux parties : ce qu'il faut implémenter pour un modèle en général puis une application au modèle OpenGL.

Dans la partie précédente de l'article, on a défini la structure et les attributs que le modèle encapsule. Maintenant, il est temps de rendre possible le stockage de données dans une structure arborescente.
Il y a deux méthodes pour le faire : la dure et la facile. La méthode la plus difficile est d'implémenter toutes les structures de données depuis zéro, alors que la plus facile dérive de QStandardItemModel et réutilise ses méthodes de stockage de données. Dans la plupart des cas, cette dernière méthode devrait fonctionner (cela fonctionne pour tout modèle dont les données sont stockées dans un QVariant), mais cela n'apprend pas grand-chose, on utilisera donc la méthode difficile, qui consiste à créer des structures de données et des méthodes personnalisées pour les utiliser.

Le framework Interview de Qt se charge du support du paradigme modèle-vue. Il ne gère pas de base la gestion des données distantes. On peut utiliser des solutions basiques, comme les modèles de QtSql, mais ces méthodes ne sont pas les plus efficaces.

Quand Qt était toujours un produit de Nokia, une équipe de développement de Brisbane, en Australie, a eu l'idée de faciliter l'incorporation de contenu 3D dans les applications Qt. Ces événements ont eu lieu en même temps que le développement du langage QML, il était donc naturel que Qt 3D ait une API QML, en plus d'une interface plus traditionnelle en C++, comme les autres modules de Qt.

Le module Qt 3D est flexible ainsi qu'extensible. Cet article explique comment ajouter des éléments à Qt 3D pour implémenter des fonctionnalités supplémentaires dans vos applications graphiques.

Le module QGL de Qt facilite l'intégration de rendu OpenGL dans des applications Qt. Dans cet article, on va montrer comment créer un QGLContext personnalisé qui implémente des fonctionnalités spécifiques non proposées par QGL. On présentera également un exemple simple d'application multiplateforme et multithread avec Qt et OpenGL.

Ce tutoriel fournit une présentation de la bibliothèque GLC_lib, puis un exemple de programmation d'une application de visualisation 3D OpenGL utilisant GLC_lib.

L'utilisation des frame buffer objects peut accélérer le rendu de QPainter. Toutefois, Qt 5 ne le permet pas directement. Giuseppe D'angelo nous explique comment utiliser QPainter pour dessiner sur un frame buffer object.

Le jeu est une activité humaine universellement partagée, et le jeu vidéo a changé la donne depuis l'arrivée de la 3D dans l'expression graphique et scénaristique. Depuis l'avènement du Web et des tablettes, il connaît une expansion d'autant plus grande. Les types de jeux produits sont très variés, et leur quantité ne cesse de s'accroître exponentiellement.

Différents tutoriels sur Blender : de l'installation aux techniques de modélisation.

Vous avez souvent entendu parler de Blender, et peut-être avez-vous déjà utilisé cet outil de modélisation gratuit et Open Source pour modéliser votre appartement ? Saviez-vous que Blender possède un moteur de jeu intégré très performant et permettant de réaliser de A à Z des jeux 3D complets fonctionnant sous Windows, Mac et Linux ? Dans cet article, nous vous proposons un petit tour d'horizon du Blender Game Engine (BGE) et de ses fonctionnalités.

Blender est à l'origine un logiciel libre de dessin 3D, mais propose de plus en plus de fonctionnalités avancées d'animation. En particulier, Blender intègre un moteur de jeux appelé Blender Game Engine (BGE), qui permet aux utilisateurs d'écrire leurs propres shaders en utilisant les langages Python et OpenGL Shading Language (GLSL).
Dans cet article, l'auteur présente les bases pour écrire ses propres shaders et les paramétrer dans Blender à partir d'un exemple simple : un filtre de flou.

Existant depuis plus de cinq décennies, mais essentiellement ancré dans l'industrie, le prototypage a évolué vers la technologie de l'impression 3D. Elle se voit de plus en plus vulgarisée avec l'apparition d'imprimantes 3D libres de source sur le marché. Il est donc effectivement possible de se procurer les plans d'une imprimante sous licence libre dans le but de la reproduire ou de s'en inspirer pour en faire un modèle personnalisé.

Traduction du manuel de référence de VPython, une bibliothèque permettant de construire des scènes 3D simplement et rapidement à partir d'éléments basiques (cubes, cônes, pyramides, sphères...). Présentation des objets basiques et contrôles à insérer dans une scène 3D, du contrôle de la caméra, de la gestion du clavier et de la souris... La version originale anglaiseversion originale anglaise est également disponible.

Cette série de tutoriels vous présente comment développer de A à Z un moteur 3D en C++ de manière propre et portable.

Cet article présente dans les grandes lignes le langage PureBasic qui, malgré sa faible renommée, a tout d'un grand. Nous allons vous aider à mieux le connaitre, et à l'apprécier au cours de nos différents articles.

Cet article a pour but de vous faire une introduction sur la bibliothèque de visualisation de données scientifiques VTK. Il vous présentera mon point de vue sur cette dernière, ses avantages et inconvénients ainsi que ses performances.

Présentation du langage POV-Ray, qui permet de décrire, de générer et de visualiser des scènes 3D.

Actuellement il n'existe aucune API pour faire de la 3D dans le JDK officiel. Cependant il existe plusieurs projets qui comblent ce manque. Certains projets sont développés par Sun eux-mêmes.

Cet article datant de 2003 explore en détail une technique de rendu maintenant très répandue dans les jeux vidéo et autres logiciels 3D : le rendu différé.

Le nouveau DOOM est un plus parfait pour la franchise. Il utilise le nouveau moteur id Tech 6, pour lequel Tiago Sousa, un ex-membre de Crytek a assumé le rôle de programmeur rendu principal après le départ de John Carmack.

Les tout premiers First Person Shooters, comme DOOM, Wolfenstein 3D, et autres jeux des années 1990 avaient un rendu relativement simpliste et anguleux.

Vous en avez marre du fond noir de votre application 3D. Il est grand temps de changer. Cet article vous explique comment ajouter un peu de vie à votre scène avec l'ajout d'une skybox

Ce tutoriel présente et explique la technique de précalcul d'illumination nommée ambient occlusion.

SIGGRAPH 2008 a été l'occasion de découvrir de nouvelles technologies et de nouvelles techniques sur l'infographie. Vous pourrez trouver une partie des présentations sur le site de NVidia : http://developer.nvidia.com/object/siggraph-2008.html. Vous trouverez ici les traductions françaises de certaines de ces présentations.

Cette série propose, à travers 6 tutoriels, d'étudier les techniques d'éclairage dynamique. Au menu : éclairage par vertex, par pixel, lightmapping, DOT3 bump mapping, utilisation de shaders, parallax mapping.

Cet article va présenter la triangulation de Delaunay, mais aussi plusieurs techniques pour générer des terrains aléatoirement. La triangulation de Delaunay permet d'avoir, à partir d'un certain nombre de points, une bonne triangulation.

Comment créer un raytracer ? Comment le rendre utilisable en temps réel pour une application 3D ? Telles sont les questions auxquelles cette série de tutoriels tentera de répondre.

Étape par étape, réalisez un raytracer (pas si) minimaliste en haskell. Un raytracer est un programme capable de rendre des scènes 3D assez fidèles sur le principe du lancer de rayon : pour chaque pixel de l'image produite, on lance un (ou des) rayon qui parcourt à rebours le trajet d'un rayon lumineux, jusqu'à atteindre l'objet qui l'a émis.

xoofx nous explique le fonctionnement de ces techniques de rendu à la mode que sont le raymarching et les distance fields. Découvrez les quelques secrets à l'origine des démonstrations sur 4 096 octets.

Récemment, la technique de raymarching, une amélioration de la technique de lancer de rayon est devenue populaire. Sa force est sa simplicité, permettant de l'exécuter sur le GPU.

Présentation du langage POV-Ray, qui permet de décrire, de générer et de visualiser des scènes 3D.