guezoloic/learnopengl
1
0
Fork 0
mirror of https://github.com/guezoloic/LearnOpenGL.git synced 2026-01-25 07:34:16 +00:00
Code Issues Packages Projects Releases Wiki Activity

feat: rework few fonctions and change glew to glad

Browse Source 
- game files deleted
This commit is contained in:
Loïc GUEZO
2025-12-06 14:53:19 +01:00
parent 71ad3a034c
commit d2942242b4
21 changed files with 355 additions and 422 deletions
Download Patch File Download Diff File Expand all files Collapse all files

23
src/EBO.cpp
View File

@@ -1,23 +1,14 @@
#include "EBO.hpp"
#include "ebo.hpp"
EBO::EBO(unsigned int* indices, size_t size)
{
glGenBuffers(1, &id);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, id);
glBufferData(GL_ELEMENT_ARRAY_BUFFER, size, indices, GL_STATIC_DRAW);
glGenBuffers(1, &id);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, id);
glBufferData(GL_ELEMENT_ARRAY_BUFFER, size, indices, GL_STATIC_DRAW);
}
EBO::~EBO()
{
glDeleteBuffers(1, &id);
}
EBO::~EBO() { glDeleteBuffers(1, &id); }
void EBO::bind()
{
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, id);
}
void EBO::bind() { glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, id); }
void EBO::unbind()
{
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
}
void EBO::unbind() { glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0); }

50
src/VAO.cpp
View File

@@ -1,40 +1,30 @@
#include "VAO.hpp"
#include "vao.hpp"
VAO::VAO()
VAO::VAO() { glGenVertexArrays(1, &id); }
VAO::~VAO() { glDeleteVertexArrays(1, &id); }
void VAO::bind() { glBindVertexArray(id); }
void VAO::unbind() { glBindVertexArray(0); }
void VAO::setAttributePointer(GLuint index, GLuint size, GLenum type,
GLsizei stride, const void* offset)
{
glGenVertexArrays(1, &id);
bind();
glEnableVertexAttribArray(index);
glVertexAttribPointer(index, size, type, GL_FALSE, stride, offset);
}
VAO::~VAO()
void VAO::drawElement(GLenum mode, GLsizei count, GLenum type,
const void* indices)
{
glDeleteVertexArrays(1, &id);
}
void VAO::bind()
{
glBindVertexArray(id);
}
void VAO::unbind()
{
glBindVertexArray(0);
}
void VAO::setAttributePointer(GLuint index, GLuint size, GLenum type, GLsizei stride, const void* offset)
{
bind();
glEnableVertexAttribArray(index);
glVertexAttribPointer(index, size, type, GL_FALSE, stride, offset);
}
void VAO::drawElement(GLenum mode, GLsizei count, GLenum type, const void* indices)
{
bind();
glDrawElements(mode, count, type, indices);
bind();
glDrawElements(mode, count, type, indices);
}
void VAO::drawArray(GLenum mode, GLint first, GLsizei count)
{
bind();
glDrawArrays(mode, first, count);
bind();
glDrawArrays(mode, first, count);
}

23
src/VBO.cpp
View File

@@ -1,23 +1,14 @@
#include "VBO.hpp"
#include "vbo.hpp"
VBO::VBO(GLfloat* vertices, size_t size)
{
glGenBuffers(1, &id);
glBindBuffer(GL_ARRAY_BUFFER, id);
glBufferData(GL_ARRAY_BUFFER, size, vertices, GL_STATIC_DRAW);
glGenBuffers(1, &id);
glBindBuffer(GL_ARRAY_BUFFER, id);
glBufferData(GL_ARRAY_BUFFER, size, vertices, GL_STATIC_DRAW);
}
VBO::~VBO()
{
glDeleteBuffers(1, &id);
}
VBO::~VBO() { glDeleteBuffers(1, &id); }
void VBO::bind()
{
glBindBuffer(GL_ARRAY_BUFFER, id);
}
void VBO::bind() { glBindBuffer(GL_ARRAY_BUFFER, id); }
void VBO::unbind()
{
glBindBuffer(GL_ARRAY_BUFFER, 0);
}
void VBO::unbind() { glBindBuffer(GL_ARRAY_BUFFER, 0); }

