Assets/scripts/SceneViewAxisGizmo.cs - main - molo4ka/wind-simulation

Assets/scripts/SceneViewAxisGizmo.cs
242 строки6 KB
molo4kaPlus
Initial check-in
18 май 2026, 12:33
18 май 2026, 12:333216236
using UnityEngine;
using UnityEngine.InputSystem;

public class SceneViewAxisGizmo : MonoBehaviour
{
    public OrbitCameraController orbitCamera;

    public float viewportSize = 0.13f;
    public Vector2 viewportOffset = new Vector2(0.84f, 0.83f);

    Camera mainCam;
    Camera gizmoCam;

    Transform pivot;

    Transform axisX;
    Transform axisY;
    Transform axisZ;

    Renderer xRenderer;
    Renderer yRenderer;
    Renderer zRenderer;

    Renderer xTipRenderer;
    Renderer yTipRenderer;
    Renderer zTipRenderer;

    const int gizmoLayer = 30;

    readonly Color xColor = new Color(0.95f, 0.35f, 0.35f);
    readonly Color yColor = new Color(0.35f, 0.95f, 0.35f);
    readonly Color zColor = new Color(0.35f, 0.55f, 0.95f);

    void Start()
    {
        mainCam = Camera.main;

        if (orbitCamera == null)
            orbitCamera = FindObjectOfType<OrbitCameraController>();

        CreateGizmo();
        CreateCamera();
    }

    void LateUpdate()
    {
        if (mainCam == null || pivot == null)
            return;

        pivot.rotation = mainCam.transform.rotation;
    }

    void Update()
    {
        HandleHover();
        HandleClick();
    }

    void CreateGizmo()
    {
        pivot = new GameObject("AxisGizmo").transform;
        pivot.SetParent(transform, false);

        CreateCenterCube();

        axisX = CreateAxis("X", Vector3.right, xColor, out xRenderer, out xTipRenderer);
        axisY = CreateAxis("Y", Vector3.up, yColor, out yRenderer, out yTipRenderer);
        axisZ = CreateAxis("Z", Vector3.forward, zColor, out zRenderer, out zTipRenderer);
    }

    void CreateCenterCube()
    {
        var cube = GameObject.CreatePrimitive(PrimitiveType.Cube);
        cube.name = "CenterCube";
        cube.transform.SetParent(pivot, false);
        cube.transform.localScale = Vector3.one * 0.16f;
        cube.layer = gizmoLayer;

        var r = cube.GetComponent<Renderer>();
        r.material = CreateMaterial(new Color(0.55f, 0.55f, 0.55f, 0.9f));

        Destroy(cube.GetComponent<Collider>());
    }

    Transform CreateAxis(
        string name,
        Vector3 dir,
        Color color,
        out Renderer shaftRenderer,
        out Renderer tipRenderer)
    {
        var root = new GameObject(name).transform;
        root.SetParent(pivot, false);
        root.gameObject.layer = gizmoLayer;

        var shaft = GameObject.CreatePrimitive(PrimitiveType.Cylinder);
        shaft.name = "Shaft";
        shaft.transform.SetParent(root, false);
        shaft.transform.localScale = new Vector3(0.03f, 0.22f, 0.03f);
        shaft.transform.localPosition = dir * 0.25f;
        shaft.transform.rotation = Quaternion.FromToRotation(Vector3.up, dir);
        shaft.layer = gizmoLayer;

        shaftRenderer = shaft.GetComponent<Renderer>();
        shaftRenderer.material = CreateMaterial(color);

        Destroy(shaft.GetComponent<Collider>());

        var tip = GameObject.CreatePrimitive(PrimitiveType.Sphere);
        tip.name = "Tip";
        tip.transform.SetParent(root, false);
        tip.transform.localScale = Vector3.one * 0.13f;
        tip.transform.localPosition = dir * 0.52f;
        tip.layer = gizmoLayer;

        tipRenderer = tip.GetComponent<Renderer>();
        tipRenderer.material = CreateMaterial(color);

        return root;
    }

    Material CreateMaterial(Color c)
    {
        var m = new Material(Shader.Find("Standard"));
        m.color = c;
        return m;
    }

    void CreateCamera()
    {
        var go = new GameObject("AxisGizmoCamera");
        gizmoCam = go.AddComponent<Camera>();

        gizmoCam.clearFlags = CameraClearFlags.Depth;
        gizmoCam.cullingMask = 1 << gizmoLayer;
        gizmoCam.orthographic = true;
        gizmoCam.orthographicSize = 0.9f;
        gizmoCam.nearClipPlane = 0.01f;
        gizmoCam.farClipPlane = 10f;
        gizmoCam.depth = 999f;

        gizmoCam.rect = new Rect(
            viewportOffset.x,
            viewportOffset.y,
            viewportSize,
            viewportSize
        );

        gizmoCam.transform.position = new Vector3(0f, 0f, -2f);
        gizmoCam.transform.LookAt(Vector3.zero);
    }

    void HandleHover()
    {
        ResetColors();

        var hovered = GetHoveredAxis();

        if (hovered == axisX)
            Highlight(xRenderer, xTipRenderer);

        if (hovered == axisY)
            Highlight(yRenderer, yTipRenderer);

        if (hovered == axisZ)
            Highlight(zRenderer, zTipRenderer);
    }

    void HandleClick()
    {
        var mouse = Mouse.current;

        if (mouse == null)
            return;

        if (!mouse.leftButton.wasPressedThisFrame)
            return;

        var hovered = GetHoveredAxis();

        if (hovered == null || orbitCamera == null)
            return;

        if (hovered == axisX)
            orbitCamera.ViewAxisX();

        if (hovered == axisY)
            orbitCamera.ViewAxisY();

        if (hovered == axisZ)
            orbitCamera.ViewAxisZ();
    }

    Transform GetHoveredAxis()
    {
        var mouse = Mouse.current;

        if (mouse == null)
            return null;

        Vector2 pos = mouse.position.ReadValue();

        Rect pixelRect = new Rect(
            Screen.width * viewportOffset.x,
            Screen.height * viewportOffset.y,
            Screen.width * viewportSize,
            Screen.height * viewportSize
        );

        if (!pixelRect.Contains(pos))
            return null;

        Ray ray = gizmoCam.ScreenPointToRay(pos);

        if (!Physics.Raycast(ray, out RaycastHit hit))
            return null;

        Transform t = hit.transform;

        while (t != null && t.parent != pivot)
            t = t.parent;

        return t;
    }

    void Highlight(Renderer shaft, Renderer tip)
    {
        shaft.material.color = Color.white;
        tip.material.color = Color.white;
    }

    void ResetColors()
    {
        xRenderer.material.color = xColor;
        yRenderer.material.color = yColor;
        zRenderer.material.color = zColor;

        xTipRenderer.material.color = xColor;
        yTipRenderer.material.color = yColor;
        zTipRenderer.material.color = zColor;
    }
}