protected override void UpdateOverride()
{
base.UpdateOverride();
if (RuntimeEditorApplication.IsActiveWindow(this))
{
if (InputController._GetKeyDown(RemoveKey))
{
if (m_treeView.SelectedItem != null)
{
ProjectItem projectItem = (ProjectItem)m_treeView.SelectedItem;
if (projectItem.Parent == null)
{
PopupWindow.Show("Unable to Remove", "Unable to remove root folder", "OK");
}
else
{
PopupWindow.Show("Remove Selected assets", "You can not undo this action", "Delete", args =>
{
m_treeView.RemoveSelectedItems();
}, "Cancel");
}
}
}
}
if (RuntimeEditorApplication.IsPointerOverWindow(this))
{
if (m_dragProjectItem != null)
{
m_treeView.ExternalItemDrag(InputController._MousePosition);
}
}
}
private void UpdateUIState(bool isInPlayMode)
{
if (ProjectionButton != null)
{
ProjectionButton.gameObject.SetActive(!isInPlayMode);
}
EditorCamera.gameObject.SetActive(!isInPlayMode);
PlayerCamera.gameObject.SetActive(isInPlayMode);
SelectionController.gameObject.SetActive(!isInPlayMode);
PlayButton.gameObject.SetActive(!isInPlayMode);
HintButton.gameObject.SetActive(!isInPlayMode);
SaveButton.gameObject.SetActive(!isInPlayMode);
LoadButton.gameObject.SetActive(!isInPlayMode);
StopButton.gameObject.SetActive(isInPlayMode);
UndoButton.gameObject.SetActive(!isInPlayMode);
RedoButton.gameObject.SetActive(!isInPlayMode);
UI.gameObject.SetActive(!isInPlayMode);
Grid.gameObject.SetActive(TogGrid.isOn && !isInPlayMode);
LoadButton.interactable = m_sceneManager != null && m_saveFileExists;
if (isInPlayMode)
{
RuntimeEditorApplication.ActivateWindow(RuntimeWindowType.GameView);
}
else
{
RuntimeEditorApplication.ActivateWindow(RuntimeWindowType.SceneView);
}
}
private void OnItemsRemoving(object sender, ItemsCancelArgs e)
{
if (e.Items == null)
{
return;
}
if (!RuntimeEditorApplication.IsActiveWindow(this))
{
e.Items.Clear();
return;
}
for (int i = e.Items.Count - 1; i >= 0; i--)
{
ProjectItem item = (ProjectItem)e.Items[i];
if (m_project.IsStatic(item))
{
e.Items.Remove(item);
}
}
if (e.Items.Count == 0)
{
PopupWindow.Show("Can't remove folder", "Unable to remove folders exposed from editor", "OK");
}
}
private void Update()
{
#if UNITY_EDITOR
UnityEditorToolsListener.Update();
#endif
if (RuntimeTools.ActiveTool != null)
{
return;
}
bool isGameViewActive = RuntimeEditorApplication.IsActiveWindow(RuntimeWindowType.GameView);
bool isLocked = RuntimeTools.IsViewing || isGameViewActive;
if (!isLocked)
{
if (InputController.GetKeyDown(ViewToolKey))
{
RuntimeTools.Current = RuntimeTool.View;
}
else if (InputController.GetKeyDown(MoveToolKey))
{
RuntimeTools.Current = RuntimeTool.Move;
}
else if (InputController.GetKeyDown(RotateToolKey))
{
RuntimeTools.Current = RuntimeTool.Rotate;
}
else if (InputController.GetKeyDown(ScaleToolKey))
{
RuntimeTools.Current = RuntimeTool.Scale;
}
if (InputController.GetKeyDown(PivotRotationKey))
{
if (RuntimeTools.PivotRotation == RuntimePivotRotation.Local)
{
RuntimeTools.PivotRotation = RuntimePivotRotation.Global;
}
else
{
RuntimeTools.PivotRotation = RuntimePivotRotation.Local;
}
}
if (InputController.GetKeyDown(PivotModeKey) &&
!(InputController.GetKey(KeyCode.LeftControl) || InputController.GetKey(KeyCode.LeftShift)))
{
if (RuntimeTools.PivotMode == RuntimePivotMode.Center)
{
RuntimeTools.PivotMode = RuntimePivotMode.Pivot;
}
else
{
RuntimeTools.PivotMode = RuntimePivotMode.Center;
}
}
}
}
protected override void UpdateOverride()
{
base.UpdateOverride();
if (!RuntimeEditorApplication.IsPointerOverWindow(this))
{
return;
}
if (InputController.GetKeyDown(SelectAllKey))
{
if (InputController.GetKey(ModifierKey))
{
if (RuntimeEditorApplication.IsActiveWindow(this))
{
m_treeView.SelectedItems = m_treeView.Items;
}
}
}
if (RuntimeTools.SpawnPrefab == null)
{
return;
}
m_treeView.ExternalItemDrag(Input.mousePosition);
if (Input.GetMouseButtonUp(0))
{
m_isSpawningPrefab = true;
GameObject prefabInstance = RuntimeTools.SpawnPrefab.InstantiatePrefab(Vector3.zero, Quaternion.identity);
prefabInstance.SetActive(true);
ExposeToEditor exposeToEditor = prefabInstance.GetComponent <ExposeToEditor>();
if (exposeToEditor == null)
{
exposeToEditor = prefabInstance.AddComponent <ExposeToEditor>();
}
exposeToEditor.SetName(RuntimeTools.SpawnPrefab.name);
RuntimeUndo.BeginRecord();
RuntimeUndo.RecordSelection();
RuntimeUndo.BeginRegisterCreateObject(prefabInstance);
RuntimeUndo.EndRecord();
bool isEnabled = RuntimeUndo.Enabled;
RuntimeUndo.Enabled = false;
RuntimeSelection.activeGameObject = prefabInstance;
RuntimeUndo.Enabled = isEnabled;
RuntimeUndo.BeginRecord();
RuntimeUndo.RegisterCreatedObject(prefabInstance);
RuntimeUndo.RecordSelection();
RuntimeUndo.EndRecord();
RuntimeTools.SpawnPrefab = null;
}
}
protected override void UpdateOverride()
{
base.UpdateOverride();
if (InputController.GetKeyDown(DuplicateKey) && InputController.GetKey(ModifierKey))
{
if (RuntimeEditorApplication.IsActiveWindow(m_projectResources))
{
DuplicateProjectResources();
}
}
}
private void OnDestroy()
{
if (m_instance == this)
{
m_instance = null;
RuntimeEditorApplication.Reset();
EditorsMap.Reset();
}
Unsubscribe();
}
private void Update()
{
if (!RuntimeEditorApplication.IsActiveWindow(RuntimeWindowType.GameView) && RuntimeEditorApplication.IsOpened)
{
return;
}
if (InputController.GetKeyDown(KeyCode.Return))
{
SwitchPlayer(m_current, 0.0f, true);
}
else if (InputController.GetKeyDown(KeyCode.Backspace))
{
SwitchPlayer(m_current, 0.0f, false);
}
}
private void OnPlaymodeStateChanged()
{
if (RuntimeEditorApplication.IsPlaying)
{
RuntimeEditorApplication.ActivateWindow(RuntimeWindowType.GameView);
}
else
{
RuntimeEditorApplication.ActivateWindow(RuntimeWindowType.SceneView);
}
if (PlayToggle != null)
{
PlayToggle.isOn = RuntimeEditorApplication.IsPlaying;
}
UpdateLoadSaveButtonsState();
}
protected override void UpdateOverride()
{
base.UpdateOverride();
if (!RuntimeEditorApplication.IsActiveWindow(this) && !RuntimeEditorApplication.IsActiveWindow(RuntimeWindowType.SceneView))
{
return;
}
if (InputController.GetKeyDown(RemoveKey))
{
if (m_listBox.SelectedItem != null)
{
PopupWindow.Show("Remove Selected assets", "You can not undo this action", "Delete", args =>
{
m_listBox.RemoveSelectedItems();
}, "Cancel");
}
}
}
private void OnDestroy()
{
if (Instance == this)
{
Instance = null;
RuntimeEditorApplication.Reset();
}
RuntimeEditorApplication.PlaymodeStateChanged -= OnPlaymodeStateChanged;
RuntimeEditorApplication.IsOpenedChanged -= OnIsOpenedChanged;
RuntimeSelection.SelectionChanged -= OnRuntimeSelectionChanged;
RuntimeTools.ToolChanged -= OnRuntimeToolChanged;
RuntimeTools.PivotRotationChanged -= OnPivotRotationChanged;
RuntimeUndo.RedoCompleted -= OnUndoCompleted;
RuntimeUndo.RedoCompleted -= OnRedoCompleted;
RuntimeUndo.StateChanged -= OnUndoRedoStateChanged;
ExposeToEditor.Awaked -= OnAwaked;
ExposeToEditor.Destroyed -= OnDestroyed;
}
protected override void UpdateOverride()
{
base.UpdateOverride();
if (RuntimeTools.ActiveTool != null)
{
return;
}
HandleInput();
if (RuntimeEditorApplication.IsPointerOverWindow(this))
{
SetCursor();
}
else
{
CursorHelper.ResetCursor(this);
}
}
private void CompleteSpawn(object item)
{
ItemContainer itemContainer = m_listBox.GetItemContainer(item);
if (itemContainer != null)
{
ResourcePreview resource = itemContainer.GetComponentInChildren <ResourcePreview>();
resource.CompleteSpawn();
}
if (RuntimeEditorApplication.IsPointerOverWindow(RuntimeWindowType.Resources))
{
RuntimeTools.SpawnPrefab = null;
}
if (Drop != null)
{
Drop(this, new ProjectResourcesEventArgs(new [] { (ProjectItemObjectPair)item }));
}
}
public ProjectItem BeginDropProjectItem()
{
ProjectItem dropTarget = null;
if (m_dragProjectItem != null)
{
if (m_treeView.DropAction == ItemDropAction.SetLastChild)
{
dropTarget = (ProjectItem)m_treeView.DropTarget;
}
if (RuntimeEditorApplication.IsPointerOverWindow(RuntimeWindowType.ProjectTree))
{
RuntimeTools.SpawnPrefab = null;
}
}
m_treeView.ExternalItemDrop();
m_dragProjectItem = null;
return(dropTarget);
}
private void Start()
{
GameObject go = RuntimeSelection.activeGameObject;
ExposeToEditor exposeToEditor = go.GetComponent <ExposeToEditor>();
HierarchyItem hierarchyItem = go.GetComponent <HierarchyItem>();
HashSet <Component> ignoreComponents = new HashSet <Component>();
if (exposeToEditor != null)
{
if (exposeToEditor.Colliders != null)
{
for (int i = 0; i < exposeToEditor.Colliders.Length; ++i)
{
Collider collider = exposeToEditor.Colliders[i];
if (!ignoreComponents.Contains(collider))
{
ignoreComponents.Add(collider);
}
}
}
ignoreComponents.Add(exposeToEditor);
}
if (hierarchyItem != null)
{
ignoreComponents.Add(hierarchyItem);
}
InputName.text = go.name;
TogEnableDisable.isOn = go.activeSelf;
InputName.onEndEdit.AddListener(OnEndEditName);
TogEnableDisable.onValueChanged.AddListener(OnEnableDisable);
Component[] components = go.GetComponents <Component>();
for (int i = 0; i < components.Length; ++i)
{
Component component = components[i];
if (component == null)
{
continue;
}
if (ignoreComponents.Contains(component))
{
continue;
}
if ((component.hideFlags & HideFlags.HideInInspector) != 0)
{
continue;
}
if (EditorsMap.IsObjectEditorEnabled(component.GetType()))
{
GameObject editorPrefab = EditorsMap.GetObjectEditor(component.GetType());
if (editorPrefab != null)
{
ComponentEditor componentEditorPrefab = editorPrefab.GetComponent <ComponentEditor>();
if (componentEditorPrefab != null)
{
ComponentEditor editor = Instantiate(componentEditorPrefab);
editor.EndEditCallback = () =>
{
RuntimeEditorApplication.SaveSelectedObjects();
};
editor.transform.SetParent(ComponentsPanel, false);
editor.Component = component;
}
else
{
Debug.LogErrorFormat("editor prefab {0} does not have ComponentEditor script", editorPrefab.name);
}
}
}
}
}
private void LateUpdate()
{
if (RuntimeTools.ActiveTool != null && RuntimeTools.ActiveTool != this)
{
return;
}
if (RuntimeTools.IsViewing)
{
return;
}
if (KeyCode == KeyCode.None || InputController.GetKeyDown(KeyCode))
{
m_active = true;
}
if (m_active)
{
if (Input.GetMouseButtonDown(MouseButton))
{
m_startMousePosition = Input.mousePosition;
m_isDragging = GetPoint(out m_startPt) &&
(!RuntimeEditorApplication.IsOpened || RuntimeEditorApplication.IsPointerOverWindow(RuntimeWindowType.SceneView) && !RuntimeTools.IsPointerOverGameObject());
if (m_isDragging)
{
m_rectTransform.anchoredPosition = m_startPt;
m_rectTransform.sizeDelta = new Vector2(0, 0);
CursorHelper.SetCursor(this, null, Vector3.zero, CursorMode.Auto);
}
else
{
RuntimeTools.ActiveTool = null;
}
}
else if (Input.GetMouseButtonUp(MouseButton))
{
if (m_isDragging)
{
m_isDragging = false;
HitTest();
m_rectTransform.sizeDelta = new Vector2(0, 0);
CursorHelper.ResetCursor(this);
}
RuntimeTools.ActiveTool = null;
m_active = false;
}
else if (m_isDragging)
{
GetPoint(out m_endPt);
Vector2 size = m_endPt - m_startPt;
if (size != Vector2.zero)
{
RuntimeTools.ActiveTool = this;
}
m_rectTransform.sizeDelta = new Vector2(Mathf.Abs(size.x), Mathf.Abs(size.y));
m_rectTransform.localScale = new Vector3(Mathf.Sign(size.x), Mathf.Sign(size.y), 1);
}
}
}
private void LateUpdate()
{
if (InputController._GetMouseButtonDown(0))
{
if (RuntimeTools.ActiveTool != null && RuntimeTools.ActiveTool != BoxSelection.Current)
{
return;
}
if (!IPointerOverEditorArea)
{
return;
}
if (RuntimeTools.IsViewing)
{
return;
}
if (!RuntimeSelection.Enabled)
{
return;
}
bool rangeSelect = InputController._GetKey(RangeSelectKey);
bool multiselect = InputController._GetKey(MultiselectKey) || InputController._GetKey(MultiselectKey2) || rangeSelect;
Ray ray = SceneCamera.ScreenPointToRay(InputController._MousePosition);
RaycastHit hitInfo;
//if (Physics.Raycast(ray, out hitInfo, float.MaxValue, LayerMask.value))
if (Physics.Raycast(ray, out hitInfo, float.MaxValue))
{
GameObject hitGO = hitInfo.collider.gameObject;
bool canSelect = CanSelect(hitGO);
if (canSelect)
{
hitGO = hitGO.GetComponentInParent <ExposeToEditor>().gameObject;
if (multiselect)
{
List <Object> selection;
if (RuntimeSelection.objects != null)
{
selection = RuntimeSelection.objects.ToList();
}
else
{
selection = new List <Object>();
}
if (selection.Contains(hitGO))
{
selection.Remove(hitGO);
if (rangeSelect)
{
selection.Insert(0, hitGO);
}
}
else
{
selection.Insert(0, hitGO);
}
RuntimeSelection.Select(hitGO, selection.ToArray());
}
else
{
RuntimeSelection.activeObject = hitGO;
}
}
else
{
if (!multiselect)
{
RuntimeSelection.activeObject = null;
}
}
}
else
{
if (!multiselect)
{
RuntimeSelection.activeObject = null;
}
}
}
if (RuntimeEditorApplication.IsActiveWindow(this))
{
if (InputController._GetKeyDown(SelectAllKey) && InputController._GetKey(ModifierKey))
{
IEnumerable <GameObject> filtered = RuntimeEditorApplication.IsPlaying ?
ExposeToEditor.FindAll(ExposeToEditorObjectType.PlayMode) :
ExposeToEditor.FindAll(ExposeToEditorObjectType.EditorMode);
RuntimeSelection.objects = filtered.ToArray();
}
}
}
private void HandleInput()
{
if (RuntimeTools.AutoFocus)
{
do
{
if (RuntimeTools.ActiveTool != null)
{
break;
}
if (m_autoFocusTransform == null)
{
break;
}
if (m_autoFocusTransform.position == SecondaryPivot.position)
{
break;
}
if (m_focusAnimation != null && m_focusAnimation.InProgress)
{
break;
}
Vector3 offset = (m_autoFocusTransform.position - SecondaryPivot.position);
SceneCamera.transform.position += offset;
Pivot.transform.position += offset;
SecondaryPivot.transform.position += offset;
}while (false);
}
if (InputController._GetMouseButtonUp(0) ||
InputController._GetMouseButtonUp(1) ||
InputController._GetMouseButtonUp(2))
{
m_handleInput = false;
m_mouseOrbit.enabled = false;
m_rotate = false;
SetCursor();
return;
}
bool isGameViewActive = RuntimeEditorApplication.IsActiveWindow(RuntimeWindowType.GameView);
if (!isGameViewActive)
{
float mouseWheel = InputController._GetAxis("Mouse ScrollWheel");
if (mouseWheel != 0)
{
if (!RuntimeTools.IsPointerOverGameObject())
{
m_mouseOrbit.Zoom();
}
}
}
if (m_lockInput)
{
return;
}
if (!isGameViewActive)
{
if (InputController._GetKeyDown(SnapToGridKey) && InputController._GetKey(ModifierKey))
{
SnapToGrid();
}
if (InputController._GetKeyDown(FocusKey))
{
Focus();
}
bool rotate = InputController._GetKey(RotateKey) || InputController._GetKey(RotateKey2) || InputController._GetKey(RotateKey3);
bool pan = InputController._GetMouseButton(2) || InputController._GetMouseButton(1) || InputController._GetMouseButton(0) && RuntimeTools.Current == RuntimeTool.View;
if (pan != m_pan)
{
m_pan = pan;
if (m_pan)
{
if (RuntimeTools.Current != RuntimeTool.View)
{
m_rotate = false;
}
m_dragPlane = new Plane(-SceneCamera.transform.forward, Pivot.position);
}
SetCursor();
}
else
{
if (rotate != m_rotate)
{
m_rotate = rotate;
SetCursor();
}
}
}
RuntimeTools.IsViewing = m_rotate || m_pan;
bool isLocked = RuntimeTools.IsViewing || isGameViewActive;
if (!IPointerOverEditorArea)
{
return;
}
bool isMouse0ButtonDown = InputController._GetMouseButtonDown(0);
bool isMouse1ButtonDown = InputController._GetMouseButtonDown(1);
bool isMouse2ButtonDown = InputController._GetMouseButtonDown(2);
if (isMouse0ButtonDown || isMouse1ButtonDown || isMouse2ButtonDown)
{
m_handleInput = !PositionHandle.IsDragging;
m_lastMousePosition = InputController._MousePosition;
if (m_rotate)
{
m_mouseOrbit.enabled = true;
}
}
if (m_handleInput)
{
if (isLocked)
{
if (m_pan && (!m_rotate || RuntimeTools.Current != RuntimeTool.View))
{
Pan();
}
}
}
}
public void CompleteSpawn()
{
if (RuntimeEditorApplication.IsPointerOverWindow(RuntimeWindowType.SceneView))
{
if (m_resource is Material)
{
Material material = (Material)m_resource;
Camera sceneCamera = RuntimeEditorApplication.ActiveSceneCamera;
if (sceneCamera)
{
Ray ray = sceneCamera.ScreenPointToRay(Input.mousePosition);
RaycastHit hitInfo;
if (Physics.Raycast(ray, out hitInfo))
{
MeshRenderer renderer = hitInfo.collider.GetComponentInChildren <MeshRenderer>();
SkinnedMeshRenderer sRenderer = hitInfo.collider.GetComponentInChildren <SkinnedMeshRenderer>();
if (renderer != null || sRenderer != null)
{
RuntimeUndo.BeginRecord();
}
if (renderer != null)
{
RuntimeUndo.RecordValue(renderer, Strong.PropertyInfo((MeshRenderer x) => x.sharedMaterials));
Material[] materials = renderer.sharedMaterials;
for (int i = 0; i < materials.Length; ++i)
{
materials[i] = material;
}
renderer.sharedMaterials = materials;
}
if (sRenderer != null)
{
RuntimeUndo.RecordValue(sRenderer, Strong.PropertyInfo((SkinnedMeshRenderer x) => x.sharedMaterials));
Material[] materials = sRenderer.sharedMaterials;
for (int i = 0; i < materials.Length; ++i)
{
materials[i] = material;
}
sRenderer.sharedMaterials = materials;
}
if (renderer != null || sRenderer != null)
{
RuntimeUndo.EndRecord();
}
if (renderer != null || sRenderer != null)
{
RuntimeUndo.BeginRecord();
}
if (renderer != null)
{
RuntimeUndo.RecordValue(renderer, Strong.PropertyInfo((MeshRenderer x) => x.sharedMaterials));
}
if (sRenderer != null)
{
RuntimeUndo.RecordValue(sRenderer, Strong.PropertyInfo((SkinnedMeshRenderer x) => x.sharedMaterials));
}
if (renderer != null || sRenderer != null)
{
RuntimeUndo.EndRecord();
}
}
}
}
else
{
if (m_state == State.AfterSpawn)
{
bool isEnabled = RuntimeUndo.Enabled;
RuntimeUndo.Enabled = false;
RuntimeSelection.objects = m_selection;
RuntimeUndo.Enabled = isEnabled;
RuntimeUndo.BeginRecord();
RuntimeUndo.RecordSelection();
RuntimeUndo.BeginRegisterCreateObject(m_instance);
RuntimeUndo.EndRecord();
RuntimeUndo.Enabled = false;
RuntimeSelection.activeGameObject = m_instance;
RuntimeUndo.Enabled = isEnabled;
RuntimeUndo.BeginRecord();
RuntimeUndo.RegisterCreatedObject(m_instance);
RuntimeUndo.RecordSelection();
RuntimeUndo.EndRecord();
}
}
EndSpawn();
RuntimeEditorApplication.ActivateWindow(RuntimeWindowType.SceneView);
}
else
{
if (!RuntimeEditorApplication.IsPointerOverWindow(RuntimeWindowType.Hierarchy))
{
EndSpawn();
}
}
}
private void Update()
{
if (InputController._GetMouseButtonDown(0))
{
if (RuntimeTools.Current != Tool && RuntimeTools.Current != RuntimeTool.None || RuntimeTools.IsViewing)
{
return;
}
if (RuntimeTools.IsPointerOverGameObject())
{
return;
}
if (SceneCamera == null)
{
Debug.LogError("Camera is null");
return;
}
if (RuntimeTools.ActiveTool != null)
{
return;
}
if (RuntimeEditorApplication.ActiveSceneCamera != null && !RuntimeEditorApplication.IsPointerOverWindow(RuntimeWindowType.SceneView))
{
return;
}
m_isDragging = OnBeginDrag();
if (m_isDragging)
{
RuntimeTools.ActiveTool = this;
RecordTransform();
}
else
{
RuntimeTools.ActiveTool = null;
}
}
else if (InputController._GetMouseButtonUp(0))
{
TryCancelDrag();
}
else
{
if (m_isDragging)
{
if (InputController._GetKey(UnitSnapKey) || RuntimeTools.UnitSnapping)
{
EffectiveGridUnitSize = CurrentGridUnitSize;
}
else
{
EffectiveGridUnitSize = 0;
}
OnDrag();
}
}
UpdateOverride();
if (Model != null)
{
SyncModelTransform();
}
if (m_isDragging)
{
if (RuntimeTools.PivotMode == RuntimePivotMode.Center && m_commonCenterTarget != null && m_realTargets != null && m_realTargets.Length > 1)
{
for (int i = 0; i < m_commonCenterTarget.Length; ++i)
{
Transform commonCenterTarget = m_commonCenterTarget[i];
Transform target = m_realTargets[i];
target.transform.position = commonCenterTarget.position;
target.transform.rotation = commonCenterTarget.rotation;
target.transform.localScale = commonCenterTarget.localScale;
}
}
}
}
public void BuildEditor()
{
foreach (Transform t in EditorsPanel)
{
Destroy(t.gameObject);
}
IMaterialDescriptor selector;
if (!m_propertySelectors.TryGetValue(Material.shader.name, out selector))
{
selector = new MaterialDescriptor();
}
object converter = selector.CreateConverter(this);
MaterialPropertyDescriptor[] descriptors = selector.GetProperties(this, converter);
if (descriptors == null)
{
Destroy(gameObject);
return;
}
for (int i = 0; i < descriptors.Length; ++i)
{
MaterialPropertyDescriptor descriptor = descriptors[i];
PropertyEditor editor = null;
object target = descriptor.Target;
PropertyInfo propertyInfo = descriptor.PropertyInfo;
#if !UNITY_WEBGL && PROC_MATERIAL
if (descriptor.ProceduralDescription == null)
#endif
{
RTShaderPropertyType propertyType = descriptor.Type;
switch (propertyType)
{
case RTShaderPropertyType.Range:
if (RangeEditor != null)
{
RangeEditor range = Instantiate(RangeEditor);
range.transform.SetParent(EditorsPanel, false);
var rangeLimits = descriptor.Limits;
range.Min = rangeLimits.Min;
range.Max = rangeLimits.Max;
editor = range;
}
break;
default:
if (EditorsMap.IsPropertyEditorEnabled(propertyInfo.PropertyType))
{
GameObject editorPrefab = EditorsMap.GetPropertyEditor(propertyInfo.PropertyType);
GameObject instance = Instantiate(editorPrefab);
instance.transform.SetParent(EditorsPanel, false);
if (instance != null)
{
editor = instance.GetComponent <PropertyEditor>();
}
}
break;
}
}
#if !UNITY_WEBGL && PROC_MATERIAL
else
{
ProcPropertyDescription input = descriptor.ProceduralDescription;
if (input.hasRange)
{
if (input.type == ProcPropertyType.Float)
{
if (RangeEditor != null)
{
RangeEditor range = Instantiate(RangeEditor);
range.transform.SetParent(EditorsPanel, false);
range.Min = input.minimum;
range.Max = input.maximum;
//TODO implement step on range editor // = input.step
editor = range;
}
}
else
{
//TODO: Implement range on vector editors
if (EditorsMap.IsPropertyEditorEnabled(propertyInfo.PropertyType))
{
GameObject editorPrefab = EditorsMap.GetPropertyEditor(propertyInfo.PropertyType);
GameObject instance = Instantiate(editorPrefab);
instance.transform.SetParent(EditorsPanel, false);
if (instance != null)
{
editor = instance.GetComponent <PropertyEditor>();
}
}
}
}
else
{
//if(input.type == ProceduralPropertyType.Enum)
//TODO: Implement enum from string array editor. //input.enumOptions
if (EditorsMap.IsPropertyEditorEnabled(propertyInfo.PropertyType))
{
GameObject editorPrefab = EditorsMap.GetPropertyEditor(propertyInfo.PropertyType);
GameObject instance = Instantiate(editorPrefab);
instance.transform.SetParent(EditorsPanel, false);
if (instance != null)
{
editor = instance.GetComponent <PropertyEditor>();
}
}
}
}
#endif
if (editor == null)
{
continue;
}
editor.Init(target, propertyInfo, descriptor.Label, null, descriptor.ValueChangedCallback, () =>
{
RuntimeEditorApplication.SaveSelectedObjects();
});
}
}
private void Update()
{
if (Input.GetMouseButtonDown(0))
{
if (RuntimeTools.IsPointerOverGameObject())
{
return;
}
if (SceneCamera == null)
{
Debug.LogError("Camera is null");
return;
}
if (RuntimeTools.IsViewing)
{
return;
}
if (RuntimeTools.ActiveTool != null)
{
return;
}
if (RuntimeEditorApplication.ActiveSceneCamera != null && !RuntimeEditorApplication.IsPointerOverWindow(RuntimeWindowType.SceneView))
{
return;
}
Vector2 pointer = Input.mousePosition;
m_dragIndex = Hit(pointer, HandlesPositions, HandlesNormals);
if (m_dragIndex >= 0 && OnBeginDrag(m_dragIndex))
{
m_handlesTransform = HandlesTransform;
m_handlesInverseTransform = Matrix4x4.TRS(Target.position, Target.rotation, Target.localScale).inverse; // m_handlesTransform.inverse;
m_dragPlane = GetDragPlane();
m_isDragging = GetPointOnDragPlane(Input.mousePosition, out m_prevPoint);
m_normal = HandlesNormals[m_dragIndex].normalized;
if (m_isDragging)
{
RuntimeTools.ActiveTool = this;
}
if (EnableUndo)
{
bool isRecording = RuntimeUndo.IsRecording;
if (!isRecording)
{
RuntimeUndo.BeginRecord();
}
RecordOverride();
if (!isRecording)
{
RuntimeUndo.EndRecord();
}
}
}
}
else if (Input.GetMouseButtonUp(0))
{
if (m_isDragging)
{
OnDrop();
bool isRecording = RuntimeUndo.IsRecording;
if (!isRecording)
{
RuntimeUndo.BeginRecord();
}
RecordOverride();
if (!isRecording)
{
RuntimeUndo.EndRecord();
}
m_isDragging = false;
RuntimeTools.ActiveTool = null;
}
}
else
{
if (m_isDragging)
{
Vector3 point;
if (GetPointOnDragPlane(Input.mousePosition, out point))
{
Vector3 offset = m_handlesInverseTransform.MultiplyVector(point - m_prevPoint);
offset = Vector3.Project(offset, m_normal);
if (InputController.GetKey(UnitSnapKey) || RuntimeTools.UnitSnapping)
{
Vector3 gridOffset = Vector3.zero;
if (Mathf.Abs(offset.x * 1.5f) >= GridSize)
{
gridOffset.x = GridSize * Mathf.Sign(offset.x);
}
if (Mathf.Abs(offset.y * 1.5f) >= GridSize)
{
gridOffset.y = GridSize * Mathf.Sign(offset.y);
}
if (Mathf.Abs(offset.z * 1.5f) >= GridSize)
{
gridOffset.z = GridSize * Mathf.Sign(offset.z);
}
if (gridOffset != Vector3.zero)
{
if (OnDrag(m_dragIndex, gridOffset))
{
m_prevPoint = point;
}
}
}
else
{
if (OnDrag(m_dragIndex, offset))
{
m_prevPoint = point;
}
}
}
}
}
UpdateOverride();
}