Merge pull request #2 from nefarius/nicer-visuals

Gamepad rendering improvements and device-specific fixes

Author: nefarius

CMakeLists.txt

@@ -18,7 +18,7 @@ add_executable(MultiPadTester WIN32
 source_group("Source Files" FILES ${SOURCE_FILES})
 source_group("Header Files" FILES ${HEADER_FILES})
 
-target_include_directories(MultiPadTester PRIVATE src)
+target_include_directories(MultiPadTester PRIVATE src res)
 
 target_link_libraries(MultiPadTester PRIVATE
     imgui::imgui

assets/CONTROLLER_TEXTURE.txt

@@ -0,0 +1,6 @@
+Controller body textures (400×280 recommended for overlay alignment):
+
+  xbox_body.png     — used for Xbox and other non-Sony devices.
+  dualsense_body.png — used when a Sony device is detected (DualSense, DualShock, etc.).
+
+Replace these PNGs with your own art to change how each layout looks.

assets/dualsense_body.png

@@ -1 +1,4 @@
+#include "resource.h"
 IDI_APPICON ICON "app.ico"
+IDR_XBOX_BODY RCDATA "..\\assets\\xbox_body.png"
+IDR_DUALSENSE_BODY RCDATA "..\\assets\\dualsense_body.png"

assets/xbox_body.png

@@ -0,0 +1,3 @@
+#pragma once
+#define IDR_XBOX_BODY      101
+#define IDR_DUALSENSE_BODY 102

res/app.rc

@@ -6,7 +6,76 @@
 
 namespace GamepadRenderer {
 
-// ── palette ──────────────────────────────────────────────────
+// ── layout coordinates (Xbox: stick upper-left, D-pad lower-left; Sony: D-pad upper-left, stick lower-left) ──
+
+struct LayoutCoords {
+	float dpadX, dpadY;
+	float faceX, faceY;
+	float leftStickX, leftStickY;
+	float rightStickX, rightStickY;
+	float lbTlX, lbTlY, lbBrX, lbBrY;
+	float rbTlX, rbTlY, rbBrX, rbBrY;
+	float ltTlX, ltTlY, ltBrX, ltBrY;
+	float rtTlX, rtTlY, rtBrX, rtBrY;
+	float backX, backY, guideX, guideY, startX, startY;
+	const char* faceLabelA;
+	const char* faceLabelB;
+	const char* faceLabelX;
+	const char* faceLabelY;
+	const char* backLabel;   // Back / Share
+	const char* guideLabel;  // Guide / PS
+	const char* startLabel;  // Start / Options
+};
+
+static const LayoutCoords XBOX_LAYOUT = {
+	160.f, 154.f,   // D-pad lower-left
+	275.f, 85.f,   // face buttons
+	125.f, 85.f,   // left stick upper-left
+	252.f, 158.f,  // right stick
+	72.f, 32.f, 162.f, 50.f,   // left bumper
+	238.f, 32.f, 328.f, 50.f,  // right bumper
+	58.f, 10.f, 88.f, 36.f,    // left trigger
+	312.f, 10.f, 342.f, 36.f,  // right trigger
+	182.f, 88.f, 200.f, 100.f, 218.f, 88.f,
+	"A", "B", "X", "Y",
+	"Back", "Guide", "Start"
+};
+
+// PlayStation: Circle (A), Cross (B), Square (X), Triangle (Y) — ASCII so default font works
+static const char* SONY_FACE_A = "O";   // Circle
+static const char* SONY_FACE_B = "X";   // Cross
+static const char* SONY_FACE_X = "S";   // Square
+static const char* SONY_FACE_Y = "T";   // Triangle
+
+static const LayoutCoords SONY_LAYOUT = {
+	114.f, 92.5f,   // D-pad upper-left (Sony symmetrical)
+	285.f, 96.f,   // face buttons
+	160.f, 130.f,   // left stick lower-left (Sony symmetrical)
+	240.f, 130.f,  // right stick
+	72.f, 32.f, 162.f, 50.f,
+	238.f, 32.f, 328.f, 50.f,
+	58.f, 10.f, 88.f, 36.f,
+	312.f, 10.f, 342.f, 36.f,
+	182.f, 88.f, 200.f, 100.f, 218.f, 88.f,
+	SONY_FACE_A, SONY_FACE_B, SONY_FACE_X, SONY_FACE_Y,
+	"Share", "PS", "Options"
+};
+
+/**
+ * @brief Selects the layout coordinates for the specified layout type.
+ *
+ * @param t Layout type indicating which coordinate set to use (e.g., LayoutType::Sony).
+ * @return const LayoutCoords& Reference to the corresponding LayoutCoords constant: SONY_LAYOUT when t is LayoutType::Sony, otherwise XBOX_LAYOUT.
+ */
+static const LayoutCoords& GetLayoutCoords(LayoutType t) {
+	return t == LayoutType::Sony ? SONY_LAYOUT : XBOX_LAYOUT;
+}
+
+/**
+ * @brief Color used for the "A" face button.
+ *
+ * @return ImU32 Packed RGBA color equal to approximately RGB(96, 202, 56) with alpha 255.
+ */
 
 static ImU32 ColorA()  { return IM_COL32( 96, 202,  56, 255); }
 static ImU32 ColorB()  { return IM_COL32(228,  56,  56, 255); }
@@ -19,7 +88,16 @@ static ImU32 Body()    { return IM_COL32( 50,  50,  55, 255); }
 static ImU32 Outline() { return IM_COL32(120, 120, 130, 255); }
 static ImU32 BgDim()   { return IM_COL32( 35,  35,  38, 180); }
 
-// ── small drawing helpers ────────────────────────────────────
+/**
+ * @brief Draws the controller body and its left/right side panels using the provided layout.
+ *
+ * Renders filled, rounded rectangles with outlines to represent the main controller shell
+ * and the two side panels. Positions, sizes, corner radii and stroke widths are derived
+ * from the supplied Layout instance and the module's color helpers.
+ *
+ * @param dl ImGui draw list used for rendering.
+ * @param L Layout providing coordinate transforms and scaling for placement and sizes.
+ */
 
 static void DrawBody(ImDrawList* dl, const Layout& L) {
     ImVec2 tl = L.P(40, 30);
@@ -38,8 +116,20 @@ static void DrawBody(ImDrawList* dl, const Layout& L) {
     dl->AddRect(grtl, grbr, Outline(), L.S(20), 0, L.S(2));
 }
 
-static void DrawDPad(ImDrawList* dl, const Layout& L, const GamepadState& gs) {
-    ImVec2 center = L.P(120, 155);
+/**
+ * @brief Renders a D-pad at the given logical center, showing directional presses.
+ *
+ * Draws a cross-shaped D-pad centered at (cx, cy) in layout coordinates and highlights
+ * individual directions when the corresponding D-pad buttons in gs are pressed.
+ *
+ * @param dl ImGui draw list used to issue drawing commands.
+ * @param L Layout helper providing coordinate transforms and scaling.
+ * @param gs Current gamepad state used to query directional button presses.
+ * @param cx X coordinate of the D-pad center in logical layout space.
+ * @param cy Y coordinate of the D-pad center in logical layout space.
+ */
+static void DrawDPad(ImDrawList* dl, const Layout& L, const GamepadState& gs, float cx, float cy) {
+    ImVec2 center = L.P(cx, cy);
     float arm = L.S(18);
     float w   = L.S(12);
     float rnd = L.S(3);
@@ -74,17 +164,38 @@ static void DrawDPad(ImDrawList* dl, const Layout& L, const GamepadState& gs) {
             ImVec2(center.x + arm, center.y + w * 0.5f), Lit(), rnd);
 }
 
-static void DrawFaceButtons(ImDrawList* dl, const Layout& L, const GamepadState& gs) {
-    ImVec2 center = L.P(290, 110);
+/**
+ * @brief Render the four face buttons (A/B/X/Y) with colors, labels, and pressed-state visuals.
+ *
+ * Draws four circular face buttons positioned around the given center using the supplied Layout for
+ * scaling and positioning. Each button is filled with its face color when pressed (or a dim fill when
+ * not), has a colored outline, and displays the provided label centered on the button. Button press
+ * state is read from the provided GamepadState.
+ *
+ * @param dl ImGui draw list used to issue the rendering commands.
+ * @param L Layout providing coordinate transforms and scaling.
+ * @param gs Current gamepad state used to determine which face buttons are pressed.
+ * @param cx X coordinate (logical) of the face-button group center.
+ * @param cy Y coordinate (logical) of the face-button group center.
+ * @param labelA Label text to render on the A button.
+ * @param labelB Label text to render on the B button.
+ * @param labelX Label text to render on the X button.
+ * @param labelY Label text to render on the Y button.
+ */
+static void DrawFaceButtons(ImDrawList* dl, const Layout& L, const GamepadState& gs,
+                            float cx, float cy,
+                            const char* labelA, const char* labelB,
+                            const char* labelX, const char* labelY) {
+    ImVec2 center = L.P(cx, cy);
     float spread = L.S(18);
     float r      = L.S(11);
 
     struct FaceBtn { float dx; float dy; Button btn; ImU32 col; const char* label; };
     std::array btns = {
-        FaceBtn{  0,  spread, Button::A, ColorA(), "A" },
-        FaceBtn{  spread,  0, Button::B, ColorB(), "B" },
-        FaceBtn{ -spread,  0, Button::X, ColorX(), "X" },
-        FaceBtn{  0, -spread, Button::Y, ColorY(), "Y" },
+        FaceBtn{  0,  spread, Button::A, ColorA(), labelA },
+        FaceBtn{  spread,  0, Button::B, ColorB(), labelB },
+        FaceBtn{ -spread,  0, Button::X, ColorX(), labelX },
+        FaceBtn{  0, -spread, Button::Y, ColorY(), labelY },
     };
 
     for (auto& fb : btns) {
@@ -150,27 +261,37 @@ static void DrawSmallButton(ImDrawList* dl, const Layout& L,
 }
 
 /**
- * @brief Render a controller panel that visualizes a gamepad's layout and state.
+ * @brief Render a framed controller panel visualizing a gamepad's layout and current state.
  *
- * Renders a framed panel at the given position/size containing a header (built from the player
- * slot, optional display name, and backend name), a connection-status pill, and a scaled
- * representation of the controller showing body, D-pad, face buttons, thumbsticks, bumpers,
- * triggers, and small buttons. When the gamepad is not connected, displays a centered
- * "No controller detected" message instead of the controls.
+ * Renders a header containing the player slot, optional display name, and backend name plus a
+ * connection-status pill, and draws a scaled representation of the controller (body, D‑pad,
+ * face buttons, thumbsticks, bumpers, triggers, and small buttons) inside the panel. If the
+ * gamepad is not connected, displays a centered "No controller detected" message instead of
+ * the controls. If a body texture is provided, it is used for the controller background;
+ * otherwise the body is drawn procedurally.
  *
- * @param dl ImGui draw list to use for low-level drawing operations.
+ * @param dl ImGui draw list used for low-level drawing operations.
  * @param panelPos Top-left corner of the panel in screen coordinates.
  * @param panelSize Width and height of the panel in screen coordinates.
  * @param gs Current gamepad state (buttons, sticks, triggers, connection).
  * @param slotIndex Zero-based player slot index used in the header label.
  * @param backendName Null-terminated string identifying the input backend (shown in header).
  * @param displayName Optional null-terminated display name for the controller; when non-empty
  *                    it is included in the header as "Player N - DisplayName  [backend]".
+ * @param bodyTexture Optional ImGui texture ID to render as the controller body; when null,
+ *                    the procedural body is drawn instead.
+ * @param textureSizeLogical Logical size (width, height) of the provided bodyTexture in the
+ *                           same coordinate space used by the renderer.
+ * @param layoutType LayoutType selecting the coordinate/label set (e.g., Xbox or Sony) used to
+ *                   position and label controls within the rendered controller.
  */
 
 void DrawGamepad(ImDrawList* dl, ImVec2 panelPos, ImVec2 panelSize,
                  const GamepadState& gs, int slotIndex, const char* backendName,
-                 const char* displayName) {
+                 const char* displayName,
+                 ImTextureID bodyTexture,
+                 ImVec2 textureSizeLogical,
+                 LayoutType layoutType) {
     dl->AddRectFilled(panelPos,
         ImVec2(panelPos.x + panelSize.x, panelPos.y + panelSize.y),
         BgDim(), 8.0f);
@@ -228,26 +349,35 @@ void DrawGamepad(ImDrawList* dl, ImVec2 panelPos, ImVec2 panelSize,
         return;
     }
 
-    DrawBody(dl, L);
-    DrawDPad(dl, L, gs);
-    DrawFaceButtons(dl, L, gs);
+    if (bodyTexture != GamepadRenderer::kNoBodyTexture) {
+        ImVec2 tl = L.P(0.f, 0.f);
+        ImVec2 br = L.P(textureSizeLogical.x, textureSizeLogical.y);
+        dl->AddImage(bodyTexture, tl, br, ImVec2(0.f, 0.f), ImVec2(1.f, 1.f));
+    } else {
+        DrawBody(dl, L);
+    }
+
+    const LayoutCoords& c = GetLayoutCoords(layoutType);
+    DrawDPad(dl, L, gs, c.dpadX, c.dpadY);
+    DrawFaceButtons(dl, L, gs, c.faceX, c.faceY,
+                   c.faceLabelA, c.faceLabelB, c.faceLabelX, c.faceLabelY);
 
-    DrawThumbstick(dl, L, L.P(170, 170), gs.leftStickX, gs.leftStickY,
+    DrawThumbstick(dl, L, L.P(c.leftStickX, c.leftStickY), gs.leftStickX, gs.leftStickY,
                    gs.IsPressed(Button::LeftThumb));
-    DrawThumbstick(dl, L, L.P(240, 170), gs.rightStickX, gs.rightStickY,
+    DrawThumbstick(dl, L, L.P(c.rightStickX, c.rightStickY), gs.rightStickX, gs.rightStickY,
                    gs.IsPressed(Button::RightThumb));
 
-    DrawBumper(dl, L, L.P(70, 30), L.P(160, 48), gs.IsPressed(Button::LeftBumper));
-    DrawBumper(dl, L, L.P(240, 30), L.P(330, 48), gs.IsPressed(Button::RightBumper));
+    DrawBumper(dl, L, L.P(c.lbTlX, c.lbTlY), L.P(c.lbBrX, c.lbBrY), gs.IsPressed(Button::LeftBumper));
+    DrawBumper(dl, L, L.P(c.rbTlX, c.rbTlY), L.P(c.rbBrX, c.rbBrY), gs.IsPressed(Button::RightBumper));
 
-    DrawTrigger(dl, L, L.P(50, 2), L.P(80, 28), gs.leftTrigger);
-    DrawTrigger(dl, L, L.P(320, 2), L.P(350, 28), gs.rightTrigger);
+    DrawTrigger(dl, L, L.P(c.ltTlX, c.ltTlY), L.P(c.ltBrX, c.ltBrY), gs.leftTrigger);
+    DrawTrigger(dl, L, L.P(c.rtTlX, c.rtTlY), L.P(c.rtBrX, c.rtBrY), gs.rightTrigger);
 
-    DrawSmallButton(dl, L, L.P(175, 100), L.S(28), L.S(12), "Back",
+    DrawSmallButton(dl, L, L.P(c.backX, c.backY), L.S(28), L.S(12), c.backLabel,
                     gs.IsPressed(Button::Back));
-    DrawSmallButton(dl, L, L.P(200, 118), L.S(22), L.S(12), "Guide",
+    DrawSmallButton(dl, L, L.P(c.guideX, c.guideY), L.S(22), L.S(12), c.guideLabel,
                     gs.IsPressed(Button::Guide));
-    DrawSmallButton(dl, L, L.P(225, 100), L.S(28), L.S(12), "Start",
+    DrawSmallButton(dl, L, L.P(c.startX, c.startY), L.S(28), L.S(12), c.startLabel,
                     gs.IsPressed(Button::Start));
 
     {

res/resource.h

@@ -25,6 +25,30 @@
 	 */
 	namespace GamepadRenderer
 {
+	/**
+	 * @brief Holds an origin and per-axis scale factors for converting logical gamepad coordinates to screen space.
+	 *
+	 * The origin is a screen-space offset applied after scaling. sx and sy are the horizontal and vertical
+	 * scale factors, respectively, used to map logical coordinates into the panel's pixel coordinates.
+	 */
+	
+	/**
+	 * @brief Map a logical (x, y) coordinate to a screen-space point using this layout.
+	 * @param x Logical x coordinate.
+	 * @param y Logical y coordinate.
+	 * @returns Screen-space ImVec2 obtained by applying the per-axis scales and then adding the origin offset.
+	 */
+	
+	/**
+	 * @brief Scale a scalar value uniformly using the smaller of the two axis scales.
+	 * @param v Value in logical units to scale.
+	 * @returns The value multiplied by min(sx, sy).
+	 */
+	enum class LayoutType { Xbox, Sony };
+
+	/** Sentinel for "no body texture" (valid for both pointer and integer ImTextureID backends). */
+	inline constexpr ImTextureID kNoBodyTexture = static_cast<ImTextureID>(0);
+
 	struct Layout
 	{
 		ImVec2 origin;
@@ -40,5 +64,8 @@
 
 	void DrawGamepad(ImDrawList* dl, ImVec2 panelPos, ImVec2 panelSize,
 	                 const GamepadState& gs, int slotIndex, const char* backendName,
-	                 const char* displayName = nullptr);
+	                 const char* displayName = nullptr,
+	                 ImTextureID bodyTexture = kNoBodyTexture,
+	                 ImVec2 textureSizeLogical = ImVec2(400.f, 280.f),
+	                 LayoutType layoutType = LayoutType::Xbox);
 } // namespace GamepadRenderer