Esempio n. 1
0
        /// <summary>
        /// attach a new component of type T to the GameObject of given name
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="goName"></param>
        /// <param name="data"></param>
        /// <param name="name"></param>
        /// <returns></returns>
        static public MonoBehaviour AddComponent <T>(string goName, SceneObjectData data, string name)
            where T : class
        {
            var go = ResolveGameObject(goName);

            return(AddComponent <T>(go, data, name));
        }
Esempio n. 2
0
 public override void OnRestart(Vector3 pos)
 {
     data = GetComponent <SceneObjectData> ();
     base.OnRestart(pos);
     laser.SetActive(false);
     parts [1].transform.localPosition = new Vector3(0, data.size.y, 0);
 }
Esempio n. 3
0
    void AddRandomObjects(int backgorundID)
    {
        string[] randomObjects;
        if (backgorundID == 2)
        {
            randomObjects    = new string[3];
            randomObjects[0] = "park_chair";
            randomObjects[1] = "park_popcorn";
            randomObjects[2] = "park_tree";
        }
        else
        {
            randomObjects    = new string[2];
            randomObjects[0] = "space_chair";
            randomObjects[1] = "space_plant";
        }

        for (int a = 0; a < randomObjects.Length; a++)
        {
            SceneObjectData data = new SceneObjectData();
            data.sceneObjectName = randomObjects[a];
            int _x = Random.Range(0, 3);
            _x += 1;
            Vector2 pos = new Vector2(_x, (a * 2));

            Events.AddGenericObject(data, GetTileByPos(pos).GetPos());
            Blocktile(GetTileByPos(pos), true);
        }
    }
Esempio n. 4
0
    public void Add(SceneObjectData data, float totalDistance)
    {
        SceneObject so;

        so = GetSceneObject(data.type);

        if (so == null)
        {
            so      = CreateNew(data.type);
            so.data = data;
        }

        sceneObjects_inScene.Add(so);
        Vector3 pos = lanes.GetCoordsByLane(data.laneID);

        pos.x = data.pos.x + totalDistance;
        so.transform.SetParent(container);
        so.transform.localPosition = pos;
        so.AddToLane(data.laneID);
        so.Init();

        if (so.GetComponent <Enemy>())
        {
            so.GetComponent <Enemy>().InitCharacter(Data.Instance.customizer.GetRandomData(), null, data.laneID);
        }
    }
Esempio n. 5
0
        /// <summary>
        /// Construct a previously instantiated Component attached to a GameObject present and active in a UnityScene
        /// and add it to the SceneObjects as a transient
        /// </summary>
        /// <typeparam name="T">Type of Component to get</typeparam>
        /// <param name="go">Name of GameObject holding the component</param>
        /// <param name="data">SceneObjectsData instance to add component to</param>
        /// <param name="name">name of the object</param>
        /// <returns>constructed component</returns>
        static public MonoBehaviour ConstructMonoBehaviour <T>(GameObject go, SceneObjectData data, string name)
            where T : class
        {
            var component = ConstructMonoBehaviour <T>(go);

            PushTransient <T>(data, name, component);
            return(component);
        }
Esempio n. 6
0
        /// <summary>
        /// Create an object of type T and insert it as singleton into the scene objects data
        /// </summary>
        /// <typeparam name="T">Type of object to create</typeparam>
        /// <param name="data">Instance of SceneObjectsData to insert to</param>
        /// <returns>constructed object</returns>
        static public T Create <T>(SceneObjectData data)
            where T : class
        {
            var obj = Create <T>();

            PushSingleton <T>(data, obj);
            return(obj);
        }
Esempio n. 7
0
        /// <summary>
        /// Create an object of type T with a custom constructor and insert it into singleton library
        /// </summary>
        /// <typeparam name="T">Type of object to create</typeparam>
        /// <param name="constructor">custom constructor to use</param>
        /// <param name="data">Instance of scene data</param>
        /// <returns>constructed object</returns>
        static public T Create <T>(Constructor constructor, SceneObjectData data)
            where T : class
        {
            var obj = Create <T>(constructor);

            PushSingleton <T>(data, obj);
            return(obj);
        }