102
src/camera.cpp
View File

@@ -1,5 +1,8 @@
#include "camera.hpp"
#include <glad/glad.h>
#include <GLFW/glfw3.h>
Camera::Camera(int width, int height, GLFWwindow* window, float sensitivity)
: screenWidth(width),
screenHeight(height),
@@ -14,86 +17,87 @@ Camera::Camera(int width, int height, GLFWwindow* window, float sensitivity)
worldUp(0.0f, 1.0f, 0.0f),
firstMouse(true)
{
glfwSetInputMode(window, GLFW_CURSOR, GLFW_CURSOR_DISABLED);
glfwSetInputMode(window, GLFW_CURSOR, GLFW_CURSOR_DISABLED);
updateCameraVectors();
}
void Camera::update(float deltaTime)
{
processInput(deltaTime);
processMouseMovement();
updateCameraVectors();
processInput(deltaTime);
processMouseMovement();
updateCameraVectors();
}
void Camera::processInput(float deltaTime)
{
float velocity = speed * deltaTime;
float velocity = speed * deltaTime;
if (glfwGetKey(window, GLFW_KEY_W) == GLFW_PRESS)
cameraPosition += cameraFront * velocity;
if (glfwGetKey(window, GLFW_KEY_W) == GLFW_PRESS)
cameraPosition += cameraFront * velocity;
if (glfwGetKey(window, GLFW_KEY_S) == GLFW_PRESS)
cameraPosition -= cameraFront * velocity;
if (glfwGetKey(window, GLFW_KEY_S) == GLFW_PRESS)
cameraPosition -= cameraFront * velocity;
if (glfwGetKey(window, GLFW_KEY_D) == GLFW_PRESS)
cameraPosition += cameraRight * velocity;
if (glfwGetKey(window, GLFW_KEY_D) == GLFW_PRESS)
cameraPosition += cameraRight * velocity;
if (glfwGetKey(window, GLFW_KEY_A) == GLFW_PRESS)
cameraPosition -= cameraRight * velocity;
if (glfwGetKey(window, GLFW_KEY_A) == GLFW_PRESS)
cameraPosition -= cameraRight * velocity;
if (glfwGetKey(window, GLFW_KEY_SPACE) == GLFW_PRESS)
cameraPosition += cameraUp * velocity;
if (glfwGetKey(window, GLFW_KEY_SPACE) == GLFW_PRESS)
cameraPosition += cameraUp * velocity;
if (glfwGetKey(window, GLFW_KEY_LEFT_CONTROL) == GLFW_PRESS)
cameraPosition -= cameraUp * velocity;
if (glfwGetKey(window, GLFW_KEY_LEFT_CONTROL) == GLFW_PRESS)
cameraPosition -= cameraUp * velocity;
// Zoom
if (glfwGetMouseButton(window, GLFW_MOUSE_BUTTON_LEFT) == GLFW_PRESS)
fov = 35.0f;
else
fov = 45.0f;
// Zoom
fov = (glfwGetMouseButton(window, GLFW_MOUSE_BUTTON_LEFT) == GLFW_PRESS)
? 35.f
: 45.f;
}
void Camera::processMouseMovement()
{
double mouseX, mouseY;
glfwGetCursorPos(window, &mouseX, &mouseY);
if (firstMouse) {
mousePosX = mouseX;
mousePosY = mouseY;
firstMouse = false;
return;
}
float deltaX = static_cast<float>(mouseX - mousePosX);
float deltaY = static_cast<float>(mousePosY - mouseY);
double mouseX, mouseY;
glfwGetCursorPos(window, &mouseX, &mouseY);
if (firstMouse)
{
mousePosX = mouseX;
mousePosY = mouseY;
firstMouse = false;
return;
}
deltaX *= cameraSensitivity;
deltaY *= cameraSensitivity;
float deltaX = static_cast<float>(mouseX - mousePosX);
float deltaY = static_cast<float>(mousePosY - mouseY);
cameraYaw += deltaX;
cameraPitch += deltaY;
mousePosX = mouseX;
mousePosY = mouseY;
if (cameraPitch > 89.0f) cameraPitch = 89.0f;
if (cameraPitch < -89.0f) cameraPitch = -89.0f;
deltaX *= cameraSensitivity;
deltaY *= cameraSensitivity;
cameraYaw += deltaX;
cameraPitch += deltaY;
if (cameraPitch > 89.0f) cameraPitch = 89.0f;
if (cameraPitch < -89.0f) cameraPitch = -89.0f;
}
void Camera::updateCameraVectors()
{
glm::vec3 front;
front.x = cos(glm::radians(cameraYaw)) * cos(glm::radians(cameraPitch));
front.y = sin(glm::radians(cameraPitch));
front.z = sin(glm::radians(cameraYaw)) * cos(glm::radians(cameraPitch));
cameraFront = glm::normalize(front);
glm::vec3 front;
front.x = cos(glm::radians(cameraYaw)) * cos(glm::radians(cameraPitch));
front.y = sin(glm::radians(cameraPitch));
front.z = sin(glm::radians(cameraYaw)) * cos(glm::radians(cameraPitch));
cameraFront = glm::normalize(front);
cameraRight = glm::normalize(glm::cross(cameraFront, worldUp));
cameraUp = glm::normalize(glm::cross(cameraRight, cameraFront));
cameraRight = glm::normalize(glm::cross(cameraFront, worldUp));
cameraUp = glm::normalize(glm::cross(cameraRight, cameraFront));
}
glm::mat4 Camera::getViewMatrix()
{
return glm::lookAt(cameraPosition, cameraPosition + cameraFront, cameraUp);
}
return glm::lookAt(cameraPosition, cameraPosition + cameraFront, cameraUp);
}

