Model is now transformable

.gitmodules

@@ -0,0 +1,3 @@
+[submodule "vendor/assimp"]
+	path = vendor/assimp
+	url = https://github.com/assimp/assimp

CMakeLists.txt

@@ -24,6 +24,8 @@ if(WIN32)
 	endif()
 endif()
 
+add_subdirectory("vendor/assimp")
+
 file(GLOB_RECURSE include_files 
 	"include/*.hpp"
 )
@@ -37,18 +39,27 @@ add_library(openglu SHARED
 	${include_files}
 	${source_files}
 	"cpp.hint"
- "src/core.cpp")
+	"src/core.cpp"
+ )
 
 target_compile_definitions(openglu PRIVATE OGLU_BUILD_DLL)
 
 include_directories(
 	include
 	vendor/include
+	vendor/assimp/include
+	${CMAKE_BINARY_DIR}/vendor/assimp/include
 )
 
 target_include_directories(openglu PUBLIC
 	include
 	vendor/include
+	vendor/assimp/include
+	${CMAKE_BINARY_DIR}/vendor/assimp/include
+)
+
+target_link_libraries(openglu PUBLIC
+	assimp
 )
 
 if(${BUILD_DOCUMENTATION})

examples/debug/main.cpp

@@ -99,8 +99,8 @@ int main(int argc, char** argv)
 	}
 
 	// Create a texture
-	oglu::Texture crate = oglu::MakeTexture("assets/crate.jpg");
-	oglu::Texture opengl = oglu::MakeTexture("assets/opengl.png");
+	oglu::Texture crate = oglu::MakeTexture("assets/crate.jpg", "crate");
+	oglu::Texture opengl = oglu::MakeTexture("assets/opengl.png", "opengl");
 
 	oglu::Camera camera;
 

examples/model/CMakeLists.txt

@@ -0,0 +1,34 @@
+add_executable(model 
+	"main.cpp"
+)
+
+find_package(glfw3 REQUIRED)
+
+target_include_directories(model PRIVATE 
+	glfw
+)
+
+target_link_libraries(model PRIVATE 
+	glfw
+)
+
+if(WIN32)
+	target_link_libraries(model PRIVATE
+		"$<TARGET_FILE_DIR:openglu>/$<TARGET_FILE_BASE_NAME:openglu>.lib"
+	)
+else()
+	target_link_libraries(model PRIVATE
+		$<TARGET_FILE:openglu>
+	)
+endif()
+
+add_custom_command(TARGET model POST_BUILD
+	COMMAND ${CMAKE_COMMAND} -E copy_directory ${CMAKE_CURRENT_SOURCE_DIR}/shaders $<TARGET_FILE_DIR:model>/shaders
+	COMMAND ${CMAKE_COMMAND} -E copy_directory ${CMAKE_CURRENT_SOURCE_DIR}/assets $<TARGET_FILE_DIR:model>/assets
+)
+
+if(WIN32)
+	add_custom_command(TARGET model POST_BUILD
+		COMMAND ${CMAKE_COMMAND} -E copy $<TARGET_FILE:openglu> $<TARGET_FILE:glfw> $<TARGET_FILE:assimp> $<TARGET_FILE_DIR:model>
+	)
+endif()

examples/model/assets/backpack.mtl

@@ -0,0 +1,16 @@
+# Blender MTL File: 'None'
+# Material Count: 1
+
+newmtl Scene_-_Root
+Ns 225.000000
+Ka 1.000000 1.000000 1.000000
+Kd 0.800000 0.800000 0.800000
+Ks 0.500000 0.500000 0.500000
+Ke 0.0 0.0 0.0
+Ni 1.450000
+d 1.000000
+illum 2
+map_Kd diffuse.jpg
+map_Bump normal.png
+map_Ks specular.jpg
+

examples/model/assets/source_attribution.txt

@@ -0,0 +1,3 @@
+Model by Berk Gedik, from: https://sketchfab.com/3d-models/survival-guitar-backpack-low-poly-799f8c4511f84fab8c3f12887f7e6b36
+
+Modified material assignment (Joey de Vries) for easier load in OpenGL model loading chapter, and renamed albedo to diffuse and metallic to specular to match non-PBR lighting setup.

examples/model/main.cpp

