Add support for linear/nearest texture sampling

Introduce explicit support for selecting linear vs nearest samplers for preview and pixel-closeup textures. Adds three ImGui platform draw callbacks (ResetRenderState, SetSamplerLinear, SetSamplerNearest) and implements them in the Metal backend with dedicated sampler states; Metal rendering now tracks a current sampler state when processing draw callbacks. Adds queue_texture_sampler_callback(draw_list, linear) to enqueue sampler selection callbacks from UI code. Propagates new boolean flags (main_texture_linear, closeup_texture_linear) through renderer vtables and backend implementations (Metal, OpenGL, Vulkan) so backends can report which preview texture variant they provide. Vulkan texture types and creation code now record whether linear filtering is supported and simplified the ImGui texture registration to use view+layout, while ensuring linear_filter_supported is set. Header and API changes update function signatures accordingly. These changes enable correct nearest sampling for pixel closeups while keeping linear sampling for ordinary previews.

Signed-off-by: Vlad <shaamaan@gmail.com>

Author: ssh4net

src/imiv/external/imgui_impl_metal_imiv.mm

@@ -18,6 +18,7 @@
 // CHANGELOG
 // (minor and older changes stripped away, please see git history for details)
 //  2026-XX-XX: Metal: Added support for multiple windows via the ImGuiPlatformIO interface.
+//  2026-04-26: Metal: Added support for standard draw callbacks (in platform_io): DrawCallback_ResetRenderState, DrawCallback_SetSamplerLinear, DrawCallback_SetSamplerNearest.
 //  2026-04-14: Metal: use a dedicated bufferCacheLock to avoid crashing when bufferCache is replaced by a new object while being used for @synchronize(). (#9367)
 //  2026-04-03: Metal: avoid redundant vertex buffer bind in SetupRenderState. (#9343)
 //  2026-03-19: Fixed issue in ImGui_ImplMetal_RenderDrawData() if ImTextureID_Invalid is defined to be != 0, which became the default since 2026-03-12. (#9295, #9310)
@@ -93,6 +94,8 @@ @interface MetalContext : NSObject
 @property (nonatomic, strong) id<MTLDevice> device;
 @property (nonatomic, strong) id<MTLDepthStencilState> depthStencilState;
 @property (nonatomic, strong) id<MTLSamplerState> defaultSamplerState;
+@property (nonatomic, strong) id<MTLSamplerState> linearSamplerState;
+@property (nonatomic, strong) id<MTLSamplerState> nearestSamplerState;
 @property (nonatomic, strong) FramebufferDescriptor*
     framebufferDescriptor;  // framebuffer descriptor for current frame; transient
 @property (nonatomic, strong) NSMutableDictionary*
@@ -127,6 +130,26 @@ - (MetalBuffer*)dequeueReusableBufferOfLength:(NSUInteger)length
     IM_DELETE(ImGui_ImplMetal_GetBackendData());
 }
 
