Commentaires de livres
Assembleurs
- Assembleur x86
- Programmation Graphique C/C++ Assembleur
C/C++
- Pour mieux développer avec C++
- Le C++ Efficace
- Data Structures for Game Programmers
- Programmer en langage C++
- Langage C
Software Design
- Design Patterns
- UML 2.0
- The pragmatic programmer
Direct X
Programmation de Jeux
- Game Programmming Golden Rules
- More OpenGL Game Programmming
- OpenGL Game Programming
Programmation Graphique
- More OpenGL Game Programmming
- Game programming gems
- Focus On 3D Terrain Programming
Programmation GPU
- More OpenGL Game Programmming
- OpenGL Shading Language
Mathématique et Physique
- Mathematics for 3D Game Programming and Computer Graphics
- 3D Math primer for Graphics and Game Development
Net
- PHP 5
- MySQL et PHP
OpenGL
- More OpenGL Game Programmming
- Game programming gems
- OpenGL Shading Language
- Focus On 3D Terrain Programming
- The OpenGL Extensions Guide
- OpenGL Game Programming
- OpenGL 1.2
XML
- XSLT : Développement en XML et HTML
- XML in a nutshell
Game Programmming Golden Rules par Martin Brownlow

2004
Anglais
up | 05/02/2006 - Game Programmming Golden Rules

Ce livre est basé sur 9 règles dont les énoncés sont applicable au développement de jeu.

La première règle est "Trust the compiler ... but not too mush". Il s'agit de comprendre certains mots clés du C++ tels que volatile, const, static, register, new et enfin de rappeler les bienfaits du preprocesseur.

la deuxième règle est "Divide and Conquer". Ce chapitre traite de la recherche dans des arbres dont l'arbre BSP avec gestion des collisions d'objets.

La troisième règle est "Trust your First Impressions" ce qui est associé aux structures de données hashés tels que la Hash List, la HashTable et le Hash Tree. Ce chapitre est illustré par une utilisation avec un Vertex Shader.

La quatrième règle est "Script is Worth a Thousand Lines of Code". Il s'agit ici de créer un language de script avec son interpréteur C++.

La cinquième règle est "Always use the right tool for the job". L'idée est de traiter de la gestion des données avec notamment l'utilisation d'archives de fichiers.

La sixième règle est "Don't use a Square Peg for a Round Hole". Ce chapitre regroupe des suggestions pour le traitement des textures, des font et des meshes dans les jeux.

La septième règle est "Exploit Your data". Cette règle est basée sur les Finite State Machines et propose d'utiliser cette technique au travers du scripting.

La huitième règle est "Save Early, Save Often". Elle aborde le sujet rarement évoqué de la sauvegarde dans les jeux.

La neuxième règle est "Mesure Twice, Cut Once" et se concacre à l'optimisation de codes par la mesure.

Game Programmming Golden Rules est un livre très intéressant qui peut nous aider à créer des jeux data-driven.

Le sommaire :
- 1. Embracing C++
- 2. Orders of Complexity
- 3. Hashes and Hash Functions
- 4. Scripting
- 5. The Ressource Pipeline
- 6. Processing Asserts
- 7. Finite State Machin
- 8. Saving Game State
- 9. Optimisation
More OpenGL Game Programmming par Dave Astle

2005
Anglais
up | 05/02/2006 - More OpenGL Game Programmming

More OpenGL Game Programming est un livre dans la lignée de OpenGL Game Programming, pourtant bien que ce dernier m'avais particulièrement déçu, More OpenGL Game Programming me parait totalement indispensable car il s'agit ici d'un livre de pragrammation graphique avancé.

Les quatres premiers chapitres sont directement dédiés à présenter de nouvelles possibilités introduitent par OpenGL, tel que les Vertex et Pixel Buffer Objects, le Framebuffer Object, les floating points buffer ou encore l'occlusion query. Ils présentent également la programmation GPU sous OpenGL avec les low level programs et l'OpenGL Shading Language. Si vous pensez que les low level programs sont aujourd'hui obsolètes, je pense vous avez plutôt raison cependant il est toujours possible de récupérer les shaders des jeux sous cette forme. Il peut donc être intéressant de connaitre les low level shaders pour étudier des shaders existant.

Pour le reste du livre, OpenGL est utilisé uniquement comme support aux techniques graphiques explicités dans ce livre.

Le chapitre 5 explique tout ce qu'il y a à connaitre actuellement sur le bump mapping tel que l'embross bump mapping, le normal mappping, le parallax mapping avec ou sans self shadows et plus encore. le chapitre 6 offrent un festival de connaissances tout aussi important mais sur le sujet de l'éclairage : BRDFs, Microfacet, Oren-Nayar, Cook-Torrance, Ashikhmin. Les jours de Phong sont comptés :p. Enfin nous y retrouvons des sujets en voir de développement comme les deferred shaders et l'High Dynamic Range (HDR). Le chapitre 7 sur les effets spéciaux traitent des moteurs de particules, des ombres (Shadow Volume et Shadow Mapping) mais aussi de la réflection et réflaction.

Les chapitres 8 à 10 sont dédiés au rendu en extérieur ce qui inclut le rendu d'eau, du ciel et de la terre. S'en suit un chapitre dédié à l'animation skeletale de modèles et enfin chapitre sur le management de scènes, ce qui inclut le frustum culling et des algorithms dédiés à cet effet: BSP, Portal, Quadtree, Octree.

En conclusion avec ce livre nous avons tous les outils utils pour créer un rendu de jeu et même un bon rendu. Il s'agit à mon sens du meilleur livre dans le genre, un livre pour programmeur graphique avancé uniquement.

Le sommaire :
- Chapter 1. More OpenGL
- Chapter 2. Introduction to Shaders
- Chapter 3. Low-level Shaders
- Chapter 4. The OpenGL Shading Language
- Chapter 5. Advanced Texture Mapping
- Chapter 6. Advanced Lighting and Shading
- Chapter 7. Special Effects
- Chapter 8. Rendering Nature
- Chapter 9. Rendering Skies
- Chapter 10. Terrain
- Chapter 11. 3D Models and Skeletal Animation
- Chapter 12. Scene Management
- Appendix A. Low-Level Shading Languages Reference
- Appendix B. OpenGL Shading Language Reference
Assembleur x86 par Kip Irvine

2003
Français
up | 20/04/2004 - Assembleur x86

Réinventer la route est quelques choses de très agréable pour beaucoup de programmeurs. Pourquoi ? Simplement l'envis de tout faire et de tout comprendre de A à Z. Voici un défit à la hauteur des programmeurs les plus chevronnés et l'assembleur est un bon langage pour atteindre le sommet de cet art.

Comme son nom l'indique, "Assembleur x86" est un livre destiné à l'architechture des CPUs x86. Ainsi, ce livre explique l'architecture IA-32 c'est-à-dire la gestion de la mémoire, les entrées sorties, ces composants, etc. Ce livre s'ouvre à plusieurs environnements : Le BIOS, MS-DOS et Win32. On regrettera particulièrement l'absence d'UNIX.

En effet, tous les exemples sont réalisés avec le même outil : MASM, l'assembleur de Microsoft. Ils font admettre qu'il est particulièrement bien documenté, ce qui constitue un très bon point ici car en assembleur pas d'IDE (Il y en à bien quelques uns en réalité). Le compilateur et le linker sont utilisées en ligne de commande. Ainsi, nous avons le doit à une explication de la démarche à suivre pour utiliser MASM, comment compiler les exemples et enfin une référence de MASM.

Concernant directement l'assembleur x86, ce livre nous propose une description complète des mots clés bien souvent épaulée d'exemples d'utilisation. Il y a également des détails sur la création et l'utilisation des fonctions, les tableaux, les structures de données et les accès aux disques.

Pour toutes les personnes souhaitant apprendre l'assembleur, ce livre viendra leur apporté l'aide qu'il recherche et leurs permettra d'atteindre un bon niveau.

