internal override void SetXML(XmlElement xml, BaseClassIfc host, Dictionary <int, XmlElement> processed)
        {
            XmlElement placement = (mObjectPlacement != null ? ObjectPlacement.GetXML(xml.OwnerDocument, "ObjectPlacement", this, processed) : null);

            base.SetXML(xml, host, processed);
            if (placement != null)
            {
                xml.AppendChild(placement);
            }
            if (mRepresentation != null)
            {
                xml.AppendChild(mRepresentation.GetXML(xml.OwnerDocument, "Representation", this, processed));
            }

            XmlElement element = xml.OwnerDocument.CreateElement("ReferencedBy");

            foreach (IfcRelAssignsToProduct rap in mReferencedBy)
            {
                element.AppendChild(rap.GetXML(xml.OwnerDocument, "", this, processed));
            }
            if (element.ChildNodes.Count > 0)
            {
                xml.AppendChild(element);
            }
        }
        public override string GetStepParameters()
        {
            var parameters = new List <string>();

            parameters.Add(GlobalId != null ? GlobalId.ToStepValue() : "$");
            parameters.Add(OwnerHistory != null ? OwnerHistory.ToStepValue() : "$");
            parameters.Add(Name != null ? Name.ToStepValue() : "$");
            parameters.Add(Description != null ? Description.ToStepValue() : "$");
            parameters.Add(ObjectType != null ? ObjectType.ToStepValue() : "$");
            parameters.Add(ObjectPlacement != null ? ObjectPlacement.ToStepValue() : "$");
            parameters.Add(Representation != null ? Representation.ToStepValue() : "$");
            parameters.Add(Tag != null ? Tag.ToStepValue() : "$");
            parameters.Add(SteelGrade != null ? SteelGrade.ToStepValue() : "$");
            parameters.Add(MeshLength != null ? MeshLength.ToStepValue() : "$");
            parameters.Add(MeshWidth != null ? MeshWidth.ToStepValue() : "$");
            parameters.Add(LongitudinalBarNominalDiameter != null ? LongitudinalBarNominalDiameter.ToStepValue() : "$");
            parameters.Add(TransverseBarNominalDiameter != null ? TransverseBarNominalDiameter.ToStepValue() : "$");
            parameters.Add(LongitudinalBarCrossSectionArea != null ? LongitudinalBarCrossSectionArea.ToStepValue() : "$");
            parameters.Add(TransverseBarCrossSectionArea != null ? TransverseBarCrossSectionArea.ToStepValue() : "$");
            parameters.Add(LongitudinalBarSpacing != null ? LongitudinalBarSpacing.ToStepValue() : "$");
            parameters.Add(TransverseBarSpacing != null ? TransverseBarSpacing.ToStepValue() : "$");
            parameters.Add(PredefinedType.ToStepValue());

            return(string.Join(", ", parameters.ToArray()));
        }
    void Start()
    {
        world         = FindObjectOfType <World>() as World;
        terrainHolder = FindObjectOfType <TerrainPool>().transform;
        Mesh mesh = this.GetComponent <MeshFilter>().mesh;

        objectPlacement = FindObjectOfType <ObjectPlacement>();
        chunk           = this.GetComponent <Chunk>();

        Vector3 [] verts = mesh.vertices;

        for (int v = 0; v < verts.Length; v++)
        {
            noiseGenereation(verts, v);

            // The pure random function will not work on limitless or cheated terrain as the pos is not saved..
            // Hashtable or Disctionary MAybe? Or another perlin noise?
            if (verts[v].y > .4f && Random.Range(0, 100) <= world.treeDensity)
            {
                GenerateTree(verts, v);
            }

            if (verts[v].y > 0.2f && verts[v].y < 0.3f && Random.Range(0, 100) < world.rockDensity)
            {
                GenerateRock(verts, v);
            }
        }

        mesh.vertices = verts;
        mesh.RecalculateBounds();
        mesh.RecalculateNormals();

        this.gameObject.AddComponent <MeshCollider>();
        objectPlacement.AddToPlacementGrid(mesh, chunk, this.transform);
    }