Esempio n. 8
0
        /// <summary>
        /// Create an object of type T with a custom constructor and insert it into transients library
        /// </summary>
        /// <typeparam name="T">Type of object to create</typeparam>
        /// <param name="constructor">custom constructor to use</param>
        /// <param name="data">Instance of scene data</param>
        /// <param name="name">Name to use in transients library</param>
        /// <returns>constructed object</returns>
        static public T Create <T>(Constructor constructor, SceneObjectData data, string name)
            where T : class
        {
            var obj = Create <T>(constructor);

            PushTransient <T>(data, name, obj);
            return(obj);
        }
Esempio n. 9
0
        static private void PushTransient <T>(SceneObjectData data, string name, object obj)
            where T : class
        {
            CDebug.Assert(data == null, "SceneObjectsData passed to Create() was null.");
            CDebug.Assert(string.IsNullOrEmpty(name), "Name passed to Create() was empty or null");

            data.PushTransient(name, (T)obj);
        }
Esempio n. 10
0
        /// <summary>
        /// Construct a previously instantiated Component attached to a GameObject present and active in a UnityScene
        /// and add it to the SceneObjects as a singleton
        /// </summary>
        /// <typeparam name="T">Type of Component to get</typeparam>
        /// <param name="go">GameObject holding the component</param>
        /// <param name="constructor">constructor to run on the component</param>
        /// <param name="data">SceneObjectsData instance to add component to</param>
        /// <returns>constructed component</returns>
        static public MonoBehaviour ConstructMonoBehaviour <T>(GameObject go, SceneObjectData data)
            where T : class
        {
            var component = ConstructMonoBehaviour <T>(go);

            PushSingleton <T>(data, component);
            return(component);
        }
Esempio n. 11
0
    void AddGenericObject(SceneObjectData data, Vector2 pos)
    {
        GenericObject go = GetGenericObjectByName(data.sceneObjectName);
        SceneObject   newGenericObject = Instantiate(go);

        newGenericObject.data = data;
        newGenericObject.transform.SetParent(World.Instance.scenesManager.sceneActive.sceneObjects);
        newGenericObject.Init(data, pos);
        newGenericObject.transform.localEulerAngles = new Vector3(90 + 20, 0, 0);
    }
Esempio n. 12
0
 protected void AddToBuildedMap(SceneObjectData data)
 {
     if (data.Status == ESceneObjectStatus.Builded)
     {
         BuildData buildData = new BuildData();
         buildData.Rect.position = data.BuildData.Rect.position;
         buildData.Rotate        = data.BuildData.Rotate;
         BuildedInfoMap.Add(data.ObjectUid, buildData);
     }
 }
Esempio n. 13
0
        /// <summary>
        /// attach a new component of type T to the GameObject
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="go"></param>
        /// <param name="data"></param>
        /// <param name="name"></param>
        /// <returns></returns>
        static public MonoBehaviour AddComponent <T>(GameObject go, SceneObjectData data, string name)
            where T : class
        {
            CDebug.Assert(go == null, "AddComponent: GameObject was null.");

            var component = go.AddComponent(typeof(T).Name) as MonoBehaviour;

            component = Injector.PerformInjections(component);
            component = (MonoBehaviour)InvokeDefaultConstructor <T>(component);
            PushTransient <T>(data, name, component);
            return(component);
        }
Esempio n. 14
0
    public void AddGenericObjectToDrag(SceneObjectData data)
    {
        GenericObject go = GetGenericObjectByName(data.sceneObjectName);

        draggableSceneObject      = Instantiate(go);
        draggableSceneObject.data = data;
        draggableSceneObject.transform.SetParent(World.Instance.scenesManager.sceneActive.sceneObjects);
        draggableSceneObject.Init(data, Vector3.zero);
        draggableSceneObject.transform.localEulerAngles = new Vector3(90 + 20, 0, 0);
        draggableSceneObject.transform.localPosition    = new Vector3(1000, 0, 0);
        go.OnSetColliders(false);
    }