@@ -0,0 +1,170 @@
+#include <iostream>
+#include <vector>
+
+#include "openglu.hpp"
+#include <GLFW/glfw3.h>
+#include <glm/gtc/type_ptr.hpp>
+#include <glm/gtx/string_cast.hpp>
+
+bool firstMouse = true;
+bool escaped = false;
+double lastX = 0.0f;
+double lastY = 0.0f;
+
+oglu::Camera camera(45.0f, 16.f / 9.f, 0.01f, 100.0f);
+
+void framebuffer_size_callback(GLFWwindow* window, int width, int height)
+{
+	oglu::SetViewport(0, 0, width, height);
+	camera.aspectRatio = ((float)width / (float)height);
+}
+
+void mouse_callback(GLFWwindow* window, double xpos, double ypos)
+{
+	if (escaped)
+		return;
+
+	if (firstMouse)
+	{
+		lastX = xpos;
+		lastY = ypos;
+		firstMouse = false;
+	}
+
+	float xoffset = (float)xpos - (float)lastX;
+	float yoffset = (float)lastY - (float)ypos;
+	lastX = xpos;
+	lastY = ypos;
+
+	float sensitivity = 0.1f;
+	xoffset *= sensitivity;
+	yoffset *= sensitivity;
+
+	camera.Pan(-xoffset);
+	camera.Tilt(yoffset);
+}
+
+void key_callback(GLFWwindow* window, int key, int scancode, int action, int mods)
+{
+	if (key == GLFW_KEY_ESCAPE && action == GLFW_RELEASE)
+	{
+		escaped = !escaped;
+		firstMouse = true;
+		glfwSetInputMode(window, GLFW_CURSOR, escaped ? GLFW_CURSOR_NORMAL : GLFW_CURSOR_DISABLED);
+	}
+}
+
+void processInput(GLFWwindow* window)
+{
+	if (glfwGetKey(window, GLFW_KEY_W) == GLFW_PRESS)
+		camera.SetPosition(camera.GetPosition() + 0.1f * glm::normalize(glm::vec3(camera.GetFront().x, 0.0f, camera.GetFront().z)));
+
+	if (glfwGetKey(window, GLFW_KEY_A) == GLFW_PRESS)
+		camera.Sideways(-0.1f);
+
+	if (glfwGetKey(window, GLFW_KEY_S) == GLFW_PRESS)
+		camera.SetPosition(camera.GetPosition() - 0.1f * glm::normalize(glm::vec3(camera.GetFront().x, 0.0f, camera.GetFront().z)));
+
+	if (glfwGetKey(window, GLFW_KEY_D) == GLFW_PRESS)
+		camera.Sideways(0.1f);
+
+	if (glfwGetKey(window, GLFW_KEY_SPACE) == GLFW_PRESS)
+		camera.Move(0.0f, 0.1f, 0.0f);
+
+	if (glfwGetKey(window, GLFW_KEY_LEFT_SHIFT) == GLFW_PRESS)
+		camera.Move(0.0f, -0.1f, 0.0f);
+}
+
+int main(int argc, char** argv)
+{
+	// Setup GLFW
+	glfwInit();
+	glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 4);
+	glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 6);
+	glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);
+
+	const GLFWvidmode* screen = glfwGetVideoMode(glfwGetPrimaryMonitor());
+	int windowHeight = screen->height / 5 * 4;
+	int windowWidth = (int)(16.f / 9.f * windowHeight);
+
+	// Create Window
+	GLFWwindow* window = glfwCreateWindow(windowWidth, windowHeight, "Model loading test", NULL, NULL);
+	if (window == nullptr)
+	{
+		std::cerr << "Failed to create GLFW window" << std::endl;
+		glfwTerminate();
+		return -1;
+	}
+	glfwMakeContextCurrent(window);
+	glfwSetFramebufferSizeCallback(window, framebuffer_size_callback);
+	glfwSetCursorPosCallback(window, mouse_callback);
+	glfwSetKeyCallback(window, key_callback);
+
+	// glad stuff
+	oglu::LoadGLLoader((GLADloadproc)glfwGetProcAddress);
+	oglu::SetViewport(0, 0, windowWidth, windowHeight);
+
+	// Create a shader
+	oglu::Shader shader;
+	try
+	{
+		shader = oglu::MakeShader("shaders/vertexShader.vert", "shaders/fragmentShader.frag");
+	}
+	catch (const std::runtime_error& e)
+	{
+		std::cerr << e.what() << std::endl;
+		return -1;
+	}
+
+	camera.Move(0.0f, 0.0f, 5.0f);
+
+	// Window loop
+	oglu::Enable(GL_DEPTH_TEST);
+
+	glfwSetInputMode(window, GLFW_CURSOR, GLFW_CURSOR_DISABLED);
+
+	oglu::Color bgColor = oglu::Color::Black;
+
+	oglu::Model model("assets/backpack.obj");
+
+	oglu::SpotLight flashlight;
+	flashlight.linear = 0.022f;
+	flashlight.quadratic = 0.0019f;
+	flashlight.angle = 18.0f;
+	flashlight.outerAngle = 24.9f;
+
+	while (!glfwWindowShouldClose(window))
+	{
+		processInput(window);
+		oglu::ClearScreen(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT, bgColor);
+
+		flashlight.SetPosition(camera.GetPosition());
+		flashlight.direction = camera.GetFront();
+
+		shader->Use();
+
+		shader->SetUniformMatrix3fv("normal", 1, GL_FALSE, glm::value_ptr(model.GetNormalMatrix()));
+		shader->SetUniformMatrix4fv("model", 1, GL_FALSE, glm::value_ptr(model.GetMatrix()));
+		shader->SetUniformMatrix4fv("view", 1, GL_FALSE, glm::value_ptr(camera.GetMatrix()));
+		shader->SetUniformMatrix4fv("projection", 1, GL_FALSE, glm::value_ptr(camera.GetProjection()));
+
+		shader->SetUniform3fv("flashlight.position", 1, flashlight.GetPositionPointer());
+		shader->SetUniform3fv("flashlight.direction", 1, glm::value_ptr(flashlight.direction));
+		shader->SetUniform("flashlight.angle", glm::cos(glm::radians(flashlight.angle)));
+		shader->SetUniform("flashlight.outerAngle", glm::cos(glm::radians(flashlight.outerAngle)));
+		shader->SetUniform("flashlight.constant", flashlight.constant);
+		shader->SetUniform("flashlight.linear", flashlight.linear);
+		shader->SetUniform("flashlight.quadratic", flashlight.quadratic);
+
+		model.Render(shader);
+		
+		model.Rotate(1.0f, glm::vec3(0.0f, 1.0f, 0.0f));
+
+		glfwSwapBuffers(window);
+		glfwPollEvents();
+
+	}
+
+	glfwTerminate();
+	return 0;
+}

