v1.2 stage2

+ Add cubemap and skybox example(including split texture and total texture)
+ Add special models, i.e. cube
+ Add more ctor for models.
+ fix bugs
+ Adjust mouse dragging(still have some bugs in singular position)
+ Add or change some tests.

Author: Extra-Creativity

Resources/Configs/SkyboxConfig.ini

@@ -0,0 +1,18 @@
+# skybox credit: https://assetstore.unity.com/packages/2d/textures-materials/sky/fantasy-skybox-free-18353
+option = split
+[paths]
+sucrose = ../../../../../Resources/Models/Sucrose/Sucrose.pmx
+sucrose_vertex_shader = ../../../../../Shaders/SkyboxReflect.vert
+sucrose_fragment_shader =  ../../../../../Shaders/SkyboxReflect.frag
+split_skybox_dir = ../../../../../Resources/Models/Skybox/split/skybox.jpg
+skybox = ../../../../../Resources/Models/Skybox/FS000_Day_01.png
+skybox_vertex_shader= ../../../../../Shaders/Skybox.vert
+skybox_fragment_shader = ../../../../../Shaders/Skybox.frag
+
+# for debug
+cube = ../../../../../Resources/Models/Cube/CubeWithNormal.obj
+
+[window]
+name = Skybox Test
+width = 800
+height = 600

Resources/Models/Skybox/FS000_Day_01.png

@@ -0,0 +1,11 @@
+#version 330 core
+out vec4 FragColor;
+
+in vec3 TexCoords;
+
+uniform samplerCube skybox;
+
+void main()
+{    
+    FragColor = texture(skybox, TexCoords);
+}

Resources/Models/Skybox/FS000_Night_03.png

@@ -0,0 +1,14 @@
+#version 330 core
+layout (location = 0) in vec3 aPos;
+
+out vec3 TexCoords;
+
+uniform mat4 model;
+uniform mat4 projection;
+uniform mat4 view;
+
+void main()
+{
+    TexCoords = (aPos - vec3(0.5, 0.5, 0.5)) * 2; // aPos is in [0,1]
+    gl_Position = projection * view * model * vec4(aPos, 1.0);
+}

Resources/Models/Skybox/split/skybox_nx.jpg

@@ -0,0 +1,20 @@
+#version 330 core
+
+in vec3 position;
+in vec3 normal;
+in vec2 texCoords;
+
+uniform sampler2D diffuseTexture1;
+uniform samplerCube skybox;
+uniform vec3 cameraPos;
+
+out vec4 FragColor;
+
+void main()
+{
+    vec3 incident = normalize(position - cameraPos);
+    vec3 reflection = reflect(incident, normalize(normal));
+    FragColor = vec4(texture(skybox, reflection).rgb, 1.0) * 0.5 + 
+                        vec4(texture(diffuseTexture1, texCoords).rgb, 1.0) * 0.5;
+    return;
+}

Resources/Models/Skybox/split/skybox_ny.jpg

@@ -0,0 +1,22 @@
+#version 330 core
+
+layout(location = 0) in vec3 aPos;
+layout(location = 1) in vec3 aNormal;
+layout(location = 2) in vec2 aTexture;
+
+uniform mat4 model;
+uniform mat4 view;
+uniform mat4 projection;
+
+out vec3 position;
+out vec3 normal;
+out vec2 texCoords;
+
+void main()
+{
+    normal = mat3(transpose(inverse(model))) * aNormal;
+    position = vec3(model * vec4(aPos, 1.0));
+    texCoords = aTexture;
+    gl_Position = projection * view * model * vec4(aPos, 1.0);
+    return;
+}

Resources/Models/Skybox/split/skybox_nz.jpg

@@ -25,6 +25,15 @@ void SetMVP(float width, float height, float near, float far,
 	return;
 }
 