Esempio n. 15
0
 public void Init(SceneObjectData data, Vector2 pos)
 {
     this.data          = data;
     transform.position = new Vector3(pos.x, 0, pos.y);
     OnInit();
     orders = new List <int> ();
     foreach (SpriteRenderer sr in GetComponentsInChildren <SpriteRenderer>())
     {
         orders.Add(sr.sortingOrder);
     }
     ReorderInLayers();
 }
Esempio n. 16
0
    public void AddBuildInfo(BuildData buildData, ESceneObjectStatus status)
    {
        SceneObjectData data = new SceneObjectData();

        data.BuildData = buildData;
        data.ObjectUid = ++SceneUid;
        data.Status    = status;
        SceneObjectMap.Add(data.ObjectUid, data);

        buildData.BuildSceneUid = data.ObjectUid;
        DirtyList.Add(data.ObjectUid);
    }
Esempio n. 17
0
    void OnDrag(SceneObjectData sceneObjectData)
    {
        if (isDragging)
        {
            return;
        }
        image.enabled = true;
        string url = "sceneObjects/" + sceneObjectData.sceneObjectName;

        // print("drag: " + url);
        image.sprite = Resources.Load(url, typeof(Sprite)) as Sprite;
        Events.OnSetColliders(false);
        sceneObjectsManager.AddGenericObjectToDrag(sceneObjectData);
        this.sceneObjectData = sceneObjectData;
        isDragging           = true;
        SetActive(true);
    }
Esempio n. 18
0
    public void ResetEveryaditionalComponent(SceneObject so)
    {
        TimelineAnimation timelineAnimation = so.GetComponent <TimelineAnimation> ();
        SceneObjectData   sceneObjectData   = so.GetComponent <SceneObjectData> ();
        FullRotation      fullRotation      = so.GetComponent <FullRotation> ();

        if (timelineAnimation != null)
        {
            timelineAnimation.OnComponentDisposed();
        }
        if (sceneObjectData != null)
        {
            Destroy(sceneObjectData);
        }
        if (fullRotation != null)
        {
            fullRotation.OnComponentDisposed();
        }
    }
Esempio n. 19
0
        public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
        {
            var jsonObject = JObject.Load(reader);
//            var typeString = (string)jsonObject.Property(SceneObjectRecord.TYPE_PROPERTY_NAME);
//            var record = typeString.Match().To<SceneObjectRecord>()
//                .With(nameof(SceneObjectRecord)).Return(new SceneObjectRecord())
//                .With(nameof(EditableSceneObjectRecord)).Return(new EditableSceneObjectRecord())
//                .With(nameof(BayRecord)).Return(new BayRecord())
//                .Else(_ => { throw new JsonReaderException($"Can't parse SceneObjectRecord, unknown type: \"{typeString}\"."); })
//                .Result();

            var record = new SceneObjectData();

            using (var jsonReader = jsonObject.CreateReader())
            {
                serializer.Populate(jsonReader, record);
            }

            return(record);
        }
Esempio n. 20
0
        void Awake()
        {
            CDebug.DisplayMethod = CDebug.ConsoleLogMethod.Selected;
            //CDebug.LogThis(typeof(Injector));

            if (Instance != this && Instance != null)
            {
                Destroy(gameObject);
            }
            else
            {
                Instance  = this;
                _commands = new CommandQueue();

                // create framework manager objects
                _frameworkObjects = new SceneObjectData();
                _frameworkObjects.PushObjectAsSingleton(new SceneManager());

                Injector.BindTemplate("Framework_UseDiskAccess", _readWriteSettingsConfiguration);
                Injector.BindSingleton <EngineOptions>(Factory.Factory.Create <EngineOptions>(_frameworkObjects));

                // give App a getter.  Get options via:
                // Framework.App.Options.<Option>
                // Remember to apply options when necessary
                // true/false parameter tells App if it can use JSON to write and read default configurations from a HD.
                App = _frameworkObjects.PushObjectAsSingleton(Factory.Factory.Create <App>());

                _frameworkObjects.InitializeSceneObjects();

                Globals = new SceneObjectData();
                Globals.InitializeSceneObjects();

                // ProcessCommands() executes all commands in a co-routine
                StartCoroutine(ProcessCommands());

                DontDestroyOnLoad(gameObject);
            }

            // when Awake() is invoked we've loaded a new scene so we create the new view
            SceneManager.CreateSceneView();
        }
