private static void ProcessKeyEvent(BrushOptionPanel panel, UnityEngine.EventType eventType, KeyCode keyCode, EventModifiers modifiers)
{
if (eventType != UnityEngine.EventType.KeyDown)
return;
var mBrushSizeSlider = Util.GetPrivate<UISlider>(panel, "m_BrushSizeSlider");
var sizeInterval = GetSliderValue(mBrushSizeSlider) < 50f ? 1f : 50f;
if (Util.GetPrivate<SavedInputKey>(panel, "m_IncreaseBrushSize").IsPressed(eventType, keyCode, modifiers))
SetSliderValue(mBrushSizeSlider, GetSliderValue(mBrushSizeSlider) + sizeInterval);
else if (Util.GetPrivate<SavedInputKey>(panel, "m_DecreaseBrushSize").IsPressed(eventType, keyCode, modifiers))
SetSliderValue(mBrushSizeSlider, GetSliderValue(mBrushSizeSlider) - sizeInterval);
else
{
var mBrushStrengthSlider = Util.GetPrivate<UISlider>(panel, "m_BrushStrengthSlider");
var strengthInterval = 0.1f;
if (Util.GetPrivate<SavedInputKey>(panel, "m_IncreaseBrushStrength").IsPressed(eventType, keyCode, modifiers))
{
mBrushStrengthSlider.value = mBrushStrengthSlider.value + strengthInterval;
}
else
{
if (!Util.GetPrivate<SavedInputKey>(panel, "m_DecreaseBrushStrength").IsPressed(eventType, keyCode, modifiers))
return;
mBrushStrengthSlider.value = mBrushStrengthSlider.value - strengthInterval;
}
}
}
public pb_Shortcut(string a, string d, KeyCode k, EventModifiers e)
{
action = a;
description = d;
key = k;
eventModifiers = e;
}
public static int IndexOf(pb_Shortcut[] shortcuts, KeyCode k, EventModifiers e)
{
for(int i = 0; i < shortcuts.Length; i++)
{
if(shortcuts[i].key == k && shortcuts[i].eventModifiers == e)
return i;
}
return -1;
}
static RainbowFoldersPreferences()
{
var homeLabel = new GUIContent("Folder Location", HOME_FOLDER_HINT);
HOME_FOLDER_PREF = new EditorPrefsString(HOME_FOLDER_PREF_KEY + ProjectName, homeLabel, HOME_FOLDER_DEFAULT);
HomeFolder = HOME_FOLDER_PREF.Value;
var modifierLabel = new GUIContent("Modifier Key", MOD_KEY_HINT);
MODIFIER_KEY_PREF = new EditorPrefsModifierKey(MOD_KEY_PREF_KEY + ProjectName, modifierLabel, MOD_KEY_DEFAULT);
ModifierKey = MODIFIER_KEY_PREF.Value;
}
public bool PreventCustomUserHotkey(EventType type, EventModifiers codeModifier, KeyCode hotkey)
{
Event currentevent = Event.current;
if (currentevent.type == type && currentevent.modifiers == codeModifier && currentevent.keyCode == hotkey)
{
currentevent.Use();
return(true);
}
return(false);
}
public void Update(char charCode, KeyCode keyCode, EventModifiers eventModifier, bool ignoreBlocker = true, bool editable = true)
{
if (!_editable)
{
return;
}
_charCode = charCode;
_keyCode = keyCode;
_eventModifier = eventModifier;
_ignoreBlocker = ignoreBlocker;
_editable = editable;
}
public ControlDefinition()
{
ControlType = ControlType.KeysOnly;
MouseButton = -1;
CustomAction = CustomControlAction.Begin_Event;
MouseButtonAlt = -1;
ModifierKeyAlt = EventModifiers.None;
KeyAlt = KeyCode.None;
HasModifierAlt = false;
InputAxisName = "";
IsAxis = false;
IsPositiveAxis = false;
}
public static void EditorPreferences()
{
EditorGUILayout.Separator();
HOME_FOLDER_PREF.Draw();
HomeFolder = HOME_FOLDER_PREF.Value;
EditorGUILayout.Separator();
MODIFIER_KEY_PREF.Draw();
ModifierKey = MODIFIER_KEY_PREF.Value;
GUILayout.FlexibleSpace();
EditorGUILayout.LabelField("Version " + AssetInfo.VERSION, EditorStyles.centeredGreyMiniLabel);
}
public FullscreenOption(EditorFullscreenSettings settings, KeyCode hotkey, EventModifiers modifiers, OpenFullscreenAtPosition openAtPosition, bool showToolbarByDefault, Vector2 position, string optionLabel, Type windowType, bool addToOptionsDict, bool isGameView)
{
this.hotkey = hotkey;
this.modifiers = modifiers;
this.openAtPosition = openAtPosition;
this.showToolbarByDefault = showToolbarByDefault;
this.position = position;
this.optionLabel = optionLabel;
this.windowTypeAssemblyQualifiedName = windowType == null ? null : windowType.AssemblyQualifiedName;
this.isGameView = isGameView;
gameViewOptions = isGameView ? new GameViewOptions() : null;
AssignOptionID(settings, addToOptionsDict);
}
internal void Update(char charCode, KeyCode keyCode, EventModifiers eventModifier, bool ignoreBlocker = true, bool editable = true)
{
if (!m_Editable)
{
return;
}
m_CharCode = charCode;
m_KeyCode = keyCode;
m_EventModifier = eventModifier;
m_IgnoreBlocker = ignoreBlocker;
m_Editable = editable;
}
public void SendTabEvent(EventModifiers eventModifiers = EventModifiers.None)
{
// This is the event sequence we get when user presses tab.
m_Window.SendEvent(new Event {
type = EventType.KeyDown, keyCode = KeyCode.Tab, modifiers = eventModifiers
});
m_Window.SendEvent(new Event {
type = EventType.KeyDown, character = '\t', modifiers = eventModifiers
});
m_Window.SendEvent(new Event {
type = EventType.KeyUp, keyCode = KeyCode.Tab, modifiers = eventModifiers
});
}
private static bool GetKeyCheck(bool isShift, bool hasModifier, EventModifiers modifierKey, KeyCode key, int mouseButton)
{
if (isShift)
{
if (UnityEngine.Input.GetKey(KeyCode.LeftShift) || UnityEngine.Input.GetKey(KeyCode.RightShift))
{
return(true);
}
}
else if (mouseButton != -1)
{
if (UnityEngine.Input.GetMouseButton(mouseButton))
{
return(true);
}
}
else if (UnityEngine.Input.GetKey(key))
{
if (hasModifier)
{
if (modifierKey == EventModifiers.Control)
{
if (UnityEngine.Input.GetKey(KeyCode.LeftControl) || UnityEngine.Input.GetKey(KeyCode.RightControl))
{
return(true);
}
}
else if (modifierKey == EventModifiers.Shift)
{
if (UnityEngine.Input.GetKey(KeyCode.LeftShift) || UnityEngine.Input.GetKey(KeyCode.RightShift))
{
return(true);
}
}
else if (modifierKey == EventModifiers.Alt)
{
if (UnityEngine.Input.GetKey(KeyCode.LeftAlt) || UnityEngine.Input.GetKey(KeyCode.RightAlt) || UnityEngine.Input.GetKey(KeyCode.AltGr))
{
return(true);
}
}
}
else
{
return(true);
}
}
return(false);
}
public bool ActivateShortcut(EventModifiers modifiers, KeyCode key, bool isKeyDown)
{
if (m_editorShortcutsDict.ContainsKey(key))
{
if (isKeyDown)
{
if (m_editorShortcutsDict[key].ContainsKey(modifiers))
{
if (m_editorShortcutsDict[key][modifiers].MyKeyDownFunctionPtr != null)
{
m_editorShortcutsDict[key][modifiers].MyKeyDownFunctionPtr();
return(true);
}
}
}
else
{
if (m_editorShortcutsDict[key].ContainsKey(modifiers))
{
if (m_editorShortcutsDict[key][modifiers].MyKeyUpFunctionPtr != null)
{
m_editorShortcutsDict[key][modifiers].MyKeyUpFunctionPtr();
return(true);
}
}
}
}
if (modifiers == EventModifiers.None && m_editorNoModifiersShortcutsDict.ContainsKey(key))
{
if (isKeyDown)
{
if (m_editorNoModifiersShortcutsDict[key].MyKeyDownFunctionPtr != null)
{
m_editorNoModifiersShortcutsDict[key].MyKeyDownFunctionPtr();
return(true);
}
}
else
{
if (m_editorNoModifiersShortcutsDict[key].MyKeyUpFunctionPtr != null)
{
m_editorNoModifiersShortcutsDict[key].MyKeyUpFunctionPtr();
return(true);
}
}
}
return(false);
}
static bool PreferenceKeyItem(ref KeyCodeWithModifier keyPref, int index = -1)
{
GUILayout.BeginHorizontal();
GUILayout.Label("Key:");
if (keyPref.keyCode != KeyCode.None && !UniqueKey(ref keyPref, index))
{
KeyEventField(index, ref keyPref, constants.redTextBox);
}
else
{
KeyEventField(index, ref keyPref, GUI.skin.textField);
}
GUILayout.EndHorizontal();
GUILayout.BeginHorizontal();
GUILayout.Label("Modifiers:");
GUILayout.BeginVertical();
EventModifiers modifier = keyPref.modifiers;
bool modifier_command = (modifier & EventModifiers.Command) != 0;
bool modifier_alt = (modifier & EventModifiers.Alt) != 0;
bool modifier_shift = (modifier & EventModifiers.Shift) != 0;
bool modifier_control = (modifier & EventModifiers.Control) != 0;
if (Application.platform == RuntimePlatform.OSXEditor)
{
modifier_command = GUILayout.Toggle(modifier_command, "Command");
}
modifier_control = GUILayout.Toggle(modifier_control, "Control");
modifier_shift = GUILayout.Toggle(modifier_shift, "Shift");
modifier_alt = GUILayout.Toggle(modifier_alt, "Alt");
var key_is_no_longer_valid = (index != -1 &&
(GUILayout.Button("Remove") ||
keyPref.keyCode == KeyCode.None));
GUILayout.EndVertical();
GUILayout.EndHorizontal();
if (GUI.changed && key_is_no_longer_valid)
{
keyPref.modifiers = (modifier_command ? EventModifiers.Command : 0)
| (modifier_alt ? EventModifiers.Alt : 0)
| (modifier_shift ? EventModifiers.Shift : 0)
| (modifier_control ? EventModifiers.Control : 0);
}
return(key_is_no_longer_valid);
}
public void Reset()
{
VersionString = Settings.VersionString;
ModifiersNormal = EventModifiers.Alt | EventModifiers.Control;
ModifiersQuick = EventModifiers.Alt | EventModifiers.Control | EventModifiers.Shift;
KeyCodeIncreaseFov = KeyCode.O;
KeyCodeDecreaseFov = KeyCode.P;
FovSpeed = 0.15f;
FovQuickMultiplier = 5.0f;
MinFov = 2.0f;
MaxFov = 160.0f;
}
public static void EndDrag(EditorWindow window, Vector2 mousePosition, EventModifiers modifiers)
{
var evt = new Event()
{
mousePosition = mousePosition,
modifiers = modifiers
};
evt.type = EventType.MouseDrag;
window.SendEvent(evt);
evt.type = EventType.MouseUp;
window.SendEvent(evt);
}
private void ProcessModifierKey(EventModifiers modifiers, EventModifiers delta, EventModifiers flag, Noesis.Key key)
{
if ((delta & flag) > 0)
{
if ((modifiers & flag) > 0)
{
_uiView.KeyDown(key);
}
else
{
_uiView.KeyUp(key);
}
}
}
internal Binding(IAction action, char charCode, KeyCode keyCode, EventModifiers eventModifier, bool ignoreBlocker = true, bool editable = true)
{
m_Action = action;
if (action is StaticAction.StaticAction)
{
m_EventMask = (action as StaticAction.StaticAction).EventMask;
}
else
{
m_EventMask = 0;
}
Update(charCode, keyCode, eventModifier, ignoreBlocker, editable);
}
public void OnSubmit(IReadOnlyList <GameObject> results, int selection, EventModifiers modifiers)
{
Object[] objects;
if ((modifiers & EventModifiers.Shift) != 0)
{
objects = results.Cast <Object>().ToArray();
}
else
{
EditorGUIUtility.PingObject(results[selection]);
objects = new Object[] { results[selection] };
}
Selection.objects = objects;
EditorAppHelpers.OpenHierarchyWindow();
}
public void DoPaintPressed(TileMap tileMap, Vector2 local_pos, EventModifiers modifiers = default(EventModifiers))
{
LogCat.log(string.Format("DoPaintPressed ({0},{1})", TileMapUtil.GetGridX(tileMap, local_pos), TileMapUtil.GetGridY(tileMap, local_pos)));
if (paint_mode == TileSetBrushPaintMode.Pencil)
{
Paint(tileMap, local_pos);
}
else
{
pressed_position = local_pos;
is_dragging = true;
offset = Vector2.zero;
brushPattern = GetBrushPattern();
}
}
public void DoPaintPressed(STETilemap tilemap, Vector2 localPos, EventModifiers modifiers = default(EventModifiers))
{
//Debug.Log("DoPaintPressed (" + TilemapUtils.GetGridX(tilemap, localPos) + "," + TilemapUtils.GetGridY(tilemap, localPos) + ")");
if (m_paintMode == eBrushPaintMode.Pencil)
{
Paint(tilemap, localPos);
}
else
{
m_pressedPosition = localPos;
m_isDragging = true;
Offset = Vector2.zero;
m_brushPattern = GetBrushPattern();
}
}
/// <summary>
/// This is a workaround for Unity where some modifier keys do not generate a KeyDown/KeyUp event.
/// NOTE: This does not distinguish between Left and Right modifier keys.
/// </summary>
private void HandleKeyModifier(Event ev, ref bool keyIsDown, EventModifiers modifier, KeyCode keyCode)
{
if ((ev.modifiers & modifier) == modifier)
{
ev.keyCode = keyCode;
keyIsDown = true;
SFMgr.HandleKeyDownEvent(ev);
}
else if (keyIsDown)
{
ev.keyCode = keyCode;
SFMgr.HandleKeyUpEvent(ev);
keyIsDown = false;
}
}
private void ProcessModifierKey(EventModifiers modifiers, EventModifiers delta,
EventModifiers flag, Noesis.Key key)
{
if ((delta & flag) > 0)
{
if ((modifiers & flag) > 0)
{
Noesis_KeyDown(_rendererId, (int)key);
}
else
{
Noesis_KeyUp(_rendererId, (int)key);
}
}
}
//-----------------------------------------------------------
// ScrollWheel Event Helpers
//-----------------------------------------------------------
public void ScrollWheelEvent(float scrollDelta, Vector2 mousePosition, EventModifiers eventModifiers = EventModifiers.None)
{
#if ENABLE_EVENT_HELPER_TRACE
Debug.Log("ScrollWheel: [" + eventModifiers + "] @" + mousePosition + " delta:" + scrollDelta);
#endif
m_Window.SendEvent(
new Event
{
type = EventType.ScrollWheel,
modifiers = eventModifiers,
mousePosition = mousePosition,
delta = new Vector2(scrollDelta, scrollDelta)
});
}
public void Reset()
{
touchId = -1;
x = 0;
y = 0;
clickCount = 0;
keyCode = KeyCode.None;
modifiers = 0;
mouseWheelDelta = 0;
lastClickTime = 0;
began = false;
target = null;
lastRollOver = null;
clickCancelled = false;
}
public void KeyUpEvent(KeyCode key, EventModifiers eventModifiers = EventModifiers.None)
{
#if ENABLE_EVENT_HELPER_TRACE
Debug.Log("KeyUp: [" + eventModifiers + "][" + key + "]");
#endif
m_Window.SendEvent(
new Event
{
type = EventType.KeyUp,
character = (char)key,
keyCode = key,
modifiers = eventModifiers
});
}
public static void EnumPopup(Rect position, SerializedProperty property, GUIContent label, bool isFlag, Type enumType)
{
// Throw error on wrong type
if (property.propertyType != SerializedPropertyType.Enum)
{
throw new ArgumentException("Parameter selected must be of type System.Enum");
}
// Add label
position = EditorGUI.PrefixLabel(position, GUIUtility.GetControlID(FocusType.Passive), label);
Array enumValues = AllValues(enumType);
string[] enumNames = AllNames(enumType);
// Get current enum name
string enumName = "";
if (property.enumValueIndex >= 0 && property.enumValueIndex < property.enumDisplayNames.Length)
{
enumName = property.enumDisplayNames[property.enumValueIndex];
}
if (isFlag && property.enumValueIndex == -1)
{
if (property.intValue < 1)
{
enumName = "[None]";
}
else if (property.intValue == int.MaxValue)
{
enumName = "[All]";
}
else
{
enumName = "[Mixed]";
}
}
// Display dropdown
if (EditorGUI.DropdownButton(position, new GUIContent(enumName), FocusType.Passive))
{
// Position is all wrong if we show the dropdown during the node draw phase. Instead, add it
// to onLateGUI to display it later.
s_lastModifiers = Event.current?.modifiers ?? EventModifiers.None;
NodeEditorWindow.current.onLateGUI += () => ShowContextMenuAtMouse(property, isFlag, enumValues, enumNames);
}
}
public void CheckGuarantees(Quest completedQuest)
{
if (EventsOption.Frequency[0] > 0)
{
var eventGuarantee = DarkestDungeonManager.Data.EventDatabase.Guarantees.Find(guarantee =>
guarantee.Dungeon == completedQuest.Dungeon && guarantee.QuestType == completedQuest.Type);
if (eventGuarantee != null)
{
GuaranteedEvent = DarkestDungeonManager.Data.EventDatabase.Events.Find(guarantEvent =>
guarantEvent.Id == eventGuarantee.EventId);
EventModifiers.IncludeEvent(GuaranteedEvent);
}
}
}
public static void BeginDrag(EditorWindow window, Vector2 mousePosition, EventModifiers modifiers)
{
var evt = new Event()
{
mousePosition = mousePosition,
modifiers = modifiers
};
evt.type = EventType.MouseDown;
evt.clickCount = 1;
window.SendEvent(evt);
evt.clickCount = 0;
evt.type = EventType.MouseDrag;
window.SendEvent(evt);
}
public void handleKeyEvent(EventType eventType)
{
if (eventType == EventType.KeyDown)
{
KeyCode code = Event.current.keyCode;
if (code == KeyCode.None)
{
return;
}
EventModifiers mods = Event.current.modifiers;
unityKeyEvent(instanceID, code, mods, code.ToString());
}
}
/**
* Applies the currently queued material to the selected face and eats the event.
*/
public bool ClickShortcutCheck(EventModifiers em, pb_Object pb, pb_Face quad)
{
if (pb_UV_Editor.instance == null)
{
if (em == (EventModifiers.Control | EventModifiers.Shift))
{
pbUndo.RecordObject(pb, "Quick Apply NoDraw");
pb.SetFaceMaterial(quad, queuedMaterial);
OnFaceChanged(pb);
pb_Editor_Utility.ShowNotification("Quick Apply Material");
return(true);
}
}
return(false);
}
public bool HandleKeyEvent(Event e)
{
InitKeyActions();
EventModifiers modifiers = e.modifiers;
e.modifiers &= ~EventModifiers.CapsLock;
if (s_Keyactions.ContainsKey(e))
{
TextEditOp operation = s_Keyactions[e];
PerformOperation(operation);
e.modifiers = modifiers;
return(true);
}
e.modifiers = modifiers;
return(false);
}
internal static T GetPooled(Vector2 position, int button, int clickCount, Vector2 delta,
EventModifiers modifiers, bool fromOS)
{
T e = GetPooled();
e.modifiers = modifiers;
e.mousePosition = position;
e.localMousePosition = position;
e.mouseDelta = delta;
e.button = button;
e.pressedButtons = PointerDeviceState.GetPressedButtons(PointerId.mousePointerId);
e.clickCount = clickCount;
((IMouseEventInternal)e).triggeredByOS = fromOS;
((IMouseEventInternal)e).recomputeTopElementUnderMouse = true;
return(e);
}
public pb_Shortcut(string str)
{
string[] split = str.Split('-');
// split[0] = action
// split[1] = description
KeyCode k = pbUtil.ParseEnum(split[2], KeyCode.None);
string[] modSplit = split[3].Split(',');
EventModifiers e = (EventModifiers)0;
for(int i = 0; i < modSplit.Length; i++)
{
e |= pbUtil.ParseEnum(modSplit[i], (EventModifiers)0);
}
action = split[0];
description = split[1];
key = k;
eventModifiers = e;
// return new Shortcut(split[0], split[1], k, e);
}
public void Reset()
{
touchId = -1;
x = 0;
y = 0;
clickCount = 0;
button = 0;
keyCode = KeyCode.None;
modifiers = 0;
mouseWheelDelta = 0;
lastClickTime = 0;
began = false;
target = null;
downTargets.Clear();
lastRollOver = null;
clickCancelled = false;
touchEndMonitors.Clear();
}
public void Reset()
{
touchId = -1;
x = 0;
y = 0;
clickCount = 0;
keyCode = KeyCode.None;
modifiers = 0;
mouseWheelDelta = 0;
lastClickTime = 0;
began = false;
target = null;
lastRollOver = null;
clickCancelled = false;
}
public bool Matches(KeyCode key, EventModifiers modifiers)
{
return this.key == key && this.eventModifiers == modifiers;
}
public bool ClickShortcutCheck(EventModifiers em, pb_Object pb, pb_Face quad)
{
// if(em == (EventModifiers.Control | EventModifiers.Shift | EventModifiers.Alt))
// {
// Continue(pb, quad);
// pb_Editor_Utility.ShowNotification("Continue UV");
// return true;
// }
if(em == (EventModifiers.Control | EventModifiers.Shift)) {
ApplyMaterial(pb, quad, queuedMat);
RepaintSceneViews();
pb_Editor_Utility.ShowNotification("Quick Apply Material");
return true;
}
if(em == (EventModifiers.Control))
{
pb.SetFaceUV(quad, new pb_UV(uv_gui));
RepaintSceneViews();
pb_Editor_Utility.ShowNotification("Copy UV Settings");
return true;
}
return false;
}
private void processKeyEvent( EventType eventType, KeyCode keyCode, EventModifiers modifiers )
{
var activeControl = dfGUIManager.ActiveControl;
if( activeControl == null || !activeControl.IsEnabled || !activeControl.transform.IsChildOf( this.transform ) )
return;
var controlKey =
( ( modifiers & EventModifiers.Control ) == EventModifiers.Control ) ||
( ( modifiers & EventModifiers.Command ) == EventModifiers.Command );
var shiftKey = ( modifiers & EventModifiers.Shift ) == EventModifiers.Shift;
var altKey = ( modifiers & EventModifiers.Alt ) == EventModifiers.Alt;
var args = new dfKeyEventArgs(
activeControl,
keyCode,
controlKey,
shiftKey,
altKey
);
if( keyCode >= KeyCode.Space && keyCode <= KeyCode.Z )
{
var ch = (char)keyCode;
args.Character = shiftKey ? char.ToUpper( ch ) : char.ToLower( ch );
}
if( eventType == EventType.keyDown )
{
activeControl.OnKeyDown( args );
}
else if( eventType == EventType.keyUp )
{
activeControl.OnKeyUp( args );
}
if( args.Used || eventType == EventType.keyUp )
return;
// TODO: Implement Tab and Enter key processing?
}
void OnKeyDown(KeyCode key, EventModifiers modifiers)
{
Debug.Log ("KeyDown " + key);
}
// 設定の読み込み
public void Load(Func<string, string> getValue)
{
Get(getValue("PresetPath"), ref presetPath);
Get(getValue("PresetDirPath"), ref presetDirPath);
GetKeyCode(getValue("ToggleWindow"), ref toggleKey);
string keylist = null;
if (Get(getValue("ToggleWindowModifier"), ref keylist) && keylist != null) {
keylist = keylist.ToLower();
if (keylist.Contains("alt")) {
toggleModifiers |= EventModifiers.Alt;
}
if (keylist.Contains("control")) {
toggleModifiers |= EventModifiers.Control;
}
if (keylist.Contains("shift")) {
toggleModifiers |= EventModifiers.Shift;
}
}
Get(getValue("SliderShininessMax"), ref shininessMax);
Get(getValue("SliderShininessMin"), ref shininessMin);
Get(getValue("SliderOutlineWidthMax"), ref outlineWidthMax);
Get(getValue("SliderOutlineWidthMin"), ref outlineWidthMin);
Get(getValue("SliderRimPowerMax"), ref rimPowerMax);
Get(getValue("SliderRimPowerMin"), ref rimPowerMin);
Get(getValue("SliderRimShiftMax"), ref rimShiftMax);
Get(getValue("SliderRimShiftMin"), ref rimShiftMin);
Get(getValue("SliderHiRateMax"), ref hiRateMax);
Get(getValue("SliderHiRateMin"), ref hiRateMin);
Get(getValue("SliderHiPowMax"), ref hiPowMax);
Get(getValue("SliderHiPowMin"), ref hiPowMin);
Get(getValue("SliderFloatVal1Max"), ref floatVal1Max);
Get(getValue("SliderFloatVal1Min"), ref floatVal1Min);
Get(getValue("SliderFloatVal2Max"), ref floatVal2Max);
Get(getValue("SliderFloatVal2Min"), ref floatVal2Min);
Get(getValue("SliderFloatVal3Max"), ref floatVal3Max);
Get(getValue("SliderFloatVal3Min"), ref floatVal3Min);
Get(getValue("EditShininessMax"), ref shininessEditMax);
Get(getValue("EditShininessMin"), ref shininessEditMin);
Get(getValue("EditOutlineWidthMax"), ref outlineWidthEditMax);
Get(getValue("EditOutlineWidthMin"), ref outlineWidthEditMin);
Get(getValue("EditRimPowerMax"), ref rimPowerEditMax);
Get(getValue("EditRimPowerMin"), ref rimPowerEditMin);
Get(getValue("EditRimShiftMax"), ref rimShiftEditMax);
Get(getValue("EditRimShiftMin"), ref rimShiftEditMin);
Get(getValue("EditHiRateMax"), ref hiRateEditMax);
Get(getValue("EditHiRateMin"), ref hiRateEditMin);
Get(getValue("EditHiPowMax"), ref hiPowEditMax);
Get(getValue("EditHiPowMin"), ref hiPowEditMin);
Get(getValue("EditFloatVal1Max"), ref floatVal1EditMax);
Get(getValue("EditFloatVal1Min"), ref floatVal1EditMin);
Get(getValue("EditFloatVal2Max"), ref floatVal2EditMax);
Get(getValue("EditFloatVal2Min"), ref floatVal2EditMin);
Get(getValue("EditFloatVal3Max"), ref floatVal3EditMax);
Get(getValue("EditFloatVal3Min"), ref floatVal3EditMin);
var texlist = string.Empty;
Get(getValue("ToonTexAddon"), ref texlist);
if (texlist.Length > 0) {
// カンマで分割後trm
toonTexAddon = texlist.Split(new char[]{','}, StringSplitOptions.RemoveEmptyEntries).Select(p => p.Trim()).ToArray();
}
texlist = string.Empty;
Get(getValue("ToonTex"), ref texlist);
if (texlist.Length > 0) {
// カンマで分割後trm
toonTexes = texlist.Split(new char[]{','}, StringSplitOptions.RemoveEmptyEntries).Select(p => p.Trim()).ToArray();
}
Get(getValue("ToonComboAutoApply"), ref toonComboAutoApply);
Get(getValue("DisplaySlotName"), ref displaySlotName);
Get(getValue("EnableMask"), ref enableMask);
Get(getValue("EnableMoza"), ref enableMoza);
Get(getValue("SSWithoutUI"), ref SSWithoutUI);
var listStr = string.Empty;
Get(getValue("EnableScenes"), ref listStr);
if (listStr.Length > 0) ParseList(listStr, ref enableScenes);
listStr = string.Empty;
Get(getValue("EnableOHScenes"), ref listStr);
if (listStr.Length > 0) ParseList(listStr, ref enableOHScenes);
listStr = string.Empty;
Get(getValue("DisableScenes"), ref listStr);
if (listStr.Length > 0) ParseList(listStr, ref disableScenes);
listStr = string.Empty;
Get(getValue("DisableOHScenes"), ref listStr);
if (listStr.Length > 0) ParseList(listStr, ref disableOHScenes);
}
void OnKeyUp(KeyCode key, EventModifiers modifiers)
{
Debug.Log ("KeyUp " + key);
}
/// <summary>
/// 处理键盘输入.
/// </summary>
void OnKeyboardInput(KeyCode keyCode, EventModifiers modifiers)
{
bool repaint = false;
if (keyCode == KeyCode.BackQuote)
{
repaint = OnBackQuote((Event.current.modifiers & EventModifiers.Shift) != 0);
}
if (keyCode == KeyCode.Return)
{
repaint = OnReturn(modifiers);
}
if (repaint)
{
Repaint();
}
}
bool OnReturn(EventModifiers modifiers)
{
if (!planting) { return false; }
if (plantedVertices.Count < 3)
{
EditorUtility.DisplayDialog("Error", "Insufficient vertices for a polygon.", "Ok");
return false;
}
RenderVertices(plantedVertices, (modifiers & EventModifiers.Shift) != 0);
ClearPlanted();
return true;
}
private bool IsModifierDown(EventModifiers modifier)
{
return (Event.current.modifiers & modifier) == modifier;
}
/**
* Applies the currently queued material to the selected face and eats the event.
*/
public bool ClickShortcutCheck(EventModifiers em, pb_Object pb, pb_Face quad)
{
if(pb_UV_Editor.instance == null)
{
if(em == (EventModifiers.Control | EventModifiers.Shift))
{
pbUndo.RecordObject(pb, "Quick Apply NoDraw");
pb.SetFaceMaterial(quad, queuedMaterial);
OnFaceChanged(pb);
pb_Editor_Utility.ShowNotification("Quick Apply Material");
return true;
}
}
return false;
}
