Débloquer la puissance de son ordianteur avec le c++

algorithmiec++

On va utiliser visual studio community OpenGlfordummies

https://expreg.org/amsi/C/PCCPPGL2122S2/

https://moodle.univ-paris8.fr/course/view.php?id=13265

SYNTAXE, VOCABULAIRE ET ARCHITECTURE DE PROGRAMMATION

La scène démo (demoscene) : Idée d’être en live et de montrer des programmes capables de faire des images sur la base de son.
C/C++ -> ce sont des langages compilés
Visual Studio Code 19
OpenGL 4

I / SYNTAXE C/C++

Récursivité: On considère récursive une fonction qui se rappelle
- exemple : la factorielle de n - s’écrit (n)! = 12 … *n
```
    3! = 1*2*3

    4! = **(1*2*3)***4 -> on constate que **(1*2*3) = 3!**
```

(dif. récursif) → boucle (for H in range…)
-

: donner le choix à la machine entre deux choses telle une intersection. → condition (if …) / break : branchement non conditionnel.
-

:Un octree est une structure de données de type arbre dans laquelle chaque nœud peut compter jusqu'à huit enfants. Les octrees sont le plus souvent utilisés pour partitionner un espace tridimensionnel en le subdivisant récursivement en huit octants.

Découpage du “monde” en un arbre permettant de gagner en performance car ne nécessite pas à ce que l 'on calcule tout mais seulement ce qui est nécessaire, soit ce qui est dans le champ de vision de l'individu.

Différence entre LP interprété et LP compilé :

