FindProperty() public method

Find serialized property by name.

public FindProperty ( string propertyPath ) : UnityEditor.SerializedProperty
propertyPath string
return UnityEditor.SerializedProperty
    public void OnEnable()
    {
        disableBehaviour = new SerializedObject(this.target);
        this.fireTime = disableBehaviour.FindProperty("firetime");
        this.componentsProperty = disableBehaviour.FindProperty("Behaviour");
        this.editorRevert = disableBehaviour.FindProperty("editorRevertMode");
        this.runtimeRevert = disableBehaviour.FindProperty("runtimeRevertMode");
        Component currentComponent = componentsProperty.objectReferenceValue as Component;

        DisableBehaviour behaviour = (target as DisableBehaviour);
        if (behaviour == null || behaviour.ActorTrackGroup == null || behaviour.ActorTrackGroup.Actor == null)
        {
            return;
        }
        GameObject actor = behaviour.ActorTrackGroup.Actor.gameObject;

        Component[] behaviours = DirectorHelper.getEnableableComponents(actor);
        for (int j = 0; j < behaviours.Length; j++)
        {
            if (behaviours[j] == currentComponent)
            {
                componentSelection = j;
            }
        }
    }
	void OnEnable()
	{
		srcObj = new SerializedObject(target);

		displace = srcObj.FindProperty("displace");
		amount = srcObj.FindProperty("amount");
	}
Beispiel #3
0
    void OnEnable()
    {
        srcObj = new SerializedObject(target);

        scale = srcObj.FindProperty("scale");
        brightness = srcObj.FindProperty("brightness");
    }
 public void OnEnable()
 {
     movingPlatform = (StationaryMovingPlatform)target;
     mObj = new SerializedObject(target);
     mDuration = mObj.FindProperty("duration");
     mStationsList = mObj.FindProperty("stationList");
 }
 public void OnEnable()
 {
     serObj = new SerializedObject (target);
     sharedMaterial = serObj.FindProperty("sharedMaterial");
     waterQuality = serObj.FindProperty("waterQuality");
     edgeBlend = serObj.FindProperty("edgeBlend");
 }
 void OnEnable()
 {
     m_soTarget = new SerializedObject(target);
     m_soRadiusFront = m_soTarget.FindProperty("radiusFront");
     m_soRadiusBack = m_soTarget.FindProperty("radiusBack");
     m_soMirrorWheels = m_soTarget.FindProperty("mirrorWheels");
 }
Beispiel #7
0
        public override void ShowGUI()
        {
            if (this == null)
            {
                return;
            }

            var serializedObject = new UnityEditor.SerializedObject(this);

            serializedObject.Update();
            SerializedProperty eventProperty = serializedObject.FindProperty("unityEvent");

            EditorGUILayout.PropertyField(eventProperty, true);

            ignoreWhenSkipping = EditorGUILayout.Toggle("Ignore when skipping?", ignoreWhenSkipping);
            if (ignoreWhenSkipping)
            {
                SerializedProperty skipEventProperty = serializedObject.FindProperty("skipEvent");
                EditorGUILayout.PropertyField(skipEventProperty, true);
            }

            serializedObject.ApplyModifiedProperties();

            EditorGUILayout.HelpBox("Parameters passed from here cannot be set, unfortunately, due to a Unity limitation.", MessageType.Warning);

            AfterRunningOption();
        }
Beispiel #8
0
    void OnEnable()
    {
        serObj = new SerializedObject (target);

        visualizeFocus = serObj.FindProperty ("visualizeFocus");

        focalLength = serObj.FindProperty ("focalLength");
        focalSize = serObj.FindProperty ("focalSize");
        aperture = serObj.FindProperty ("aperture");
        focalTransform = serObj.FindProperty ("focalTransform");
        maxBlurSize = serObj.FindProperty ("maxBlurSize");
        highResolution = serObj.FindProperty ("highResolution");

        blurType = serObj.FindProperty ("blurType");
        blurSampleCount = serObj.FindProperty ("blurSampleCount");

        nearBlur = serObj.FindProperty ("nearBlur");
        foregroundOverlap = serObj.FindProperty ("foregroundOverlap");

        dx11BokehThreshhold = serObj.FindProperty ("dx11BokehThreshhold");
        dx11SpawnHeuristic = serObj.FindProperty ("dx11SpawnHeuristic");
        dx11BokehTexture = serObj.FindProperty ("dx11BokehTexture");
        dx11BokehScale = serObj.FindProperty ("dx11BokehScale");
        dx11BokehIntensity = serObj.FindProperty ("dx11BokehIntensity");
    }
        private string ShowComponents(SerializedObject objTarget, GameObject gameObject)
        {
            var targetComponentAssemblyName = objTarget.FindProperty("targetComponentAssemblyName");
            var targetComponentFullname = objTarget.FindProperty("targetComponentFullname");
            var targetComponentText = objTarget.FindProperty("targetComponentText");
            var objComponents = gameObject.GetComponents<Component>();
            var objTypesAssemblynames = (from objComp in objComponents select objComp.GetType().AssemblyQualifiedName).ToList();
            var objTypesName = (from objComp in objComponents select objComp.GetType().Name).ToList();

            int index = objTypesAssemblynames.IndexOf(targetComponentAssemblyName.stringValue);

            index = EditorGUILayout.Popup("Target Component", index, objTypesName.ToArray());

            if (index != -1)
            {
                targetComponentAssemblyName.stringValue = objTypesAssemblynames[index];
                targetComponentFullname.stringValue = objComponents.GetType().FullName;
                targetComponentText.stringValue = objTypesName[index];
            }
            else
            {
                targetComponentAssemblyName.stringValue = null;
            }

            objTarget.ApplyModifiedProperties();

            return targetComponentAssemblyName.stringValue;
        }
Beispiel #10
0
//--> checkIfIDExist
    private void checkIfIDExist(SerializedProperty selectedID)
    {
        string objectPath2 = "Assets/AP/Assets/Datas/ProjectManagerDatas.asset";
        datasProjectManager _datasProjectManager = AssetDatabase.LoadAssetAtPath(objectPath2, typeof(UnityEngine.Object)) as datasProjectManager;


        string   objectPath = "Assets/AP/Assets/Resources/" + _datasProjectManager.currentDatasProjectFolder + "/TextList/wItem.asset";
        TextList _textList  = AssetDatabase.LoadAssetAtPath(objectPath, typeof(UnityEngine.Object)) as TextList;

        if (_textList)
        {
            SerializedObject serializedObject2 = new UnityEditor.SerializedObject(_textList);

            if (selectedID.intValue < serializedObject2.FindProperty("diaryList").GetArrayElementAtIndex(0).FindPropertyRelative("_languageSlot").arraySize &&
                selectedID.intValue >= 0)
            {
                SerializedProperty _Title = serializedObject2.FindProperty("diaryList").GetArrayElementAtIndex(0).FindPropertyRelative("_languageSlot").GetArrayElementAtIndex(selectedID.intValue).FindPropertyRelative("diaryTitle").GetArrayElementAtIndex(0);

                EditorGUILayout.BeginHorizontal();
                EditorGUILayout.LabelField("Item :", GUILayout.Width(40));
                EditorGUILayout.LabelField(_Title.stringValue.ToString());
                EditorGUILayout.EndHorizontal();
            }
            else
            {
                EditorGUILayout.HelpBox("This ID doesn't exist", MessageType.Warning);
            }
        }
    }
 void OnEnable()
 {
     serObj = new SerializedObject(target);
     bloomIntensity = serObj.FindProperty("bloomIntensity");
     lensDirtIntensity = serObj.FindProperty("lensDirtIntensity");
     lensDirtTexture = serObj.FindProperty("lensDirtTexture");
 }
Beispiel #12
0
        private static void SetupWrldMap(GameObject wrldMapGameobject, Camera streamingCamera, double latitudeDegrees,
                                         double longitudeDegrees, string materialDirectory)
        {
            if (wrldMapGameobject != null)
            {
                WrldMap            wrldMap = wrldMapGameobject.AddComponent <WrldMap> ();
                SerializedObject   serializedWrldMapObject          = new UnityEditor.SerializedObject(wrldMap);
                SerializedProperty streamingCameraProperty          = serializedWrldMapObject.FindProperty("m_streamingCamera");
                SerializedProperty latitudeDegreesProperty          = serializedWrldMapObject.FindProperty("m_latitudeDegrees");
                SerializedProperty longitudeDegreesProperty         = serializedWrldMapObject.FindProperty("m_longitudeDegrees");
                SerializedProperty materialDirectoryProperty        = serializedWrldMapObject.FindProperty("m_materialDirectory");
                SerializedProperty useBuiltInCameraControlsProperty = serializedWrldMapObject.FindProperty("m_useBuiltInCameraControls");

                streamingCameraProperty.objectReferenceValue = streamingCamera;
                latitudeDegreesProperty.doubleValue          = latitudeDegrees;
                longitudeDegreesProperty.doubleValue         = longitudeDegrees;
                materialDirectoryProperty.stringValue        = materialDirectory;
                useBuiltInCameraControlsProperty.boolValue   = false;

                serializedWrldMapObject.ApplyModifiedProperties();
            }
            else
            {
                Debug.LogError("WrldMap gameobject not referenced in WRLDARKitSetupHelper.");
            }
        }