Esempio n. 21
0
    void Save()
    {
        GameObject[] allGameObject = GameObject.FindObjectsOfType <GameObject> ();
        SceneData    sceneData     = new SceneData();

        for (int i = 0; i < allGameObject.Length; ++i)
        {
            SceneObjectData sceneObjectData = new SceneObjectData();
            sceneObjectData.name = allGameObject[i].name;
            sceneObjectData.posX = allGameObject[i].transform.position.x;
            sceneObjectData.posY = allGameObject[i].transform.position.y;
            sceneObjectData.posZ = allGameObject[i].transform.position.z;
            sceneData.sceneObjectDatas.Add(sceneObjectData);
        }

        XmlSerializer serializer = new XmlSerializer(typeof(SceneData));
        FileStream    stream     = new FileStream(Application.dataPath + "/saveFile.xml", FileMode.Create);

        serializer.Serialize(stream, sceneData);
        stream.Close();
    }
Esempio n. 22
0
    void OnUIButtonClicked(UIButton _uiButton)
    {
        switch (_uiButton.type)
        {
        case UIButton.types.SCENEOBJECT_MENU:
            World.Instance.worldStates.Change(WorldStates.states.SCENE_EDITOR);
            SetActive(true);
            break;

        case UIButton.types.CHARACTER_EDITOR:
            World.Instance.worldStates.Change(WorldStates.states.CHARACTERS_EDITOR);
            SetActive(false);
            break;

        case UIButton.types.SCENEOBJECT:

            SceneObjectData data = new SceneObjectData();
            data.sceneObjectName = _uiButton.field.text;
            data.type            = selectedType;
            Events.OnDrag(data);
            print(data.sceneObjectName);
            break;
        }
    }
Esempio n. 23
0
 public virtual void Start()
 {
     SceneObjects = new SceneObjectData();
 }
