gKit2 light

- Main Page
- Related Pages
- Modules
- Classes
- Files

interface C openGL

## une api3d est...

un ensemble de fonctions. openGL est utilisable à travers un ensemble de fonctions C, ce qui signifie, pas de surchage, mais une famille de fonctions, des types opaques, pas d'objet, mais des identifiants.

une interface C++ pourrait ressembler à ça :

Context *context= new Context();
Point positions[]= { ... };
Buffer *buffer= context->createBuffer();
buffer->data(sizeof(positions), positions);

tout est explicite, on connait le contexte, le buffer, etc.

la version C pur pourrait ressembler à ça :

struct Context *context= context_create();
Point positions[]= { ... };
struct Buffer *buffer= context_createBuffer(context);
buffer_data(buffer, sizeof(positions), positions);

tout est explicite, mais un peu plus long à écrire.

l'interface d'openGL utilise une convention différente : au lieu de rendre explicite l'objet / la structure manipulée, elle est d'abord "sélectionnée" pour une opération particulière, puis manipulée implicitement :

createContext(); // crée un contexte, et le sélectionne,
uint buffer= createBuffer(); // crée un buffer, représenté par un identifiant numérique
bindBuffer(0, buffer); // sélectionne le buffer, pour une utilisation particulière
Point positions[]= { ... };
bufferData(0, sizeof(positions), positions); // alloue le buffer et l'initialise avec le contenu de positions.
// le buffer manipulé est celui sélectionné sur l'attribut 0...

ce qui permet d'obtenir une syntaxe compacte, mais peut être source de nombreuses erreurs, si l'on n'y prête pas attention.

## pas de surcharge

autre détail important, il n'y a pas de surchage en C, on ne peut écrire ça pour modifier la valeur d'un paramètre de shader :

Program *program= context->createProgram( ... );
program->uniform("color", Color(1, 1, 0)); // affecter une couleur
program->uniform("time", 12); // affecter un float

ni ça :

struct Program *program= context_createProgram( context, ... );
program_uniform(program, "color", make_color(1, 1, 0));
program_uniform(program, "time", 12);

mais plutot ça :

uint program= createProgram( ... );
program_uniform3f(program, "color", 1.0f, 1.0f, 0.0f);
program_uniform1f(program, "time", 12.0f);

chaque surcharge est nommée explicitement, puisque seul le nom de la fonction est utilisé. selon le type de valeur à manipuler, les noms de fonctions sont décorés par un suffixe indiquant le nombre de paramètres (1, 2, 3, ou 4) et leur type (f pour float, i pour int, u pour unsigned int, v pour vector, un pointeur sur une ou plusieurs valeurs, etc.)

## création des objets openGL

pour dessiner, il faut en général créer plusieurs types d'objets openGL, la démarche est toujours la même :

- créer un ou plusieurs identifiants, type `GLuint`, cf la famille de fonctions glGenXXX( ),
- sélectionner l'objet pour le configurer.

exemple, pour créer plusieurs buffers openGL, cf `glGenBuffers( )` :

GLuint buffers[4];
glGenBuffers(4, buffers);

### créer un buffer

pour créer un seul buffer, il suffit de passer le pointeur sur l'identifiant :

GLuint buffer;
glGenBuffers(1, &buffer);

le buffer sera ensuite sélectionné avec `glBindBuffer( )`. cf configurer un format de sommet, vertex array object pour plus de détails sur l'utilisation des buffers.

### créer un vertex array object

GLuint vao;
glGenVertexArrays(1, &vao);

le vao sera ensuite sélectionné avec `glBindVertexArray( )`. cf configurer un format de sommet, vertex array object pour plus de détails.

### créer une texture

GLuint texture;
glGenTextures(1, &texture);

la texture sera ensuite sélectionnée avec `glBindTexture( )`, cf textures, samplers et pipeline.

### créer un shader, un shader program

les shaders et les programs sont un peu à part, leur fonction de création ne crée qu'un seul objet à la fois :

GLuint vertex_shader= glCreateShader(GL_VERTEX_SHADER);
GLuint shader_program= glCreateProgram();

le program sera sélectionné avec `glUseProgram( )`. cf compiler et linker un shader program pour les détails.

# documentation complète

l'api complète et sa documentation est consultable sur opengl.org