bit more

Assets/floppy-resources.conf

@@ -0,0 +1,13 @@
+group=floppy-resources
+
+[file]
+filename=shaders/pipe_shader.frag
+alias=pipe_shader.frag
+
+[file]
+filename=shaders/pipe_shader.vert
+alias=pipe_shader.vert
+
+[file]
+filename=images/bird.png
+alias=bird.png

Assets/resources.conf

@@ -0,0 +1,12 @@
+group=texturedquad-data
+
+[file]
+filename=shaders/TexturedQuadShader.frag
+alias=TexturedQuadShader.frag
+
+[file]
+filename=shaders/TexturedQuadShader.vert
+alias=TexturedQuadShader.vert
+
+[file]
+filename=stone.tga

Assets/shaders/TexturedQuadShader.frag

@@ -0,0 +1,11 @@
+uniform vec3 color = vec3(1.0, 1.0, 1.0);
+uniform sampler2D textureData;
+
+in vec2 interpolatedTextureCoordinates;
+
+out vec4 fragmentColor;
+
+void main() {
+    fragmentColor.rgb = color*texture(textureData, interpolatedTextureCoordinates).rgb;
+    fragmentColor.a = 1.0;
+}

Assets/shaders/TexturedQuadShader.vert

@@ -0,0 +1,10 @@
+layout(location = 0) in vec4 position;
+layout(location = 1) in vec2 textureCoordinates;
+
+out vec2 interpolatedTextureCoordinates;
+
+void main() {
+    interpolatedTextureCoordinates = textureCoordinates;
+
+    gl_Position = position;
+}

CMakeLists.txt