42
src/cube.cpp
View File

@@ -1,5 +1,7 @@
#include "cube.hpp"
#include "VAO.hpp"
#include "glm/gtc/type_ptr.hpp"
#include "vao.hpp"
#include "vbo.hpp"
GLfloat cubeVertices[] = {
@@ -124,21 +126,21 @@ const char* cubeFragShader = R"(
}
)";
Cube::Cube(Camera &camera) :
vbo(cubeVertices, sizeof(cubeVertices)),
ebo(cubeIndices, sizeof(cubeIndices)),
texture("stone.png"),
camera(camera),
shader(cubeVertexShader, cubeFragShader)
Cube::Cube(Camera& camera)
: vbo(cubeVertices, sizeof(cubeVertices)),
ebo(cubeIndices, sizeof(cubeIndices)),
texture("stone.png"),
camera(camera),
shader(cubeVertexShader, cubeFragShader)
{
vao.bind();
vbo.bind();
GLsizei stride = 8*sizeof(float);
GLsizei stride = 8 * sizeof(float);
vao.setAttributePointer(0, 3, GL_FLOAT, stride, (void*)0);
vao.setAttributePointer(1, 3, GL_FLOAT, stride, (void*)(3*sizeof(float)));
vao.setAttributePointer(2, 2, GL_FLOAT, stride, (void*)(6*sizeof(float)));
vao.setAttributePointer(1, 3, GL_FLOAT, stride, (void*)(3 * sizeof(float)));
vao.setAttributePointer(2, 2, GL_FLOAT, stride, (void*)(6 * sizeof(float)));
ebo.bind();
}
@@ -148,13 +150,10 @@ void Cube::loop(int width, int height)
shader.use();
glActiveTexture(GL_TEXTURE0);
glm::vec3 coordinate = glm::vec3(0.0f, -1.0f, 0.0f);
glm::vec3 coordinate = glm::vec3(0.0f, 0.0f, -1.0f);
glm::mat4 projection = glm::perspective(
glm::radians(camera.fov),
static_cast<float>(width) / static_cast<float>(height),
0.1f,
100.0f
);
glm::radians(camera.fov),
static_cast<float>(width) / static_cast<float>(height), 0.1f, 100.0f);
GLint texLoc = glGetUniformLocation(shader.getProgram(), "material.diffuse");
glUniform1i(texLoc, 0);
@@ -163,16 +162,13 @@ void Cube::loop(int width, int height)
glUniformMatrix4fv(projectionLoc, 1, GL_FALSE, glm::value_ptr(projection));
GLint viewLoc = glGetUniformLocation(shader.getProgram(), "view");
glUniformMatrix4fv(viewLoc, 1, GL_FALSE, glm::value_ptr(camera.getViewMatrix()));
glUniformMatrix4fv(viewLoc, 1, GL_FALSE,
glm::value_ptr(camera.getViewMatrix()));
glm::mat4 model = glm::translate(glm::mat4(1.0f), coordinate);
GLint modelLoc = glGetUniformLocation(shader.getProgram(), "model");
glUniformMatrix4fv(modelLoc, 1, GL_FALSE, glm::value_ptr(model));
vao.drawElement(
GL_TRIANGLES,
sizeof(cubeIndices) / sizeof(unsigned int),
GL_UNSIGNED_INT,
0
);
vao.drawElement(GL_TRIANGLES, sizeof(cubeIndices) / sizeof(unsigned int),
GL_UNSIGNED_INT, 0);
}