Le sommaire :
- Introduction
- Chapitre 1. Concepts fondamentaux
- Chapitre 2. Architecture IA-32
- Chapitre 3. Principes du langage assembleur
- Chapitre 4. Transferts de données, adressage et arithmétique
- Chapitre 5. Procédures
- Chapitre 6. Traitements conditionnels
- Chapitre 7. Arithmétique des entiers
- Chapitre 8. Procédures (niveau 2)
- Chapitre 9. Chaînes et tableaux
- Chapitre 10. Structures de données et macros
- Chapitre 11. Programmation Windows 32 bits
- Chapitre 12. Interface avec les langages de haut niveau
- Chapitre 13. Programmation MS-DOS 16 bits
- Chapitre 14. Concept de base des disques
- Chapitre 15. Programmation au niveau BIOS
- Chapitre 16. Programmation MS-DOS pour les experts
- Annexe A. Installation et utilisation de MASM
- Annexe B. Le jeu d'instructions Intel
- Annexe C. Interruptions BIOS et MS-DOS
- Annexe D. Référence de MASM
- Annexe E. Réponses aux questions des révisions de sections
- Index
Programmation Graphique C/C++ Assembleur par Michael Abrash

2000
Français
up | 22/04/2004 - Programmation Graphique C/C++ Assembleur

Si le livre saint des chrétiens est la Bible et celui des Musulmans est la Coran, alors Programmation Graphique C/C++ Assembleur est très certainement le livre saint des programmeurs.

Ce livre est en fait la réunion de tous les livres et articles publiés par Michael Abrash. Le titre indique que trois langages sont utilisés : le C, le C++ et l'Assembleur (x86). Cependant, il y a très peu de C et de C++ ... c'est un livre d'Assembleur x86 !

Ce livre est organisé en deux parties, la première concernant l'optimisation de code (au niveau du processeur) et la seconde sur la programmation graphique (au niveau de la vidéo). Même si vous n'êtes pas une star de l'Assembleur, ce livre propose de nombreux concepts et algorithme fondamentaux pour optimiser son code et pour les applications graphiques.

Il faut admettre que certains points peuvent paraître un peu vieux : Description des processeurs 286, 386, 486 et Pentium et rien de plus récent. Pour la partie graphique, une grande partie du livre se concentre sur le mode VGA avec accès à la mémoire vidéo. Cependant, apprendre ces concepts n'est pas une perte de temps car dernière nos bibliothèques préférés le fonctionnement est toujours celui-ci.

Notez également qu'une grande partie du livre décrit des concepts de Quake et Quake 2 telle que les arbres BSP, le clipping 3D, la détermination des surfaces visibles, le mipmappping, etc.

Enfin, il faut remarquez la lecture très agréable du livre dans lequel Michael Abrash fait preuve de beaucoup d'humour ainsi chaque chapitre commence par une introduction ne parlant absolument pas de programmation mais dont la chute montre l'intérêt du chapitre.

Le sommaire :
- 1 La meilleure des optimisations s'effectue entre vos oreilles
- 2 Un mode à part
- 3 Ne présumez de rien
- 4 Dans l'antre des mangeurs de cycles
- 5 Traverser la frontière
- 6 Examiner les valeurs
- 7 Optimisation locale
- 8 Accélérer le C avec le langage Assembleur
- 9 Lecteurs, faites-moi signe !
- 10 Coder patiemmement, coder plus vite
- 11 Pousser les 286 et 386
- 12 Pousser le 486 à ses limites
- 13 Cibler le 486
- 14 L'algorithme de recherche de chaîne Boyer-Moore
- 15 Listes chainées et autre défis
- 16 Aucun code n'est le plus rapide
- 17 Le jeu de la vie
- 18 La vie est belle
- 19 Pentium : ce n'est pas la même chanson
- 20 Les règles du Pentium
- 21 Utiliser le pipeline V du Pentium
- 22 Le Zen et l'esprit souple
- 23 Os et tendons
- 24 Traitement en parallèle avec le VGA
- 25 Les mécanisme du VGA
- 26 Le mode 3 Write du VGA
- 27 Encore un nouveau mode Write du VGA
- 28 Lire en mémoire VGA
- 29 Sauvegardes d'écran et autres mystèmes du VGA
- 30 Video est omnis divisa
- 31 Haute résolution en 256 couleurs sur VGA
- 32 A résoudre : 360x480
- 33 Yogi et Eurythmics confrontés aux couleurs VGA
- 34 Changer les couleurs sans écrire de pixels
- 35 Bresenham est rapide, et la rapidité est bonne
- 36 Le bon, le mauvais et les traitements segmentés
- 37 Chats morts et lignes d'éclairs
- 38 La genèse du polygone
- 39 Polygones convexes rapides
- 40 Chansons, impôts et simplicité des polygones complexes
- 41 Le blues des nomenclatures de polygones
- 42 Frit ou selon Wu ?
- 43 Animation par plans de bits
- 44 La division d'écran au secours de la permutation de pages
- 45 Poils de chien et recouvrement de rectangle
- 46 Qui est ce Sprite ?
- 47 Mode X : Toute la magie du VGA 256 couleurs
- 48 Le mode X et les latches
- 49 Animation en mode X et en 256 couleurs
- 50 Ajouter une dimention
- 51 Espadrilles dans l'espace
- 52 Lorsque l'animation 3D rapide rencontre XSharp
- 53 Vitesse pure
- 54 Les sources de lumière 3D
- 55 Un modèle d'illumination en 256 couleurs
- 56 L'ourson et la station spatiale
- 57 Afficher 10 000 moutons fraîchement tondus
- 58 Boule de cristal d'Heinlein, Cerveau de Spock et défi des 9 cycles
- 59 L'Id des arbres BSP
- 60 Compiler des arbres BSP
- 61 Systèmes de référence
- 62 Une histoire, deux règles et un moteur de rendu BSP
- 63 Savoir mettre les mathématiques traditionnelles au panier
- 64 Détermination des surfaces visibles de Quake
- 65 Clipping 3D et autres considérations
- 66 La suppresstion des surfaces cachées de Quake
- 67 Les segments raster en action
- 68 Le modèle d'illumination de Quake
- 69 Le cache de surface et modèle de triangle de Quake
- 70 Quake : Une conclusion et une prospective
Pour mieux développer avec C++ par Aurélien Géron
Fatmé Tawbi

1999
Français
up | 28/02/2005 - Pour mieux développer avec C++

Ce livre sur le langage C++ est à destination des programmeurs initiés. Il est composé de trois parties principales.

La première est consacrée aux mécanismes virtuels du C++, ce qui inclut le polymorphisme sous ses trois composantes : l'encapsulation, l'abstraction et l'héritage. Ce livre explique concrètement le fonctionnement de ces mécanismes en C++ ainsi que les conséquences qu'ils impliquent que ce soit par leurs forces ou leurs faiblesses. Un autre chapitre très intéressant évoque un thème pour le moins anodin et pourtant riche en piège : les conversions de types ! Les problèmes de ce type de manipulation sont évoqués dans une perspective de robustesse. Les auteurs en profitent pour discuter des avantages des nouveaux casts telle que static_cast et de la RTTI. L'une des choses agréables dans ce livre c'est que les mauvaises solutions sont autant évoquées que les bonnes. Par exemple, les auteurs évoquent const_cast et mutable sans concision puis propose une meilleure alternative avec l'utilisation de "const" comme qualificateur de fonctions. Enfin, cette partie évoque l'héritage multiple et la notion "d'interface" d'inspiration JAVA (Le terme 'interface' n'existe pas véritablement en C++, c'est une classe ne contenant que des fonctions virtuelles pures).

La seconde partie est consacrée à la bibliothèque standard du C++ : la STL. Elle aborde donc les conteneurs qu'ils soient séquentiels (list, vector, deque) ou associatifs (map, multimap, set, multiset) et les mécanismes de manipulation comme les itérateurs et les modèles internes sur lesquels la STL repose : Le conteneur - Iterateur et la Stratégie. Nous regretterons cependant que les cotés "cause/conséquence" ou "force/faiblesse" de la première partie ne soit pas aussi développé que dans la première partie ... Heureusement, le dernier chapitre dédié aux "smart pointers" reprend ces concepts avec brio. En fait, ce chapitre commence avec la problématique de gestion de la mémoire puis part dans la construction d'une solution avec le lecteur, la réponse étant le smart pointer. Le tout en précisant les limites de cette technique.