Beispiel #13
0
    void OnEnable()
    {
        srcObj = new SerializedObject(target);

        strength = srcObj.FindProperty("strength");
        clamp = srcObj.FindProperty("clamp");
    }
Beispiel #14
0
    void Update()
    {
        if (dlb_GameManager.dlb_state == dlb_GameManager.States.play)
        {
            dlb_Move();
            dlb_Fire();
        }
        else if (dlb_GameManager.dlb_state == dlb_GameManager.States.wait || dlb_GameManager.dlb_state == dlb_GameManager.States.nextWave)
        {
            dlb_Move();             //peut bouger pour attraper la capsule dans l'attente d'une nouvelle vague
        }

        // vérifie si un bonus est appliqué
        if (dlb_bonus)
        {
            dlb_delaiBonus += Time.deltaTime;
            // vérifie si le délai du bonus obtenu est dépassé
            if (dlb_delaiBonus > dlb_capsule.dlb_delai)
            {
                // remise des valeurs par défaut du joueur
                dlb_speed      = 5f;
                dlb_fireRate   = .50f;
                dlb_invincible = false;
                dlb_bonus      = false;
                dlb_delaiBonus = 0;
                dlb_halo.FindProperty("m_Enabled").boolValue = dlb_bonus;                 // dlb_halo.enabled = dlb_bonus;
                dlb_halo.ApplyModifiedProperties();
                print("Fin du bonus");
            }
        }
    }
 void OnEnable()
 {
     t = (IpcIrcEventHandler)target;
     GetTarget = new SerializedObject(t);
     ThisString = GetTarget.FindProperty("triggerPhrase"); // Find the triggerphrase string
     ThisList = GetTarget.FindProperty("myEventList"); // Find the List in our script and create a refrence of it
 }
	void OnEnable()
	{
		playerId = serializedObject.FindProperty("playerId");
		bodyTrackingDevice = serializedObject.FindProperty("bodyTrackingDevice");
//		gestureSelectionMethod = serializedObject.FindProperty("gestureSelectionMethod");
		wandStart = serializedObject.FindProperty("wandStart");
		wandEnd = serializedObject.FindProperty("wandEnd");
		rotationNoiseCovariance = serializedObject.FindProperty("rotationNoiseCovariance");
		visualizerThreshold = serializedObject.FindProperty("visualizerThreshold");
		visualizerWidth = serializedObject.FindProperty("visualizerWidth");
		visualizerHeight = serializedObject.FindProperty("visualizerHeight");
		wandColor = serializedObject.FindProperty("wandColor");
//		gestureRecognizer = serializedObject.FindProperty("gestureRecognizer");
		wandPositionVisualizer = serializedObject.FindProperty("wandPositionVisualizer");
		showVisualizer = serializedObject.FindProperty("showVisualizer");
		switchToAvailableKinect = serializedObject.FindProperty("switchToAvailableKinect");
		
		skeletonWand = target as RUISSkeletonWand;
		
		if(skeletonWand) {
			gestureSelectionMethodLink = new SerializedObject(skeletonWand);
			guiGestureSelectionMethodChoiceLink = gestureSelectionMethodLink.FindProperty("gestureSelectionMethod");
			gestureScriptLink = gestureSelectionMethodLink.FindProperty("gestureSelectionScriptName");
		}
		
	}
    void OnEnable()
    {
        srcObj = new SerializedObject(target);

        rampTexture = srcObj.FindProperty("rampTexture");
        amount = srcObj.FindProperty("amount");
    }
Beispiel #18
0
    // ===========================================================
    // Static Methods
    // ===========================================================
    
    public static void DrawInspector(SerializedObject so) {
        so.Update();
        
        var mode = so.FindProperty("mode");
        var position = so.FindProperty("position");
        var anchorObject = so.FindProperty("anchorObject");
        var anchorCamera = so.FindProperty("anchorCamera");
        
        MadGUI.PropertyField(mode, "Mode");
        switch ((MadAnchor.Mode) mode.enumValueIndex) {
            case MadAnchor.Mode.ObjectAnchor:
                MadGUI.PropertyField(anchorObject, "Anchor Object", MadGUI.ObjectIsSet);
                MadGUI.PropertyField(anchorCamera, "Anchor Camera", property => property.objectReferenceValue != null || HasMainCamera());

                if (!HasMainCamera()) {
                    GUIMissingMainCameraWarning();
                } else if (anchorCamera.objectReferenceValue == null) {
                    GUIMainCameraWillBeUsed();
                }
                break;
                
            case MadAnchor.Mode.ScreenAnchor:
                MadGUI.PropertyField(position, "Position");
                break;
                
            default:
                MadDebug.Assert(false, "Unknown mode: " + (MadAnchor.Mode) mode.enumValueIndex);
                break;
        }
        
        so.ApplyModifiedProperties();
    }
 // Use this for initialization
 void OnEnable()
 {
     waypoint = new SerializedObject(target);
     lanesCount = waypoint.FindProperty("waypointsCount");
     laneid =  waypoint.FindProperty("pathID");
     objectsCount = (GameObject.FindObjectOfType(typeof(Lane)) as Lane).gameObject.GetComponentsInChildren<WayPoint>().Length;
 }
    void OnGUI()
    {
        m_Type = (ItemType)EditorGUILayout.EnumPopup("Item Type", m_Type);
        m_strName = EditorGUILayout.TextField("Name", m_strName);
        m_strDescription = EditorGUILayout.TextField("Description", m_strDescription);

        ScriptableObject target = this;
        SerializedObject so = new SerializedObject(target);
        SerializedProperty sp_picNames = so.FindProperty("m_strPicNames");
        SerializedProperty sp_childItems = so.FindProperty("m_iChildItems");

        EditorGUILayout.PropertyField(sp_picNames, true);
        EditorGUILayout.PropertyField(sp_childItems, true);
        so.ApplyModifiedProperties();


        if (GUILayout.Button("Create"))
        {
            ItemInfo info = new ItemInfo();
            info.m_iID = 0;
            info.m_Type = m_Type;
            info.m_strName = m_strName;
            info.m_strDescription = m_strDescription;
            info.m_iPhotoIDs = m_iPhotoIDs;
            info.m_iChildIDs = m_iChildIDs;

            WriteItemInfo(info);
        }
    }
    public void LegacyEffectScaleChange(float Value)
    {
        ParticleEmitter[] ParticleEmitters = GetComponentsInChildren<ParticleEmitter>();
        ParticleAnimator[] ParticleAnimators = GetComponentsInChildren<ParticleAnimator>();
        ParticleRenderer[] ParticleRenderers = GetComponentsInChildren<ParticleRenderer>();

        transform.localScale *= Value;

        foreach (ParticleEmitter _ParticleEmitter in ParticleEmitters)
        {
            _ParticleEmitter.minSize *= Value;
            _ParticleEmitter.maxSize *= Value;
            _ParticleEmitter.localVelocity *= Value;
            _ParticleEmitter.rndAngularVelocity *= Value;
            _ParticleEmitter.rndVelocity *= Value;
            SerializedObject _SerializedObject = new SerializedObject(_ParticleEmitter);
            _SerializedObject.FindProperty("m_Ellipsoid").vector3Value *= Value;
            _SerializedObject.FindProperty("tangentVelocity").vector3Value *= Value;
            _SerializedObject.ApplyModifiedProperties();

        }

        foreach (ParticleAnimator _ParticleAnimator in ParticleAnimators)
        {
            _ParticleAnimator.sizeGrow *= Value;
            _ParticleAnimator.force *= Value;
            _ParticleAnimator.rndForce *= Value;

        }

        foreach (ParticleRenderer _ParticleRenderer in ParticleRenderers)
        {
            _ParticleRenderer.maxParticleSize *= Value;
        }
    }
Beispiel #22
0
		private void DoVariable(FsmVariable variable){
			SerializedObject serializedObject = new SerializedObject (variable);
			SerializedProperty nameProperty = serializedObject.FindProperty ("name");
			SerializedProperty valueProperty = serializedObject.FindProperty ("value");

			GUILayout.BeginHorizontal ();
			serializedObject.Update ();
			EditorGUILayout.PropertyField(nameProperty,GUIContent.none);
			if (valueProperty != null) {
				if (valueProperty.propertyType == SerializedPropertyType.Boolean) {
					EditorGUILayout.PropertyField (valueProperty, GUIContent.none, GUILayout.Width (17));	
				} else {
					EditorGUILayout.PropertyField (valueProperty, GUIContent.none);
				}
			}
			serializedObject.ApplyModifiedProperties ();
			GUILayout.FlexibleSpace ();
			if (GUILayout.Button (FsmEditorStyles.toolbarMinus,FsmEditorStyles.label)) {
				FsmEditor.Root.Variables=ArrayUtility.Remove<FsmVariable>(FsmEditor.Root.Variables,variable);
				UnityEngine.Object.DestroyImmediate(variable,true);
				AssetDatabase.SaveAssets();
			}
			GUILayout.EndHorizontal ();

		}