Esempio n. 24
0
    public void AddComponentsToSceneObject(AreaSceneObjectData jsonData, GameObject so)
    {
        if (jsonData.soData.Count > 0)
        {
            SceneObjectDataGeneric data            = jsonData.soData [0];
            SceneObjectData        sceneObjectData = so.GetComponent <SceneObjectData> ();
            Bumper bumper = so.GetComponent <Bumper> ();

            if (data.bumperForce > 0)
            {
                if (bumper == null)
                {
                    bumper = so.gameObject.AddComponent <Bumper> ();
                }
                bumper.force = data.bumperForce;
            }
            if (data.size != Vector3.zero)
            {
                if (sceneObjectData == null)
                {
                    sceneObjectData = so.gameObject.AddComponent <SceneObjectData> ();
                }
                sceneObjectData.size = data.size;
            }
            if (data.random_pos_x != 0)
            {
                if (sceneObjectData == null)
                {
                    sceneObjectData = so.gameObject.AddComponent <SceneObjectData> ();
                }

                sceneObjectData.random_pos_x = data.random_pos_x;
            }
            if (data.minPayers != 0)
            {
                if (sceneObjectData == null)
                {
                    sceneObjectData = so.gameObject.AddComponent <SceneObjectData> ();
                }

                sceneObjectData.minPayers = data.minPayers;
            }
        }

        MaterialSwapper mat = so.GetComponent <MaterialSwapper>();

        if (mat != null && jsonData.mat.Count > 0)
        {
            MaterialChanger data = jsonData.mat[0];
            //if (mat == null)
            //    mat = so.gameObject.AddComponent<MaterialSwapper>();
            mat.Init(data.name);
        }

        FullRotation fullRotation = so.GetComponent <FullRotation> ();

        if (jsonData.fullRotationData.Count > 0)
        {
            FullRotationData data = jsonData.fullRotationData [0];

            if (fullRotation == null)
            {
                fullRotation = so.gameObject.AddComponent <FullRotation> ();
            }
            fullRotation.rotateX        = data.rotateX;
            fullRotation.rotateY        = data.rotateY;
            fullRotation.rotateZ        = data.rotateZ;
            fullRotation.speed          = data.speed;
            fullRotation.randomRotation = data.random;
        }
        else if (fullRotation != null)
        {
            fullRotation.OnComponentDisposed();
        }

        TimelineAnimation timelineAnimation = so.GetComponent <TimelineAnimation> ();

        if (jsonData.timelineAnimation.Count > 0)
        {
            TimelineAnimationData data = jsonData.timelineAnimation [0];
            if (timelineAnimation == null)
            {
                timelineAnimation = so.gameObject.AddComponent <TimelineAnimation> ();
            }
            timelineAnimation.timeLineData = data.timeLineData;
        }
        else if (timelineAnimation != null)
        {
            timelineAnimation.OnComponentDisposed();
        }

        if (jsonData.bossSettings.Count > 0)
        {
            BossSettingsData data         = jsonData.bossSettings [0];
            BossSettings     newcomponent = so.GetComponent <BossSettings> ();

            if (newcomponent == null)
            {
                newcomponent = so.gameObject.AddComponent <BossSettings> ();
            }

            newcomponent.bossModule           = data.bossModule;
            newcomponent.time_to_init_enemies = data.time_to_init_enemies;
            newcomponent.asset                 = data.asset;
            newcomponent.time_to_kill          = data.time_to_kill;
            newcomponent.distance_from_avatars = data.distance_from_avatars;
            newcomponent.bundle                = data.bundle;
        }
        if (jsonData.moveForward.Count > 0)
        {
            MoveForwardData data         = jsonData.moveForward [0];
            MoveForward     newcomponent = so.GetComponent <MoveForward> ();
            if (newcomponent == null)
            {
                newcomponent = so.gameObject.AddComponent <MoveForward> ();
            }
            newcomponent.speed           = data.speed;
            newcomponent.randomSpeedDiff = data.randomSpeedDiff;
            newcomponent.moveBackIn      = data.moveBackIn;
        }
    }
Esempio n. 25
0
    public void AddComponentsToJson(AreaSceneObjectData newSOdata, GameObject go)
    {
        FullRotation      fullRotation      = go.GetComponent <FullRotation> ();
        MaterialSwapper   mat               = go.GetComponent <MaterialSwapper>();
        TimelineAnimation timelineAnimation = go.GetComponent <TimelineAnimation> ();
        BossSettings      bossSettings      = go.GetComponent <BossSettings> ();
        MoveForward       moveForward       = go.GetComponent <MoveForward> ();
        Bumper            bumper            = go.GetComponent <Bumper> ();
        SceneObjectData   soData            = go.GetComponent <SceneObjectData> ();

        if (newSOdata.name == "wallSmall")
        {
            newSOdata.mat = new List <MaterialChanger>();
            MaterialChanger mc = new MaterialChanger();
            mc.name = go.GetComponent <MeshRenderer>().sharedMaterial.ToString().Split(" "[0])[0];
            newSOdata.mat.Add(mc);
        }

        if (soData != null)
        {
            newSOdata.soData = new List <SceneObjectDataGeneric> ();
            SceneObjectDataGeneric data = new SceneObjectDataGeneric();
            data.size         = soData.size;
            data.random_pos_x = soData.random_pos_x;
            data.minPayers    = soData.minPayers;
            data.minPayers    = soData.minPayers;
            newSOdata.soData.Add(data);
        }
        if (bumper != null)
        {
            newSOdata.soData = new List <SceneObjectDataGeneric> ();
            SceneObjectDataGeneric data = new SceneObjectDataGeneric();
            data.bumperForce = bumper.force;
            newSOdata.soData.Add(data);
        }
        if (fullRotation != null)
        {
            newSOdata.fullRotationData = new List <FullRotationData> ();
            FullRotationData data = new FullRotationData();
            data.rotateX = fullRotation.rotateX;
            data.rotateY = fullRotation.rotateY;
            data.rotateZ = fullRotation.rotateZ;
            data.speed   = fullRotation.speed;
            data.random  = fullRotation.randomRotation;
            newSOdata.fullRotationData.Add(data);
        }
        if (timelineAnimation != null)
        {
            newSOdata.timelineAnimation = new List <TimelineAnimationData> ();
            TimelineAnimationData data = new TimelineAnimationData();
            data.timeLineData = timelineAnimation.timeLineData;
            newSOdata.timelineAnimation.Add(data);
        }
        if (bossSettings != null)
        {
            newSOdata.bossSettings = new List <BossSettingsData> ();
            BossSettingsData data = new BossSettingsData();
            data.bossModule            = bossSettings.bossModule;
            data.asset                 = bossSettings.asset;
            data.time_to_init_enemies  = bossSettings.time_to_init_enemies;
            data.time_to_kill          = bossSettings.time_to_kill;
            data.distance_from_avatars = bossSettings.distance_from_avatars;
            data.bundle                = bossSettings.bundle;
            newSOdata.bossSettings.Add(data);
        }
        if (moveForward != null)
        {
            newSOdata.moveForward = new List <MoveForwardData> ();
            MoveForwardData data = new MoveForwardData();
            data.speed           = moveForward.speed;
            data.randomSpeedDiff = moveForward.randomSpeedDiff;
            data.moveBackIn      = moveForward.moveBackIn;
            newSOdata.moveForward.Add(data);
        }
    }
