Incorporate emissive material parameters (#64)

- Material: emissive texture, emissive factor.
- Camera: exposure.
- editor: inspect new params; WIP: drag-and-drop.

Author: karnkaul

.clang-format

@@ -28,3 +28,4 @@ IncludeCategories:
     - Regex: '<([A-Za-z0-9\/-_])+>'
       Priority: 30
 PointerAlignment: Left
+QualifierAlignment: Right

lib/engine/include/facade/engine/editor/inspector.hpp

@@ -54,7 +54,8 @@ class SceneInspector : public Inspector {
 	bool inspect(NotClosed<TreeNode>, UnlitMaterial& out_material) const;
 	bool inspect(NotClosed<TreeNode> node, LitMaterial& out_material) const;
 	bool inspect(Id<Material> material_id) const;
-	bool inspect(Id<Mesh> mesh) const;
+	bool inspect(Id<Mesh> mesh_id) const;
+	bool inspect(Id<Camera> camera_id) const;
 
 	bool inspect(Id<Node> node_id, Bool& out_unified_scaling) const;
 

lib/engine/include/facade/engine/scene_renderer.hpp

@@ -22,6 +22,7 @@ class SceneRenderer {
 	Buffer m_view_proj;
 	Buffer m_dir_lights;
 	Texture m_white;
+	Texture m_black;
 
 	std::vector<glm::mat4x4> m_instance_mats{};
 	Scene const* m_scene{};

lib/engine/src/editor/inspector.cpp

@@ -18,7 +18,7 @@ struct Modified {
 	}
 };
 
-using DragFloatFunc = bool (*)(const char*, float* v, float, float, float, const char*, ImGuiSliderFlags);
+using DragFloatFunc = bool (*)(char const*, float* v, float, float, float, char const*, ImGuiSliderFlags);
 
 constexpr DragFloatFunc drag_float_vtable[] = {
 	nullptr, &ImGui::DragFloat, &ImGui::DragFloat2, &ImGui::DragFloat3, &ImGui::DragFloat4,
@@ -153,14 +153,14 @@ bool Inspector::inspect(Lights& out_lights) const {
 bool Inspector::do_inspect(Transform& out_transform, Bool& out_unified_scaling, Bool scaling_toggle) const {
 	auto ret = Modified{};
 	auto vec3 = out_transform.position();
-	if (ret(inspect("Position", vec3))) { out_transform.set_position(vec3); }
+	if (ret(inspect("Position", vec3, 0.1f))) { out_transform.set_position(vec3); }
 	auto quat = out_transform.orientation();
 	if (ret(inspect("Orientation", quat))) { out_transform.set_orientation(quat); }
 	vec3 = out_transform.scale();
 	if (out_unified_scaling) {
-		if (ret(ImGui::DragFloat("Scale", &vec3.x, 0.1f))) { out_transform.set_scale({vec3.x, vec3.x, vec3.x}); }
+		if (ret(ImGui::DragFloat("Scale", &vec3.x, 0.05f))) { out_transform.set_scale({vec3.x, vec3.x, vec3.x}); }
 	} else {
-		if (ret(inspect("Scale", vec3, 0.1f))) { out_transform.set_scale(vec3); }
+		if (ret(inspect("Scale", vec3, 0.05f))) { out_transform.set_scale(vec3); }
 	}
 	if (scaling_toggle) {
 		ImGui::SameLine();
@@ -182,16 +182,28 @@ bool SceneInspector::inspect(NotClosed<TreeNode>, LitMaterial& out_material) con
 	ret(ImGui::SliderFloat("Metallic", &out_material.metallic, 0.0f, 1.0f));
 	ret(ImGui::SliderFloat("Roughness", &out_material.roughness, 0.0f, 1.0f));
 	ret(inspect_rgb("Albedo", out_material.albedo));
+	if (out_material.emissive) { ret(inspect_rgb("Emission", out_material.emissive_factor)); }
 	if (out_material.base_colour || out_material.roughness_metallic) {
 		auto const ri = ResourceInspector{m_target, m_scene.resources()};
 		if (out_material.base_colour) {
 			auto const* tex = m_scene.find(*out_material.base_colour);
 			ri.display(*tex, *out_material.base_colour, "Base Colour: ");
+			if (ImGui::BeginDragDropTarget()) {
+				if (ImGuiPayload const* payload = ImGui::AcceptDragDropPayload("ID_TEXTURE")) {
+					assert(payload->DataSize == sizeof(std::size_t));
+					out_material.base_colour = *reinterpret_cast<std::size_t*>(payload->Data);
+				}
+				ImGui::EndDragDropTarget();
+			}
 		}
 		if (out_material.roughness_metallic) {
 			auto const* tex = m_scene.find(*out_material.roughness_metallic);
 			ri.display(*tex, *out_material.roughness_metallic, "Roughness Metallic: ");
 		}
+		if (out_material.emissive) {
+			auto const* tex = m_scene.find(*out_material.emissive);
+			ri.display(*tex, *out_material.emissive, "Emissive: ");
+		}
 	}
 	return ret.value;
 }
@@ -224,13 +236,24 @@ bool SceneInspector::inspect(Id<Mesh> mesh_id) const {
 	return ret.value;
 }
 
+bool SceneInspector::inspect(Id<Camera> camera_id) const {
+	auto ret = Modified{};
+	auto* camera = m_scene.find(camera_id);
+	if (!camera) { return ret.value; }
+	if (ImGui::CollapsingHeader(FixedString{"Camera ({})###Camera", camera_id}.c_str())) {
+		ret(ImGui::DragFloat("Exposure", &camera->exposure, 0.1f, 0.0f, 10.0f));
+	}
+	return ret.value;
+}
+
 bool SceneInspector::inspect(Id<Node> node_id, Bool& out_unified_scaling) const {
 	auto ret = Modified{};
 	auto* node = m_scene.find(node_id);
 	if (!node) { return false; }
 	ret(inspect(node->transform, out_unified_scaling));
 	ret(inspect(node->instances, out_unified_scaling));
 	if (auto const* mesh_id = node->find<Id<Mesh>>()) { ret(inspect(*mesh_id)); }
+	if (auto const* camera_id = node->find<Id<Camera>>()) { ret(inspect(*camera_id)); }
 	return ret.value;
 }
 
@@ -283,13 +306,20 @@ void ResourceInspector::display(Camera const& camera, std::size_t index, std::st
 }
 
 void ResourceInspector::display(Texture const& texture, std::size_t index, std::string_view prefix) const {
-	if (auto tn = editor::TreeNode{FixedString<128>{"{}{} ({})", prefix, texture.name(), index}.c_str()}) {
+	auto const name = FixedString<128>{"{}{} ({})", prefix, texture.name(), index};
+	if (auto tn = editor::TreeNode{name.c_str()}) {
 		auto const view = texture.view();
 		editor::TreeNode::leaf(FixedString{"Extent: {}x{}", view.extent.width, view.extent.height}.c_str());
 		editor::TreeNode::leaf(FixedString{"Mip levels: {}", texture.mip_levels()}.c_str());
 		auto const cs = texture.colour_space() == ColourSpace::eLinear ? "linear" : "sRGB";
 		editor::TreeNode::leaf(FixedString{"Colour Space: {}", cs}.c_str());
 	}
+
+	if (ImGui::BeginDragDropSource()) {
+		ImGui::SetDragDropPayload("ID_TEXTURE", &index, sizeof(index));
+		ImGui::Text("%s", name.c_str());
+		ImGui::EndDragDropSource();
+	}
 }
 
 void ResourceInspector::display(Material const& material, std::size_t const index, std::string_view prefix) const {

lib/engine/src/scene_renderer.cpp

@@ -41,7 +41,8 @@ struct DirLightSSBO {
 
 SceneRenderer::SceneRenderer(Gfx const& gfx)
 	: m_gfx(gfx), m_sampler(gfx), m_view_proj(gfx, Buffer::Type::eUniform), m_dir_lights(gfx, Buffer::Type::eStorage),
-	  m_white(gfx, m_sampler.sampler(), Img1x1::make({0xff, 0xff, 0xff, 0xff}).view(), Texture::CreateInfo{.mip_mapped = false}) {}
+	  m_white(gfx, m_sampler.sampler(), Img1x1::make({0xff, 0xff, 0xff, 0xff}).view(), Texture::CreateInfo{.mip_mapped = false}),
+	  m_black(gfx, m_sampler.sampler(), Img1x1::make({0x0, 0x0, 0x0, 0xff}).view(), Texture::CreateInfo{.mip_mapped = false}) {}
 
 void SceneRenderer::render(Scene const& scene, Renderer& renderer, vk::CommandBuffer cb) {
 	m_scene = &scene;
@@ -57,11 +58,11 @@ void SceneRenderer::write_view(glm::vec2 const extent) {
 	struct {
 		glm::mat4x4 mat_v;
 		glm::mat4x4 mat_p;
-		glm::vec4 pos_v;
+		glm::vec4 vpos_exposure;
 	} vp{
 		.mat_v = cam.view(cam_node.transform),
 		.mat_p = cam.projection(extent),
-		.pos_v = {cam_node.transform.position(), 1.0f},
+		.vpos_exposure = {cam_node.transform.position(), cam.exposure},
 	};
 	m_view_proj.write(&vp, sizeof(vp));
 	auto dir_lights = FlexArray<DirLightSSBO, 4>{};
@@ -99,7 +100,7 @@ void SceneRenderer::render(Renderer& renderer, vk::CommandBuffer cb, Node const&
 			pipeline.set_line_width(m_scene->pipeline_state.line_width);
 
 			update_view(pipeline);
-			auto const store = TextureStore{resources.textures, m_white};
+			auto const store = TextureStore{resources.textures, m_white, m_black};
 			material.write_sets(pipeline, store);
 
 			auto const& static_mesh = resources.static_meshes[primitive.static_mesh];

lib/scene/include/facade/scene/camera.hpp

@@ -35,5 +35,6 @@ struct Camera {
 
 	std::string name{};
 	std::variant<Perspective, Orthographic> type{Perspective{}};
+	float exposure{2.0f};
 };
 } // namespace facade

lib/scene/include/facade/scene/material.hpp

@@ -23,11 +23,19 @@ struct TextureStore {
 	/// \brief White texture.
 	///
 	Texture const& white;
+	///
+	/// \brief Black texture;
+	///
+	Texture const& black;
 
+	///
+	/// \brief Obtain a texture corresponding to index if present, else fallback.
+	///
+	Texture const& get(std::optional<std::size_t> index, Texture const& fallback) const;
 	///
 	/// \brief Obtain a texture corresponding to index if present, else white.
 	///
-	Texture const& get(std::optional<std::size_t> index) const;
+	Texture const& get(std::optional<std::size_t> index) const { return get(index, white); }
 };
 
 ///
@@ -98,6 +106,10 @@ class LitMaterial : public Material {
 	///
 	glm::vec3 albedo{1.0f};
 	///
+	/// \brief Emissive factor.
+	///
+	glm::vec3 emissive_factor{0.0f};
+	///
 	/// \brief Metallic factor.
 	///
 	float metallic{0.5f};
@@ -113,6 +125,11 @@ class LitMaterial : public Material {
 	/// \brief Roughness-metallic texture.
 	///
 	std::optional<Id<Texture>> roughness_metallic{};
+	///
+	/// \brief Emissive texture.
+	///
+	std::optional<Id<Texture>> emissive{};
+
 	float alpha_cutoff{};
 	AlphaMode alpha_mode{AlphaMode::eOpaque};
 

lib/scene/include/facade/scene/scene.hpp

@@ -156,11 +156,17 @@ class Scene {
 	///
 	Ptr<Texture const> find(Id<Texture> id) const;
 	///
-	/// \brief Obtain an immutable pointer to the Mesh corresponding to its Id.
+	/// \brief Obtain a mutable pointer to the Mesh corresponding to its Id.
 	/// \param id Id of the Mesh
 	/// \returns nullptr if id is invalid (out of bounds)
 	///
-	Ptr<Mesh const> find(Id<Mesh> id) const;
+	Ptr<Mesh> find(Id<Mesh> id);
+	///
+	/// \brief Obtain a mutable pointer to the Camera corresponding to its Id.
+	/// \param id Id of the Camera
+	/// \returns nullptr if id is invalid (out of bounds)
+	///
+	Ptr<Camera> find(Id<Camera> id);
 
 	///
 	/// \brief Obtain a mutable view into all the root nodes attached to the active Tree.

lib/scene/src/detail/gltf.cpp

@@ -483,12 +483,11 @@ struct Data {
 			auto set_linear = [this](std::size_t index) { storage.textures.at(index).colour_space = ColourSpace::eLinear; };
 
 			// Determine whether a texture points to colour data by referring to the material(s) it is used in
-			// In our case all material textures except pbr.base_colour_texture are linear
+			// In our case all material textures except pbr.base_colour_texture and emissive_texture are linear
 			// The GLTF spec mandates image formats for corresponding material textures:
 			// https://registry.khronos.org/glTF/specs/2.0/glTF-2.0.html#reference-material
 			for (auto const& m : storage.materials) {
 				if (m.pbr.metallic_roughness_texture) { set_linear(m.pbr.metallic_roughness_texture->texture); }
-				if (m.emissive_texture) { set_linear(m.emissive_texture->texture); }
 				if (m.occlusion_texture) { set_linear(m.occlusion_texture->info.texture); }
 				if (m.normal_texture) { set_linear(m.normal_texture->info.texture); }
 			}

lib/scene/src/gltf_loader.cpp

@@ -58,8 +58,10 @@ std::unique_ptr<Material> to_material(gltf::Material const& material) {
 	ret->roughness = material.pbr.roughness_factor;
 	ret->alpha_mode = material.alpha_mode;
 	ret->alpha_cutoff = material.alpha_cutoff;
-	if (material.pbr.base_colour_texture) { ret->base_colour = material.pbr.base_colour_texture->texture; }
-	if (material.pbr.metallic_roughness_texture) { ret->roughness_metallic = material.pbr.metallic_roughness_texture->texture; }
+	ret->base_colour = material.pbr.base_colour_texture->texture;
+	ret->roughness_metallic = material.pbr.metallic_roughness_texture->texture;
+	ret->emissive = material.emissive_texture->texture;
+	ret->emissive_factor = material.emissive_factor;
 	return ret;
 }
 

lib/scene/src/material.cpp

@@ -7,6 +7,7 @@ namespace {
 struct Mat {
 	glm::vec4 albedo;
 	glm::vec4 m_r_aco_am;
+	glm::vec4 emissive;
 };
 
 // std::bit_cast not available on GCC 10.x
@@ -17,8 +18,8 @@ float bit_cast_f(Material::AlphaMode const mode) {
 }
 } // namespace
 
-Texture const& TextureStore::get(std::optional<std::size_t> const index) const {
-	if (!index || *index >= textures.size()) { return white; }
+Texture const& TextureStore::get(std::optional<std::size_t> const index, Texture const& fallback) const {
+	if (!index || *index >= textures.size()) { return fallback; }
 	return textures[*index];
 }
 
@@ -32,6 +33,7 @@ void UnlitMaterial::write_sets(Pipeline& pipeline, TextureStore const& store) co
 	auto const mat = Mat{
 		.albedo = to_linear(tint),
 		.m_r_aco_am = {},
+		.emissive = {},
 	};
 	set2.write(0, mat);
 	pipeline.bind(set1);
@@ -42,10 +44,12 @@ void LitMaterial::write_sets(Pipeline& pipeline, TextureStore const& store) cons
 	auto& set1 = pipeline.next_set(1);
 	set1.update(0, store.get(base_colour).descriptor_image());
 	set1.update(1, store.get(roughness_metallic).descriptor_image());
+	set1.update(2, store.get(emissive, store.black).descriptor_image());
 	auto& set2 = pipeline.next_set(2);
 	auto const mat = Mat{
 		.albedo = to_linear({albedo, 1.0f}),
 		.m_r_aco_am = {metallic, roughness, alpha_cutoff, bit_cast_f(alpha_mode)},
+		.emissive = to_linear({emissive_factor, 1.0f}),
 	};
 	set2.write(0, mat);
 	pipeline.bind(set1);

lib/scene/src/scene.cpp

@@ -143,7 +143,8 @@ Ptr<Node const> Scene::find(Id<Node> id) const { return find_node(m_tree.roots,
 Ptr<Material> Scene::find(Id<Material> id) const { return id >= m_storage.materials.size() ? nullptr : m_storage.materials[id].get(); }
 Ptr<StaticMesh const> Scene::find(Id<StaticMesh> id) const { return id >= m_storage.static_meshes.size() ? nullptr : &m_storage.static_meshes[id]; }
 Ptr<Texture const> Scene::find(Id<Texture> id) const { return id >= m_storage.textures.size() ? nullptr : &m_storage.textures[id]; }
-Ptr<Mesh const> Scene::find(Id<Mesh> id) const { return id >= m_storage.meshes.size() ? nullptr : &m_storage.meshes[id]; }
+Ptr<Mesh> Scene::find(Id<Mesh> id) { return id >= m_storage.meshes.size() ? nullptr : &m_storage.meshes[id]; }
+Ptr<Camera> Scene::find(Id<Camera> id) { return id >= m_storage.cameras.size() ? nullptr : &m_storage.cameras[id]; }
 
 bool Scene::select(Id<Camera> id) {
 	if (id >= camera_count()) { return false; }