Beispiel #23
0
    void ScaleLegacySystems(float scaleFactor)
    {
        //get all emitters we need to do scaling on
        ParticleEmitter[] emitters = GetComponentsInChildren<ParticleEmitter>();

        //get all animators we need to do scaling on
        ParticleAnimator[] animators = GetComponentsInChildren<ParticleAnimator>();

        //apply scaling to emitters
        foreach (ParticleEmitter emitter in emitters)
        {
            emitter.minSize *= scaleFactor;
            emitter.maxSize *= scaleFactor;
            emitter.worldVelocity *= scaleFactor;
            emitter.localVelocity *= scaleFactor;
            emitter.rndVelocity *= scaleFactor;

            //some variables cannot be accessed through regular script, we will acces them through a serialized object
            SerializedObject so = new SerializedObject(emitter);

            so.FindProperty("m_Ellipsoid").vector3Value *= scaleFactor;
            so.FindProperty("tangentVelocity").vector3Value *= scaleFactor;
            so.ApplyModifiedProperties();
        }

        //apply scaling to animators
        foreach (ParticleAnimator animator in animators)
        {
            animator.force *= scaleFactor;
            animator.rndForce *= scaleFactor;
        }
    }
 internal override void Apply()
 {
     MappingRelevantSettings[] sourceArray = new MappingRelevantSettings[base.targets.Length];
     for (int i = 0; i < base.targets.Length; i++)
     {
         SerializedObject obj2 = new SerializedObject(base.targets[i]);
         SerializedProperty property = obj2.FindProperty("m_AnimationType");
         SerializedProperty property2 = obj2.FindProperty("m_CopyAvatar");
         sourceArray[i].humanoid = property.intValue == 3;
         sourceArray[i].hasNoAnimation = property.intValue == 0;
         sourceArray[i].copyAvatar = property2.boolValue;
     }
     MappingRelevantSettings[] destinationArray = new MappingRelevantSettings[base.targets.Length];
     Array.Copy(sourceArray, destinationArray, base.targets.Length);
     for (int j = 0; j < base.targets.Length; j++)
     {
         if (!this.m_AnimationType.hasMultipleDifferentValues)
         {
             destinationArray[j].humanoid = this.m_AnimationType.intValue == 3;
         }
         if (!this.m_CopyAvatar.hasMultipleDifferentValues)
         {
             destinationArray[j].copyAvatar = this.m_CopyAvatar.boolValue;
         }
     }
     base.serializedObject.ApplyModifiedProperties();
     for (int k = 0; k < base.targets.Length; k++)
     {
         if (sourceArray[k].usesOwnAvatar && !destinationArray[k].usesOwnAvatar)
         {
             SerializedObject serializedObject = new SerializedObject(base.targets[k]);
             AvatarSetupTool.ClearAll(serializedObject);
             serializedObject.ApplyModifiedProperties();
         }
         if (!sourceArray[k].usesOwnAvatar && destinationArray[k].usesOwnAvatar)
         {
             ModelImporter importer = base.targets[k] as ModelImporter;
             if (sourceArray[k].hasNoAnimation)
             {
                 AssetDatabase.ImportAsset(importer.assetPath);
             }
             SerializedObject modelImporterSerializedObject = new SerializedObject(base.targets[k]);
             GameObject original = AssetDatabase.LoadMainAssetAtPath(importer.assetPath) as GameObject;
             Animator component = original.GetComponent<Animator>();
             bool flag = (component != null) && !component.hasTransformHierarchy;
             if (flag)
             {
                 original = UnityEngine.Object.Instantiate<GameObject>(original);
                 AnimatorUtility.DeoptimizeTransformHierarchy(original);
             }
             AvatarSetupTool.AutoSetupOnInstance(original, modelImporterSerializedObject);
             this.m_IsBiped = AvatarBipedMapper.IsBiped(original.transform);
             if (flag)
             {
                 UnityEngine.Object.DestroyImmediate(original);
             }
             modelImporterSerializedObject.ApplyModifiedProperties();
         }
     }
 }
 public void OnEnable(SerializedObject serializedObject)
 {
     this.m_WidthMultiplier = serializedObject.FindProperty("m_Parameters.widthMultiplier");
     this.m_WidthCurve = serializedObject.FindProperty("m_Parameters.widthCurve");
     this.m_Settings.hRangeMin = 0f;
     this.m_Settings.vRangeMin = 0f;
     this.m_Settings.vRangeMax = 1f;
     this.m_Settings.hRangeMax = 1f;
     this.m_Settings.vSlider = false;
     this.m_Settings.hSlider = false;
     TickStyle style = new TickStyle {
         tickColor = { color = new Color(0f, 0f, 0f, 0.15f) },
         distLabel = 30
     };
     this.m_Settings.hTickStyle = style;
     TickStyle style2 = new TickStyle {
         tickColor = { color = new Color(0f, 0f, 0f, 0.15f) },
         distLabel = 20
     };
     this.m_Settings.vTickStyle = style2;
     this.m_Settings.undoRedoSelection = true;
     this.m_Editor = new CurveEditor(new Rect(0f, 0f, 1000f, 100f), new CurveWrapper[0], false);
     this.m_Editor.settings = this.m_Settings;
     this.m_Editor.margin = 25f;
     this.m_Editor.SetShownHRangeInsideMargins(0f, 1f);
     this.m_Editor.SetShownVRangeInsideMargins(0f, 1f);
     this.m_Editor.ignoreScrollWheelUntilClicked = true;
     Undo.undoRedoPerformed = (Undo.UndoRedoCallback) Delegate.Combine(Undo.undoRedoPerformed, new Undo.UndoRedoCallback(this.UndoRedoPerformed));
 }
    public override void OnInspectorGUI()
    {
        aap = serializedObject;
        SerializedProperty movementActions = aap.FindProperty ("actions");
        SerializedProperty fireTags = aap.FindProperty ("fireTags");
        SerializedProperty bulletTags = aap.FindProperty ("bulletTags");

        DanmakuEditorUtils.AttackPatternPropertiesGUI (aap);
        if(EditorGUILayout.PropertyField (movementActions, new GUIContent("Movement Pattern")))
        {
            CommonActionDrawer.attackPattern = target as ActionAttackPattern;
            DanmakuEditorUtils.ActionGroupField(movementActions, this, true);
        }
        if(EditorGUILayout.PropertyField (fireTags))
        {
            CommonActionDrawer.attackPattern = target as ActionAttackPattern;
            DanmakuEditorUtils.TagGroupField(fireTags, this, false);
        }
        if(EditorGUILayout.PropertyField (bulletTags))
        {
            CommonActionDrawer.attackPattern = target as ActionAttackPattern;
            DanmakuEditorUtils.TagGroupField(bulletTags, this, false);
        }
        aap.ApplyModifiedProperties ();
    }
    public override void OnInspectorGUI()
    {
        SerializedObject myScript = new SerializedObject(target);
        SerializedProperty SpawnGameObject = myScript.FindProperty("SpawnGameObject");
        SerializedProperty SpawnTime = myScript.FindProperty("SpawnTime");
        SerializedProperty DependOnThisState = myScript.FindProperty("DependOnThisState");
        SerializedProperty DestroyTime = myScript.FindProperty("DestroyTime");
        SerializedProperty OffsetDueDirection = myScript.FindProperty("OffsetDueDirection");

        EditorGUILayout.Space(); EditorGUILayout.Space();
        SpawnGameObject.objectReferenceValue =
            EditorGUILayout.ObjectField(new GUIContent("Spawn Game Object"), SpawnGameObject.objectReferenceValue, typeof(GameObject), true) as GameObject;

        if (SpawnGameObject.objectReferenceValue == null) {
            EditorGUILayout.HelpBox(_spawnError, MessageType.Error);
        }

        EditorGUILayout.Slider(SpawnTime, 0.0f, 1.0f, new GUIContent("Spawn Time (%)"));

        EditorGUILayout.Space(); EditorGUILayout.Space();
        EditorGUILayout.PropertyField(DependOnThisState);

        if (DependOnThisState.boolValue) {
            EditorGUILayout.Slider(DestroyTime, 0.0f, 1.0f, new GUIContent("Destroy Time (%)"));
        }

        EditorGUILayout.Space(); EditorGUILayout.Space();
        EditorGUILayout.LabelField("Player Base Setup", EditorStyles.boldLabel);

        EditorGUILayout.HelpBox(_offsetDueDirectionInfo, MessageType.Info);

        EditorGUILayout.PropertyField(OffsetDueDirection);

        myScript.ApplyModifiedProperties();
    }
	public void OnEnable () {
		serObj = new SerializedObject (target); 
		
		reflectionMask = serObj.FindProperty("reflectionMask");   		
		reflectSkybox = serObj.FindProperty("reflectSkybox");   		
		clearColor = serObj.FindProperty("clearColor");   		
	}
 /// <summary>
 /// On inspector enable, load serialized objects
 /// </summary>
 public void OnEnable()
 {
     dialogueTrack = new SerializedObject(this.target);
     canOptimize = dialogueTrack.FindProperty("canOptimize");
     anchor = dialogueTrack.FindProperty("anchor");
     playbackMode = dialogueTrack.FindProperty("PlaybackMode");
 }
    void OnEnable()
    {
        srcObj = new SerializedObject(target);

        color = srcObj.FindProperty("color");
        density = srcObj.FindProperty("density");
    }
    void OnEnable()
    {
        srcObj = new SerializedObject(target);

        sharpness = srcObj.FindProperty("sharpness");
        darkness = srcObj.FindProperty("darkness");
    }
