material preview

Author: Cheaterdev

sources/RenderSystem/Assets/AssetExplorer.cpp

@@ -133,8 +133,10 @@ namespace GUI
 
 
 				};
-				auto texture = loaded_asset->get_ptr<TextureAsset>();
-				auto binary  = loaded_asset->get_ptr<BinaryAsset>();
+				auto texture  = loaded_asset->get_ptr<TextureAsset>();
+				auto binary   = loaded_asset->get_ptr<BinaryAsset>();
+				auto mesh     = loaded_asset->get_ptr<MeshAsset>();
+				auto material = loaded_asset->get_ptr<MaterialAsset>();
 
 				if (texture)
 					menu->add_item("Compress")->on_click = [this](menu_list_element::ptr e)
@@ -143,7 +145,7 @@ namespace GUI
 					texture->compress();
 				};
 
-				if ((texture || binary) && on_open_preview)
+				if ((texture || binary || mesh || material) && on_open_preview)
 					menu->add_item("Preview")->on_click = [this](menu_list_element::ptr e)
 				{
 					if (on_open_preview) on_open_preview(asset->get_asset());

sources/RenderSystem/Assets/AssetRenderer.cpp

@@ -248,3 +248,120 @@ AssetRenderer::AssetRenderer()
     //	ssgi = std::make_shared<SSGI>(*gbuffer);
 
 }
+
+
+// ===========================================================================
+//  SceneTextureRenderer — copy of AssetRenderer's scene-to-texture core.
+//  (AssetRenderer left intact; it will later be rewritten to use this.)
+// ===========================================================================
+
+SceneTextureRenderer::SceneTextureRenderer()
+{
+    std::lock_guard<std::mutex> g(lock);
+
+    scene_renderer = std::make_shared<main_renderer>();
+    scene_renderer->register_renderer(meshes_renderer = std::make_shared<mesh_renderer>());
+    cam.position = vec3(0, 5, -30);
+
+    mesh_plane.reset(new MeshAssetInstance(EngineAssets::plane.get_asset()));
+    material_tester.reset(new MeshAssetInstance(EngineAssets::material_tester.get_asset()));
+
+    scene = std::make_shared<Scene>();
+
+    rendering = std::make_shared<SceneRenderWorkflow>();
+    rendering->scene_renderer = scene_renderer;
+}
+
+void SceneTextureRenderer::draw(Scene::ptr scene, HAL::Texture::ptr result)
+{
+    graph.start_new_frame();
+
+    scene->update_transforms();
+
+    auto mn = scene->get_min();
+    auto mx = scene->get_max();
+    scene->add_child(mesh_plane);
+    scene->update(*graph.builder.current_frame);
+
+    float x = mx.x - mn.x;
+    float y = mx.y - mn.y;
+
+    mesh_plane->local_transform.scaling(std::max(x, y));
+
+    mesh_plane->local_transform.a42 = mn.y;
+    scene->update_transforms();
+
+    auto& time      = graph.get_context<TimeInfo>();
+    auto& skyinfo   = graph.get_context<SkyInfo>();
+    auto& caminfo   = graph.get_context<CameraInfo>();
+    auto& sceneinfo = graph.get_context<SceneInfo>();
+    auto& vp        = graph.get_context<ViewportInfo>();
+
+    auto  rsize  = result->get_size().xy;
+    float aspect = float(rsize.x) / float(rsize.y);
+
+    float base_dist = (mx - mn).length();
+    if (base_dist < 0.001f) base_dist = 1.0f;
+
+    // Orbit direction from yaw/pitch; distance scaled by zoom.
+    vec3 dir;
+    dir.x = Math::cos(m_orbit.y) * Math::sin(m_orbit.x);
+    dir.y = Math::sin(m_orbit.y);
+    dir.z = Math::cos(m_orbit.y) * Math::cos(m_orbit.x);
+
+    cam.target   = (mn + mx) / 2;
+    cam.position = cam.target + dir * (base_dist * m_zoom);
+    cam.set_projection_params(Math::pi / 4, aspect, 1, 100 + (mn - mx).length());
+    cam.update();
+
+    skyinfo.sunDir = float3(1, 1, 1).normalize();
+
+    graph.builder.debug = true;
+    vp.frame_size   = rsize / 2;
+    vp.upscale_size = rsize;
+
+    sceneinfo.scene    = scene;
+    sceneinfo.renderer = scene_renderer;
+    caminfo.cam        = &cam;
+
+    rendering->render(graph);
+    graph.builder.pass_texture(FrameGraph::ResourceID::swapchain, result->resource, {}, ResourceFlags::Required);
+
+    graph.setup();
+    graph.compile(frame++);
+    graph.render();
+    graph.commit_command_lists();
+    graph.reset();
+    mesh_plane->remove_from_parent();
+}
+
+void SceneTextureRenderer::draw(scene_object::ptr obj, HAL::Texture::ptr result)
+{
+    std::lock_guard<std::mutex> g(lock);
+
+    scene->add_child(obj);
+    draw(scene, result);
+    obj->remove_from_parent();
+}
+
+void SceneTextureRenderer::draw(MaterialAsset::ptr mat, HAL::Texture::ptr result)
+{
+    std::lock_guard<std::mutex> g(lock);
+
+    scene->add_child(material_tester);
+    material_tester->override_material(1, mat);
+
+    draw(scene, result);
+    material_tester->remove_from_parent();
+}
+
+void SceneTextureRenderer::orbit(vec2 delta)
+{
+    m_orbit += delta;
+    m_orbit.y = Math::clamp(m_orbit.y, -Math::m_pi_2 + Math::eps2, Math::m_pi_2 - Math::eps2);
+}
+
+void SceneTextureRenderer::zoom(float amount)
+{
+    m_zoom = Math::clamp(m_zoom * (1.0f - amount * 0.1f), 0.05f, 10.0f);
+}