examples/model/shaders/fragmentShader.frag

@@ -0,0 +1,46 @@
+#version 330 core
+struct Material
+{
+	sampler2D tex_diffuse1;
+	sampler2D tex_specular1;
+};
+
+struct SpotLight
+{
+	vec3 position, direction;
+	float angle, outerAngle;
+	float constant, linear, quadratic;
+};
+
+in vec3 oNormal;
+in vec2 oUV;
+in vec3 oFragPos;
+
+out vec4 FragColor;
+
+uniform Material material;
+uniform SpotLight flashlight;
+
+void main()
+{
+	vec3 lightDir = normalize(flashlight.position - oFragPos);
+
+	float theta = dot(lightDir, normalize(-flashlight.direction));
+	float epsilon = flashlight.angle - flashlight.outerAngle;
+	float intensity = clamp((theta - flashlight.outerAngle) / epsilon, 0.0, 1.0);
+
+	float diff = max(dot(oNormal, lightDir), 0.0);
+
+	vec3 reflectDir = reflect(-lightDir, oNormal);
+	float spec = pow(max(dot(lightDir, reflectDir), 0.0), 32.0);
+
+	float dist = length(flashlight.position - oFragPos);
+	float attenuation = 1.0 / (flashlight.constant + flashlight.linear * dist + flashlight.quadratic * dist * dist);
+
+	vec3 diffuse = vec3(1.0) * diff * vec3(texture(material.tex_diffuse1, oUV));
+	vec3 specular = vec3(1.0) * spec * vec3(texture(material.tex_specular1, oUV));
+	vec3 ambient = vec3(0.1) * vec3(texture(material.tex_diffuse1, oUV));
+
+	FragColor = vec4(ambient + (diffuse + specular) * intensity * attenuation, 1.0);
+	// FragColor = vec4(vec3(texture(material.tex_diffuse1, oUV)), 1.0);
+}

