Multiparadigme


[Initiation Python] www.multiparadigme.org, menu: [Vidéos de cours d'informatique] [Vidéos de cours de maths] [Parlons musique] [Retour à l'entrée du site] [Cours particuliers] [Images calculées]


Cette page présente la liste des cours vidéo de programmation informatique publiés sur Youtube par Jacques-Olivier Lapeyre. L'accès à ces vidéos est libre et gratuit. Le code source de cette page web a lui-même été écrit à l'occasion du tournage d'une vidéo de cours (la vidéo numéro 20 de l'Unité 1).




Version la plus récente de Cfuns

Vous pouvez télécharger ici la dernière version publiée des modules Cfuns.
Il s'agit de la version du 20 septembre 2016.

Cfuns est un ensemble d'outils très généraux pour la programmation, sous forme de modules écrits en langage C. On y trouve avant tout différents types de containers (tableaux redimensionnables, hash tables, graphes, etc) ainsi que des petites fonctions "utilitaires" (comme tools_malloc et tools_free) ou des fonctions mathématiques (comme celles permettant de manipuler des nombres rationnels ou des triangles 2D).
Les versions initiales de ces modules ont été programmées dans le cadre de la réalisation des premières versions des Unités 1 et 2, mais beaucoup d'améliorations et d'ajouts ont été faits depuis.




Fastris, étape 2 (pas encore jouable)