+void SetProjection(float width, float height, float near, float far, 
+	Core::Camera& camera, Core::Shader& shader)
+{
+	auto projectionMat = glm::perspective(glm::radians(camera.fov),
+		width / height, near, far);
+	shader.SetMat4("projection", projectionMat);
+	return;
+}
+
 inline void SetBasicKeyBindings(Core::MainWindow& mainWindow, Core::Camera& camera)
 {
     mainWindow.BindKeyPressing<GLFW_KEY_W>([&camera, &mainWindow]() {
@@ -85,6 +94,7 @@ inline void SetBasicButtonBindings(Core::MainWindow& mainWindow, Core::Camera& c
 	});
 
 	static bool lastNotDrag = false;
+	static float initCameraY = camera.GetPosition().y;
 	mainWindow.BindMouseButtonPressing<GLFW_MOUSE_BUTTON_RIGHT>([&mainWindow, &camera]() {
 		const auto [xPos, yPos] = mainWindow.GetCursorPos();
 		static float lastxPos = xPos, lastyPos = yPos;
@@ -96,10 +106,14 @@ inline void SetBasicButtonBindings(Core::MainWindow& mainWindow, Core::Camera& c
 			return;
 		}
 
+		glm::vec3 yAxis = glm::cross(camera.GetGaze(), {0, 1, 0});
+		if (glm::all(glm::epsilonEqual(yAxis, glm::zero<glm::vec3>(), glm::vec3{ 1e-4f })))
+			yAxis = { 1,0,0 };
+
 		camera.RotateAroundCenter(camera.mouseSensitivity * xOffset, { 0, 1, 0 },
-			{ 0, 10, 0 });
-		camera.RotateAroundCenter(camera.mouseSensitivity * yOffset, { 1, 0, 0 },
-			{ 0, 10, 0 });
+			{ 0, initCameraY, 0 });
+		camera.RotateAroundCenter(camera.mouseSensitivity * yOffset, yAxis,
+			{ 0, initCameraY, 0 });
 		});
 	mainWindow.BindMouseButtonReleasing<GLFW_MOUSE_BUTTON_RIGHT>([]() { lastNotDrag = true; });
 }

Resources/Models/Skybox/split/skybox_px.jpg

@@ -1,9 +1,7 @@
-#include "BasicSettings.h"
-
 #include "FrameworkCore/Core_All.h"
 #include "Utility/IO/IniFile.h"
-#include "Utility/IO/IOExtension.h"
 
+using namespace OpenGLFramework;
 int main()
 {
 	std::filesystem::path configPath = "../../../../../Resources/Configs/ShadowMapConfig.ini";

Resources/Models/Skybox/split/skybox_py.jpg

@@ -0,0 +1,77 @@
+#include "BasicSettings.h"
+
+#include "FrameworkCore/Core_All.h"
+#include "Utility/IO/IniFile.h"
+
+int main()
+{
+	std::filesystem::path configPath = "../../../../../Resources/Configs/SkyboxConfig.ini";
+	IOExtension::IniFile file{ configPath };
+
+	auto& pathsSection = file.rootSection.GetSubsection("paths")->get();
+	auto& windowSection = file.rootSection.GetSubsection("window")->get();
+	std::string windowName = windowSection("name");
+	unsigned int width = std::stoi(windowSection("width")),
+		height = std::stoi(windowSection("height"));
+
+	[[maybe_unused]] auto& contextManager = Core::ContextManager::GetInstance();
+	Core::MainWindow mainWindow{ width, height, windowName.c_str() };
+	
+	auto skyBox = file.rootSection("option") == "split" ? 
+		Core::SkyBoxTexture{ pathsSection("split_skybox_dir") } :
+		Core::SkyBoxTexture{ pathsSection("skybox"), 
+			Core::SkyBoxTexture::TextureSegmentType::HorizontalLeft 
+		};
+	Core::Shader skyBoxShader{
+		pathsSection("skybox_vertex_shader"),
+		pathsSection("skybox_fragment_shader")
+	};
+	Core::BasicTriRenderModel cube = Core::Cube::GetBasicTriRenderModel();
+	cube.transform.scale = { 10, 10, 10 };
+	cube.transform.Translate({ -0.5,-0.5,-0.5 });
+
+	Core::BasicTriRenderModel sucroseModel{ pathsSection("sucrose") };
+	Core::Shader sucroseShader{
+		pathsSection("sucrose_vertex_shader"),
+		pathsSection("sucrose_fragment_shader")
+	};
+	sucroseModel.transform.scale = { 0.1, 0.1, 0.1 };
+
+	float near = 0.1f, far = 100.0f;
+
+	Core::Camera frontCamera{ { 0, 1, 3.5}, {0, 1, 0}, {0, 0, -1} };
+	auto initialViewMatTranslation = frontCamera.GetViewMatrix()[3];
+	SetBasicKeyBindings(mainWindow, frontCamera);
+	SetBasicButtonBindings(mainWindow, frontCamera);
+
+	auto BindSkybox = [&skyBox](int textureBeginID, Core::Shader& shader)
+	{
+		glActiveTexture(GL_TEXTURE0 + textureBeginID);
+		shader.SetInt("skybox", textureBeginID);
+		glBindTexture(GL_TEXTURE_CUBE_MAP, skyBox.GetID());
+	};
+
+	mainWindow.Register([&]() {
+		sucroseShader.Activate();
+		SetMVP(static_cast<float>(width), static_cast<float>(height), 
+			static_cast<float>(near), static_cast<float>(far), 
+			sucroseModel, frontCamera, sucroseShader);
+		sucroseShader.SetVec3("cameraPos", frontCamera.GetPosition());
+		sucroseModel.Draw(sucroseShader, BindSkybox, nullptr);
+	});
+
+	mainWindow.Register([&]() {
+		glDepthFunc(GL_LEQUAL);
+		skyBoxShader.Activate();
+		skyBoxShader.SetMat4("model", cube.transform.GetModelMatrix());
+		auto viewMat = glm::mat4{ glm::mat3{ frontCamera.GetViewMatrix() } };
+		viewMat[3] = initialViewMatTranslation;
+		skyBoxShader.SetMat4("view", viewMat);
+		SetProjection(width, height, near, far, frontCamera, skyBoxShader);
+		cube.Draw(skyBoxShader, BindSkybox, nullptr);
+		glDepthFunc(GL_LESS);
+	});
+
+	mainWindow.MainLoop({ 0.0, 0.0, 0.0, 0.0 });
+	return 0;
+}

Resources/Models/Skybox/split/skybox_pz.jpg

@@ -225,6 +225,8 @@ Core::MainWindow LoadMainWindow(IOExtension::IniFile<std::unordered_map>& file)
 	return { width, height, windowName.c_str() };
 }
 