La troisième et dernière partie concerne les design patterns et pour mon plus grand bonheur, leur présentation est basée sur des diagrammes de classes UML. Ce livre est loin de faire le tour de tous les design patterns (mais est ce possible ?), il se contente des modèles les plus utiles : Le Composite; La fabrication; La Fabrique Abstraite; Le Singleton; L'Observateur et le Médiateur. La présentation des différents patterns est globalement toujours identiques : Qu'elle est l'objet du pattern, son rôle; Comment remplit t'il sa tâche; Comment le programmer; qu'elles sont ses avantages et ses inconvénients. Notons également que les patterns sont illustrés par des exemples.

En bref, un excellent livre qui a au minimum l'intérêt de nous apprendre que si l'on nous vend une solution comme miraculeuse, c'est il y a anguille sous roche.

Le sommaire :
- Chapitre 1 - Les mécanismes du polymorphisme
- Chapitre 2 - Le patron de méthode
- Chapitre 3 - La RTTI et les nouveaux casts
- Chapitre 4 - Héritage multiple et héritage virtuel
- Chapitre 5 - Les classes d'interface
- Chapitre 6 - Conteneurs et itérateurs de la STL
- Chapitre 7 - Le modèle stratégie
- Chapitre 8 - Adapter l'interface d'une classe
- Chapitre 9 - les smart pointers
- Chapitre 10 - Le Composite
- Chapitre 11 - La Fabrication (Factory Method)
- Chapitre 12 - La Fabrique Abstraite (Abstract Factory)
- Chapitre 13 - Le Singleton
- Chapitre 14 - L'observateur (Observer)
- Chapitre 15 - Le Médiateur (Médiator)
- A. Fiches techniques
- B. Bibliographie
- C. Sites web
- Index
Le C++ Efficace par Scott Meyers

2001
Français
up | 12/02/2005 - Le C++ Efficace

Ce livre n'est autre que la traduction française de Effective C++. Bien que ce livre est été publié en 2001 en français il a réellement vue le jour en 1994. Malgré son age, il n'a rien perdu de son intérêt.

En effet, après avoir lue des livres tel que Programmer en langage C++ de Claude Delannoy nous sommes en mesure de dire que l'on connaît le langage C++ pourtant ce n'est pas pour autant que l'on sait l'utiliser.

Ce livre est une sorte de collection de "gems" sur le C++, 50 exactement. Scott Meyers nous explique les bonnes et mauvaises pratiques du langage C++. Sa démarche n'est pas de proposer des vérités mais surtout de favoriser la réflexion du lecteur sur des thèmes pour lui permettre de prendre des décisions ou des choix. Il ne s'agit pas d'aller dans les méandres de la technicité du C++ mais vraiment de discuter des problèmes concrets.

Cerise sur le gâteau, ce livre est très agréable à livre grâce à une organisation proche des "livres jeux" avec des références à d'autres "gems" du livres. Il est également véritablement bien écrit et l'auteur est loin d'être dénué d'humour dans sa rédaction. Je pense que la plus part des livres sont fait pour être consulté comme référence mais celui ci est d'une telle richesse et tellement agréable à lire que le vous conseille vivement de le lire en entier en suivant les références à d'autres parties suivants votre humeur.

A mon avis, un livre indispensable pour un programmeur C++.

Le sommaire :
- 1 Utilisez const et inline au lieu de #define
- 2 Préférez iostream.h à stdio.h
- 3 Utilisez new et delete plutôt que malloc et free
- 4 Préférez les commentaires de style C++
- 5 Utilisez la même forme pour les appels correspondants à new et delete
- 6 Appelez delete sur les membres pointeurs dans les destructeurs
- 7 Vérifiez la valeur retour de new
- 8 Conformez-vous aux conventions pour écrire new
- 9 Evitez de masquer l'opérateur global new
- 10 Ecrivez delete dès que vous écrivez new
- 11 Définissez un constructeur de copie et un opérateur d'affectation pour les classes à mémoire allouée dynamiquement
- 12 Préférez l'initialisation à l'affectation dans les constructeurs
- 13 Rangez les membres de la liste d'initialisation dans l'ordre de leur déclaration
- 14 Déclarez les destructeurs virtuels dans les classes de base
- 15 Faites en sorte que l'opérator= retourne une référence à *this
- 16 Dans l'opérator=, affectez des valeurs à tous les membres
- 17 Vérifiez les auto-affectations dans l'operator=
- 18 Efforcez vous de faire des interfaces de classes complètes et minimales
- 19 Différenciez les méthodes, les fonctions globales et les fonctions amies(friend)
- 20 Evitez les données membres dans l'interface publique
- 21 Utilisez const autant que possible
- 22 Passez et retournez les objets par référence plutôt que par valeur
- 23 N'essayer pas de renvoyer une référence quand vous devez renvoyer un objet
- 24 Choissiez bien entre surcharge de fonctions et le paramétrage par défaut
- 25 Evitez la surcharge entre un pointeur et un type numérique
- 26 Méfiez-vous de l'ambiguïté potentielle
- 27 Interdisez explicitement l'utilisation de méthodes indésirables générées implicitement
- 28 Utilisez les structures pour cloisonner l'espace global des noms
- 29 Evitez de renvoyer des "poignées" révélant des données internes depuis des méthodes const
- 30 Evitez les méthodes quirenvoient des pointeurs ou des références à des membres moins accessibles qu'elles mêmes
- 31 Ne renvoyez jamais une références à un objet local ni un pointeur déréférencé initialisé par new dans une fonction
- 32 Utilisez les enums pour des constantes de classe entières
- 33 Utilisez inline judicieusement
- 34 Minimisez les dépendances de compilation entre fichiers
- 35 Assuez-vous que l'héritage public modélise le "est-un"
- 36 Différenciez l'héritage d'interface de l'héritage d'implémentation
- 37 Ne redéfinissez jamais une méthode non virtuelle héritée
- 38 Ne redéfinissez jamais une valeur de paramètre par défaut héritée
- 39 Evitez la conversion de type descendant la hiérarchie d'héritage
- 40 Modélisez "a-un" ou "est-implémenté-en-termes-de" avec le layering (modèle en couches)
- 41 Utilisez judicieusement l'héritage privé
- 42 Faites la différence entre héritage et templates
- 43 Utilisez judicieusement l'héritage multiple
- 44 Dites ce que vous voulez dire ; comprenez ce que vous dites
- 45 Sachez quelles méthodes le C++ écrit et appelle en silence
- 46 Préférez des erreurs de compilation et d'édition de liens à des erreurs d'exécution
- 47 Assuez-vous que les objets globaux sont initialisés avant d'être utilisés
- 48 Soyez attentif aux avertissements du compilateur
- 49 Prévoyez les avancées futures du langage
- 50 Lisez l'ARM
Data Structures for Game Programmers par Ron Penton

2002
Anglais
up | 16/05/2004 - Data Structures for Game Programmers

Data Structures for Game Programmers est un livre organisé en six parties de plusieurs chapitres chacunes.