examples/model/shaders/vertexShader.vert

@@ -0,0 +1,23 @@
+#version 330 core
+
+layout (location = 0) in vec3 aPos;
+layout (location = 1) in vec3 aNormal;
+layout (location = 2) in vec2 aUV;
+
+out vec3 oNormal;
+out vec2 oUV;
+out vec3 oFragPos;
+
+uniform mat3 normal;
+uniform mat4 model;
+uniform mat4 view;
+uniform mat4 projection;
+
+void main()
+{
+	oNormal = normal * aNormal;
+	oUV = aUV;
+
+	gl_Position = projection * view * model * vec4(aPos, 1.0);
+	oFragPos = vec3(model * vec4(aPos, 1.0));
+}

examples/movement/main.cpp

@@ -172,8 +172,8 @@ int main(int argc, char** argv)
 
 	//cubeMaterial->AddProperty("ambient", oglu::Color::White);
 	cubeMaterial->AddProperty("shininess", 32.f);
-	cubeMaterial->AddProperty("diffuse", oglu::MakeTexture("assets/tiles_diffuse.jpg"));
-	cubeMaterial->AddProperty("specular", oglu::MakeTexture("assets/tiles_bump.jpg"));
+	cubeMaterial->AddProperty("diffuse", oglu::MakeTexture("assets/tiles_diffuse.jpg", "diffuse"));
+	cubeMaterial->AddProperty("specular", oglu::MakeTexture("assets/tiles_bump.jpg", "specular"));
 
 	oglu::Object cubes[10] = { 
 		oglu::Object(cubeDefault),
@@ -395,4 +395,4 @@ int main(int argc, char** argv)
 
 	glfwTerminate();
 	return 0;
-}
+}

include/model/mesh.hpp

@@ -0,0 +1,43 @@
+#ifndef MESH_HPP
+#define MESH_HPP
+
+#include <vector>
+
+#include <core.hpp>
+#include <glm/glm.hpp>
+
+#include <texture.hpp>
+#include <shader.hpp>
+#include <vertexArray.hpp>
+
+namespace oglu
+{
+	struct OGLU_API Vertex
+	{
+		glm::vec3 Position;
+		glm::vec3 Normal;
+		glm::vec2 UV;
+	};
+
+	class OGLU_API Mesh
+	{
+	public:
+		Mesh(const std::vector<Vertex>& vertices, 
+			 const std::vector<GLuint>& indices, 
+			 const std::vector<Texture>& textures);
+		void Render(Shader& shader);
+
+	private:
+		void CreateMesh();
+
+	public:
+		std::vector<Vertex>	vertices;
+		std::vector<GLuint> indices;
+		std::vector<Texture> textures;
+
+	private:
+		VertexArray VAO;
+	};
+}
+
+#endif

include/model/model.hpp

@@ -0,0 +1,33 @@
+#ifndef MODEL_HPP
+#define MODEL_HPP
+
+#include <vector>
+
+#include <core.hpp>
+#include <shader.hpp>
+#include <object.hpp>
+#include <model/mesh.hpp>
+
+#include <assimp/scene.h>
+
+namespace oglu
+{
+	class OGLU_API Model : public Transformable
+	{
+	public:
+		Model(const std::string& path);
+		void Render(Shader& shader);
+
+	private:
+		std::vector<Texture> loaded;
+		std::vector<Mesh> meshes;
+		std::string directory;
+
+		void LoadModel(const std::string& path);
+		void ProcessNode(aiNode* node, const aiScene* scene);
+		Mesh ProcessMesh(aiMesh* mesh, const aiScene* scene);
+		std::vector<Texture> LoadMaterialTextures(aiMaterial* mat, aiTextureType type, const std::string& typeName);
+	};
+}
+
+#endif

include/openglu.hpp

@@ -20,6 +20,9 @@
 #include <lighting/point.hpp>
 #include <lighting/spotlight.hpp>
 