Exemple #4
0
        public void Snap()
        {
            float offsetFromSurface = SourcePrefab.OffsetFromGridSurface;

            if (ObjectSnapping.Get().SnapSurfaceType != SnapSurfaceType.GridCell)
            {
                offsetFromSurface = SourcePrefab.OffsetFromObjectSurface;
            }

            if (AllShortcutCombos.Instance.PlaceGuideBehindSurfacePlane.IsActive())
            {
                offsetFromSurface *= -1.0f;
            }

            if (AllShortcutCombos.Instance.SnapCenterToCenter.IsActive())
            {
                ObjectSnapping.Get().SnapObjectHierarchyToCenterOfSnapSurface(gameObject, ObjectPlacement.Get().CenterProjectedGuidePivotPoint, ObjectPlacement.Get().ProjectedGuidePivotPoints, offsetFromSurface);
            }
            else
            {
                ObjectSnapping.Get().SnapObjectHierarchy(gameObject, ObjectPlacement.Get().ProjectedGuidePivotPoints, offsetFromSurface);
            }

            PersistentObjectPlacementGuideData.Get().LastUsedWorldPosition = _transform.position;
        }
        public static void SaveConfig(string fileName, Octave3DConfigSaveLoadSettings saveSettings)
        {
            if (string.IsNullOrEmpty(fileName))
            {
                return;
            }

            using (XmlTextWriter xmlWriter = new XmlTextWriter(fileName, Encoding.UTF8))
            {
                xmlWriter.WriteStartDocument();
                xmlWriter.WriteNewLine(0);
                xmlWriter.WriteStartElement(Octave3DConfigXMLInfo.RootNode);

                SaveSnapSettings(xmlWriter, saveSettings);
                SaveObjectSelectionSettings(xmlWriter, saveSettings);
                SaveObjectErasingSettings(xmlWriter, saveSettings);
                SaveMirrorLookAndFeel(ObjectPlacement.Get().MirrorRenderSettings, xmlWriter, saveSettings, true);
                SaveMirrorLookAndFeel(ObjectSelection.Get().MirrorRenderSettings, xmlWriter, saveSettings, false);
                SaveSnapLookAndFeel(xmlWriter, saveSettings);
                SaveObjectPlacementLookAndFeel(xmlWriter, saveSettings);
                SaveObjectSelectionLookAndFeel(xmlWriter, saveSettings);
                SaveObjectErasingLookAndFeel(xmlWriter, saveSettings);

                xmlWriter.WriteNewLine(0);
                xmlWriter.WriteEndElement();
                xmlWriter.WriteEndDocument();
            }
        }
    private void PlaceItem(GameObject place)
    {
        ObjectPlacement newPlace          = place.transform.gameObject.GetComponent <ObjectPlacement>();
        bool            itemHasBeenPlaced = false;

        foreach (objectProperties item in objectsGrabbed)
        {
            if (newPlace.PlaceObject(item.id))
            {
                Destroy(item.icon);
                objectsToRemove.Add(item);
                if (OnPlayerPlaceItem != null)
                {
                    OnPlayerPlaceItem();
                }

                itemHasBeenPlaced = true;
            }
        }

        if (itemHasBeenPlaced)
        {
            foreach (objectProperties item in objectsToRemove)
            {
                objectsGrabbed.Remove(item);
            }

            objectsToRemove.Clear();
        }
    }