@@ -10,31 +10,37 @@ set(CMAKE_MODULE_PATH "${PROJECT_SOURCE_DIR}/modules/" ${CMAKE_MODULE_PATH} ${CM
 
 # Add Corrade as a subproject
 add_subdirectory(corrade EXCLUDE_FROM_ALL)
+set_directory_properties(PROPERTIES CORRADE_USE_PEDANTIC_FLAGS ON)
 
 # Add Magnum as a subproject, enable Sdl2Application
 set(MAGNUM_WITH_SDL2APPLICATION ON CACHE BOOL "" FORCE)
+set(MAGNUM_WITH_TGAIMPORTER ON CACHE BOOL "" FORCE)
 add_subdirectory(magnum EXCLUDE_FROM_ALL)
+find_package(Magnum REQUIRED GL Sdl2Application Trade TgaImporter)
 
-find_package(Magnum REQUIRED GL Sdl2Application)
 message(STATUS "Magnum found: ${MAGNUM_FOUND}")
 
-set_directory_properties(PROPERTIES CORRADE_USE_PEDANTIC_FLAGS ON)
+corrade_add_resource(RESOURCES Assets/resources.conf)
 
+# Set the sources, allows VS to filter them properly
+file(GLOB SOURCES "src/*.cpp")
+file(GLOB HEADERS "src/*.h")
 include_directories(include)
 
-# Set the sources, allows VS to filter them properly 
+add_executable(${PNAME} ${SOURCES}
-file(GLOB SOURCES "*.cpp") 
+        ${RESOURCES})
-file(GLOB HEADERS "*.h")
 
-add_executable(${PNAME} ${SOURCES} Bird.cpp Bird.h Pipe.cpp Pipe.h)
+
+message(STATUS "sources: ${SOURCES}")
+
+add_dependencies(${PNAME} Magnum::TgaImporter)
 
 target_link_libraries(${PNAME} PRIVATE
+        Corrade::Main
         Magnum::Application
         Magnum::GL
-        Magnum::Magnum)
+        Magnum::Magnum
-
+        Magnum::Trade)
-# Link CL, GL, and SFML 
-target_link_libraries (${PNAME} ${SFML_LIBRARIES} ${SFML_DEPENDENCIES}) 
 
 # Setup to use C++11 + others
 set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++11") 

src/Bird.h

@@ -1,9 +1,5 @@
-//#ifndef FLOPPY_BIRD_BIRD_H
+#pragma once
-//#define FLOPPY_BIRD_BIRD_H
+
-//
-//#include <SFML/Graphics/Sprite.hpp>
-//#include <SFML/Graphics/Texture.hpp>
-//#include <SFML/Graphics/RenderTarget.hpp>
 //#include <memory>
 //
 //const float gravity = 9.8;
@@ -26,5 +22,3 @@
 //    virtual void draw(sf::RenderTarget& target, sf::RenderStates states) const;
 //};
 //
-//
-//#endif //FLOPPY_BIRD_BIRD_H

src/QuadShader.cpp

@@ -0,0 +1,22 @@
+#include "QuadShader.h"
+
+QuadShader::QuadShader() {
+    MAGNUM_ASSERT_GL_VERSION_SUPPORTED(GL::Version::GL330);
+
+    const Utility::Resource rs{"texturedquad-data"};
+
+    GL::Shader vert{GL::Version::GL330, GL::Shader::Type::Vertex};
+    GL::Shader frag{GL::Version::GL330, GL::Shader::Type::Fragment};
+
+    vert.addSource(rs.getString("TexturedQuadShader.vert"));
+    frag.addSource(rs.getString("TexturedQuadShader.frag"));
+
+    CORRADE_INTERNAL_ASSERT_OUTPUT(vert.compile() && frag.compile());
+
+    attachShaders({vert, frag});
+
+    CORRADE_INTERNAL_ASSERT_OUTPUT(link());
+
+    _colorUniform = uniformLocation("color");
+    setUniform(uniformLocation("textureData"), TextureUnit);
+}

src/QuadShader.h

@@ -0,0 +1,52 @@
+#pragma once
+#include <Magnum/GL/DefaultFramebuffer.h>
+#include <Magnum/Platform/Sdl2Application.h>
+#include <Corrade/Containers/Optional.h>
+#include <Corrade/Containers/StringView.h>
+#include <Corrade/PluginManager/Manager.h>
+#include <Corrade/Utility/Resource.h>
+#include <Magnum/ImageView.h>
+#include <Magnum/GL/Buffer.h>
+#include <Magnum/GL/DefaultFramebuffer.h>
+#include <Magnum/GL/Mesh.h>
+#include <Magnum/GL/Texture.h>
+#include <Magnum/GL/TextureFormat.h>
+#include <Magnum/Platform/Sdl2Application.h>
+#include <Magnum/Trade/AbstractImporter.h>
+#include <Magnum/Trade/ImageData.h>
+#include <Magnum/GL/Texture.h>
+#include <Magnum/Math/Color.h>
+#include <Corrade/Containers/Iterable.h>
+#include <Corrade/Containers/StringView.h>
+#include <Corrade/Containers/StringStl.h>
+#include <Corrade/Utility/Resource.h>
+#include <Magnum/GL/Context.h>
+#include <Magnum/GL/Shader.h>
+#include <Magnum/GL/Version.h>
+#include <Magnum/GL/AbstractShaderProgram.h>
+
+using namespace Magnum;
+
+class QuadShader: public GL::AbstractShaderProgram {
+public:
+    typedef GL::Attribute<0, Vector2> Position;
+    typedef GL::Attribute<1, Vector2> TextureCoordinates;
+
+    explicit QuadShader();
+
+    QuadShader& setColor(const Color3& color) {
+        setUniform(_colorUniform, color);
+        return *this;
+    }
+
+    QuadShader& bindTexture(GL::Texture2D& texture) {
+        texture.bind(TextureUnit);
+        return *this;
+    }
+
+private:
+    enum: Int { TextureUnit = 0 };
+
+    Int _colorUniform;
+};
+

src/main.cpp

@@ -14,8 +14,31 @@
 
 #include <Magnum/GL/DefaultFramebuffer.h>
 #include <Magnum/Platform/Sdl2Application.h>
+#include <Corrade/Containers/Optional.h>
+#include <Corrade/Containers/StringView.h>
+#include <Corrade/PluginManager/Manager.h>
+#include <Corrade/Utility/Resource.h>
+#include <Magnum/ImageView.h>
+#include <Magnum/GL/Buffer.h>
+#include <Magnum/GL/DefaultFramebuffer.h>
+#include <Magnum/GL/Mesh.h>
+#include <Magnum/GL/Texture.h>
+#include <Magnum/GL/TextureFormat.h>
+#include <Magnum/Platform/Sdl2Application.h>
+#include <Magnum/Trade/AbstractImporter.h>
+#include <Magnum/Trade/ImageData.h>
+#include <Magnum/GL/AbstractShaderProgram.h>
+#include <Magnum/GL/Texture.h>
+#include <Magnum/Math/Color.h>
+#include <Corrade/Containers/Iterable.h>
+#include <Corrade/Containers/StringView.h>
+#include <Corrade/Containers/StringStl.h>
+#include <Corrade/Utility/Resource.h>
+#include <Magnum/GL/Context.h>
+#include <Magnum/GL/Shader.h>
+#include <Magnum/GL/Version.h>
 
-using namespace Magnum;
+#include "QuadShader.h"
 
 class MyApplication: public Platform::Application {
 public:
@@ -23,10 +46,55 @@ public:
 
 private:
     void drawEvent() override;
+
+    GL::Mesh _mesh;
+    QuadShader _shader;
+    GL::Texture2D _texture;
 };
 
 MyApplication::MyApplication(const Arguments& arguments): Platform::Application{arguments} {
-    /* TODO: Add your initialization code here */
+
+    // =============== Vertex and index buffer stuff =====================
+
+    struct QuadVertex {
+        Vector2 position;
+        Vector2 textureCoordinates;
+    };
+    const QuadVertex vertices[] {
+            {{ 0.5f, -0.5f}, {1.0f, 0.0f}}, /* Bottom right */
+            {{ 0.5f,  0.5f}, {1.0f, 1.0f}}, /* Top right */
+            {{-0.5f, -0.5f}, {0.0f, 0.0f}}, /* Bottom left */
+            {{-0.5f,  0.5f}, {0.0f, 1.0f}}  /* Top left */
+    };
+    const UnsignedInt indices[]{        /* 3--1 1 */
+            0, 1, 2,                        /* | / /| */
+            2, 1, 3                         /* |/ / | */
+    };                                  /* 2 2--0 */
+
+    _mesh.setCount(Containers::arraySize(indices))
+            .addVertexBuffer(GL::Buffer{vertices}, 0,
+                             QuadShader::Position{},
+                             QuadShader::TextureCoordinates{})
+            .setIndexBuffer(GL::Buffer{indices}, 0,
+                            GL::MeshIndexType::UnsignedInt);
+
+    // ====================== Materials, resources, Textures =======================
+
+    PluginManager::Manager<Trade::AbstractImporter> manager;
+    Containers::Pointer<Trade::AbstractImporter> importer =
+            manager.loadAndInstantiate("TgaImporter");
+    const Utility::Resource rs{"texturedquad-data"};
+    if(!importer || !importer->openData(rs.getRaw("stone.tga")))
+        std::exit(1);
+
+    Containers::Optional<Trade::ImageData2D> image = importer->image2D(0);
+    CORRADE_INTERNAL_ASSERT(image);
+
+    _texture.setWrapping(GL::SamplerWrapping::ClampToEdge)
+            .setMagnificationFilter(GL::SamplerFilter::Linear)
+            .setMinificationFilter(GL::SamplerFilter::Linear)
+            .setStorage(1, GL::textureFormat(image->format()), image->size())
+            .setSubImage(0, {}, *image);
 }
 
 void MyApplication::drawEvent() {
@@ -35,7 +103,12 @@ void MyApplication::drawEvent() {
     GL::Renderer::setClearColor(Color4::red());
     GL::defaultFramebuffer.clear(GL::FramebufferClear::Color);
 
+    using namespace Math::Literals;
 
+    _shader
+            .setColor(0xffb2b2_rgbf)
+            .bindTexture(_texture)
+            .draw(_mesh);
 
     swapBuffers();
 }