+#include <model/mesh.hpp>
+#include <model/model.hpp>
+
 namespace oglu
 {
 	/**

include/texture.hpp

@@ -45,7 +45,7 @@ namespace oglu
 		 *
 		 * @return A shared pointer to the texture.
 		 */
-		friend Texture OGLU_API MakeTexture(const char* filename);
+		friend Texture OGLU_API MakeTexture(const char* filename, const std::string& name);
 
 		/**
 		 * @brief Copy constructor.
@@ -88,7 +88,11 @@ namespace oglu
 		 *
 		 * @param[in] vertexShaderFile Filepath to the image file
 		 */
-		AbstractTexture(const char* filename);
+		AbstractTexture(const char* filename, const std::string& name);
+
+	public:
+		std::string name;
+		std::string filepath;
 
 	private:
 		int width;		///< Width of the loaded image
@@ -97,7 +101,7 @@ namespace oglu
 		GLuint texture;	///< OpenGL handle to the texture
 	};
 
-	Texture OGLU_API MakeTexture(const char* filename);
+	Texture OGLU_API MakeTexture(const char* filename, const std::string& name);
 }
 
 #endif

src/model/mesh.cpp

@@ -0,0 +1,41 @@
+#include "model/mesh.hpp"
+
+#include <glm/gtc/type_ptr.hpp>
+
+namespace oglu
+{
+	Mesh::Mesh(const std::vector<Vertex>& vertices, const std::vector<GLuint>& indices, const std::vector<Texture>& textures) :
+		vertices(vertices), indices(indices), textures(textures)
+	{
+		CreateMesh();
+	}
+
+	void Mesh::Render(Shader& shader)
+	{
+		GLuint diffuseIndex = 1;
+		GLuint bumpIndex = 1;
+		
+		for (GLuint i = 0; i < textures.size(); i++)
+		{
+			textures[i]->BindAs(i);
+		}
+		ActiveTexture(0);
+
+		VAO->BindAndDraw();
+	}
+
+	void Mesh::CreateMesh()
+	{
+		VertexAttribute topology[] = {
+			{0, 3, GL_FLOAT, GL_FALSE, sizeof(Vertex), (void*)0},
+			{1, 3, GL_FLOAT, GL_FALSE, sizeof(Vertex), (void*)offsetof(Vertex, Normal)},
+			{2, 2, GL_FLOAT, GL_FALSE, sizeof(Vertex), (void*)offsetof(Vertex, UV)}
+		};
+
+		VAO = MakeVertexArray(
+			glm::value_ptr(vertices[0].Position), sizeof(Vertex) * vertices.size(),
+			&indices[0], sizeof(GLuint) * indices.size(),
+			topology, sizeof(topology)
+		);
+	}
+}

src/model/model.cpp