Exemple #7
0
    // Update is called once per frame
    void Update()
    {
        float val = 1.0f / fillTime * Time.deltaTime;

        if (fillAmount + val < 1.0f)
        {
            fillAmount          += val;
            fillImage.fillAmount = fillAmount;
        }
        else
        {
            bool output = ObjectPlacement.insertNewBlock();
            if (output)
            {
                fillAmount      = 0;
                textToShow.text = "New Building";
            }
            else
            {
                fillAmount      = 1.0f;
                textToShow.text = "Docks are full";
            }
        }
        fillImage.fillAmount = fillAmount;
    }
        private void BindPlacement(ObjectPlacement placement, Helix.Element3D model)
        {
            IMultiValueConverter converter = EulerTransformConverter.Instance;
            var rotationPath = nameof(ObjectPlacement.Rotation);

            if (placement.PaletteKey == PaletteType.Decal)
            {
                converter    = QuaternionTransformConverter.Instance;
                rotationPath = nameof(ObjectPlacement.QRotation);
            }

            var binding = new MultiBinding {
                Converter = converter, Mode = BindingMode.TwoWay
            };

            binding.Bindings.Add(new Binding(nameof(ObjectPlacement.Position))
            {
                Mode = BindingMode.TwoWay
            });
            binding.Bindings.Add(new Binding(rotationPath)
            {
                Mode = BindingMode.TwoWay
            });
            binding.Bindings.Add(new Binding(nameof(ObjectPlacement.Scale))
            {
                Mode = BindingMode.TwoWay
            });

            model.DataContext = placement;
            BindingOperations.SetBinding(model, Helix.Element3D.TransformProperty, binding);
        }
        public void RefreshObject(ModelFactory factory, string paletteKey, ObjectPlacement placement, string fieldId)
        {
            var holder = PaletteHolders[paletteKey];
            var index  = holder.Definition.Placements.IndexOf(placement);

            if (index < 0)
            {
                return;
            }

            if (fieldId == FieldId.Variant)
            {
                (holder.Elements[index] as ObjectModel3D)?.SetVariant(placement.Variant);
            }
            else if (fieldId == FieldId.PaletteIndex)
            {
                ConfigurePlacement(factory, holder, index);

                var info = holder.GetInfoForIndex(index);
                info.TreeItem.Tag = info.Element;

                var listItem = scenario.Items.FirstOrDefault(i => i.Tag == info.Placement);
                if (listItem != null)
                {
                    listItem.Content = info.TreeItem.Header;
                }
            }
        }
 public static void ShowWindow()
 {
     EditorWindow.GetWindow(typeof(ObjectPlacement));
     SceneView.onSceneGUIDelegate += view =>
     {
         var e = Event.current;
         if (shortcutToggle && e != null && e.keyCode != KeyCode.None)
         {
             ObjectPlacement objectPlacement = ScriptableObject.CreateInstance <ObjectPlacement>();
             if (e.keyCode == KeyCode.Keypad0)
             {
                 objectPlacement.RoundAngle();
             }
             else if (e.keyCode == KeyCode.Keypad1)
             {
                 objectPlacement.SetSnap(0.125f);
             }
             else if (e.keyCode == KeyCode.Keypad2)
             {
                 objectPlacement.SetSnap(0.25f);
             }
             else if (e.keyCode == KeyCode.Keypad3)
             {
                 objectPlacement.SetSnap(0.5f);
             }
             else if (e.keyCode == KeyCode.Keypad4)
             {
                 objectPlacement.SetSnap(1.0f);
             }
         }
     };
 }
        private static void EnsureGuideUsesBeginTileConnectionPrefab()
        {
            ObjectPlacementPathTileConnectionSettings     tileConnectionSettings      = ObjectPlacement.Get().PathObjectPlacement.PathSettings.TileConnectionSettings;
            ObjectPlacementPathTileConnectionTypeSettings beginTileConnectionSettings = tileConnectionSettings.GetSettingsForTileConnectionType(ObjectPlacementPathTileConnectionType.Begin);

            if (CanRefreshGuideToUseBeginTileConnectionPrefab(beginTileConnectionSettings))
            {
                PrefabCategory categoryWhichContainsBeginPrefab = PrefabCategoryDatabase.Get().GetPrefabCategoryWhichContainsPrefab(beginTileConnectionSettings.Prefab);
                if (categoryWhichContainsBeginPrefab == null)
                {
                    return;
                }

                PrefabCategoryDatabase.Get().SetActivePrefabCategory(categoryWhichContainsBeginPrefab);
                categoryWhichContainsBeginPrefab.SetActivePrefab(beginTileConnectionSettings.Prefab);

                ObjectPlacement.Get().DestroyPlacementGuide();
                ObjectPlacementGuide.CreateFromActivePrefabIfNotExists();
            }

            // Note: When using tile connections, we will always use the original prefab scale
            if (ObjectPlacementGuide.ExistsInScene)
            {
                ObjectPlacementGuide.Instance.WorldScale = beginTileConnectionSettings.Prefab.InitialWorldScale;
            }
        }
Exemple #12
0
        protected override void RenderContent()
        {
            if (!ObjectPlacement.Get().UserWantsToPlaceTileConnections)
            {
                RenderExcludeCornersToggle();
            }
            if (!ObjectPlacement.Get().UserWantsToPlaceTileConnections)
            {
                RenderRandomizePrefabsInActiveCategoryToggle();
            }
            if (!ObjectPlacement.Get().UserWantsToPlaceTileConnections)
            {
                RenderRotateObjectsToFollowPathToggle();
            }
            RenderObjectMissChanceSlider();
            RenderOffsetAlongGrowDirectionField();
            if (!ObjectPlacement.Get().UserWantsToPlaceTileConnections)
            {
                _settings.PaddingSettings.View.Render();
            }

            EditorGUILayout.Separator();
            _settings.BorderSettings.View.Render();

            EditorGUILayout.Separator();
            _settings.HeightAdjustmentSettings.View.Render();
        }
 private void Start()
 {
     if (op == null)
     {
         op = ObjectPlacement.instance;
     }
     b.interactable = on;
 }