Ma participation au WE-JV6 en août 2016

  1. Intégrale partie 1 : Welcome to the chat
  2. Intégrale partie 2 : j'aime pas faire les graphismes !
  3. Intégrale partie 3 : faut souffrir
  4. Intégrale partie 4 : premiers affichages et déplacements
  5. Intégrale partie 5 : on tire et on ramasse-miettes
  6. Intégrale partie 6 : cela devient jouable
  7. Intégrale partie 7 : création et programmation d'une map
  8. Intégrale partie 8 : création du nuage de bubble gum
  9. Intégrale partie 9 : modification du comportement des nuages
  10. Intégrale partie 10 : le pillon, monstre pétrifié
  11. Intégrale partie 11 : derniers réglages
  12. Retour sur une game jam réussie
  13. On explique le code (cours de l'Unité 5)

Cours hors série sur les algorithmes de compression

  1. Algorithmes de compression : introduction.
  2. Compression : algorithme de Huffman, partie 1.
  3. Compression : algorithme de Huffman, partie 2.
  4. Compression : algorithme de Huffman, partie 3.

Unité 6 > Image numérique (titre non définitif)

  1. Pixels, couleurs, modèle RGB.
  2. Adresse d'un pixel. Fonction spécifique.
  3. Exemple de code générique et performant.
  4. Comment créer un sous-type de pixmap ?, [sources].
  5. Algorithmes de remplissage (non basés sur des scanlines).
  6. Le HSV : teinte, saturation, valeur.
  7. Comment dessiner des triangles ?.
  8. Le projet Square noize, partie 1.
  9. Le projet Square noize, partie 2 : calcul des textures.
  10. Le projet Square noize, partie 3 : pixels à coordonnées non entières.
  11. Inventions un format de fichier, comme ça, pour voir.
  12. TO BE CONTINUED...

Ma participation au "Week Of Awesome II"

  1. Shmup, partie 1.
  2. Shmup, partie 2 (recorded 09/22/2014)
  3. Shmup, partie 3 (recorded 09/22/2014)
  4. Shmup, partie 4 (recorded 09/23/2014)
  5. Shmup, partie 5 (recorded 09/23/2014)
  6. Shmup, partie 6 (recorded 09/24/2014)
  7. Shmup, partie 7 (recorded 09/24/2014)
  8. Shmup, partie 8 (recorded 09/25/2014)
  9. Shmup, partie 9 (recorded 09/25/2014)
  10. Shmup, partie 10 (recorded 09/26/2014)
  11. Shmup, partie 11 (recorded 09/26/2014)
  12. Shmup, partie 12 (recorded 09/27/2014)
  13. Shmup, partie 13 (recorded 09/27/2014)

Tutoriels sur les modules de Cfuns

  1. Tutoriel : le module array (tableaux), [sources tutoriel_array.zip].
  2. Tutoriel : le module dlist, [sources tutoriel_dlist.zip].
  3. Tutoriel : programmer un undo/redo illimité, [sources de Cfuns].
  4. Tutoriel : arbres binaires en C, partie 1.
  5. Tutoriel : arbres binaires en C, partie 2.
  6. Tutoriel : des tableaux modifiables bit par bit.

Unité 5 > Programmation de jeux 2D

  1. Unité 5, le défi qui rend fou.
  2. Logiciel de dessin et undo illimité.
  3. Arbres fractals et autres détails.
  4. Création d'un jeu vidéo : rendu de texte.
  5. Les premières lignes de code de mon jeu. Gestion d'erreur.
  6. Algorithmes du jeu Nullotron.
  7. Ajout d'un nouveau monstre dans Nullotron.
  8. Les champs de bits.
  9. De la programmation des shmups.
  10. Qualité du code, partie 1.
  11. Représenter l'ensemble de Mandelbrot.
  12. Quelques mesures de performances.
  13. Quand doit-on se préoccuper de l'endianness ?
  14. Pointeurs, partie 4 : de la superiorité des langages avec pointeurs.
  15. De la programmation événementielle, partie 1.
  16. Comment j'ai programmé le jeu Memiro.
  17. Modification de la représentation des maps.
  18. Comment je programme le jeu Nullotron II, partie 1.
  19. Comment je programme le jeu Nullotron II, partie 2 : représentation des sprites. [sources]
  20. Comment je programme le jeu Nullotron II, partie 3 : déroulement du temps. [sources]
  21. Comment je programme le jeu Nullotron II, partie 4 : les événements.
  22. Comment je programme le jeu Nullotron II, partie 5 : les collisions.
  23. Enregistrer des graphes et des floats.
  24. On explique le code de Full Blast.
  25. TO BE CONTINUED...

Unité 4 > Programmation orientée objet (POO)

  1. Du C au C++, partie 1.
  2. Du C au C++, partie 2.
  3. POO, partie 1 : fonctions membres.
  4. POO, partie 2 : des structs aux classes.
  5. POO, partie 3 : passage par référence ; operator_chevron_chevron.
  6. POO, partie 4 : héritage public.
  7. Les tas en C++, sources du module intarray version C++.
  8. Les templates en C++, partie 1.
  9. Des classes date, adresse et personne en C++.
  10. Entrées et std::string en C++.
  11. Les templates en C++, partie 2.
  12. Les templates en C++, partie 3 + traitement d'image, sources C++ (sauf module pixmap).
  13. Traitement d'image en C++, partie 1.
  14. Traitement d'image en C++, partie 2.
  15. Traitement d'image en C++, partie 3.
  16. Traitement d'image en C++, partie 4.
  17. Image numérique : fonctions affines et contraste.
  18. Image numérique : de mystérieux filtres....
  19. Image numérique : effets graphiques avec masques, partie 1.
  20. Image numérique : effets graphiques avec masques, partie 2.
  21. Image numérique : effets graphiques avec masques, partie 3.
  22. Image numérique : effets graphiques avec masques, partie 4 + dégradés de couleurs, sources de CPPFUNS, sources de pixmap.
  23. Initiation accidentelle et improvisée à l'analyse d'image.
  24. Fuites de mémoire et autres joies du programmeur C.
  25. Calculs de dégradés en 24 ou 32 bits, sources de CPPFUNS, sources de pixmap.
  26. Algorithme de Floyd-Steinberg.
  27. Calculs de dégradés en 48 ou 64 bits, sources de pixmap.
  28. L'application "Grand Ciel" partie 1, sources version alpha.
  29. "Grand Ciel" version graphique, partie 1, sources version beta.
  30. "Grand Ciel" version graphique, partie 2.
  31. Utilisations du logiciel "Grand Ciel".
  32. Introduction au langage Java.
  33. Une classe "Trinôme" en Java.
  34. Une classe "Polynôme" en Java.
  35. Une classe "Polynôme" en C++.
  36. Polynômes : algorithme de Horner et recherche dichotomique.
  37. Polynômes : racines et surcharge des opérateurs.
  38. Java : classe Object et comparaison avec C++.
  39. Les exceptions en C++, partie 1.
  40. Les exceptions en C++, partie 2.
  41. Les exceptions en C++, partie 3.
  42. Les exceptions en Java.
  43. Les graphes (introduction).
  44. Les graphes : définitions et parcours en largeur.
  45. Les graphes en C++ et matrices d'adjacence.
  46. Les graphes en C et parcours en profondeur.
  47. Graphes : parcours en profondeur en C.

Unité 3 > Applications graphiques et SDL

  1. Introduction à l'image numérique
  2. Affichons un rectangle
  3. Quelques structs de la SDL. Différence entre image true colour et image à palette indexée.
  4. Notre module image, les sources de SDL intro.
  5. Transparence, format TGA, exercices, sources de SDL intro.
  6. Application dust-- : comment supprimer les poussières sur une photo argentique numérisée ?
  7. Filtre médian, sources de Cfuns, sources de SDL intro.
  8. Filtre médian (suite) + un peu de SDL.
  9. Fonctionnement de dust--.
  10. Function putpixel pour SDL.
  11. Ecriture de dust--, partie 1.
  12. Ecriture de dust--, partie 2.
  13. Ecriture de dust--, partie 3, sources de Cfuns, sources de dust--.
  14. Divers : union, dictionnaire (hash table), prochain projet.
  15. Dictionnaires, partie 1.
  16. Dictionnaires, partie 2.
  17. Dictionnaires, partie 3, sources de Cfuns
  18. Dictionnaires, partie 4.
  19. Editeur de sprite, partie 1, sources de spritedit
  20. Editeur de sprite, partie 2, sources de spritedit
  21. Editeur de sprite, partie 3, sources de Cfuns, sources de spritedit.
  22. Editeur de sprite, partie 4.
  23. Editeur de sprite, partie 5, sources de Cfuns, sources de spritedit.
  24. Editeur de sprite, partie 6.
  25. Editeur de sprite, partie 7, sources de Cfuns, sources de spritedit.
  26. Editeur de sprite, partie 8.
  27. Editeur de sprite, partie 9.
  28. Informaticien et pédagogue, sources de Cfuns, sources de spritedit.
  29. Editeur de sprite, partie 10.
  30. Editeur de sprite, partie 11.
  31. Algorithme de Bresenham (pour tracer des segments) + exercices.
  32. Programmation d'un jeu vidéo, partie 1.
  33. Programmation d'un jeu vidéo, partie 2.
  34. Programmation d'un jeu vidéo, partie 3.
  35. Programmation d'un jeu vidéo, partie 4, sources de Cfuns, sources de mole_game.
  36. Programmation d'un jeu vidéo, partie 5.
  37. Programmation d'un jeu vidéo, partie 6, sources de graphics, sources de mole_game, sources de spritedit.
  38. Programmation d'un jeu vidéo, partie 7, sources de mole_game.
  39. Programmation d'un jeu vidéo, partie 8.
  40. Programmation d'un jeu vidéo, partie 9, sources de Borpion, sources de mole_game.
  41. Programmation d'un jeu vidéo, partie 10, sources de Cfuns, sources de graphics, sources de spritedit.
  42. Programmation d'un jeu vidéo, partie 11.
  43. Programmation d'un jeu vidéo, partie 12.
  44. Programmation d'un jeu vidéo, partie 13, sources de mole_game.
  45. Programmation d'un jeu vidéo, partie 14.
  46. Programmation d'un jeu vidéo, partie 15, sources de Cfuns, sources de mole_game.
  47. Programmation d'un jeu vidéo, partie 16 (cours sans parole !), sources de mole_game (VERSION FINALE).

Unité 2 > Algorithmique et structures de données

  1. Algorithmique et structures de données (intro) [Ancienne version]
  2. Langage algorithmique [Ancienne version]
  3. Calcul de a puissance b [Ancienne version]
  4. Introduction à la complexité algorithmique [Ancienne version différente]
  5. Complexité algorithmique (suite) [Ancienne version], sources
  6. Tri et complexité quadratique [Ancienne version]
  7. Tableaux à deux dimensions, partie 1 [Ancienne version], sources
  8. Tableaux à deux dimensions, partie 2 [Ancienne version], sources
  9. Tableaux à deux dimensions, partie 3 [Ancienne vesion], sources
  10. Primitives géométriques optimisées [Ancienne version différente], sources
  11. Un morpion amélioré [Ancienne version différente]
  12. Les fichiers, partie 1 [Ancienne version différente], sources de Cfuns, sources de projet_jv
  13. Les fichiers, partie 2 [Ancienne version différente], sources de Cfuns, sources de projet_jv.
  14. Les fichiers, partie 3 : on écrit notre propre module [Ancienne version différente], sources de Cfuns, sources de projet_jv.
  15. Les fichiers, partie 4 [Ancienne version différente]
  16. Les fichiers, partie 5 : gestion d'erreurs [Ancienne version différente]
  17. Le bazard qu'est la création d'un format de fichier [Ancienne version différente]
  18. Les fichiers texte ne sont pas plus simples [Ancienne version différente], sources de Cfuns.
  19. Nos premiers pas en image numérique [Ancienne version différente], sources de Cfuns.
  20. Chargement d'une image .ppm [Ancienne version différente].
  21. Cours d'algorithmique 16. Jeu de la vie, partie 5, sources de Cfuns, sources de projet jv.
  22. Cours d'algorithmique 17. Les tas. Le tri par tas., sources de Cfuns.
  23. Cours d'algorithmique 18. Les tableaux génériques. Les pointeurs de fonctions.
  24. Cours d'algorithmique 19. Jeu de la vie, partie 6
  25. Cours d'algorithmique 20. Jeu de la vie, partie 7, sources de Cfuns, sources de projet jv.
  26. Cours d'algorithmique 21. Jeu de la vie, partie 8. Saisie robuste d'entiers et de chaînes.
  27. Cours d'algorithmique 22. Jeu de la vie, partie 9.
  28. Cours d'algorithmique 23. Fonctions, partie 2 : la récursivité et la récursivité terminale.
  29. Cours d'algorithmique 24. Jeu de la vie, partie 10 (dernière partie !), sources de Cfuns, sources de jv.
  30. Cours d'algorithmique 25. Listes doublement chaînées, partie 1, sources de projet_list.
  31. Cours d'algorithmique 26. Listes doublement chaînées, partie 2, sources de projet_list, sources de Cfuns.
  32. Cours d'algorithmique 27. Listes doublement chaînées, partie 3, sources de projet_list, sources de Cfuns.
  33. Cours d'algorithmique 28. Listes doublement chaînées, partie 4 : listes et tri par tas. Fonction filter, sources de Cfuns, sources de projet_list, sources de projet_jv, VERSION FINALE.
  34. Cours d'algorithmique 29. Listes doublement chaînées, partie 5 : premier test de performance, sources de projet_list.
  35. Pointeurs, partie 3 : casts et arithmétique des pointeurs. Fonctionnement d'un memory pool.
  36. Cours d'algorithmique 30. Memory pool, partie 1, sources de projet_list.
  37. Cours d'algorithmique 31. Memory pool, partie 2, sources de projet_list.
  38. Cours d'algorithmique 32. Recherche par dichotomie, sources de Cfuns.
  39. Numération hexadécimale.
  40. Improvisation non artistique.
  41. Cours d'algorithmique 33. Piles, files et files de priorité.
  42. Cours d'algorithmique 34. Arbres, partie 1 : arbres binaires et tri par dichotomie.
  43. Cours d'algorithmique 35. Arbres, partie 2 : parcours d'arbres binaires..
  44. Petit détour par les listes simplement chaînées, sources de Cfuns.
  45. Cours d'algorithmique 36. Arbres, partie 3 : le module btree.
  46. Cours d'algorithmique 37. Arbres, partie 4 : parcours en largeur et en profondeur, sources de Cfuns.
  47. Cours d'algotithmique 38. Arbres, partie 5 : tri par dichotomie, sources de Cfuns.



Unité 1 > Le tout début

  1. Le premier cours [Ancienne version]
  2. Les chaînes de caractères, partie 1 [Ancienne version]
  3. Variables en C [Ancienne version]
  4. Le type char en langage C [Ancienne version]
  5. Le type char en langage C, partie 2 [Ancienne version]
  6. Calcul d'aires et de périmètres de rectangles [Ancienne version]
  7. Boucles, partie 1 [Ancienne version]
  8. Les pointeurs, partie 0 [Ancienne version]
  9. Les pointeurs, partie 1 [Ancienne version]
  10. Simplifications d'écriture, boucles for en C [Ancienne version]
  11. Les boucles imbriquées [Ancienne version]
  12. Tableaux en C (introduction) [Ancienne version]
  13. Installation d'Emacs et revue de code
  14. Numération binaire, partie 1
  15. Les fonctions en C [Ancienne version]
  16. Fichiers et installation de Cygwin
  17. La compilation. La gestion d'erreur. [Ancienne version]
  18. Les modules, partie 1 [Ancienne version]
  19. Allocation mémoire dynamique [Ancienne version]
  20. Initiation au langage HTML
  21. Les modules, partie 2 [Ancienne version]
  22. Les structs en C [Ancienne version]
  23. Programmer proprement, partie 1 [Ancienne version]
  24. Coder factorisé [Ancienne version]
  25. Passage par valeur [Ancienne version]
  26. Tri par sélection [Ancienne version]
  27. Programmer proprement, partie 2 [Ancienne version]
  28. Convertir une chaîne en entier [Ancienne version]
  29. Moyenne et médiane d'un tableau d'entiers [Ancienne version]
  30. Notre deuxième programme intéressant [Ancienne version]
  31. Revue de code [Ancienne version]
  32. Pointeurs de structs [Ancienne version]
  33. Tableaux de taille variable, partie 1 [Ancienne version]
  34. Tableaux de taille variable, partie 2 [Ancienne version]
  35. Jeu du pendu (version texte), partie 1 [Ancienne version : jeu du morpion]
  36. Jeu du pendu (version texte), partie 1 [Ancienne version : jeu du morpion]
  37. De vraies chaînes de caractères en C [Ancienne version]
  38. Algorithmes sur les chaînes de caractères, partie 1 , sources
  39. Algorithmes sur les chaînes de caractères, partie 2 [Ancienne version]
  40. Les pointeurs, partie 2. (pointeurs de pointeurs...) [Ancienne version]
  41. Module stringarray, partie 1 [Ancienne version]
  42. Module stringarray, partie 2 [Ancienne version]
  43. Gestion de la mémoire en C. [Ancienne version]



Contact : profmathsbdx@laposte.net