87
src/game.cpp
View File

@@ -1,87 +0,0 @@
#include "GL/glew.h"
#include "game.hpp"
#include "GLFW/glfw3.h"
#include <cstdlib>
#include <iostream>
Game::Game(int width, int height, string name) :
width(width),
height(height),
name(name.c_str())
{
if(glfwInit() == GLFW_FALSE)
std::cerr << "error glfw" << std::endl;
this->window = glfwCreateWindow(
this->width,
this->height,
this->name,
nullptr,
nullptr
);
// OpenGL 3.3
glfwWindowHint(GLFW_VERSION_MAJOR, 3);
glfwWindowHint(GLFW_VERSION_MINOR, 3);
glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);
glfwWindowHint(GLFW_DEPTH_BITS, 24);
glfwWindowHint(GLFW_STENCIL_BITS, 8);
glfwWindowHint(GLFW_SAMPLES, 4);
glfwMakeContextCurrent(this->window);
glewInit();
glEnable(GL_DEPTH_TEST);
glEnable(GL_MULTISAMPLE);
}
void Game::run(bool (*func)(Game *g))
{
while(func(this))
{
glfwGetWindowSize(this->window, &this->width, &this->height);
glViewport(0, 0, this->width, this->height);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glClearColor(0.5f, 0.2f, 0.2f, 1.0f);
glDisable(GL_MULTISAMPLE);
glfwPollEvents();
glfwSwapBuffers(this->window);
GLenum error = glGetError();
if (error != glGetError())
{
std::cerr << error << std::endl;
exit(1);
}
}
}
Game::~Game()
{
glfwTerminate();
}
GLFWwindow *Game::getWindow()
{
return this->window;
}
const char *Game::getName()
{
return this->name;
}
int Game::getWidth()
{
return this->height;
}
int Game::getHeight()
{
return this->width;
}

102
src/main.cpp
View File