+void Increment(auto& it) { it++; }
+
 int main()
 {
 	std::filesystem::path configPath = "../../../../../Resources/Configs/SoftShadowConfig.ini";
@@ -249,17 +251,17 @@ int main()
 	SetBasicButtonBindings(mainWindow, normalCamera);
 
 	auto lightSetter = SetLightPosition(lightSpaceCamera);
-	mainWindow.Register(std::bind<void(IterType&, int)>(
-		std::advance<IterType, int>, lightSetter.begin(), 1)
+	mainWindow.Register(std::bind(
+		Increment<IterType>, lightSetter.begin())
 	);
 	int option = 1;
 	auto shadowOptionSetter = SetShadowOption(option);
-	mainWindow.Register(std::bind<void(IterType&, int)>(
-		std::advance<IterType, int>, shadowOptionSetter.begin(), 1)
+	mainWindow.Register(std::bind(
+		Increment<IterType>, shadowOptionSetter.begin())
 	);
 	auto basicInfoShow = ShowBasicInfo(mainWindow);
-	mainWindow.Register(std::bind<void(IterType&, int)>(
-		std::advance<IterType, int>, basicInfoShow.begin(), 1)
+	mainWindow.Register(std::bind(
+		Increment<IterType>, basicInfoShow.begin())
 	);
 
 	mainWindow.Register(std::bind(RenderShadowMap, 

Resources/Models/Skybox/test.png

@@ -1,29 +1,12 @@
-target("BlinnPhong")
-    set_kind("binary")
-    add_includedirs("../src/")
-    add_headerfiles("./*.h")
-    add_deps("OpenGLFramework")
-    add_files("BlinnPhong.cpp")
-
-target("ShadowMap")
-    set_kind("binary")
-    add_includedirs("../src/")
-    add_headerfiles("./*.h")
-    add_deps("OpenGLFramework")
-    add_files("ShadowMap.cpp")
+for _, file in ipairs(os.files("./*.cpp")) do
 
-target("SoftShadow")
+target(path.basename(file))
     set_kind("binary")
     add_includedirs("../src/")
-    add_headerfiles("./*.h")
+    add_headerfiles("*.h")
     add_deps("OpenGLFramework")
-    add_files("SoftShadow.cpp")
+    add_files(file)
 
-target("BasicFilters")
-    set_kind("binary")
-    add_includedirs("../src/")
-    add_headerfiles("./*.h")
-    add_deps("OpenGLFramework")
-    add_files("BasicFilters.cpp")
+end
 
 includes("complex-examples")

Shaders/Skybox.frag

@@ -81,6 +81,8 @@ class Camera
     }
 
     glm::vec3 GetPosition() const { return position_; };
+    glm::vec3 GetGaze() const { return gaze_; }
+    glm::vec3 GetUp() const { return up_; }
 private:
     // Note that this sequence is deliberate, so that up will be initialized after front.
     glm::vec3 position_;

Shaders/Skybox.vert

@@ -4,3 +4,5 @@
 #include "FrameworkCore/Shader.h"
 #include "FrameworkCore/Camera.h"
 #include "FrameworkCore/Framebuffer.h"
+#include "FrameworkCore/SkyboxTexture.h"
+#include "FrameworkCore/SpecialModels/SpecialModel.h"

Shaders/SkyboxReflect.frag

@@ -28,6 +28,11 @@ BasicTriMesh::BasicTriMesh(const aiMesh* mesh): vertices(mesh->mNumVertices),
     return;
 }
 
+BasicTriMesh::BasicTriMesh(std::vector<glm::vec3> init_vertices,
+    std::vector<glm::ivec3> init_triangles) : 
+    vertices{std::move(init_vertices)}, triangles{std::move(init_triangles)}
+{};
+
 std::vector<glm::vec3> BasicTriMesh::GetRealTriNormals()
 {
     std::vector<glm::vec3> normals(triangles.size());
@@ -200,6 +205,16 @@ BasicTriRenderMesh::BasicTriRenderMesh(const aiMesh* mesh,
     return;
 };
 
+BasicTriRenderMesh::BasicTriRenderMesh(BasicTriMesh mesh,
+    const std::vector<glm::vec3>& init_normals) : 
+    BasicTriMesh{ std::move(mesh) }, verticesAttributes(init_normals.size())
+{
+    for (int i = 0; i < verticesAttributes.size(); i++)
+        verticesAttributes[i].normalCoord = init_normals[i];
+    SetupRenderResource_();
+    return;
+};
+
 void BasicTriRenderMesh::ReleaseRenderResources_()
 {
     glDeleteBuffers(1, &VBO);

Shaders/SkyboxReflect.vert

@@ -38,6 +38,8 @@ class BasicTriMesh
     std::vector<glm::vec3> vertices;
     std::vector<glm::ivec3> triangles;
     BasicTriMesh(const aiMesh* mesh);
+    BasicTriMesh(std::vector<glm::vec3> init_vertices, 
+        std::vector<glm::ivec3> init_triangles);
     std::vector<glm::vec3> GetRealTriNormals();
     std::vector<glm::vec3> GetRealVertexNormals();
 };
@@ -49,6 +51,8 @@ class BasicTriRenderMesh : public BasicTriMesh
     std::vector<std::reference_wrapper<Texture>> diffuseTextureRefs;
     std::vector<std::reference_wrapper<Texture>> specularTextureRefs;
 
+    BasicTriRenderMesh(BasicTriMesh mesh, 
+        const std::vector<glm::vec3>& init_normals);
     BasicTriRenderMesh(const aiMesh* mesh, const aiMaterial* material, 
         TexturePool& texturePool, const std::filesystem::path& rootPath);
     BasicTriRenderMesh(const BasicTriRenderMesh&) = delete;

examples/BasicSettings.h

@@ -13,7 +13,7 @@ BasicTriModel::BasicTriModel(const std::filesystem::path& modelPath)
 {
     Assimp::Importer importer;
     const aiScene* model = importer.ReadFile(modelPath.string(),
-        aiProcess_Triangulate | aiProcess_GenSmoothNormals | aiProcess_FlipUVs
+        aiProcess_Triangulate | aiProcess_FlipUVs
         | aiProcess_JoinIdenticalVertices);
     if (model == nullptr || (model->mFlags & AI_SCENE_FLAGS_INCOMPLETE) != 0 ||
         model->mRootNode == nullptr) [[unlikely]]
@@ -25,6 +25,10 @@ BasicTriModel::BasicTriModel(const std::filesystem::path& modelPath)
     return;
 }
 
+BasicTriModel::BasicTriModel(std::vector<BasicTriMesh> init_meshes):
+    meshes{std::move(init_meshes)}
+{};
+
 void BasicTriModel::LoadResources_(const aiScene* model)
 {
     LoadResourcesDecorator_(model,
@@ -54,12 +58,17 @@ void BasicTriRenderModel::LoadResources_(const aiScene* model,
     stbi_set_flip_vertically_on_load(false);
 }
 
+BasicTriRenderModel::BasicTriRenderModel(std::vector<BasicTriRenderMesh> 
+    init_meshes) : meshes{ std::move(init_meshes) }
+{ };
+
 BasicTriRenderModel::BasicTriRenderModel(const std::filesystem::path& modelPath, 
     bool textureNeedFlip)
 {
     Assimp::Importer importer;
     const aiScene* model = importer.ReadFile(modelPath.string(), 
-        aiProcess_Triangulate | aiProcess_GenSmoothNormals | aiProcess_FlipUVs);
+        aiProcess_Triangulate | aiProcess_GenSmoothNormals | aiProcess_FlipUVs
+        | aiProcess_JoinIdenticalVertices);
     if (model == nullptr || (model->mFlags & AI_SCENE_FLAGS_INCOMPLETE) != 0 ||
         model->mRootNode == nullptr) [[unlikely]]
     {