Allow selecting skin variant

Moulberry · Moulberry · commit 4a7cb2a63301 · 2026-03-19T20:16:20.000+08:00
diff --git a/crates/backend/src/backend_handler.rs b/crates/backend/src/backend_handler.rs
@@ -5,7 +5,7 @@ use bridge::{
     install::{ContentDownload, ContentInstall, ContentInstallFile, ContentInstallPath, InstallTarget}, instance::{ContentSummary, ContentType}, keep_alive::KeepAlive, message::{AccountCapesResult, AccountSkinResult, BackendConfigWithPassword, EmbeddedOrRaw, LogFiles, MessageToBackend, MessageToFrontend}, meta::MetadataResult, modal_action::{ModalAction, ModalActionVisitUrl, ProgressTracker, ProgressTrackerFinishType}, safe_path::SafePath, serial::AtomicOptionSerial
 };
 use futures::TryFutureExt;
-use schema::{auxiliary::AuxiliaryContentMeta, content::ContentSource, curseforge::{CachedCurseforgeFileInfo, CurseforgeGetFilesRequest, CurseforgeGetModFilesRequest, CurseforgeModLoaderType}, minecraft_profile::MinecraftProfileResponse, modrinth::{ModrinthLoader, ModrinthSideRequirement}, version::{LaunchArgument, LaunchArgumentValue}};
+use schema::{auxiliary::AuxiliaryContentMeta, content::ContentSource, curseforge::{CachedCurseforgeFileInfo, CurseforgeGetFilesRequest, CurseforgeGetModFilesRequest, CurseforgeModLoaderType}, minecraft_profile::{MinecraftProfileResponse, SkinVariant}, modrinth::{ModrinthLoader, ModrinthSideRequirement}, version::{LaunchArgument, LaunchArgumentValue}};
 use serde::{Deserialize, Serialize};
 use strum::IntoEnumIterator;
 use tokio::{io::AsyncBufReadExt, sync::{Semaphore, TryAcquireError}};
@@ -1560,9 +1560,9 @@ impl BackendState {
                     };
 
                     if let Some(skin) = account.active_skin() {
-                        SkinManager::frontend_request(&backend, skin.url.clone(), result);
+                        SkinManager::frontend_request(&backend, skin.url.clone(), skin.variant, result);
                     } else {
-                        _ = result.send(AccountSkinResult::Success { skin: None });
+                        _ = result.send(AccountSkinResult::Success { skin: None, variant: SkinVariant::Classic });
                     }
                 });
             },
@@ -1573,7 +1573,7 @@ impl BackendState {
                 };
 
                 let variant_str = match variant {
-                    schema::minecraft_profile::SkinVariant::Slim => "slim",
+                    SkinVariant::Slim => "slim",
                     _ => "classic",
                 };
 
