Texture

CMakeLists.txt

@@ -88,12 +88,23 @@ add_library(imgui STATIC
         ${IMGUI_DIR}/backends/imgui_impl_sdlgpu3.cpp
         ${IMGUI_DIR}/misc/cpp/imgui_stdlib.cpp
 )
-target_include_directories(imgui PUBLIC
+target_include_directories(imgui SYSTEM PUBLIC
         ${IMGUI_DIR}
         ${IMGUI_DIR}/backends
 )
 target_link_libraries(imgui PUBLIC SDL3::SDL3)
 
+FetchContent_Declare(
+        stb
+        GIT_REPOSITORY https://github.com/nothings/stb.git
+        GIT_TAG master
+        GIT_SHALLOW TRUE
+        GIT_PROGRESS TRUE
+)
+FetchContent_MakeAvailable(stb)
+add_library(stb INTERFACE)
+target_include_directories(stb SYSTEM INTERFACE ${stb_SOURCE_DIR})
+
 FetchContent_Declare(
         googletest
         GIT_REPOSITORY https://github.com/google/googletest.git
@@ -111,10 +122,26 @@ add_subdirectory(sdl_wrapper)
 add_subdirectory(glsl_reflector)
 
 add_executable(SDL_TEST main.cpp)
-target_link_libraries(SDL_TEST PRIVATE imgui sdl_wrapper)
-
+target_link_libraries(SDL_TEST PRIVATE imgui sdl_wrapper stb)
 
 include(GNUInstallDirs)
 install(TARGETS SDL_TEST
         RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}
-)
+)
+
+set(ASSETS_DST_DIR ${CMAKE_BINARY_DIR}/assets)
+file(MAKE_DIRECTORY ${ASSETS_DST_DIR})
+
+set(TEST_TEXTURE_PATH ${ASSETS_DST_DIR}/test_texture.png)
+
+if (NOT EXISTS ${TEST_TEXTURE_PATH})
+    file(DOWNLOAD
+            "https://opengameart.org/sites/default/files/slime_25.png"
+            "${TEST_TEXTURE_PATH}"
+            SHOW_PROGRESS
+    )
+endif()
+
+install(DIRECTORY ${ASSETS_DST_DIR}/
+        DESTINATION ${CMAKE_INSTALL_BINDIR}/assets
+)

README.md

