とりあえず、VRMを表示できるように。（VRM→glTFはRust側で行う）

Author: logue

backend/src/command.rs

@@ -7,8 +7,9 @@ use vrm2sl_tauri_lib::{
     LogLevel,
     convert::{AnalysisReport, ConversionReport},
     ipc::{
-        AnalyzeRequest, ConvertRequest, LoadSettingsRequest, SaveSettingsRequest, analyze_vrm_ipc,
-        convert_vrm_to_gdb_ipc, load_project_settings_ipc, save_project_settings_ipc,
+        AnalyzeRequest, ConvertRequest, LoadSettingsRequest, PreviewRequest, SaveSettingsRequest,
+        analyze_vrm_ipc, build_preview_glb_ipc, convert_vrm_to_gdb_ipc, load_project_settings_ipc,
+        save_project_settings_ipc,
     },
     project::ProjectSettings,
     send_log_with_handle,
@@ -60,6 +61,23 @@ pub async fn convert_vrm_command(
     result
 }
 
+#[tauri::command]
+pub async fn build_preview_glb_command(
+    request: PreviewRequest,
+    app: AppHandle,
+) -> Result<String, String> {
+    send_log_with_handle(
+        &app,
+        LogLevel::Info,
+        &format!("Build preview GLB request: {}", request.input_path),
+    );
+    let result = build_preview_glb_ipc(request);
+    if result.is_ok() {
+        send_log_with_handle(&app, LogLevel::Info, "Build preview GLB completed");
+    }
+    result
+}
+
 #[tauri::command]
 pub async fn save_project_settings_command(
     request: SaveSettingsRequest,

backend/src/convert.rs

@@ -216,34 +216,48 @@ pub fn analyze_vrm(input_path: &Path, options: ConvertOptions) -> Result<Analysi
         })
         .collect();
 
-    let oversized_count = texture_infos
+    let medium_oversized_count = texture_infos
         .iter()
-        .filter(|texture| texture.width > 1024 || texture.height > 1024)
+        .filter(|texture| {
+            let max_dim = texture.width.max(texture.height);
+            max_dim > 1024 && max_dim <= 2048
+        })
+        .count();
+    let large_oversized_count = texture_infos
+        .iter()
+        .filter(|texture| texture.width.max(texture.height) > 2048)
         .count();
 
