jie/learnOpengl
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

practice1 complete

Browse Source
This commit is contained in:
jie 2023-10-10 00:53:47 +08:00
parent e1eade4af7
commit 68490e9a0c
5 changed files with 212 additions and 130 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
CMakeLists.txt
View File

@ -28,7 +28,8 @@ ELSE(WIN32)
set(THIRD_LIB_DIR D:/document/lib/)
#glad
include_directories(${THIRD_LIB_DIR}/glad/glad3.3/include)
set(GLAD_SRCS ${THIRD_LIB_DIR}/glad/glad3.3/src/glad.c)
set(GLAD_SRCS ${THIRD_LIB_DIR}/glad/glad3.3/src/glad.c
src/practice_1.cpp)
#glfw
include_directories(${THIRD_LIB_DIR}/glfw/glfw-3.3.8.bin.WIN64/glfw-3.3.8.bin.WIN64/include)
link_directories(${THIRD_LIB_DIR}/glfw/glfw-3.3.8.bin.WIN64/glfw-3.3.8.bin.WIN64/lib-vc2022)
@ -39,9 +40,12 @@ ELSE(WIN32)
set(Opengl_LIBS
opengl32.lib
)
include_directories(${PROJECT_SOURCE_DIR}/include)
file(GLOB_RECURSE PROJECT_SRCS ${PROJECT_SOURCE_DIR}/src/*.cpp)
#link
add_executable(${PROJECT_N}
main.cpp
${PRACTICE_SRCS}
${GLAD_SRCS}
)
target_link_libraries(${PROJECT_N}

11
include/pch.h Normal file
View File

@ -0,0 +1,11 @@
//
// Created by jie on 2023/10/9.
//
#ifndef LEARNOPENGL_PCH_H
#define LEARNOPENGL_PCH_H
#include "glad/glad.h"
#include "GLFW/glfw3.h"
#endif //LEARNOPENGL_PCH_H

43
include/practice_1.h Normal file
View File

@ -0,0 +1,43 @@
//
// Created by jie on 2023/10/9.
//
#ifndef MEDIAPLAYER_PRACTICE_1_H
#define MEDIAPLAYER_PRACTICE_1_H
#include "pch.h"
namespace PRACTICE {
static 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"
"}\n";
static 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";
static const char *fragmentShaderSource1 = "#version 330 core\n"
"out vec4 FragColor;\n"
"void main()\n"
"{\n"
" FragColor = vec4(1.0f, 1.0f, 0.0f, 1.0f);\n"
"}\n\0";
int Practice1();
void frameBufferSizeChange(GLFWwindow *window, int width, int height);
void processInput(GLFWwindow *window);
void CheckShader(unsigned int shaderIndex, bool isPorgram = false);
}
#endif //MEDIAPLAYER_PRACTICE_1_H

131
main.cpp
View File

@ -1,134 +1,7 @@
#include <iostream>
#include "glad/glad.h"
#include "GLFW/glfw3.h"
void frameBufferSizeChange(GLFWwindow *window, int width, int height) {
glViewport(0, 0, width, height);
}
void processInput(GLFWwindow *window) {
if (glfwGetKey(window, GLFW_KEY_ESCAPE) == GLFW_PRESS) {
glfwSetWindowShouldClose(window, true);
}
}
void CheckShader(unsigned int shaderIndex, bool isPorgram = false) {
int successful;
char logInfo[512];
if (isPorgram) {
glad_glGetProgramiv(shaderIndex, GL_LINK_STATUS, &successful);
} else {
glad_glGetShaderiv(shaderIndex, GL_COMPILE_STATUS, &successful);
}
if (!successful){
if(isPorgram){
glad_glGetProgramInfoLog(shaderIndex, 512, nullptr, logInfo);
}else{
glad_glGetShaderInfoLog(shaderIndex, 512, nullptr, logInfo);
}
std::cout<<logInfo<<std::endl;
}
}
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"
"}\n";
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";
#include "practice_1.h"
int main(int argc, char **const argv) {
glfwInit();
glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);
glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3);
glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);
GLFWwindow *window = glfwCreateWindow(800, 600, "Windows", nullptr, nullptr);
if (window == nullptr) {
return -1;
}
glfwMakeContextCurrent(window);
glfwSetWindowSizeCallback(window, frameBufferSizeChange);
if (!gladLoadGLLoader((GLADloadproc) glfwGetProcAddress)) {
auto error = glad_glGetError();
return static_cast<int>(error);
}
float vertices[] = {
-0.5, 0.5f, 0.0f,
0.5f, 0.5f, 0.0f,
0.5f, -0.5f, 0.0f,
-0.5f, -0.5f, 0.0f,
};
unsigned int indices[] = {
0, 1, 3,
1, 2, 3,
};
unsigned int VAO, VBO, EBO;
glGenVertexArrays(1, &VAO);
glGenBuffers(1, &VBO);
glGenBuffers(1, &EBO);
glBindVertexArray(VAO);
glBindBuffer(GL_ARRAY_BUFFER, VBO);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, EBO);
glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW);
glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(indices), indices, GL_STATIC_DRAW);
glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 3 * sizeof(float), (void *) 0);
glEnableVertexAttribArray(0);
glBindVertexArray(0);
unsigned int vertexShader, fragmentShader, shaderProgram;
vertexShader = glCreateShader(GL_VERTEX_SHADER);
fragmentShader = glCreateShader(GL_FRAGMENT_SHADER);
shaderProgram = glCreateProgram();
glShaderSource(vertexShader, 1, &vertexShaderSource, nullptr);
CheckShader(vertexShader);
glShaderSource(fragmentShader, 1, &fragmentShaderSource, nullptr);
CheckShader(fragmentShader);
glAttachShader(shaderProgram, vertexShader);
glAttachShader(shaderProgram, fragmentShader);
glLinkProgram(shaderProgram);
CheckShader(shaderProgram, true);
glDeleteShader(vertexShader);
glDeleteShader(fragmentShader);
glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
while (!glfwWindowShouldClose(window)) {
processInput(window);
glClearColor(.2f, .3f, .3f, 1.0f);
glClear(GL_COLOR_BUFFER_BIT);
glUseProgram(shaderProgram);
glBindVertexArray(VAO);
// glDrawArrays(GL_TRIANGLES, 0, 3);
glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_INT, 0);
glfwSwapBuffers(window);
glfwPollEvents();
}
glDeleteVertexArrays(1, &VAO);
glDeleteBuffers(1, &VBO);
glDeleteProgram(shaderProgram);
glfwTerminate();
PRACTICE::Practice1();
return 0;
}

151
src/practice_1.cpp Normal file
View File

@ -0,0 +1,151 @@
#include "practice_1.h"
#include "iostream"
namespace PRACTICE {
void frameBufferSizeChange(GLFWwindow *window, int width, int height) {
glViewport(0, 0, width, height);
}
void processInput(GLFWwindow *window) {
if (glfwGetKey(window, GLFW_KEY_ESCAPE) == GLFW_PRESS) {
glfwSetWindowShouldClose(window, true);
}
}
void CheckShader(unsigned int shaderIndex, bool isPorgram) {
int successful;
char logInfo[512];
if (isPorgram) {
glad_glGetProgramiv(shaderIndex, GL_LINK_STATUS, &successful);
} else {
glad_glGetShaderiv(shaderIndex, GL_COMPILE_STATUS, &successful);
}
if (!successful) {
if (isPorgram) {
glad_glGetProgramInfoLog(shaderIndex, 512, nullptr, logInfo);
} else {
glad_glGetShaderInfoLog(shaderIndex, 512, nullptr, logInfo);
}
std::cout << logInfo << std::endl;
}
}
int Practice1() {
glfwInit();
glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);
glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3);
glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);
GLFWwindow *window = glfwCreateWindow(800, 600, "Windows", nullptr, nullptr);
if (window == nullptr) {
return -1;
}
glfwMakeContextCurrent(window);
glfwSetWindowSizeCallback(window, frameBufferSizeChange);
if (!gladLoadGLLoader((GLADloadproc) glfwGetProcAddress)) {
auto error = glad_glGetError();
return static_cast<int>(error);
}
float vertices[] = {
-0.5, 0.5f, 0.0f,
0.5f, 0.5f, 0.0f,
0.0f, 0.0f, 0.0f,
0.5f, -0.5f, 0.0f,
-0.5f, -0.5f, 0.0f,
};
unsigned int indices[] = {
0, 1, 2,
};
unsigned int indices2[]{
2, 3, 4,
};
unsigned int VAOs[2], VBO, EBOs[2];
glGenVertexArrays(2, VAOs);
glGenBuffers(1, &VBO);
glGenBuffers(2, EBOs);
glBindVertexArray(VAOs[0]);
glBindBuffer(GL_ARRAY_BUFFER, VBO);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, EBOs[0]);
glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW);
glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(indices), indices, GL_STATIC_DRAW);
glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 3 * sizeof(float), (void *) 0);
glEnableVertexAttribArray(0);
glBindVertexArray(0);
glBindVertexArray(VAOs[1]);
glBindBuffer(GL_ARRAY_BUFFER, VBO);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, EBOs[1]);
glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW);
glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(indices2), indices2, GL_STATIC_DRAW);
glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 3 * sizeof(float), (void *) 0);
glEnableVertexAttribArray(0);
glBindVertexArray(0);
unsigned int vertexShader, fragmentShader[2], shaderProgram[2];
vertexShader = glCreateShader(GL_VERTEX_SHADER);
fragmentShader[0] = glCreateShader(GL_FRAGMENT_SHADER);
fragmentShader[1] = glCreateShader(GL_FRAGMENT_SHADER);
shaderProgram[0] = glCreateProgram();
shaderProgram[1] = glCreateProgram();
glShaderSource(vertexShader, 1, &vertexShaderSource, nullptr);
CheckShader(vertexShader);
glShaderSource(fragmentShader[0], 1, &fragmentShaderSource, nullptr);
CheckShader(fragmentShader[0]);
glShaderSource(fragmentShader[1], 1, &fragmentShaderSource1, nullptr);
CheckShader(fragmentShader[1]);
glAttachShader(shaderProgram[0], vertexShader);
glAttachShader(shaderProgram[0], fragmentShader[0]);
glLinkProgram(shaderProgram[0]);
CheckShader(shaderProgram[0], true);
glAttachShader(shaderProgram[1], vertexShader);
glAttachShader(shaderProgram[1], fragmentShader[1]);
glLinkProgram(shaderProgram[1]);
CheckShader(shaderProgram[1], true);
glDeleteShader(vertexShader);
glDeleteShader(fragmentShader[0]);
glDeleteShader(fragmentShader[1]);
glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
while (!glfwWindowShouldClose(window)) {
processInput(window);
glClearColor(.2f, .3f, .3f, 1.0f);
glClear(GL_COLOR_BUFFER_BIT);
glUseProgram(shaderProgram[0]);
glBindVertexArray(VAOs[0]);
glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_INT, 0);
glUseProgram(shaderProgram[1]);
glBindVertexArray(VAOs[1]);
glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_INT, 0);
// glDrawArrays(GL_TRIANGLES, 0, 3);
glfwSwapBuffers(window);
glfwPollEvents();
}
glDeleteBuffers(1, &VBO);
glDeleteVertexArrays(2, VAOs);
glDeleteBuffers(2, EBOs);
glDeleteProgram(shaderProgram[0]);
glDeleteProgram(shaderProgram[1]);
glfwTerminate();
return 0;
}
}