Beispiel #32
0
    protected virtual void OnEnable()
    {
        myObject = new SerializedObject(target);

        attackInput = myObject.FindProperty("attackInput");
        attackName = myObject.FindProperty("attackName");
    }
Beispiel #33
0
        public void DrawGeneralFunction()
        {
            AmplifyShaderFunction function = ParentWindow.CurrentGraph.CurrentShaderFunction;

            if (function == null)
            {
                return;
            }

            float cacheWidth = EditorGUIUtility.labelWidth;

            EditorGUIUtility.labelWidth = 115;

            SerializedObject serializedObject = new UnityEditor.SerializedObject(function);

            if (serializedObject != null)
            {
                SerializedProperty temo = serializedObject.FindProperty("m_description");
                EditorGUILayout.PropertyField(temo, new GUIContent("    Description"));

                SerializedProperty cat  = serializedObject.FindProperty("m_nodeCategory");
                SerializedProperty ppos = serializedObject.FindProperty("m_previewPosition");

                EditorGUILayout.PropertyField(ppos, new GUIContent("Preview Position"));
                cat.intValue = ParentWindow.CurrentGraph.CurrentOutputNode.EditorGUILayoutPopup("Category", cat.intValue, UIUtils.CategoryPresets);

                if (cat.enumValueIndex == 0)
                {
                    SerializedProperty custCat = serializedObject.FindProperty("m_customNodeCategory");
                    EditorGUILayout.PropertyField(custCat, new GUIContent("Custom"));
                }
                serializedObject.ApplyModifiedProperties();
            }
            EditorGUIUtility.labelWidth = cacheWidth;
        }
        // 导出ExportAudioTrack
        private int ExportAudioTrack(AudioTrack audioTrack, JSONObject trackListArr, JSONObject clipListArr)
        {
            JSONObject trackJSON = GenerateBaseTrack(audioTrack, PlaybaleTrackTypeMap["AudioTrack"]);

#if UNITY_2019_1_OR_NEWER
            UnityEditor.SerializedObject   serializedObject           = new UnityEditor.SerializedObject(audioTrack);
            UnityEditor.SerializedProperty propertiesserializedObject = serializedObject.FindProperty("m_TrackProperties");
            float volume       = propertiesserializedObject.FindPropertyRelative("volume").floatValue;
            float stereoPan    = propertiesserializedObject.FindPropertyRelative("stereoPan").floatValue;
            float spatialBlend = propertiesserializedObject.FindPropertyRelative("spatialBlend").floatValue;
            trackJSON.AddField("volume", volume);
            trackJSON.AddField("stereoPan", stereoPan);
            trackJSON.AddField("spatialBlend", spatialBlend);
#else
            trackJSON.AddField("volume", 1);
            trackJSON.AddField("stereoPan", 0);
            trackJSON.AddField("spatialBlend", 0);
#endif

            JSONObject clipsIndexArr = trackJSON.GetField("clips");
            IEnumerable <TimelineClip> timelineClipList = audioTrack.GetClips();
            int num = 0;
            foreach (TimelineClip timelineClip in timelineClipList)
            {
                JSONObject clipJSON = GenerateBaseTimelineClip(timelineClip, PlaybaleClipTypeMap["Audio"]);
                JSONObject clipData = new JSONObject(JSONObject.Type.OBJECT);
                clipJSON.AddField("data", clipData);

                AudioPlayableAsset asset = (AudioPlayableAsset)timelineClip.asset;
                if ((UnityEngine.Object)asset.clip != (UnityEngine.Object)null)
                {
                    WXAudioClip converter = new WXAudioClip(asset.clip, gameObject);
                    string      clipPath  = AddDependencies(converter);
                    clipData.AddField("clip", clipPath);
                }
                else
                {
                    clipData.AddField("clip", JSONObject.nullJO);
                }
                // clipData.AddField("clipCaps", ClipCapsMap.ContainsKey(timelineClip.clipCaps) ? ClipCapsMap[timelineClip.clipCaps] : ClipCapsMap[ClipCaps.None]);
                // clipData.AddField("duration", (float)asset.duration);

                // 兼容2017没有loop
                UnityEditor.SerializedObject assetSerializedObject = new UnityEditor.SerializedObject(asset);
                bool loop = assetSerializedObject.FindProperty("m_Loop").boolValue;
                clipData.AddField("loop", loop);

#if UNITY_2019_1_OR_NEWER
                UnityEditor.SerializedProperty clipProperties = assetSerializedObject.FindProperty("m_ClipProperties");
                float clipVolume = clipProperties.FindPropertyRelative("volume").floatValue;
                clipData.AddField("volume", clipVolume);
#else
                clipData.AddField("volume", 1);
#endif

                clipsIndexArr.Add(ExportTimelineClip(clipJSON, clipListArr));
                num++;
            }
            return(ExportTrack(trackJSON, trackListArr));
        }
    public static void CreateNewGameLevel()
    {
        // Ask the user if they would like to save the current scene if need be, if they do not press cancel...
        if (EditorApplication.SaveCurrentSceneIfUserWantsTo())
        {
            // ... then load a new scene.
            EditorApplication.NewScene();

            // We do not want the default `Main Camera` object do destroy that.
            Object.DestroyImmediate(GameObject.Find("Main Camera"));

            // For each required prefab file name...
            foreach (string levelRequirement in LevelRequirementPrefabs)
            {
                // ... load the prefab from the asset database.
                GameObject requiredPrefab = AssetDatabase.LoadAssetAtPath<GameObject>(RootLevelRequirements + levelRequirement);

                // Instantiate it within the new scene connected to the prefab.
                PrefabUtility.InstantiatePrefab(requiredPrefab);
            }

            // Reference the objects that need connecting to each other.
            EndOfLevel endOfLevel = Object.FindObjectOfType<EndOfLevel>();
            LevelController levelController = Object.FindObjectOfType<LevelController>();
            CameraController cameraController = Object.FindObjectOfType<CameraController>();
            Player player = Object.FindObjectOfType<Player>();

            // Disconect required objects from prefabs if appropriate to do so.
            PrefabUtility.DisconnectPrefabInstance(endOfLevel);

            // Create a new serialized object of the end of level.
            SerializedObject serializedEndOfLevel = new SerializedObject(endOfLevel);

            // Set the appropriate properties to their correct values.
            serializedEndOfLevel.FindProperty("menuSwitcher").objectReferenceValue = Object.FindObjectOfType<MenuSwitcher>();

            // Apply the changed properties without an undo.
            serializedEndOfLevel.ApplyModifiedPropertiesWithoutUndo();

            // Create a new serialized object of the level controller.
            SerializedObject serializedLevelController = new SerializedObject(levelController);

            // Set the appropriate properties to their correct values.
            serializedLevelController.FindProperty("cameraController").objectReferenceValue = cameraController;
            serializedLevelController.FindProperty("player").objectReferenceValue = player;

            // Apply the changed properties without an undo.
            serializedLevelController.ApplyModifiedPropertiesWithoutUndo();

            // Create a new serialized object of the camera controller.
            SerializedObject serializedCameraController = new SerializedObject(cameraController);

            // Set the appropriate properties to their correct values.
            serializedCameraController.FindProperty("target").objectReferenceValue = player.GetComponent<CameraTarget>();

            // Apply the changed properties without an undo.
            serializedCameraController.ApplyModifiedPropertiesWithoutUndo();
        }
    }
	protected virtual void OnEnable(){
		database = ItemDatabase.Load ();

		parameterTypeNames = TypeUtility.GetSubTypeNames (typeof(FsmVariable));
		parameterTypeNames = ArrayUtility.Insert<string> (parameterTypeNames, "None", 0);

		customDataList = new ReorderableList(serializedObject, 
		                                     serializedObject.FindProperty("customData"), 
		                                     true, true, true, true);
		customDataList.elementHeight = EditorGUIUtility.singleLineHeight * 3+10;
		customDataList.onRemoveCallback = (ReorderableList list) => {
			list.serializedProperty.serializedObject.Update();
			DestroyImmediate(list.serializedProperty.GetArrayElementAtIndex(list.index).objectReferenceValue,true);
			AssetDatabase.SaveAssets();
			list.serializedProperty.DeleteArrayElementAtIndex(list.index);
			list.serializedProperty.serializedObject.ApplyModifiedProperties();
		};

		customDataList.drawElementCallback =  (Rect rect, int index, bool isActive, bool isFocused) => {
			var element = customDataList.serializedProperty.GetArrayElementAtIndex(index);
			FsmVariable variable = element.objectReferenceValue as FsmVariable;
			rect.y+=2;
			int m = parameterTypeNames.ToList ().FindIndex (x => x == (variable!= null?variable.GetType ().Name:""));
			m = Mathf.Clamp (m, 0, int.MaxValue);
			rect.height=EditorGUIUtility.singleLineHeight;
			m = EditorGUI.Popup (rect,"Parameter Type", m, parameterTypeNames);
			string typeName=parameterTypeNames [m];
			string variableTypeName = (variable == null ? "None" : variable.GetType ().Name);

			if(typeName != variableTypeName){
				DestroyImmediate(element.objectReferenceValue,true);
				if(typeName != "None"){
					variable = ScriptableObject.CreateInstance (TypeUtility.GetTypeByName(typeName)[0]) as FsmVariable;
					variable.hideFlags = HideFlags.HideInHierarchy;
					
					if (EditorUtility.IsPersistent (element.serializedObject.targetObject)) {
						AssetDatabase.AddObjectToAsset (variable, element.serializedObject.targetObject);
						AssetDatabase.SaveAssets ();
					}
					
					element.serializedObject.Update();
					element.objectReferenceValue = variable;
					element.serializedObject.ApplyModifiedProperties ();
				}
			}
			if(variable != null){
				SerializedObject mVariable=new SerializedObject(variable);
				mVariable.Update();
				rect.y+=EditorGUIUtility.singleLineHeight+2;
				EditorGUI.PropertyField(rect,mVariable.FindProperty("name"));
				rect.y+=EditorGUIUtility.singleLineHeight+2;
				EditorGUI.PropertyField(rect,mVariable.FindProperty("value"));
				mVariable.ApplyModifiedProperties();
			}
		};
		customDataList.drawHeaderCallback = (Rect rect) => {  
			EditorGUI.LabelField(rect, "Custom Data");
		};
	}