La première partie présente d'une part la notion de complexité d'un algorithme et d'autre part la notion de template. La deusième partie aborde des structures de données : Tableaux, Bitvectors, listes chaînées, piles, queues et tables de hachage. La troisième partie présente les arbres avec notamment un chapitre sur l'algorithme Minimax, très utile en recherche opération pour par exemple réalisé une IA. Ces notions sont d'ailleurs approfondi dans la partie quatre qui traite des graphes. La partie suivante est batisé 'Algorithms' et elle aborde les problèmes de tries (bubble, heap, quick, radix), de compression de données (RLE, Huffman), de nombres alléatoires, etc. La dernière partie est un ensemble d'annexe sur le C++ (Math, I/O, Exceptions, surcharge d'opérateurs, etc.), la mémoire, SDL et STL.

Ce livre contient un CD contenant tous les exemples du livre. Ces exemples ont pour but de données un apperçu visuel du fonctionnement de certaines notions. Par exemple, pour la pile, il y a un programme utilisant SDL comprenant deux boutons dont les actions sont : empiler et dépiler. L'utilisation de SDL garantie des programmes potentiellements portables, mais ils ne sont disponibles que pour Windows et on été réalisé avec Visual C++ 6.

N'oublions pas que ce livre est destiné aux programmeurs de jeux, ce livre nous propose de développer un jeu de rôles/aventures à la fin des parties deux à cinq.

Le sommaire :
- Chapter 1 : Basic Algorithm Analysis
- Chapter 2 : Templates
- Chapter 3 : Arrays
- Chapter 4 : Bitvectors
- Chapter 5 : Multi-Dimensional Arrays
- Chapter 6 : Linked Lists
- Chapter 7 : Stacks and Queues
- Chapter 8 : Hash Tables
- Chapter 9 : Tying it together : The Basics
- Chapter 10 : Recursion
- Chapter 11 : Trees
- Chapter 12 : Binary Trees
- Chapter 13 : Binary Trees
- Chapter 14 : Binary Search Trees
- Chapter 15 : Priority Queues And Heaps
- Chapter 16 : Game Trees Ans Minimax Trees
- Chapter 17 : Tying it Together : Trees
- Chapter 18 : Using Graphs for IA : Finite State Machines
- Chapter 19 : Graphs
- Chapter 20 : Sorting Data
- Chapter 21 : Data Compression
- Chapter 22 : Random Numbers
- Chapter 23 : Pathfinding
- Chapter 24 : Tying it together : Algorithms
- Appendix A : A C++ Primer
- Appendix B : The memory layout of a computer program
- Appendix C : Introduction to SDL
- Appendix D : Intriduction to the Standard Template Library
Programmer en langage C++ par Claude Delannoy

2002
Français
up | 16/05/2004 - Programmer en langage C++

Programmer en langage C++ est un livre basé et respectant la norme ISO C++. On retrouve naturellement toutes les notions du langage C++ : Types, fonctions, surcharges, patrons, héritage, flots, exceptions, etc. Ce livre aborde aussi tous les conteneurs de la STL de la norme C++ : list, vector, degue, map, multimap, set, multiset, bitset, valarray et présente également les algorithmes.

Ce livre offre également une comparaison avec le langage C au niveau de la compatibilité et aborde d'autres point critique comme les conversions de type définies par l'utilisateur et les fonctions amies.

Le sommaire :
- Chapitre 1 : Généralités concernant C++
- Chapitre 2 : Les incompatibilités entre C++ et C
- Chapitre 3 : Les entrées-sorties conversationnelles du C++
- Chapitre 4 : Les spécificités du C++
- Chapitre 5 : Classes et objets
- Chapitre 6 : Les propriétés des fonctiones membres
- Chapitre 7 : Construction, destruction et initialisation des objets
- Chapitre 8 : Les fonctions amies
- Chapitre 9 : La surdéfinition d'opérateurs
- Chapitre 10 : Les conversions de type définis par d'utilisateur
- Chapitre 11 : Les patrons de fonctions
- Chapitre 12 : Les patrons de classes
- Chapitre 13 : L'héritage simple
- Chapitre 14 : L'héritage multiple
- Chapitre 15 : Les fonctions virtuelles et le typage dynamique
- Chapitre 16 : Les flots
- Chapitre 17 : La gestion des exceptions
- Chapitre 18 : Généralités sur la bibliothèque standard
- Chapitre 19 : Les conteneurs séquentiels
- Chapitre 20 : Les conteneurs associatifs
- Chapitre 21 : Les algorithmes standard
- Chapitre 22 : La classe string
- Chapitre 23 : les outils numériques
- Chapitre 24 : les espaces de noms
- Annexe A : Mise en correspondance d'arguments
- Annexe B : Les incompatibilités entre C et C++
- Annexe C : Compléments sur les exceptions
- Annexe D : Les différentes sortes de fonctions en C++
- Annexe E : Comptage de références
- Annexe F : Les pointeurs sur des membres
- Annexe G : Les algorithmes standard
- Correction des exercices
- Index
- Contenu du site Web
Langage C par Claude Delannoy

2002
Français
up | 15/05/2004 - Langage C

Voici un livre sur le langage C. Il n'a rien de particuliers, ne dispose pas de CD, n'utilise pas une pédagogie spécial, l'auteur de raconte pas sa vie, non rien de toute cela. Il s'agit seulement d'un classique livre de programmation sur le langage C, mais parmi les nombreux livres sur le langage C, il se distingue pas un point très important : c'est un bon livre !

En effet, ce livre est dédié de le langage C et il ne s'agit ni d'un langage C dédié à un compilateur ni d'une variante du langage C, non il s'agit d'une description belle et bien du langage C de la norme ANSI C99 avec une description complète, de A à Z, ni plus ni moins.

Ainsi, ce livre décrit tous les fondements du langage C : types de base, opérateurs, expressions, structures de contrôles, tableaux, pointeurs, fonctions, etc. Ce livre présente également les fonctions standard, c'est à dire leurs utilisations et leurs déclarations. De plus, il présente la création de type personnalisé par le biais de structures, d'unions, d'énumérations ainsi que la gestion de la mémoire dynamique et aborde en profondeur la gestion des fichiers. Parmi les autres notions misent en valeur dans ce livre nous noterons les arguments variables, la communication avec l'environnement, les caractères étendus. Bien entendu le pré processeur n'a pas été oublié.

Enfin nous noterons deux parties particulièrement intéressantes. La première concernant les compatibilités entre le C et le C++ et la seconde étant l'annexe. En effet celui si indique dans quel fichier doit t'on trouver les déclarations de chaque élément du langage ce qui est à la fois très pratique et facilité l'écriture de code portable.

Le sommaire :
- Chapitre 1 - Généralités
- Chapitre 2 - Les éléments constitutifs d'un programme source
- Chapitre 3 - Les types de base
- Chapitre 4 - Les opérations et les expressions
- Chapitre 5 - Les instructions exécutables
- Chapitre 6 - Les tableaux
- Chapitre 7 - Les pointeurs
- Chapitre 8 - Les fonctions
- Chapitre 9 - Les entrées-sorties standard
- Chapitre 10 - Les chaînes de caractères
- Chapitre 11 - Les types strutures, union et énumération
- Chapitre 12 - La définition de synonymes avec typedef
- Chapitre 13 - Les fichiers
- Chapitre 14 - La gestion dynamique
- Chapitre 15 - Le préprocesseur
- Chapitre 16 - Les déclarations
- Chapitre 17 - Fiabilisation des lectures au clavier
- Chapitre 18 - Les catégories de caractères et les fonctions associées
- Chapitre 19 - Gestion des gros programmes
- Chapitre 20 - Les arguments variables
- Chapitre 21 - Communication avec l'environnement
- Chapitre 22 - Les caractères étendus
- Chapitre 23 - Les adaptations locales
- Chapitre 24 - La récursivité
- Chapitre 25 - Les branchements non locaux
- Chapitre 26 - Les incompatibilités entre le C et C++
- Annexe - la bibilothèque standard
Design Patterns par Erich Gamma
Richard Helm
Ralph Johnson
John Vlissides

1999
Français
up | 14/09/2004 - Design Patterns

Ce livre est composé de deux parties : La première décrit ce que sont les desing patterns et comment ils peuvent apportés une aide dans une approche orienté objet. La deuxième partie, qui compose la majorité du livre, contient pas moins de vingt trois patterns.

Ce livre contient des exemples en code C++ et Smalltack (plus rare) et les patterns sont décrient à l'aide de diagrammes de classes UML.

Notons la présence d'un CD, vendu avec le livre, qui contient le texte du livre en version original sous une forme HTML très aggréable.

Le sommaire :
- Chapitre 1 Introduction
- Chapitre 2 Etude de cas : conception d'un éditeur de documents
- Chapitre 3 Modèles créateurs
- - Fabrique abstraite
- - Monteur
- - Fabrication
- - Prototype
- - Singleton
- Chapitre 4 Modèles structuraux
- - Adaptateur
- - Pont
- - Composite
- - Decorateur
- - Facade
- - Poids mouche
- - Procuration
- Chapitre 5 Modèles de comportement
- - Chaine de responsabilités
- - Commande
- - Interpreteur
- - Iterateur
- - Mediateur
- - Mememto
- - Observateur
- - Etat
- - Stratégie
- - Patron de methode
- - Visiteur
- Chapitre 6 Conclusion
- Annexe A Glossaire
- Annexe B Guide de notation
- Annexe C Classes Fondations
- Bibliographie
UML 2.0 par Martin Fowler

2004
Français
up | 14/09/2004 - UML 2.0

Ce livre est une présentation d'UML. L'auteur commence par décrire le rôle d'UML puis il discute de son rôle dans un processus de développement. Nous avons enfin une description plus ou moins détaillé de chacun des diagrammes de classes d'UML.

L'un des principaux plus, de ce livre, est certainement que l'auteur nous offre son opinion car le monde d'UML n'est pas blanc ou noir mais plutôt gris. C'est donc un excélent livre pour se forger son opinion sur UML.

Ce livre est une traduction de la version originale anglaise nommé UML Distilled.

Le sommaire :
- Chapitre 1. Introduction
- Chapitre 2. Processus de développement
- Chapitre 3. Diagrammes de classes : concepts essentiels
- Chapitre 4. Les diagrammes de séquence
- Chapitre 5. Diagrammes de classes : concepts avancés
- Chapitre 6. Diagrammes d'objets
- Chapitre 7. Diagrammes de packages
- Chapitre 8. Diagrammes de déploiement
- Chapitre 9. Cas d'utilisation
- Chapitre 10. Diagrammes de machines d'états
- Chapitre 11. Diagrammes d'activités
- Chapitre 12. Diagrammes de comunication
- Chapitre 13. Structures composites
- Chapitre 14. Diagrammes de composants
- Chapitre 15. Collaborations
- Chapitre 16. Les diagrammes de vue d'ensemble des interactions
- Chapitre 17. Diagrammes de timing
- Annexe A. Conventions de notation
- Annexe B. Différences entre versions d'UML
- Annexe C. Bibliographie
- Index
The pragmatic programmer par Andrew Hunt
David Thomas

2003
Anglais
up | 14/09/2004 - The pragmatic programmer

The pramatic programmer propose un grand nombre de concept pour nous aider à mieux concevoir, mieux programmer, mieux gérer un projet. Comme son nom l'indique, ce livre expose des résultats produits par la pratique. Il n'y a pas de concepts novateurs et pourtant ce livre pourrait bien révolutionner notre vision du développement grâce à des outils et méthodes nous permettant de tendre vers une qualité supérieure.

Quels concepts sont abordés ? La communication, le design par contrat, Le refactoring, le debugging, les générateurs de code, etc. En tout, quarante six idées nous permettant d'allez au bout de nos projets. Certain concepts sont difficilement appréciable cependant l'essentiel est, à mon avis, la dynamique de réflexions que ce livre induit.

Le sommaire :
- 1. The cat ate my source code
- 2. Software entropy
- 3. Stone soup and boiled frogs
- 4. Good-Enough Software
- 5. Your knowledge Portfolio
- 6. Comunicate!
- 7. The evils of duplication
- 8. Orthogonality
- 9. Reversibility
- 10. Tracer bullets
- 11. Prototypes and post-it notes
- 12. Domain languages
- 13. Estimating
- 14. The power of plain text
- 15. Shell Games
- 16. Power editing
- 17. Source code control
- 18. Debugging
- 19. Text manipulation
- 20. Code generators
- 21. Design by contract
- 22. Dead Programs Tell no lies
- 23. Assertive programming
- 24. When to use exceptions
- 25. How to balance ressources
- 26. Decoupling and law of demeter
- 27. Metaprogramming
- 28. Temporal Coupling
- 29. It's just a view
- 30. Blackboards
- 31. Programming by coincidence
- 32. Algorithm speed
- 33. Refactoring
- 34. Code that's easy to test
- 35. Evil wizards
- 36. The requirements pit
- 37. Solving impossible puzzles
- 38. Not until you're ready
- 39. The specification trap
- 40. Circles ans arrows
- 41. Pragmatic teams
- 42. Ubiquitous automation
- 43. Ruthless testing
- 44. It's all writing
- 45. Great expectations
- 46. Pride and prejudice
Mathematics for 3D Game Programming and Computer Graphics par Eric Langyel

2004
Anglais
up | 13/09/2004 - Mathematics for 3D Game Programming and Computer Graphics

En parcourant les pages de ce livres, nous observons tout de suites que l'approche des Maths pour la 3D choisi pour ce livre est très scolaire. Nous retrouvons des propriétés, des formules, des théorèmes, des démonstrations ... bref de quoi faire fuir un bon nombre de personnes.

Notons que chaque chapitre se termine par un résumer des principaux résultats obtenus dans le chapitre puis par des exercices donc les quelques réponses sont données à la fin du livre. Aussi scolaire, soit t'il, ce livre en particulièrement bien fait dans cette approche.

En terme de notions abordées, nous avons bien entendu le droit à une partie sur les espaces vertoriels mais elle est limitée au chapitre 1 à 4. Il y a de nombreux chapitres qui abordé d'un point de vue mathématique des notions de rendus 3D : La camera, les stencils shadows, les courbes de beziers et B-Splines, etc. Remarquons également la présence de trois chapitres de physiques traitant des mouvements de translations et de rotations d'un solide et abordant la simulation de fluïde.

Ce livre est principalement destiné aux personnes ayant de bonnes connaissances mathématiques et aux étudiants de seconds cycles disposant de notions en programmation et en infographie, c'est à dire connaissant le C++ et le langage de shader de bas niveau d'OpenGL ...

Le sommaire :
- Chapter 0 The Rendering Pipeline
- Chapter 1 Vectors
- Chapter 2 Matrices
- Chapter 3 Transforms
- Chapter 4 3D Engine Geometry
- Chapter 5 Ray Tracing
- Chapter 6 Illumination
- Chapter 7 Visibility Determination
- Chapter 8 Collision Detection
- Chapter 9 Polygonal Techniques
- Chapter 10 Shadows
- Chapter 11 Linear Physics
- Chapter 12 Rotational Physics
- Chapter 13 Fuild Simulation
- Chapter 14 Numerical Methods
- Chapter 15 Curves and surfaces
- Appendix A Complex Numbers
- Appendix B Trigonometry Reference
- Appendix C Coordinate Systems
- Appendix D Taylor Series
- Appendix E Answers to Exercises
3D Math primer for Graphics and Game Development par Fletcher Dunn
Ian Parberry

2002
Anglais
up | 02/03/2004 - 3D Math primer for Graphics and Game Development

Tout d'abord je tiens à signaler que ce livre est vraiment à la porté de tous, que vous soyez bon ou pas. En effet, il abord des sujets depuis la base, ce qui est une très bonne chose pour charifier le sujet.

Si de nombreux concepts paretront déjà connu par nombre de personnes, il y à des notions fondammenles qui sont clarifié. Par exemple, quel est la différence entre "Position" et "Displacement"(Déplacement est français). La reponse parait évidente (mais faut t'il déjà ce la posé) mais elle ne l'ai pas tant que ça. En fait c'est exactement la même différence qu'entre point et vecteur. Concretement identique mais matématiquement différent.

Ce livre dégage quelques comparaisons. Par exemple, quel est le point est commun entre les angles, les matrices et les quaternions ? Ce sont tous des méthodes permettant de réaliser des transformations. Ce livre indique les points forts et les points faibles de chaque méthode.

La fin du livre traite de sujet plus délicat comme les collisions, les meshes, l'éclairage et les testes de visibilités.

Le sommaire :
- Chapter 1 Introduction
- Chapter 2 The Cartesian Coordinate System
- Chapter 3 Multiple Coorinate Spaces
- Chapter 4 Vectors
- Chapter 5 Operations on Vectors
- Chapter 6 A Simple 3D Vector Class
- Chapter 7 Introduction to Matrices
- Chapter 8 Matrices ans Linear Transformations
- Chapter 9 More on matrices
- Chapter 10 Orientation and Angular Displacement in 3D
- Chapter 11 Transformations in C++
- Chapter 12 Geometric Primitives
- Chapter 13 Geometric Tests
- Chapter 14 Triangle Meshes
- Chapter 15 3D Math for Graphics
- Chapter 16 Visibility Determination
- Chapter 17 Afterword
- Appendix A Math Review
- Appendix B References
Game programming gems par Mark Deloura

2000
Anglais
up | 15/09/2004 - Game programming gems

Ce livre est le premier ouvrage d'une série dont le cinquième volume est prévu pour mars 2005. C'est une sorte de recueille de trucs et astuces pour la programmation de jeux, réalisé par une trentaine de contributeurs.

Les articles sont organisés dans cinq parties : Programming techniques, Mathematics, Artificial intelligence, polygonal techniques et pixel effects.

Dans la partie Programming techniques sont abordées la notion de design pattern, de fonctionnalité du C++ ou encore des techniques pour le chargement de données et la gestion de mémoires.

Dans la partie mathematics nous trouvons notamment un chapitre sur les méthodes d'interpolations, sur le mouvement mais aussi plusieurs chapitres qui font le tour des quaternions.

La partie concernant l'IA parcours principalement l'algorithme A* en proposant plusieurs optimisations.

Ce livre comprend deux parties dédiées à l'affichage OpenGL, la première nommée polygonal techniques offre des articles orientés géométries avec notamment plusieurs chapitres que le rendu de terrain et la deuxième partie nommée pixel effects traitant d'avantage des textures, des ombres, du bump mapping, etc.

Le sommaire :
- Chapter 1. Review of OpenGL Basics
- Chapter 2. Basics
- Chapter 3. Language Definition
- Chapter 4. The OpenGL Programmable Pipeline
- Chapter 5. Built-in Functions
- Chapter 6. Simple Shading Example
- Chapter 7. OpenGL Shading Language API
- Chapter 8. Shader Development
- Chapter 9. Traditional Shaders
- Chapter 10. Stored Texture Shaders
- Chapter 11. Procedural Texture Shaders
- Chapter 12. Noise
- Chapter 13. Animated Shaders
- Chapter 14. Antialiasing Procedural Textures
- Chapter 15. Non-Photorealistic Shaders
- Chapter 16. Shaders for Imaging
- Chapter 17. Language Comparison
- Appendix A. Language Grammar
- Appendix B. API Function Reference
- Afterword
- Glossary
- Further Reading
- Index
OpenGL Shading Language par Randi J.Rost
John M. Kessenich
Barthold Lichtenbelt

2004
Anglais
up | 23/04/2004 - OpenGL Shading Language

Sortie en fécrier 2004, ce livre est le premier à traiter de l'OpenGL Shading Language et il ne parle que de ce langage mis à part le premier chapitre. On ne voit donc presque aucun code C appelant des fonctions OpenGL et si vous n'avez que de faible connaissance d'OpenGL, passez votre chemin !

En terme d'organisation et de contenue, ce livre est plus proche d'un livre sur le langage C qu'un livre sur OpenGL. En effet, il s'agit bien de décrire un langage et non une bibliothèque.

Ainsi, ce livre présente une vue l'ensemble du langage en commençant par décrire les types supportés par le langage, la conversion de types, les qualificatifs (ex const en C++), les branchements dynamiques (if, while, etc.) et le pré-processeur. Bien entendu, il y a également une description de toute les fonctions intégrer au langage, à la manière de la bibliothèque standard du langage C.

Il y a également une partie beaucoup plus conceptuelle, qui se charge de décrire le processus de rendu d'une scène OpenGL ainsi que ce que son réellement les Pixel et Vertex Programs et ce qu'ils peuvent réaliser et afin un comparatif avec d'autres langages de shaders : ISL, HLSL et Cg.

L'une des particularités de ce livre réside sur une grande partie dédiée à la pratique. Ainsi, il y a un chapitre qui traite du développement des shaders, les problèmes de performance, de debbugage mais également des outils comme RenderMonkey, l'IDE d'ATI. Toujours dans la partie pratique, il est bon de notez que 187 pages sur les 543 pages qui compose ce livre sont dédiées à la présentation de technique de rendu au travers d'exemples de shaders.

Vous l'aurez compris, j'ai été particulièrement séduit par cet Orange Book mais je vous avoue que la difficulté de ce livre me paru d'un niveau relevé.

Le sommaire :
- Chapter 1. Review of OpenGL Basics
- Chapter 2. Basics
- Chapter 3. Language Definition
- Chapter 4. The OpenGL Programmable Pipeline
- Chapter 5. Built-in Functions
- Chapter 6. Simple Shading Example
- Chapter 7. OpenGL Shading Language API
- Chapter 8. Shader Development
- Chapter 9. Traditional Shaders
- Chapter 10. Stored Texture Shaders
- Chapter 11. Procedural Texture Shaders
- Chapter 12. Noise
- Chapter 13. Animated Shaders
- Chapter 14. Antialiasing Procedural Textures
- Chapter 15. Non-Photorealistic Shaders
- Chapter 16. Shaders for Imaging
- Chapter 17. Language Comparison
- Appendix A. Language Grammar
- Appendix B. API Function Reference
- Afterword
- Glossary
- Further Reading
- Index
Focus On 3D Terrain Programming par Trent Polack

2002
Anglais
up | 02/03/2004 - Focus On 3D Terrain Programming

Un excellent livre sur le rendu de terrain et l'utilisation de CLOD (Continous Level Of Detail), pour l'optimisation du rendu.

Ainsi dans une première partie, l'auteur décrit l'affichage de terrain : Mesh, Texture et éclairage. La technique d'éclairage utilisé est une lightmap de type colormap, c'est-à-dire que pour chaque vertex du mesh est associé une couleur provenant d'un pixel d'une texture.

La deuxième partie du livre est beaucoup plus ardu car concerne notamment 3 algorithmes nommés Geomipmapping, QuadTree et ROAM.

La mise en ouvre de chacun des algorithmes est réalisée progressivement afin de simplifier la compréhension.

L'une des puissances de ce livre réside dans la parfaite coxistence entre la partie théorique et la partie pratique. La pédagogie de ce livre consiste par commencer par la théorie puis une phase de pratique et un exemple. Ensuite le processus boucle et parfois plusieurs fois par chapitre. Les exemples sont réalisés avec OpenGL sous Windows.

Si le sujet vous intéresse, achetez le, d'autant plus que son coup est raisonnable (30$).

Le sommaire :
- Part One : Introduction to Terrain Programming
- Chapter 1 : The Journey into the Great Outdoors
- Chapter 2 : Terrain 101
- Chapter 3 : Texture Terrain
- Chapter 4 : Lighting Terrain
- Part Two : Advanced Terrain Programming
- Chapter 5 : Geomipmapping for CLOD impaired
- Chapter 6 : Climbing the Quadtree
- Chapter 7 : Wherever you may ROAM
- Chapter 8 : Wrapping it up : Special Effects and more
- Appendix What's on the CD
- Index
The OpenGL Extensions Guide par Eric Lengyel

2003
Anglais
up | 15/05/2004 - The OpenGL Extensions Guide

Ce livre présente 78 d'extensions OpenGL, qu'elles soient officielles ou propriétaires. Les extensions sont regroupés par chapitre avec des indications sur les dépendences avec d'autres extensions, la version d'OpenGL où elles ont été propu.

Ce livre est très formel, pas d'exemples, ce qui le dirige directement vers les programmeurs OpenGL averti. Cette stratégie à l'avantage de permettre la description de A à Z des extensions évoquées.

A noter, que les 2 dernières chapitres sont destinés aux Pixel et Vertex Shaders bas niveau et bien qu'il ne soit que 2 chapitres sur 18, ils représentent près de la moitié du livre car il détaille pour chacune des extensions GL_ARB_vertex_program, GL_NV_vertex_program, GL_NV_vertex_program1_1, GL_NV_vertex_program2, GL_ ARB_vertex_program1_1, GL_ARB_fragment_program, et GL_NV_fragment_program, chaque instruction des langages de shaders utilisés par chaque extension.

Ce livre se présente comme le blue book. En conséquence, si vous êtes allergique au blue book, passez votre chemin sinon foncez.

A noter enfin, qu'une partie du livre est maintenant dépassée, malgré sa date de parution récente. En effet, ce livre est consacré à OpenGL 1.4, hors avec l'arrivé d'OpenGL 1.5 le chapitre 8 "Array Management" est maintenant représenté par l'extension GL_ARB_vertex_buffer_object. De plus, l'utilisation de langage de shader de nVidia n'est plus utilise car l'amélioration des drivers de nVidia à permis de gommer les écarts de performance avec le langage officiel.

Le sommaire :
- Chapter 1 : About OpenGL Extensions
- Chapter 2 : Blending
- Chapter 3 : Texture Environment
- Chapter 4 : Texture Mapping
- Chapter 5 : Texture Compression
- Chapter 6 : Fragment Shading
- Chapter 7 : Vertex Blending
- Chapter 8 : Array Management
- Chapter 9 : Synchronization
- Chapter 10 : Lighting
- Chapter 11 : Fog
- Chapter 12 : Stencil Operations
- Chapter 13 : Shadow Mapping
- Chapter 14 : Occlusion Culling
- Chapter 15 : Point Rendering
- Chapter 16 : Pixel Formats
- Chapter 17 : Miscellaneous
- Chapter 18 : Vertex Programs
- Chapter 19 : Fragment Programs
- Appendix A : Program Syntax Specifications
- Appendix B : Extension Index
- Appendix C : Function Index
OpenGL Game Programming par Kevin Hawkins
Dave Astle

2001
Anglais
up | 02/03/2004 - OpenGL Game Programming

Ce livre est dédié à la programmation OpenGL sous Windows. Ainsi il se base sur Direct X pour les entrées, le son et le fenêtrage. Ce n'est pas un livre sur OpenGL vous dites vous ? Effectivement, ce n'est pas uniquement un livre sur OpenGL mais également sur la programmation de jeu. Il comprend également un chapitre sur la théorie de la 3D.

Une grande partie du livre est consacré au base d'OpenGL : Transformations; Couleurs; Transparence, Eclairage, Texture, Display list, etc. On trouve vraiment beaucoup de concepts mais le contenu n'est pas très approfondit car particulièrement orienté vers la pratique.

Dans cet esprit de pratique le livre décrit comment chargé une image BMP et TGA. De plus à la fin du livre le format MD2 de Quake 2 est décrit : Chargement du mesh, texture et animation.

Le sommaire :
- Part I : Introduction to OpenGL and DirectX
- Chapitre 1 : The Exploration Begins : OpenGL and Direct X
- Chapitre 2 : Using Windws with OpenGL
- Chapitre 3 : An Overview of 3D Graphics Theory
- Part II : Using OpenGL
- Chapter 4 : OpenGL States and Primitives
- Chapter 5 : Coordinates Transformations and OpenGL Matrices
- Chapter 6 : Adding Colors, Blending and Lighting
- Chapter 7 : Bitmaps and Images with OpenGL
- Chapter 8 : Texture Mapping
- Chapter 9 : Advanced Texture Mapping
- Chapter 10 : Display Lists and Vertex Arrays
- Chapter 11 : Displaying Text
- Chapter 12 : OpenGL Buffers
- Chapter 13 : OpenGL Quadrics
- Chapter 14 : Curves and Surfaces
- Chapter 15 : Special Effects
- Part III : Building a Game
- Chapter 16 : Using DirectX : DirectInput
- Chapter 17 : Using DirectX Audio
- Chapter 18 : Working with 3D Models
- Chapter 19 : Physics Modeling with OpenGL
- Chapter 20 : Building a Game Engine
- Chapter 21 : Making a Game : A Time to Kill
- Part IV : Appendixes
- Annexe A : Online Resources
- Annexe B : Using the CD / Index
OpenGL 1.2 par Mason Woo
Jackie Neider
Tom Davis
Dave Shreiner

2000
Français
up | 02/03/2004 - OpenGL 1.2

Ce livre n'est autre que le fameux Red Book traduit est français.

Il est à la fois pratique et théorique car dispose de nombreux exemples et fait la par belle à la théorie : Mathématique de l'éclairage, calcule de normales, processus de restitution d'OpenGL, etc.

Son champ d'étude va des bases au multitexturing en passant par la visualisation ou encore l'éclairage. De plus, une bonne partie du livre est consacrée à GLU, bibliothèque qui simplifie la tache dans bien des exemples pour se concentrer sur le sujet.

On regrettera l'age déjà avancé du livre (1999 pour la version originale) ce qui implique une découverte d'OpenGL limité à la version 1.2 . et encore ! De même, les exemples utilisent la bibliothèque GLUT, abandonnée depuis 2001.

Malgré tout, ce livre demeure une référence pour se lancer dans OpenGL, car sont contenu est toujours d'actualité, d'autant plus que c'est un rare dès rare livre en Français sur OpenGL .

Le sommaire :
- A propos de ce livre
- Chapitre 1 : Introduction à OpenGL
- Chapitre 2 : Gestion des états et dessin géométrique
- Chapitre 3 : Visualisation
- Chapitre 4 : Couleur
- Chapitre 5 : Eclairage
- Chapitre 6 : Blending,Lissage, fog et décalage de polygone
- Chapitre 7 : Listes d'affichage
- Chapitre 8 : Dessiner des pixels, des bitmaps, des polices et des images
- Chapitre 9 : Application de texture
- Chapitre 10 : Tampon d'image
- Chapitre 11 : Fragmenteurs et quadriques
- Chapitre 12 : Evaluateurs et NURBS
- Chapitre 13 : Mode sélection et mode feedback
- Chapitre 14 : Et maintenant ...
- Annexe A : Ordre des opérations
- Annexe B : Variables d'état
- Annexe C : OpenGL et les gestionnaires de fenêtres
- Annexe D : Base du GLUT : l'Utility Toolkit d'OpenGL
- Annexe E : Calcul de verteurs normaux
- Annexe F : Coordonnées homogènes et matrices de transformation
- Annexe G : Astuces de programmation
- Annexe H : Invariance OpenGL
- Glossaire
- Index
PHP 5 par Leon Atkinson

2004
Français
up | 14/09/2004 - PHP 5

PHP 5 est un livre de référence. Son rôle est d'expliquer le langage, la syntaxe, le fonctionnement du langage. Une grosse partie de ce livre est un annuaire de fonctions classées par catégories.

Comme beaucoup de livres intitulés se revendiquant basé sur la version 5 de PHP, ce titre est d'avantage flatteur qu'un réalité. En effet, si la partie concernant le langage PHP lui-même est effectivement une description de la version 5, l'annuaire de fonction correspond d'avantage à celui de la version 4. De plus, l'auteur c'est basé sur une version non finale de PHP pour la rédaction de ce livre. Il est donc possible de certains bugs apparaissent.

Ce livre est pourtant de bonne qualité et vrai agréable à lire grâce notamment aux exemples d'utilisation des fonctions dans l'annuaire de fonctions. Pourtant, si ce livre vous intéresse, je ne serait trop vous conseillez de patienter jusqu'à la sortie de la 4ème édition qui j'espère sera totalement tournée vers PHP 5 et comprendra une partie sur XML, totalement absente dans cette édition.

Le sommaire :
- Chapitre 1. Présentation de PHP
- Chapitre 2. Variables, opérateurs et expressions
- Chapitre 3. Instructions de contrôle
- Chapitre 4. Fonctions
- Chapitre 5. Tableaux
- Chapitre 6. Classes et objets
- Chapitre 7. Entrées/sorties et accès disque
- Chapitre 8. Entrées/sorties navigateur
- Chapitre 9. Fonctions fichiers
- Chapitre 10. Fonctions d'entrées/sorties réseau
- Chapitre 11. Fonctions de traitement de données
- Chapitre 12. Traitement des chaînes
- Chapitre 13. Fonctions mathématiques
- Chapitre 14. Fonctions de temps et de date
- Chapitre 15. Fonctions relatives aux images
- Chapitre 16. Fonctions de base de données
- Chapitre 17. Interfaçage avec des couches objet
- Chapitre 18. Fonctions diverses
- Chapitre 19. Tri, recherche et nombres aléatoires
- Chapitre 20. Analyse et évaluation des chaînes de caractères
- Chapitre 21. Intégration des bases de données
- Chapitre 22. Interactions avec le réseau
- Chapitre 23. Générer des images
- Chapitre 24. Intégration de PHP et de HTML
- Chapitre 25. Conception d'une application Web
- Chapitre 26. Efficacité et débogage
- Index des fonctions
- Index
MySQL et PHP par Philippe Rigaux

2003
Français
up | 14/09/2004 - MySQL et PHP

Ce livre est un n-ème volume sur l'un des sujets les plus exploités de la littérature informatique : MySQL et PHP. En quoi se différencie t'il de la concurrence ? Par son approche pratique. Nous trouvons ainsi de nombreux codes SQL et PHP commenté mais aussi HTML et CSS.

L'objectif de ce livre n'ai pas d'apprendre le langage SQL et encore moins le langage PHP mais d'apprendre à s'en servir pour obtenir un résultat flatteur qui soit robuste et évolutif. Ici, on fait de la programmation de qualité !

Malgré une parution récente ce livre commence à ce faire vieux. En effet, il s'appuie sur PHP4, certains points seront alors dépassés si vous utilisez PHP5 mais l'intérêt de ce livre réside avant tout sur la conception.

A la fin de ce livre nous trouvons une référence PHP et surtout une très bonne référence SQL qui n'est pas parfaitement complet mais qui satisfera pour la réalisation de la majorité des sites web.

Le sommaire :
- Chapitre 1. Introduction
- Chapitre 2. Programmation Web
- Chapitre 3. Environnement MySQL/PHP
- Chapitre 4. Techniques de base
- Chapitre 5. Création d'une MySQL
- Chapitre 6. Développement d'utilitaires
- Chapitre 7. Production du site
- Chapitre 8. XML
- Chapitre 9. Graphiques
- Chapitre 10. Récapitulatifs SQL
- Chapitre 11. Récapitulatif PHP
- Chapitre 12. Administration de MySQL
- Annexe A. Installation Apache/PHP/MySQL
- Annexe B. Référence MySQL
- Annexe C. Fonctions PHP
- Index
XSLT : Développement en XML et HTML par Khun Yee Fung

2001
Français
up | 15/05/2004 - XSLT : Développement en XML et HTML

Voici bien une livre qui m'aurai vraiment aidé à réaliser G-Truc Creation depuis ça version 3 car il est dédié à ce type d'application. En effet, ce livre vous propose une application très courante : Transformer des documents XML en document HTML à l'aide de XSLT.

Vous n'êtes pas obligé de connaître XML pour vous lancer dans la lecture de ce livre car il offre une bonne introduction au langage en évoquant les concepts principaux : Intérêt de XML, différence entre XML et HTML, URI, document bien formé, validité, espace de nom, terminologie, arbre, etc. Si vous connaissez déjà XML, vous constaterez que la présentation de XML est vraiment complète. Pourtant, elle ne tient que sur trois chapitres. Personnellement j'ai trouvé cette "introduction" bien plus intéressante que le contenu de certains livres dédiés exclusivement à XML : Concis, complet et pertinent.

Ce livre traite également de HTML. Utilisant principalement HTML 3.2, il vous faudra connaître ce langage de présentation. On pourra regretter que l'auteur n'ai pas opté pour XHTML qui est bien plus d'actualité cependant le livre date de 2001. Effectivement, il n'y a guère plus d'une petite page sur XHTML ...

Mise à part ce faux pas, qui n'est pas vraiment important, le reste de ce livre tend vers la perfection. Le chapitre 5, baptisé "Chemins d'accès", traite de XPath. Les explications sont particulièrement convaincantes et illustrés. Ce choix de l'illustration est véritablement une excellente idée car il rend la compréhension de XPath simple en dépit de sa réputation.

Concernant la partie essentielle du livre, XSLT, le chapitre 3 offre une introduction qui met en oeuvre la transformation d'un document de base et offre une critique sur les différentes méthodes permettant d'obtenir une même résultat de base. Il y a bien entendu des chapitres beaucoup plus évolués sur la transformation avec notamment le principe de template, l'utilisation de structure de contrôle, le paramétrage pour une sortie HTML, etc. Notons également le chapitre 11 qui est une sorte de chapitre "trucs et astuces", vraiment très utile. De plus, le chapitre 12 est un exemple de développement qui présente en plus du coté pratique une véritable démarche pour la réalisation de projets. Enfin le chapitre 13 donne une ouverture vers la transformation de document XML en document XML, XHTML, SVG (dessin vectoriel) ou encore texte ainsi qu'une présentation de XSL-FO (Présentation de donnée telle que HTML).

Le livre se termine finalement par une référence, expliquant le fonctionnement de bon nombre d'éléments XSLT et XPath.

Je tiens enfin à notez la grande rigueur de l'auteur au niveau du vocabulaire XML. En effet, bien que cette partie soit souvent oubliée dans de nombreux livres sur ce sujet c'est un point fondamental qui permet de comprendre les messages d'erreurs retournés par les parseurs et permet tout simplement une bonne communication entre programmeurs.

Finalement, je qualifiais la partie sur XML de concis, complète et pertinente, je pense que se sont les maîtres mots sur lesquels l'auteur c'est basé pour écrire ce livre. Bref, si vous recherchez un livre sur XSLT pour réaliser des transformations de fichiers XML en fichiers (X)HTML, c'est le livre qu'il vous faut !

Le sommaire :
- Chapitre 1. Introduction
- Chapitre 2. XML
- Chapitre 3. Introduction au XSLT
- Chapitre 4. L'arbre d'un document XML
- Chapitre 5. Chemins d'accès
- Chapitre 6. Transformations
- Chapitre 7. Contrôle
- Chapitre 8. Construire l'arbre final
- Chapitre 9. Combinaison de modèles
- Chapitre 10. Extensions
- Chapitre 11. Expressions usuelles
- Chapitre 12. Transformation en XML et en texte
- Annexe A. Outils et ressources
- Annexe B. Jeux de caractères et schémas de codage
- Annexe C. XSLT et XPath
- Index
XML in a nutshell par Elliotte Rusty Harold
W. Scott Means

2002
Français
up | 25/04/2004 - XML in a nutshell

Ce livre est un excellent résumé des langages XML. De nombreux langages liés à XML du W3C sont présent : XHTML (HTML au format XML), XSLT (le langage de transformation de document XML en n'importe quel langage), XPath (le langage de parcours d'arbre XML), XLink (le langage pour attacher des liens aux documents XML), XPointer (le langage de localisation des points ou des régions dans les documents XML), CSS (le langage de formatage de données), XSL-FO (Langage décrivant la mise en page d'un document XML), XML Schema (Le langage de description de document XML).

Les fichiers XML n'auraient un grand intérêt sans les méthodes de traitement qui lui son associée. Logiquement, on retrouve une description complète de la méthode DOM (Avantage, inconvénient, structure, plusieurs interfaces) et la méthode SAX.

On notera également que ce livre comprend bon nombre de tables unicodes, qui s'avèrent très utilise car les caractères sont indiquées sous forme d'entité XHTML, en hexadécimal et en décimal.

Si vous souhaitez découvrir XML et ces technologies affiliées, ce livre vous offrira un bon départ !

Le sommaire :
- Chapitre 1 - Introduction à XML
- Chapitre 2 - Principes de XML
- Chapitre 3 - Définition de Type de Document
- Chapitre 4 - Espaces de noms
- Chapitre 5 - Internationnalisation
- Chapitre 6 - XML comme format de documents
- Chapitre 7 - XML sur le Web
- Chapitre 8 - XSLT
- Chapitre 9 - XPath
- Chapitre 10 - XLink
- Chapitre 11 - XPointers
- Chapitre 12 - CSS
- Chapitre 13 - XSL-FO
- Chapitre 14 - RDDL
- Chapitre 15 - XML comme format de données
- Chapitre 16 - Schémas XML
- Chapitre 17 - Modèles de programmation
- Chapitre 18 - DOM
- Chapitre 19 - SAX
- Chapitre 20 - Référence de XML 1.0
- Chapitre 21 - Référence des schémas
- Chapitre 22 - Référence de XPath
- Chapitre 23 - Référence de XSLT
- Chapitre 24 - Référence de DOM
- Chapitre 25 - Référence de SAX
- Chapitre 26 - Jeux de caractères
- Index
Copyright © 2002-2006 G-Truc Creation tous droits réservés