diff --git a/crates/backend/src/skin_manager.rs b/crates/backend/src/skin_manager.rs
@@ -4,6 +4,7 @@ use bridge::message::{AccountSkinResult, BridgeDataLoadState, MessageToFrontend,
 use image::DynamicImage;
 use parking_lot::RwLock;
 use rustc_hash::FxHashMap;
+use schema::minecraft_profile::SkinVariant;
 use tokio::sync::oneshot::Sender;
 use uuid::Uuid;
 
@@ -34,7 +35,7 @@ impl Default for SkinManager {
 enum SkinEntry {
     Loading {
         accounts: Vec<Uuid>,
-        frontend_requests: Vec<Sender<AccountSkinResult>>,
+        frontend_requests: Vec<(SkinVariant, Sender<AccountSkinResult>)>,
     },
     Loaded {
         skin: Arc<[u8]>,
@@ -57,25 +58,32 @@ impl SkinManager {
     pub fn frontend_request(
         backend: &BackendState,
         skin_url: Arc<str>,
+        skin_variant: SkinVariant,
         send: Sender<AccountSkinResult>
     ) {
         {
             let mut skin_manager = backend.skin_manager.write();
             if let Some(existing) = skin_manager.skins_download.get_mut(&skin_url) {
                 match existing {
                     SkinEntry::Loading { frontend_requests, .. } => {
-                        frontend_requests.push(send);
+                        frontend_requests.push((skin_variant, send));
                     },
                     SkinEntry::Loaded { skin, .. } => {
                         let skin = skin.clone();
                         drop(skin_manager);
-                        _ = send.send(AccountSkinResult::Success { skin: Some(skin) });
+                        _ = send.send(AccountSkinResult::Success {
+                            skin: Some(skin),
+                            variant: skin_variant,
+                        });
                     },
                     SkinEntry::Failed => {}
                 }
                 return;
             }
-            skin_manager.skins_download.insert(skin_url.clone(), SkinEntry::Loading { accounts: Vec::new(), frontend_requests: vec![send] });
+            skin_manager.skins_download.insert(skin_url.clone(), SkinEntry::Loading {
+                accounts: Vec::new(),
+                frontend_requests: vec![(skin_variant, send)]
+            });
         }
 
         Self::download_skin(backend, skin_url);
@@ -119,8 +127,8 @@ impl SkinManager {
         let previous = skin_manager.write().skins_download.insert(skin_url, SkinEntry::Failed);
 
         if let Some(SkinEntry::Loading { frontend_requests, .. }) = previous {
-            for fronend_request in frontend_requests {
-                _ = fronend_request.send(AccountSkinResult::UnableToLoadSkin);
+            for (_, frontend_request) in frontend_requests {
+                _ = frontend_request.send(AccountSkinResult::UnableToLoadSkin);
             }
         }
     }
@@ -188,8 +196,11 @@ impl SkinManager {
                 return;
             };
 
-            for frontend_request in frontend_requests {
-                _ = frontend_request.send(AccountSkinResult::Success { skin: Some(skin.clone()) });
+            for (variant, frontend_request) in frontend_requests {
+                _ = frontend_request.send(AccountSkinResult::Success {
+                    skin: Some(skin.clone()),
+                    variant,
+                });
             }
 
             if accounts.is_empty() {
diff --git a/crates/bridge/src/message.rs b/crates/bridge/src/message.rs
@@ -411,10 +411,12 @@ pub enum EmbeddedOrRaw {
     Raw(Arc<[u8]>),
 }
 
+
 #[derive(Debug, Clone)]
 pub enum AccountSkinResult {
     Success {
         skin: Option<Arc<[u8]>>,
+        variant: SkinVariant,
     },
     NeedsLogin,
     UnableToLoadSkin,
diff --git a/crates/frontend/src/component/player_model.rs b/crates/frontend/src/component/player_model.rs
@@ -1,6 +1,7 @@
 use std::sync::Arc;
 
 use gpui::{App, AppContext, AvailableSpace, Bounds, Element, Entity, IntoElement, RenderImage, Size, Style, Task, px, size};
+use schema::minecraft_profile::SkinVariant;
 
 pub const DEFAULT_YAW: f64 = 22.5;
 pub const DEFAULT_PITCH: f64 = 10.5;
@@ -10,6 +11,7 @@ struct RenderedPlayerModel {
     image: Arc<RenderImage>,
     skin: Arc<[u8]>,
     cape: Option<Arc<[u8]>>,
+    variant: SkinVariant,
     yaw: f64,
     pitch: f64,
     animation: f64,
@@ -20,6 +22,7 @@ struct RenderedPlayerModel {
 pub struct PlayerModelState {
     pub skin: Arc<[u8]>,
     pub cape: Option<Arc<[u8]>>,
+    pub variant: SkinVariant,
     pub yaw: f64,
     pub pitch: f64,
     pub animation: f64,
@@ -28,10 +31,11 @@ pub struct PlayerModelState {
 }
 
 impl PlayerModelState {
-    pub fn new(cx: &mut App, skin: Arc<[u8]>) -> Entity<Self> {
+    pub fn new(cx: &mut App, skin: Arc<[u8]>, variant: SkinVariant) -> Entity<Self> {
         let entity = cx.new(|_| Self {
             skin,
             cape: None,
+            variant,
             yaw: DEFAULT_YAW,
             pitch: DEFAULT_PITCH,
             animation: DEFAULT_ANIMATION,
@@ -52,6 +56,7 @@ impl PlayerModelState {
         };
         if rendered.width != width || rendered.height != height || rendered.yaw != self.yaw
             || rendered.pitch != self.pitch || rendered.animation != self.animation
+            || rendered.variant != self.variant
             || !Arc::ptr_eq(&rendered.skin, &self.skin)
         {
                 return true;
@@ -159,11 +164,12 @@ impl Element for PlayerModel {
                 let yaw = state.yaw;
                 let pitch = state.pitch;
                 let animation = state.animation;
+                let variant = state.variant;
 
                 let (send, recv) = tokio::sync::oneshot::channel();
 
                 cx.background_executor().spawn(async move {
-                    send.send(crate::skin_renderer::render_skin_3d(&skin, cape.as_deref(), image_width, image_height, yaw, pitch, animation))
+                    send.send(crate::skin_renderer::render_skin_3d(&skin, cape.as_deref(), variant, image_width, image_height, yaw, pitch, animation))
                 }).detach();
 
                 let skin = state.skin.clone();
@@ -187,6 +193,7 @@ impl Element for PlayerModel {
                             image: render_image,
                             skin,
                             cape,
+                            variant,
                             yaw,
                             pitch,
                             animation,
diff --git a/crates/frontend/src/component/player_model_widget.rs b/crates/frontend/src/component/player_model_widget.rs
@@ -1,7 +1,8 @@
 use std::{sync::Arc, time::Instant};
 
 use gpui::{prelude::*, *};
-use gpui_component::{Sizable, button::Button, h_flex, slider::{Slider, SliderEvent, SliderState}, v_flex};
+use gpui_component::{Selectable, Sizable, button::Button, h_flex, slider::{Slider, SliderEvent, SliderState}, v_flex};
+use schema::minecraft_profile::SkinVariant;
 
 use crate::{component::player_model::{self, PlayerModel, PlayerModelState}, icon::PandoraIcon};
 
@@ -14,6 +15,7 @@ pub struct PlayerModelWidget {
     animating_pitch_positive: bool,
     animating_pitch: bool,
     animating_animation: bool,
+    variant: SkinVariant,
     last_drag: Option<Point<Pixels>>,
     last_render: Instant,
 }
@@ -30,35 +32,52 @@ impl PlayerModelWidget {
             SliderState::new().min(0.0).max(1.0).step(1.0/800.0).default_value(player_model::DEFAULT_ANIMATION as f32)
         });
 
+        let variant = crate::skin_renderer::determine_skin_variant(&skin).unwrap_or(SkinVariant::Classic);
+
         cx.subscribe(&yaw_slider_state, Self::on_yaw_changed).detach();
         cx.subscribe(&pitch_slider_state, Self::on_pitch_changed).detach();
         cx.subscribe(&animation_slider_state, Self::on_animation_changed).detach();
 
         Self {
-            player_model_state: PlayerModelState::new(cx, skin),
+            player_model_state: PlayerModelState::new(cx, skin, variant),
             yaw_slider_state,
             pitch_slider_state,
             animation_slider_state,
             animating_yaw: false,
             animating_pitch_positive: true,
             animating_pitch: false,
             animating_animation: false,
+            variant,
             last_drag: None,
             last_render: Instant::now(),
         }
     }
 
-    pub fn set_skin(&mut self, cx: &mut App, skin: Arc<[u8]>) {
-        self.player_model_state.as_mut(cx).skin = skin;
+    pub fn set_skin(&mut self, cx: &mut App, skin: Arc<[u8]>, variant: SkinVariant) {
+        self.variant = variant;
+        let mut state = self.player_model_state.as_mut(cx);
+        state.skin = skin;
+        state.variant = variant;
     }
 
     pub fn set_cape(&mut self, cx: &mut App, cape: Option<Arc<[u8]>>) {
         self.player_model_state.as_mut(cx).cape = cape;
     }
 
-    pub fn set_skin_and_cape(&mut self, cx: &mut App, skin: Arc<[u8]>, cape: Option<Arc<[u8]>>) {
+    pub fn set_variant(&mut self, cx: &mut App, variant: SkinVariant) {
+        self.variant = variant;
+        self.player_model_state.as_mut(cx).variant = variant;
+    }
+
+    pub fn get_variant(&self) -> SkinVariant {
+        self.variant
+    }
+
+    pub fn set_skin_and_cape(&mut self, cx: &mut App, skin: Arc<[u8]>, variant: SkinVariant, cape: Option<Arc<[u8]>>) {
+        self.variant = variant;
         let mut state = self.player_model_state.as_mut(cx);
         state.skin = skin;
+        state.variant = variant;
         state.cape = cape;
     }
 
@@ -207,6 +226,30 @@ impl Render for PlayerModelWidget {
                 }))
             )
             .child(v_flex().p_4().w_full()
+                .child(h_flex()
+                    .w_full()
+                    .gap_2()
+                    .pb_2()
+                    .child(Button::new("classic")
+                        .label("Classic")
+                        .flex_1()
+                        .selected(self.variant == SkinVariant::Classic)
+                        .on_click(cx.listener(|this, _, _, cx| {
+                            this.variant = SkinVariant::Classic;
+                            this.player_model_state.update(cx, |state, _| {
+                                state.variant = SkinVariant::Classic;
+                            });
+                        })))
+                    .child(Button::new("slim")
+                        .label("Slim")
+                        .flex_1()
+                        .selected(self.variant == SkinVariant::Slim)
+                        .on_click(cx.listener(|this, _, _, cx| {
+                            this.variant = SkinVariant::Slim;
+                            this.player_model_state.update(cx, |state, _| {
+                                state.variant = SkinVariant::Slim;
+                            });
+                        }))))
                 .child(v_flex()
                     .child(h_flex().text_sm().gap_1()
                         .child(format!("Yaw: {}°", yaw as i32))
diff --git a/crates/frontend/src/pages/skins_page.rs b/crates/frontend/src/pages/skins_page.rs
diff --git a/crates/frontend/src/skin_renderer.rs b/crates/frontend/src/skin_renderer.rs