Exemple #14
0
 void InitialHandleObject(GameObject focusedObject)
 {
     handleObj       = focusedObject;
     handlePlacement = focusedObject.GetComponent <ObjectPlacement>();
     if (handlePlacement == null)
     {
         handlePlacement = focusedObject.GetComponentInParent <ObjectPlacement>();
     }
 }
Exemple #15
0
    // Start is called before the first frame update
    void Start()
    {
        if (!player)
        {
            player = Instantiate(playerPrefab);
        }


        DontDestroyOnLoad(player);
        DontDestroyOnLoad(forestSpawn.gameObject);
        DontDestroyOnLoad(houseSpawn.gameObject);
        uniquePlacement  = GetComponent <ObjectPlacement>();
        playerController = player.GetComponent <PlayerController>();
        playerController.OnPlayerPickUpLastItem += UnlockEntranceDoor;
        playerController.checklistGameObject     = playerCheckList;

        for (int i = 0; i < maxItemsNeeded; i++)
        {
            int random = Random.Range(0, allItems.Length);

            while (itemNumber.Contains(random))
            {
                random = Random.Range(0, allItems.Length);
            }
            itemNumber.Add(random);
        }

        itemsNeeded = new GameObject[maxItemsNeeded];
        playerController.checklistItems = new PlayerController.checklistItem[maxItemsNeeded];
        uniquePlacement.prefabs         = new ObjectPlacement.prefabInfo[itemsNeeded.Length];

        for (int i = 0; i < itemsNeeded.Length; i++)
        {
            GameObject newItem           = Instantiate(allItems[itemNumber[i]]);
            GameObject newIngredientText = Instantiate(checklistItemUIPrefab);
            ObjectCore newItemProperties = newItem.GetComponent <ObjectCore>();

            itemsNeeded[i] = newItem;
            newIngredientText.transform.SetParent(playerController.checklistGameObject.transform, false);
            playerController.checklistItems[i].item = newIngredientText;
            playerController.checklistItems[i].id   = newItemProperties.id;
            newIngredientText.name = "Ingredient #" + i + " Text";
            newIngredientText.GetComponent <Text>().text = "• " + newItemProperties.itemName;
            newItem.SetActive(true);
            newItem.SetActive(false);

            uniquePlacement.prefabs[i].id = newItemProperties.id;
        }

        RelocatePlayer();
        playerController.staffOfLighting.staffBar = staffBar;
        playerController.OnPlayerDeath           += Loss;
        playerController.OnPlayerWin += Win;
        levelLoader = GetComponent <LevelLoader>();
        //generator.OnGeneratorFinish += SpawnPlayer;
    }
        protected override void HandleRepaintEvent(Event e)
        {
            if (!CanEventBeHandled(e))
            {
                return;
            }
            base.HandleRepaintEvent(e);

            ObjectPlacement.Get().HandleRepaintEvent(e);
        }
        protected override void HandleKeyboardButtonUpEvent(Event e)
        {
            if (!CanEventBeHandled(e))
            {
                return;
            }
            base.HandleKeyboardButtonUpEvent(e);

            ObjectPlacement.Get().HandleKeyboardButtonUpEvent(e);
        }
        protected override void HandleMouseScrollWheelEvent(Event e)
        {
            if (!CanEventBeHandled(e))
            {
                return;
            }
            base.HandleMouseScrollWheelEvent(e);

            ObjectPlacement.Get().HandleMouseScrollWheelEvent(e);
        }
    // Use this for initialization
    void Start()
    {
        UnityARSessionNativeInterface.ARFrameUpdatedEvent += OnFrameUpdate;
        pathText = FindObjectOfType <InputField>();

        pathText.onEndEdit.AddListener(SetPath);

        m_TGOPlacement = GameObject.Find("TGO/default").GetComponent <ObjectPlacement>();
        //m_ESAPlacement = GameObject.Find("ESA_icon").GetComponent<ObjectPlacement>();
    }
        public ObjectPlacement InsertPlacement(int index, ScenarioModel scenario, string paletteKey)
        {
            var placement = new ObjectPlacement(scenario, paletteKey);

            Definition.Placements.Insert(index, placement);
            TreeItems.Insert(index, new TreeItemModel {
                Header = placement.GetDisplayName(), IsChecked = true, Tag = null
            });
            Elements.Insert(index, null);

            return(placement);
        }