-    if oversized_count > 0 {
+    if medium_oversized_count > 0 {
         issues.push(ValidationIssue {
-            severity: if options.texture_auto_resize {
-                Severity::Info
-            } else {
-                Severity::Warning
-            },
-            code: "TEXTURE_OVERSIZE".to_string(),
+            severity: Severity::Warning,
+            code: "TEXTURE_OVERSIZE_1024_2048".to_string(),
+            message: format!(
+                "⚠️ Detected {} texture(s) with max edge between 1025 and 2048. Enable the 1024px resize option if you want to downscale them",
+                medium_oversized_count
+            ),
+        });
+    }
+
+    if large_oversized_count > 0 {
+        issues.push(ValidationIssue {
+            severity: Severity::Warning,
+            code: "TEXTURE_OVERSIZE_OVER_2048".to_string(),
             message: if options.texture_auto_resize {
                 format!(
-                    "⚠️ Detected {} oversized texture(s). They will be resized to a 1024px max on export",
-                    oversized_count
+                    "⚠️ Detected {} texture(s) larger than 2048. They will be resized to a 1024px max on export",
+                    large_oversized_count
                 )
             } else {
                 format!(
-                    "⚠️ Detected {} oversized texture(s). Second Life upload cost may increase",
-                    oversized_count
+                    "⚠️ Detected {} texture(s) larger than 2048. They will be resized to a 2048px max on export",
+                    large_oversized_count
                 )
             },
         });
     }
 
-    let fee_estimate = estimate_texture_fee(&texture_infos);
+    let fee_estimate = estimate_texture_fee(&texture_infos, options.texture_auto_resize);
 
     let estimated_height_cm = estimate_height_cm(&document, &buffers).unwrap_or(170.0);
 
@@ -521,7 +535,10 @@ fn collect_mesh_statistics(document: &Document) -> (usize, usize, Vec<Validation
 }
 
 /// Estimate texture upload fees before/after resize policy.
-fn estimate_texture_fee(texture_infos: &[TextureInfo]) -> UploadFeeEstimate {
+fn estimate_texture_fee(
+    texture_infos: &[TextureInfo],
+    auto_resize_to_1024: bool,
+) -> UploadFeeEstimate {
     let before = texture_infos
         .iter()
         .map(|texture| fee_per_texture(texture.width, texture.height))
@@ -530,9 +547,9 @@ fn estimate_texture_fee(texture_infos: &[TextureInfo]) -> UploadFeeEstimate {
     let after = texture_infos
         .iter()
         .map(|texture| {
-            let clamped_width = texture.width.min(1024);
-            let clamped_height = texture.height.min(1024);
-            fee_per_texture(clamped_width, clamped_height)
+            let (projected_width, projected_height) =
+                projected_texture_size(texture.width, texture.height, auto_resize_to_1024);
+            fee_per_texture(projected_width, projected_height)
         })
         .sum::<u32>();
 
@@ -549,6 +566,29 @@ fn estimate_texture_fee(texture_infos: &[TextureInfo]) -> UploadFeeEstimate {
     }
 }
 
+/// Estimate texture size after export policy is applied.
+fn projected_texture_size(width: u32, height: u32, auto_resize_to_1024: bool) -> (u32, u32) {
+    let max_dim = width.max(height);
+    let target_max = if max_dim <= 1024 {
+        1024
+    } else if max_dim <= 2048 {
+        if auto_resize_to_1024 { 1024 } else { max_dim }
+    } else if auto_resize_to_1024 {
+        1024
+    } else {
+        2048
+    };
+
+    if max_dim <= target_max {
+        return (width, height);
+    }
+
+    let scale = target_max as f64 / max_dim as f64;
+    let projected_width = (width as f64 * scale).round().max(1.0) as u32;
+    let projected_height = (height as f64 * scale).round().max(1.0) as u32;
+    (projected_width, projected_height)
+}
+
 /// Estimate fee per texture based on max dimension bands.
 fn fee_per_texture(width: u32, height: u32) -> u32 {
     let max_dim = width.max(height);
@@ -619,9 +659,12 @@ fn transform_and_write_glb(
     remove_unsupported_features(&mut json);
     apply_uniform_scale_to_scene_roots(&mut json, scale_factor);
 
-    if texture_auto_resize {
-        apply_texture_resize_to_embedded_images(&mut json, &mut bin, texture_resize_method)?;
-    }
+    apply_texture_resize_to_embedded_images(
+        &mut json,
+        &mut bin,
+        texture_auto_resize,
+        texture_resize_method,
+    )?;
 
     let json_bytes =
         serde_json::to_vec(&json).context("failed to serialize transformed glTF JSON")?;
@@ -651,6 +694,7 @@ fn transform_and_write_glb(
 fn apply_texture_resize_to_embedded_images(
     json: &mut Value,
     bin: &mut Vec<u8>,
+    auto_resize_to_1024: bool,
     interpolation: ResizeInterpolation,
 ) -> Result<()> {
     let Some(buffer_views) = json.get("bufferViews").and_then(Value::as_array) else {
@@ -700,11 +744,22 @@ fn apply_texture_resize_to_embedded_images(
             let decoded = image::load_from_memory(image_bytes)
                 .with_context(|| format!("failed to decode embedded texture view {view_index}"))?;
 
-            if decoded.width() <= 1024 && decoded.height() <= 1024 {
-                continue;
-            }
+            let max_dim = decoded.width().max(decoded.height());
+            let target_max = if max_dim <= 1024 {
+                1024
+            } else if max_dim <= 2048 {
+                if auto_resize_to_1024 { 1024 } else { max_dim }
+            } else if auto_resize_to_1024 {
+                1024
+            } else {
+                2048
+            };
 
-            let resized = resize_texture_to_max(&decoded, 1024, 1024, interpolation);
+            let resized = if max_dim > target_max {
+                resize_texture_to_max(&decoded, target_max, target_max, interpolation)
+            } else {
+                decoded
+            };
             let mut encoded = Vec::<u8>::new();
             resized
                 .write_to(&mut Cursor::new(&mut encoded), image_format)
@@ -976,11 +1031,25 @@ mod tests {
             },
         ];
 
-        let estimate = estimate_texture_fee(&textures);
+        let estimate = estimate_texture_fee(&textures, true);
         assert!(estimate.before_linden_dollar > estimate.after_resize_linden_dollar);
         assert!(estimate.reduction_percent > 0);
     }
 
+    #[test]
+    fn given_large_texture_when_1024_resize_disabled_then_policy_caps_at_2048() {
+        let (width, height) = projected_texture_size(4096, 2048, false);
+        assert_eq!(width, 2048);
+        assert_eq!(height, 1024);
+    }
+
+    #[test]
+    fn given_mid_texture_when_1024_resize_disabled_then_size_is_kept() {
+        let (width, height) = projected_texture_size(1800, 900, false);
+        assert_eq!(width, 1800);
+        assert_eq!(height, 900);
+    }
+
     #[test]
     fn given_required_hierarchy_when_parent_mismatch_then_error_is_reported() {
         let humanoid_bone_nodes = ["hips", "spine", "chest"]

backend/src/ipc.rs

@@ -1,4 +1,8 @@
-use std::path::PathBuf;
+use std::{
+    fs,
+    path::PathBuf,
+    time::{SystemTime, UNIX_EPOCH},
+};
 
 use serde::{Deserialize, Serialize};
 
@@ -38,6 +42,13 @@ pub struct LoadSettingsRequest {
     pub path: String,
 }
 
+/// IPC payload for generating a backend-side preview GLB.
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct PreviewRequest {
+    pub input_path: String,
+    pub options: ConvertOptions,
+}
+
 /// Analyze a source model through the IPC boundary.
 pub fn analyze_vrm_ipc(request: AnalyzeRequest) -> Result<AnalysisReport, String> {
     let input = PathBuf::from(&request.input_path);
@@ -65,6 +76,16 @@ pub fn convert_vrm_to_gdb_ipc(request: ConvertRequest) -> Result<ConversionRepor
     Ok(report)
 }
 
+/// Build a preview GLB file through the IPC boundary and return its path.
+pub fn build_preview_glb_ipc(request: PreviewRequest) -> Result<String, String> {
+    let input = PathBuf::from(&request.input_path);
+    let output = create_preview_output_path().map_err(|err| err.to_string())?;
+
+    convert_vrm_to_gdb(&input, &output, request.options).map_err(|err| err.to_string())?;
+
+    Ok(output.to_string_lossy().to_string())
+}
+
 /// Save project settings through the IPC boundary.
 pub fn save_project_settings_ipc(request: SaveSettingsRequest) -> Result<(), String> {
     let path = PathBuf::from(request.path);
@@ -76,3 +97,14 @@ pub fn load_project_settings_ipc(request: LoadSettingsRequest) -> Result<Project
     let path = PathBuf::from(request.path);
     load_project_settings(&path).map_err(|err| err.to_string())
 }
+
+fn create_preview_output_path() -> anyhow::Result<PathBuf> {
+    let mut dir = std::env::temp_dir();
+    dir.push("vrm2sl-preview");
+    fs::create_dir_all(&dir)?;
+
+    let timestamp = SystemTime::now().duration_since(UNIX_EPOCH)?.as_millis();
+    let file_name = format!("preview-{}-{}.glb", std::process::id(), timestamp);
+
+    Ok(dir.join(file_name))
+}

backend/src/main.rs

@@ -16,6 +16,7 @@ fn main() {
         .invoke_handler(tauri::generate_handler![
             command::analyze_vrm_command,
             command::convert_vrm_command,
+            command::build_preview_glb_command,
             command::save_project_settings_command,
             command::load_project_settings_command,
             command::get_app_version,

frontend/package.json

@@ -43,6 +43,7 @@
     "@tauri-apps/plugin-os": "^2.3.2",
     "pinia": "^3.0.4",
     "pinia-plugin-persistedstate": "^4.7.1",
+    "three": "^0.183.1",
     "unified-network": "^0.6.4",
     "vue": "^3.5.29",
     "vue-i18n": "^11.2.8",
@@ -55,6 +56,7 @@
     "@tauri-apps/cli": "^2.10.0",
     "@tsconfig/node-lts": "^24.0.0",
     "@types/node": "^25.3.0",
+    "@types/three": "^0.183.1",
     "@vitejs/plugin-vue": "^6.0.4",
     "@vue/eslint-config-prettier": "^10.2.0",
     "@vue/eslint-config-typescript": "^14.7.0",

frontend/src/Meta.ts

@@ -3,6 +3,6 @@ import type MetaInterface from '@/interfaces/MetaInterface';
 // This file is auto-generated by the build system.
 const meta: MetaInterface = {
   version: '0.0.0',
-  date: '2026-02-26T02:00:50.275Z'
+  date: '2026-02-26T04:28:40.837Z',
 };
 export default meta;