Beispiel #37
0
    void LoadCar()
    {
        // --> Find and Pause Cars
        GameObject[] arrCars = GameObject.FindGameObjectsWithTag("Car");


        List <GameObject> tmpList = new List <GameObject> ();

        foreach (GameObject car in arrCars)
        {
            if (car.GetComponent <CarController> ())
            {
                tmpList.Add(car);
            }
        }
        for (var i = tmpList.Count - 1; i >= 0; i--)
        {
            //Debug.Log(arrCars.Length + " : " +  arrCars[i].name);
            Undo.DestroyObjectImmediate(tmpList[i]);
        }
        tmpList.Clear();


        for (var i = 0; i < 4; i++)
        {
            SerializedObject serializedObject0 = new UnityEditor.SerializedObject(inventoryItemList);
            serializedObject0.Update();
            SerializedProperty m_carName    = serializedObject0.FindProperty("inventoryItem").GetArrayElementAtIndex(0).FindPropertyRelative("list_Cars");
            SerializedProperty m_PlayerType = serializedObject0.FindProperty("inventoryItem").GetArrayElementAtIndex(0).FindPropertyRelative("list_playerType");

            if (inventoryItemList)
            {
                if (m_carName.GetArrayElementAtIndex(i).objectReferenceValue != null)
                {
                    GameObject instance = (GameObject)Instantiate(m_carName.GetArrayElementAtIndex(i).objectReferenceValue);

                    Undo.RegisterCreatedObjectUndo(instance, instance.name);

                    instance.name = instance.name.Replace("(Clone)", "");

                    GameObject tmpPosition = GameObject.Find("Start_Position_0" + (i + 1));

                    if (tmpPosition)
                    {
                        Undo.RegisterFullObjectHierarchyUndo(instance, "Pos_" + instance.name);

                        instance.GetComponent <CarController> ().playerNumber = i + 1;                                                                  // Select the player number

                        instance.GetComponent <CarAI>().enabled = m_PlayerType.GetArrayElementAtIndex(i).boolValue;

                        instance.transform.position    = new Vector3(tmpPosition.transform.position.x, tmpPosition.transform.position.y + .15f, tmpPosition.transform.position.z);
                        instance.transform.eulerAngles = tmpPosition.transform.eulerAngles;
                    }
                }
            }
            serializedObject0.ApplyModifiedProperties();
        }
    }
Beispiel #38
0
    private void clearSlectedCustomMethods(int value, actionsWhenPuzzleIsSolved myScript, bool b_Clear)
    {
        SerializedObject serializedObject2 = new UnityEditor.SerializedObject(myScript);

        SerializedProperty obj            = serializedObject2.FindProperty("methodsList").GetArrayElementAtIndex(value).FindPropertyRelative("obj");
        SerializedProperty scriptRef      = serializedObject2.FindProperty("methodsList").GetArrayElementAtIndex(value).FindPropertyRelative("scriptRef");
        SerializedProperty indexScript    = serializedObject2.FindProperty("methodsList").GetArrayElementAtIndex(value).FindPropertyRelative("indexScript");
        SerializedProperty indexMethod    = serializedObject2.FindProperty("methodsList").GetArrayElementAtIndex(value).FindPropertyRelative("indexMethod");
        SerializedProperty methodInfoName = serializedObject2.FindProperty("methodsList").GetArrayElementAtIndex(value).FindPropertyRelative("methodInfoName");
        SerializedProperty intValue       = serializedObject2.FindProperty("methodsList").GetArrayElementAtIndex(value).FindPropertyRelative("intValue");
        SerializedProperty floatValue     = serializedObject2.FindProperty("methodsList").GetArrayElementAtIndex(value).FindPropertyRelative("floatValue");
        SerializedProperty stringValue    = serializedObject2.FindProperty("methodsList").GetArrayElementAtIndex(value).FindPropertyRelative("stringValue");
        SerializedProperty objValue       = serializedObject2.FindProperty("methodsList").GetArrayElementAtIndex(value).FindPropertyRelative("objValue");



        serializedObject2.Update();
        if (b_Clear)
        {
            obj.objectReferenceValue = null;
        }

        scriptRef.objectReferenceValue = null;
        indexScript.intValue           = 0;
        indexMethod.intValue           = 0;
        methodInfoName.stringValue     = "";
        intValue.intValue             = 0;
        floatValue.floatValue         = 0;
        stringValue.stringValue       = "";
        objValue.objectReferenceValue = null;

        serializedObject2.ApplyModifiedProperties();
    }
Beispiel #39
0
        public bool[] GetHumanoidBonesSet(Avatar avatar)
        {
            bool[] result           = new bool[(int)HumanBodyBones.LastBone];
            var    serializedObject = new UnityEditor.SerializedObject(avatar);

            for (var humanoidIndex = (HumanBodyBones)0; humanoidIndex < HumanBodyBones.LastBone; humanoidIndex++)
            {
                int skeletonIndex = -1;
                if (humanoidIndex <= HumanBodyBones.Jaw || humanoidIndex == HumanBodyBones.UpperChest)
                {
                    int humanId = -1;
                    if (humanoidIndex <= HumanBodyBones.Chest)
                    {
                        humanId = (int)humanoidIndex;
                    }
                    else if (humanoidIndex <= HumanBodyBones.Jaw)
                    {
                        humanId = (int)humanoidIndex + 1;
                    }
                    else
                    {
                        humanId = 9;
                    }
                    var pHumanBoneIndexArray = serializedObject.FindProperty("m_Avatar.m_Human.data.m_HumanBoneIndex");
                    if (pHumanBoneIndexArray == null || !pHumanBoneIndexArray.isArray || humanId < 0 || humanId >= pHumanBoneIndexArray.arraySize)
                    {
                        continue;
                    }
                    skeletonIndex = pHumanBoneIndexArray.GetArrayElementAtIndex(humanId).intValue;
                }
                else if (humanoidIndex <= HumanBodyBones.LeftLittleDistal)
                {
                    int handId = (int)humanoidIndex - (int)HumanBodyBones.LeftThumbProximal;
                    var pHandBoneIndexArray = serializedObject.FindProperty("m_Avatar.m_Human.data.m_LeftHand.data.m_HandBoneIndex");
                    if (pHandBoneIndexArray == null || !pHandBoneIndexArray.isArray || handId < 0 || handId >= pHandBoneIndexArray.arraySize)
                    {
                        continue;
                    }
                    skeletonIndex = pHandBoneIndexArray.GetArrayElementAtIndex(handId).intValue;
                }
                else if (humanoidIndex <= HumanBodyBones.RightLittleDistal)
                {
                    int handId = (int)humanoidIndex - (int)HumanBodyBones.RightThumbProximal;
                    var pHandBoneIndexArray = serializedObject.FindProperty("m_Avatar.m_Human.data.m_RightHand.data.m_HandBoneIndex");
                    if (pHandBoneIndexArray == null || !pHandBoneIndexArray.isArray || handId < 0 || handId >= pHandBoneIndexArray.arraySize)
                    {
                        continue;
                    }
                    skeletonIndex = pHandBoneIndexArray.GetArrayElementAtIndex(handId).intValue;
                }
                result[(int)humanoidIndex] = skeletonIndex >= 0;
            }
            return(result);
        }