La différence centrale entre compilé et interprété est comme suit : là où le compilateur traduit une bonne fois pour toute un code source en un fichier indépendant exécutable (donc utilisant du code machine ou du code d'assemblage), l'interprète est nécessaire à chaque lancement du programme interprété, pour traduire au fur et à mesure le code source en code machine. Cette traduction à la volée est la cause première de la lenteur des langages dits interprétés.

-Langage de programmation interprété : Souple mais lent. -Langage de programmation compilé : Un langage est dit compilé quand son implémentation exécutable requiert un compilateur. Je traduis d’un coup et je fais qqch pour la machine. Rigide et rapide.

II / Application

Installation VS :

Visual Studio > Créer un projet > Application console C++

Application du programme pour compiler le projet :

Menu :

Générer > Générer la solution / Compile

Déboguer > Exécuter sans débogage / Démarrer le débogage

-> Nouveau projet : helloWorld

= préprocesseur = langage par dessus un langage

io = input output (bibliothèque c++ pour gérer les entrées et sorties dans un terminal)

-> on le convertit en #include <stdio.h> qui correspond à du langage C. le ‘h’ correspond à header.

puis on compile.

Une bibliothèque est composée de fonctions qui a besoin d’un main. Un exécutable n’a pas de main.

Signé / non-signé = positif/négatif

Octet qui stocke entre 0 et 255

Creer un moteur de jeux

https://artboard.studio/

Les factoriel = n! = 1x2x3…xn Multiplier n x $$ 3! = 1x2x3 4! = (1x2x3)x4 $$

récursif # l’itératif

fact n
si n < 2 →1 sinon → nx fact (n-1)

Nouvelle type de donnée : octree
un esopace que l'on va couper en plusieurs plan en 8 petit plan La magie de l'octri perùet de de trier plus facilement la scèbne

Et on peut dfapre ça dd maniere recursive

Utilité -> permet de gérer plus facilement les objets dans l'univers -> mémoire

QuadTree

L'octree et le quadtree permet d'avoir une gestion du monde plus efficace du monde et de la mémoire.

struture d'un projet

Il y a des fihiers sources comme

.c
.cpp
.h

Les fichiers .h permet de d'envoyer les donnéees

Une bibliothèque c'est

Les languages # est un langage precomplilé

La structure d'une fonction

en cpp il est important d'avoir une fonctiopn maij dans un programme. Si la fonction main n'existe pas cela ne fonctionnera jamais si l'on veut faire un executable.

On est pas obligé d'utiliser le main pour executer des fonctions. Mais le main est la point de départ de notre code.

function()

les int le type préférer de l'architecture d'ordinateur

tout les type de int

int -> 32 bits (4 octets)
short -> 16 bits (2 octets)
char -> 8 bits (1 octet)

long long -> 64 bits

// il existe egalement les nombre décimale

float -> 32 bits
double -> 64 bits

Float

Comment fonctionne un floatant avec l'ordinateur :

https://fr.wikipedia.org/wiki/IEEE_754

Incrémentation

i++ ou ++i sont différent !

    int i = 0;
    while (i < 10) {
        printf("%d\n", i);
        ++i;
    }
    int j = 42, k = j++, l = j, m = ++j;
    printf("j : %d\nk: %d\n1: d\n",j,k,l,m);

Faire des comparaison de calculs

grâce au Xor il va utiliser les propriéter binaire pour comparer des valeurs :

A 
a^b

Un pointeur c'est une étiquette sur une adresse mémoire.

############# AND #############
#     A   |  B  |  A AND B
#
#     0   |  0  |     0
#     0   |  1  |     0
#     1   |  0  |     0
#     1   |  1  |     1
#
#
###############################

############# OR #############
#     A   |  B  |  A OR B
#
#     0   |  0  |     0
#     0   |  1  |     1
#     1   |  0  |     1
#     1   |  1  |     1
#
#
###############################


############# XOR #############
#     A   |  B  |  A XOR B
#
#     0   |  0  |     0
#     0   |  1  |     1
#     1   |  0  |     1
#     1   |  1  |     0
#
#
###############################


############# NOT #############
#
#     NOT 0     => 1
#     NOT 1     => 0
#
###############################

Les classes :

normal
inteface
Abstraite (obligé d'utliser les méthodes)

Les listes / tableau

Les listes en python sont très mauvaise en l’itératif

Les macros

les macros sont très utiliser pour ne pas recopier du code. Et peut être très utiles pour les macros pour les conditions.

2 règles a respecter :

proteger ses variables

#define NMIN(a, b) ((a) < (b) ? (a) : (b))

void toto(void) {
    int w = gl4dpGetWidth();
    int h = gl4dpGetHeight();
    GLuint* pixels = gl4dpGetPixels();
 
    int a;
    if (rand() % 2 == 0)
        a = ((15 > 2) < 20 ? (15 > 2) : 20); //NMIN(15 > 2, 20);
    else
        a = NMIN(20, 30);

    for (int y = 0; y < h; ++y) {
        for (int x = 0; x <a w; ++x) {
            int i = y * w + x;
            unsigned char r, g, b;
            r = rand() % 256; // valeurs comprises entre 0 et 255
            g = r;// rand() % 256;
            b = r;// rand() % 256;
            pixels[i] = RGB(r, g, b);
        }
    }
    /* décommentez la ligne suivante pour effacer l'écran en bleu foncé. */
    //gl4dpClearScreenWith(RGB(r, g, b));
    gl4dpScreenHasChanged();
    /* fonction permettant de raffraîchir l'ensemble de la fenêtre*/
    gl4dpUpdateScreen(NULL);
}

Quand ne pas utiliser une macro :

Ne pas utiliser des fonctions dans les macros cra il appelle

Class et instance, la programmation POO

Les types de méthodes :

L'héritages :

la méthode virtual permet lors de l'instanciation d'uilise la méthode

Pour créer de

Convention de nomage : Notation hongroise (ou camelCase)

Les classes commencent par Une majuscule et les instance en minuscule mais les instances en

calcule d'éclairage diffuse lambertien -> plus c'est perpediculaire plus c'est 1 :

gouro -> -> au niveaux de chaque sommet Phong -> au niveaux de chaque fragment

OpenGl Redbook

bible openGl

le jeux quake est l'un des premiers a utiliser la rasterisation

Aide pour comprendre la projection Aide pour comprendre la projection

normal au sommet

Concept :

Explication a 52:30s

Normal : une surface est décrit par la perpendiculaire qui la définie

On fabrique une normale

Produit vectoriel :

L'application d'une normale a la face : (comme une boule a facet)

Dot product de la normal et de la lumière :

Produit scalaire :

Ils ont pas la même direction mais le même sens ! 🤯

En math :

le sens est opposé
la direction est la même

Cross product -> vecteur dot product -> float entre 0 et 1

Transposer inverse de la matrice

Cela permet de mettre a jours le model de la view, et du coup mettre a jours les normales.
Si le cube est modifier cela permettera de mettre a jours les normales.

.vs

vec3 N = normalize((transpose(inverse(model)) * vec4(vsiNormal, 0.0)).xyz);

Light algoritme de goureau :**.vs** ```cpp layout (location = 0) in vec3 vsiPosition;

/* variable cablée sur l'attribut 1 du sommet dans le code CPU (dans

gl4dg.c, dans l'appel glVertexAttribPointer(1, ...), le 1
correspond au location = 1) */

layout (location = 1) in vec3 vsiNormal;

/* variable cablée sur l'attribut 2 du sommet dans le code CPU (dans

gl4dg.c, dans l'appel glVertexAttribPointer(2, ...), le 2
correspond au location = 2) */ layout (location = 2) in vec2 vsiTexCoord;

uniform mat4 projection, model, view;

out float IL; vec3 Ld = vec3(0,-.707,-0.707);

void main(void) { vec3 N = normalize((transpose(inverse(model)) vec4(vsiNormal, 0.0)).xyz); IL = dot(N, -Ld); vec4 pos = projection view model vec4(vsiPosition, 1.0f); gl_Position = pos; }


texels : 
cordonnée de texture

<a href="https://www.libsdl.org/projects/SDL_mixer/" targe="_blank" rel="nofolow">SDL MIXER (son)</a>

Pour importer les executable Dll dans le bonne endroit il faut les placer à 2 endroits :
*  Pour les ordinateur 32 bit : C:\Windows\SysWOW64
*  Pour les ordinateur 64 bit : C:\Windows\System32

Lib assym

## Importer une modé 3d
<a href="https://github.com/assimp/assimp" target="_blank" rel="nofollow">Importer une modé 3d</a>

Mip mapping : permet de diviser la texture et gagner des performances dans la vue

Trilinear

![éclairage normal au sommet](/img/programmation-bas-niveaux-cpp/anisotropic.jpg)

Repère tbn :
 
<a href="https://learnopengl.com/Advanced-Lighting/Normal-Mapping" targe="_blank" rel="nofolow">opengl TBN</a>

<a href="https://perso.univ-rennes1.fr/pierre.nerzic/IMR2/IMR2%20-%20Synth%C3%A8se%20d'images%20-%20CM5.pdf" targe="_blank" rel="nofolow">PDF webgl</a>

Voir un autre post