Exemple #21
0
 //Event for buy menu buttons to add new blocks
 private static void buyMenuButtonClickEvent(int newBlockLevel)
 {
     if (PointGeneration.totalPoint >= newBlockLevel * staticMultiplier)
     {
         bool output = ObjectPlacement.placeBuyedBlock(newBlockLevel);
         if (output)
         {
             PointGeneration.totalPoint -= newBlockLevel * staticMultiplier;
             PointGeneration.immediateUpdate();
         }
     }
 }
    private void Awake()
    {
        alter        = FindObjectOfType <ObjectAlteration>();
        placement    = FindObjectOfType <ObjectPlacement>();
        planeManager = FindObjectOfType <ARPlaneManager>();
        play         = FindObjectOfType <Play>();

        placement.enabled = false;
        alter.enabled     = false;
        play.enabled      = false;

        Application.RequestUserAuthorization(UserAuthorization.WebCam);
    }
Exemple #23
0
        public static GameObject GetSurfaceObject()
        {
            ObjectPlacementSettings objectPlacementSettings = ObjectPlacementSettings.Get();

            if (objectPlacementSettings.ObjectPlacementMode == ObjectPlacementMode.DecorPaint)
            {
                return(ObjectPlacement.Get().DecorPaintObjectPlacement.DecorPaintSurfaceObject);
            }
            else
            {
                return(ObjectSnapping.Get().ObjectSnapSurfaceObject);
            }
        }
Exemple #24
0
        public void TestAppDomainMarshalling()
        {
            var domain = AppDomain.CreateDomain("TestCrossDomain", null, new AppDomainSetup
            {
                ApplicationBase = AppDomain.CurrentDomain.BaseDirectory
            });

            _array = Enumerable.Range(0, 100).Select(x => Guid.NewGuid()).ToArray();
            var placement = new ObjectPlacement <Guid[]>(ref _array);

            domain.SetData(nameof(_array), placement);
            domain.SetData(nameof(Guid), _array);
            domain.DoCallBack(AppDomainCallback);
        }
Exemple #25
0
        public override string GetStepParameters()
        {
            var parameters = new List <string>();

            parameters.Add(GlobalId != null ? GlobalId.ToStepValue() : "$");
            parameters.Add(OwnerHistory != null ? OwnerHistory.ToStepValue() : "$");
            parameters.Add(Name != null ? Name.ToStepValue() : "$");
            parameters.Add(Description != null ? Description.ToStepValue() : "$");
            parameters.Add(ObjectType != null ? ObjectType.ToStepValue() : "$");
            parameters.Add(ObjectPlacement != null ? ObjectPlacement.ToStepValue() : "$");
            parameters.Add(Representation != null ? Representation.ToStepValue() : "$");

            return(string.Join(", ", parameters.ToArray()));
        }
Exemple #26
0
 private void OnEditorUpdate()
 {
     if (!EditorApplication.isPlaying)
     {
         if (Octave3DWorldBuilder.ActiveInstance == null)
         {
             UndoEx.DestroyObjectImmediate(gameObject);
         }
         else
         if (!Selection.Contains(Octave3DWorldBuilder.ActiveInstance.gameObject))
         {
             ObjectPlacement.Get().DestroyPlacementGuide();
         }
     }
 }
Exemple #27
0
        public static void PerformRegistrationForObjectPlacementModule(ObjectPlacement objectPlacement)
        {
            if (objectPlacement != null)
            {
                MessageListenerDatabase listenerDatabase = MessageListenerDatabase.Instance;
                listenerDatabase.UnregisterListener(objectPlacement);

                listenerDatabase.RegisterListenerForMessage(MessageType.ObjectPlacementModeWasChanged, objectPlacement);
                listenerDatabase.RegisterListenerForMessage(MessageType.UndoRedoWasPerformed, objectPlacement);
                listenerDatabase.RegisterListenerForMessage(MessageType.InspectorGUIWasChanged, objectPlacement);
                listenerDatabase.RegisterListenerForMessage(MessageType.PrefabWasRemovedFromCategory, objectPlacement);
                listenerDatabase.RegisterListenerForMessage(MessageType.PrefabCategoryWasRemovedFromDatabase, objectPlacement);
                listenerDatabase.RegisterListenerForMessage(MessageType.ObjectHierarchyRootsWerePlacedInScene, objectPlacement);
                listenerDatabase.RegisterListenerForMessage(MessageType.ObjectPlacementGuideWasInstantiated, objectPlacement);
                listenerDatabase.RegisterListenerForMessage(MessageType.ToolWasReset, objectPlacement);
            }
        }