Beispiel #40
0
        private static void SetupGeographicsTransforms(WRLDARKitSetupHelper.CubeInfo[] cubes)
        {
            foreach (var cube in cubes)
            {
                GeographicTransform geographicTransform = cube.cubeGameObject.AddComponent <GeographicTransform> ();
                SerializedObject    serializedObject    = new UnityEditor.SerializedObject(geographicTransform);
                SerializedProperty  latitudeProperty    = serializedObject.FindProperty("InitialLatitude");
                SerializedProperty  longitudeProperty   = serializedObject.FindProperty("InitialLongitude");

                latitudeProperty.doubleValue  = cube.latitudeDegrees;
                longitudeProperty.doubleValue = cube.longitudeDegrees;

                serializedObject.ApplyModifiedProperties();
            }
        }
Beispiel #41
0
        //EDITOR-ONLY SERIALIZATION:
#if UNITY_EDITOR
        public static E.SerializedProperty FindDeepProperty(this E.SerializedObject so, string path)
        {
            so.ApplyModifiedProperties();
            so.Update();

            string[] _pathArray = StringUtil.ToPathArray(path);

            E.SerializedProperty
                _so_parentDir = null,
                _so_targ      = null;

            if (_pathArray.Length > 1)
            {
                _so_parentDir = so.FindProperty(_pathArray[0]);
                for (int i = 0; i < _pathArray.Length - 1 /*go only through the parents, hence -1*/; i++)
                {
                    if (_so_parentDir != null)
                    {
                        if (i > 0)                         //iterate through the parents
                        {
                            _so_parentDir = _so_parentDir.FindPropertyRelative(_pathArray[i]);
                        }
                        _so_targ = _so_parentDir.FindPropertyRelative(_pathArray[i + 1]);
                    }
                    else
                    {
                        EditorUtil.Debug("[SETUtil_EditorUtil.FindDeepProperty ERROR] Invalid path element: " + _so_parentDir);
                    }
                }
            }
            else if (_pathArray.Length == 1)
            {
                _so_targ = so.FindProperty(_pathArray[0]);
            }
            else
            {
                EditorUtil.Debug("[SETUtil_EditorUtil.FindDeepProperty ERROR] Empty target path!");
                return(null);
            }

            if (_so_targ == null)
            {
                EditorUtil.Debug("[SETUtil_EditorUtil.FindDeepProperty ERROR] Nonexistent or inaccessible property: " + path + ". Make sure you are not targeting a MonoBehavior-derived class instance.");
                return(null);
            }

            return(_so_targ);
        }
Beispiel #42
0
    public override float GetPropertyHeight(SerializedProperty property, GUIContent label)
    {
        float totalHeight         = 0;
        SerializedProperty isList = property.FindPropertyRelative("m_isList");

        totalHeight += EditorGUI.GetPropertyHeight(property, label, true) + EditorGUIUtility.standardVerticalSpacing;
        totalHeight += EditorGUI.GetPropertyHeight(property.FindPropertyRelative("m_isList"), label, true) + EditorGUIUtility.standardVerticalSpacing;
        totalHeight += EditorGUI.GetPropertyHeight(property.FindPropertyRelative("m_isNot"), label, true) + EditorGUIUtility.standardVerticalSpacing;

        if (!isList.boolValue)
        {
            UnityEngine.Object command = property.FindPropertyRelative("m_conditionCommand").objectReferenceValue;
            if (command != null)
            {
                SerializedObject commandObject = new UnityEditor.SerializedObject(command as ConditionCommand);

                SerializedProperty propertyIterator = commandObject.GetIterator();

                while (propertyIterator.NextVisible(true))
                {
                    totalHeight += EditorGUI.GetPropertyHeight(propertyIterator, label, true) + EditorGUIUtility.standardVerticalSpacing;
                }


                SerializedProperty methodProperty = commandObject.FindProperty("m_method");

                totalHeight += EditorGUI.GetPropertyHeight(methodProperty, label, true) + EditorGUIUtility.standardVerticalSpacing;

                MethodInfo methodInfo = (command as ConditionCommand).GetType().GetMethod(methodProperty.stringValue);
                if (methodInfo != null)
                {
                    for (int i = 0; i < methodInfo.GetParameters().Length; i++)
                    {
                        ParameterInfo parametter = methodInfo.GetParameters()[i];

                        propertyIterator = commandObject.GetIterator();

                        while (propertyIterator.Next(true))
                        {
                            if (propertyIterator.name == parametter.Name)
                            {
                                totalHeight += EditorGUI.GetPropertyHeight(propertyIterator, label, true) + EditorGUIUtility.standardVerticalSpacing;
                                break;
                            }
                        }
                    }
                }
            }
        }
        else
        {
            totalHeight += EditorGUI.GetPropertyHeight(property.FindPropertyRelative("m_isOr"), label, true) + EditorGUIUtility.standardVerticalSpacing;
            totalHeight += EditorGUI.GetPropertyHeight(property.FindPropertyRelative("m_conditions"), label, true) + EditorGUIUtility.standardVerticalSpacing;
        }


        totalHeight += EditorGUIUtility.standardVerticalSpacing * 3;

        return(totalHeight);
    }
Beispiel #43
0
    private static void HandleTag(StringBuilder sb)
    {
        sb.AppendLine("public class TagDefine");
        sb.AppendLine("{");

        //处理预定义部分
        sb.AppendLine("\tpublic const string " + "TAG_Untagged".ToUpper() + " = " + "\"Untagged\";");
        sb.AppendLine("\tpublic const string " + "TAG_Respawn".ToUpper() + " = " + "\"Respawn\";");
        sb.AppendLine("\tpublic const string " + "TAG_Finish".ToUpper() + " = " + "\"Finish\";");
        sb.AppendLine("\tpublic const string " + "TAG_EditorOnly".ToUpper() + " = " + "\"EditorOnly\";");
        sb.AppendLine("\tpublic const string " + "TAG_MainCamera".ToUpper() + "= " + "\"MainCamera\";");
        sb.AppendLine("\tpublic const string " + "TAG_Player".ToUpper() + " = " + "\"Player\";");
        sb.AppendLine("\tpublic const string " + "TAG_GameController".ToUpper() + " = " + "\"GameController\";");                    //把一部分内置Tag先写死

        var asset = UnityEditor.AssetDatabase.LoadAllAssetsAtPath("ProjectSettings/TagManager.asset");

        if ((asset != null) && (asset.Length > 0))
        {
            for (int i = 0; i < asset.Length; i++)
            {
                //创建序列化对象
                var so   = new UnityEditor.SerializedObject(asset[i]);
                var tags = so.FindProperty("tags");          //读取具体字段
                for (int j = 0; j < tags.arraySize; ++j)
                {
                    var item = tags.GetArrayElementAtIndex(j).stringValue;
                    sb.AppendLine("\tpublic const string TAG_" + item.ToUpper() + " = \"" + item + "\";"); //添加到模板
                }
            }
        }

        sb.AppendLine("}");
    }
    public static SerializedProperty GetSerializedProperty(object p_object, string p_propertyName)
    {
        SerializedObject   _obj      = new UnityEditor.SerializedObject((Object)p_object);
        SerializedProperty _property = _obj.FindProperty(p_propertyName);

        return(_property);
    }