Esempio n. 26
0
        void Awake()
        {
            CDebug.DisplayMethod = CDebug.ConsoleLogMethod.Selected;

            if (Instance != this && Instance != null)
            {
                Destroy(gameObject);
            }
            else
            {
                Instance = this;
                _commands = new CommandQueue();

                // create framework manager objects
                _frameworkObjects = new SceneObjectData();
                _frameworkObjects.PushObjectAsSingleton(new SceneManager());
                _frameworkObjects.PushObjectAsSingleton(new App());

                Globals = new SceneObjectData();

                StartCoroutine(ProcessCommands());

                DontDestroyOnLoad(gameObject);
            }

            SceneManager.CreateSceneView();
        }
Esempio n. 27
0
 public static void Show(SceneObjectData data)
 {
     _image.sprite = data.Icon;
     _name.text    = data.Name;
     _panel.SetActive(true);
 }
Esempio n. 28
0
        void Awake()
        {
            CDebug.DisplayMethod = CDebug.ConsoleLogMethod.Selected;

            if (Instance != this && Instance != null)
            {
                Destroy(gameObject);
            }
            else
            {
                Instance = this;
                _commands = new CommandQueue();

                // create framework manager objects
                _frameworkObjects = new SceneObjectData();
                _frameworkObjects.PushObjectAsSingleton(new SceneManager());
                // give App a getter.  Get options via:
                // Framework.App.Options.<Option>
                // Remember to apply options when necessary
                App = _frameworkObjects.PushObjectAsSingleton(new App()) as App;

                Globals = new SceneObjectData();

                // ProcessCommands() executes all commands in a co-routine
                StartCoroutine(ProcessCommands());

                DontDestroyOnLoad(gameObject);
            }

            // when Awake() is invoked we've loaded a new scene so we create the new view
            SceneManager.CreateSceneView();
        }