@@ -1,16 +1,98 @@
#define STB_IMAGE_IMPLEMENTATION
#include "stb_image.h"
#include <glad/glad.h>
#include <GLFW/glfw3.h>
#include "game.hpp"
#include <cstdlib>
#include <iostream>
#include "camera.hpp"
#include "cube.hpp"
static void glfwErrorCallback(int error, const char *description)
{
std::cerr << "GLFW Error " << error << ": " << description << std::endl;
}
int main()
{
Game game(800, 600, "game");
const char *title = "window";
int width = 800, height = 600;
auto quit = [](Game *g) {
return !glfwWindowShouldClose(g->getWindow());
};
glfwSetErrorCallback(glfwErrorCallback);
game.run(quit);
return 0;
}
if (glfwInit() == GLFW_FALSE)
{
std::cerr << "ERROR(GLFW): initialisation error" << std::endl;
exit(EXIT_FAILURE);
}
// OpenGL 3.3
glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);
glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3);
glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);
glfwWindowHint(GLFW_DEPTH_BITS, 24);
glfwWindowHint(GLFW_STENCIL_BITS, 8);
glfwWindowHint(GLFW_SAMPLES, 4);
#ifdef __APPLE__
glfwWindowHint(GLFW_OPENGL_FORWARD_COMPAT, GL_TRUE);
#endif
GLFWwindow *window = glfwCreateWindow(width, height, title, nullptr, nullptr);
if (window == nullptr)
{
std::cerr
<< "ERROR: Failed to create GLFW window with requested GL version."
<< std::endl;
glfwTerminate();
exit(EXIT_FAILURE);
}
glfwMakeContextCurrent(window);
if (!gladLoadGLLoader((GLADloadproc)glfwGetProcAddress))
{
std::cerr << "ERROR: Failed to initialize GLAD" << std::endl;
glfwDestroyWindow(window);
glfwTerminate();
exit(EXIT_FAILURE);
}
glfwSwapInterval(1);
Camera camera(width, height, window, 0.1f);
Cube cube{camera};
glEnable(GL_DEPTH_TEST);
glEnable(GL_MULTISAMPLE);
double deltaTime = 0.f;
double lastTime = glfwGetTime();
while (!glfwWindowShouldClose(window))
{
glfwGetFramebufferSize(window, &width, &height);
glViewport(0, 0, width, height);
glClearColor(0.5f, 0.2f, 0.2f, 1.0f);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
double currentTime = glfwGetTime();
deltaTime = currentTime - lastTime;
lastTime = currentTime;
camera.update(deltaTime);
cube.loop(width, height);
glfwPollEvents();
glfwSwapBuffers(window);
GLenum error = glGetError();
if (error != GL_NO_ERROR)
{
std::cerr << error << std::endl;
// exit(1);
}
}
glfwDestroyWindow(window);
glfwTerminate();
return 0;
}

49
src/shader.cpp
View File

@@ -2,51 +2,42 @@
Shader::Shader(const char* vertexShaderSource, const char* fragmentShaderSource)
{
vertexShader = glCreateShader(GL_VERTEX_SHADER);
fragmentShader = glCreateShader(GL_FRAGMENT_SHADER);
shaderProgram = glCreateProgram();
vertexShader = glCreateShader(GL_VERTEX_SHADER);
fragmentShader = glCreateShader(GL_FRAGMENT_SHADER);
shaderProgram = glCreateProgram();
addVertShader(vertexShaderSource);
addFragShader(fragmentShaderSource);
addVertShader(vertexShaderSource);
addFragShader(fragmentShaderSource);
compileInProgram();
compileInProgram();
}
void Shader::addVertShader(const char* vertexShaderSource)
{
glShaderSource(vertexShader, 1, &vertexShaderSource, nullptr);
glCompileShader(vertexShader);
glShaderSource(vertexShader, 1, &vertexShaderSource, nullptr);
glCompileShader(vertexShader);
}
void Shader::addFragShader(const char* fragmentShaderSource)
{
glShaderSource(fragmentShader, 1, &fragmentShaderSource, nullptr);
glCompileShader(fragmentShader);
glShaderSource(fragmentShader, 1, &fragmentShaderSource, nullptr);
glCompileShader(fragmentShader);
}
void Shader::compileInProgram()
{
glAttachShader(shaderProgram, vertexShader);
glAttachShader(shaderProgram, fragmentShader);
glLinkProgram(shaderProgram);
glAttachShader(shaderProgram, vertexShader);
glAttachShader(shaderProgram, fragmentShader);
glLinkProgram(shaderProgram);
glDetachShader(shaderProgram, vertexShader);
glDetachShader(shaderProgram, fragmentShader);
glDeleteShader(vertexShader);
glDeleteShader(fragmentShader);
glDetachShader(shaderProgram, vertexShader);
glDetachShader(shaderProgram, fragmentShader);
glDeleteShader(vertexShader);
glDeleteShader(fragmentShader);
}
Shader::~Shader()
{
glDeleteProgram(shaderProgram);
}
Shader::~Shader() { glDeleteProgram(shaderProgram); }
void Shader::use() const
{
glUseProgram(shaderProgram);
}
void Shader::use() const { glUseProgram(shaderProgram); }
GLuint Shader::getProgram() const
{
return shaderProgram;
}
GLuint Shader::getProgram() const { return shaderProgram; }

