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

命名修改

Browse Source
This commit is contained in:
jie 2023-10-12 15:07:28 +08:00
parent d23a6427d9
commit 8e128f2d42
5 changed files with 122 additions and 174 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

25
include/triangle.h
View File

@ -6,30 +6,9 @@
#define MEDIAPLAYER_PRACTICE_1_H
#include "pch.h"
#include "shaderService.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";
namespace TRIANGLE {
int Practice1();
void frameBufferSizeChange(GLFWwindow *window, int width, int height);

6
shaders/fragmentShader.glsl Normal file
View File

@ -0,0 +1,6 @@
#version 330 core
in vec3 ourColor;
out vec4 FragColor;
void main(){
FragColor = vec4(ourColor, 1.0f);
}

9
shaders/vertexShader.glsl Normal file
View File

@ -0,0 +1,9 @@
#version 330 core
layout (location = 0) in vec3 aPos;
layout (location = 1) in vec3 aColor;
uniform float position;
out vec3 ourColor;
void main(){
gl_Position = vec4(aPos.x + position , -aPos.y, aPos.z, 1.0f);
ourColor = aPos;
}

151
src/triaangle.cpp
View File

@ -1,151 +0,0 @@
#include "triangle.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;
}
}

105
src/triangle.cpp Normal file
View File

@ -0,0 +1,105 @@
#include "triangle.h"
#include "iostream"
#include <chrono>
using namespace std::literals::chrono_literals;
namespace TRIANGLE {
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.5f, -0.5f, 0.0f, 1.0f, 0.0f, 0.0f,
-0.5f, -0.5f, 0.0f, 0.0f, 1.0f, 0.0f,
0.0f, 0.5f, 0.0f, 0.0f, 0.0f, 1.0f
};
unsigned int VAO, VBO, EBO;
glGenVertexArrays(1, &VAO);
glGenBuffers(1, &VBO);
glGenBuffers(1, &EBO);
glBindVertexArray(VAO);
glBindBuffer(GL_ARRAY_BUFFER, VBO);
glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW);
glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 6 * sizeof(float), (void *) 0);
glEnableVertexAttribArray(0);
glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, 6*sizeof(float), (void*)(3*sizeof(float)));
glEnableVertexAttribArray(1);
glBindVertexArray(0);
auto shader = ShaderService("../../shaders/vertexShader.glsl",
"../../shaders/fragmentShader.glsl");
glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
float pos = .0f;
while (!glfwWindowShouldClose(window)) {
processInput(window);
glClearColor(.2f, .3f, .3f, 1.0f);
glClear(GL_COLOR_BUFFER_BIT);
shader.Use();
shader.SetUniform<float>("position", pos+=0.001);
// std::this_thread::sleep_for(5ms);
glBindVertexArray(VAO);
// glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_INT, 0);
// glUseProgram(shaderProgram[1]);
glDrawArrays(GL_TRIANGLES, 0, 3);
glfwSwapBuffers(window);
glfwPollEvents();
}
glDeleteBuffers(1, &VBO);
glDeleteVertexArrays(1, &VAO);
glDeleteBuffers(1, &EBO);
glfwTerminate();
return 0;
}
}