@@ -0,0 +1,120 @@
+#include "model/model.hpp"
+
+#include <assimp/Importer.hpp>
+#include <assimp/postprocess.h>
+
+namespace oglu
+{
+	Model::Model(const std::string& path)
+	{
+		LoadModel(path);
+	}
+
+	void Model::Render(Shader& shader)
+	{
+		for (Mesh& mesh : meshes)
+			mesh.Render(shader);
+	}
+
+	void Model::LoadModel(const std::string& path)
+	{
+		Assimp::Importer importer;
+		const aiScene* scene = importer.ReadFile(path, aiProcess_Triangulate | aiProcess_FlipUVs);
+
+		if (!scene || scene->mFlags && AI_SCENE_FLAGS_INCOMPLETE || !scene->mRootNode)
+		{
+			std::string errStr = importer.GetErrorString();
+			importer.FreeScene();
+			throw std::runtime_error(errStr);
+		}
+
+		directory = path.substr(0, path.find_last_of('/'));
+		ProcessNode(scene->mRootNode, scene);
+
+		importer.FreeScene();
+	}
+
+	void Model::ProcessNode(aiNode* node, const aiScene* scene)
+	{
+		for (GLuint i = 0; i < node->mNumMeshes; i++)
+		{
+			aiMesh* mesh = scene->mMeshes[node->mMeshes[i]];
+			meshes.push_back(ProcessMesh(mesh, scene));
+		}
+
+		for (GLuint i = 0; i < node->mNumChildren; i++)
+		{
+			ProcessNode(node->mChildren[i], scene);
+		}
+	}
+
+	Mesh Model::ProcessMesh(aiMesh* mesh, const aiScene* scene)
+	{
+		std::vector<Vertex> vertices;
+		std::vector<GLuint> indices;
+		std::vector<Texture> textures;
+
+		for (GLuint i = 0; i < mesh->mNumVertices; i++)
+		{
+			Vertex vertex;
+
+			vertex.Position = glm::vec3(mesh->mVertices[i].x, mesh->mVertices[i].y, mesh->mVertices[i].z);
+			vertex.Normal = glm::vec3(mesh->mNormals[i].x, mesh->mNormals[i].y, mesh->mNormals[i].z);
+
+			if (mesh->mTextureCoords[0])
+				vertex.UV = glm::vec2(mesh->mTextureCoords[0][i].x, mesh->mTextureCoords[0][i].y);
+			else
+				vertex.UV = glm::vec2(0.0f);
+
+			vertices.push_back(vertex);
+		}
+
+		for (GLuint i = 0; i < mesh->mNumFaces; i++)
+		{
+			aiFace face = mesh->mFaces[i];
+			for (GLuint j = 0; j < face.mNumIndices; j++)
+				indices.push_back(face.mIndices[j]);
+		}
+
+		if (mesh->mMaterialIndex >= 0)
+		{
+			aiMaterial* material = scene->mMaterials[mesh->mMaterialIndex];
+			std::vector<Texture> diffuseMaps = LoadMaterialTextures(material, aiTextureType_DIFFUSE, "tex_diffuse");
+			textures.insert(textures.end(), diffuseMaps.begin(), diffuseMaps.end());
+
+			std::vector<Texture> specularMaps = LoadMaterialTextures(material, aiTextureType_SPECULAR, "tex_spec");
+			textures.insert(textures.end(), specularMaps.begin(), specularMaps.end());
+		}
+
+		return Mesh(vertices, indices, textures);
+	}
+
+	std::vector<Texture> Model::LoadMaterialTextures(aiMaterial* mat, aiTextureType type, const std::string& typeName)
+	{
+		std::vector<Texture> textures;
+		
+		for (GLuint i = 0; i < mat->GetTextureCount(type); i++)
+		{
+			aiString str;
+			mat->GetTexture(type, i, &str);
+			bool skip = false;
+			for (GLuint j = 0; j < loaded.size(); j++)
+			{
+				if (std::strcmp(loaded[j]->filepath.data(), str.C_Str()))
+				{
+					textures.push_back(loaded[j]);
+					skip = true;
+					break;
+				}
+			}
+			if (!skip)
+			{
+				Texture texture = MakeTexture((directory + "/" + std::string(str.C_Str())).c_str(), typeName + std::to_string(i));
+				loaded.push_back(texture);
+				textures.push_back(texture);
+			}
+		}
+
+		return textures;
+	}
+}

src/texture.cpp

@@ -13,7 +13,7 @@ namespace oglu
 	}
 
 	AbstractTexture::AbstractTexture(const AbstractTexture& other) :
-		width(other.width), height(other.height), nrChannels(other.nrChannels), texture(other.texture)
+		width(other.width), height(other.height), nrChannels(other.nrChannels), texture(other.texture), name(other.name)
 	{
 	}
 
@@ -22,7 +22,8 @@ namespace oglu
 		glDeleteBuffers(1, &texture);
 	}
 
-	AbstractTexture::AbstractTexture(const char* filename)
+	AbstractTexture::AbstractTexture(const char* filename, const std::string& name) :
+		name(name), filepath(filename)
 	{
 		stbi_set_flip_vertically_on_load(true);
 		stbi_uc* data = stbi_load(filename, &width, &height, &nrChannels, 0);
@@ -57,9 +58,9 @@ namespace oglu
 		stbi_image_free(data);
 	}
 
-	Texture MakeTexture(const char* filename)
+	Texture MakeTexture(const char* filename, const std::string& name)
 	{
-		return std::shared_ptr<AbstractTexture>(new AbstractTexture(filename));
+		return std::shared_ptr<AbstractTexture>(new AbstractTexture(filename, name));
 	}
 
 	void AbstractTexture::Bind()

vendor/assimp

@@ -0,0 +1 @@
+Subproject commit d87d9f209448e6edb7c89ddda7a5b6dea71e35d1