+// Draw callbacks. They are intentionally empty and used as stable identifiers
+// for the render loop, matching Dear ImGui's standard backend convention.
+static void
+ImGui_ImplMetal_DrawCallback_ResetRenderState(const ImDrawList*,
+                                              const ImDrawCmd*)
+{
+}
+
+static void
+ImGui_ImplMetal_DrawCallback_SetSamplerLinear(const ImDrawList*,
+                                              const ImDrawCmd*)
+{
+}
+
+static void
+ImGui_ImplMetal_DrawCallback_SetSamplerNearest(const ImDrawList*,
+                                               const ImDrawCmd*)
+{
+}
+
 static inline CFTimeInterval
 GetMachAbsoluteTimeInSeconds()
 {
@@ -175,7 +198,8 @@ - (MetalBuffer*)dequeueReusableBufferOfLength:(NSUInteger)length
 bool
 ImGui_ImplMetal_Init(id<MTLDevice> device)
 {
-    ImGuiIO& io = ImGui::GetIO();
+    ImGuiIO& io                  = ImGui::GetIO();
+    ImGuiPlatformIO& platform_io = ImGui::GetPlatformIO();
     IMGUI_CHECKVERSION();
     IM_ASSERT(io.BackendRendererUserData == nullptr
               && "Already initialized a renderer backend!");
@@ -193,6 +217,13 @@ - (MetalBuffer*)dequeueReusableBufferOfLength:(NSUInteger)length
     bd->SharedMetalContext        = [[MetalContext alloc] init];
     bd->SharedMetalContext.device = device;
 
+    platform_io.DrawCallback_ResetRenderState
+        = ImGui_ImplMetal_DrawCallback_ResetRenderState;
+    platform_io.DrawCallback_SetSamplerLinear
+        = ImGui_ImplMetal_DrawCallback_SetSamplerLinear;
+    platform_io.DrawCallback_SetSamplerNearest
+        = ImGui_ImplMetal_DrawCallback_SetSamplerNearest;
+
     ImGui_ImplMetal_InitMultiViewportSupport();
 
     return true;
@@ -375,6 +406,8 @@ - (MetalBuffer*)dequeueReusableBufferOfLength:(NSUInteger)length
     // Render command lists
     size_t vertexBufferOffset = 0;
     size_t indexBufferOffset  = 0;
+    id<MTLSamplerState> currentSamplerState
+        = bd->SharedMetalContext.defaultSamplerState;
     for (const ImDrawList* draw_list : draw_data->CmdLists) {
         memcpy((char*)vertexBuffer.buffer.contents + vertexBufferOffset,
                draw_list->VtxBuffer.Data,
@@ -387,15 +420,26 @@ - (MetalBuffer*)dequeueReusableBufferOfLength:(NSUInteger)length
             const ImDrawCmd* pcmd = &draw_list->CmdBuffer[cmd_i];
             if (pcmd->UserCallback) {
                 // User callback, registered via ImDrawList::AddCallback()
-                // (ImDrawCallback_ResetRenderState is a special callback value used by the user to request the renderer to reset render state.)
-                if (pcmd->UserCallback == ImDrawCallback_ResetRenderState)
+                if (pcmd->UserCallback
+                    == ImGui_ImplMetal_DrawCallback_ResetRenderState) {
                     ImGui_ImplMetal_SetupRenderState(draw_data, commandBuffer,
                                                      commandEncoder,
                                                      renderPipelineState,
                                                      vertexBuffer,
                                                      vertexBufferOffset);
-                else
+                    currentSamplerState
+                        = bd->SharedMetalContext.defaultSamplerState;
+                } else if (pcmd->UserCallback
+                           == ImGui_ImplMetal_DrawCallback_SetSamplerLinear) {
+                    currentSamplerState
+                        = bd->SharedMetalContext.linearSamplerState;
+                } else if (pcmd->UserCallback
+                           == ImGui_ImplMetal_DrawCallback_SetSamplerNearest) {
+                    currentSamplerState
+                        = bd->SharedMetalContext.nearestSamplerState;
+                } else {
                     pcmd->UserCallback(draw_list, pcmd);
+                }
             } else {
                 // Project scissor/clipping rectangles into framebuffer space
                 ImVec2 clip_min((pcmd->ClipRect.x - clip_off.x) * clip_scale.x,
@@ -431,9 +475,8 @@ ImVec2 clip_max((pcmd->ClipRect.z - clip_off.x) * clip_scale.x,
                 [commandEncoder setScissorRect:scissorRect];
 
                 // Bind texture, Draw
-                id<MTLSamplerState> sampler_state
-                    = bd->SharedMetalContext.defaultSamplerState;
-                ImTextureID tex_id = pcmd->GetTexID();
+                id<MTLSamplerState> sampler_state = currentSamplerState;
+                ImTextureID tex_id                = pcmd->GetTexID();
                 if (tex_id != ImTextureID_Invalid) {
                     id metal_object = (__bridge id)(void*)(intptr_t)(tex_id);
                     if ([metal_object isKindOfClass:[MetalTexture class]]) {
@@ -578,7 +621,14 @@ ImVec2 clip_max((pcmd->ClipRect.z - clip_off.x) * clip_scale.x,
     samplerDescriptor.mipFilter                 = MTLSamplerMipFilterLinear;
     samplerDescriptor.sAddressMode = MTLSamplerAddressModeClampToEdge;
     samplerDescriptor.tAddressMode = MTLSamplerAddressModeClampToEdge;
-    bd->SharedMetalContext.defaultSamplerState = [device
+    bd->SharedMetalContext.linearSamplerState = [device
+        newSamplerStateWithDescriptor:samplerDescriptor];
+    bd->SharedMetalContext.defaultSamplerState
+        = bd->SharedMetalContext.linearSamplerState;
+    samplerDescriptor.minFilter                = MTLSamplerMinMagFilterNearest;
+    samplerDescriptor.magFilter                = MTLSamplerMinMagFilterNearest;
+    samplerDescriptor.mipFilter                = MTLSamplerMipFilterNearest;
+    bd->SharedMetalContext.nearestSamplerState = [device
         newSamplerStateWithDescriptor:samplerDescriptor];
     ImGui_ImplMetal_CreateDeviceObjectsForPlatformWindows();
 #    ifdef IMGUI_IMPL_METAL_CPP
@@ -602,6 +652,8 @@ ImVec2 clip_max((pcmd->ClipRect.z - clip_off.x) * clip_scale.x,
     ImGui_ImplMetal_InvalidateDeviceObjectsForPlatformWindows();
     [bd->SharedMetalContext.renderPipelineStateCache removeAllObjects];
     bd->SharedMetalContext.defaultSamplerState = nil;
+    bd->SharedMetalContext.linearSamplerState  = nil;
+    bd->SharedMetalContext.nearestSamplerState = nil;
     bd->SharedMetalContext.depthStencilState   = nil;
 }
 

src/imiv/imiv_image_view.cpp

@@ -238,12 +238,16 @@ draw_image_window_contents(ViewerState& viewer, PlaceholderUiState& ui_state,
         ImTextureRef closeup_texture_ref;
         bool has_main_texture           = false;
         bool has_closeup_texture        = false;
+        bool main_texture_linear        = false;
+        bool closeup_texture_linear     = false;
         bool image_canvas_hovered       = false;
         bool image_canvas_active        = false;
         PendingZoomRequest pending_zoom = shortcut_zoom_request;
         renderer_get_viewer_texture_refs(viewer, ui_state, main_texture_ref,
-                                         has_main_texture, closeup_texture_ref,
-                                         has_closeup_texture);
+                                         has_main_texture, main_texture_linear,
+                                         closeup_texture_ref,
+                                         has_closeup_texture,
+                                         closeup_texture_linear);
         ImageCoordinateMap coord_map;
         coord_map.source_width  = viewer.image.width;
         coord_map.source_height = viewer.image.height;
@@ -305,8 +309,10 @@ draw_image_window_contents(ViewerState& viewer, PlaceholderUiState& ui_state,
                                          coord_map.image_rect_max);
             draw_list->PushClipRect(coord_map.viewport_rect_min,
                                     coord_map.viewport_rect_max, true);
+            queue_texture_sampler_callback(draw_list, main_texture_linear);
             draw_list->AddImage(main_texture_ref, coord_map.image_rect_min,
                                 coord_map.image_rect_max);
+            queue_texture_sampler_callback(draw_list, true);
             draw_list->PopClipRect();
         } else if (!has_main_texture) {
             const bool texture_loading = renderer_texture_is_loading(
@@ -541,10 +547,9 @@ draw_image_window_contents(ViewerState& viewer, PlaceholderUiState& ui_state,
         if (zoom_changed)
             queue_auto_subimage_from_zoom(viewer);
 
-        const OverlayPanelRect pixel_panel
-            = draw_pixel_closeup_overlay(viewer, ui_state, coord_map,
-                                         closeup_texture_ref,
-                                         has_closeup_texture, fonts);
+        const OverlayPanelRect pixel_panel = draw_pixel_closeup_overlay(
+            viewer, ui_state, coord_map, closeup_texture_ref,
+            has_closeup_texture, closeup_texture_linear, fonts);
         draw_area_probe_overlay(viewer, ui_state, coord_map, pixel_panel,
                                 fonts);
     } else if (viewer.last_error.empty()) {

src/imiv/imiv_probe_overlay.cpp

@@ -460,7 +460,8 @@ draw_pixel_closeup_overlay(const ViewerState& viewer,
                            PlaceholderUiState& ui_state,
                            const ImageCoordinateMap& map,
                            ImTextureRef closeup_texture,
-                           bool has_closeup_texture, const AppFonts& fonts)
+                           bool has_closeup_texture,
+                           bool closeup_texture_linear, const AppFonts& fonts)
 {
     OverlayPanelRect panel;
     if (!ui_state.show_pixelview_window || !map.valid)
@@ -621,8 +622,10 @@ draw_pixel_closeup_overlay(const ViewerState& viewer,
                             static_cast<float>(ybegin) / display_h);
         const ImVec2 uv_max(static_cast<float>(xend) / display_w,
                             static_cast<float>(yend) / display_h);
+        queue_texture_sampler_callback(draw_list, closeup_texture_linear);
         draw_list->AddImage(closeup_texture, closeup_min, closeup_max, uv_min,
                             uv_max, IM_COL32_WHITE);
+        queue_texture_sampler_callback(draw_list, true);
 
         const float cell_w = closeup_window_size / patch_w;
         const float cell_h = closeup_window_size / patch_h;

src/imiv/imiv_probe_overlay.h

@@ -36,7 +36,8 @@ draw_pixel_closeup_overlay(const ViewerState& viewer,
                            PlaceholderUiState& ui_state,
                            const ImageCoordinateMap& map,
                            ImTextureRef closeup_texture,
-                           bool has_closeup_texture, const AppFonts& fonts);
+                           bool has_closeup_texture,
+                           bool closeup_texture_linear, const AppFonts& fonts);
 void
 draw_area_probe_overlay(const ViewerState& viewer,
                         const PlaceholderUiState& ui_state,

src/imiv/imiv_renderer.cpp

@@ -467,24 +467,26 @@ renderer_texture_is_loading(const RendererTexture& texture)
 }
 
 void
-renderer_get_viewer_texture_refs(const ViewerState& viewer,
-                                 const PlaceholderUiState& ui_state,
-                                 ImTextureRef& main_texture_ref,
-                                 bool& has_main_texture,
-                                 ImTextureRef& closeup_texture_ref,
-                                 bool& has_closeup_texture)
+renderer_get_viewer_texture_refs(
+    const ViewerState& viewer, const PlaceholderUiState& ui_state,
+    ImTextureRef& main_texture_ref, bool& has_main_texture,
+    bool& main_texture_linear, ImTextureRef& closeup_texture_ref,
+    bool& has_closeup_texture, bool& closeup_texture_linear)
 {
     main_texture_ref                    = ImTextureRef();
     closeup_texture_ref                 = ImTextureRef();
     has_main_texture                    = false;
     has_closeup_texture                 = false;
+    main_texture_linear                 = false;
+    closeup_texture_linear              = false;
     const RendererBackendVTable* vtable = texture_dispatch_vtable(
         viewer.texture);
     if (vtable == nullptr || vtable->get_viewer_texture_refs == nullptr)
         return;
     vtable->get_viewer_texture_refs(viewer, ui_state, main_texture_ref,
-                                    has_main_texture, closeup_texture_ref,
-                                    has_closeup_texture);
+                                    has_main_texture, main_texture_linear,
+                                    closeup_texture_ref, has_closeup_texture,
+                                    closeup_texture_linear);
 }
 
 bool

src/imiv/imiv_renderer.h

@@ -176,12 +176,11 @@ bool
 renderer_texture_is_loading(const RendererTexture& texture);
 
 void
-renderer_get_viewer_texture_refs(const ViewerState& viewer,
-                                 const PlaceholderUiState& ui_state,
-                                 ImTextureRef& main_texture_ref,
-                                 bool& has_main_texture,
-                                 ImTextureRef& closeup_texture_ref,
-                                 bool& has_closeup_texture);
+renderer_get_viewer_texture_refs(
+    const ViewerState& viewer, const PlaceholderUiState& ui_state,
+    ImTextureRef& main_texture_ref, bool& has_main_texture,
+    bool& main_texture_linear, ImTextureRef& closeup_texture_ref,
+    bool& has_closeup_texture, bool& closeup_texture_linear);
 
 bool
 renderer_create_texture(RendererState& renderer_state, const LoadedImage& image,

src/imiv/imiv_renderer_backend.h

@@ -11,12 +11,11 @@ namespace Imiv {
 struct RendererBackendVTable {
     BackendKind kind = BackendKind::Auto;
     bool (*probe_runtime_support)(std::string& error_message) = nullptr;
-    bool (*get_viewer_texture_refs)(const ViewerState& viewer,
-                                    const PlaceholderUiState& ui_state,
-                                    ImTextureRef& main_texture_ref,
-                                    bool& has_main_texture,
-                                    ImTextureRef& closeup_texture_ref,
-                                    bool& has_closeup_texture)
+    bool (*get_viewer_texture_refs)(
+        const ViewerState& viewer, const PlaceholderUiState& ui_state,
+        ImTextureRef& main_texture_ref, bool& has_main_texture,
+        bool& main_texture_linear, ImTextureRef& closeup_texture_ref,
+        bool& has_closeup_texture, bool& closeup_texture_linear)
         = nullptr;
     bool (*texture_is_loading)(const RendererTexture& texture) = nullptr;
     bool (*create_texture)(RendererState& renderer_state,

src/imiv/imiv_renderer_metal.mm

@@ -1798,12 +1798,11 @@ bool render_preview_texture(MetalRendererBackendState& state,
                                          error_message);
     }
 
-    bool metal_get_viewer_texture_refs(const ViewerState& viewer,
-                                       const PlaceholderUiState& ui_state,
-                                       ImTextureRef& main_texture_ref,
-                                       bool& has_main_texture,
-                                       ImTextureRef& closeup_texture_ref,
-                                       bool& has_closeup_texture)
+    bool metal_get_viewer_texture_refs(
+        const ViewerState& viewer, const PlaceholderUiState& ui_state,
+        ImTextureRef& main_texture_ref, bool& has_main_texture,
+        bool& main_texture_linear, ImTextureRef& closeup_texture_ref,
+        bool& has_closeup_texture, bool& closeup_texture_linear)
     {
         const RendererTextureBackendState* state
             = texture_backend_state<RendererTextureBackendState>(
@@ -1817,16 +1816,20 @@ bool metal_get_viewer_texture_refs(const ViewerState& viewer,
         if (main_texture_id == ImTextureID_Invalid)
             main_texture_id = state->preview_linear_tex_id;
         if (main_texture_id != ImTextureID_Invalid) {
-            main_texture_ref = ImTextureRef(main_texture_id);
-            has_main_texture = true;
+            main_texture_ref    = ImTextureRef(main_texture_id);
+            has_main_texture    = true;
+            main_texture_linear = main_texture_id
+                                  == state->preview_linear_tex_id;
         }
 
         ImTextureID closeup_texture_id = state->preview_nearest_tex_id;
         if (closeup_texture_id == ImTextureID_Invalid)
             closeup_texture_id = state->preview_linear_tex_id;
         if (closeup_texture_id != ImTextureID_Invalid) {
-            closeup_texture_ref = ImTextureRef(closeup_texture_id);
-            has_closeup_texture = true;
+            closeup_texture_ref    = ImTextureRef(closeup_texture_id);
+            has_closeup_texture    = true;
+            closeup_texture_linear = closeup_texture_id
+                                     == state->preview_linear_tex_id;
         }
         return has_main_texture || has_closeup_texture;
     }

src/imiv/imiv_renderer_opengl.cpp

@@ -1402,12 +1402,11 @@ void main()
         return true;
     }
 
-    bool opengl_get_viewer_texture_refs(const ViewerState& viewer,
-                                        const PlaceholderUiState& ui_state,
-                                        ImTextureRef& main_texture_ref,
-                                        bool& has_main_texture,
-                                        ImTextureRef& closeup_texture_ref,
-                                        bool& has_closeup_texture)
+    bool opengl_get_viewer_texture_refs(
+        const ViewerState& viewer, const PlaceholderUiState& ui_state,
+        ImTextureRef& main_texture_ref, bool& has_main_texture,
+        bool& main_texture_linear, ImTextureRef& closeup_texture_ref,
+        bool& has_closeup_texture, bool& closeup_texture_linear)
     {
         const RendererTextureBackendState* state
             = texture_backend_state<RendererTextureBackendState>(
@@ -1421,16 +1420,19 @@ void main()
         if (main_texture != 0) {
             main_texture_ref = ImTextureRef(
                 static_cast<ImTextureID>(static_cast<intptr_t>(main_texture)));
-            has_main_texture = true;
+            has_main_texture    = true;
+            main_texture_linear = main_texture == state->preview_linear_texture;
         }
 
         const GLuint closeup_texture = state->preview_nearest_texture != 0
                                            ? state->preview_nearest_texture
                                            : state->preview_linear_texture;
         if (closeup_texture != 0) {
-            closeup_texture_ref = ImTextureRef(static_cast<ImTextureID>(
+            closeup_texture_ref    = ImTextureRef(static_cast<ImTextureID>(
                 static_cast<intptr_t>(closeup_texture)));
-            has_closeup_texture = true;
+            has_closeup_texture    = true;
+            closeup_texture_linear = closeup_texture
+                                     == state->preview_linear_texture;
         }
         return has_main_texture || has_closeup_texture;
     }