diff --git a/assets/shaders/Image.frag b/assets/shaders/Image.frag new file mode 100644 index 0000000000000000000000000000000000000000..1af2c2fd7e6e20ebec8c3eff60f7b4a4cf6cc871 --- /dev/null +++ b/assets/shaders/Image.frag @@ -0,0 +1,10 @@ +#version 330 core +out vec4 FragColor; + +in vec2 Texture; + +uniform sampler2D uSampler; + +void main() { + FragColor = texture(uSampler, Texture); +} \ No newline at end of file diff --git a/assets/shaders/Image.vert b/assets/shaders/Image.vert new file mode 100644 index 0000000000000000000000000000000000000000..74c6db6c61d5a8f5f73827f1ff15703f20d7c357 --- /dev/null +++ b/assets/shaders/Image.vert @@ -0,0 +1,14 @@ +#version 330 core +layout (location = 0) in vec2 aPos; +layout (location = 1) in vec2 aTex; + +uniform mat4 uProj; +uniform mat4 uView; +uniform mat4 uModel; + +out vec2 Texture; + +void main() { + Texture = aTex; + gl_Position = uProj * uView * uModel * vec4(aPos.x, aPos.y, 0.0, 1.0); +} \ No newline at end of file diff --git a/source/engine/graphics/back/geometry/Geometry.cpp b/source/engine/graphics/back/geometry/Geometry.cpp deleted file mode 100644 index 26a8f590e14f3b6c3d52d9a248ad3ae7c0da6d62..0000000000000000000000000000000000000000 --- a/source/engine/graphics/back/geometry/Geometry.cpp +++ /dev/null @@ -1,19 +0,0 @@ -#include "Geometry.hpp" - -namespace megu { - template <Primitive P> - Geometry<P>::Geometry(const Layout_Initializer & layout) - : _layout(layout) {} - - template <Primitive P> - Geometry_Indiced<P>::Geometry_Indiced(const Layout_Initializer & layout) - : Geometry<P>(layout) {} - - template <class T, Primitive P> - Static_Geometry<T,P>::Static_Geometry(const Layout_Initializer & layout) - : Geometry<P>(layout) {} - - template <class T, Primitive P> - Static_Geometry_Indiced<T, P>:: Static_Geometry_Indiced(const Layout_Initializer & layout) - : Geometry<P>(layout) {} -} \ No newline at end of file diff --git a/source/engine/graphics/back/geometry/Geometry.hpp b/source/engine/graphics/back/geometry/Geometry.hpp index d61e0eaf9d126e4cb000a20c5e3e8a0fe0d729d6..7b34f29090660d2aac1b896631091be7a995f7b2 100644 --- a/source/engine/graphics/back/geometry/Geometry.hpp +++ b/source/engine/graphics/back/geometry/Geometry.hpp @@ -13,55 +13,57 @@ namespace megu { using Vertices_t = std::vector<float>; using Elements_t = std::vector<unsigned int>; - enum Primitive { + enum Primitive_t { TRIANGLES = GL_TRIANGLES, QUADS = GL_QUADS, }; - template <Primitive P> + template <Primitive_t P> class Geometry { public: Geometry() = delete; - Geometry(const Layout_Initializer &); + Geometry(const Layout &); ~Geometry() = default; virtual const Vertices_t & vertices() const = 0; + inline static Primitive_t Primitive() {return P;} + private: Layout _layout; }; - template <Primitive P> - class Geometry_Indiced : virtual public Geometry<P> { + template <Primitive_t P> + class Geometry_Indiced : public Geometry<P> { public: Geometry_Indiced() = delete; - Geometry_Indiced(const Layout_Initializer &); + Geometry_Indiced(const Layout &); ~Geometry_Indiced() = default; virtual const Elements_t & elements() const = 0; }; - template <class T, Primitive P> - class Static_Geometry : virtual public Geometry<P> { + template <class T, Primitive_t P> + class Static_Geometry : public Geometry<P> { public: Static_Geometry() = delete; - Static_Geometry(const Layout_Initializer &); + Static_Geometry(const Layout &); ~Static_Geometry() = default; const Vertices_t & vertices() const final override {return Static_Geometry<T, P>::Vertices();} static const Vertices_t & Vertices() {return T::Vertices();} }; - template <class T, Primitive P> + template <class T, Primitive_t P> class Static_Geometry_Indiced : public Geometry_Indiced<P>, public Static_Geometry<T, P> { public: Static_Geometry_Indiced() = delete; - Static_Geometry_Indiced(const Layout_Initializer &); + Static_Geometry_Indiced(const Layout &); ~Static_Geometry_Indiced() = default; const Elements_t & elements() const final override {return Static_Geometry_Indiced<T, P>::Elements();} static const Elements_t & Elements() {return T::Elements();} - }; + }; +} - -} \ No newline at end of file +#include "Geometry.tpp" \ No newline at end of file diff --git a/source/engine/graphics/back/geometry/Geometry.tpp b/source/engine/graphics/back/geometry/Geometry.tpp new file mode 100644 index 0000000000000000000000000000000000000000..c8cdbdcb2ac16a8dfbc2aa511f76a82eb78961ab --- /dev/null +++ b/source/engine/graphics/back/geometry/Geometry.tpp @@ -0,0 +1,19 @@ +#include "Geometry.hpp" + +namespace megu { + template <Primitive_t P> + Geometry<P>::Geometry(const Layout & layout) + : _layout(layout) {} + + template <Primitive_t P> + Geometry_Indiced<P>::Geometry_Indiced(const Layout & layout) + : Geometry<P>(layout) {} + + template <class T, Primitive_t P> + Static_Geometry<T,P>::Static_Geometry(const Layout & layout) + : Geometry<P>(layout) {} + + template <class T, Primitive_t P> + Static_Geometry_Indiced<T, P>:: Static_Geometry_Indiced(const Layout & layout) + : Geometry<P>(layout) {} +} \ No newline at end of file diff --git a/source/engine/graphics/back/textures/TextureBuffer.cpp b/source/engine/graphics/back/textures/TextureBuffer.cpp index 0c7e3f521030a8a2fbd45011825d3215a48e82de..1d020b3acb297474efe3a7ae0f70c712ef89e686 100644 --- a/source/engine/graphics/back/textures/TextureBuffer.cpp +++ b/source/engine/graphics/back/textures/TextureBuffer.cpp @@ -23,7 +23,7 @@ namespace megu { return *this; } - GLuint TextureBuffer::getPixel(GLuint x, GLuint y) const { + GLuint TextureBuffer::get(GLuint x, GLuint y) const { return this->_data.at((this->_width * y) + x); } @@ -75,7 +75,7 @@ namespace megu { this->_data.clear(); } - void TextureBuffer::setPixel(GLuint x, GLuint y, GLubyte v) { + void TextureBuffer::set(GLuint x, GLuint y, GLubyte v) { this->_data[(y * this->_width) + x] = v; } } \ No newline at end of file diff --git a/source/engine/graphics/back/textures/TextureBuffer.hpp b/source/engine/graphics/back/textures/TextureBuffer.hpp index 1c96c4235123215a8e25026b4683bf7190a11053..cb7f87fa4d17be2ec6ff3d3082cdc0927c78fb5f 100644 --- a/source/engine/graphics/back/textures/TextureBuffer.hpp +++ b/source/engine/graphics/back/textures/TextureBuffer.hpp @@ -21,13 +21,13 @@ namespace megu { inline const GLubyte * data_ptr() const {return this->_data.data();} inline bool empty() const {return this->_data.empty();} - GLuint getPixel(GLuint, GLuint) const; + GLuint get(GLuint, GLuint) const; void load(const GLubyte *, size_t); void load(const std::filesystem::path &, bool = true); void free(); - void setPixel(GLuint, GLuint, GLubyte); + void set(GLuint, GLuint, GLubyte); private: GLuint _width, _height; diff --git a/source/engine/graphics/front/geometry/FlatGeometry.cpp b/source/engine/graphics/front/geometry/FlatGeometry.cpp new file mode 100644 index 0000000000000000000000000000000000000000..e6e0de17daf4a8e06e0814b8c18f96367a8767fb --- /dev/null +++ b/source/engine/graphics/front/geometry/FlatGeometry.cpp @@ -0,0 +1,21 @@ +#include "FlatGeometry.hpp" + +namespace megu { + Flat_Geometry::Flat_Geometry() + : Geometry({layout::FLAT, layout::COLOR}) {} + + Vertices_t Static_Flat_Geometry::_Vertices = { + 0.f, 0.f, 0.f, 0.f, + 1.f, 0.f, 1.f, 0.f, + 1.f, 1.f, 1.f, 1.f, + 0.f, 1.f, 0.f, 1.f + }; + + Static_Flat_Geometry::Static_Flat_Geometry() + : Static_Geometry<Static_Flat_Geometry, QUADS>(Static_Flat_Geometry::GetLayout()) {} + + const Vertices_t & Static_Flat_Geometry::Vertices() { + return Static_Flat_Geometry::_Vertices; + } + +} \ No newline at end of file diff --git a/source/engine/graphics/front/geometry/FlatGeometry.hpp b/source/engine/graphics/front/geometry/FlatGeometry.hpp new file mode 100644 index 0000000000000000000000000000000000000000..7f56662bcaa71c655fd5d924ad14bd4173eb3976 --- /dev/null +++ b/source/engine/graphics/front/geometry/FlatGeometry.hpp @@ -0,0 +1,24 @@ +#pragma once + +#include <engine/graphics/back/geometry/Geometry.hpp> + +namespace megu { + class Flat_Geometry : public Geometry<QUADS> { + public: + Flat_Geometry(); + ~Flat_Geometry() = default; + }; + + class Static_Flat_Geometry : public Static_Geometry<Static_Flat_Geometry, QUADS> { + public: + Static_Flat_Geometry(); + ~Static_Flat_Geometry() = default; + + inline static Layout GetLayout() {return {layout::FLAT, layout::TEXTURE};} + + static const Vertices_t & Vertices(); + + private: + static Vertices_t _Vertices; + }; +} diff --git a/source/engine/graphics/front/group/DrawGroup.hpp b/source/engine/graphics/front/group/DrawGroup.hpp new file mode 100644 index 0000000000000000000000000000000000000000..d9a485553feab5e4de392008b34664fb409a0d1f --- /dev/null +++ b/source/engine/graphics/front/group/DrawGroup.hpp @@ -0,0 +1,10 @@ +#pragma once + +#include <engine/graphics/back/cameras/Camera.hpp> + +namespace megu { + class DrawGroup { + public: + virtual void draw(const Camera &) const = 0; + }; +} \ No newline at end of file diff --git a/source/engine/graphics/front/group/ImageGroup.cpp b/source/engine/graphics/front/group/ImageGroup.cpp new file mode 100644 index 0000000000000000000000000000000000000000..47fe30a4360cb91119c2ec3b765b8f0f93aeaa8f --- /dev/null +++ b/source/engine/graphics/front/group/ImageGroup.cpp @@ -0,0 +1,34 @@ +#include "ImageGroup.hpp" + +namespace megu { + ImageGroup::ImageGroup() + : _images(nullptr), _vbo(this->_vao, Static_Flat_Geometry::GetLayout(), 400) { + { + Source vert("assets/shaders/Image.vert", Source::Categorie::VERTEX); + Source frag("assets/shaders/Image.frag", Source::Categorie::FRAGMENT); + + this->_program << vert; + this->_program << frag; + this->_program.link(); + + vert.release(); + frag.release(); + } + + this->_vbo << Static_Flat_Geometry::Vertices(); + } + + void ImageGroup::draw(const Camera & camera) const { + this->_vao.bind(); + this->_program.use(); + + this->_images->texture().bind(0); + + this->_program.setUniform("uProj", camera.projection()); + this->_program.setUniform("uView", camera.view()); + this->_program.setUniform("uModel", this->_images->transformation().model()); + this->_program.setUniform("uSampler", 0); + + glDrawArrays(Static_Flat_Geometry::Primitive(), 0, static_cast<GLsizei>(this->_vbo.size())); + } +} \ No newline at end of file diff --git a/source/engine/graphics/front/group/ImageGroup.hpp b/source/engine/graphics/front/group/ImageGroup.hpp new file mode 100644 index 0000000000000000000000000000000000000000..465609efcd3788c70bc94344e10991511e7e96b1 --- /dev/null +++ b/source/engine/graphics/front/group/ImageGroup.hpp @@ -0,0 +1,28 @@ +#pragma once + +#include "DrawGroup.hpp" + +#include <engine/graphics/back/buffers/VertexArray.hpp> +#include <engine/graphics/back/buffers/VerticeBuffer.hpp> +#include <engine/graphics/back/shaders/Program.hpp> + +#include <engine/graphics/front/object/Image.hpp> + +namespace megu { + class ImageGroup : public DrawGroup { + public: + ImageGroup(); + ~ImageGroup() = default; + + void draw(const Camera & camera) const override; + + inline void temp_set(Image & image) {this->_images = ℑ} + + private: + Image * _images; + + VertexArray _vao; + VerticeBuffer _vbo; + Program _program; + }; +} \ No newline at end of file diff --git a/source/engine/graphics/front/object/Image.cpp b/source/engine/graphics/front/object/Image.cpp new file mode 100644 index 0000000000000000000000000000000000000000..d719bfba3917729233dae4fa2fe6f300b83ad744 --- /dev/null +++ b/source/engine/graphics/front/object/Image.cpp @@ -0,0 +1,19 @@ +#include "Image.hpp" + +namespace megu { + Image::Image() + : _texture(), + _transformation(), + _geometry() {} + + void Image::load(const std::filesystem::path & path, bool flip) { + TextureBuffer buffer; + buffer.load(path, flip); + this->load(buffer); + } + + void Image::load(const TextureBuffer & buffer) { + this->setSize(buffer.width(), buffer.height()); + this->_texture.store(buffer); + } +} \ No newline at end of file diff --git a/source/engine/graphics/front/object/Image.hpp b/source/engine/graphics/front/object/Image.hpp new file mode 100644 index 0000000000000000000000000000000000000000..0392e9411f0a2068338a2d76664cf29d321633d7 --- /dev/null +++ b/source/engine/graphics/front/object/Image.hpp @@ -0,0 +1,35 @@ +#pragma once + +#include <filesystem> +#include <glm/vec2.hpp> + +#include <engine/graphics/back/geometry/Transformable.hpp> +#include <engine/graphics/back/textures/Texture.hpp> + +#include <engine/graphics/front/geometry/FlatGeometry.hpp> + +namespace megu { + class Image { + public: + Image(); + ~Image() = default; + + inline glm::vec2 getPosition() const {return glm::vec2(this->_transformation.x(), this->_transformation.y());} + inline glm::vec2 getSize() const {return glm::vec2(this->_transformation.scaling().x, this->_transformation.scaling().y);} + + + inline void setPosition(float x, float y) {this->_transformation.setPosition(x, y);} + inline void setSize(float x, float y) {this->_transformation.setScaling(x, y);} + + void load(const std::filesystem::path &, bool = true); + void load(const TextureBuffer &); + + inline const Texture & texture() const {return this->_texture;} + inline const Transformable & transformation() const {return this->_transformation;} + + private: + Texture _texture; + Transformable _transformation; + Static_Flat_Geometry _geometry; + }; +} \ No newline at end of file diff --git a/source/main.cpp b/source/main.cpp index d0207f29da94f815d12c5521c5dee08954b136ac..ba376e78122fea9e4d928a16b3817a595f004c3f 100644 --- a/source/main.cpp +++ b/source/main.cpp @@ -3,14 +3,14 @@ #include <GL/glew.h> #include <GLFW/glfw3.h> -#include <engine/graphics/errors.hpp> -#include <engine/graphics/back.hpp> - -#define NORMALIZE(X) X/255.f - #define WINDOW_WIDTH 1200 #define WINDOW_HEIGHT 720 +#include <engine/graphics/back/cameras/View.hpp> +#include <engine/graphics/front/object/Image.hpp> +#include <engine/graphics/front/group/ImageGroup.hpp> +#include <engine/graphics/errors.hpp> + int main(int argc, const char * argv[]) { try { //? GLFW @@ -54,106 +54,21 @@ int main(int argc, const char * argv[]) { glViewport(0, 0, WINDOW_WIDTH, WINDOW_HEIGHT); megu::error::opengl_error::check(); - std::cout << "Viewport" << std::endl; - - //? Buffers - megu::VertexArray vao; - megu::VerticeBuffer vbo(vao, {megu::layout::POSITION, megu::layout::COLOR}, 128, megu::EditMode::STATIC); - - std::vector<float> vertices = { - -1.f, -1.f, 0.f, NORMALIZE(33), NORMALIZE(114), NORMALIZE(255), - 1.f, -1.f, 0.f, NORMALIZE(33), NORMALIZE(114), NORMALIZE(255), - 1.f, 0.0f, 0.f, NORMALIZE(217), NORMALIZE(63), NORMALIZE(114), - - 1.f, 0.0f, 0.f, NORMALIZE(217), NORMALIZE(63), NORMALIZE(114), - -1.f, 0.0f, 0.f, NORMALIZE(217), NORMALIZE(63), NORMALIZE(114), - -1.f, -1.f, 0.f, NORMALIZE(33), NORMALIZE(114), NORMALIZE(255), - - -1.f, -0.0f, 0.f, NORMALIZE(217), NORMALIZE(63), NORMALIZE(114), - 1.f, -0.0f, 0.f, NORMALIZE(217), NORMALIZE(63), NORMALIZE(114), - 1.f, 1.f, 0.f, NORMALIZE(190), NORMALIZE(105), NORMALIZE(170), - - 1.f, 1.f, 0.f, NORMALIZE(190), NORMALIZE(105), NORMALIZE(170), - -1.f, 1.f, 0.f, NORMALIZE(190), NORMALIZE(105), NORMALIZE(170), - -1.f, 0.0f, 0.f, NORMALIZE(217), NORMALIZE(63), NORMALIZE(114) - }; - - vbo << vertices; - - std::cout << "VBO" << std::endl; - - megu::VertexArray vao_2; - megu::VerticeBuffer vbo_2(vao_2, {megu::layout::POSITION, megu::layout::COLOR}, 128, megu::EditMode::STATIC); - - std::vector<float> vertices_2 = { - -0.5f, -0.5f, 0.0, NORMALIZE(255), NORMALIZE(0), NORMALIZE(0), - 0.5f, -0.5f, 0.0, NORMALIZE(0), NORMALIZE(255), NORMALIZE(0), - 0.0f, 0.5f, 0.0, NORMALIZE(0), NORMALIZE(0), NORMALIZE(255), - }; - - vbo_2 << vertices_2; - - megu::VertexArray vao_F; - megu::VerticeBuffer vbo_F(vao_F, {megu::layout::POSITION, megu::layout::TEXTURE}, 64, megu::EditMode::STATIC); - - std::vector<float> vertices_F = { - -1.f, -1.f, 0.f, 0.f, 0.f, - 1.f, -1.f, 0.f, 1.f, 0.f, - 1.f, 1.f, 0.f, 1.f, 1.f, - - -1.f, -1.f, 0.f, 0.f, 0.f, - 1.f, 1.f, 0.f, 1.f, 1.f, - -1.f, 1.f, 0.f, 0.f, 1.f - }; - - vbo_F << vertices_F; - std::cout << "VBO - FBO" << std::endl; + //? Camera + megu::View view(0, 0, WINDOW_WIDTH, WINDOW_HEIGHT); - //? Material + //? Image + megu::Image image; + image.load("assets/textures/Test.png"); - megu::TextureBuffer buffer; - buffer.load("assets/textures/All_Might_Armored.png"); + image.setSize(WINDOW_WIDTH/2, WINDOW_HEIGHT/2); - megu::Texture texture; - texture.store(buffer); - buffer.free(); - - //? FBO - - megu::FrameBuffer fbo(WINDOW_WIDTH, WINDOW_HEIGHT); - megu::FrameBuffer fbo_2(WINDOW_WIDTH, WINDOW_HEIGHT); - - //? Shaders - megu::Program program; - - { - megu::Source vertex("assets/shaders/Basic.vert", megu::Source::Categorie::VERTEX); - megu::Source fragment("assets/shaders/Basic.frag", megu::Source::Categorie::FRAGMENT); - - program << vertex; - program << fragment; - - program.link(); - } - - std::cout << "Shader - FBO" << std::endl; - - - megu::Program program_F; - - { - megu::Source vertex("assets/shaders/Texture.vert", megu::Source::Categorie::VERTEX); - megu::Source fragment("assets/shaders/Texture.frag", megu::Source::Categorie::FRAGMENT); - - program_F << vertex; - program_F << fragment; - - program_F.link(); - } - - std::cout << "Shader" << std::endl; + std::cout << "Texture" << std::endl; + //? Group + megu::ImageGroup group; + group.temp_set(image); //? Render Loop glClearColor(0.0f, 0.0f, 0.0f, 0.f); @@ -163,28 +78,10 @@ int main(int argc, const char * argv[]) { glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); glfwPollEvents(); - /*fbo.bind(); - vao.bind(); - program.use(); - glDrawArrays(GL_TRIANGLES, 0, static_cast<GLsizei>(vbo.size())); + group.draw(view); - fbo_2.bind(); - vao_2.bind(); - program.use(); - glDrawArrays(GL_TRIANGLES, 0, static_cast<GLsizei>(vbo_2.size()));*/ - - megu::FrameBuffer::BindDefaultFrameBuffer(); - vao_F.bind(); + image.setPosition(sin(glfwGetTime()) * WINDOW_WIDTH/2, cos(glfwGetTime()) * WINDOW_HEIGHT/2); - //fbo.texture().bind(0); - //fbo_2.texture().bind(1); - - texture.bind(0); - - program_F.use(); - program_F.setUniform("uSamp", std::vector<GLint>({0, 1})); - - glDrawArrays(GL_TRIANGLES, 0, static_cast<GLsizei>(vbo_F.size())); glfwSwapBuffers(window); } diff --git a/source/main.cpp.old b/source/main.cpp.old new file mode 100644 index 0000000000000000000000000000000000000000..d0207f29da94f815d12c5521c5dee08954b136ac --- /dev/null +++ b/source/main.cpp.old @@ -0,0 +1,198 @@ +#include <iostream> + +#include <GL/glew.h> +#include <GLFW/glfw3.h> + +#include <engine/graphics/errors.hpp> +#include <engine/graphics/back.hpp> + +#define NORMALIZE(X) X/255.f + +#define WINDOW_WIDTH 1200 +#define WINDOW_HEIGHT 720 + +int main(int argc, const char * argv[]) { + try { + //? GLFW + if(glfwInit() == GLFW_FALSE) { + std::cerr << "GLFW : GLFW Init Error" << std::endl; + return EXIT_FAILURE; + } + + GLFWmonitor * monitore = glfwGetPrimaryMonitor(); + const GLFWvidmode * videoMode = glfwGetVideoMode(monitore); + + glfwWindowHint(GLFW_RED_BITS, videoMode->redBits); + glfwWindowHint(GLFW_GREEN_BITS, videoMode->greenBits); + glfwWindowHint(GLFW_BLUE_BITS, videoMode->blueBits); + glfwWindowHint(GLFW_REFRESH_RATE, videoMode->refreshRate); + + glfwWindowHint(GLFW_RESIZABLE, true); + glfwWindowHint(GLFW_DECORATED, true); + glfwWindowHint(GLFW_VISIBLE, true); + glfwWindowHint(GLFW_DOUBLEBUFFER, true); + + GLFWwindow * window = glfwCreateWindow(WINDOW_WIDTH, WINDOW_HEIGHT, "Scene", NULL, NULL); + if(window == NULL) { + std::cerr << "GLFW : Window Init Error" << std::endl; + return EXIT_FAILURE; + } + + glfwMakeContextCurrent(window); + glfwSwapInterval(0); + std::cout << "GLFW Inited" << std::endl; + + //? Glew + if (glewInit()) { + std::cerr << "Failed to initialize GLAD" << std::endl; + return EXIT_FAILURE; + } + + std::cout << "Glew Inited" << std::endl; + + //? Viewport + glViewport(0, 0, WINDOW_WIDTH, WINDOW_HEIGHT); + + megu::error::opengl_error::check(); + std::cout << "Viewport" << std::endl; + + //? Buffers + megu::VertexArray vao; + megu::VerticeBuffer vbo(vao, {megu::layout::POSITION, megu::layout::COLOR}, 128, megu::EditMode::STATIC); + + std::vector<float> vertices = { + -1.f, -1.f, 0.f, NORMALIZE(33), NORMALIZE(114), NORMALIZE(255), + 1.f, -1.f, 0.f, NORMALIZE(33), NORMALIZE(114), NORMALIZE(255), + 1.f, 0.0f, 0.f, NORMALIZE(217), NORMALIZE(63), NORMALIZE(114), + + 1.f, 0.0f, 0.f, NORMALIZE(217), NORMALIZE(63), NORMALIZE(114), + -1.f, 0.0f, 0.f, NORMALIZE(217), NORMALIZE(63), NORMALIZE(114), + -1.f, -1.f, 0.f, NORMALIZE(33), NORMALIZE(114), NORMALIZE(255), + + -1.f, -0.0f, 0.f, NORMALIZE(217), NORMALIZE(63), NORMALIZE(114), + 1.f, -0.0f, 0.f, NORMALIZE(217), NORMALIZE(63), NORMALIZE(114), + 1.f, 1.f, 0.f, NORMALIZE(190), NORMALIZE(105), NORMALIZE(170), + + 1.f, 1.f, 0.f, NORMALIZE(190), NORMALIZE(105), NORMALIZE(170), + -1.f, 1.f, 0.f, NORMALIZE(190), NORMALIZE(105), NORMALIZE(170), + -1.f, 0.0f, 0.f, NORMALIZE(217), NORMALIZE(63), NORMALIZE(114) + }; + + vbo << vertices; + + std::cout << "VBO" << std::endl; + + megu::VertexArray vao_2; + megu::VerticeBuffer vbo_2(vao_2, {megu::layout::POSITION, megu::layout::COLOR}, 128, megu::EditMode::STATIC); + + std::vector<float> vertices_2 = { + -0.5f, -0.5f, 0.0, NORMALIZE(255), NORMALIZE(0), NORMALIZE(0), + 0.5f, -0.5f, 0.0, NORMALIZE(0), NORMALIZE(255), NORMALIZE(0), + 0.0f, 0.5f, 0.0, NORMALIZE(0), NORMALIZE(0), NORMALIZE(255), + }; + + vbo_2 << vertices_2; + + megu::VertexArray vao_F; + megu::VerticeBuffer vbo_F(vao_F, {megu::layout::POSITION, megu::layout::TEXTURE}, 64, megu::EditMode::STATIC); + + std::vector<float> vertices_F = { + -1.f, -1.f, 0.f, 0.f, 0.f, + 1.f, -1.f, 0.f, 1.f, 0.f, + 1.f, 1.f, 0.f, 1.f, 1.f, + + -1.f, -1.f, 0.f, 0.f, 0.f, + 1.f, 1.f, 0.f, 1.f, 1.f, + -1.f, 1.f, 0.f, 0.f, 1.f + }; + + vbo_F << vertices_F; + + std::cout << "VBO - FBO" << std::endl; + + //? Material + + megu::TextureBuffer buffer; + buffer.load("assets/textures/All_Might_Armored.png"); + + megu::Texture texture; + texture.store(buffer); + buffer.free(); + + //? FBO + + megu::FrameBuffer fbo(WINDOW_WIDTH, WINDOW_HEIGHT); + megu::FrameBuffer fbo_2(WINDOW_WIDTH, WINDOW_HEIGHT); + + //? Shaders + megu::Program program; + + { + megu::Source vertex("assets/shaders/Basic.vert", megu::Source::Categorie::VERTEX); + megu::Source fragment("assets/shaders/Basic.frag", megu::Source::Categorie::FRAGMENT); + + program << vertex; + program << fragment; + + program.link(); + } + + std::cout << "Shader - FBO" << std::endl; + + + megu::Program program_F; + + { + megu::Source vertex("assets/shaders/Texture.vert", megu::Source::Categorie::VERTEX); + megu::Source fragment("assets/shaders/Texture.frag", megu::Source::Categorie::FRAGMENT); + + program_F << vertex; + program_F << fragment; + + program_F.link(); + } + + std::cout << "Shader" << std::endl; + + + //? Render Loop + glClearColor(0.0f, 0.0f, 0.0f, 0.f); + + std::cout << "Render Loop Begin !" << std::endl; + while(!glfwWindowShouldClose(window)) { + glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); + glfwPollEvents(); + + /*fbo.bind(); + vao.bind(); + program.use(); + glDrawArrays(GL_TRIANGLES, 0, static_cast<GLsizei>(vbo.size())); + + fbo_2.bind(); + vao_2.bind(); + program.use(); + glDrawArrays(GL_TRIANGLES, 0, static_cast<GLsizei>(vbo_2.size()));*/ + + megu::FrameBuffer::BindDefaultFrameBuffer(); + vao_F.bind(); + + //fbo.texture().bind(0); + //fbo_2.texture().bind(1); + + texture.bind(0); + + program_F.use(); + program_F.setUniform("uSamp", std::vector<GLint>({0, 1})); + + glDrawArrays(GL_TRIANGLES, 0, static_cast<GLsizei>(vbo_F.size())); + + glfwSwapBuffers(window); + } + std::cout << "Render Loop End !" << std::endl; + } + catch(std::exception & error) { + std::cerr << error.what() << std::endl; + } + + return EXIT_SUCCESS; +} \ No newline at end of file