Esempio n. 29
0
        public void add(GameObject go)
        {
            if (root.isLoadBySceneRootData)
            {
                return;
            }

            SceneObjectData sceneObjectData = new SceneObjectData();

            sceneObjectData.p = go.transform.position;
            sceneObjectData.s = go.transform.localScale;
            sceneObjectData.r = go.transform.rotation;
            sceneObjectData.gameObjectPath = GetPath(go.transform.name, go.transform);

#if UNITY_EDITOR
            //判断GameObject是否为一个Prefab的引用

            /*
             * if (PrefabUtility.GetPrefabType(go) == PrefabType.PrefabInstance)
             * {
             *  UnityEngine.Object parentObject = EditorUtility.GetPrefabParent(go);
             *  string assetPath = AssetDatabase.GetAssetPath(parentObject);
             *  sceneObjectData.prefabName = assetPath;
             *  GameObject prefabGo = null;
             *  root.prefabNameDic.TryGetValue(sceneObjectData.prefabName, out prefabGo);
             *  if (prefabGo == null)
             *  {
             *      root.prefabNameDic.Add(sceneObjectData.prefabName, go);
             *  }
             * }
             */
#endif

            list.Add(sceneObjectData);

            GameObject goNew = GameObject.Instantiate(go);

            Collider collider = goNew.GetComponentInChildren <Collider>();
            if (collider != null)
            {
                collider.enabled = false;
            }
            collider = goNew.GetComponent <Collider>();
            if (collider != null)
            {
                collider.enabled = false;
            }

            goNew.transform.parent     = goNode.transform;
            goNew.transform.position   = sceneObjectData.p;
            goNew.transform.localScale = sceneObjectData.s;
            goNew.transform.rotation   = sceneObjectData.r;

            Renderer[] rendererList    = go.GetComponentsInChildren <Renderer>();
            Renderer[] rendererListNew = goNew.GetComponentsInChildren <Renderer>();

            sceneObjectData.sceneObjectLMDataArr = new SceneObjectLMData[rendererList.Length];

            for (int i = 0; i < rendererList.Length; i++)
            {
                Renderer renderer    = rendererList[i];
                Renderer rendererNew = rendererListNew[i];
                rendererNew.lightmapIndex       = renderer.lightmapIndex;
                rendererNew.lightmapScaleOffset = renderer.lightmapScaleOffset;
                SceneObjectLMData sceneObjectLMData = new SceneObjectLMData();
                sceneObjectLMData.rendererIndex         = i;
                sceneObjectLMData.lightmapIndex         = renderer.lightmapIndex;
                sceneObjectLMData.lightmapScaleOffset   = renderer.lightmapScaleOffset;
                sceneObjectData.sceneObjectLMDataArr[i] = sceneObjectLMData;
            }
        }
Esempio n. 30
0
 static private void PushSingleton <T>(SceneObjectData data, object obj)
     where T : class
 {
     CDebug.Assert(data == null, "SceneObjectsData passed to Create() was null.");
     data.PushObjectAsSingleton((T)obj);
 }
Esempio n. 31
0
        /// <summary>
        /// attach a new component of type T to the GameObject of given name
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="goName"></param>
        /// <param name="constructor"></param>
        /// <param name="data"></param>
        /// <returns></returns>
        static public MonoBehaviour AddComponent <T>(string goName, Constructor constructor, SceneObjectData data)
            where T : class
        {
            var go = ResolveGameObject(goName);

            return(AddComponent <T>(go, constructor, data));
        }
Esempio n. 32
0
        /// <summary>
        /// attach a new component of type T to the GameObject
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="go"></param>
        /// <param name="constructor"></param>
        /// <param name="data"></param>
        /// <returns></returns>
        static public MonoBehaviour AddComponent <T>(GameObject go, Constructor constructor, SceneObjectData data)
            where T : class
        {
            CDebug.Assert(go == null, "AddComponent: GameObject was null.");

            var component = go.AddComponent(typeof(T).Name) as MonoBehaviour;

            component = Injector.PerformInjections(component);
            component = (MonoBehaviour)InvokeConstructor <T>(component, constructor);
            PushSingleton <T>(data, component);
            return(component);
        }
Esempio n. 33
0
        /// <summary>
        /// Construct a previously instantiated Component attached to a GameObject present and active in a UnityScene
        /// and add it to the SceneObjects as a singleton
        /// </summary>
        /// <typeparam name="T">Type of Component to get</typeparam>
        /// <param name="goName">Name of GameObject holding the component</param>
        /// <param name="constructor">constructor to run on the component</param>
        /// <param name="data">SceneObjectsData instance to add component to</param>
        /// <returns>constructed component</returns>
        static public MonoBehaviour ConstructMonoBehaviour <T>(string goName, Constructor constructor, SceneObjectData data)
            where T : class
        {
            var component = ConstructMonoBehaviour <T>(goName, constructor);

            PushSingleton <T>(data, component);
            return(component);
        }