sources/RenderSystem/Assets/AssetRenderer.ixx

@@ -39,4 +39,44 @@ export  class AssetRenderer : public Singleton<AssetRenderer>
         virtual void draw(MaterialAsset::ptr m, HAL::Texture::ptr result);
 		virtual void draw(scene_object::ptr scene, HAL::Texture::ptr result);
 
+};
+
+
+// Generic offscreen "render a scene into a target texture" engine. Owns its own
+// FrameGraph so it can run alongside the main UI graph (which only fits one main
+// pipeline). Copied from AssetRenderer's implementation; AssetRenderer will later
+// be rewritten to build on this. Not a Singleton — each user owns an instance
+// (own graph / scene / camera).
+export class SceneTextureRenderer
+{
+        FrameGraph::Graph graph;
+        UINT frame = 0;
+
+        main_renderer::ptr scene_renderer;
+        camera cam;
+        mesh_renderer::ptr meshes_renderer;
+        std::shared_ptr<SceneRenderWorkflow> rendering;
+
+        MeshAssetInstance::ptr mesh_plane;
+        MeshAssetInstance::ptr material_tester; // test mesh for material previews
+
+        Scene::ptr scene;
+        std::mutex lock;
+
+        // Orbit camera around the auto-fit center: yaw/pitch + zoom distance.
+        vec2  m_orbit = { 0.785398f, 0.35f }; // ~pi/4 yaw, slight pitch
+        float m_zoom  = 1.0f;
+
+    public:
+        SceneTextureRenderer();
+
+        camera& get_camera() { return cam; }
+
+        // Drag to orbit, wheel to zoom (forwarded from the preview widget).
+        void orbit(vec2 delta);
+        void zoom(float amount);
+
+        void draw(Scene::ptr scene, HAL::Texture::ptr result);
+        void draw(scene_object::ptr obj, HAL::Texture::ptr result);
+        void draw(MaterialAsset::ptr m, HAL::Texture::ptr result);
 };

sources/RenderSystem/GUI/Elements/FlowGraph/ComponentWindow.cpp

@@ -132,7 +132,7 @@ GUI::Elements::FlowGraph::component_window::component_window(canvas* canva, ::Fl
 	contents_preview->width_size = size_type::MATCH_CHILDREN;
 	contents_preview->height_size = size_type::MATCH_CHILDREN;
 	visual_graph = dynamic_cast<VisualGraph*>(node);
-	if (visual_graph)
+	if (visual_graph && type != window_type::GRAPH_IN) // input side never shows the editor/preview
 	{
 		auto p = visual_graph->create_editor_window();
 

sources/RenderSystem/Materials/Values.cpp

@@ -741,6 +741,14 @@ void VectorNode::operator()(MaterialContext* c)
 	o_value->put(res);
 }
 
+GUI::base::ptr MaterialGraph::create_editor_window()
+{
+	// Live material preview on the graph-output node (widget built by the app).
+	if (create_preview_hook && preview_material)
+		return create_preview_hook(preview_material->get_ptr<Asset>());
+	return nullptr;
+}
+
 GUI::base::ptr VectorNode::create_editor_window()
 {
 	auto picker = std::make_shared<GUI::Elements::color_picker>();

sources/RenderSystem/Materials/Values.ixx

@@ -402,8 +402,16 @@ class MaterialGraph : public MaterialFunction
     public:
         using ptr = s_ptr<MaterialGraph>;
 
+        // The owning material (set by universal_material); used to build a live
+        // preview on the graph-output node.
+        Asset* preview_material = nullptr;
+        // Filled by the app layer (which can build a preview widget above the
+        // Materials module — Materials can't import the renderer without a cycle).
+        static inline std::function<GUI::base::ptr(std::shared_ptr<Asset>)> create_preview_hook;
+
         MaterialGraph();
         virtual ~MaterialGraph();
+        virtual GUI::base::ptr create_editor_window() override;
         FlowGraph::input::ptr get_texcoord();
 
         FlowGraph::output::ptr get_base_color();

sources/RenderSystem/Materials/universal_material.cpp

@@ -413,6 +413,7 @@ materials::universal_material::universal_material(MaterialGraph::ptr graph) : in
 	include_file_raytacing = EngineAssets::material_raytracing_header.get_asset();
 	this->graph = BinaryData<MaterialGraph>(graph);
 	graph->add_listener(this, false);
+	graph->preview_material = this; // let the graph-output node build a live preview
 	need_regenerate_material = true;
 	need_update_uniforms = true;
 	generate_material();

sources/RenderSystem/Materials/universal_material.events.cpp

@@ -16,7 +16,9 @@ size_t materials::universal_material::get_id()
 
 MaterialGraph::ptr materials::universal_material::get_graph()
 {
-	return graph.get();
+	auto g = graph.get();
+	if (g) g->preview_material = this; // ensure the editor's graph can build a live preview
+	return g;
 }
 
 void materials::universal_material::test()