@@ -0,0 +1,22 @@
+# SDL Test
+
+This is a personal learning project following [Learn OpenGL](https://learnopengl.com/)
+
+## Track
+
+- [ ] Getting started
+  - [x] OpenGL
+  - [x] Creating a window
+  - [x] Hello Window
+  - [x] Hello Triangle
+  - [x] Shaders
+  - [x] Textures
+  - [ ] Transformations
+  - [ ] Coordinate Systems
+  - [ ] Camera
+- [ ] Lighting
+- [ ] Model Loading
+- [ ] Advanced OpenGL
+- [ ] Advanced Lighting
+- [ ] PBR
+- [ ] In Practice

data_type/modules/data_type.ixx

@@ -2,19 +2,26 @@
 // Created by sophomore on 11/23/25.
 //
 module;
-#include<expected>
+#include <cstdint>
+#include <expected>
+#include <string>
+#include <vector>
 export module data_type;
 
-export namespace sopho {
-    enum class GpuError {
+export namespace sopho
+{
+    enum class GpuError
+    {
         UNINITIALIZED,
         CREATE_DEVICE_FAILED,
         CREATE_WINDOW_FAILED,
         CLAIM_WINDOW_FAILED,
         CREATE_GPU_BUFFER_FAILED,
         CREATE_TRANSFER_BUFFER_FAILED,
+        CREATE_TEXTURE_FAILED,
         CREATE_SHADER_FAILED,
         CREATE_PIPELINE_FAILED,
+        CREATE_SAMPLER_FAILED,
         GET_TEXTUREFORMAT_FAILED,
         BUFFER_OVERFLOW,
         MAP_TRANSFER_BUFFER_FAILED,
@@ -26,6 +33,39 @@ export namespace sopho {
     };
 
     using TError = GpuError;
-    template<typename T>
+    template <typename T>
     using checkable = std::expected<T, TError>;
-}
+
+    struct ImageData
+    {
+        int width{};
+        int height{};
+        int channels{};
+        std::vector<std::byte> pixels{};
+    };
+
+    enum class BasicType : std::uint8_t
+    {
+        NONE,
+        FLOAT
+    };
+
+    struct VertexInfo
+    {
+        std::uint32_t location{};
+        std::string name{};
+        BasicType basic_type{};
+        int vector_size{};
+    };
+
+    struct VertexReflection
+    {
+        std::vector<VertexInfo> inputs{};
+    };
+
+    struct FragmentReflection
+    {
+        std::uint32_t sampler_count{};
+    };
+
+} // namespace sopho

glsl_reflector/CMakeLists.txt

@@ -8,10 +8,9 @@ target_sources(glsl_reflector
         PUBLIC
         FILE_SET cxx_modules TYPE CXX_MODULES FILES
         modules/glsl_reflector.ixx
-        modules/glsl_reflector.type.ixx
 )
 
-target_link_libraries(glsl_reflector PUBLIC glslang glslang::glslang-default-resource-limits)
+target_link_libraries(glsl_reflector PUBLIC glslang glslang::glslang-default-resource-limits data_type)
 
 add_executable(glslr test/test.cpp)
 

glsl_reflector/modules/glsl_reflector.ixx

@@ -10,7 +10,7 @@ module;
 #include "glslang/Public/ResourceLimits.h"
 #include "glslang/Public/ShaderLang.h"
 export module glsl_reflector;
-export import :type;
+export import data_type;
 
 namespace sopho
 {
@@ -82,6 +82,59 @@ namespace sopho
                                                   .basic_type = to_basic_type(type->getBasicType()),
                                                   .vector_size = type->getVectorSize()});
         }
+        count = program.getNumUniformVariables();
+        for (auto i = 0; i < count; i++)
+        {
+            auto var = program.getUniform(i);
+        }
+        return result;
+    }
+
+    export auto reflect_fragment(const std::string& fragment_source)
+    {
+        GlslangProcessGuard glslang_initializer{};
+        FragmentReflection result{};
+        glslang::TShader shader(EShLangFragment);
+        std::vector sources{fragment_source.data()};
+        shader.setStrings(sources.data(), sources.size());
+
+        int clientInputSemanticsVersion = 100; // not used for desktop GL
+        glslang::EShTargetClientVersion clientVersion = glslang::EShTargetOpenGL_450;
+        glslang::EShTargetLanguageVersion targetVersion = glslang::EShTargetSpv_1_0;
+
+        shader.setEnvInput(glslang::EShSourceGlsl, EShLangFragment, glslang::EShClientOpenGL,
+                           clientInputSemanticsVersion);
+        shader.setEnvClient(glslang::EShClientOpenGL, clientVersion);
+        shader.setEnvTarget(glslang::EShTargetSpv, targetVersion);
+
+        EShMessages messages = (EShMessages)(EShMsgDefault | EShMsgSpvRules | EShMsgVulkanRules);
+
+        if (!shader.parse(GetDefaultResources(), 450, ENoProfile, false, false, messages))
+        {
+            std::cerr << "Parse failed:\n" << shader.getInfoLog() << std::endl;
+            return result;
+        }
+
+        glslang::TProgram program;
+        program.addShader(&shader);
+        if (!program.link(messages))
+        {
+            std::cerr << "Link failed:\n" << program.getInfoLog() << std::endl;
+            return result;
+        }
+        program.buildReflection();
+        auto count = program.getNumUniformVariables();
+        for (auto i = 0; i < count; i++)
+        {
+            auto var = program.getUniform(i);
+            auto type = var.getType();
+            auto basic_type = type->getBasicType();
+            if (basic_type == glslang::EbtSampler)
+            {
+                result.sampler_count++;
+            }
+        }
         return result;
     }
+
 } // namespace sopho

glsl_reflector/test/test.cpp

@@ -36,3 +36,41 @@ TEST(reflect_vertex, Basic)
     EXPECT_EQ(reflect_info.inputs[1].basic_type, sopho::BasicType::FLOAT);
     EXPECT_EQ(reflect_info.inputs[1].vector_size, 3);
 }
+
+
+TEST(reflect_fragment, Basic)
+{
+    auto reflect_info = sopho::reflect_fragment(R"(
+#version 460
+
+layout (location = 0) in vec4 v_color;
+layout (location = 0) out vec4 FragColor;
+
+layout(set = 2, binding = 0) uniform sampler2D uTexture;
+
+void main()
+{
+    FragColor = texture(uTexture, v_color.xy);
+}
+    )");
+    EXPECT_EQ(reflect_info.sampler_count, 1);
+}
+
+TEST(reflect_fragment, Multi)
+{
+    auto reflect_info = sopho::reflect_fragment(R"(
+#version 460
+
+layout (location = 0) in vec4 v_color;
+layout (location = 0) out vec4 FragColor;
+
+layout(set = 2, binding = 0) uniform sampler2D uTexture;
+layout(set = 2, binding = 1) uniform sampler2D uTexture1;
+
+void main()
+{
+    FragColor = texture(uTexture, v_color.xy) + texture(uTexture1, v_color.xy);
+}
+    )");
+    EXPECT_EQ(reflect_info.sampler_count, 2);
+}