81
src/texture.cpp
View File

@@ -1,6 +1,7 @@
#include "texture.hpp"
#include <iostream>
#include <filesystem>
#include <iostream>
#define STB_IMAGE_IMPLEMENTATION
#include "stb_image.h"
@@ -9,60 +10,56 @@ namespace fs = std::filesystem;
Texture::Texture(const std::string& filename)
{
fs::path path = fs::absolute(fs::current_path() / "res" / filename);
fs::path path = fs::absolute(fs::current_path() / "res" / filename);
int maxTextureSize;
glGetIntegerv(GL_MAX_TEXTURE_SIZE, &maxTextureSize);
int maxTextureSize;
glGetIntegerv(GL_MAX_TEXTURE_SIZE, &maxTextureSize);
glGenTextures(1, &id);
glBindTexture(GL_TEXTURE_2D, id);
glGenTextures(1, &id);
glBindTexture(GL_TEXTURE_2D, id);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
int imgW, imgH, numColCh;
stbi_set_flip_vertically_on_load(true);
unsigned char* data = stbi_load(path.string().c_str(), &imgW, &imgH, &numColCh, 0);
int imgW, imgH, numColCh;
stbi_set_flip_vertically_on_load(true);
unsigned char* data =
stbi_load(path.string().c_str(), &imgW, &imgH, &numColCh, 0);
if (!data)
{
std::cerr << "Error loading image: " << path << std::endl;
return;
}
if (!data)
{
std::cerr << "Error loading image: " << path << std::endl;
return;
}
int loadedTextureSize = imgW * imgH;
if (loadedTextureSize >= maxTextureSize)
{
std::cerr << "Error: max texture size is " << maxTextureSize
<< " pixels, but image size = " << loadedTextureSize << std::endl;
stbi_image_free(data);
return;
}
GLenum format = (numColCh == 4) ? GL_RGBA : GL_RGB;
glTexImage2D(GL_TEXTURE_2D, 0, format, imgW, imgH, 0, format, GL_UNSIGNED_BYTE, data);
glGenerateMipmap(GL_TEXTURE_2D);
int loadedTextureSize = imgW * imgH;
if (loadedTextureSize >= maxTextureSize)
{
std::cerr << "Error: max texture size is " << maxTextureSize
<< " pixels, but image size = " << loadedTextureSize << std::endl;
stbi_image_free(data);
return;
}
GLenum format = (numColCh == 4) ? GL_RGBA : GL_RGB;
glTexImage2D(GL_TEXTURE_2D, 0, format, imgW, imgH, 0, format,
GL_UNSIGNED_BYTE, data);
glGenerateMipmap(GL_TEXTURE_2D);
stbi_image_free(data);
}
Texture::~Texture()
{
glDeleteTextures(1, &id);
}
Texture::~Texture() { glDeleteTextures(1, &id); }
void Texture::bind(GLenum textureUnit) const
{
glActiveTexture(textureUnit);
glBindTexture(GL_TEXTURE_2D, id);
glActiveTexture(textureUnit);
glBindTexture(GL_TEXTURE_2D, id);
}
unsigned int Texture::getID() const
{
return id;
}
unsigned int Texture::getID() const { return id; }