コード例 #1
0
 void OnSceneGUI()
 {
     for (var i = 0; i < m_TypedTargets.Length; i++)
     {
         ReflectionProxyVolumeComponentUI.DrawHandles_EditBase(m_UIHandlerState[i], m_TypedTargets[i]);
     }
 }
コード例 #2
0
        internal static void DrawGizmos(HDProbe d, GizmoType gizmoType)
        {
            HDProbeUI s;

            if (!HDProbeEditor.TryGetUIStateFor(d, out s))
            {
                return;
            }

            var mat = Matrix4x4.TRS(d.transform.position, d.transform.rotation, Vector3.one);

            switch (EditMode.editMode)
            {
            case EditBaseShape:
                InfluenceVolumeUI.DrawGizmos(
                    s.influenceVolume, d.influenceVolume, mat,
                    InfluenceVolumeUI.HandleType.Base,
                    InfluenceVolumeUI.HandleType.All);
                break;

            case EditInfluenceShape:
                InfluenceVolumeUI.DrawGizmos(
                    s.influenceVolume,
                    d.influenceVolume,
                    mat,
                    InfluenceVolumeUI.HandleType.Influence,
                    InfluenceVolumeUI.HandleType.All);
                break;

            case EditInfluenceNormalShape:
                InfluenceVolumeUI.DrawGizmos(
                    s.influenceVolume,
                    d.influenceVolume,
                    mat,
                    InfluenceVolumeUI.HandleType.InfluenceNormal,
                    InfluenceVolumeUI.HandleType.All);
                break;

            default:
            {
                var showedHandles = s.influenceVolume.showInfluenceHandles
                        ? InfluenceVolumeUI.HandleType.All
                        : InfluenceVolumeUI.HandleType.Base | InfluenceVolumeUI.HandleType.Influence;
                InfluenceVolumeUI.DrawGizmos(
                    s.influenceVolume,
                    d.influenceVolume,
                    mat,
                    InfluenceVolumeUI.HandleType.None,
                    showedHandles);
                break;
            }
            }

            if (d.proxyVolume != null)
            {
                ReflectionProxyVolumeComponentUI.DrawGizmos_EditNone(d.proxyVolume);
            }
        }