Beispiel #45
0
//--> Move tile in scene view
    private void MoveTileInSceneView(int oldPosition, string direction, SlidingPuzzle myScript)
    {
        if (oldPosition != -1)
        {
            // Debug.Log("oldPosition : " + oldPosition);
            SerializedObject serializedObject2 = new UnityEditor.SerializedObject(myScript.tilesList[myScript.positionList[oldPosition]].GetComponent <Transform>());
            serializedObject2.Update();
            SerializedProperty m_Position = serializedObject2.FindProperty("m_LocalPosition");

            if (direction == "Down")
            {
                m_Position.vector3Value = new Vector3(m_Position.vector3Value.x, m_Position.vector3Value.y - .25f, 0);
            }
            if (direction == "Up")
            {
                m_Position.vector3Value = new Vector3(m_Position.vector3Value.x, m_Position.vector3Value.y + .25f, 0);
            }
            if (direction == "Left")
            {
                m_Position.vector3Value = new Vector3(m_Position.vector3Value.x - .25f, m_Position.vector3Value.y, 0);
            }
            if (direction == "Right")
            {
                m_Position.vector3Value = new Vector3(m_Position.vector3Value.x + .25f, m_Position.vector3Value.y, 0);
            }

            serializedObject2.ApplyModifiedProperties();
        }
    }
        public void DrawGeneralFunction()
        {
            AmplifyShaderFunction function = ParentWindow.CurrentGraph.CurrentShaderFunction;

            if (function == null)
            {
                return;
            }

            string oldName = function.FunctionName;

            //oldName = EditorGUILayout.TextField( "Name", oldName );
            //if ( oldName != function.FunctionName )
            //{
            //	function.FunctionName = oldName;
            //	EditorUtility.SetDirty( function );
            //}

            SerializedObject serializedObject = new UnityEditor.SerializedObject(function);

            if (serializedObject != null)
            {
                SerializedProperty temo = serializedObject.FindProperty("m_description");
                oldName = temo.stringValue;
                EditorGUILayout.PropertyField(temo, new GUIContent("    Description"));
                if (!oldName.Equals(temo.stringValue))
                {
                    function.Description = temo.stringValue;
                    oldName = temo.stringValue;
                }
            }
        }
Beispiel #47
0
    void RemoveACar(int value)
    {
        // --> Find and Pause Cars
        GameObject[] arrCars = GameObject.FindGameObjectsWithTag("Car");

        List <GameObject> tmpList = new List <GameObject> ();

        foreach (GameObject car in arrCars)
        {
            if (car.GetComponent <CarController> () && car.GetComponent <CarController> ().playerNumber == (value + 1))
            {
                tmpList.Add(car);
            }
        }

        for (var i = tmpList.Count - 1; i >= 0; i--)
        {
            Undo.DestroyObjectImmediate(tmpList[i]);
        }
        tmpList.Clear();

        SerializedObject serializedObject0 = new UnityEditor.SerializedObject(inventoryItemList);

        serializedObject0.Update();
        SerializedProperty m_carName = serializedObject0.FindProperty("inventoryItem").GetArrayElementAtIndex(0).FindPropertyRelative("list_Cars");


        if (inventoryItemList)
        {
            m_carName.GetArrayElementAtIndex(value).objectReferenceValue = null;
        }
        serializedObject0.ApplyModifiedProperties();
    }
Beispiel #48
0
    private static void HandleSortingLayer(StringBuilder sb)
    {
        sb.AppendLine("public class SortingDefine");
        sb.AppendLine("{");
        //处理预定义部分
        sb.AppendLine("\tpublic const string " + "SORTING_Default".ToUpper() + " = " + "\"Default\";");
        var asset = UnityEditor.AssetDatabase.LoadAllAssetsAtPath("ProjectSettings/TagManager.asset");

        if ((asset != null) && (asset.Length > 0))
        {
            for (int i = 0; i < asset.Length; i++)
            {
                var so = new UnityEditor.SerializedObject(asset[i]);

                var sortings = so.FindProperty("m_SortingLayers");
                for (int j = 0; j < sortings.arraySize; ++j)
                {
                    var item = sortings.GetArrayElementAtIndex(j).stringValue;
                    sb.AppendLine("\tpublic const string SORTING_" + item.ToUpper() + " = " + item + ";");
                }
            }
        }

        sb.AppendLine("}");
    }
    void displayTracks(MainMenu myScript, int i)
    {
        // inventoryOnlineTracks

        //EditorGUILayout.PropertyField(inventoryOnlineTracks, new GUIContent(""));

        SerializedObject serializedObject0 = new UnityEditor.SerializedObject(myScript.S_CurrentBackground.GetComponent <Image>());

        serializedObject0.Update();

        SerializedProperty m_Scale = serializedObject0.FindProperty("m_Sprite");

        if (m_Scale.objectReferenceValue != (Sprite)TableBackgroundSpriteList.GetArrayElementAtIndex(i).objectReferenceValue)
        {
            m_Scale.objectReferenceValue = null;
            m_Scale.objectReferenceValue = (Sprite)TableBackgroundSpriteList.GetArrayElementAtIndex(i).objectReferenceValue;
        }


        // if (m_Scale.objectReferenceValue != (Sprite)TableBackgroundSpriteList.GetArrayElementAtIndex(i).objectReferenceValue)
        //   m_Scale.objectReferenceValue = (Sprite)TableBackgroundSpriteList.GetArrayElementAtIndex(i).objectReferenceValue;


        serializedObject0.ApplyModifiedProperties();
    }
        /// <summary>
        /// Called when the inspector needs to draw
        /// </summary>
        public override bool OnInspectorGUI(UnityEditor.SerializedObject rTargetSO, UnityEngine.Object rTarget)
        {
            bool lIsDirty = base.OnInspectorGUI(rTargetSO, rTarget);

            if (mActorCore == null && mOwner != null)
            {
                mActorCore = mOwner.GetComponent <ActorCore>();
            }

            if (_StoredUnityEventIndex < 0)
            {
                lIsDirty = true;
                _StoredUnityEventIndex = mActorCore.StoreUnityEvent(-1, new ReactorActionEvent());
            }

            //EditorGUILayout.LabelField(_StoredUnityEventIndex.ToString() + " of " + mActorCore._StoredUnityEvents.Count);

            SerializedProperty lArray = rTargetSO.FindProperty("_StoredUnityEvents");

            if (lArray.isArray && lArray.arraySize > _StoredUnityEventIndex)
            {
                SerializedProperty lItem = lArray.GetArrayElementAtIndex(_StoredUnityEventIndex);

                EditorGUI.BeginChangeCheck();
                EditorGUILayout.PropertyField(lItem);
                if (EditorGUI.EndChangeCheck())
                {
                    lIsDirty = true;
                }
            }

            return(lIsDirty);
        }
Beispiel #51
0
        public static void FixByOneKey(string projectCode, string folder, bool isCombProj = false)
        {
            string root = Path.GetFullPath(".") + Path.DirectorySeparatorChar + "Assets" + Path.DirectorySeparatorChar;

            string searchPath = root + folder + (isCombProj ? Path.DirectorySeparatorChar + projectCode : "");

            if (!Directory.Exists(searchPath))
            {
                return;
            }

            List <string> filePath = new List <string>();

            filePath.AddRange(
                Directory.GetFiles(searchPath, "*.*", SearchOption.AllDirectories)
                );
            int counter = -1;

            foreach (string file in filePath)
            {
                string tempFolder = file.Substring(root.Length);
                EditorUtility.DisplayProgressBar("Search File", tempFolder, counter / (float)filePath.Count);
                counter++;

                string ext = Path.GetExtension(file).ToLower();
                if (ext.Equals(".mp3") || ext.Equals(".wav") || ext.Equals(".ogg") || ext.Equals(".m4a"))
                {
                    string    path          = file.Substring(file.IndexOf("Assets/"));
                    AudioClip audio         = AssetDatabase.LoadAssetAtPath <AudioClip>(path);
                    var       audioImporter = (AudioImporter)AudioImporter.GetAtPath(path);
                    var       isDirty       = false;
                    if (audio && audio.length > MAX_LENGTH &&
                        audioImporter.defaultSampleSettings.loadType != AudioClipLoadType.Streaming)
                    {
                        var setting = audioImporter.defaultSampleSettings;
                        setting.loadType = AudioClipLoadType.Streaming;
                        audioImporter.defaultSampleSettings = setting;
                        isDirty = true;
                    }
                    if (audio && audioImporter.forceToMono == false)
                    {
                        audioImporter.forceToMono = true;
                        isDirty = true;

                        SerializedObject   serializedObject = new UnityEditor.SerializedObject(audioImporter);
                        SerializedProperty normalize        = serializedObject.FindProperty("m_Normalize");
                        normalize.boolValue = false;
                        serializedObject.ApplyModifiedProperties();
                    }
                    if (isDirty)
                    {
                        audioImporter.SaveAndReimport();
                        EditorUtility.SetDirty(audio);
                    }
                }
            }

            EditorUtility.ClearProgressBar();
            AssetDatabase.Refresh();
        }
