J'ai déjà essayé opengl dans l'environnement Linux, la configuration en un clic des packages de ressources et j'ai récemment appris la configuration d'opengl et des fenêtres associées. Hier, j'ai utilisé le package nuget de VS pour le configurer en un clic. Il s'avère que le l'auteur de nupengl ne l'a pas mis à jour depuis longtemps, et le paquet nuget est conservé Le paquet opengl mis à jour ne prend en charge que le langage C#, et il a été reconfiguré via le lien lien aujourd'hui.
Besoin principalement de deux packages de support : glad, glfw
Un outil de compilation : cmake
GLFW est une bibliothèque de langage C spécifiquement pour OpenGL, qui fournit quelques interfaces minimales nécessaires pour rendre les objets. Il permet aux utilisateurs de créer des contextes OpenGL, de définir des paramètres de fenêtre et de traiter les entrées utilisateur. Après avoir utilisé glfw, il n'est pas nécessaire d'inclure des fichiers d'en-tête opengl , ni d'inclure <windows.h> ou d'autres fichiers d'en-tête de plate-forme, sauf si vous souhaitez les utiliser spécifiquement Apis.
GLAD peut rendre le rendu de base OpenGL très simple
heureux téléchargement officiel
heureux configuration 1
heureux configuration 1
CMake est un outil de compilation, de test et d'empaquetage multiplateforme
Organisez vos fichiers téléchargés :
Première affaire avec glfw, je viens de télécharger le paquet source, nous utilisons cmake pour compiler
Dans le chemin du fichier cmake : cmake-3.23.0-rc3-windows-x86_64\bin, exécutez cmake-gui.exe
Importez le chemin source de glfw dans cmake et spécifiez le chemin de sortie.Le fichier de construction dans la figure est nouvellement créé par moi, et vous pouvez le placer où vous voulez.
Ensuite, définissez votre modèle de studio visuel sous Outils-> configurer dans la barre de menus
Configurez d'abord vos paramètres, puis générez
Obtenez simplement les commentaires de la génération terminée
pour exécuter le makefile
Clic droit pour générer une solution
Après un retour réussi, récupérez glfw3.lib et glfw3.pdb sous le chemin glfw-3.3.6\build\src\Debug, et récupérez GLFW sous glfw-3.3.6\include
Pour résumer, vous avez maintenant les fichiers glad (include, src), glfw (glfw3.lib, glfw3.pdb, GLFW)
Il faut expliquer ici que chaque fois que nous créons un projet opengl, nous devons lier ces fichiers, donc créez un nouveau dossier, par exemple : Opengl
Sa structure est représentée sur la figure
Le fichier joint est configuré, puis créez un nouveau projet opengl, puis liez-les et créez un nouveau projet vide C++
Ajouté au fichier glad.c
Dans les propriétés du projet Opengl, implémentez l'importation des chemins d'inclusion et de bibliothèque (notez que ma plate-forme est X64, bien sûr la plupart des ordinateurs sont X64 maintenant, mais vous pouvez confirmer, si vous êtes X86, veuillez définir la plate-forme de la page de propriétés comme X86, le fichier de débogage est également défini sur X86 lors de la compilation)
Ensuite, configurez la bibliothèque correspondante dans le lien : opengl32.lib ; glfw3.lib ;
(Plate-forme Windows, opengl32.lib est déjà inclus dans le SDK Microsoft et est installé par défaut lors de l'installation de Visual Studio. Étant donné que ce didacticiel utilise le compilateur VS et se trouve sur le système d'exploitation Windows, il suffit d'ajouter opengl32. lib aux paramètres de l'éditeur de liens. Il convient de noter que le nom de fichier de la version 64 bits de la bibliothèque OpenGL est toujours opengl32.lib)
Après avoir appliqué et confirmé, essayez l'exemple suivant pour vérifier (veuillez noter que glad doit être devant d'autres dossiers opengl, sinon une erreur sera signalée)
#include <glad/glad.h>
#include <GLFW/glfw3.h>
#include <iostream>
void framebuffer_size_callback(GLFWwindow* window, int width, int height);
void processInput(GLFWwindow* window);
// settings
const unsigned int SCR_WIDTH = 800;
const unsigned int SCR_HEIGHT = 600;
const char* vertexShaderSource = "#version 330 core\n"
"layout (location = 0) in vec3 aPos;\n"
"void main()\n"
"{\n"
" gl_Position = vec4(aPos.x, aPos.y, aPos.z, 1.0);\n"
"}\0";
const char* fragmentShaderSource = "#version 330 core\n"
"out vec4 FragColor;\n"
"void main()\n"
"{\n"
" FragColor = vec4(1.0f, 0.5f, 0.2f, 1.0f);\n"
"}\n\0";
int main()
{
// glfw: initialize and configure
// ------------------------------
glfwInit();
glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);
glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3);
glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);
#ifdef __APPLE__
glfwWindowHint(GLFW_OPENGL_FORWARD_COMPAT, GL_TRUE);
#endif
// glfw window creation
// --------------------
GLFWwindow* window = glfwCreateWindow(SCR_WIDTH, SCR_HEIGHT, "LearnOpenGL", NULL, NULL);
if (window == NULL)
{
std::cout << "Failed to create GLFW window" << std::endl;
glfwTerminate();
return -1;
}
glfwMakeContextCurrent(window);
glfwSetFramebufferSizeCallback(window, framebuffer_size_callback);
// glad: load all OpenGL function pointers
// ---------------------------------------
if (!gladLoadGLLoader((GLADloadproc)glfwGetProcAddress))
{
std::cout << "Failed to initialize GLAD" << std::endl;
return -1;
}
// build and compile our shader program
// ------------------------------------
// vertex shader
unsigned int vertexShader = glCreateShader(GL_VERTEX_SHADER);
glShaderSource(vertexShader, 1, &vertexShaderSource, NULL);
glCompileShader(vertexShader);
// check for shader compile errors
int success;
char infoLog[512];
glGetShaderiv(vertexShader, GL_COMPILE_STATUS, &success);
if (!success)
{
glGetShaderInfoLog(vertexShader, 512, NULL, infoLog);
std::cout << "ERROR::SHADER::VERTEX::COMPILATION_FAILED\n" << infoLog << std::endl;
}
// fragment shader
unsigned int fragmentShader = glCreateShader(GL_FRAGMENT_SHADER);
glShaderSource(fragmentShader, 1, &fragmentShaderSource, NULL);
glCompileShader(fragmentShader);
// check for shader compile errors
glGetShaderiv(fragmentShader, GL_COMPILE_STATUS, &success);
if (!success)
{
glGetShaderInfoLog(fragmentShader, 512, NULL, infoLog);
std::cout << "ERROR::SHADER::FRAGMENT::COMPILATION_FAILED\n" << infoLog << std::endl;
}
// link shaders
unsigned int shaderProgram = glCreateProgram();
glAttachShader(shaderProgram, vertexShader);
glAttachShader(shaderProgram, fragmentShader);
glLinkProgram(shaderProgram);
// check for linking errors
glGetProgramiv(shaderProgram, GL_LINK_STATUS, &success);
if (!success) {
glGetProgramInfoLog(shaderProgram, 512, NULL, infoLog);
std::cout << "ERROR::SHADER::PROGRAM::LINKING_FAILED\n" << infoLog << std::endl;
}
glDeleteShader(vertexShader);
glDeleteShader(fragmentShader);
// set up vertex data (and buffer(s)) and configure vertex attributes
// ------------------------------------------------------------------
// add a new set of vertices to form a second triangle (a total of 6 vertices); the vertex attribute configuration remains the same (still one 3-float position vector per vertex)
float vertices[] = {
// first triangle
-0.9f, -0.5f, 0.0f, // left
-0.0f, -0.5f, 0.0f, // right
-0.45f, 0.5f, 0.0f, // top
// second triangle
0.0f, -0.5f, 0.0f, // left
0.9f, -0.5f, 0.0f, // right
0.45f, 0.5f, 0.0f // top
};
unsigned int VBO, VAO;
glGenVertexArrays(1, &VAO);
glGenBuffers(1, &VBO);
// bind the Vertex Array Object first, then bind and set vertex buffer(s), and then configure vertex attributes(s).
glBindVertexArray(VAO);
glBindBuffer(GL_ARRAY_BUFFER, VBO);
glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW);
glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 3 * sizeof(float), (void*)0);
glEnableVertexAttribArray(0);
// note that this is allowed, the call to glVertexAttribPointer registered VBO as the vertex attribute's bound vertex buffer object so afterwards we can safely unbind
glBindBuffer(GL_ARRAY_BUFFER, 0);
// You can unbind the VAO afterwards so other VAO calls won't accidentally modify this VAO, but this rarely happens. Modifying other
// VAOs requires a call to glBindVertexArray anyways so we generally don't unbind VAOs (nor VBOs) when it's not directly necessary.
glBindVertexArray(0);
// uncomment this call to draw in wireframe polygons.
//glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
// render loop
// -----------
while (!glfwWindowShouldClose(window))
{
// input
// -----
processInput(window);
// render
// ------
glClearColor(0.2f, 0.3f, 0.3f, 1.0f);
glClear(GL_COLOR_BUFFER_BIT);
// draw our first triangle
glUseProgram(shaderProgram);
glBindVertexArray(VAO); // seeing as we only have a single VAO there's no need to bind it every time, but we'll do so to keep things a bit more organized
glDrawArrays(GL_TRIANGLES, 0, 6); // set the count to 6 since we're drawing 6 vertices now (2 triangles); not 3!
// glBindVertexArray(0); // no need to unbind it every time
// glfw: swap buffers and poll IO events (keys pressed/released, mouse moved etc.)
// -------------------------------------------------------------------------------
glfwSwapBuffers(window);
glfwPollEvents();
}
// optional: de-allocate all resources once they've outlived their purpose:
// ------------------------------------------------------------------------
glDeleteVertexArrays(1, &VAO);
glDeleteBuffers(1, &VBO);
glDeleteProgram(shaderProgram);
// glfw: terminate, clearing all previously allocated GLFW resources.
// ------------------------------------------------------------------
glfwTerminate();
return 0;
}
// process all input: query GLFW whether relevant keys are pressed/released this frame and react accordingly
// ---------------------------------------------------------------------------------------------------------
void processInput(GLFWwindow* window)
{
if (glfwGetKey(window, GLFW_KEY_ESCAPE) == GLFW_PRESS)
glfwSetWindowShouldClose(window, true);
}
// glfw: whenever the window size changed (by OS or user resize) this callback function executes
// ---------------------------------------------------------------------------------------------
void framebuffer_size_callback(GLFWwindow* window, int width, int height)
{
// make sure the viewport matches the new window dimensions; note that width and
// height will be significantly larger than specified on retina displays.
glViewport(0, 0, width, height);
}Après exécution, une fenêtre apparaît, et un double triangle peut être dessiné