Exemple #28
0
        public override string GetStepParameters()
        {
            var parameters = new List <string>();

            parameters.Add(GlobalId != null ? GlobalId.ToStepValue() : "$");
            parameters.Add(OwnerHistory != null ? OwnerHistory.ToStepValue() : "$");
            parameters.Add(Name != null ? Name.ToStepValue() : "$");
            parameters.Add(Description != null ? Description.ToStepValue() : "$");
            parameters.Add(ObjectType != null ? ObjectType.ToStepValue() : "$");
            parameters.Add(ObjectPlacement != null ? ObjectPlacement.ToStepValue() : "$");
            parameters.Add(Representation != null ? Representation.ToStepValue() : "$");
            parameters.Add(AppliedLoad != null ? AppliedLoad.ToStepValue() : "$");
            parameters.Add(GlobalOrLocal.ToStepValue());
            parameters.Add(DestabilizingLoad != null ? DestabilizingLoad.ToStepValue() : "$");
            parameters.Add(ProjectedOrTrue.ToStepValue());
            parameters.Add(PredefinedType.ToStepValue());

            return(string.Join(", ", parameters.ToArray()));
        }
Exemple #29
0
        public override string GetStepParameters()
        {
            var parameters = new List <string>();

            parameters.Add(GlobalId != null ? GlobalId.ToStepValue() : "$");
            parameters.Add(OwnerHistory != null ? OwnerHistory.ToStepValue() : "$");
            parameters.Add(Name != null ? Name.ToStepValue() : "$");
            parameters.Add(Description != null ? Description.ToStepValue() : "$");
            parameters.Add(ObjectType != null ? ObjectType.ToStepValue() : "$");
            parameters.Add(ObjectPlacement != null ? ObjectPlacement.ToStepValue() : "$");
            parameters.Add(Representation != null ? Representation.ToStepValue() : "$");
            parameters.Add(LongName != null ? LongName.ToStepValue() : "$");
            parameters.Add(CompositionType.ToStepValue());
            parameters.Add(ElevationOfRefHeight != null ? ElevationOfRefHeight.ToStepValue() : "$");
            parameters.Add(ElevationOfTerrain != null ? ElevationOfTerrain.ToStepValue() : "$");
            parameters.Add(BuildingAddress != null ? BuildingAddress.ToStepValue() : "$");

            return(string.Join(", ", parameters.ToArray()));
        }
Exemple #30
0
        public override void Render()
        {
            if (ObjectPlacement.Get().IsPlacementLocked)
            {
                string helpMessage = "Object placement is currently locked. Press \'" + AllShortcutCombos.Instance.LockObjectPlacement.ToString() + "\' to toggle the lock state.";
                EditorGUILayout.HelpBox(helpMessage, UnityEditor.MessageType.Warning);
            }

            RenderXZGridRotationField();
            ObjectPlacement.Get().MirrorView.Render();
            Octave3DWorldBuilder.ActiveInstance.PlacementObjectGroupDatabase.View.Render();
            ObjectPlacementSettings.Get().View.Render();
            if (ObjectPlacementSettings.Get().ObjectPlacementMode == ObjectPlacementMode.DecorPaint)
            {
                RenderControlsForDecorPaintPlacementMode();
            }

            _objectPlacementLookAndFeelSettingsView.Render();
        }
 // Use this for initialization
 void Start()
 {
     objPlacement = FindObjectOfType<ObjectPlacement>() as ObjectPlacement;
 }
Exemple #32
0
 // Update is called once per frame
 void Update()
 {
     if (TowerManager.GetSelected() != null) {
         placer = TowerManager.selected.GetComponent (typeof(ObjectPlacement)) as ObjectPlacement;
     }
 }
Exemple #33
0
	// Use this for initialization
	void Start () {
		objectPlacement = GetComponent<ObjectPlacement>();
	
	}