Beispiel #52
0
    private void DisconnectTeleporter(TelportVrScript teleporter)
    {
        SerializedObject   serializedObject   = new UnityEditor.SerializedObject(teleporter);
        SerializedProperty serializedProperty = serializedObject.FindProperty("destinationSphereName");

        serializedProperty.stringValue = "";

        SerializedProperty serializedAllignment = serializedObject.FindProperty("alligned");

        serializedAllignment.boolValue = false;

        serializedProperty.serializedObject.ApplyModifiedProperties();
        serializedProperty.serializedObject.Update();

        teleporter.gameObject.SetActive(false);
    }
        /// <summary>
        /// Add the observer to the outfit with proper change tracking.
        /// </summary>
        /// <remarks>
        /// <para>
        /// It is safe to use this method to add an existing observer.  In this case the update will force a
        /// change record.  (Useful when the observer has already been added, but wasn't properly recorded
        /// for serialization.)
        /// </para>
        /// </remarks>
        /// <param name="outfit">The outfit. (Required)</param>
        /// <param name="observer">The observer to add, or to update so it has change tracking. (Required)</param>
        public static void AddObserverWithUndo(Outfit outfit, IOutfitObserver observer)
        {
            // Design note: Adding an observer can sometimes fail when added using the standard method.
            // Don't know why yet.  This method works in all cases.

            var obj = (Object)observer;

            var so   = new UnityEditor.SerializedObject(outfit);
            var prop = so.FindProperty("m_Observers.m_Items");
            int idx  = -1;

            for (int i = 0; i < prop.arraySize; i++)
            {
                if (prop.GetArrayElementAtIndex(i).objectReferenceValue == obj)
                {
                    prop.GetArrayElementAtIndex(idx).objectReferenceValue = null;
                    idx = i;
                    break;
                }
            }

            if (idx == -1)
            {
                idx = prop.arraySize;
                prop.arraySize++;
            }

            prop.GetArrayElementAtIndex(idx).objectReferenceValue = obj;
            so.ApplyModifiedProperties();
        }
Beispiel #54
0
    public void DrawWindow()
    {
        //Serializing Objects/Properties
        DLNode             thisNode         = this;
        SerializedObject   serializedObject = new UnityEditor.SerializedObject(thisNode);
        SerializedProperty st  = serializedObject.FindProperty("sentences");
        SerializedProperty ans = serializedObject.FindProperty("answers");
        SerializedProperty eve = serializedObject.FindProperty("onEnd");

        // End Serializing Objects/Properties


        nodeType = (NodeType)EditorGUILayout.EnumPopup("Node Type", nodeType);

        switch (nodeType)
        {
        case (NodeType)0:
            if (sentences != null)
            {
                rect.height = 100 + (sentences.Length * 60);
            }
            npcName     = EditorGUILayout.TextField("NPC name", npcName);
            windowTitle = "Sentences : " + npcName;
            serializedObject.Update();
            EditorGUILayout.PropertyField(st, true);
            serializedObject.ApplyModifiedProperties();
            break;

        case (NodeType)1:
            if (answers != null)
            {
                rect.height = 100 + (answers.Length * 60);
            }
            windowTitle = "Answers";
            serializedObject.Update();
            EditorGUILayout.PropertyField(ans, true);
            serializedObject.ApplyModifiedProperties();

            break;

        case (NodeType)2:
            rect.height = 220;
            windowTitle = "Event";
            EditorGUILayout.PropertyField(eve, true);
            break;
        }
    }
Beispiel #55
0
        private static void SetupWRLDMap(WRLDARCoreSetupHelper wrldARCoreSetupHelper)
        {
            // Please import WRLD3D plugin if you are seeing a compiler error here.
            WrldMap            wrldMap = wrldARCoreSetupHelper.wrldMapGameObject.AddComponent <WrldMap> ();
            SerializedObject   serializedWrldMapObject   = new UnityEditor.SerializedObject(wrldMap);
            SerializedProperty streamingCameraProperty   = serializedWrldMapObject.FindProperty("m_streamingCamera");
            SerializedProperty latitudeDegreesProperty   = serializedWrldMapObject.FindProperty("m_latitudeDegrees");
            SerializedProperty longitudeDegreesProperty  = serializedWrldMapObject.FindProperty("m_longitudeDegrees");
            SerializedProperty materialDirectoryProperty = serializedWrldMapObject.FindProperty("m_materialDirectory");

            streamingCameraProperty.objectReferenceValue = wrldARCoreSetupHelper.streamingCamera;
            latitudeDegreesProperty.doubleValue          = wrldARCoreSetupHelper.wrldStartLatitudeDegrees;
            longitudeDegreesProperty.doubleValue         = wrldARCoreSetupHelper.wrldStartLongitudeDegrees;
            materialDirectoryProperty.stringValue        = wrldARCoreSetupHelper.wrldMaterialDirectory;

            serializedWrldMapObject.ApplyModifiedProperties();
        }
Beispiel #56
0
        private static void SetupGeographicsTransforms(WRLDARCoreSetupHelper wrldARCoreSetupHelper)
        {
            WRLDARCoreSetupHelper.CubeInfo[] cubes;
            foreach (WRLDARCoreSetupHelper.CubeInfo cubeInfo in wrldARCoreSetupHelper.cubeInfos)
            {
                // Please import WRLD3D plugin if you are seeing a compiler error here.
                GeographicTransform geographicTransform = cubeInfo.cubeGameObject.AddComponent <GeographicTransform> ();
                SerializedObject    serializedObject    = new UnityEditor.SerializedObject(geographicTransform);
                SerializedProperty  latitudeProperty    = serializedObject.FindProperty("InitialLatitude");
                SerializedProperty  longitudeProperty   = serializedObject.FindProperty("InitialLongitude");

                latitudeProperty.doubleValue  = cubeInfo.latitudeDegrees;
                longitudeProperty.doubleValue = cubeInfo.longitudeDegrees;

                serializedObject.ApplyModifiedProperties();
            }
        }
        void OnGUI()
        {
            var serializedTable = new UnityEditor.SerializedObject(_table);

            EditorGUILayout.BeginVertical();

            // Screen num box
            var viewCount = serializedTable.FindProperty("viewCount");

            EditorGUILayout.PropertyField(viewCount, _textViewCount);

            EditorGUILayout.Space();

            // View-display table
            var viewTable = serializedTable.FindProperty("viewTable");

            for (var i = 0; i < viewCount.intValue; i++)
            {
                EditorGUILayout.IntPopup(
                    viewTable.GetArrayElementAtIndex(i),
                    _optionLabels, _optionValues, _viewLabels[i]
                    );
            }

            EditorGUILayout.Space();

            // Function buttons
            EditorGUILayout.BeginHorizontal();
            EditorGUILayout.Space();
            if (GUILayout.Button("Layout"))
            {
                LayoutViews();
            }
            EditorGUILayout.Space();
            if (GUILayout.Button("Close All"))
            {
                CloseAllViews();
            }
            EditorGUILayout.Space();
            EditorGUILayout.EndHorizontal();

            EditorGUILayout.EndVertical();

            serializedTable.ApplyModifiedProperties();
        }
Beispiel #58
0
        // Method to apply the changes
        void Validate()
        {
            foreach (Rotator rotator in rotatorsToEdit)
            {
                Rotator          component        = rotator.GetComponent <Rotator>();
                SerializedObject serializedObject = new UnityEditor.SerializedObject(rotator);
                if (identifierBool)
                {
                    SerializedProperty serializedProperty = serializedObject.FindProperty("_identifier");
                    serializedProperty.stringValue = identifier;
                }
                if (timeBool)
                {
                    SerializedProperty serializedProperty2 = serializedObject.FindProperty("_timeBeforeStoppingInSeconds");
                    serializedProperty2.floatValue = timeBeforeStoppingInSeconds;
                }
                if (reverseBool)
                {
                    SerializedProperty serializedProperty3 = serializedObject.FindProperty("_shouldReverseRotation");
                    serializedProperty3.boolValue = shouldReverseRotation;
                }
                if (settingsBool)
                {
                    SerializedProperty serializedProperty4 = serializedObject.FindProperty("_rotationsSettings");


                    foreach (SerializedProperty p in serializedProperty4)
                    {
                        if (objectToRotateBool && p.name == "ObjectToRotate")
                        {
                            p.objectReferenceValue = objectToRotate;
                        }
                        if (angleRotationBool && p.name == "AngleRotation")
                        {
                            p.vector3Value = angleRotation;
                        }
                        if (timeToRotateBool && p.name == "TimeToRotateInSeconds")
                        {
                            p.floatValue = timeBeforeStoppingInSeconds;
                        }
                    }
                }
                serializedObject.ApplyModifiedProperties();
            }
        }
Beispiel #59
0
    public virtual void OnDrawEditSettings()
    {
        //Poly
        SerializedObject   serializedObject = new UnityEditor.SerializedObject(area2d);
        SerializedProperty serializedLine   = serializedObject.FindProperty("_poly");

        EditorGUILayout.PropertyField(serializedLine);
        serializedObject.ApplyModifiedProperties();
    }
        public static int GetLocalIdentfierInFile(Object comp)
        {
            var inspectorModeInfo = typeof(UnityEditor.SerializedObject).GetProperty("inspectorMode", BindingFlags.NonPublic | BindingFlags.Instance);

            UnityEditor.SerializedObject serializedObject = new UnityEditor.SerializedObject(comp);
            inspectorModeInfo.SetValue(serializedObject, UnityEditor.InspectorMode.Debug, null);
            UnityEditor.SerializedProperty localIdProp = serializedObject.FindProperty("m_LocalIdentfierInFile");

            return(localIdProp.intValue);
        }