644 lines
25 KiB
C#
644 lines
25 KiB
C#
#nullable enable
|
|
using Cysharp.Threading.Tasks;
|
|
using GLTFast;
|
|
using System;
|
|
using System.Collections.Generic;
|
|
using System.Threading;
|
|
using UnityEngine;
|
|
using UnityEngine.UI;
|
|
using UVC.UI.List.Tree;
|
|
using UVC.Util;
|
|
|
|
namespace SHI.modal
|
|
{
|
|
public class ModelDetailView : MonoBehaviour
|
|
{
|
|
public Action<TreeListItemData>? OnItemSelected;
|
|
|
|
[Header("View Output (UI)")]
|
|
[SerializeField] private RawImage outputImage;
|
|
[SerializeField] private Color backgroundColor = new Color(0.2f, 0.2f, 0.22f, 1f);
|
|
[Tooltip("전용 카메라가 렌더링할 레이어. 모델 노드에 재귀적으로 적용됩니다.")]
|
|
[SerializeField] private int modelLayer = 6;
|
|
[SerializeField] private bool createDefaultLight = true;
|
|
|
|
[Header("Mouse Controls")]
|
|
[SerializeField] private float panSpeed = 1.0f; // 픽셀→월드 스케일 보정 계수
|
|
[SerializeField] private float rotateDegPerPixel = 0.2f; // RMB 회전(도/픽셀)
|
|
[SerializeField] private float zoomSpeed = 5f; // 휠 전/후 모델 이동 속도
|
|
|
|
[Header("Output Image Setup")]
|
|
[SerializeField] private bool autoCreateOutputImage = true;
|
|
[SerializeField] private bool autoApplyRectMask = true;
|
|
|
|
[Header("Wireframe")]
|
|
[SerializeField] private bool wireframeMode = false; // 켜면 라인만 렌더
|
|
|
|
private UnityEngine.Camera _viewCamera;
|
|
private RenderTexture _rt;
|
|
private Material _wireframeMat; // Resources에서 로드한 메터리얼
|
|
private bool _wireframeApplied;
|
|
|
|
// Orbit controls state (카메라 위치 계산용)
|
|
private Vector3 _orbitTarget;
|
|
private float _orbitDistance = 5f;
|
|
private float _yaw = 0f;
|
|
private float _pitch = 20f;
|
|
|
|
// Drag state
|
|
private bool _mmbDragging;
|
|
private bool _rmbDragging;
|
|
private Vector3 _mmbLastPos;
|
|
private Vector3 _rmbStartPos;
|
|
private float _yawStart;
|
|
private float _pitchStart;
|
|
private Quaternion _modelStartRot;
|
|
private Vector3 _modelStartPos; // RMB 드래그 시작 시 모델 위치
|
|
private Vector3 _rmbPivot; // RMB 회전의 피벗(모델 중심)
|
|
|
|
private readonly Dictionary<Guid, GameObject> _idToObject = new Dictionary<Guid, GameObject>();
|
|
private readonly Dictionary<GameObject, (Renderer[] rends, UnityEngine.Material[][] originals)> _matCache = new Dictionary<GameObject, (Renderer[], UnityEngine.Material[][])>();
|
|
private GameObject? _root;
|
|
private Guid? _focusedId;
|
|
|
|
|
|
public async UniTask<IEnumerable<ModelDetailListItemData>> LoadModelAsync(string path, CancellationToken ct)
|
|
{
|
|
Debug.Log($"ModelDetailView.LoadModelAsync: {path}");
|
|
Dispose();
|
|
await UniTask.DelayFrame(1); // Dispose 후1프레임 대기하여 리소스 해제 안정화
|
|
EnsureCameraAndTargetTexture();
|
|
|
|
var items = new List<ModelDetailListItemData>();
|
|
var gltf = new GltfImport();
|
|
var success = await gltf.Load(path, new ImportSettings(), ct);
|
|
if (!success)
|
|
{
|
|
Debug.LogError($"glTFast Load failed: {path}");
|
|
return items;
|
|
}
|
|
|
|
_root = new GameObject("ModelDetailViewRoot");
|
|
_root.layer = modelLayer;
|
|
var sceneOk = await gltf.InstantiateMainSceneAsync(_root.transform);
|
|
if (!sceneOk)
|
|
{
|
|
Debug.LogError("InstantiateMainSceneAsync failed");
|
|
return items;
|
|
}
|
|
|
|
SetLayerRecursive(_root, modelLayer);
|
|
|
|
// Build hierarchical item data preserving parent-child relationships
|
|
if (_root != null)
|
|
{
|
|
for (int i = 0; i < _root.transform.childCount; i++)
|
|
{
|
|
var child = _root.transform.GetChild(i);
|
|
var topItem = BuildItemRecursive(child, _root.transform);
|
|
if (topItem != null)
|
|
{
|
|
items.Add(topItem);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
var bounds = CalculateBounds(_root);
|
|
FrameToBounds(bounds);
|
|
|
|
// 요청: Resources/SHI/Shader/BasicWireframe 메터리얼 적용
|
|
TryLoadWireframeMaterial();
|
|
if (wireframeMode && _wireframeMat != null)
|
|
{
|
|
ApplyWireframeMaterialToRoot();
|
|
}
|
|
|
|
return items;
|
|
}
|
|
|
|
private ModelDetailListItemData BuildItemRecursive(Transform node, Transform root)
|
|
{
|
|
var data = new ModelDetailListItemData
|
|
{
|
|
Name = node.name,
|
|
ExternalKey = BuildFullPath(node, root)
|
|
};
|
|
|
|
// map id -> object for selection/highlight and cache materials at this subtree root
|
|
_idToObject[data.Id] = node.gameObject;
|
|
CacheOriginalMaterials(node.gameObject);
|
|
|
|
// children
|
|
for (int i = 0; i < node.childCount; i++)
|
|
{
|
|
var child = node.GetChild(i);
|
|
var childData = BuildItemRecursive(child, root);
|
|
data.AddChild(childData);
|
|
}
|
|
return data;
|
|
}
|
|
|
|
private void TryLoadWireframeMaterial()
|
|
{
|
|
if (_wireframeMat == null)
|
|
{
|
|
_wireframeMat = Resources.Load<Material>("SHI/Shader/BasicWireframe");
|
|
if (_wireframeMat == null)
|
|
{
|
|
Debug.LogWarning("BasicWireframe material not found at Resources/SHI/Shader/BasicWireframe. Wireframe will be disabled.");
|
|
}
|
|
}
|
|
}
|
|
|
|
private void ApplyWireframeMaterialToRoot()
|
|
{
|
|
if (_root == null || _wireframeMat == null) return;
|
|
var rends = _root.GetComponentsInChildren<Renderer>(true);
|
|
foreach (var r in rends)
|
|
{
|
|
if (r == null) continue;
|
|
var count = Mathf.Max(1, r.sharedMaterials.Length);
|
|
var arr = new Material[count];
|
|
for (int i = 0; i < count; i++) arr[i] = _wireframeMat;
|
|
r.sharedMaterials = arr;
|
|
}
|
|
_wireframeApplied = true;
|
|
}
|
|
|
|
private void RestoreAllOriginalMaterials()
|
|
{
|
|
foreach (var kv in _matCache)
|
|
{
|
|
var (rends, originals) = kv.Value;
|
|
for (int i = 0; i < rends.Length; i++)
|
|
{
|
|
if (rends[i] == null) continue;
|
|
rends[i].sharedMaterials = originals[i];
|
|
}
|
|
}
|
|
_wireframeApplied = false;
|
|
}
|
|
|
|
|
|
private void EnsureCameraAndTargetTexture()
|
|
{
|
|
EnsureOutputImageUI();
|
|
|
|
if (_viewCamera == null)
|
|
{
|
|
// Create a world-space rig not parented to UI to avoid layout side effects
|
|
var rig = new GameObject("ModelDetailViewRig");
|
|
rig.layer = modelLayer;
|
|
rig.transform.SetParent(null, false);
|
|
|
|
var camGo = new GameObject("ModelDetailViewCamera");
|
|
camGo.layer = modelLayer;
|
|
camGo.transform.SetParent(rig.transform, false);
|
|
_viewCamera = camGo.AddComponent<UnityEngine.Camera>();
|
|
_viewCamera.clearFlags = CameraClearFlags.SolidColor;
|
|
_viewCamera.backgroundColor = backgroundColor;
|
|
_viewCamera.nearClipPlane = 0.01f;
|
|
_viewCamera.farClipPlane = 5000f;
|
|
_viewCamera.cullingMask = (modelLayer >= 0 && modelLayer <= 31) ? (1 << modelLayer) : ~0;
|
|
// Prevent drawing to main display when no RT assigned
|
|
_viewCamera.targetDisplay = 1; // secondary display
|
|
_viewCamera.enabled = false; // enable only when RT is bound
|
|
}
|
|
|
|
// optional default light (independent of UI)
|
|
if (createDefaultLight && _viewCamera.transform.parent != null && _viewCamera.transform.parent.Find("ModelDetailViewLight") == null)
|
|
{
|
|
var lightGo = new GameObject("ModelDetailViewLight");
|
|
lightGo.layer = modelLayer;
|
|
lightGo.transform.SetParent(_viewCamera.transform.parent, false);
|
|
lightGo.transform.localPosition = Vector3.zero;
|
|
lightGo.transform.localRotation = Quaternion.Euler(50f, -30f, 0f);
|
|
var light = lightGo.AddComponent<Light>();
|
|
light.type = LightType.Directional;
|
|
light.intensity = 1.1f;
|
|
light.shadows = LightShadows.Soft;
|
|
}
|
|
|
|
EnsureRenderTargetSize();
|
|
}
|
|
|
|
private void EnsureOutputImageUI()
|
|
{
|
|
var selfRt = GetComponent<RectTransform>();
|
|
if (autoApplyRectMask && selfRt != null && selfRt.GetComponent<RectMask2D>() == null)
|
|
{
|
|
selfRt.gameObject.AddComponent<RectMask2D>();
|
|
}
|
|
|
|
if (outputImage == null && autoCreateOutputImage)
|
|
{
|
|
var go = new GameObject("OutputImage", typeof(RectTransform), typeof(RawImage));
|
|
go.transform.SetParent(transform, false);
|
|
outputImage = go.GetComponent<RawImage>();
|
|
}
|
|
|
|
if (outputImage != null)
|
|
{
|
|
var rt = outputImage.rectTransform;
|
|
rt.anchorMin = Vector2.zero;
|
|
rt.anchorMax = Vector2.one;
|
|
rt.offsetMin = Vector2.zero;
|
|
rt.offsetMax = Vector2.zero;
|
|
}
|
|
}
|
|
|
|
private void EnsureRenderTargetSize()
|
|
{
|
|
if (_viewCamera == null)
|
|
{
|
|
return;
|
|
}
|
|
if (outputImage == null)
|
|
{
|
|
// No output target; keep camera disabled to avoid drawing to display
|
|
_viewCamera.enabled = false;
|
|
return;
|
|
}
|
|
var rtf = outputImage.rectTransform;
|
|
int w = Mathf.Max(64, Mathf.RoundToInt(rtf.rect.width));
|
|
int h = Mathf.Max(64, Mathf.RoundToInt(rtf.rect.height));
|
|
if (_rt == null || _rt.width != w || _rt.height != h)
|
|
{
|
|
// release old
|
|
if (_rt != null)
|
|
{
|
|
if (_viewCamera.targetTexture == _rt) _viewCamera.targetTexture = null;
|
|
_rt.Release();
|
|
Destroy(_rt);
|
|
}
|
|
// create new
|
|
_rt = new RenderTexture(w, h, 24, RenderTextureFormat.ARGB32)
|
|
{
|
|
name = "ModelDetailViewRT",
|
|
antiAliasing = 2
|
|
};
|
|
_viewCamera.targetTexture = _rt;
|
|
outputImage.texture = _rt;
|
|
// enable camera only when RT is assigned
|
|
_viewCamera.enabled = true;
|
|
}
|
|
else
|
|
{
|
|
// ensure binding and enable
|
|
if (_viewCamera.targetTexture != _rt)
|
|
{
|
|
_viewCamera.targetTexture = _rt;
|
|
}
|
|
if (!_viewCamera.enabled) _viewCamera.enabled = true;
|
|
}
|
|
}
|
|
|
|
protected void OnRectTransformDimensionsChange()
|
|
{
|
|
// Keep RT in sync with UI size changes (e.g., parent resized)
|
|
EnsureRenderTargetSize();
|
|
}
|
|
|
|
// Allow external toggle
|
|
public void SetWireframe(bool on)
|
|
{
|
|
wireframeMode = on;
|
|
TryLoadWireframeMaterial();
|
|
if (_wireframeMat != null)
|
|
{
|
|
if (on) ApplyWireframeMaterialToRoot(); else RestoreAllOriginalMaterials();
|
|
}
|
|
else
|
|
{
|
|
Debug.LogWarning("Wireframe material not found. Wireframe toggle ignored.");
|
|
}
|
|
}
|
|
|
|
private static void SetLayerRecursive(GameObject go, int layer)
|
|
{
|
|
if (layer < 0 || layer > 31) return;
|
|
go.layer = layer;
|
|
foreach (Transform c in go.transform) SetLayerRecursive(c.gameObject, layer);
|
|
}
|
|
|
|
private static Bounds CalculateBounds(GameObject root)
|
|
{
|
|
var rends = root.GetComponentsInChildren<Renderer>(true);
|
|
var has = false;
|
|
var bounds = new Bounds(root.transform.position, Vector3.zero);
|
|
foreach (var r in rends)
|
|
{
|
|
if (r == null) continue;
|
|
if (!has) { bounds = r.bounds; has = true; }
|
|
else bounds.Encapsulate(r.bounds);
|
|
}
|
|
if (!has) bounds = new Bounds(root.transform.position, Vector3.one);
|
|
return bounds;
|
|
}
|
|
|
|
private void FrameToBounds(Bounds b)
|
|
{
|
|
if (_viewCamera == null) return;
|
|
var center = b.center;
|
|
var extents = b.extents;
|
|
float radius = Mathf.Max(extents.x, Mathf.Max(extents.y, Mathf.Max(extents.z, 0.001f)));
|
|
float fovRad = _viewCamera.fieldOfView * Mathf.Deg2Rad;
|
|
float dist = radius / Mathf.Sin(fovRad * 0.5f);
|
|
dist = Mathf.Clamp(dist, 1f, 1e4f);
|
|
_viewCamera.transform.position = center + new Vector3(1, 0.5f, 1).normalized * dist;
|
|
_viewCamera.transform.LookAt(center);
|
|
//_viewCamera.nearClipPlane = Mathf.Max(0.01f, dist - radius * 2f);
|
|
//_viewCamera.farClipPlane = dist + radius * 4f;
|
|
|
|
_orbitTarget = center;
|
|
_orbitDistance = Vector3.Distance(_viewCamera.transform.position, _orbitTarget);
|
|
var dir = (_viewCamera.transform.position - _orbitTarget).normalized;
|
|
_yaw = Mathf.Atan2(dir.x, dir.z) * Mathf.Rad2Deg;
|
|
_pitch = Mathf.Asin(dir.y) * Mathf.Rad2Deg;
|
|
}
|
|
|
|
private string BuildFullPath(Transform node, Transform root)
|
|
{
|
|
var stack = new Stack<string>();
|
|
var current = node;
|
|
while (current != null && current != root)
|
|
{
|
|
stack.Push(current.name);
|
|
current = current.parent;
|
|
}
|
|
return "/" + string.Join('/', stack);
|
|
}
|
|
|
|
private void CacheOriginalMaterials(GameObject go)
|
|
{
|
|
var rends = go.GetComponentsInChildren<Renderer>(true);
|
|
if (rends.Length == 0) return;
|
|
var originals = new UnityEngine.Material[rends.Length][];
|
|
for (int i = 0; i < rends.Length; i++) originals[i] = rends[i].sharedMaterials;
|
|
_matCache[go] = (rends, originals);
|
|
}
|
|
|
|
public void FocusItem(TreeListItemData data)
|
|
{
|
|
if (data == null) return;
|
|
FocusItemById(data.Id);
|
|
}
|
|
|
|
public void FocusItemById(Guid id)
|
|
{
|
|
_focusedId = id;
|
|
if (_idToObject.TryGetValue(id, out var go))
|
|
{
|
|
Highlight(go, true);
|
|
Debug.Log($"ModelDetailView.FocusItemById: {go.name}");
|
|
_orbitTarget = go.transform.position;
|
|
}
|
|
}
|
|
|
|
public void UnfocusItem()
|
|
{
|
|
if (_focusedId.HasValue && _idToObject.TryGetValue(_focusedId.Value, out var go))
|
|
{
|
|
Highlight(go, false);
|
|
}
|
|
_focusedId = null;
|
|
}
|
|
|
|
public void SetVisibility(Guid id, bool on)
|
|
{
|
|
Debug.Log($"ModelDetailView.SetVisibility: id={id} on={on}");
|
|
if (_idToObject.TryGetValue(id, out var go))
|
|
{
|
|
go.SetActive(on);
|
|
}
|
|
}
|
|
|
|
// Common color property names across pipelines/shaders
|
|
private static readonly string[] ColorProps = new[] {
|
|
"_WireframeColor", "_WireColor", // wireframe shader variants
|
|
"_BaseColor", "_Color", "_LineColor", "_TintColor"
|
|
};
|
|
|
|
private bool TrySetColor(Material mat, Color c)
|
|
{
|
|
for (int i = 0; i < ColorProps.Length; i++)
|
|
{
|
|
var prop = ColorProps[i];
|
|
if (mat != null && mat.HasProperty(prop)) { mat.SetColor(prop, c); return true; }
|
|
}
|
|
// fallback to material.color if supported
|
|
try { mat.color = c; return true; } catch { /* ignore */ }
|
|
return false;
|
|
}
|
|
|
|
private bool TryGetColor(Material mat, out Color c)
|
|
{
|
|
for (int i = 0; i < ColorProps.Length; i++)
|
|
{
|
|
var prop = ColorProps[i];
|
|
if (mat != null && mat.HasProperty(prop)) { c = mat.GetColor(prop); return true; }
|
|
}
|
|
try { c = mat.color; return true; } catch { /* ignore */ }
|
|
c = ColorUtil.FromHex("#888888"); return false;
|
|
}
|
|
|
|
private bool TryGetDefaultWireColor(out Color c)
|
|
{
|
|
if (_wireframeMat != null && TryGetColor(_wireframeMat, out c)) return true;
|
|
c = ColorUtil.FromHex("#888888"); return false;
|
|
}
|
|
|
|
private void Highlight(GameObject go, bool on)
|
|
{
|
|
if (!_matCache.TryGetValue(go, out var tuple)) return;
|
|
var (rends, originals) = tuple;
|
|
|
|
for (int i = 0; i < rends.Length; i++)
|
|
{
|
|
var r = rends[i];
|
|
if (r == null) continue;
|
|
|
|
// Work on instantiated materials to avoid touching shared assets
|
|
var mats = r.materials;
|
|
for (int m = 0; m < mats.Length; m++)
|
|
{
|
|
if (on)
|
|
{
|
|
// set to highlight color regardless of shader
|
|
TrySetColor(mats[m], ColorUtil.FromHex("#888814"));
|
|
}
|
|
else
|
|
{
|
|
// When in wireframe mode (material replaced) restore to default wireframe color.
|
|
bool matIsWire = mats[m] != null && (mats[m].HasProperty("_WireframeColor") || mats[m].HasProperty("_WireColor"));
|
|
if (_wireframeApplied || matIsWire)
|
|
{
|
|
Color baseWire;
|
|
if (TryGetDefaultWireColor(out baseWire))
|
|
TrySetColor(mats[m], baseWire);
|
|
else
|
|
TrySetColor(mats[m], ColorUtil.FromHex("#888888"));
|
|
}
|
|
else
|
|
{
|
|
// restore to original color if known; otherwise white
|
|
Color orig;
|
|
if (i < originals.Length && m < originals[i].Length && originals[i][m] != null && TryGetColor(originals[i][m], out orig))
|
|
TrySetColor(mats[m], orig);
|
|
else
|
|
TrySetColor(mats[m], ColorUtil.FromHex("#888888"));
|
|
}
|
|
}
|
|
}
|
|
r.materials = mats;
|
|
}
|
|
}
|
|
|
|
|
|
public void RaiseSelected(TreeListItemData data)
|
|
{
|
|
OnItemSelected?.Invoke(data);
|
|
}
|
|
|
|
private void Update()
|
|
{
|
|
if (_viewCamera == null) return;
|
|
|
|
// 영역 히트테스트
|
|
if (outputImage != null)
|
|
{
|
|
var cam = outputImage.canvas != null && outputImage.canvas.renderMode != RenderMode.ScreenSpaceOverlay
|
|
? outputImage.canvas.worldCamera
|
|
: null;
|
|
if (!RectTransformUtility.RectangleContainsScreenPoint(outputImage.rectTransform, Input.mousePosition, cam))
|
|
{
|
|
return;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
var selfRt = GetComponent<RectTransform>();
|
|
if (selfRt != null)
|
|
{
|
|
var parentCanvas = selfRt.GetComponentInParent<Canvas>();
|
|
UnityEngine.Camera uiCam = null;
|
|
if (parentCanvas != null && parentCanvas.renderMode != RenderMode.ScreenSpaceOverlay)
|
|
uiCam = parentCanvas.worldCamera;
|
|
if (!RectTransformUtility.RectangleContainsScreenPoint(selfRt, Input.mousePosition, uiCam))
|
|
return;
|
|
}
|
|
}
|
|
|
|
// 드래그 상태 전이 처리 (점프 방지)
|
|
if (Input.GetMouseButtonDown(2)) { _mmbDragging = true; _mmbLastPos = Input.mousePosition; }
|
|
if (Input.GetMouseButtonUp(2)) { _mmbDragging = false; }
|
|
if (Input.GetMouseButtonDown(1)) { _rmbDragging = true; _rmbStartPos = Input.mousePosition; _yawStart = _yaw; _pitchStart = _pitch; if (_root != null) { _modelStartRot = _root.transform.rotation; _modelStartPos = _root.transform.position; } _rmbPivot = _orbitTarget; }
|
|
if (Input.GetMouseButtonUp(1)) { _rmbDragging = false; }
|
|
|
|
// 가운데 버튼: 모델 이동 (좌/우/상/하) - 카메라 기준, 픽셀 델타 기반
|
|
if (_mmbDragging && _root != null)
|
|
{
|
|
Vector3 cur = Input.mousePosition;
|
|
Vector2 dp = (Vector2)(cur - _mmbLastPos);
|
|
_mmbLastPos = cur;
|
|
// 뷰 사각 픽셀 크기 구하기
|
|
float wPix, hPix;
|
|
if (outputImage != null)
|
|
{ var r = outputImage.rectTransform.rect; wPix = Mathf.Max(1f, r.width); hPix = Mathf.Max(1f, r.height); }
|
|
else
|
|
{ var rt = GetComponent<RectTransform>(); var r = (rt != null) ? rt.rect : new Rect(0, 0, Screen.width, Screen.height); wPix = Mathf.Max(1f, r.width); hPix = Mathf.Max(1f, r.height); }
|
|
// 카메라에서의 월드/픽셀 스케일(거리 기반)
|
|
float halfV = Mathf.Tan(_viewCamera.fieldOfView * Mathf.Deg2Rad * 0.5f) * _orbitDistance;
|
|
float halfH = halfV * _viewCamera.aspect;
|
|
float worldPerPixelX = (halfH * 2f) / wPix * panSpeed;
|
|
float worldPerPixelY = (halfV * 2f) / hPix * panSpeed;
|
|
Vector3 deltaModel = _viewCamera.transform.right * (dp.x * worldPerPixelX) + _viewCamera.transform.up * (dp.y * worldPerPixelY);
|
|
_root.transform.position += deltaModel;
|
|
_orbitTarget += deltaModel;
|
|
}
|
|
|
|
// 마우스 휠: 모델 전/후 이동(카메라 기준)
|
|
float scroll = Input.GetAxis("Mouse ScrollWheel");
|
|
if (Mathf.Abs(scroll) > 1e-5f && _root != null)
|
|
{
|
|
var forward = _viewCamera.transform.forward;
|
|
Vector3 deltaZ = forward * (-scroll * zoomSpeed);
|
|
_root.transform.position += deltaZ;
|
|
_orbitTarget += deltaZ;
|
|
}
|
|
|
|
// 오른쪽 버튼: 모델 회전 (카메라 기준 yaw/pitch) - 모델 중심(_orbitTarget) 기준으로 회전
|
|
if (_rmbDragging && _root != null)
|
|
{
|
|
Vector3 cur = Input.mousePosition;
|
|
Vector2 dpAbs = (Vector2)(cur - _rmbStartPos);
|
|
// 반전: 좌우/상하 모두 반대 방향으로 회전
|
|
float yaw = -dpAbs.x * rotateDegPerPixel; // 좌우 반전
|
|
float pitch = dpAbs.y * rotateDegPerPixel; // 위아래 반전
|
|
|
|
// 카메라 기준 축으로 회전 행렬 구성
|
|
Quaternion yawQ = Quaternion.AngleAxis(yaw, _viewCamera.transform.up);
|
|
Quaternion pitchQ = Quaternion.AngleAxis(pitch, _viewCamera.transform.right);
|
|
Quaternion r = yawQ * pitchQ;
|
|
|
|
// 피벗(_rmbPivot, 보통 모델 중심) 기준으로 위치+회전 동시 적용
|
|
Vector3 startVec = _modelStartPos - _rmbPivot;
|
|
_root.transform.position = _rmbPivot + r * startVec;
|
|
_root.transform.rotation = r * _modelStartRot;
|
|
}
|
|
}
|
|
|
|
private void UpdateOrbitPose()
|
|
{
|
|
if (_viewCamera == null) return;
|
|
_orbitDistance = Mathf.Max(0.01f, _orbitDistance);
|
|
var rot = Quaternion.Euler(_pitch, _yaw, 0f);
|
|
var offset = rot * new Vector3(0, 0, -_orbitDistance);
|
|
_viewCamera.transform.position = _orbitTarget + offset;
|
|
_viewCamera.transform.LookAt(_orbitTarget);
|
|
}
|
|
|
|
public void Dispose()
|
|
{
|
|
foreach (var kv in _matCache)
|
|
{
|
|
var (rends, originals) = kv.Value;
|
|
for (int i = 0; i < rends.Length; i++)
|
|
{
|
|
if (rends[i] == null) continue;
|
|
var mats = rends[i].materials;
|
|
for (int m = 0; m < mats.Length; m++)
|
|
{
|
|
if (mats[m] != null) UnityEngine.Object.Destroy(mats[m]);
|
|
}
|
|
rends[i].materials = originals[i];
|
|
}
|
|
}
|
|
_matCache.Clear();
|
|
_idToObject.Clear();
|
|
if (_root != null) UnityEngine.Object.Destroy(_root);
|
|
_root = null;
|
|
_focusedId = null;
|
|
_wireframeApplied = false;
|
|
|
|
if (_viewCamera != null)
|
|
{
|
|
// detach RT and keep camera disabled to avoid replacing main display
|
|
if (_rt != null && _viewCamera.targetTexture == _rt)
|
|
{
|
|
_viewCamera.targetTexture = null;
|
|
}
|
|
_viewCamera.enabled = false;
|
|
}
|
|
if (_rt != null)
|
|
{
|
|
_rt.Release();
|
|
Destroy(_rt);
|
|
_rt = null;
|
|
}
|
|
}
|
|
|
|
}
|
|
}
|