コード例 #3
0
        void OnEnable()
        {
            m_TypedTargets   = targets.Cast <ReflectionProxyVolumeComponent>().ToArray();
            m_SerializedData = new SerializedReflectionProxyVolumeComponent(serializedObject);

            m_UIState.Reset(m_SerializedData, Repaint);

            m_UIHandlerState = new ReflectionProxyVolumeComponentUI[m_TypedTargets.Length];
            for (var i = 0; i < m_UIHandlerState.Length; i++)
            {
                m_UIHandlerState[i] = new ReflectionProxyVolumeComponentUI();
            }
        }
        public static void DrawHandles(PlanarReflectionProbeUI s, PlanarReflectionProbe d, Editor o)
        {
            var mat = d.transform.localToWorldMatrix;

            switch (EditMode.editMode)
            {
            case EditBaseShape:
                InfluenceVolumeUI.DrawHandles_EditBase(s.influenceVolume, d.influenceVolume, o, mat, d);
                break;

            case EditInfluenceShape:
                InfluenceVolumeUI.DrawHandles_EditInfluence(s.influenceVolume, d.influenceVolume, o, mat, d);
                break;

            case EditInfluenceNormalShape:
                InfluenceVolumeUI.DrawHandles_EditInfluenceNormal(s.influenceVolume, d.influenceVolume, o, mat, d);
                break;

            case EditMirrorPosition:
            {
                EditorGUI.BeginChangeCheck();
                var m = Handles.matrix;
                Handles.matrix = mat;
                var p = Handles.PositionHandle(d.captureMirrorPlaneLocalPosition, d.transform.rotation);
                if (EditorGUI.EndChangeCheck())
                {
                    Undo.RecordObject(d, "Translate Mirror Plane");
                    d.captureMirrorPlaneLocalPosition = p;
                    EditorUtility.SetDirty(d);
                }
                Handles.matrix = m;
                break;
            }

            case EditMirrorRotation:
            {
                EditorGUI.BeginChangeCheck();
                var m = Handles.matrix;
                Handles.matrix = mat;
                var q = Quaternion.LookRotation(d.captureMirrorPlaneLocalNormal, Vector3.up);
                q = Handles.RotationHandle(q, d.captureMirrorPlaneLocalPosition);
                if (EditorGUI.EndChangeCheck())
                {
                    Undo.RecordObject(d, "Rotate Mirror Plane");
                    d.captureMirrorPlaneLocalNormal = q * Vector3.forward;
                    EditorUtility.SetDirty(d);
                }
                Handles.matrix = m;
                break;
            }

            case EditCenter:
            {
                EditorGUI.BeginChangeCheck();
                var m = Handles.matrix;
                Handles.matrix = mat;
                var p = Handles.PositionHandle(d.captureLocalPosition, d.transform.rotation);
                if (EditorGUI.EndChangeCheck())
                {
                    Undo.RecordObject(d, "Translate Capture Position");
                    d.captureLocalPosition = p;
                    EditorUtility.SetDirty(d);
                }
                Handles.matrix = m;
                break;
            }
            }

            if (d.useMirrorPlane)
            {
                var m = Handles.matrix;
                Handles.matrix = mat;
                Handles.color  = k_GizmoMirrorPlaneCamera;
                Handles.ArrowHandleCap(
                    0,
                    d.captureMirrorPlaneLocalPosition,
                    Quaternion.LookRotation(d.captureMirrorPlaneLocalNormal),
                    HandleUtility.GetHandleSize(d.captureMirrorPlaneLocalPosition),
                    Event.current.type
                    );
                Handles.matrix = m;
            }

            if (d.proxyVolumeReference != null)
            {
                ReflectionProxyVolumeComponentUI.DrawHandles_EditNone(s.reflectionProxyVolume, d.proxyVolumeReference);
            }
        }
        public static void DrawGizmos(PlanarReflectionProbe d, GizmoType gizmoType)
        {
            PlanarReflectionProbeUI s;

            if (!PlanarReflectionProbeEditor.TryGetUIStateFor(d, out s))
            {
                return;
            }

            var mat = d.transform.localToWorldMatrix;

            switch (EditMode.editMode)
            {
            case EditBaseShape:
                InfluenceVolumeUI.DrawGizmos(
                    s.influenceVolume,
                    d.influenceVolume,
                    mat,
                    InfluenceVolumeUI.HandleType.Base,
                    InfluenceVolumeUI.HandleType.All);
                break;

            case EditInfluenceShape:
                InfluenceVolumeUI.DrawGizmos(
                    s.influenceVolume,
                    d.influenceVolume,
                    mat,
                    InfluenceVolumeUI.HandleType.Influence,
                    InfluenceVolumeUI.HandleType.All);
                break;

            case EditInfluenceNormalShape:
                InfluenceVolumeUI.DrawGizmos(
                    s.influenceVolume,
                    d.influenceVolume,
                    mat,
                    InfluenceVolumeUI.HandleType.InfluenceNormal,
                    InfluenceVolumeUI.HandleType.All);
                break;

            default:
            {
                var showedHandles = s.influenceVolume.showInfluenceHandles
                            ? InfluenceVolumeUI.HandleType.All
                            : InfluenceVolumeUI.HandleType.Base;
                InfluenceVolumeUI.DrawGizmos(
                    s.influenceVolume,
                    d.influenceVolume,
                    mat,
                    InfluenceVolumeUI.HandleType.None,
                    showedHandles);
                break;
            }
            }

            if (d.proxyVolumeReference != null)
            {
                ReflectionProxyVolumeComponentUI.DrawGizmos_EditNone(s.reflectionProxyVolume, d.proxyVolumeReference);
            }

            var showFrustrum = s.showCaptureHandles ||
                               EditMode.editMode == EditCenter;
            var showCaptureMirror = d.useMirrorPlane ||
                                    EditMode.editMode == EditMirrorPosition ||
                                    EditMode.editMode == EditMirrorRotation;

            if (showFrustrum)
            {
                DrawGizmos_CaptureFrustrum(s, d);
            }

            if (showCaptureMirror)
            {
                DrawGizmos_CaptureMirror(s, d);
            }
        }
コード例 #6
0
 public static void DrawGizmos_EditNone(ReflectionProxyVolumeComponentUI ui, ReflectionProxyVolumeComponent target)
 {
     ProxyVolumeUI.DrawGizmos_EditNone(target.transform, target.proxyVolume, ui.proxyVolume, target);
 }